The MC reconstruction will be aborted if the trigger.root file is not found
[u/mrichter/AliRoot.git] / STEER / STEER / AliReconstruction.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 // class for running the reconstruction                                      //
21 //                                                                           //
22 // Clusters and tracks are created for all detectors and all events by       //
23 // typing:                                                                   //
24 //                                                                           //
25 //   AliReconstruction rec;                                                  //
26 //   rec.Run();                                                              //
27 //                                                                           //
28 // The Run method returns kTRUE in case of successful execution.             //
29 //                                                                           //
30 // If the input to the reconstruction are not simulated digits but raw data, //
31 // this can be specified by an argument of the Run method or by the method   //
32 //                                                                           //
33 //   rec.SetInput("...");                                                    //
34 //                                                                           //
35 // The input formats and the corresponding argument are:                     //
36 // - DDL raw data files: directory name, ends with "/"                       //
37 // - raw data root file: root file name, extension ".root"                   //
38 // - raw data DATE file: DATE file name, any other non-empty string          //
39 // - MC root files     : empty string, default                               //
40 //                                                                           //
41 // By default all events are reconstructed. The reconstruction can be        //
42 // limited to a range of events by giving the index of the first and the     //
43 // last event as an argument to the Run method or by calling                 //
44 //                                                                           //
45 //   rec.SetEventRange(..., ...);                                            //
46 //                                                                           //
47 // The index -1 (default) can be used for the last event to indicate no      //
48 // upper limit of the event range.                                           //
49 //                                                                           //
50 // In case of raw-data reconstruction the user can modify the default        //
51 // number of events per digits/clusters/tracks file. In case the option      //
52 // is not used the number is set 1. In case the user provides 0, than        //
53 // the number of events is equal to the number of events inside the          //
54 // raw-data file (i.e. one digits/clusters/tracks file):                     //
55 //                                                                           //
56 //   rec.SetNumberOfEventsPerFile(...);                                      //
57 //                                                                           //
58 //                                                                           //
59 // The name of the galice file can be changed from the default               //
60 // "galice.root" by passing it as argument to the AliReconstruction          //
61 // constructor or by                                                         //
62 //                                                                           //
63 //   rec.SetGAliceFile("...");                                               //
64 //                                                                           //
65 // The local reconstruction can be switched on or off for individual         //
66 // detectors by                                                              //
67 //                                                                           //
68 //   rec.SetRunLocalReconstruction("...");                                   //
69 //                                                                           //
70 // The argument is a (case sensitive) string with the names of the           //
71 // detectors separated by a space. The special string "ALL" selects all      //
72 // available detectors. This is the default.                                 //
73 //                                                                           //
74 // The reconstruction of the primary vertex position can be switched off by  //
75 //                                                                           //
76 //   rec.SetRunVertexFinder(kFALSE);                                         //
77 //                                                                           //
78 // The tracking and the creation of ESD tracks can be switched on for        //
79 // selected detectors by                                                     //
80 //                                                                           //
81 //   rec.SetRunTracking("...");                                              //
82 //                                                                           //
83 // Uniform/nonuniform field tracking switches (default: uniform field)       //
84 //                                                                           //
85 //   rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
86 //                                                                           //
87 // The filling of additional ESD information can be steered by               //
88 //                                                                           //
89 //   rec.SetFillESD("...");                                                  //
90 //                                                                           //
91 // Again, for both methods the string specifies the list of detectors.       //
92 // The default is "ALL".                                                     //
93 //                                                                           //
94 // The call of the shortcut method                                           //
95 //                                                                           //
96 //   rec.SetRunReconstruction("...");                                        //
97 //                                                                           //
98 // is equivalent to calling SetRunLocalReconstruction, SetRunTracking and    //
99 // SetFillESD with the same detector selecting string as argument.           //
100 //                                                                           //
101 // The reconstruction requires digits or raw data as input. For the creation //
102 // of digits and raw data have a look at the class AliSimulation.            //
103 //                                                                           //
104 // The input data of a detector can be replaced by the corresponding HLT     //
105 // data by calling (usual detector string)                                   //
106 // SetUseHLTData("...");                                                     //
107 //                                                                           //
108 //                                                                           //
109 ///////////////////////////////////////////////////////////////////////////////
110
111 #include <TArrayD.h>
112 #include <TArrayF.h>
113 #include <TArrayS.h>
114 #include <TChain.h>
115 #include <TFile.h>
116 #include <TGeoGlobalMagField.h>
117 #include <TGeoManager.h>
118 #include <TList.h>
119 #include <TLorentzVector.h>
120 #include <TMap.h>
121 #include <TObjArray.h>
122 #include <TPRegexp.h>
123 #include <TParameter.h>
124 #include <TPluginManager.h>
125 #include <TProof.h>
126 #include <TProofOutputFile.h>
127 #include <TROOT.h>
128 #include <TSystem.h>
129 #include <THashTable.h>
130 #include <TGrid.h>
131 #include <TMessage.h>
132 #include <TUrl.h>
133 #include <TRandom.h>
134 #include <THashList.h>
135
136 #include "AliAlignObj.h"
137 #include "AliAnalysisManager.h"
138 #include "AliAnalysisDataContainer.h"
139 #include "AliCDBEntry.h"
140 #include "AliCDBManager.h"
141 #include "AliCDBStorage.h"
142 #include "AliCTPRawStream.h"
143 #include "AliCascadeVertexer.h"
144 #include "AliCentralTrigger.h"
145 #include "AliCodeTimer.h"
146 #include "AliDAQ.h"
147 #include "AliDetectorRecoParam.h"
148 #include "AliESDCaloCells.h"
149 #include "AliESDCaloCluster.h"
150 #include "AliESDEvent.h"
151 #include "AliESDMuonTrack.h"
152 #include "AliESDPmdTrack.h"
153 #include "AliESDTagCreator.h"
154 #include "AliESDVertex.h"
155 #include "AliESDcascade.h"
156 #include "AliESDfriend.h"
157 #include "AliESDkink.h"
158 #include "AliESDpid.h"
159 #include "AliESDtrack.h"
160 #include "AliESDtrack.h"
161 #include "AliEventInfo.h"
162 #include "AliGRPObject.h"
163 #include "AliGRPRecoParam.h"
164 #include "AliGenEventHeader.h"
165 #include "AliGeomManager.h"
166 #include "AliGlobalQADataMaker.h" 
167 #include "AliHeader.h"
168 #include "AliLog.h"
169 #include "AliMagF.h"
170 #include "AliMultiplicity.h"
171 #include "AliPID.h"
172 #include "AliPlaneEff.h"
173 #include "AliQAv1.h"
174 #include "AliQADataMakerRec.h" 
175 #include "AliQAManager.h"
176 #include "AliRawVEvent.h"
177 #include "AliRawEventHeaderBase.h"
178 #include "AliRawHLTManager.h"
179 #include "AliRawReaderDate.h"
180 #include "AliRawReaderFile.h"
181 #include "AliRawReaderRoot.h"
182 #include "AliRecoInputHandler.h"
183 #include "AliReconstruction.h"
184 #include "AliReconstructor.h"
185 #include "AliRun.h"
186 #include "AliRunInfo.h"
187 #include "AliRunLoader.h"
188 #include "AliSysInfo.h" // memory snapshots
189 #include "AliTrackPointArray.h"
190 #include "AliTracker.h"
191 #include "AliTriggerClass.h"
192 #include "AliTriggerCluster.h"
193 #include "AliTriggerIR.h"
194 #include "AliTriggerConfiguration.h"
195 #include "AliV0vertexer.h"
196 #include "AliVertexer.h"
197 #include "AliTrackleter.h"
198 #include "AliVertexerTracks.h"
199 #include "AliTriggerRunScalers.h"
200 #include "AliCTPTimeParams.h" 
201 #include "AliESDHLTDecision.h"
202 #include "AliTriggerInput.h"
203 #include "AliLHCData.h"
204 #include "ARVersion.h"
205 #include <RVersion.h>
206 #include <unistd.h>
207 #include <sys/resource.h>
208 ClassImp(AliReconstruction)
209
210 using std::endl;
211
212 //_____________________________________________________________________________
213 const char* AliReconstruction::fgkStopEvFName = "_stopEvent_";
214 const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE"
215 // #ifdef MFT_UPGRADE
216 //                                                                                   , "MFT"
217 // #endif 
218                                                                                   , "MFT"    // AU
219                                                                                   , "HLT"
220 };
221
222 //_____________________________________________________________________________
223 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
224   TSelector(),
225   fRunVertexFinder(kTRUE),
226   fRunVertexFinderTracks(kTRUE),
227   fRunMuonTracking(kFALSE),
228   fRunV0Finder(kTRUE),
229   fRunCascadeFinder(kTRUE),
230   fRunMultFinder(kTRUE),
231   fStopOnError(kTRUE),
232   fStopOnMissingTriggerFile(kTRUE),
233   fWriteAlignmentData(kFALSE),
234   fWriteESDfriend(kFALSE),
235   fFillTriggerESD(kTRUE),
236
237   fCleanESD(kTRUE),
238   fV0DCAmax(3.),
239   fV0CsPmin(0.),
240   fDmax(50.),
241   fZmax(50.),
242
243   fRunLocalReconstruction("ALL"),
244   fRunTracking("ALL"),
245   fFillESD("ALL"),
246   fDeleteRecPoints(""),
247   fDeleteDigits(""),
248   fLoadCDB(""),
249   fUseTrackingErrorsForAlignment(""),
250   fGAliceFileName(gAliceFilename),
251   fRawInput(""),
252   fESDOutput(""),
253   fProofOutputFileName(""),
254   fProofOutputLocation(""),
255   fProofOutputDataset(kFALSE),
256   fProofOutputArchive(""),
257   fEquipIdMap(""),
258   fFirstEvent(0),
259   fLastEvent(-1),
260   fNumberOfEventsPerFile((UInt_t)-1),
261   fFractionFriends(0.04),
262   fOptions(),
263   fLoadAlignFromCDB(kTRUE),
264   fLoadAlignData("ALL"),
265   fUseHLTData(),
266   fRunInfo(NULL),
267   fEventInfo(),
268   fRunScalers(NULL),
269   fCTPTimeParams(NULL),  
270   fCTPTimeAlign(NULL),  
271
272   fRunLoader(NULL),
273   fRawReader(NULL),
274   fParentRawReader(NULL),
275
276   fRecoParam(),
277
278   fSPDTrackleter(NULL),
279
280   fDiamondProfileSPD(NULL),
281   fDiamondProfile(NULL),
282   fDiamondProfileTPC(NULL),
283   fListOfCosmicTriggers(NULL),
284   
285   fGRPData(NULL),
286
287   fAlignObjArray(NULL),
288   fCDBUri(),
289   fQARefUri(),
290   fSpecCDBUri(), 
291   fInitCDBCalled(kFALSE),
292   fCDBSnapshotMode(kFALSE),
293   fSetRunNumberFromDataCalled(kFALSE),
294   fQADetectors("ALL"), 
295   fQATasks("ALL"), 
296   fRunQA(kTRUE),  
297   fRunGlobalQA(kTRUE),
298   fSameQACycle(kFALSE),
299   fInitQACalled(kFALSE), 
300   fWriteQAExpertData(kTRUE), 
301   fRunPlaneEff(kFALSE),
302
303   fesd(NULL),
304   fhltesd(NULL),
305   fesdf(NULL),
306   ffile(NULL),
307   ffileF(NULL),
308   ftree(NULL),
309   ftreeF(NULL),
310   fhlttree(NULL),
311   ftVertexer(NULL),
312   fIsNewRunLoader(kFALSE),
313   fRunAliEVE(kFALSE),
314   fChain(NULL),
315   fNall(0),
316   fNspecie(0),
317   fSspecie(0),
318   fNhighPt(0),
319   fShighPt(0),
320   fUpgradeModule(""),
321   fAnalysisMacro(),
322   fAnalysis(0),
323   fRecoHandler(0),
324   fDeclTriggerClasses(""),
325   fStopped(kFALSE),
326   fMaxRSS(0),
327   fMaxVMEM(0)
328 {
329 // create reconstruction object with default parameters
330   gGeoManager = NULL;
331   
332   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
333     fReconstructor[iDet] = NULL;
334     fUpgradeMask[iDet]=kFALSE;
335     fLoader[iDet] = NULL;
336     fTracker[iDet] = NULL;
337   }
338   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
339     fQACycles[iDet] = 999999 ;
340     fQAWriteExpert[iDet] = kFALSE ; 
341   }
342   fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
343
344   AliPID pid;
345 }
346
347 //_____________________________________________________________________________
348 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
349   TSelector(),
350   fRunVertexFinder(rec.fRunVertexFinder),
351   fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
352   fRunMuonTracking(rec.fRunMuonTracking),
353   fRunV0Finder(rec.fRunV0Finder),
354   fRunCascadeFinder(rec.fRunCascadeFinder),
355   fRunMultFinder(rec.fRunMultFinder),
356   fStopOnError(rec.fStopOnError),
357   fStopOnMissingTriggerFile(rec.fStopOnMissingTriggerFile),
358   fWriteAlignmentData(rec.fWriteAlignmentData),
359   fWriteESDfriend(rec.fWriteESDfriend),
360   fFillTriggerESD(rec.fFillTriggerESD),
361
362   fCleanESD(rec.fCleanESD),
363   fV0DCAmax(rec.fV0DCAmax),
364   fV0CsPmin(rec.fV0CsPmin),
365   fDmax(rec.fDmax),
366   fZmax(rec.fZmax),
367
368   fRunLocalReconstruction(rec.fRunLocalReconstruction),
369   fRunTracking(rec.fRunTracking),
370   fFillESD(rec.fFillESD),
371   fDeleteRecPoints(""),
372   fDeleteDigits(""),
373   fLoadCDB(rec.fLoadCDB),
374   fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
375   fGAliceFileName(rec.fGAliceFileName),
376   fRawInput(rec.fRawInput),
377   fESDOutput(rec.fESDOutput),
378   fProofOutputFileName(rec.fProofOutputFileName),
379   fProofOutputLocation(rec.fProofOutputLocation),
380   fProofOutputDataset(rec.fProofOutputDataset),
381   fProofOutputArchive(rec.fProofOutputArchive),
382   fEquipIdMap(rec.fEquipIdMap),
383   fFirstEvent(rec.fFirstEvent),
384   fLastEvent(rec.fLastEvent),
385   fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
386   fFractionFriends(rec.fFractionFriends),
387   fOptions(),
388   fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
389   fLoadAlignData(rec.fLoadAlignData),
390   fUseHLTData(rec.fUseHLTData),
391   fRunInfo(NULL),
392   fEventInfo(),
393   fRunScalers(NULL),
394   fCTPTimeParams(NULL),
395   fCTPTimeAlign(NULL),
396
397   fRunLoader(NULL),
398   fRawReader(NULL),
399   fParentRawReader(NULL),
400
401   fRecoParam(rec.fRecoParam),
402
403   fSPDTrackleter(NULL),
404
405   fDiamondProfileSPD(rec.fDiamondProfileSPD),
406   fDiamondProfile(rec.fDiamondProfile),
407   fDiamondProfileTPC(rec.fDiamondProfileTPC),
408   fListOfCosmicTriggers(NULL),
409   
410   fGRPData(NULL),
411
412   fAlignObjArray(rec.fAlignObjArray),
413   fCDBUri(rec.fCDBUri),
414   fQARefUri(rec.fQARefUri),
415   fSpecCDBUri(), 
416   fInitCDBCalled(rec.fInitCDBCalled),
417   fCDBSnapshotMode(rec.fCDBSnapshotMode),
418   fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
419   fQADetectors(rec.fQADetectors), 
420   fQATasks(rec.fQATasks), 
421   fRunQA(rec.fRunQA),  
422   fRunGlobalQA(rec.fRunGlobalQA),
423   fSameQACycle(rec.fSameQACycle),
424   fInitQACalled(rec.fInitQACalled),
425   fWriteQAExpertData(rec.fWriteQAExpertData), 
426   fRunPlaneEff(rec.fRunPlaneEff),
427
428   fesd(NULL),
429   fhltesd(NULL),
430   fesdf(NULL),
431   ffile(NULL),
432   ffileF(NULL),
433   ftree(NULL),
434   ftreeF(NULL),
435   fhlttree(NULL),
436   ftVertexer(NULL),
437   fIsNewRunLoader(rec.fIsNewRunLoader),
438   fRunAliEVE(kFALSE),
439   fChain(NULL),
440   fNall(0),
441   fNspecie(0),
442   fSspecie(0),
443   fNhighPt(0),
444   fShighPt(0),
445   fUpgradeModule(""),
446   fAnalysisMacro(rec.fAnalysisMacro),
447   fAnalysis(0),
448   fRecoHandler(0),
449   fDeclTriggerClasses(rec.fDeclTriggerClasses),
450   fStopped(kFALSE),
451   fMaxRSS(0),
452   fMaxVMEM(0)
453 {
454 // copy constructor
455
456   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
457     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
458   }
459   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
460     fReconstructor[iDet] = NULL;
461     fUpgradeMask[iDet] = kFALSE;
462     fLoader[iDet] = NULL;
463     fTracker[iDet] = NULL;
464   }  
465   
466   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
467     fQACycles[iDet] = rec.fQACycles[iDet];
468     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ; 
469   }
470
471   for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
472     if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
473   }
474
475   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
476
477 }
478
479 //_____________________________________________________________________________
480 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
481 {
482 // assignment operator
483 // Used in PROOF mode
484 // Be very careful while modifing it!
485 // Simple rules to follow:
486 // for persistent data members - use their assignment operators
487 // for non-persistent ones - do nothing or take the default values from constructor
488 // TSelector members should not be touched
489   if(&rec == this) return *this;
490
491   fRunVertexFinder       = rec.fRunVertexFinder;
492   fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
493   fRunMuonTracking       = rec.fRunMuonTracking;
494   fRunV0Finder           = rec.fRunV0Finder;
495   fRunCascadeFinder      = rec.fRunCascadeFinder;
496   fRunMultFinder         = rec.fRunMultFinder;
497   fStopOnError           = rec.fStopOnError;
498   fStopOnMissingTriggerFile = rec.fStopOnMissingTriggerFile;
499   fWriteAlignmentData    = rec.fWriteAlignmentData;
500   fWriteESDfriend        = rec.fWriteESDfriend;
501   fFillTriggerESD        = rec.fFillTriggerESD;
502
503   fCleanESD  = rec.fCleanESD;
504   fV0DCAmax  = rec.fV0DCAmax;
505   fV0CsPmin  = rec.fV0CsPmin;
506   fDmax      = rec.fDmax;
507   fZmax      = rec.fZmax;
508
509   fRunLocalReconstruction        = rec.fRunLocalReconstruction;
510   fRunTracking                   = rec.fRunTracking;
511   fFillESD                       = rec.fFillESD;
512   fDeleteRecPoints               = rec.fDeleteRecPoints;
513   fDeleteDigits                  = rec.fDeleteDigits;
514   fLoadCDB                       = rec.fLoadCDB;
515   fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
516   fGAliceFileName                = rec.fGAliceFileName;
517   fRawInput                      = rec.fRawInput;
518   fESDOutput                     = rec.fESDOutput;
519   fProofOutputFileName           = rec.fProofOutputFileName;
520   fProofOutputLocation           = rec.fProofOutputLocation;
521   fProofOutputDataset            = rec.fProofOutputDataset;
522   fProofOutputArchive            = rec.fProofOutputArchive;
523   fEquipIdMap                    = rec.fEquipIdMap;
524   fFirstEvent                    = rec.fFirstEvent;
525   fLastEvent                     = rec.fLastEvent;
526   fNumberOfEventsPerFile         = rec.fNumberOfEventsPerFile;
527   fFractionFriends               = rec.fFractionFriends;
528
529   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
530     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
531   }
532
533   fLoadAlignFromCDB              = rec.fLoadAlignFromCDB;
534   fLoadAlignData                 = rec.fLoadAlignData;
535   fUseHLTData                    = rec.fUseHLTData;
536
537   delete fRunInfo; fRunInfo = NULL;
538   if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
539
540   fEventInfo                     = rec.fEventInfo;
541
542   delete fRunScalers; fRunScalers = NULL;
543   if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers); 
544
545   delete fCTPTimeParams; fCTPTimeParams = NULL;
546   if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
547   delete fCTPTimeAlign; fCTPTimeAlign = NULL;
548   if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
549
550   fRunLoader       = NULL;
551   fRawReader       = NULL;
552   fParentRawReader = NULL;
553
554   fRecoParam = rec.fRecoParam;
555
556   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
557     fUpgradeMask[iDet] = kFALSE;
558     delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
559     delete fLoader[iDet]; fLoader[iDet] = NULL;
560     delete fTracker[iDet]; fTracker[iDet] = NULL;
561   }
562   
563   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
564     fQACycles[iDet] = rec.fQACycles[iDet];
565     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
566   } 
567
568   delete fSPDTrackleter; fSPDTrackleter = NULL;
569     
570   delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
571   if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
572   delete fDiamondProfile; fDiamondProfile = NULL;
573   if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
574   delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
575   if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
576
577   delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
578   if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
579
580   delete fGRPData; fGRPData = NULL;
581   //  if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
582   if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
583
584   delete fAlignObjArray; fAlignObjArray = NULL;
585
586   fCDBUri        = "";
587   fQARefUri      = rec.fQARefUri;
588   fSpecCDBUri.Delete();
589   fInitCDBCalled               = rec.fInitCDBCalled;
590   fCDBSnapshotMode             = rec.fCDBSnapshotMode;
591   fSetRunNumberFromDataCalled  = rec.fSetRunNumberFromDataCalled;
592   fQADetectors                 = rec.fQADetectors;
593   fQATasks                     = rec.fQATasks; 
594   fRunQA                       = rec.fRunQA;  
595   fRunGlobalQA                 = rec.fRunGlobalQA;
596   fSameQACycle                 = rec.fSameQACycle;
597   fInitQACalled                = rec.fInitQACalled;
598   fWriteQAExpertData           = rec.fWriteQAExpertData;
599   fRunPlaneEff                 = rec.fRunPlaneEff;
600   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
601   fesd     = NULL;
602   fhltesd  = NULL;
603   fesdf    = NULL;
604   ffile    = NULL;
605   ffileF   = NULL;
606   ftree    = NULL;
607   ftreeF   = NULL;
608   fhlttree = NULL;
609   ftVertexer = NULL;
610   fIsNewRunLoader = rec.fIsNewRunLoader;
611   fRunAliEVE = kFALSE;
612   fChain = NULL;
613   fNall = 0;
614   fNspecie = 0;
615   fSspecie = 0;
616   fNhighPt = 0;
617   fShighPt = 0;
618   fUpgradeModule="";
619   fAnalysisMacro = rec.fAnalysisMacro;
620   fAnalysis = 0;
621   fRecoHandler = 0;
622   fDeclTriggerClasses = rec.fDeclTriggerClasses;
623
624   return *this;
625 }
626
627 //_____________________________________________________________________________
628 AliReconstruction::~AliReconstruction()
629 {
630 // clean up
631
632   CleanUp();
633   if (fListOfCosmicTriggers) {
634     fListOfCosmicTriggers->Delete();
635     delete fListOfCosmicTriggers;
636   }
637   delete fGRPData;
638   delete fRunScalers;
639   delete fCTPTimeParams;
640   delete fCTPTimeAlign;
641   fOptions.Delete();
642   if (fAlignObjArray) {
643     fAlignObjArray->Delete();
644     delete fAlignObjArray;
645   }
646   fSpecCDBUri.Delete();
647
648   AliCodeTimer::Instance()->Print();
649 }
650
651 //_____________________________________________________________________________
652 void AliReconstruction::InitQA()
653 {
654   //Initialize the QA and start of cycle 
655   AliCodeTimerAuto("",0);
656   
657   if (fInitQACalled) return;
658   fInitQACalled = kTRUE;
659   
660   if (fGRPData) AliQADataMaker::SetCloningRequest( fGRPData->GetQATrigClasses(), fGRPData->GetQACloningRequest());
661
662
663   AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ; 
664   qam->SetSaveData(kTRUE); 
665   qam->SetCycleLength(AliQAv1::kITS, 5) ; 
666   if (fWriteQAExpertData)
667     qam->SetWriteExpert() ; 
668  
669   if (qam->IsDefaultStorageSet()) {
670     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
671     AliWarning("Default QA reference storage has been already set !");
672     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
673     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
674     fQARefUri = qam->GetDefaultStorage()->GetURI();
675   } else {
676     if (fQARefUri.Length() > 0) {
677         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
678         AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
679         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
680       } else {
681         fQARefUri="local://$ALICE_ROOT/QAref";
682         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
683         AliWarning("Default QA refeference storage not yet set !!!!");
684         AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
685         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
686                 
687       }
688     qam->SetDefaultStorage(fQARefUri);
689   }
690   
691   if (fRunQA) {
692   qam->SetActiveDetectors(fQADetectors) ; 
693   for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
694     qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;  
695     qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
696   }
697   if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
698     fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
699   qam->SetTasks(fQATasks) ; 
700   qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ; 
701   }
702   if (fRunGlobalQA) {
703     Bool_t sameCycle = kFALSE ;
704     AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
705     AliInfo(Form("Initializing the global QA data maker"));
706     if (IsInTasks(AliQAv1::kRECPOINTS)) {
707       qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
708       TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
709       AliTracker::SetResidualsArray(arr);
710       sameCycle = kTRUE ; 
711     }
712     if (IsInTasks(AliQAv1::kESDS)) {
713       qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
714       qadm->Init(AliQAv1::kESDS);
715     }
716   }
717     AliSysInfo::AddStamp("InitQA") ; 
718 }
719
720 //_____________________________________________________________________________
721 void AliReconstruction::MergeQA(const char *fileName)
722 {
723   //Initialize the QA and start of cycle 
724   AliCodeTimerAuto("",0) ;
725   AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ; 
726   AliSysInfo::AddStamp("MergeQA") ; 
727 }
728   
729 //_____________________________________________________________________________
730 void AliReconstruction::InitCDB()
731 {
732 // activate a default CDB storage
733 // First check if we have any CDB storage set, because it is used 
734 // to retrieve the calibration and alignment constants
735   AliCodeTimerAuto("",0);
736
737   if (fInitCDBCalled) return;
738   fInitCDBCalled = kTRUE;
739
740   AliCDBManager* man = AliCDBManager::Instance();
741   if (man->IsDefaultStorageSet())
742   {
743     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
744     AliWarning("Default CDB storage has been already set !");
745     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
746     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
747     fCDBUri = man->GetDefaultStorage()->GetURI();
748   }
749   else {
750     if (fCDBUri.Length() > 0) 
751     {
752         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
753         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
754         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
755         man->SetDefaultStorage(fCDBUri);
756     } 
757     else if (!man->GetRaw()){
758         fCDBUri="local://$ALICE_ROOT/OCDB";
759         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
760         AliWarning("Default CDB storage not yet set !!!!");
761         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
762         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
763         man->SetDefaultStorage(fCDBUri);
764     }
765     else {    
766         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
767         AliWarning("Default storage will be set after setting the Run Number!!!");
768         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");                    
769     }
770   }
771
772   // Now activate the detector specific CDB storage locations
773   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
774     TObject* obj = fSpecCDBUri[i];
775     if (!obj) continue;
776     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
777     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
778     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
779     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
780   }
781   AliSysInfo::AddStamp("InitCDB");
782 }
783
784 //_____________________________________________________________________________
785 void AliReconstruction::SetCDBSnapshotMode(const char* snapshotFileName) {
786     fCDBSnapshotMode = kTRUE;
787     AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName);
788 }
789
790 //_____________________________________________________________________________
791 void AliReconstruction::SetDefaultStorage(const char* uri) {
792 // Store the desired default CDB storage location
793 // Activate it later within the Run() method
794
795   fCDBUri = uri;
796
797 }
798
799 //_____________________________________________________________________________
800 void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
801   // Store the desired default CDB storage location
802   // Activate it later within the Run() method
803   
804   fQARefUri = uri;
805   AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
806   
807 }
808 //_____________________________________________________________________________
809 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
810 // Store a detector-specific CDB storage location
811 // Activate it later within the Run() method
812
813   AliCDBPath aPath(calibType);
814   if(!aPath.IsValid()){
815         // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
816         for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
817                 if(!strcmp(calibType, fgkDetectorName[iDet])) {
818                         aPath.SetPath(Form("%s/*", calibType));
819                         AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
820                         break;
821                 }
822         }
823         if(!aPath.IsValid()){
824                 AliError(Form("Not a valid path or detector: %s", calibType));
825                 return;
826         }
827   }
828
829 //  // check that calibType refers to a "valid" detector name
830 //  Bool_t isDetector = kFALSE;
831 //  for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
832 //    TString detName = fgkDetectorName[iDet];
833 //    if(aPath.GetLevel0() == detName) {
834 //      isDetector = kTRUE;
835 //      break;
836 //    }
837 //  }
838 //
839 //  if(!isDetector) {
840 //      AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
841 //      return;
842 //  }
843
844   TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
845   if (obj) fSpecCDBUri.Remove(obj);
846   fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
847
848 }
849
850 //_____________________________________________________________________________
851 Bool_t AliReconstruction::SetRunNumberFromData()
852 {
853   // The method is called in Run() in order
854   // to set a correct run number.
855   // In case of raw data reconstruction the
856   // run number is taken from the raw data header
857
858   if (fSetRunNumberFromDataCalled) return kTRUE;
859   fSetRunNumberFromDataCalled = kTRUE;
860   
861   AliCDBManager* man = AliCDBManager::Instance();
862  
863   if(fRawReader) {
864     if(fRawReader->NextEvent()) {
865       if(man->GetRun() > 0) {
866         AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
867       } 
868       man->SetRun(fRawReader->GetRunNumber());
869       GetEventInfo();
870       fRawReader->RewindEvents();
871     }
872     else {
873       if(man->GetRun() > 0) {
874         AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
875       }
876       else {
877         AliWarning("Neither raw events nor settings in AliCDBManager are found !");
878         return kFALSE;
879       }
880     }
881   }
882   else {
883     AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
884     if (!rl) {
885       AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
886       return kFALSE;
887     }
888     else {
889       rl->LoadHeader();
890       // read run number from gAlice
891       if(rl->GetHeader()) {
892         man->SetRun(rl->GetHeader()->GetRun());
893         rl->UnloadHeader();
894         delete rl;
895       }
896       else {
897         AliError("Neither run-loader header nor RawReader objects are found !");
898         delete rl;
899         return kFALSE;
900       }
901     }
902   }
903
904   man->Print();  
905   
906   return kTRUE;
907 }
908
909 //_____________________________________________________________________________
910 void AliReconstruction::SetCDBLock() {
911   // Set CDB lock: from now on it is forbidden to reset the run number
912   // or the default storage or to activate any further storage!
913   
914   AliCDBManager::Instance()->SetLock(1);
915 }
916
917 //_____________________________________________________________________________
918 void AliReconstruction::MatchUpgradeDetector() {
919   // Translates detector name in a boolean.
920   // The boolean is used in GetReconstructor to load the 
921   // upgrade reconstructor instead of the standard one.
922    for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
923     if(fUpgradeModule.Contains(fgkDetectorName[iDet])) fUpgradeMask[iDet]=kTRUE;
924    }
925 }
926 //_____________________________________________________________________________
927 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
928 {
929   // Read the alignment objects from CDB.
930   // Each detector is supposed to have the
931   // alignment objects in DET/Align/Data CDB path.
932   // All the detector objects are then collected,
933   // sorted by geometry level (starting from ALIC) and
934   // then applied to the TGeo geometry.
935   // Finally an overlaps check is performed.
936
937   // Load alignment data from CDB and fill fAlignObjArray 
938   if(fLoadAlignFromCDB){
939         
940     TString detStr = detectors;
941     TString loadAlObjsListOfDets = "";
942     
943     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
944       if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
945       if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
946       
947       if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
948       {
949         loadAlObjsListOfDets += fgkDetectorName[iDet];
950         loadAlObjsListOfDets += " ";
951       }
952     } // end loop over detectors
953     
954     if(AliGeomManager::GetNalignable("GRP") != 0)
955       loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
956     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
957   }else{
958     // Check if the array with alignment objects was
959     // provided by the user. If yes, apply the objects
960     // to the present TGeo geometry
961     if (fAlignObjArray) {
962       if (gGeoManager && gGeoManager->IsClosed()) {
963         if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
964           AliError("The misalignment of one or more volumes failed!"
965                    "Compare the list of simulated detectors and the list of detector alignment data!");
966           return kFALSE;
967         }
968       }
969       else {
970         AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
971         return kFALSE;
972       }
973     }
974   }
975   
976   if (fAlignObjArray) {
977     fAlignObjArray->Delete();
978     delete fAlignObjArray; fAlignObjArray=NULL;
979   }
980
981   return kTRUE;
982 }
983
984 //_____________________________________________________________________________
985 void AliReconstruction::SetGAliceFile(const char* fileName)
986 {
987 // set the name of the galice file
988
989   fGAliceFileName = fileName;
990 }
991
992 //_____________________________________________________________________________
993 void AliReconstruction::SetInput(const char* input) 
994 {
995   // In case the input string starts with 'mem://', we run in an online mode
996   // and AliRawReaderDateOnline object is created. In all other cases a raw-data
997   // file is assumed. One can give as an input:
998   // mem://: - events taken from DAQ monitoring libs online
999   //  or
1000   // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
1001   if (input) fRawInput = input;
1002 }
1003
1004 //_____________________________________________________________________________
1005 void AliReconstruction::SetOutput(const char* output) 
1006 {
1007   // Set the output ESD filename
1008   // 'output' is a normalt ROOT url
1009   // The method is used in case of raw-data reco with PROOF
1010   if (output) fESDOutput = output;
1011 }
1012
1013 //_____________________________________________________________________________
1014 void AliReconstruction::SetOption(const char* detector, const char* option)
1015 {
1016 // set options for the reconstruction of a detector
1017
1018   TObject* obj = fOptions.FindObject(detector);
1019   if (obj) fOptions.Remove(obj);
1020   fOptions.Add(new TNamed(detector, option));
1021 }
1022
1023 //_____________________________________________________________________________
1024 void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
1025 {
1026   // Set custom reconstruction parameters for a given detector
1027   // Single set of parameters for all the events
1028
1029   // First check if the reco-params are global
1030   if(!strcmp(detector, "GRP")) {
1031     par->SetAsDefault();
1032     fRecoParam.AddDetRecoParam(kNDetectors,par);
1033     return;
1034   }
1035
1036   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1037     if(!strcmp(detector, fgkDetectorName[iDet])) {
1038       par->SetAsDefault();
1039       fRecoParam.AddDetRecoParam(iDet,par);
1040       break;
1041     }
1042   }
1043
1044 }
1045
1046 //_____________________________________________________________________________
1047 Bool_t AliReconstruction::InitGRP() {
1048   //------------------------------------
1049   // Initialization of the GRP entry 
1050   //------------------------------------
1051   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
1052
1053   if (entry) {
1054
1055     TMap* m = dynamic_cast<TMap*>(entry->GetObject());  // old GRP entry
1056
1057     if (m) {
1058        AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1059        m->Print();
1060        fGRPData = new AliGRPObject();
1061        fGRPData->ReadValuesFromMap(m);
1062     }
1063
1064     else {
1065        AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1066        fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject());  // new GRP entry
1067        entry->SetOwner(0);
1068     }
1069
1070     //    FIX ME: The unloading of GRP entry is temporarily disabled
1071     //    because ZDC and VZERO are using it in order to initialize
1072     //    their reconstructor objects. In the future one has to think
1073     //    of propagating AliRunInfo to the reconstructors.
1074     //    AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
1075   }
1076
1077   if (!fGRPData) {
1078      AliError("No GRP entry found in OCDB!");
1079      return kFALSE;
1080   }
1081
1082   TString lhcState = fGRPData->GetLHCState();
1083   if (lhcState==AliGRPObject::GetInvalidString()) {
1084     AliError("GRP/GRP/Data entry:  missing value for the LHC state ! Using UNKNOWN");
1085     lhcState = "UNKNOWN";
1086   }
1087
1088   TString beamType = fGRPData->GetBeamType();
1089   if (beamType==AliGRPObject::GetInvalidString()) {
1090     AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
1091     beamType = "UNKNOWN";
1092   }
1093
1094   Float_t beamEnergy = fGRPData->GetBeamEnergy();
1095   if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
1096     AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
1097     beamEnergy = 0;
1098   }
1099
1100   TString runType = fGRPData->GetRunType();
1101   if (runType==AliGRPObject::GetInvalidString()) {
1102     AliError("GRP/GRP/Data entry:  missing value for the run type ! Using UNKNOWN");
1103     runType = "UNKNOWN";
1104   }
1105
1106   Int_t activeDetectors = fGRPData->GetDetectorMask();
1107   if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
1108     AliError("GRP/GRP/Data entry:  missing value for the detector mask ! Using 1074790399");
1109     activeDetectors = 1074790399;
1110   }
1111   AliDebug(1, Form("activeDetectors = %d", activeDetectors));
1112
1113   fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
1114   fRunInfo->Dump();
1115
1116
1117   // Process the list of active detectors
1118   if (activeDetectors) {
1119     UInt_t detMask = activeDetectors;
1120     AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1121     fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1122     AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1123     fRunTracking = MatchDetectorList(fRunTracking,detMask);
1124     fFillESD = MatchDetectorList(fFillESD,detMask);
1125     fQADetectors = MatchDetectorList(fQADetectors,detMask);
1126     fDeleteRecPoints = MatchDetectorList(fDeleteRecPoints,detMask);
1127     fDeleteDigits    = MatchDetectorList(fDeleteDigits,detMask);
1128     fLoadCDB.Form("%s %s %s %s",
1129                   fRunLocalReconstruction.Data(),
1130                   fRunTracking.Data(),
1131                   fFillESD.Data(),
1132                   fQADetectors.Data());
1133     fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
1134     if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
1135         !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
1136         !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
1137       // switch off the vertexer
1138       AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
1139       fRunVertexFinder = kFALSE;
1140       fRunMultFinder = kFALSE;
1141     }
1142     if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1143       // switch off the reading of CTP raw-data payload
1144       if (fFillTriggerESD) {
1145         AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1146         fFillTriggerESD = kFALSE;
1147       }
1148     }
1149   }
1150
1151   AliInfo("===================================================================================");
1152   AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1153   AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1154   AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
1155   AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
1156   AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
1157   AliInfo("===================================================================================");
1158
1159   //*** Dealing with the magnetic field map
1160   if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
1161     if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
1162       AliInfo("ExpertMode!!! GRP information will be ignored !");
1163       AliInfo("ExpertMode!!! Running with the externally locked B field !");
1164     }
1165     else {
1166       AliInfo("Destroying existing B field instance!");
1167       delete TGeoGlobalMagField::Instance();
1168     }    
1169   }
1170   if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
1171     // Construct the field map out of the information retrieved from GRP.
1172     Bool_t ok = kTRUE;
1173     // L3
1174     Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1175     if (l3Current == AliGRPObject::GetInvalidFloat()) {
1176       AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
1177       ok = kFALSE;
1178     }
1179     
1180     Char_t l3Polarity = fGRPData->GetL3Polarity();
1181     if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1182       AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
1183       ok = kFALSE;
1184     }
1185
1186     // Dipole
1187     Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1188     if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1189       AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
1190       ok = kFALSE;
1191     }
1192
1193     Char_t diPolarity = fGRPData->GetDipolePolarity();
1194     if (diPolarity == AliGRPObject::GetInvalidChar()) {
1195       AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
1196       ok = kFALSE;
1197     }
1198
1199     // read special bits for the polarity convention and map type
1200     Int_t  polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
1201     Bool_t uniformB = fGRPData->IsUniformBMap();
1202
1203     if (ok) { 
1204       AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1), 
1205                                              TMath::Abs(diCurrent) * (diPolarity ? -1:1), 
1206                                              polConvention,uniformB,beamEnergy, beamType.Data());
1207       if (fld) {
1208         TGeoGlobalMagField::Instance()->SetField( fld );
1209         TGeoGlobalMagField::Instance()->Lock();
1210         AliInfo("Running with the B field constructed out of GRP !");
1211       }
1212       else AliFatal("Failed to create a B field map !");
1213     }
1214     else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1215   }
1216   
1217   //*** Get the diamond profiles from OCDB
1218   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1219   if (entry) {
1220     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1221   } else {
1222      AliError("No SPD diamond profile found in OCDB!");
1223   }
1224
1225   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1226   if (entry) {
1227     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1228   } else {
1229      AliError("No diamond profile found in OCDB!");
1230   }
1231
1232   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1233   if (entry) {
1234     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1235   } else {
1236      AliError("No TPC diamond profile found in OCDB!");
1237   }
1238
1239   entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1240   if (entry) {
1241     fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1242     entry->SetOwner(0);
1243   }
1244
1245   if (!fListOfCosmicTriggers) {
1246     AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
1247   }
1248
1249   return kTRUE;
1250
1251
1252 //_____________________________________________________________________________
1253 Bool_t AliReconstruction::LoadCDB()
1254 {
1255   // Load CDB entries for all active detectors.
1256   // By default we load all the entries in <det>/Calib
1257   // folder.
1258
1259   AliCodeTimerAuto("",0);
1260
1261   AliCDBManager::Instance()->Get("GRP/CTP/Config");
1262
1263   AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
1264
1265   TString detStr = fLoadCDB;
1266   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1267     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1268     AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1269     AliCDBManager::Instance()->GetAll(Form("%s/Trigger/*",fgkDetectorName[iDet]));
1270   }
1271
1272   // Temporary fix - one has to define the correct policy in order
1273   // to load the trigger OCDB entries only for the detectors that
1274   // in the trigger or that are needed in order to put correct
1275   // information in ESD
1276   AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
1277
1278   return kTRUE;
1279 }
1280 //_____________________________________________________________________________
1281 Bool_t AliReconstruction::LoadTriggerScalersCDB()
1282 {
1283   // Load CTP scalers from OCDB.
1284   // The scalers are checked for consistency.
1285
1286   AliCodeTimerAuto("",0);
1287
1288   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
1289
1290   if (entry) { 
1291    
1292        AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1293        fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1294        entry->SetOwner(0);
1295        if (fRunScalers && (fRunScalers->CorrectScalersOverflow() == 0)) AliInfo("32bit Trigger counters corrected for overflow");
1296
1297   }
1298   return kTRUE;
1299 }
1300 //_____________________________________________________________________________
1301 Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
1302 {
1303   // Load CTP timing information (alignment)
1304   // from OCDB.
1305
1306   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
1307   if (!entry) return kFALSE;
1308
1309   AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
1310   fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
1311   entry->SetOwner(0);
1312
1313   AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
1314   if (!entry2) return kFALSE;
1315
1316   AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
1317   fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
1318   entry2->SetOwner(0);
1319
1320   return kTRUE;
1321 }
1322
1323 //_____________________________________________________________________________
1324 Bool_t AliReconstruction::ReadIntensityInfoCDB()
1325 {
1326   // Load LHC DIP data
1327   AliCDBEntry* entry    = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
1328   AliCDBEntry* entryCTP = AliCDBManager::Instance()->Get("GRP/CTP/Config");
1329   //
1330   if (!entry || !entryCTP) {
1331     AliError(Form("Failed to extract CDB objects GRP/GRP/LHCData: %p or GRP/CTP/Config: %p",entry,entryCTP));
1332     return kFALSE;
1333   }
1334   // extract BC masks
1335   enum {kA,kB,kC,kE,kNMasks};
1336   AliTriggerConfiguration* conf = (AliTriggerConfiguration*)entryCTP->GetObject();
1337   const TObjArray& clArr = conf->GetClasses();
1338   TObjArray masks(kNMasks);
1339   TIter next(&clArr);
1340   AliTriggerClass* trClass = 0;
1341   int nFound = 0;
1342   masks.SetOwner(kFALSE);
1343   //
1344   while ( (trClass=(AliTriggerClass*)next()) ) {
1345     TString trName = trClass->GetName();
1346     int ind = trName.Index("-"); // prefix in front of A,B,C,E
1347     if (ind<1) continue;   // anomaly
1348     //
1349     trName = trName.Data() + ind;
1350     AliTriggerBCMask* bcMask = trClass->GetBCMask();
1351     if (!bcMask) continue;
1352     UInt_t which = 0;
1353     if      (trName.BeginsWith("-A-"))  which |= 0x1<<kA;
1354     else if (trName.BeginsWith("-B-"))  which |= 0x1<<kB;
1355     else if (trName.BeginsWith("-C-"))  which |= 0x1<<kC;
1356     else if (trName.BeginsWith("-E-"))  which |= 0x1<<kE;
1357     else if (trName.BeginsWith("-AC-")) which |= (0x1<<kA) | (0x1<<kC);
1358     else if (trName.BeginsWith("-CA-")) which |= (0x1<<kA) | (0x1<<kC);
1359     else { AliWarning(Form("Unknown trigger type %s\n",trClass->GetName())); continue;}
1360     //
1361     for (int ip=kNMasks;ip--;) {
1362       if ( !(which&(0x1<<ip)) || masks[ip] ) continue; // does not match or already done
1363       masks[ip] = (TObject*)bcMask;
1364       nFound++;
1365     }
1366     if (nFound==kNMasks) break;
1367   }  
1368   //  
1369   AliInfo("Reading mean bunch intensities from GRP/GRP/LHCData");
1370   AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
1371   //
1372   for (int ib=2;ib--;) {
1373     double intI,intNI;
1374     if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI,&masks)>=0)) {
1375       fBeamInt[ib][0] = intI;
1376       fBeamInt[ib][1] = intNI;  
1377       AliInfo(Form("Mean intensity for beam %d: Interacting:%.2e Non-Interacting:%.2e",ib,intI,intNI));
1378     }
1379   }
1380   return kTRUE;
1381   //
1382 }
1383
1384
1385 //_____________________________________________________________________________
1386 Bool_t AliReconstruction::Run(const char* input)
1387 {
1388   // Run Run Run
1389   AliCodeTimerAuto("",0);
1390
1391   InitRun(input);
1392   if (GetAbort() != TSelector::kContinue) return kFALSE;
1393
1394   TChain *chain = NULL;
1395   if (fRawReader && (chain = fRawReader->GetChain())) {
1396     Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
1397     // Proof mode
1398     if (gProof) {
1399       // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
1400       gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
1401
1402       if (gGrid)
1403         gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
1404
1405       TMessage::EnableSchemaEvolutionForAll(kTRUE);
1406       gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
1407
1408       gProof->AddInput(this);
1409
1410       if (!ParseOutput()) return kFALSE;
1411
1412       gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
1413       chain->SetProof();
1414       chain->Process("AliReconstruction","",nEntries,fFirstEvent);
1415     }
1416     else {
1417       chain->Process(this,"",nEntries,fFirstEvent);
1418     }
1419   }
1420   else {
1421     Begin(NULL);
1422     if (GetAbort() != TSelector::kContinue) return kFALSE;
1423     SlaveBegin(NULL);
1424     if (GetAbort() != TSelector::kContinue) return kFALSE;
1425     //******* The loop over events
1426     AliInfo("Starting looping over events");
1427     Int_t iEvent = 0;
1428     while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1429            (fRawReader && fRawReader->NextEvent())) {
1430       //
1431       // check if process has enough resources 
1432       if (!HasEnoughResources(iEvent)) break;
1433       if (!ProcessEvent(iEvent)) {
1434         Abort("ProcessEvent",TSelector::kAbortFile);
1435         return kFALSE;
1436       }
1437       iEvent++;
1438     }
1439     if (!iEvent) AliWarning("No events passed trigger selection");
1440     SlaveTerminate();
1441     if (GetAbort() != TSelector::kContinue) return kFALSE;
1442     Terminate();
1443     if (GetAbort() != TSelector::kContinue) return kFALSE;
1444   }
1445
1446   return kTRUE;
1447 }
1448
1449 //_____________________________________________________________________________
1450 void AliReconstruction::InitRawReader(const char* input)
1451 {
1452   // Init raw-reader and
1453   // set the input in case of raw data
1454
1455   AliCodeTimerAuto("",0);
1456
1457   if (input) fRawInput = input;
1458   fRawReader = AliRawReader::Create(fRawInput.Data());
1459   if (!fRawReader) {
1460     if (fRawInput.IsNull()) {
1461       AliInfo("Reconstruction will run over digits");
1462     }
1463     else {
1464       AliFatal("Can not create raw-data reader ! Exiting..."); 
1465     }
1466   }
1467
1468   if (!fEquipIdMap.IsNull() && fRawReader)
1469     fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1470
1471   if (!fUseHLTData.IsNull()) {
1472     // create the RawReaderHLT which performs redirection of HLT input data for
1473     // the specified detectors
1474     AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1475     if (pRawReader) {
1476       fParentRawReader=fRawReader;
1477       fRawReader=pRawReader;
1478     } else {
1479       AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1480     }
1481   }
1482   AliSysInfo::AddStamp("CreateRawReader");
1483 }
1484
1485 //_____________________________________________________________________________
1486 void AliReconstruction::InitRun(const char* input)
1487 {
1488   // Initialization of raw-reader,
1489   // run number, CDB etc.
1490   AliCodeTimerAuto("",0);
1491   AliSysInfo::AddStamp("Start");
1492
1493   // Initialize raw-reader if any
1494   InitRawReader(input);
1495
1496   // Initialize the CDB storage
1497   InitCDB();
1498
1499   // Set run number in CDBManager (if it is not already set by the user)
1500   if (!SetRunNumberFromData()) {
1501     Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1502     return;
1503   }
1504
1505   // Set CDB lock: from now on it is forbidden to reset the run number
1506   // or the default storage or to activate any further storage!
1507   SetCDBLock();
1508   
1509 }
1510
1511 //_____________________________________________________________________________
1512 void AliReconstruction::Begin(TTree *)
1513 {
1514   // Initialize AlReconstruction before
1515   // going into the event loop
1516   // Should follow the TSelector convention
1517   // i.e. initialize only the object on the client side
1518   AliCodeTimerAuto("",0);
1519
1520   AliReconstruction *reco = NULL;
1521   if (fInput) {
1522     if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1523       *this = *reco;
1524     }
1525     AliSysInfo::AddStamp("ReadInputInBegin");
1526   }
1527
1528   // Import ideal TGeo geometry and apply misalignment
1529   if (!gGeoManager) {
1530     TString geom(gSystem->DirName(fGAliceFileName));
1531     geom += "/geometry.root";
1532     AliGeomManager::LoadGeometry(geom.Data());
1533     if (!gGeoManager) {
1534       Abort("LoadGeometry", TSelector::kAbortProcess);
1535       return;
1536     }
1537     AliSysInfo::AddStamp("LoadGeom");
1538     TString detsToCheck=fRunLocalReconstruction;
1539     if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1540       Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1541       return;
1542     }
1543     AliSysInfo::AddStamp("CheckGeom");
1544   }
1545
1546   Bool_t toCDBSnapshot=kFALSE;
1547   TString snapshotFileOut(""); // we could use fSnapshotFileName if we are not interested
1548   // in reading from and writing to a snapshot file at the same time
1549   if(TString(getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
1550       toCDBSnapshot=kTRUE;
1551       //fFromCDBSnapshot=kFALSE;
1552       TString snapshotFile(getenv("OCDB_SNAPSHOT_FILENAME"));
1553       if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
1554           snapshotFileOut = snapshotFile;
1555       else
1556           snapshotFileOut="OCDB.root";
1557   }
1558
1559   if (!MisalignGeometry(fLoadAlignData)) {
1560     Abort("MisalignGeometry", TSelector::kAbortProcess);
1561     return;
1562   }
1563   AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1564   if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1565   AliSysInfo::AddStamp("MisalignGeom");
1566
1567   if (!InitGRP()) {
1568     Abort("InitGRP", TSelector::kAbortProcess);
1569     return;
1570   }
1571   AliSysInfo::AddStamp("InitGRP");
1572   if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1573
1574   if(!fCDBSnapshotMode || toCDBSnapshot){
1575       if (!LoadCDB()) {
1576           Abort("LoadCDB", TSelector::kAbortProcess);
1577           return;
1578       }
1579       AliSysInfo::AddStamp("LoadCDB"); 
1580   }
1581
1582   if (!LoadTriggerScalersCDB()) {
1583     Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1584     return;
1585   }
1586   AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1587
1588   if (!LoadCTPTimeParamsCDB()) {
1589     Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
1590     return;
1591   }
1592   AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
1593
1594   if (!ReadIntensityInfoCDB()) {
1595     Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
1596     return;
1597   }
1598   AliSysInfo::AddStamp("ReadIntensityInfoCDB");
1599
1600   // Read the reconstruction parameters from OCDB
1601   if (!InitRecoParams()) {
1602     AliWarning("Not all detectors have correct RecoParam objects initialized");
1603   }
1604   AliSysInfo::AddStamp("InitRecoParams");
1605
1606   if(toCDBSnapshot)
1607   {
1608       AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
1609       AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1610       AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1611   }
1612
1613   if (fInput && gProof) {
1614     if (reco) *reco = *this;
1615
1616     gGeoManager->SetName("Geometry");
1617     gProof->AddInputData(gGeoManager,kTRUE);
1618     gGeoManager = NULL;
1619     gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
1620     fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1621     AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1622     magFieldMap->SetName("MagneticFieldMap");
1623     gProof->AddInputData(magFieldMap,kTRUE);
1624     if (fAnalysis) {
1625       fAnalysis->SetName("Analysis");
1626       gProof->AddInputData(fAnalysis,kTRUE);
1627     }  
1628   }
1629
1630 }
1631
1632 //_____________________________________________________________________________
1633 void AliReconstruction::SlaveBegin(TTree*)
1634 {
1635   // Initialization related to run-loader,
1636   // vertexer, trackers, recontructors
1637   // In proof mode it is executed on the slave
1638   AliCodeTimerAuto("",0);
1639
1640   TProofOutputFile *outProofFile = NULL;
1641   if (fInput) {
1642     if (AliDebugLevel() > 0) fInput->Print();
1643     if (AliDebugLevel() > 10) fInput->Dump();
1644     if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1645       *this = *reco;
1646     }
1647     if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1648       gGeoManager = tgeo;
1649       AliGeomManager::SetGeometry(tgeo);
1650     }
1651     if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1652       Int_t runNumber = -1;
1653       if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1654         AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1655         man->SetCacheFlag(kTRUE);
1656         man->SetLock(kTRUE);
1657         man->Print();
1658       }
1659     }
1660     if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1661       AliMagF *newMap = new AliMagF(*map);
1662       if (!newMap->LoadParameterization()) {
1663         Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
1664         return;
1665       }
1666       TGeoGlobalMagField::Instance()->SetField(newMap);
1667       TGeoGlobalMagField::Instance()->Lock();
1668     }
1669     if (!fAnalysis) {
1670        // Attempt to get the analysis manager from the input list
1671        fAnalysis = (AliAnalysisManager*)fInput->FindObject("Analysis");
1672        if (fAnalysis) AliInfo("==== Analysis manager retrieved from input list ====");
1673     }   
1674     if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
1675       fProofOutputFileName = outputFileName->GetTitle();
1676     if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
1677       fProofOutputLocation = outputLocation->GetTitle();
1678     if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
1679       fProofOutputDataset = kTRUE;
1680     if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
1681       fProofOutputArchive = archiveList->GetTitle();
1682     if (!fProofOutputFileName.IsNull() &&
1683         !fProofOutputLocation.IsNull() &&
1684         fProofOutputArchive.IsNull()) {
1685       if (!fProofOutputDataset) {
1686         outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
1687         outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
1688       }
1689       else {
1690         outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
1691       }
1692       if (AliDebugLevel() > 0) outProofFile->Dump();
1693       fOutput->Add(outProofFile);
1694     }
1695     AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1696   }
1697   // Check if analysis was requested in the reconstruction event loop
1698   if (!fAnalysis) {
1699     // Attempt to connect in-memory singleton
1700     fAnalysis = AliAnalysisManager::GetAnalysisManager();
1701     if (fAnalysis) AliInfo(Form("==== Analysis manager <%s> found in memory ====", fAnalysis->GetName()));
1702     // Check if an analysis macro was specified
1703     if (!fAnalysis && !fAnalysisMacro.IsNull()) {
1704       // Run specified analysis macro
1705       gROOT->ProcessLine(Form(".x %s",fAnalysisMacro.Data()));
1706       fAnalysis = AliAnalysisManager::GetAnalysisManager();
1707       if (!fAnalysis) AliError(Form("No analysis manager produced by analysis macro %s", fAnalysisMacro.Data()));
1708       else AliInfo(Form("==== Analysis manager <%s> produced by analysis macro <%s> ====", 
1709                         fAnalysis->GetName(), fAnalysisMacro.Data()));
1710     }
1711   }
1712   
1713   // get the run loader
1714   if (!InitRunLoader()) {
1715     Abort("InitRunLoader", TSelector::kAbortProcess);
1716     return;
1717   }
1718   AliSysInfo::AddStamp("LoadLoader");
1719  
1720   ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1721
1722   // get trackers
1723   if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1724     Abort("CreateTrackers", TSelector::kAbortProcess);
1725     return;
1726   }      
1727   AliSysInfo::AddStamp("CreateTrackers");
1728
1729   // create the ESD output file and tree
1730   if (!outProofFile) {
1731     ffile = TFile::Open("AliESDs.root", "RECREATE");
1732     ffile->SetCompressionLevel(2);
1733     if (!ffile->IsOpen()) {
1734       Abort("OpenESDFile", TSelector::kAbortProcess);
1735       return;
1736     }
1737   }
1738   else {
1739     AliInfo(Form("Opening output PROOF file: %s/%s",
1740                  outProofFile->GetDir(), outProofFile->GetFileName()));
1741     if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1742       Abort(Form("Problems opening output PROOF file: %s/%s",
1743                  outProofFile->GetDir(), outProofFile->GetFileName()),
1744             TSelector::kAbortProcess);
1745       return;
1746     }
1747   }
1748
1749   ftree = new TTree("esdTree", "Tree with ESD objects");
1750   fesd = new AliESDEvent();
1751   fesd->CreateStdContent();
1752   // add a so far non-std object to the ESD, this will
1753   // become part of the std content
1754   fesd->AddObject(new AliESDHLTDecision);
1755
1756   fesd->WriteToTree(ftree);
1757   if (fWriteESDfriend) {
1758     ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
1759     ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
1760     fesdf  = new AliESDfriend();
1761     ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
1762     fesd->AddObject(fesdf);
1763     ffile->cd();
1764   }
1765   ftree->GetUserInfo()->Add(fesd);
1766
1767   fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1768   fhltesd = new AliESDEvent();
1769   fhltesd->CreateStdContent();
1770   // read the ESD template from CDB
1771   // HLT is allowed to put non-std content to its ESD, the non-std
1772   // objects need to be created before invocation of WriteToTree in
1773   // order to create all branches. Initialization is done from an
1774   // ESD layout template in CDB
1775   AliCDBManager* man = AliCDBManager::Instance();
1776   AliCDBEntry* hltESDConfig = man->Get("HLT/Calib/esdLayout");
1777   AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1778   if (pESDLayout) {
1779       // init all internal variables from the list of objects
1780       pESDLayout->GetStdContent();
1781
1782       // copy content and create non-std objects
1783       *fhltesd=*pESDLayout;
1784       fhltesd->Reset();
1785   } else {
1786       AliError(Form("error setting hltEsd layout from \"HLT/Calib/esdLayout\": invalid object type"));
1787   }
1788
1789   fhltesd->WriteToTree(fhlttree);
1790   fhlttree->GetUserInfo()->Add(fhltesd);
1791
1792   ProcInfo_t procInfo;
1793   gSystem->GetProcInfo(&procInfo);
1794   AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
1795   
1796   //QA
1797   //Initialize the QA and start of cycle 
1798   if (fRunQA || fRunGlobalQA) 
1799     InitQA() ; 
1800
1801   //Initialize the Plane Efficiency framework
1802   if (fRunPlaneEff && !InitPlaneEff()) {
1803     Abort("InitPlaneEff", TSelector::kAbortProcess);
1804     return;
1805   }
1806
1807   if (strcmp(gProgName,"alieve") == 0)
1808     fRunAliEVE = InitAliEVE();
1809   // If we have an analysis manager, connect the AliRecoInputHandler here  
1810   if (fAnalysis) {
1811     if (!dynamic_cast<AliRecoInputHandler*>(fAnalysis->GetInputEventHandler())) {
1812        AliError("Analysis manager used in reconstruction should use AliRecoInputHandler - \
1813                  \n  ->Replacing with AliRecoInputHandler instance.");
1814        delete fAnalysis->GetInputEventHandler();
1815     }
1816     // Set the event and other data pointers
1817     fRecoHandler = new AliRecoInputHandler();
1818 //    fRecoHandler->Init(ftree, "LOCAL");
1819     fRecoHandler->SetEvent(fesd);
1820     fRecoHandler->SetESDfriend(fesdf);
1821     fRecoHandler->SetHLTEvent(fhltesd);
1822     fRecoHandler->SetHLTTree(fhlttree);
1823     fAnalysis->SetInputEventHandler(fRecoHandler);
1824     // Enter external loop mode
1825     fAnalysis->SetExternalLoop(kTRUE);
1826     // Initialize analysis
1827     fAnalysis->SlaveBegin(ftree);
1828     fAnalysis->StartAnalysis("local", (TTree*)0);
1829     // Connect ESD tree with the input container
1830     fAnalysis->GetCommonInputContainer()->SetData(ftree);
1831   }  
1832   return;
1833 }
1834
1835 //_____________________________________________________________________________
1836 Bool_t AliReconstruction::Process(Long64_t entry)
1837 {
1838   // run the reconstruction over a single entry
1839   // from the chain with raw data
1840   AliCodeTimerAuto("",0);
1841
1842   TTree *currTree = fChain->GetTree();
1843   AliRawVEvent *event = NULL;
1844   currTree->SetBranchAddress("rawevent",&event);
1845   currTree->GetEntry(entry);
1846   fRawReader = new AliRawReaderRoot(event);
1847   // check if process has enough resources 
1848   if (!HasEnoughResources(entry)) return kFALSE;
1849   fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1850   delete fRawReader;
1851   fRawReader = NULL;
1852   delete event;
1853
1854   return fStatus;
1855 }
1856
1857 //_____________________________________________________________________________
1858 void AliReconstruction::Init(TTree *tree)
1859 {
1860   // Implementation of TSelector::Init()
1861   // method
1862   if (tree == 0) {
1863     AliError("The input tree is not found!");
1864     return;
1865   }
1866   fChain = tree;
1867 }
1868
1869 //_____________________________________________________________________________
1870 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1871 {
1872   // run the reconstruction over a single event
1873   // The event loop is steered in Run method
1874
1875
1876   static Long_t oldMres=0;
1877   static Long_t oldMvir=0;
1878   static Float_t oldCPU=0;
1879   static Long_t aveDMres=0;
1880   static Long_t aveDMvir=0;
1881   static Float_t aveDCPU=0;
1882
1883   AliCodeTimerAuto("",0);
1884
1885   AliESDpid pid;
1886
1887   AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
1888
1889   if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1890     fRunLoader->SetEventNumber(iEvent);
1891     if (fRawReader)
1892       fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(), 
1893                                      iEvent, iEvent);
1894     fRunLoader->TreeE()->Fill();
1895
1896     if (fRawReader && fRawReader->UseAutoSaveESD())
1897       fRunLoader->TreeE()->AutoSave("SaveSelf");
1898   }
1899
1900   if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1901     return kTRUE;
1902   }
1903
1904
1905   fRunLoader->GetEvent(iEvent);
1906
1907   // Fill Event-info object
1908   GetEventInfo();
1909   fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
1910   
1911   ProcInfo_t procInfo;
1912   if(iEvent==fFirstEvent) {
1913     gSystem->GetProcInfo(&procInfo);
1914     oldMres=procInfo.fMemResident;
1915     oldMvir=procInfo.fMemVirtual;
1916     oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
1917   }
1918   AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
1919
1920   AliSysInfo::AddStamp(Form("StartReco_%d",iEvent), 0,0,iEvent);
1921
1922   // Set the reco-params
1923   {
1924     TString detStr = fLoadCDB;
1925     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1926       if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1927       AliReconstructor *reconstructor = GetReconstructor(iDet);
1928       if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1929         const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1930         reconstructor->SetRecoParam(par);
1931         reconstructor->GetPidSettings(&pid);
1932         reconstructor->SetEventInfo(&fEventInfo);
1933         if (fRunQA) {
1934           AliQAManager::QAManager()->SetEventInfo(&fEventInfo) ;
1935           AliQAManager::QAManager()->SetRecoParam(iDet, par) ; 
1936           if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
1937         }
1938       }
1939     }
1940     //
1941     if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
1942     //
1943     if (fRunQA) {
1944       const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
1945       AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ; 
1946       AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
1947     }
1948   }
1949
1950     // QA on single raw 
1951   if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
1952     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1953     AliQAManager::QAManager()->RunOneEvent(fRawReader) ;  
1954     AliSysInfo::AddStamp(Form("RawQA_%d",iEvent), 0,0,iEvent);
1955   }
1956
1957     // fill Event header information from the RawEventHeader
1958     if (fRawReader){FillRawEventHeaderESD(fesd);}
1959     if (fRawReader){FillRawEventHeaderESD(fhltesd);}
1960
1961     fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1962     fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1963     
1964     ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1965     ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
1966     ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1967     ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
1968
1969     fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1970     fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1971
1972     fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1973     fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1974     
1975     // Set magnetic field from the tracker
1976     fesd->SetMagneticField(AliTracker::GetBz());
1977     fhltesd->SetMagneticField(AliTracker::GetBz());
1978     //
1979     AliESDRun *esdRun,*esdRunH;
1980     esdRun  = (AliESDRun*)fesd->GetESDRun();
1981     esdRunH = (AliESDRun*)fhltesd->GetESDRun();
1982     esdRun->SetBeamEnergyIsSqrtSHalfGeV();
1983     esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
1984     //
1985     for (int ib=2;ib--;) for (int it=2;it--;) {
1986         esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]); 
1987         esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]); 
1988       }
1989     //
1990     fesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
1991     fesd->SetBeamType(fGRPData->GetBeamType().Data());
1992     fesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
1993     fesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
1994     fhltesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
1995     fhltesd->SetBeamType(fGRPData->GetBeamType().Data());
1996     fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
1997     fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
1998     //
1999     AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2000     if (fld) { // set info needed for field initialization
2001       fesd->SetCurrentL3(fld->GetCurrentSol());
2002       fesd->SetCurrentDip(fld->GetCurrentDip());
2003       fesd->SetUniformBMap(fld->IsUniform());
2004       fesd->SetBInfoStored();
2005       //
2006       fhltesd->SetCurrentL3(fld->GetCurrentSol());
2007       fhltesd->SetCurrentDip(fld->GetCurrentDip());
2008       fhltesd->SetUniformBMap(fld->IsUniform());
2009       fhltesd->SetBInfoStored();
2010     }
2011
2012     //
2013     // run full HLT reconstruction first
2014     //
2015     {
2016       TString detectors=fRunLocalReconstruction;
2017       if (IsSelected("HLT", detectors) &&
2018           !RunLocalEventReconstruction("HLT")) {
2019         if (fStopOnError) {CleanUp(); return kFALSE;}
2020       }
2021       detectors=fFillESD;
2022       // run HLT on hltesd
2023       if (IsSelected("HLT", detectors) &&
2024           !FillESD(fhltesd, "HLT")) {
2025         if (fStopOnError) {CleanUp(); return kFALSE;}
2026       }
2027     }
2028
2029     // local single event reconstruction
2030     if (!fRunLocalReconstruction.IsNull()) {
2031       TString detectors=fRunLocalReconstruction;
2032       // the logic for selection and correct sequence of reconstruction relies on the
2033       // full list of detectors. Keyword 'ALL' should have been replaced at this point.
2034       if (detectors.Contains("ALL")) {
2035         AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
2036                  "fRunLocalReconstruction. This should have been done by the framework");
2037       }
2038       detectors.ReplaceAll("HLT", "");
2039       if (!RunLocalEventReconstruction(detectors)) {
2040         if (fStopOnError) {
2041           CleanUp(); 
2042           return kFALSE;
2043         }
2044       }
2045     }
2046
2047   
2048     //
2049     // Set most probable pt, for B=0 tracking
2050     // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
2051     const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
2052     if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
2053     
2054     // Fill raw-data error log into the ESD
2055     if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2056
2057     AliSysInfo::AddStamp(Form("FillHeadErrs_%d",iEvent), 0,0,iEvent);
2058
2059     // vertex finder
2060     if (fRunVertexFinder) {
2061       if (!RunVertexFinder(fesd)) {
2062         if (fStopOnError) {CleanUp(); return kFALSE;}
2063       }
2064       AliSysInfo::AddStamp(Form("VtxFinder_%d",iEvent), 0,0,iEvent);
2065     }
2066
2067     // For Plane Efficiency: run the SPD trackleter
2068     if (fRunPlaneEff && fSPDTrackleter) {
2069       if (!RunSPDTrackleting(fesd)) {
2070         if (fStopOnError) {CleanUp(); return kFALSE;}
2071       }
2072       AliSysInfo::AddStamp(Form("TrackletEff_%d",iEvent), 0,0,iEvent);
2073     }
2074
2075     // Muon tracking
2076     if (!fRunTracking.IsNull()) {
2077       if (fRunMuonTracking) {
2078         if (!RunMuonTracking(fesd)) {
2079           if (fStopOnError) {CleanUp(); return kFALSE;}
2080         }
2081       }
2082       AliSysInfo::AddStamp(Form("TrackingMUON_%d",iEvent), 0,0,iEvent);      
2083     }
2084
2085     // barrel tracking
2086     if (!fRunTracking.IsNull()) {
2087       if (!RunTracking(fesd,pid)) {
2088         if (fStopOnError) {CleanUp(); return kFALSE;}
2089       }
2090     }
2091
2092     // fill ESD
2093     if (!fFillESD.IsNull()) {
2094       TString detectors=fFillESD;
2095       // the logic for selection and correct sequence of reconstruction relies on the
2096       // full list of detectors. Keyword 'ALL' should have been replaced at this point.
2097       if (detectors.Contains("ALL")) {
2098         AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
2099                  "fFillESD. This should have been done by the framework");
2100       }
2101       // remove HLT as this has been executed at the beginning of the event reconstruction
2102       detectors.ReplaceAll("HLT", "");
2103       if (!FillESD(fesd, detectors)) {
2104         if (fStopOnError) {CleanUp(); return kFALSE;}
2105       }
2106     }
2107
2108     ffile->cd();
2109
2110     //
2111     // Propagate track to the beam pipe  (if not already done by ITS)
2112     //
2113     const Int_t ntracks = fesd->GetNumberOfTracks();
2114     const Double_t kRadius  = 2.8; //something less than the beam pipe radius
2115
2116     TObjArray trkArray;
2117     UShort_t selectedIdx[ntracks];
2118
2119     for (Int_t itrack=0; itrack<ntracks; itrack++){
2120       const Double_t kMaxStep = 1;   //max step over the material
2121       Bool_t ok;
2122
2123       AliESDtrack *track = fesd->GetTrack(itrack);
2124       if (!track) continue;
2125
2126       AliExternalTrackParam *tpcTrack =
2127            (AliExternalTrackParam *)track->GetTPCInnerParam();
2128       ok = kFALSE;
2129       if (tpcTrack)
2130         ok = AliTracker::
2131           PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
2132
2133       if (ok) {
2134         Int_t n=trkArray.GetEntriesFast();
2135         selectedIdx[n]=track->GetID();
2136         trkArray.AddLast(tpcTrack);
2137       }
2138
2139       //Tracks refitted by ITS should already be at the SPD vertex
2140       if (track->IsOn(AliESDtrack::kITSrefit)) continue;
2141
2142       AliTracker::
2143          PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
2144       Double_t x[3]; track->GetXYZ(x);
2145       Double_t b[3]; AliTracker::GetBxByBz(x,b);
2146       track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
2147
2148     }
2149     AliSysInfo::AddStamp(Form("RelToSPDVtx_%d",iEvent), 0,0,iEvent);      
2150     //
2151     // Improve the reconstructed primary vertex position using the tracks
2152     //
2153     Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
2154     if(fesd->GetPrimaryVertexSPD()) {
2155       TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
2156       if(vtitle.Contains("cosmics")) {
2157         runVertexFinderTracks=kFALSE;
2158       }
2159     }
2160
2161     if (runVertexFinderTracks) {
2162        // TPC + ITS primary vertex
2163        ftVertexer->SetITSMode();
2164        ftVertexer->SetConstraintOff();
2165        // get cuts for vertexer from AliGRPRecoParam
2166        Bool_t constrSPD=kFALSE;
2167        if (grpRecoParam) {
2168          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2169          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2170          grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer,nCutsVertexer);
2171          ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2172          delete [] cutsVertexer; cutsVertexer = NULL; 
2173          if(grpRecoParam->GetVertexerTracksConstraintITS()) { 
2174            if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
2175              ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius 
2176            }else{
2177              if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
2178                ftVertexer->SetVtxStart(fDiamondProfileSPD);
2179                constrSPD=kTRUE;
2180              }
2181            }
2182          } 
2183        }
2184        AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
2185        if (pvtx) {
2186          if(constrSPD){
2187            TString title=pvtx->GetTitle();
2188            title.Append("SPD");
2189            pvtx->SetTitle(title);
2190          }
2191           if (pvtx->GetStatus()) {
2192              fesd->SetPrimaryVertexTracks(pvtx);
2193              for (Int_t i=0; i<ntracks; i++) {
2194                  AliESDtrack *t = fesd->GetTrack(i);
2195                  Double_t x[3]; t->GetXYZ(x);
2196                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
2197                  t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
2198              } 
2199           }
2200           delete pvtx; pvtx=NULL;
2201        }
2202        AliSysInfo::AddStamp(Form("VtxTrk_%d",iEvent), 0,0,iEvent);      
2203
2204        // TPC-only primary vertex
2205        ftVertexer->SetTPCMode();
2206        ftVertexer->SetConstraintOff();
2207        // get cuts for vertexer from AliGRPRecoParam
2208        if (grpRecoParam) {
2209          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2210          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2211          grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer,nCutsVertexer);
2212          ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2213          delete [] cutsVertexer; cutsVertexer = NULL; 
2214          if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) { 
2215            if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius 
2216          } 
2217        }
2218        pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
2219        if (pvtx) {
2220           if (pvtx->GetStatus()) {
2221              fesd->SetPrimaryVertexTPC(pvtx);
2222              for (Int_t i=0; i<ntracks; i++) {
2223                  AliESDtrack *t = fesd->GetTrack(i);
2224                  Double_t x[3]; t->GetXYZ(x);
2225                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
2226                  t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
2227              } 
2228           }
2229           delete pvtx; pvtx=NULL;
2230        }
2231        AliSysInfo::AddStamp(Form("VtxTPC_%d",iEvent), 0,0,iEvent);      
2232
2233     }
2234     
2235     if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
2236     else fesd->SetDiamond(fDiamondProfileSPD);
2237
2238     if (fRunV0Finder) {
2239        // V0 finding
2240        AliV0vertexer vtxer;
2241        // get cuts for V0vertexer from AliGRPRecoParam
2242        if (grpRecoParam) {
2243          Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
2244          Double_t cutsV0vertexer[nCutsV0vertexer];
2245          grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
2246          vtxer.SetCuts(cutsV0vertexer);
2247        }
2248        vtxer.Tracks2V0vertices(fesd);
2249        AliSysInfo::AddStamp(Form("V0Finder_%d",iEvent), 0,0,iEvent); 
2250
2251        if (fRunCascadeFinder) {
2252           // Cascade finding
2253           AliCascadeVertexer cvtxer;
2254           // get cuts for CascadeVertexer from AliGRPRecoParam
2255           if (grpRecoParam) {
2256             Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
2257             Double_t cutsCascadeVertexer[nCutsCascadeVertexer];
2258             grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
2259             cvtxer.SetCuts(cutsCascadeVertexer);
2260           }
2261           cvtxer.V0sTracks2CascadeVertices(fesd);
2262           AliSysInfo::AddStamp(Form("CascadeFinder_%d",iEvent), 0,0,iEvent); 
2263        }
2264     }
2265
2266     // AdC+FN
2267     if (fReconstructor[3])
2268       GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
2269
2270     // combined PID
2271     pid.MakePID(fesd);
2272
2273     if (fFillTriggerESD) {
2274       if (!FillTriggerESD(fesd)) {
2275         if (fStopOnError) {CleanUp(); return kFALSE;}
2276       }
2277     }
2278     // Always fill scalers
2279     if (!FillTriggerScalers(fesd)) {
2280        if (fStopOnError) {CleanUp(); return kFALSE;}
2281     }
2282
2283     AliSysInfo::AddStamp(Form("FillVaria_%d",iEvent), 0,0,iEvent); 
2284
2285     // write ESD
2286     UInt_t specie = fesd->GetEventSpecie();
2287     Bool_t keepAll = (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib);
2288     if (fCleanESD && (!keepAll) ) {
2289       CleanESD(fesd);
2290       AliSysInfo::AddStamp(Form("CleanESD_%d",iEvent), 0,0,iEvent); 
2291     }
2292     // 
2293     // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the 
2294     // tracks interpreted as primary, this step should be done in the very end, when full 
2295     // ESD info is available (particulalry, V0s)
2296     // vertex finder
2297     if (fRunMultFinder) {
2298       if (!RunMultFinder(fesd)) {
2299         if (fStopOnError) {CleanUp(); return kFALSE;}
2300       }
2301       AliSysInfo::AddStamp(Form("MultFinder_%d",iEvent), 0,0,iEvent); 
2302     }
2303
2304   if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
2305     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2306     AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ; 
2307     AliSysInfo::AddStamp(Form("RunQA_%d",iEvent), 0,0,iEvent); 
2308   }
2309   if (fRunGlobalQA) {
2310     AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2311     if (qadm)
2312       qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2313     if (qadm && IsInTasks(AliQAv1::kESDS))
2314       qadm->Exec(AliQAv1::kESDS, fesd);
2315     AliSysInfo::AddStamp(Form("RunGlobQA_%d",iEvent), 0,0,iEvent);     
2316   }
2317
2318   // copy HLT decision from HLTesd to esd
2319   // the most relevant information is stored in a reduced container in the esd,
2320   // while the full information can be found in the HLTesd
2321   TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
2322   TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
2323   if (pHLTSrc && pHLTTgt) {
2324     pHLTSrc->Copy(*pHLTTgt);
2325   }
2326   //
2327   // Perform analysis of this event if requested
2328   // RS: Should be done before WriteESDfriend, since the latter may clean the esdfriend
2329   if (fAnalysis) {
2330     fRecoHandler->BeginEvent(iEvent);
2331     fAnalysis->ExecAnalysis();
2332     fRecoHandler->FinishEvent();
2333     AliSysInfo::AddStamp(Form("Analysis_%d",iEvent), 0,0,iEvent);     
2334   }  
2335   //
2336   if (fWriteESDfriend) {
2337     fesd->GetESDfriend(fesdf);
2338     AliSysInfo::AddStamp(Form("CreateFriend_%d",iEvent), 0,0,iEvent);     
2339   
2340   }
2341   //
2342   ftree->Fill();
2343   AliSysInfo::AddStamp(Form("ESDFill_%d",iEvent), 0,0,iEvent);     
2344   //
2345   if (fWriteESDfriend) {
2346     WriteESDfriend();
2347     AliSysInfo::AddStamp(Form("WriteFriend_%d",iEvent), 0,0,iEvent);     
2348   }
2349   //
2350   //
2351   // Auto-save the ESD tree in case of prompt reco @P2
2352   if (fRawReader && fRawReader->UseAutoSaveESD()) {
2353     ftree->AutoSave("SaveSelf");
2354     if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
2355   }
2356     // write HLT ESD
2357     fhlttree->Fill();
2358
2359     // call AliEVE
2360     if (fRunAliEVE) RunAliEVE();
2361     //
2362     fesd->Reset();
2363     fhltesd->Reset();
2364     if (fWriteESDfriend) {
2365       fesdf->~AliESDfriend();
2366       new (fesdf) AliESDfriend(); // Reset...
2367     }
2368
2369     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2370       if (fReconstructor[iDet]) fReconstructor[iDet]->FinishEvent();
2371     }
2372  
2373     gSystem->GetProcInfo(&procInfo);
2374     Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
2375     Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
2376     Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
2377     aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
2378     aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
2379     aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
2380     AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
2381                  iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
2382     oldMres=procInfo.fMemResident;
2383     oldMvir=procInfo.fMemVirtual;
2384     oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
2385   
2386     fEventInfo.Reset();
2387     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2388       if (fReconstructor[iDet]) {
2389         fReconstructor[iDet]->SetRecoParam(NULL);
2390         fReconstructor[iDet]->SetEventInfo(NULL);
2391       }
2392       if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
2393     }
2394         
2395   if (fRunQA || fRunGlobalQA) 
2396     AliQAManager::QAManager()->Increment() ; 
2397
2398   DeleteRecPoints(fDeleteRecPoints);
2399   DeleteDigits(fDeleteDigits);
2400   //
2401   return kTRUE;
2402 }
2403
2404 //_____________________________________________________________________________
2405 void AliReconstruction::SlaveTerminate()
2406 {
2407   // Finalize the run on the slave side
2408   // Called after the exit
2409   // from the event loop
2410   AliCodeTimerAuto("",0);
2411   // If analysis was done during reconstruction, we need to call SlaveTerminate for it
2412   if (fAnalysis) {
2413      fAnalysis->PackOutput(fOutput);
2414      fAnalysis->SetSkipTerminate(kTRUE);
2415      fAnalysis->Terminate();
2416   }   
2417
2418   if (fIsNewRunLoader) { // galice.root didn't exist
2419     fRunLoader->WriteHeader("OVERWRITE");
2420     fRunLoader->WriteTrigger("OVERWRITE");
2421     fRunLoader->CdGAFile();
2422     fRunLoader->Write(0, TObject::kOverwrite);
2423   }
2424
2425   const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();       
2426   const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();   
2427                  
2428    TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());    
2429    cdbMapCopy->SetOwner(1);      
2430    cdbMapCopy->SetName("cdbMap");        
2431    TIter iter(cdbMap->GetTable());       
2432          
2433    TPair* pair = 0;      
2434    while((pair = dynamic_cast<TPair*> (iter.Next()))){   
2435          TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());   
2436          TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2437          if (keyStr && valStr)
2438            cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));        
2439    }     
2440          
2441    TList *cdbListCopy = new TList();     
2442    cdbListCopy->SetOwner(1);     
2443    cdbListCopy->SetName("cdbList");      
2444          
2445    TIter iter2(cdbList);         
2446          
2447         AliCDBId* id=0;
2448         while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){    
2449          cdbListCopy->Add(new TObjString(id->ToString().Data()));        
2450    }     
2451          
2452    ftree->GetUserInfo()->Add(cdbMapCopy);        
2453    ftree->GetUserInfo()->Add(cdbListCopy);
2454
2455    // Add the AliRoot version that created this file
2456    TString sVersion("aliroot ");
2457    sVersion += ALIROOT_SVN_BRANCH;
2458    sVersion += ":";
2459    sVersion += ALIROOT_SVN_REVISION;
2460    sVersion += "; root ";
2461    sVersion += ROOT_SVN_BRANCH;
2462    sVersion += ":";
2463    sVersion += ROOT_SVN_REVISION;
2464    sVersion += "; metadata ";
2465    sVersion += getenv("PRODUCTION_METADATA");
2466                     
2467
2468    TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
2469    ftree->GetUserInfo()->Add(alirootVersion); // The list becomes owner of alirootVersion
2470
2471   ffile->cd();
2472
2473   // we want to have only one tree version number
2474   ftree->Write(ftree->GetName(),TObject::kOverwrite);
2475   fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
2476
2477   if (fWriteESDfriend) {
2478     ffileF->cd();
2479     ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
2480   }
2481
2482 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
2483   if (fRunPlaneEff && !FinishPlaneEff()) {
2484    AliWarning("Finish PlaneEff evaluation failed");
2485   }
2486
2487   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2488     if (fReconstructor[iDet]) fReconstructor[iDet]->Terminate();
2489   }
2490   // End of cycle for the in-loop  
2491
2492   if (fRunQA || fRunGlobalQA) {
2493     AliQAManager::QAManager()->EndOfCycle() ;
2494     if (fInput &&
2495         !fProofOutputLocation.IsNull() &&
2496         fProofOutputArchive.IsNull() &&
2497         !fProofOutputDataset) {
2498       TString qaOutputFile(Form("%sMerged.%s.Data.root",
2499                                 fProofOutputLocation.Data(),
2500                                 AliQAv1::GetQADataFileName()));
2501       TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2502                                                                 AliQAv1::GetQADataFileName()));
2503       qaProofFile->SetOutputFileName(qaOutputFile.Data());
2504       if (AliDebugLevel() > 0) qaProofFile->Dump();
2505       fOutput->Add(qaProofFile);
2506       MergeQA(qaProofFile->GetFileName());
2507     }
2508     else {
2509       MergeQA();
2510     }
2511   }
2512
2513   gROOT->cd();
2514   CleanUp();
2515
2516   if (fInput) {
2517     if (!fProofOutputFileName.IsNull() &&
2518         !fProofOutputLocation.IsNull() &&
2519         fProofOutputDataset &&
2520         !fProofOutputArchive.IsNull()) {
2521       TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2522                                                             "DROV",
2523                                                             fProofOutputLocation.Data());
2524       if (AliDebugLevel() > 0) zipProofFile->Dump();
2525       fOutput->Add(zipProofFile);
2526       TString fileList(fProofOutputArchive.Data());
2527       fileList.ReplaceAll(","," ");
2528       TString command;
2529 #if ROOT_SVN_REVISION >= 30174
2530       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2531 #else
2532       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2533 #endif
2534       AliInfo(Form("Executing: %s",command.Data()));
2535       gSystem->Exec(command.Data());
2536     }
2537   }
2538 }
2539     
2540 //_____________________________________________________________________________
2541 void AliReconstruction::Terminate()
2542 {
2543   // Create tags for the events in the ESD tree (the ESD tree is always present)
2544   // In case of empty events the tags will contain dummy values
2545   AliCodeTimerAuto("",0);
2546
2547   // Do not call the ESD tag creator in case of PROOF-based reconstruction
2548   if (!fInput) {
2549     AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2550     esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2551     delete esdtagCreator;
2552   }
2553
2554   // Cleanup of CDB manager: cache and active storages!
2555   AliCDBManager::Instance()->ClearCache();
2556 }
2557
2558 //_____________________________________________________________________________
2559 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2560 {
2561 // run the local reconstruction
2562
2563   static Int_t eventNr=0;
2564   AliCodeTimerAuto("",0)
2565
2566   TString detStr = detectors;
2567   // execute HLT reconstruction first since other detector reconstruction
2568   // might depend on HLT data
2569   // key 'HLT' is removed from detStr by IsSelected
2570   if (IsSelected("HLT", detStr)) {
2571     AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
2572     if (reconstructor) {
2573       // there is no AliLoader for HLT, see
2574       // https://savannah.cern.ch/bugs/?35473
2575       AliInfo("running reconstruction for HLT");
2576       if (fRawReader) {
2577         AliInfo("reconstructor->Reconstruct(fRawReader, NULL)");
2578         reconstructor->Reconstruct(fRawReader, NULL);
2579       } 
2580       else {
2581         AliInfo("reconstructor->Reconstruct(dummy, NULL)");
2582         TTree* dummy=NULL;
2583         reconstructor->Reconstruct(dummy, NULL);
2584       }
2585     }
2586     AliSysInfo::AddStamp(Form("LRecHLT_%d",eventNr), -1,1,eventNr);
2587   }
2588
2589   AliInfo(Form("kNDetectors = %d",kNDetectors));
2590
2591   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2592     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2593     AliDebug(1, Form("Detector: %s", fgkDetectorName[iDet]));
2594     AliReconstructor* reconstructor = GetReconstructor(iDet);
2595     if (!reconstructor) continue;
2596     AliLoader* loader = fLoader[iDet];
2597     if (!loader) {
2598       AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2599       continue;
2600     }
2601     // conversion of digits
2602     if (fRawReader && reconstructor->HasDigitConversion()) {
2603       AliInfo(Form("converting raw data digits into root objects for %s", 
2604                    fgkDetectorName[iDet]));
2605 //      AliCodeTimerAuto(Form("converting raw data digits into root objects for %s", 
2606 //                            fgkDetectorName[iDet]),0);
2607       loader->LoadDigits("update");
2608       loader->CleanDigits();
2609       loader->MakeDigitsContainer();
2610       TTree* digitsTree = loader->TreeD();
2611       reconstructor->ConvertDigits(fRawReader, digitsTree);
2612       loader->WriteDigits("OVERWRITE");
2613       loader->UnloadDigits();
2614     }
2615     // local reconstruction
2616     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
2617     //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
2618     AliDebug(1, "Loading Rec Points");
2619     loader->LoadRecPoints("update");
2620     AliDebug(1, "Cleaning Rec Points");
2621     loader->CleanRecPoints();
2622     AliDebug(1, "Making Rec Points Container");
2623     loader->MakeRecPointsContainer();
2624     TTree* clustersTree = loader->TreeR();
2625     if (fRawReader && !reconstructor->HasDigitConversion()) {
2626       reconstructor->Reconstruct(fRawReader, clustersTree);
2627     } 
2628     else {
2629       AliDebug(1, "Loading Digits");
2630       loader->LoadDigits("read");
2631       TTree* digitsTree = loader->TreeD();
2632       AliDebug(1, Form("Digits Tree = %p",digitsTree));
2633       if (!digitsTree) {
2634         AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2635         if (fStopOnError) 
2636           return kFALSE;
2637       } 
2638       else {
2639         AliDebug(1, "Digits -> Clusters");
2640         reconstructor->Reconstruct(digitsTree, clustersTree);
2641         if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
2642           AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2643           AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ; 
2644         }
2645       }
2646       loader->UnloadDigits();
2647     }
2648     if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
2649       AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2650       AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ; 
2651     }
2652     loader->WriteRecPoints("OVERWRITE");
2653     loader->UnloadRecPoints();
2654     AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
2655   }
2656   if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
2657   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2658     AliError(Form("the following detectors were not found: %s",
2659                   detStr.Data()));
2660     if (fStopOnError) 
2661       return kFALSE;
2662   }
2663   eventNr++;
2664   return kTRUE;
2665 }
2666 //_____________________________________________________________________________
2667 Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2668 {
2669 // run the SPD trackleting (for SPD efficiency purpouses)
2670
2671   AliCodeTimerAuto("",0)
2672
2673   Double_t vtxPos[3] = {0, 0, 0};
2674   Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2675 /*
2676   TArrayF m
2677 /
2678 cVertex(3);
2679   // if(MC)
2680   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2681     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2682     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2683   }
2684 */
2685   const AliESDVertex *vertex = esd->GetVertex();
2686   if(!vertex){
2687     AliWarning("Vertex not found");
2688     return kFALSE;
2689   }
2690   vertex->GetXYZ(vtxPos);
2691   vertex->GetSigmaXYZ(vtxErr);
2692   if (fSPDTrackleter) {
2693     AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2694
2695     // load clusters
2696     fLoader[0]->LoadRecPoints("read");
2697     TTree* tree = fLoader[0]->TreeR();
2698     if (!tree) {
2699       AliError("Can't get the ITS cluster tree");
2700       return kFALSE;
2701     }
2702     fSPDTrackleter->LoadClusters(tree);
2703     fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2704     // run trackleting
2705     if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2706       AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
2707      // fLoader[0]->UnloadRecPoints();
2708       return kFALSE;
2709     }
2710 //fSPDTrackleter->UnloadRecPoints();
2711   } else {
2712     AliWarning("SPDTrackleter not available");
2713     return kFALSE;
2714   }
2715   return kTRUE;
2716 }
2717
2718 //_____________________________________________________________________________
2719 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
2720 {
2721 // run the barrel tracking
2722
2723   AliCodeTimerAuto("",0)
2724
2725   AliVertexer *vertexer = CreateVertexer();
2726   if (!vertexer) return kFALSE;
2727
2728   AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
2729   AliESDVertex* vertex = NULL;
2730   if (fLoader[0]) {
2731     fLoader[0]->LoadRecPoints();
2732     TTree* cltree = fLoader[0]->TreeR();
2733     if (cltree) {
2734       if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2735       vertex = vertexer->FindVertexForCurrentEvent(cltree);
2736     }
2737     else {
2738       AliError("Can't get the ITS cluster tree");
2739     }
2740     fLoader[0]->UnloadRecPoints();
2741   }
2742   else {
2743     AliError("Can't get the ITS loader");
2744   }
2745   if(!vertex){
2746     AliWarning("Vertex not found");
2747     vertex = new AliESDVertex();
2748     vertex->SetName("default");
2749   }
2750   else {
2751     vertex->SetName("reconstructed");
2752   }
2753
2754   Double_t vtxPos[3];
2755   Double_t vtxErr[3];
2756   vertex->GetXYZ(vtxPos);
2757   vertex->GetSigmaXYZ(vtxErr);
2758
2759   esd->SetPrimaryVertexSPD(vertex);
2760   AliESDVertex *vpileup = NULL;
2761   Int_t novertices = 0;
2762   vpileup = vertexer->GetAllVertices(novertices);
2763   if(novertices>1){
2764     for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2765   }
2766   /*
2767   // if SPD multiplicity has been determined, it is stored in the ESD
2768   AliMultiplicity *mult = vertexer->GetMultiplicity();
2769   if(mult)esd->SetMultiplicity(mult);
2770   */
2771   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2772     if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2773   }  
2774   delete vertex;
2775
2776   delete vertexer;
2777
2778   return kTRUE;
2779 }
2780
2781 //_____________________________________________________________________________
2782 Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
2783 {
2784   // run the trackleter for multiplicity study
2785
2786   AliCodeTimerAuto("",0)
2787
2788   AliTrackleter *trackleter = CreateMultFinder();
2789   if (!trackleter) return kFALSE;
2790
2791   AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
2792
2793   if (fLoader[0]) {
2794     fLoader[0]->LoadRecPoints();
2795     TTree* cltree = fLoader[0]->TreeR();
2796     if (cltree) {
2797       trackleter->Reconstruct(esd,cltree);
2798       AliMultiplicity *mult = trackleter->GetMultiplicity();
2799       if(mult) esd->SetMultiplicity(mult);
2800     }
2801     else {
2802       AliError("Can't get the ITS cluster tree");
2803     }
2804     fLoader[0]->UnloadRecPoints();
2805   }
2806   else {
2807     AliError("Can't get the ITS loader");
2808   }
2809
2810   delete trackleter;
2811
2812   return kTRUE;
2813 }
2814
2815 //_____________________________________________________________________________
2816 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2817 {
2818 // run the muon spectrometer tracking
2819
2820   AliCodeTimerAuto("",0)
2821
2822   if (!fRunLoader) {
2823     AliError("Missing runLoader!");
2824     return kFALSE;
2825   }
2826   Int_t iDet =  GetDetIndex("MUON"); // for MUON
2827
2828   // Get a pointer to the MUON reconstructor
2829   AliReconstructor *reconstructor = GetReconstructor(iDet);
2830   if (!reconstructor) return kFALSE;
2831
2832   
2833   TString detName = fgkDetectorName[iDet];
2834   AliDebug(1, Form("%s tracking", detName.Data()));
2835   AliTracker *tracker =  reconstructor->CreateTracker();
2836   if (!tracker) {
2837     AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2838     return kFALSE;
2839   }
2840      
2841   // read RecPoints
2842   fLoader[iDet]->LoadRecPoints("read");  
2843
2844   tracker->LoadClusters(fLoader[iDet]->TreeR());
2845   
2846   Int_t rv = tracker->Clusters2Tracks(esd);
2847   
2848   fLoader[iDet]->UnloadRecPoints();
2849
2850   tracker->UnloadClusters();
2851   
2852   if ( rv )
2853   {
2854     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2855     return kFALSE;
2856   }
2857   
2858   return kTRUE;
2859 }
2860
2861
2862 //_____________________________________________________________________________
2863 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
2864 {
2865 // run the barrel tracking
2866   static Int_t eventNr=0;
2867   AliCodeTimerAuto("",0)
2868
2869   AliInfo("running tracking");
2870
2871   // Set the event info which is used
2872   // by the trackers in order to obtain
2873   // information about read-out detectors,
2874   // trigger etc.
2875   AliDebug(1, "Setting event info");
2876   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2877     if (!fTracker[iDet]) continue;
2878     fTracker[iDet]->SetEventInfo(&fEventInfo);
2879   }
2880
2881   //Fill the ESD with the T0 info (will be used by the TOF) 
2882   if (fReconstructor[11] && fLoader[11]) {
2883     fLoader[11]->LoadRecPoints("READ");
2884     TTree *treeR = fLoader[11]->TreeR();
2885     if (treeR) {
2886       GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2887     }
2888   }
2889
2890   // pass 1: TPC + ITS inwards
2891   for (Int_t iDet = 1; iDet >= 0; iDet--) {
2892     if (!fTracker[iDet]) continue;
2893     AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
2894
2895     // load clusters
2896     fLoader[iDet]->LoadRecPoints("read");
2897     AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
2898     TTree* tree = fLoader[iDet]->TreeR();
2899     if (!tree) {
2900       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2901       return kFALSE;
2902     }
2903     fTracker[iDet]->LoadClusters(tree);
2904     AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2905     // run tracking
2906     if (fTracker[iDet]->Clusters2TracksHLT(esd, fhltesd) != 0) {
2907       AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2908       return kFALSE;
2909     }
2910     AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
2911     // preliminary PID in TPC needed by the ITS tracker
2912     if (iDet == 1) {
2913       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2914       PID.MakePID(esd,kTRUE);
2915       AliSysInfo::AddStamp(Form("MakePID0%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
2916     } 
2917   }
2918
2919   // pass 2: ALL backwards
2920
2921   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2922     if (!fTracker[iDet]) continue;
2923     AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2924
2925     // load clusters
2926     if (iDet > 1) {     // all except ITS, TPC
2927       TTree* tree = NULL;
2928       fLoader[iDet]->LoadRecPoints("read");
2929       AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
2930       tree = fLoader[iDet]->TreeR();
2931       if (!tree) {
2932         AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2933         return kFALSE;
2934       }
2935       fTracker[iDet]->LoadClusters(tree); 
2936       AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2937     }
2938
2939     // run tracking
2940     if (iDet>1) // start filling residuals for the "outer" detectors
2941       if (fRunGlobalQA) {
2942         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);     
2943         TObjArray ** arr = AliTracker::GetResidualsArray() ; 
2944         if (arr) {
2945           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2946           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
2947           if ( elem && (! elem->At(0)) ) {
2948             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2949             if (qadm) qadm->InitRecPointsForTracker() ; 
2950           }
2951         }
2952         //      AliSysInfo::AddStamp(Form("QAInitResid%s_%d",fgkDetectorName[iDet],eventNr), iDet,0, eventNr);
2953       }
2954     if (fTracker[iDet]->PropagateBack(esd) != 0) {
2955       AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
2956       //      return kFALSE;
2957     }
2958     AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2959
2960     // unload clusters
2961     if (iDet > 3) {     // all except ITS, TPC, TRD and TOF
2962       fTracker[iDet]->UnloadClusters();
2963       fLoader[iDet]->UnloadRecPoints();
2964     }
2965     // updated PID in TPC needed by the ITS tracker -MI
2966     if (iDet == 1) {
2967       //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2968       //AliESDpid::MakePID(esd);
2969       PID.MakePID(esd,kTRUE);
2970       AliSysInfo::AddStamp(Form("MakePID1%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
2971     }
2972
2973   }
2974   //stop filling residuals for the "outer" detectors
2975   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);     
2976
2977   // pass 3: TRD + TPC + ITS refit inwards
2978
2979   for (Int_t iDet = 2; iDet >= 0; iDet--) {
2980     if (!fTracker[iDet]) continue;
2981     AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
2982
2983     // run tracking
2984     if (iDet<2) // start filling residuals for TPC and ITS
2985       if (fRunGlobalQA) {
2986         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);     
2987         TObjArray ** arr = AliTracker::GetResidualsArray() ; 
2988         if (arr) {
2989           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2990           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
2991           if ( elem && (! elem->At(0)) ) {
2992             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2993             if (qadm) qadm->InitRecPointsForTracker() ; 
2994           }
2995         }
2996       }
2997     
2998     if (fTracker[iDet]->RefitInward(esd) != 0) {
2999       AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
3000       //      return kFALSE;
3001     }
3002     // run postprocessing
3003     if (fTracker[iDet]->PostProcess(esd) != 0) {
3004       AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
3005       //      return kFALSE;
3006     }
3007     AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3008   }
3009
3010   // write space-points to the ESD in case alignment data output
3011   // is switched on
3012   if (fWriteAlignmentData) {
3013     WriteAlignmentData(esd);
3014     AliSysInfo::AddStamp(Form("WrtAlignData_%d",eventNr), 0,0, eventNr);
3015   }
3016   
3017   for (Int_t iDet = 3; iDet >= 0; iDet--) {
3018     if (!fTracker[iDet]) continue;
3019     // unload clusters
3020     fTracker[iDet]->UnloadClusters();
3021     AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
3022     fLoader[iDet]->UnloadRecPoints();
3023     AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
3024   }
3025   // stop filling residuals for TPC and ITS
3026   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);     
3027
3028   eventNr++;
3029   return kTRUE;
3030 }
3031
3032 //_____________________________________________________________________________
3033 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
3034   //
3035   // Remove the data which are not needed for the physics analysis.
3036   //
3037
3038   Int_t nTracks=esd->GetNumberOfTracks();
3039   Int_t nV0s=esd->GetNumberOfV0s();
3040   AliInfo
3041   (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
3042
3043   Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
3044   Bool_t rc=esd->Clean(cleanPars);
3045
3046   nTracks=esd->GetNumberOfTracks();
3047   nV0s=esd->GetNumberOfV0s();
3048   AliInfo
3049   (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
3050
3051   return rc;
3052 }
3053
3054 //_____________________________________________________________________________
3055 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
3056 {
3057 // fill the event summary data
3058
3059   AliCodeTimerAuto("",0)
3060     static Int_t eventNr=0; 
3061   TString detStr = detectors;
3062   
3063   AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
3064   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3065   if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3066     AliReconstructor* reconstructor = GetReconstructor(iDet);
3067     if (!reconstructor) continue;
3068     AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
3069     TTree* clustersTree = NULL;
3070     if (fLoader[iDet]) {
3071       fLoader[iDet]->LoadRecPoints("read");
3072       clustersTree = fLoader[iDet]->TreeR();
3073       if (!clustersTree) {
3074         AliError(Form("Can't get the %s clusters tree", 
3075                       fgkDetectorName[iDet]));
3076         if (fStopOnError) return kFALSE;
3077       }
3078     }
3079     if (fRawReader && !reconstructor->HasDigitConversion()) {
3080       reconstructor->FillESD(fRawReader, clustersTree, esd);
3081     } else {
3082       TTree* digitsTree = NULL;
3083       if (fLoader[iDet]) {
3084         fLoader[iDet]->LoadDigits("read");
3085         digitsTree = fLoader[iDet]->TreeD();
3086         if (!digitsTree) {
3087           AliError(Form("Can't get the %s digits tree", 
3088                         fgkDetectorName[iDet]));
3089           if (fStopOnError) return kFALSE;
3090         }
3091       }
3092       reconstructor->FillESD(digitsTree, clustersTree, esd);
3093       if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
3094     }
3095     if (fLoader[iDet]) {
3096       fLoader[iDet]->UnloadRecPoints();
3097     }
3098   }
3099   
3100   if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
3101   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
3102     AliError(Form("the following detectors were not found: %s", 
3103                   detStr.Data()));
3104     if (fStopOnError) return kFALSE;
3105   }
3106   AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
3107   eventNr++;
3108   return kTRUE;
3109 }
3110
3111 //_____________________________________________________________________________
3112 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
3113 {
3114   // Reads the trigger decision which is
3115   // stored in Trigger.root file and fills
3116   // the corresponding esd entries
3117
3118   AliCodeTimerAuto("",0)
3119   
3120   AliInfo("Filling trigger information into the ESD");
3121
3122   if (fRawReader) {
3123     AliCTPRawStream input(fRawReader);
3124     if (!input.Next()) {
3125       AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
3126     }
3127     else {
3128       if (esd->GetTriggerMask() != input.GetClassMask())
3129         AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
3130                       input.GetClassMask(),esd->GetTriggerMask()));
3131       if (esd->GetOrbitNumber() != input.GetOrbitID())
3132         AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
3133                       input.GetOrbitID(),esd->GetOrbitNumber()));
3134       if (esd->GetBunchCrossNumber() != input.GetBCID())
3135         AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
3136                       input.GetBCID(),esd->GetBunchCrossNumber()));
3137       AliESDHeader* esdheader = esd->GetHeader();
3138       esdheader->SetL0TriggerInputs(input.GetL0Inputs());
3139       esdheader->SetL1TriggerInputs(input.GetL1Inputs());
3140       esdheader->SetL2TriggerInputs(input.GetL2Inputs());
3141       // IR
3142       //      UInt_t orbit=input.GetOrbitID();
3143       for(Int_t i=0 ; i<input.GetNIRs() ; i++ ) {
3144         esdheader->AddTriggerIR(input.GetIR(i));
3145       }
3146        AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3147        if (rlCTP) {
3148          rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
3149          rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
3150          rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
3151        }
3152     }
3153     if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
3154   }
3155   return kTRUE;
3156 }
3157 //_____________________________________________________________________________
3158 Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
3159 {
3160   //Scalers
3161   //fRunScalers->Print();
3162   if(fRunScalers && fRunScalers->CheckRunScalers()){
3163      AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
3164      //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
3165      AliESDHeader* esdheader = fesd->GetHeader();
3166      for(Int_t i=0;i<50;i++){
3167           if((1ull<<i) & esd->GetTriggerMask()){
3168           AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
3169           if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
3170         }
3171      }
3172      const AliTriggerScalersRecordESD* scalrecEvent = fRunScalers->GetScalersDeltaForEvent( timestamp);
3173      const AliTriggerScalersRecordESD* scalrecRun = fRunScalers->GetScalersDeltaForRun();
3174      if (scalrecEvent) esdheader->SetTriggerScalersDeltaEvent(scalrecEvent);
3175      if (scalrecRun) esdheader->SetTriggerScalersDeltaRun(scalrecRun);
3176   }
3177   return kTRUE;
3178 }
3179 //_____________________________________________________________________________
3180 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
3181 {
3182   // 
3183   // Filling information from RawReader Header
3184   // 
3185
3186   if (!fRawReader) return kFALSE;
3187
3188   AliInfo("Filling information from RawReader Header");
3189
3190   esd->SetBunchCrossNumber(fRawReader->GetBCID());
3191   esd->SetOrbitNumber(fRawReader->GetOrbitID());
3192   esd->SetPeriodNumber(fRawReader->GetPeriod());
3193
3194   esd->SetTimeStamp(fRawReader->GetTimestamp());  
3195   esd->SetEventType(fRawReader->GetType());
3196
3197   return kTRUE;
3198 }
3199
3200
3201 //_____________________________________________________________________________
3202 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
3203 {
3204 // check whether detName is contained in detectors
3205 // if yes, it is removed from detectors
3206
3207   // check if all detectors are selected
3208   if ((detectors.CompareTo("ALL") == 0) ||
3209       detectors.BeginsWith("ALL ") ||
3210       detectors.EndsWith(" ALL") ||
3211       detectors.Contains(" ALL ")) {
3212     detectors = "ALL";
3213     return kTRUE;
3214   }
3215
3216   // search for the given detector
3217   Bool_t result = kFALSE;
3218   if ((detectors.CompareTo(detName) == 0) ||
3219       detectors.BeginsWith(detName+" ") ||
3220       detectors.EndsWith(" "+detName) ||
3221       detectors.Contains(" "+detName+" ")) {
3222     detectors.ReplaceAll(detName, "");
3223     result = kTRUE;
3224   }
3225
3226   // clean up the detectors string
3227   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
3228   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
3229   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
3230
3231   return result;
3232 }
3233
3234 //_____________________________________________________________________________
3235 Bool_t AliReconstruction::InitRunLoader()
3236 {
3237 // get or create the run loader
3238
3239   if (gAlice) delete gAlice;
3240   gAlice = NULL;
3241
3242   TFile *gafile = TFile::Open(fGAliceFileName.Data());
3243   //  if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
3244   if (gafile) { // galice.root exists
3245     gafile->Close();
3246     delete gafile;
3247
3248     // load all base libraries to get the loader classes
3249     TString libs = gSystem->GetLibraries();
3250     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3251       TString detName = fgkDetectorName[iDet];
3252       if (libs.Contains("lib" + detName + "base.so")) continue;
3253       gSystem->Load("lib" + detName + "base.so");
3254     }
3255     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
3256     if (!fRunLoader) {
3257       AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
3258       CleanUp();
3259       return kFALSE;
3260     }
3261
3262     fRunLoader->CdGAFile();
3263     fRunLoader->LoadgAlice();
3264
3265     //PH This is a temporary fix to give access to the kinematics
3266     //PH that is needed for the labels of ITS clusters
3267     fRunLoader->LoadHeader();
3268     fRunLoader->LoadKinematics();
3269
3270   } else {               // galice.root does not exist
3271     if (!fRawReader) {
3272       AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
3273     }
3274     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
3275                                     AliConfig::GetDefaultEventFolderName(),
3276                                     "recreate");
3277     if (!fRunLoader) {
3278       AliError(Form("could not create run loader in file %s", 
3279                     fGAliceFileName.Data()));
3280       CleanUp();
3281       return kFALSE;
3282     }
3283     fIsNewRunLoader = kTRUE;
3284     fRunLoader->MakeTree("E");
3285     fRunLoader->MakeTree("GG");
3286
3287     if (fNumberOfEventsPerFile > 0)
3288       fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
3289     else
3290       fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
3291   }
3292
3293   return kTRUE;
3294 }
3295
3296 //_____________________________________________________________________________
3297 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
3298 {
3299 // get the reconstructor object and the loader for a detector
3300
3301   if (fReconstructor[iDet]) {
3302     if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3303       const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3304       fReconstructor[iDet]->SetRecoParam(par);
3305       fReconstructor[iDet]->SetRunInfo(fRunInfo);
3306     }
3307     return fReconstructor[iDet];
3308   }
3309
3310   // load the reconstructor object
3311   TPluginManager* pluginManager = gROOT->GetPluginManager();
3312   TString detName = fgkDetectorName[iDet];
3313   TString recName = "Ali" + detName + "Reconstructor";
3314
3315   if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
3316
3317   AliReconstructor* reconstructor = NULL;
3318   // first check if a plugin is defined for the reconstructor
3319   TPluginHandler* pluginHandler = 
3320     pluginManager->FindHandler("AliReconstructor", detName);
3321   // if not, add a plugin for it
3322   if (!pluginHandler) {
3323     AliDebug(1, Form("defining plugin for %s", recName.Data()));
3324     TString libs = gSystem->GetLibraries();
3325     if (libs.Contains("lib" + detName + "base.so") ||
3326         (gSystem->Load("lib" + detName + "base.so") >= 0)) {
3327       pluginManager->AddHandler("AliReconstructor", detName, 
3328                                 recName, detName + "rec", recName + "()");
3329     } else {
3330       pluginManager->AddHandler("AliReconstructor", detName, 
3331                                 recName, detName, recName + "()");
3332     }
3333     pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
3334   }
3335   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3336     reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
3337   }
3338
3339    // check if the upgrade reconstructor should be used instead of the standard one
3340   if(fUpgradeMask[iDet]) {
3341     if(reconstructor) delete reconstructor;
3342     TClass *cl = new TClass(Form("Ali%sUpgradeReconstructor",fgkDetectorName[iDet]));
3343     reconstructor = (AliReconstructor*)(cl->New());
3344    }
3345
3346   if (reconstructor) {
3347     TObject* obj = fOptions.FindObject(detName.Data());
3348     if (obj) reconstructor->SetOption(obj->GetTitle());
3349     reconstructor->SetRunInfo(fRunInfo);
3350     reconstructor->SetHLTESD(fhltesd);
3351     reconstructor->Init();
3352     fReconstructor[iDet] = reconstructor;
3353   }
3354
3355   // get or create the loader
3356   if (detName != "HLT") {
3357     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
3358     if (!fLoader[iDet]) {
3359       AliConfig::Instance()
3360         ->CreateDetectorFolders(fRunLoader->GetEventFolder(), 
3361                                 detName, detName);
3362       // first check if a plugin is defined for the loader
3363       pluginHandler = 
3364         pluginManager->FindHandler("AliLoader", detName);
3365       // if not, add a plugin for it
3366       if (!pluginHandler) {
3367         TString loaderName = "Ali" + detName + "Loader";
3368         AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
3369         pluginManager->AddHandler("AliLoader", detName, 
3370                                   loaderName, detName + "base", 
3371                                   loaderName + "(const char*, TFolder*)");
3372         pluginHandler = pluginManager->FindHandler("AliLoader", detName);
3373       }
3374       if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3375         fLoader[iDet] = 
3376           (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(), 
3377                                                  fRunLoader->GetEventFolder());
3378       }
3379       if (!fLoader[iDet]) {   // use default loader
3380         fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
3381       }
3382       if (!fLoader[iDet]) {
3383         AliWarning(Form("couldn't get loader for %s", detName.Data()));
3384         if (fStopOnError) return NULL;
3385       } else {
3386         fRunLoader->AddLoader(fLoader[iDet]);
3387         fRunLoader->CdGAFile();
3388         if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
3389         fRunLoader->Write(0, TObject::kOverwrite);
3390       }
3391     }
3392   }
3393       
3394   if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3395     const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3396     if (reconstructor) {
3397       reconstructor->SetRecoParam(par);
3398       reconstructor->SetRunInfo(fRunInfo);
3399     }
3400   }
3401   return reconstructor;
3402 }
3403
3404 //_____________________________________________________________________________
3405 AliVertexer* AliReconstruction::CreateVertexer()
3406 {
3407 // create the vertexer
3408 // Please note that the caller is the owner of the
3409 // vertexer
3410
3411   AliVertexer* vertexer = NULL;
3412   AliReconstructor* itsReconstructor = GetReconstructor(0);
3413   if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || 
3414                            fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3415     vertexer = itsReconstructor->CreateVertexer();
3416   }
3417   if (!vertexer) {
3418     AliWarning("couldn't create a vertexer for ITS");
3419   }
3420
3421   return vertexer;
3422 }
3423
3424 //_____________________________________________________________________________
3425 AliTrackleter* AliReconstruction::CreateMultFinder()
3426 {
3427 // create the ITS trackleter for mult. estimation
3428 // Please note that the caller is the owner of the
3429 // trackleter
3430
3431   AliTrackleter* trackleter = NULL;
3432   AliReconstructor* itsReconstructor = GetReconstructor(0);
3433   if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || 
3434                            fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3435     trackleter = itsReconstructor->CreateMultFinder();
3436   }
3437   else {
3438     AliWarning("ITS is not in reconstruction, switching off RunMultFinder");
3439     fRunMultFinder = kFALSE;
3440   }
3441
3442   return trackleter;
3443 }
3444
3445 //_____________________________________________________________________________
3446 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
3447 {
3448 // create the trackers
3449         AliInfo("Creating trackers");
3450
3451   TString detStr = detectors;
3452   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3453     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3454     AliReconstructor* reconstructor = GetReconstructor(iDet);
3455     if (!reconstructor) continue;
3456     TString detName = fgkDetectorName[iDet];
3457     if (detName == "MUON") {
3458       fRunMuonTracking = kTRUE;
3459       continue;
3460     }
3461
3462     fTracker[iDet] = reconstructor->CreateTracker();
3463     if (!fTracker[iDet] && (iDet < 7)) {
3464       AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
3465       if (fStopOnError) return kFALSE;
3466     }
3467     AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
3468   }
3469
3470   return kTRUE;
3471 }
3472
3473 //_____________________________________________________________________________
3474 void AliReconstruction::CleanUp()
3475 {
3476 // delete trackers and the run loader and close and delete the file
3477 /*
3478   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3479     delete fReconstructor[iDet];
3480     fReconstructor[iDet] = NULL;
3481     fLoader[iDet] = NULL;
3482     delete fTracker[iDet];
3483     fTracker[iDet] = NULL;
3484   }
3485 */
3486
3487   delete fRunInfo;
3488   fRunInfo = NULL;
3489
3490   delete fSPDTrackleter;
3491   fSPDTrackleter = NULL;
3492
3493   delete ftVertexer;
3494   ftVertexer = NULL;
3495   
3496   delete fRunLoader;
3497   fRunLoader = NULL;
3498   delete fRawReader;
3499   fRawReader = NULL;
3500   delete fParentRawReader;
3501   fParentRawReader=NULL;
3502
3503   if (ffile) {
3504     ffile->Close();
3505     delete ffile;
3506     ffile = NULL;
3507   }
3508
3509   if (AliQAManager::QAManager())
3510     AliQAManager::QAManager()->ShowQA() ; 
3511   //  AliQAManager::Destroy() ;
3512   delete fAnalysis; 
3513   fAnalysis = NULL;
3514 }
3515
3516 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
3517 {
3518   // Write space-points which are then used in the alignment procedures
3519   // For the moment only ITS, TPC, TRD and TOF
3520
3521   Int_t ntracks = esd->GetNumberOfTracks();
3522   for (Int_t itrack = 0; itrack < ntracks; itrack++)
3523     {
3524       AliESDtrack *track = esd->GetTrack(itrack);
3525       Int_t nsp = 0;
3526       Int_t idx[200];
3527       for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
3528       for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
3529           nsp += (iDet==GetDetIndex("TRD")) ? track->GetTRDntracklets():track->GetNcls(iDet);
3530
3531           if (iDet==GetDetIndex("ITS")) { // ITS "extra" clusters
3532              track->GetClusters(iDet,idx);
3533              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
3534           }  
3535       }
3536
3537       if (nsp) {
3538         AliTrackPointArray *sp = new AliTrackPointArray(nsp);
3539         track->SetTrackPointArray(sp);
3540         Int_t isptrack = 0;
3541         for (Int_t iDet = 5; iDet >= 0; iDet--) {
3542           AliTracker *tracker = fTracker[iDet];
3543           if (!tracker) continue;
3544           Int_t nspdet = (iDet==GetDetIndex("TRD")) ? track->GetTRDtracklets(idx):track->GetClusters(iDet,idx);
3545
3546           if (iDet==GetDetIndex("ITS")) // ITS "extra" clusters             
3547              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
3548
3549           if (nspdet <= 0) continue;
3550           AliTrackPoint p;
3551           Int_t isp = 0;
3552           Int_t isp2 = 0;
3553           while (isp2 < nspdet) {
3554             Bool_t isvalid=kTRUE;
3555
3556             Int_t index=idx[isp++];
3557             if (index < 0) continue;
3558
3559             TString dets = fgkDetectorName[iDet];
3560             if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
3561             fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
3562             fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
3563             fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
3564               isvalid = tracker->GetTrackPointTrackingError(index,p,track);
3565             } else {
3566               isvalid = tracker->GetTrackPoint(index,p); 
3567             } 
3568             isp2++;
3569             if (!isvalid) continue;
3570             if (iDet==GetDetIndex("ITS") && (isp-1)>=6) p.SetExtra();
3571             sp->AddPoint(isptrack,&p); isptrack++;
3572           }
3573         }       
3574       }
3575     }
3576 }
3577
3578 //_____________________________________________________________________________
3579 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
3580 {
3581   // The method reads the raw-data error log
3582   // accumulated within the rawReader.
3583   // It extracts the raw-data errors related to
3584   // the current event and stores them into
3585   // a TClonesArray inside the esd object.
3586
3587   if (!fRawReader) return;
3588
3589   for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3590
3591     AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3592     if (!log) continue;
3593     if (iEvent != log->GetEventNumber()) continue;
3594
3595     esd->AddRawDataErrorLog(log);
3596   }
3597
3598 }
3599
3600 //_____________________________________________________________________________
3601 // void AliReconstruction::CheckQA()
3602 // {
3603 // check the QA of SIM for this run and remove the detectors 
3604 // with status Fatal
3605   
3606 //      TString newRunLocalReconstruction ; 
3607 //      TString newRunTracking ;
3608 //      TString newFillESD ;
3609 //       
3610 //      for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3611 //              TString detName(AliQAv1::GetDetName(iDet)) ;
3612 //              AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;       
3613 //      if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
3614 //        AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS  and/or Digits was Fatal; No reconstruction performed", 
3615 //                   detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3616 //                      } else {
3617 //                      if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) || 
3618 //                                      fRunLocalReconstruction.Contains("ALL") )  {
3619 //                              newRunLocalReconstruction += detName ; 
3620 //                              newRunLocalReconstruction += " " ;                      
3621 //                      }
3622 //                      if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) || 
3623 //                                      fRunTracking.Contains("ALL") )  {
3624 //                              newRunTracking += detName ; 
3625 //                              newRunTracking += " " ;                         
3626 //                      }
3627 //                      if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) || 
3628 //                                      fFillESD.Contains("ALL") )  {
3629 //                              newFillESD += detName ; 
3630 //                              newFillESD += " " ;                     
3631 //                      }
3632 //              }
3633 //      }
3634 //      fRunLocalReconstruction = newRunLocalReconstruction ; 
3635 //      fRunTracking            = newRunTracking ; 
3636 //      fFillESD                = newFillESD ; 
3637 // }
3638
3639 //_____________________________________________________________________________
3640 Int_t AliReconstruction::GetDetIndex(const char* detector)
3641 {
3642   // return the detector index corresponding to detector
3643   Int_t index = -1 ; 
3644   for (index = 0; index < kNDetectors ; index++) {
3645     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3646         break ; 
3647   }     
3648   return index ; 
3649 }
3650 //_____________________________________________________________________________
3651 Bool_t AliReconstruction::FinishPlaneEff() {
3652  //
3653  // Here execute all the necessary operationis, at the end of the tracking phase,
3654  // in case that evaluation of PlaneEfficiencies was required for some detector.
3655  // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
3656  //
3657  // This Preliminary version works only FOR ITS !!!!!
3658  // other detectors (TOF,TRD, etc. have to develop their specific codes)
3659  //
3660  //  Input: none
3661  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
3662  //
3663  Bool_t ret=kFALSE;
3664  TString detStr = fLoadCDB;
3665  //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
3666  for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
3667    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3668    if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
3669       AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3670       TString name=planeeff->GetName();
3671       name+=".root";
3672       TFile* pefile = TFile::Open(name, "RECREATE");
3673       ret=(Bool_t)planeeff->Write();
3674       pefile->Close();
3675       if(planeeff->GetCreateHistos()) {
3676         TString hname=planeeff->GetName();
3677         hname+="Histo.root";
3678         ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
3679       }
3680    }
3681    if(fSPDTrackleter) {
3682      AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3683       TString name="AliITSPlaneEffSPDtracklet.root";
3684       TFile* pefile = TFile::Open(name, "RECREATE");
3685       ret=(Bool_t)planeeff->Write();
3686       pefile->Close();
3687       AliESDEvent *dummy=NULL;
3688       ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3689    }
3690  }
3691  return ret;
3692 }
3693 //_____________________________________________________________________________
3694 Bool_t AliReconstruction::InitPlaneEff() {
3695 //
3696  // Here execute all the necessary operations, before of the tracking phase,
3697  // for the evaluation of PlaneEfficiencies, in case required for some detectors.
3698  // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
3699  // which should be updated/recalculated.
3700  //
3701  // This Preliminary version will work only FOR ITS !!!!!
3702  // other detectors (TOF,TRD, etc. have to develop their specific codes)
3703  //
3704  //  Input: none
3705  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
3706  //
3707
3708   fSPDTrackleter = NULL;
3709   TString detStr = fLoadCDB;
3710   if (IsSelected(fgkDetectorName[0], detStr)) {
3711     AliReconstructor* itsReconstructor = GetReconstructor(0);
3712     if (itsReconstructor) {
3713       fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3714     }
3715     if (fSPDTrackleter) {
3716       AliInfo("Trackleter for SPD has been created");
3717     }
3718   }
3719  return kTRUE;
3720 }
3721
3722 //_____________________________________________________________________________
3723 Bool_t AliReconstruction::InitAliEVE()
3724 {
3725   // This method should be called only in case 
3726   // AliReconstruction is run
3727   // within the alieve environment.
3728   // It will initialize AliEVE in a way
3729   // so that it can visualize event processed
3730   // by AliReconstruction.
3731   // The return flag shows whenever the
3732   // AliEVE initialization was successful or not.
3733
3734   TString macroStr(getenv("ALIEVE_ONLINE_MACRO"));
3735
3736   if (macroStr.IsNull())
3737     macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3738
3739   AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3740
3741   if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3742
3743   gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
3744   gROOT->ProcessLine("alieve_online_init()");
3745
3746   return kTRUE;
3747 }
3748   
3749 //_____________________________________________________________________________
3750 void AliReconstruction::RunAliEVE()
3751 {
3752   // Runs AliEVE visualisation of
3753   // the current event.
3754   // Should be executed only after
3755   // successful initialization of AliEVE.
3756
3757   AliInfo("Running AliEVE...");
3758   gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p,(AliESDfriend*)%p);",fRunLoader,fRawReader,fesd,fesdf));
3759   gSystem->Run();
3760 }
3761
3762 //_____________________________________________________________________________
3763 Bool_t AliReconstruction::SetRunQA(TString detAndAction) 
3764 {
3765         // Allows to run QA for a selected set of detectors
3766         // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
3767         // all selected detectors run the same selected tasks
3768         
3769         if (!detAndAction.Contains(":")) {
3770                 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3771                 fRunQA = kFALSE ;
3772                 return kFALSE ;                 
3773         }
3774         Int_t colon = detAndAction.Index(":") ; 
3775         fQADetectors = detAndAction(0, colon) ; 
3776         fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ; 
3777         if (fQATasks.Contains("ALL") ) {
3778                 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ; 
3779         } else {
3780                 fQATasks.ToUpper() ; 
3781                 TString tempo("") ; 
3782                 if ( fQATasks.Contains("RAW") ) 
3783                         tempo = Form("%d ", AliQAv1::kRAWS) ; 
3784                 if ( fQATasks.Contains("DIGIT") ) 
3785                         tempo += Form("%d ", AliQAv1::kDIGITSR) ; 
3786                 if ( fQATasks.Contains("RECPOINT") ) 
3787                         tempo += Form("%d ", AliQAv1::kRECPOINTS) ; 
3788                 if ( fQATasks.Contains("ESD") ) 
3789                         tempo += Form("%d ", AliQAv1::kESDS) ; 
3790                 fQATasks = tempo ; 
3791                 if (fQATasks.IsNull()) {
3792                         AliInfo("No QA requested\n")  ;
3793                         fRunQA = kFALSE ;
3794                         return kTRUE ; 
3795                 }
3796         }       
3797         TString tempo(fQATasks) ; 
3798         tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS))      ;
3799         tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;      
3800         tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;  
3801         tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;    
3802         AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;  
3803         fRunQA = kTRUE ;
3804         return kTRUE; 
3805
3806
3807 //_____________________________________________________________________________
3808 Bool_t AliReconstruction::InitRecoParams() 
3809 {
3810   // The method accesses OCDB and retrieves all
3811   // the available reco-param objects from there.
3812
3813   Bool_t isOK = kTRUE;
3814
3815   if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
3816     AliInfo("Using custom GRP reconstruction parameters");
3817   }
3818   else {
3819     AliInfo("Loading GRP reconstruction parameter objects");
3820
3821     AliCDBPath path("GRP","Calib","RecoParam");
3822     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3823     if(!entry){ 
3824       AliWarning("Couldn't find GRP RecoParam entry in OCDB");
3825       isOK = kFALSE;
3826     }
3827     else {
3828       TObject *recoParamObj = entry->GetObject();
3829       if (dynamic_cast<TObjArray*>(recoParamObj)) {
3830         // GRP has a normal TobjArray of AliDetectorRecoParam objects
3831         // Registering them in AliRecoParam
3832         fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
3833       }
3834       else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3835         // GRP has only onse set of reco parameters
3836         // Registering it in AliRecoParam
3837         AliInfo("Single set of GRP reconstruction parameters found");
3838         dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3839         fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3840       }
3841       else {
3842         AliError("No valid GRP RecoParam object found in the OCDB");
3843         isOK = kFALSE;
3844       }
3845       entry->SetOwner(0);
3846     }
3847   }
3848
3849   TString detStr = fLoadCDB;
3850   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3851
3852     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3853
3854     if (fRecoParam.GetDetRecoParamArray(iDet)) {
3855       AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
3856       continue;
3857     }
3858
3859     AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
3860   
3861     AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
3862     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3863     if(!entry){ 
3864       AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
3865       isOK = kFALSE;
3866     }
3867     else {
3868       TObject *recoParamObj = entry->GetObject();
3869       if (dynamic_cast<TObjArray*>(recoParamObj)) {
3870         // The detector has a normal TobjArray of AliDetectorRecoParam objects
3871         // Registering them in AliRecoParam
3872         fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
3873       }
3874       else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3875         // The detector has only onse set of reco parameters
3876         // Registering it in AliRecoParam
3877         AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
3878         dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3879         fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3880       }
3881       else {
3882         AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
3883         isOK = kFALSE;
3884       }
3885       entry->SetOwner(0);
3886       //      FIX ME: We have to disable the unloading of reco-param CDB
3887       //      entries because QA framework is using them. Has to be fix in
3888       //      a way that the QA takes the objects already constructed in
3889       //      this method.
3890       //      AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
3891     }
3892   }
3893
3894   if (AliDebugLevel() > 0) fRecoParam.Print();
3895
3896   return isOK;
3897 }
3898
3899 //_____________________________________________________________________________
3900 Bool_t AliReconstruction::GetEventInfo() 
3901 {
3902   // Fill the event info object
3903   // ...
3904   AliCodeTimerAuto("",0)
3905
3906   AliCentralTrigger *aCTP = NULL;
3907   if (fRawReader) {
3908     fEventInfo.SetEventType(fRawReader->GetType());
3909
3910     ULong64_t mask = fRawReader->GetClassMask();
3911     fEventInfo.SetTriggerMask(mask);
3912     UInt_t clmask = fRawReader->GetDetectorPattern()[0];
3913     fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3914
3915     aCTP = new AliCentralTrigger();
3916     TString configstr("");
3917     if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB