CMake: Retrieve Git information
[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: AliReconstruction.cxx 63911 2013-08-19 16:46:41Z hristov $ */
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 <stdlib.h>
207 #include <unistd.h>
208 #include <sys/resource.h>
209 ClassImp(AliReconstruction)
210
211 using std::endl;
212
213 //_____________________________________________________________________________
214 const char* AliReconstruction::fgkStopEvFName = "_stopEvent_";
215 const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD",
216 "TOF", "PHOS", 
217 "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE","AD","FIT","MFT", "HLT"};
218
219 //_____________________________________________________________________________
220 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
221   TSelector(),
222   fRunVertexFinder(kTRUE),
223   fRunVertexFinderTracks(kTRUE),
224   fRunMuonTracking(kFALSE),
225   fRunMFTTrackingMU(kFALSE),
226   fRunV0Finder(kTRUE),
227   fRunCascadeFinder(kTRUE),
228   fRunMultFinder(kTRUE),
229   fStopOnError(kTRUE),
230   fStopOnMissingTriggerFile(kTRUE),
231   fWriteAlignmentData(kFALSE),
232   fWriteESDfriend(kFALSE),
233   fFillTriggerESD(kTRUE),
234
235   fCleanESD(kTRUE),
236   fV0DCAmax(3.),
237   fV0CsPmin(0.),
238   fDmax(50.),
239   fZmax(50.),
240
241   fCosmicAlias("kCosmic"),
242   fLaserAlias("kCalibLaser"),
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), //RS for BWD comp.
284   fAlias2Trigger(NULL),
285   
286   fGRPData(NULL),
287
288   fAlignObjArray(NULL),
289   fCDBUri(),
290   fQARefUri(),
291   fSpecCDBUri(), 
292   fCheckRecoCDBvsSimuCDB(),
293   fInitCDBCalled(kFALSE),
294   fCDBSnapshotMode(kFALSE),
295   fSetRunNumberFromDataCalled(kFALSE),
296   fQADetectors("ALL"), 
297   fQATasks("ALL"), 
298   fRunQA(kTRUE),  
299   fRunGlobalQA(kTRUE),
300   fSameQACycle(kFALSE),
301   fInitQACalled(kFALSE), 
302   fWriteQAExpertData(kTRUE), 
303   fRunPlaneEff(kFALSE),
304
305   fESDpid(NULL),
306
307   fesd(NULL),
308   fhltesd(NULL),
309   fesdf(NULL),
310   ffile(NULL),
311   ffileF(NULL),
312   ftree(NULL),
313   ftreeF(NULL),
314   fhlttree(NULL),
315   ftVertexer(NULL),
316   fIsNewRunLoader(kFALSE),
317   fRunAliEVE(kFALSE),
318   fChain(NULL),
319   fNall(0),
320   fNspecie(0),
321   fSspecie(0),
322   fNhighPt(0),
323   fShighPt(0),
324   //
325   fTreeBuffSize(30000000),
326   fMemCountESD(0),
327   fMemCountESDF(0),
328   fMemCountESDHLT(0),
329   //
330   fUpgradeModule(""),
331   fAnalysisMacro(),
332   fAnalysis(0),
333   fRecoHandler(0),
334   fDeclTriggerClasses(""),
335   fStopped(kFALSE),
336   fMaxRSS(0),
337   fMaxVMEM(0)
338 {
339 // create reconstruction object with default parameters
340   AliGeomManager::Destroy();
341   
342   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
343     fReconstructor[iDet] = NULL;
344     fUpgradeMask[iDet]=kFALSE;
345     fLoader[iDet] = NULL;
346     fTracker[iDet] = NULL;
347   }
348   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
349     fQACycles[iDet] = 999999 ;
350     fQAWriteExpert[iDet] = kFALSE ; 
351   }
352   fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
353   //
354   AddCheckRecoCDBvsSimuCDB("TPC/Calib/RecoParam"); // check for similarity in the sim and rec
355   //
356   AliPID pid;
357 }
358
359 //_____________________________________________________________________________
360 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
361   TSelector(),
362   fRunVertexFinder(rec.fRunVertexFinder),
363   fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
364   fRunMuonTracking(rec.fRunMuonTracking),
365   fRunMFTTrackingMU(rec.fRunMFTTrackingMU),
366   fRunV0Finder(rec.fRunV0Finder),
367   fRunCascadeFinder(rec.fRunCascadeFinder),
368   fRunMultFinder(rec.fRunMultFinder),
369   fStopOnError(rec.fStopOnError),
370   fStopOnMissingTriggerFile(rec.fStopOnMissingTriggerFile),
371   fWriteAlignmentData(rec.fWriteAlignmentData),
372   fWriteESDfriend(rec.fWriteESDfriend),
373   fFillTriggerESD(rec.fFillTriggerESD),
374
375   fCleanESD(rec.fCleanESD),
376   fV0DCAmax(rec.fV0DCAmax),
377   fV0CsPmin(rec.fV0CsPmin),
378   fDmax(rec.fDmax),
379   fZmax(rec.fZmax),
380
381   fCosmicAlias(rec.fCosmicAlias),
382   fLaserAlias(rec.fLaserAlias),
383   fRunLocalReconstruction(rec.fRunLocalReconstruction),
384   fRunTracking(rec.fRunTracking),
385   fFillESD(rec.fFillESD),
386   fDeleteRecPoints(""),
387   fDeleteDigits(""),
388   fLoadCDB(rec.fLoadCDB),
389   fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
390   fGAliceFileName(rec.fGAliceFileName),
391   fRawInput(rec.fRawInput),
392   fESDOutput(rec.fESDOutput),
393   fProofOutputFileName(rec.fProofOutputFileName),
394   fProofOutputLocation(rec.fProofOutputLocation),
395   fProofOutputDataset(rec.fProofOutputDataset),
396   fProofOutputArchive(rec.fProofOutputArchive),
397   fEquipIdMap(rec.fEquipIdMap),
398   fFirstEvent(rec.fFirstEvent),
399   fLastEvent(rec.fLastEvent),
400   fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
401   fFractionFriends(rec.fFractionFriends),
402   fOptions(),
403   fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
404   fLoadAlignData(rec.fLoadAlignData),
405   fUseHLTData(rec.fUseHLTData),
406   fRunInfo(NULL),
407   fEventInfo(),
408   fRunScalers(NULL),
409   fCTPTimeParams(NULL),
410   fCTPTimeAlign(NULL),
411
412   fRunLoader(NULL),
413   fRawReader(NULL),
414   fParentRawReader(NULL),
415
416   fRecoParam(rec.fRecoParam),
417
418   fSPDTrackleter(NULL),
419
420   fDiamondProfileSPD(rec.fDiamondProfileSPD),
421   fDiamondProfile(rec.fDiamondProfile),
422   fDiamondProfileTPC(rec.fDiamondProfileTPC),
423   fListOfCosmicTriggers(NULL), //RS for BWD comp.
424   fAlias2Trigger(NULL),
425   
426   fGRPData(NULL),
427
428   fAlignObjArray(rec.fAlignObjArray),
429   fCDBUri(rec.fCDBUri),
430   fQARefUri(rec.fQARefUri),
431   fSpecCDBUri(), 
432   fCheckRecoCDBvsSimuCDB(),
433   fInitCDBCalled(rec.fInitCDBCalled),
434   fCDBSnapshotMode(rec.fCDBSnapshotMode),
435   fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
436   fQADetectors(rec.fQADetectors), 
437   fQATasks(rec.fQATasks), 
438   fRunQA(rec.fRunQA),  
439   fRunGlobalQA(rec.fRunGlobalQA),
440   fSameQACycle(rec.fSameQACycle),
441   fInitQACalled(rec.fInitQACalled),
442   fWriteQAExpertData(rec.fWriteQAExpertData), 
443   fRunPlaneEff(rec.fRunPlaneEff),
444
445   fESDpid(NULL),
446
447   fesd(NULL),
448   fhltesd(NULL),
449   fesdf(NULL),
450   ffile(NULL),
451   ffileF(NULL),
452   ftree(NULL),
453   ftreeF(NULL),
454   fhlttree(NULL),
455   ftVertexer(NULL),
456   fIsNewRunLoader(rec.fIsNewRunLoader),
457   fRunAliEVE(kFALSE),
458   fChain(NULL),
459   fNall(0),
460   fNspecie(0),
461   fSspecie(0),
462   fNhighPt(0),
463   fShighPt(0),
464   //
465   fTreeBuffSize(rec.fTreeBuffSize),
466   fMemCountESD(0),
467   fMemCountESDF(0),
468   fMemCountESDHLT(0),
469   //
470   fUpgradeModule(""),
471   fAnalysisMacro(rec.fAnalysisMacro),
472   fAnalysis(0),
473   fRecoHandler(0),
474   fDeclTriggerClasses(rec.fDeclTriggerClasses),
475   fStopped(kFALSE),
476   fMaxRSS(0),
477   fMaxVMEM(0)
478 {
479 // copy constructor
480
481   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
482     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
483   }
484   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
485     fReconstructor[iDet] = NULL;
486     fUpgradeMask[iDet] = kFALSE;
487     fLoader[iDet] = NULL;
488     fTracker[iDet] = NULL;
489   }  
490   
491   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
492     fQACycles[iDet] = rec.fQACycles[iDet];
493     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ; 
494   }
495
496   for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
497     if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
498   }
499
500   for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
501     if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
502   }
503
504   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
505
506 }
507
508 //_____________________________________________________________________________
509 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
510 {
511 // assignment operator
512 // Used in PROOF mode
513 // Be very careful while modifing it!
514 // Simple rules to follow:
515 // for persistent data members - use their assignment operators
516 // for non-persistent ones - do nothing or take the default values from constructor
517 // TSelector members should not be touched
518   if(&rec == this) return *this;
519
520   fRunVertexFinder       = rec.fRunVertexFinder;
521   fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
522   fRunMuonTracking       = rec.fRunMuonTracking;
523   fRunMFTTrackingMU      = rec.fRunMFTTrackingMU;
524   fRunV0Finder           = rec.fRunV0Finder;
525   fRunCascadeFinder      = rec.fRunCascadeFinder;
526   fRunMultFinder         = rec.fRunMultFinder;
527   fStopOnError           = rec.fStopOnError;
528   fStopOnMissingTriggerFile = rec.fStopOnMissingTriggerFile;
529   fWriteAlignmentData    = rec.fWriteAlignmentData;
530   fWriteESDfriend        = rec.fWriteESDfriend;
531   fFillTriggerESD        = rec.fFillTriggerESD;
532
533   fCleanESD  = rec.fCleanESD;
534   fV0DCAmax  = rec.fV0DCAmax;
535   fV0CsPmin  = rec.fV0CsPmin;
536   fDmax      = rec.fDmax;
537   fZmax      = rec.fZmax;
538
539   fCosmicAlias                   = rec.fCosmicAlias;
540   fLaserAlias                    = rec.fLaserAlias;
541
542   fRunLocalReconstruction        = rec.fRunLocalReconstruction;
543   fRunTracking                   = rec.fRunTracking;
544   fFillESD                       = rec.fFillESD;
545   fDeleteRecPoints               = rec.fDeleteRecPoints;
546   fDeleteDigits                  = rec.fDeleteDigits;
547   fLoadCDB                       = rec.fLoadCDB;
548   fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
549   fGAliceFileName                = rec.fGAliceFileName;
550   fRawInput                      = rec.fRawInput;
551   fESDOutput                     = rec.fESDOutput;
552   fProofOutputFileName           = rec.fProofOutputFileName;
553   fProofOutputLocation           = rec.fProofOutputLocation;
554   fProofOutputDataset            = rec.fProofOutputDataset;
555   fProofOutputArchive            = rec.fProofOutputArchive;
556   fEquipIdMap                    = rec.fEquipIdMap;
557   fFirstEvent                    = rec.fFirstEvent;
558   fLastEvent                     = rec.fLastEvent;
559   fNumberOfEventsPerFile         = rec.fNumberOfEventsPerFile;
560   fFractionFriends               = rec.fFractionFriends;
561
562   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
563     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
564   }
565
566   fLoadAlignFromCDB              = rec.fLoadAlignFromCDB;
567   fLoadAlignData                 = rec.fLoadAlignData;
568   fUseHLTData                    = rec.fUseHLTData;
569
570   delete fRunInfo; fRunInfo = NULL;
571   if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
572
573   fEventInfo                     = rec.fEventInfo;
574
575   delete fRunScalers; fRunScalers = NULL;
576   if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers); 
577
578   delete fCTPTimeParams; fCTPTimeParams = NULL;
579   if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
580   delete fCTPTimeAlign; fCTPTimeAlign = NULL;
581   if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
582
583   fRunLoader       = NULL;
584   fRawReader       = NULL;
585   fParentRawReader = NULL;
586
587   fRecoParam = rec.fRecoParam;
588
589   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
590     fUpgradeMask[iDet] = kFALSE;
591     delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
592     delete fLoader[iDet]; fLoader[iDet] = NULL;
593     delete fTracker[iDet]; fTracker[iDet] = NULL;
594   }
595   
596   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
597     fQACycles[iDet] = rec.fQACycles[iDet];
598     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
599   } 
600
601   delete fSPDTrackleter; fSPDTrackleter = NULL;
602     
603   delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
604   if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
605   delete fDiamondProfile; fDiamondProfile = NULL;
606   if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
607   delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
608   if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
609
610   delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
611   if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
612   //
613   delete fAlias2Trigger; fAlias2Trigger = NULL;
614   if (rec.fAlias2Trigger) fAlias2Trigger = (THashList*)((rec.fAlias2Trigger)->Clone());
615
616   delete fGRPData; fGRPData = NULL;
617   //  if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
618   if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
619
620   delete fAlignObjArray; fAlignObjArray = NULL;
621
622   fCDBUri        = "";
623   fQARefUri      = rec.fQARefUri;
624   fSpecCDBUri.Delete();
625   fCheckRecoCDBvsSimuCDB.Delete();
626   //
627   for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
628     if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
629   }
630   //
631   fInitCDBCalled               = rec.fInitCDBCalled;
632   fCDBSnapshotMode             = rec.fCDBSnapshotMode;
633   fSetRunNumberFromDataCalled  = rec.fSetRunNumberFromDataCalled;
634   fQADetectors                 = rec.fQADetectors;
635   fQATasks                     = rec.fQATasks; 
636   fRunQA                       = rec.fRunQA;  
637   fRunGlobalQA                 = rec.fRunGlobalQA;
638   fSameQACycle                 = rec.fSameQACycle;
639   fInitQACalled                = rec.fInitQACalled;
640   fWriteQAExpertData           = rec.fWriteQAExpertData;
641   fRunPlaneEff                 = rec.fRunPlaneEff;
642   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
643   fESDpid  = NULL;
644   fesd     = NULL;
645   fhltesd  = NULL;
646   fesdf    = NULL;
647   ffile    = NULL;
648   ffileF   = NULL;
649   ftree    = NULL;
650   ftreeF   = NULL;
651   fhlttree = NULL;
652   ftVertexer = NULL;
653   fIsNewRunLoader = rec.fIsNewRunLoader;
654   fRunAliEVE = kFALSE;
655   fChain = NULL;
656   fNall = 0;
657   fNspecie = 0;
658   fSspecie = 0;
659   fNhighPt = 0;
660   fShighPt = 0;
661   //
662   fTreeBuffSize = rec.fTreeBuffSize;
663   fMemCountESD = 0;
664   fMemCountESDF = 0;
665   fMemCountESDHLT = 0;
666   //
667   fUpgradeModule="";
668   fAnalysisMacro = rec.fAnalysisMacro;
669   fAnalysis = 0;
670   fRecoHandler = 0;
671   fDeclTriggerClasses = rec.fDeclTriggerClasses;
672
673   return *this;
674 }
675
676 //_____________________________________________________________________________
677 AliReconstruction::~AliReconstruction()
678 {
679 // clean up
680
681   CleanUp();
682   if (fListOfCosmicTriggers) {
683     fListOfCosmicTriggers->Delete();
684     delete fListOfCosmicTriggers;
685   }
686   if (fAlias2Trigger) {
687     fAlias2Trigger->Delete();
688     delete fAlias2Trigger;
689   }
690   delete fGRPData;
691   delete fRunScalers;
692   delete fCTPTimeParams;
693   delete fCTPTimeAlign;
694   fOptions.Delete();
695   if (fAlignObjArray) {
696     fAlignObjArray->Delete();
697     delete fAlignObjArray;
698   }
699   fSpecCDBUri.Delete();
700   fCheckRecoCDBvsSimuCDB.Delete();
701   AliCodeTimer::Instance()->Print();
702 }
703
704 //_____________________________________________________________________________
705 void AliReconstruction::InitQA()
706 {
707   //Initialize the QA and start of cycle 
708   AliCodeTimerAuto("",0);
709   
710   if (fInitQACalled) return;
711   fInitQACalled = kTRUE;
712   
713   if (fGRPData) AliQADataMaker::SetCloningRequest( fGRPData->GetQATrigClasses(), fGRPData->GetQACloningRequest());
714
715
716   AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ; 
717   qam->SetSaveData(kTRUE); 
718   qam->SetCycleLength(AliQAv1::kITS, 5) ; 
719   if (fWriteQAExpertData)
720     qam->SetWriteExpert() ; 
721  
722   if (qam->IsDefaultStorageSet()) {
723     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
724     AliWarning("Default QA reference storage has been already set !");
725     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
726     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
727     fQARefUri = qam->GetDefaultStorage()->GetURI();
728   } else {
729     if (fQARefUri.Length() > 0) {
730         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
731         AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
732         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
733       } else {
734         fQARefUri="local://$ALICE_ROOT/QAref";
735         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
736         AliWarning("Default QA refeference storage not yet set !!!!");
737         AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
738         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
739                 
740       }
741     qam->SetDefaultStorage(fQARefUri);
742   }
743   
744   if (fRunQA) {
745   qam->SetActiveDetectors(fQADetectors) ;
746   qam->SetActiveOnlineDetectors(fRunInfo->GetActiveDetectors());
747     
748   for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
749     qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;  
750     qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
751   }
752   if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
753     fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
754   qam->SetTasks(fQATasks) ; 
755   qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ; 
756   }
757   if (fRunGlobalQA) {
758     Bool_t sameCycle = kFALSE ;
759     AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
760     AliInfo(Form("Initializing the global QA data maker"));
761     if (IsInTasks(AliQAv1::kRECPOINTS)) {
762       qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
763       TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
764       AliTracker::SetResidualsArray(arr);
765       sameCycle = kTRUE ; 
766     }
767     if (IsInTasks(AliQAv1::kESDS)) {
768       qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ; 
769       qadm->Init(AliQAv1::kESDS);
770     }
771   }
772     AliSysInfo::AddStamp("InitQA") ; 
773 }
774
775 //_____________________________________________________________________________
776 void AliReconstruction::MergeQA(const char *fileName)
777 {
778   //Initialize the QA and start of cycle 
779   AliCodeTimerAuto("",0) ;
780   AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ; 
781   AliSysInfo::AddStamp("MergeQA") ; 
782 }
783   
784 //_____________________________________________________________________________
785 void AliReconstruction::InitCDB()
786 {
787 // activate a default CDB storage
788 // First check if we have any CDB storage set, because it is used 
789 // to retrieve the calibration and alignment constants
790   AliCodeTimerAuto("",0);
791
792   if (fInitCDBCalled) return;
793   fInitCDBCalled = kTRUE;
794
795   AliCDBManager* man = AliCDBManager::Instance();
796   if (man->IsDefaultStorageSet())
797   {
798     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
799     AliWarning("Default CDB storage has been already set !");
800     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
801     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
802     fCDBUri = man->GetDefaultStorage()->GetURI();
803   }
804   else {
805     if (fCDBUri.Length() > 0) 
806     {
807         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
808         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
809         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
810         man->SetDefaultStorage(fCDBUri);
811     } 
812     else if (!man->GetRaw()){
813         fCDBUri="local://$ALICE_ROOT/OCDB";
814         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
815         AliWarning("Default CDB storage not yet set !!!!");
816         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
817         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
818         man->SetDefaultStorage(fCDBUri);
819     }
820     else {    
821         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
822         AliWarning("Default storage will be set after setting the Run Number!!!");
823         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");                    
824     }
825   }
826
827   // Now activate the detector specific CDB storage locations
828   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
829     TObject* obj = fSpecCDBUri[i];
830     if (!obj) continue;
831     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
832     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
833     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
834     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
835   }
836   AliSysInfo::AddStamp("InitCDB");
837 }
838
839 //_____________________________________________________________________________
840 void AliReconstruction::SetCDBSnapshotMode(const char* snapshotFileName) {
841     if (!AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName))
842       AliFatal("Setting CDB snapshot mode failed.");
843     fCDBSnapshotMode = kTRUE;
844 }
845
846 //_____________________________________________________________________________
847 void AliReconstruction::SetDefaultStorage(const char* uri) {
848 // Store the desired default CDB storage location
849 // Activate it later within the Run() method
850
851   fCDBUri = uri;
852
853 }
854
855 //_____________________________________________________________________________
856 void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
857   // Store the desired default CDB storage location
858   // Activate it later within the Run() method
859   
860   fQARefUri = uri;
861   AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
862   
863 }
864
865 //_____________________________________________________________________________
866 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
867 // Store a detector-specific CDB storage location
868 // Activate it later within the Run() method
869
870   AliCDBPath aPath(calibType);
871   if(!aPath.IsValid()){
872         // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
873         for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
874                 if(!strcmp(calibType, fgkDetectorName[iDet])) {
875                         aPath.SetPath(Form("%s/*", calibType));
876                         AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
877                         break;
878                 }
879         }
880         if(!aPath.IsValid()){
881                 AliError(Form("Not a valid path or detector: %s", calibType));
882                 return;
883         }
884   }
885
886 //  // check that calibType refers to a "valid" detector name
887 //  Bool_t isDetector = kFALSE;
888 //  for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
889 //    TString detName = fgkDetectorName[iDet];
890 //    if(aPath.GetLevel0() == detName) {
891 //      isDetector = kTRUE;
892 //      break;
893 //    }
894 //  }
895 //
896 //  if(!isDetector) {
897 //      AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
898 //      return;
899 //  }
900
901   TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
902   if (obj) fSpecCDBUri.Remove(obj);
903   fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
904
905 }
906
907 //_____________________________________________________________________________
908 void AliReconstruction::AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment) 
909 {
910   // require the cdb item to be the same in the rec as in the sim
911   // Activate it later within the Run() method
912   TString newent = cdbpath;
913   if (newent.IsNull()) return;
914   TIter nextit(&fCheckRecoCDBvsSimuCDB);
915   TNamed* cdbent=0;
916   while ((cdbent=(TNamed*)nextit())) {
917     TString str = cdbent->GetName();
918     if (str==newent) {
919       AliInfo(Form("%s is already in the list to check",cdbpath));
920       return;
921     }
922   }
923   fCheckRecoCDBvsSimuCDB.AddLast(new TNamed(cdbpath,comment));
924   //
925 }
926
927 //_____________________________________________________________________________
928 void AliReconstruction::RemCheckRecoCDBvsSimuCDB(const char* cdbpath) 
929 {
930   // require the cdb item to be the same in the rec as in the sim
931   // Activate it later within the Run() method
932   TString newent = cdbpath;
933   if (newent.IsNull()) return;
934   TIter nextit(&fCheckRecoCDBvsSimuCDB);
935   TNamed* cdbent=0;
936   while ((cdbent=(TNamed*)nextit())) {
937     TString str = cdbent->GetName();
938     if (str==newent) {
939       AliInfo(Form("Removing %s from the list to check",cdbpath));
940       delete fCheckRecoCDBvsSimuCDB.Remove(cdbent);
941       fCheckRecoCDBvsSimuCDB.Compress();
942       return;
943     }
944   }
945   AliInfo(Form("%s is not in the list to check",cdbpath));
946   //
947 }
948
949 //_____________________________________________________________________________
950 Bool_t AliReconstruction::SetRunNumberFromData()
951 {
952   // The method is called in Run() in order
953   // to set a correct run number.
954   // In case of raw data reconstruction the
955   // run number is taken from the raw data header
956
957   if (fSetRunNumberFromDataCalled) return kTRUE;
958   fSetRunNumberFromDataCalled = kTRUE;
959   
960   AliCDBManager* man = AliCDBManager::Instance();
961   if(fRawReader) {
962     if(fRawReader->NextEvent()) {
963       if(man->GetRun() > 0) {
964         AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
965       } 
966       man->SetRun(fRawReader->GetRunNumber());
967       GetEventInfo();
968       fRawReader->RewindEvents();
969     }
970     else {
971       if(man->GetRun() > 0) {
972         AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
973       }
974       else {
975         AliWarning("Neither raw events nor settings in AliCDBManager are found !");
976         return kFALSE;
977       }
978     }
979   }
980   else {
981     AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
982     if (!rl) {
983       AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
984       return kFALSE;
985     }
986     else {
987       rl->LoadHeader();
988       // read run number from gAlice
989       if(rl->GetHeader()) {
990         man->SetRun(rl->GetHeader()->GetRun());
991         rl->UnloadHeader();
992         delete rl;
993       }
994       else {
995         AliError("Neither run-loader header nor RawReader objects are found !");
996         delete rl;
997         return kFALSE;
998       }
999     }
1000   }
1001
1002   man->Print();  
1003   
1004   return kTRUE;
1005 }
1006
1007 //_____________________________________________________________________________
1008 void AliReconstruction::SetCDBLock() {
1009   // Set CDB lock: from now on it is forbidden to reset the run number
1010   // or the default storage or to activate any further storage!
1011   
1012   AliCDBManager::Instance()->SetLock(1);
1013 }
1014
1015 //_____________________________________________________________________________
1016 void AliReconstruction::MatchUpgradeDetector() {
1017   // Translates detector name in a boolean.
1018   // The boolean is used in GetReconstructor to load the 
1019   // upgrade reconstructor instead of the standard one.
1020    for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1021     if(fUpgradeModule.Contains(fgkDetectorName[iDet])) fUpgradeMask[iDet]=kTRUE;
1022    }
1023 }
1024 //_____________________________________________________________________________
1025 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
1026 {
1027   // Read the alignment objects from CDB.
1028   // Each detector is supposed to have the
1029   // alignment objects in DET/Align/Data CDB path.
1030   // All the detector objects are then collected,
1031   // sorted by geometry level (starting from ALIC) and
1032   // then applied to the TGeo geometry.
1033   // Finally an overlaps check is performed.
1034
1035   // Load alignment data from CDB and fill fAlignObjArray 
1036   if(fLoadAlignFromCDB){
1037         
1038     TString detStr = detectors;
1039     TString loadAlObjsListOfDets = "";
1040     
1041     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1042       if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1043       if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
1044       
1045       if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
1046       {
1047         loadAlObjsListOfDets += fgkDetectorName[iDet];
1048         loadAlObjsListOfDets += " ";
1049       }
1050     } // end loop over detectors
1051     
1052     if(AliGeomManager::GetNalignable("GRP") != 0)
1053       loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
1054     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
1055   }else{
1056     // Check if the array with alignment objects was
1057     // provided by the user. If yes, apply the objects
1058     // to the present TGeo geometry
1059     if (fAlignObjArray) {
1060       if (gGeoManager && gGeoManager->IsClosed()) {
1061         if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
1062           AliError("The misalignment of one or more volumes failed!"
1063                    "Compare the list of simulated detectors and the list of detector alignment data!");
1064           return kFALSE;
1065         }
1066       }
1067       else {
1068         AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
1069         return kFALSE;
1070       }
1071     }
1072   }
1073   
1074   if (fAlignObjArray) {
1075     fAlignObjArray->Delete();
1076     delete fAlignObjArray; fAlignObjArray=NULL;
1077   }
1078
1079   return kTRUE;
1080 }
1081
1082 //_____________________________________________________________________________
1083 void AliReconstruction::SetGAliceFile(const char* fileName)
1084 {
1085 // set the name of the galice file
1086
1087   fGAliceFileName = fileName;
1088 }
1089
1090 //_____________________________________________________________________________
1091 void AliReconstruction::SetInput(const char* input) 
1092 {
1093   // In case the input string starts with 'mem://', we run in an online mode
1094   // and AliRawReaderDateOnline object is created. In all other cases a raw-data
1095   // file is assumed. One can give as an input:
1096   // mem://: - events taken from DAQ monitoring libs online
1097   //  or
1098   // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
1099   if (input) fRawInput = input;
1100 }
1101
1102 //_____________________________________________________________________________
1103 void AliReconstruction::SetOutput(const char* output) 
1104 {
1105   // Set the output ESD filename
1106   // 'output' is a normalt ROOT url
1107   // The method is used in case of raw-data reco with PROOF
1108   if (output) fESDOutput = output;
1109 }
1110
1111 //_____________________________________________________________________________
1112 void AliReconstruction::SetOption(const char* detector, const char* option)
1113 {
1114 // set options for the reconstruction of a detector
1115
1116   TObject* obj = fOptions.FindObject(detector);
1117   if (obj) fOptions.Remove(obj);
1118   fOptions.Add(new TNamed(detector, option));
1119 }
1120
1121 //_____________________________________________________________________________
1122 void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
1123 {
1124   // Set custom reconstruction parameters for a given detector
1125   // Single set of parameters for all the events
1126
1127   // First check if the reco-params are global
1128   if(!strcmp(detector, "GRP")) {
1129     par->SetAsDefault();
1130     fRecoParam.AddDetRecoParam(kNDetectors,par);
1131     return;
1132   }
1133
1134   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1135     if(!strcmp(detector, fgkDetectorName[iDet])) {
1136       par->SetAsDefault();
1137       fRecoParam.AddDetRecoParam(iDet,par);
1138       break;
1139     }
1140   }
1141
1142 }
1143
1144 //_____________________________________________________________________________
1145 Bool_t AliReconstruction::InitGRP() {
1146   //------------------------------------
1147   // Initialization of the GRP entry 
1148   //------------------------------------
1149   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
1150
1151   if (entry) {
1152
1153     TMap* m = dynamic_cast<TMap*>(entry->GetObject());  // old GRP entry
1154
1155     if (m) {
1156        AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1157        m->Print();
1158        fGRPData = new AliGRPObject();
1159        fGRPData->ReadValuesFromMap(m);
1160     }
1161
1162     else {
1163        AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1164        fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject());  // new GRP entry
1165        entry->SetOwner(0);
1166     }
1167
1168     //    FIX ME: The unloading of GRP entry is temporarily disabled
1169     //    because ZDC and VZERO are using it in order to initialize
1170     //    their reconstructor objects. In the future one has to think
1171     //    of propagating AliRunInfo to the reconstructors.
1172     //    AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
1173   }
1174
1175   if (!fGRPData) {
1176      AliError("No GRP entry found in OCDB!");
1177      return kFALSE;
1178   }
1179
1180   TString lhcState = fGRPData->GetLHCState();
1181   if (lhcState==AliGRPObject::GetInvalidString()) {
1182     AliError("GRP/GRP/Data entry:  missing value for the LHC state ! Using UNKNOWN");
1183     lhcState = "UNKNOWN";
1184   }
1185
1186   TString beamType = fGRPData->GetBeamType();
1187   if (beamType==AliGRPObject::GetInvalidString()) {
1188     AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
1189     beamType = "UNKNOWN";
1190   }
1191
1192   Float_t beamEnergy = fGRPData->GetBeamEnergy();
1193   if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
1194     AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
1195     beamEnergy = 0;
1196   }
1197
1198   TString runType = fGRPData->GetRunType();
1199   if (runType==AliGRPObject::GetInvalidString()) {
1200     AliError("GRP/GRP/Data entry:  missing value for the run type ! Using UNKNOWN");
1201     runType = "UNKNOWN";
1202   }
1203
1204   Int_t activeDetectors = fGRPData->GetDetectorMask();
1205   if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
1206     AliError("GRP/GRP/Data entry:  missing value for the detector mask ! Using 1074790399");
1207     activeDetectors = 1074790399;
1208   }
1209   AliDebug(1, Form("activeDetectors = %d", activeDetectors));
1210
1211   fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
1212   fRunInfo->Dump();
1213
1214
1215   // Process the list of active detectors
1216   if (activeDetectors) {
1217     UInt_t detMask = activeDetectors;
1218     AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1219     fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1220     AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1221     fRunTracking = MatchDetectorList(fRunTracking,detMask);
1222     fFillESD = MatchDetectorList(fFillESD,detMask);
1223     fQADetectors = MatchDetectorList(fQADetectors,detMask);
1224     AliInfo(Form("fQADetectors=%s",fQADetectors.Data()));
1225     fDeleteRecPoints = MatchDetectorList(fDeleteRecPoints,detMask);
1226     fDeleteDigits    = MatchDetectorList(fDeleteDigits,detMask);
1227     fLoadCDB.Form("%s %s %s %s",
1228                   fRunLocalReconstruction.Data(),
1229                   fRunTracking.Data(),
1230                   fFillESD.Data(),
1231                   fQADetectors.Data());
1232     fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
1233     if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
1234         !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
1235         !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
1236       // switch off the vertexer
1237       AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
1238       fRunVertexFinder = kFALSE;
1239       fRunMultFinder = kFALSE;
1240     }
1241     if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1242       // switch off the reading of CTP raw-data payload
1243       if (fFillTriggerESD) {
1244         AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1245         fFillTriggerESD = kFALSE;
1246       }
1247     }
1248   }
1249
1250   AliInfo("===================================================================================");
1251   AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1252   AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1253   AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
1254   AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
1255   AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
1256   AliInfo("===================================================================================");
1257
1258   //*** Dealing with the magnetic field map
1259   if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
1260     if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
1261       AliInfo("ExpertMode!!! GRP information will be ignored !");
1262       AliInfo("ExpertMode!!! Running with the externally locked B field !");
1263     }
1264     else {
1265       AliInfo("Destroying existing B field instance!");
1266       delete TGeoGlobalMagField::Instance();
1267     }    
1268   }
1269   if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
1270     // Construct the field map out of the information retrieved from GRP.
1271     Bool_t ok = kTRUE;
1272     // L3
1273     Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1274     if (l3Current == AliGRPObject::GetInvalidFloat()) {
1275       AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
1276       ok = kFALSE;
1277     }
1278     
1279     Char_t l3Polarity = fGRPData->GetL3Polarity();
1280     if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1281       AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
1282       ok = kFALSE;
1283     }
1284
1285     // Dipole
1286     Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1287     if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1288       AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
1289       ok = kFALSE;
1290     }
1291
1292     Char_t diPolarity = fGRPData->GetDipolePolarity();
1293     if (diPolarity == AliGRPObject::GetInvalidChar()) {
1294       AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
1295       ok = kFALSE;
1296     }
1297
1298     // read special bits for the polarity convention and map type
1299     Int_t  polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
1300     Bool_t uniformB = fGRPData->IsUniformBMap();
1301
1302     if (ok) { 
1303       AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1), 
1304                                              TMath::Abs(diCurrent) * (diPolarity ? -1:1), 
1305                                              polConvention,uniformB,beamEnergy, beamType.Data());
1306       if (fld) {
1307         TGeoGlobalMagField::Instance()->SetField( fld );
1308         TGeoGlobalMagField::Instance()->Lock();
1309         AliInfo("Running with the B field constructed out of GRP !");
1310       }
1311       else AliFatal("Failed to create a B field map !");
1312     }
1313     else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1314   }
1315   
1316   //*** Get the diamond profiles from OCDB
1317   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1318   if (entry) {
1319     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1320   } else {
1321      AliError("No SPD diamond profile found in OCDB!");
1322   }
1323
1324   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1325   if (entry) {
1326     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1327   } else {
1328      AliError("No diamond profile found in OCDB!");
1329   }
1330
1331   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1332   if (entry) {
1333     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());  
1334   } else {
1335      AliError("No TPC diamond profile found in OCDB!");
1336   }
1337
1338   return kTRUE;
1339
1340
1341 //_____________________________________________________________________________
1342 Bool_t AliReconstruction::LoadCDB()
1343 {
1344   // Load CDB entries for all active detectors.
1345   // By default we load all the entries in <det>/Calib
1346   // folder.
1347
1348   AliCodeTimerAuto("",0);
1349
1350   AliCDBManager::Instance()->Get("GRP/CTP/Config");
1351
1352   AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
1353
1354   TString detStr = fLoadCDB;
1355   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1356     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1357     AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1358     AliCDBManager::Instance()->GetAll(Form("%s/Trigger/*",fgkDetectorName[iDet]));
1359   }
1360
1361   // Temporary fix - one has to define the correct policy in order
1362   // to load the trigger OCDB entries only for the detectors that
1363   // in the trigger or that are needed in order to put correct
1364   // information in ESD
1365   AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
1366   AliCDBManager::Instance()->GetAll("HLT/*/*");
1367
1368   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1369   if (entry) {
1370     fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1371     entry->SetOwner(0);
1372   }
1373   //
1374   if (!fListOfCosmicTriggers) {
1375     AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will rely on aliases if defined");
1376   }
1377
1378
1379   return kTRUE;
1380 }
1381 //_____________________________________________________________________________
1382 Bool_t AliReconstruction::LoadTriggerScalersCDB()
1383 {
1384   // Load CTP scalers from OCDB.
1385   // The scalers are checked for consistency.
1386
1387   AliCodeTimerAuto("",0);
1388
1389   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
1390
1391   if (entry) { 
1392    
1393        AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1394        fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1395        entry->SetOwner(0);
1396        if (fRunScalers && (fRunScalers->CorrectScalersOverflow() == 0)) AliInfo("32bit Trigger counters corrected for overflow");
1397
1398   }
1399   return kTRUE;
1400 }
1401 //_____________________________________________________________________________
1402 Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
1403 {
1404   // Load CTP timing information (alignment)
1405   // from OCDB.
1406
1407   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
1408   if (!entry) return kFALSE;
1409
1410   AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
1411   fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
1412   entry->SetOwner(0);
1413
1414   AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
1415   if (!entry2) return kFALSE;
1416
1417   AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
1418   fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
1419   entry2->SetOwner(0);
1420
1421   return kTRUE;
1422 }
1423
1424 //_____________________________________________________________________________
1425 Bool_t AliReconstruction::ReadIntensityInfoCDB()
1426 {
1427   // Load LHC DIP data
1428   AliCDBEntry* entry    = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
1429   AliCDBEntry* entryCTP = AliCDBManager::Instance()->Get("GRP/CTP/Config");
1430   //
1431   if (!entry || !entryCTP) {
1432     AliError(Form("Failed to extract CDB objects GRP/GRP/LHCData: %p or GRP/CTP/Config: %p",entry,entryCTP));
1433     return kFALSE;
1434   }
1435   // extract BC masks
1436   enum {kA,kB,kC,kE,kNMasks};
1437   AliTriggerConfiguration* conf = (AliTriggerConfiguration*)entryCTP->GetObject();
1438   const TObjArray& clArr = conf->GetClasses();
1439   TObjArray masks(kNMasks);
1440   TIter next(&clArr);
1441   AliTriggerClass* trClass = 0;
1442   int nFound = 0;
1443   masks.SetOwner(kFALSE);
1444   //
1445   while ( (trClass=(AliTriggerClass*)next()) ) {
1446     TString trName = trClass->GetName();
1447     int ind = trName.Index("-"); // prefix in front of A,B,C,E
1448     if (ind<1) continue;   // anomaly
1449     //
1450     trName = trName.Data() + ind;
1451     AliTriggerBCMask* bcMask = trClass->GetBCMask();
1452     if (!bcMask) continue;
1453     UInt_t which = 0;
1454     if      (trName.BeginsWith("-A-"))  which |= 0x1<<kA;
1455     else if (trName.BeginsWith("-B-"))  which |= 0x1<<kB;
1456     else if (trName.BeginsWith("-C-"))  which |= 0x1<<kC;
1457     else if (trName.BeginsWith("-E-"))  which |= 0x1<<kE;
1458     else if (trName.BeginsWith("-AC-")) which |= (0x1<<kA) | (0x1<<kC);
1459     else if (trName.BeginsWith("-CA-")) which |= (0x1<<kA) | (0x1<<kC);
1460     else { AliWarning(Form("Unknown trigger type %s\n",trClass->GetName())); continue;}
1461     //
1462     for (int ip=kNMasks;ip--;) {
1463       if ( !(which&(0x1<<ip)) || masks[ip] ) continue; // does not match or already done
1464       masks[ip] = (TObject*)bcMask;
1465       nFound++;
1466     }
1467     if (nFound==kNMasks) break;
1468   }  
1469   //  
1470   AliInfo("Reading mean bunch intensities from GRP/GRP/LHCData");
1471   AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
1472   //
1473   for (int ib=2;ib--;) {
1474     double intI,intNI;
1475     if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI,&masks)>=0)) {
1476       fBeamInt[ib][0] = intI;
1477       fBeamInt[ib][1] = intNI;  
1478       AliInfo(Form("Mean intensity for beam %d: Interacting:%.2e Non-Interacting:%.2e",ib,intI,intNI));
1479     }
1480   }
1481   return kTRUE;
1482   //
1483 }
1484
1485
1486 //_____________________________________________________________________________
1487 Bool_t AliReconstruction::Run(const char* input)
1488 {
1489   // Run Run Run
1490   AliCodeTimerAuto("",0);
1491
1492   InitRun(input);
1493   if (GetAbort() != TSelector::kContinue) return kFALSE;
1494
1495   TChain *chain = NULL;
1496   if (fRawReader && (chain = fRawReader->GetChain())) {
1497     ProcessTriggerAliases();
1498     Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
1499     // Proof mode
1500     if (gProof) {
1501       // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
1502       gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
1503
1504       if (gGrid)
1505         gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
1506
1507       TMessage::EnableSchemaEvolutionForAll(kTRUE);
1508       gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
1509
1510       gProof->AddInput(this);
1511
1512       if (!ParseOutput()) return kFALSE;
1513
1514       gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
1515       chain->SetProof();
1516       chain->Process("AliReconstruction","",nEntries,fFirstEvent);
1517     }
1518     else {
1519       chain->Process(this,"",nEntries,fFirstEvent);
1520     }
1521   }
1522   else {
1523     Begin(NULL);
1524     if (GetAbort() != TSelector::kContinue) return kFALSE;
1525     SlaveBegin(NULL);
1526     if (GetAbort() != TSelector::kContinue) return kFALSE;
1527     //******* The loop over events
1528     AliInfo("Starting looping over events");
1529     Int_t iEvent = 0;
1530     while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1531            (fRawReader && fRawReader->NextEvent())) {
1532       //
1533       // check if process has enough resources 
1534       if (!HasEnoughResources(iEvent)) break;
1535       if (!ProcessEvent(iEvent)) {
1536         Abort("ProcessEvent",TSelector::kAbortFile);
1537         return kFALSE;
1538       }
1539       CleanProcessedEvent();
1540       iEvent++;
1541     }
1542     if (!iEvent) AliWarning("No events passed trigger selection");
1543     SlaveTerminate();
1544     if (GetAbort() != TSelector::kContinue) return kFALSE;
1545     Terminate();
1546     if (GetAbort() != TSelector::kContinue) return kFALSE;
1547   }
1548
1549   return kTRUE;
1550 }
1551
1552 //_____________________________________________________________________________
1553 void AliReconstruction::InitRawReader(const char* input)
1554 {
1555   // Init raw-reader and
1556   // set the input in case of raw data
1557
1558   AliCodeTimerAuto("",0);
1559
1560   if (input) fRawInput = input;
1561   fRawReader = AliRawReader::Create(fRawInput.Data());
1562   if (!fRawReader) {
1563     if (fRawInput.IsNull()) {
1564       AliInfo("Reconstruction will run over digits");
1565     }
1566     else {
1567       AliFatal("Can not create raw-data reader ! Exiting..."); 
1568     }
1569   }
1570
1571   if (!fEquipIdMap.IsNull() && fRawReader)
1572     fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1573
1574   if (!fUseHLTData.IsNull()) {
1575     // create the RawReaderHLT which performs redirection of HLT input data for
1576     // the specified detectors
1577     AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1578     if (pRawReader) {
1579       fParentRawReader=fRawReader;
1580       fRawReader=pRawReader;
1581     } else {
1582       AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1583     }
1584   }
1585   AliSysInfo::AddStamp("CreateRawReader");
1586 }
1587
1588 //_____________________________________________________________________________
1589 void AliReconstruction::InitRun(const char* input)
1590 {
1591   // Initialization of raw-reader,
1592   // run number, CDB etc.
1593   AliCodeTimerAuto("",0);
1594   AliSysInfo::AddStamp("Start");
1595
1596   // Initialize raw-reader if any
1597   InitRawReader(input);
1598
1599   // Initialize the CDB storage
1600   InitCDB();
1601
1602   // Set run number in CDBManager (if it is not already set by the user)
1603   if (!SetRunNumberFromData()) {
1604     Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1605     return;
1606   }
1607
1608   // Set CDB lock: from now on it is forbidden to reset the run number
1609   // or the default storage or to activate any further storage!
1610   SetCDBLock();
1611   //
1612 }
1613
1614 //_____________________________________________________________________________
1615 void AliReconstruction::Begin(TTree *)
1616 {
1617   // Initialize AlReconstruction before
1618   // going into the event loop
1619   // Should follow the TSelector convention
1620   // i.e. initialize only the object on the client side
1621   AliCodeTimerAuto("",0);
1622
1623   AliReconstruction *reco = NULL;
1624   if (fInput) {
1625     if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1626       *this = *reco;
1627     }
1628     AliSysInfo::AddStamp("ReadInputInBegin");
1629   }
1630
1631   // Import ideal TGeo geometry and apply misalignment
1632   if (!AliGeomManager::GetGeometry()) {
1633     TString geom(gSystem->DirName(fGAliceFileName));
1634     geom += "/geometry.root";
1635     AliGeomManager::LoadGeometry(geom.Data());
1636     if (!gGeoManager) {
1637       Abort("LoadGeometry", TSelector::kAbortProcess);
1638       return;
1639     }
1640     AliSysInfo::AddStamp("LoadGeom");
1641     TString detsToCheck=fRunLocalReconstruction;
1642     if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1643       Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1644       return;
1645     }
1646     AliSysInfo::AddStamp("CheckGeom");
1647   }
1648
1649   Bool_t toCDBSnapshot=kFALSE;
1650   TString snapshotFileOut(""); // we could use fSnapshotFileName if we are not interested
1651   // in reading from and writing to a snapshot file at the same time
1652   if(TString(getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
1653       toCDBSnapshot=kTRUE;
1654       //fFromCDBSnapshot=kFALSE;
1655       TString snapshotFile(getenv("OCDB_SNAPSHOT_FILENAME"));
1656       if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
1657           snapshotFileOut = snapshotFile;
1658       else
1659           snapshotFileOut="OCDB.root";
1660   }
1661
1662   TString detStr(fLoadAlignData);
1663   if (!toCDBSnapshot) {
1664     if (!MisalignGeometry(fLoadAlignData)) {
1665       Abort("MisalignGeometry", TSelector::kAbortProcess);
1666       return;
1667     }
1668   } else {
1669     // when creating the snapshot, load the CDB alignment objects without applying them to the geometry
1670     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1671       if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1672       if (!strcmp(fgkDetectorName[iDet],"HLT")) continue;
1673       if (AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
1674       {
1675         TString detAlignPath = fgkDetectorName[iDet];
1676         detAlignPath += "/Align/Data";
1677         AliCDBManager::Instance()->Get(detAlignPath);
1678       }
1679     } // end loop over detectors
1680     if(AliGeomManager::GetNalignable("GRP") != 0)
1681       AliCDBManager::Instance()->Get("GRP/Align/Data");
1682   }
1683
1684   const TMap* cdbCache = AliCDBManager::Instance()->GetEntryCache();
1685   if(!toCDBSnapshot) {
1686     if(cdbCache->Contains("GRP/Geometry/Data"))
1687       AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1688     AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1689   }
1690   AliSysInfo::AddStamp("MisalignGeom");
1691
1692   if (!InitGRP()) {
1693     Abort("InitGRP", TSelector::kAbortProcess);
1694     return;
1695   }
1696   AliSysInfo::AddStamp("InitGRP");
1697   if(!toCDBSnapshot)
1698       if(cdbCache->Contains("GRP/Calib/CosmicTriggers"))
1699           AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1700
1701   if(!fCDBSnapshotMode || toCDBSnapshot){
1702       if (!LoadCDB()) {
1703           Abort("LoadCDB", TSelector::kAbortProcess);
1704           return;
1705       }
1706       AliSysInfo::AddStamp("LoadCDB"); 
1707   }
1708
1709   if (!LoadTriggerScalersCDB()) {
1710     Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1711     return;
1712   }
1713   AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1714
1715   if (!LoadCTPTimeParamsCDB()) {
1716     Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
1717     return;
1718   }
1719   AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
1720
1721   if (!ReadIntensityInfoCDB()) {
1722     Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
1723     return;
1724   }
1725   AliSysInfo::AddStamp("ReadIntensityInfoCDB");
1726
1727   // Read the reconstruction parameters from OCDB
1728   if (!InitRecoParams()) {
1729     AliWarning("Not all detectors have correct RecoParam objects initialized");
1730   }
1731   AliSysInfo::AddStamp("InitRecoParams");
1732
1733   if(toCDBSnapshot)
1734   {
1735       AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
1736       exit(0);
1737   }
1738
1739   if (fInput && gProof) {
1740     if (reco) *reco = *this;
1741
1742     gGeoManager->SetName("Geometry");
1743     gProof->AddInputData(gGeoManager,kTRUE);
1744     gGeoManager = NULL;
1745     gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
1746     fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1747     AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1748     magFieldMap->SetName("MagneticFieldMap");
1749     gProof->AddInputData(magFieldMap,kTRUE);
1750     if (fAnalysis) {
1751       fAnalysis->SetName("Analysis");
1752       gProof->AddInputData(fAnalysis,kTRUE);
1753     }  
1754   }
1755
1756 }
1757
1758 //_____________________________________________________________________________
1759 void AliReconstruction::SlaveBegin(TTree*)
1760 {
1761   // Initialization related to run-loader,
1762   // vertexer, trackers, recontructors
1763   // In proof mode it is executed on the slave
1764   AliCodeTimerAuto("",0);
1765   TProofOutputFile *outProofFile = NULL;
1766   if (fInput) {
1767     if (AliDebugLevel() > 0) fInput->Print();
1768     if (AliDebugLevel() > 10) fInput->Dump();
1769     if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1770       *this = *reco;
1771     }
1772     if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1773       gGeoManager = tgeo;
1774       AliGeomManager::SetGeometry(tgeo);
1775     }
1776     if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1777       Int_t runNumber = -1;
1778       if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1779         AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1780         man->SetCacheFlag(kTRUE);
1781         man->SetLock(kTRUE);
1782         man->Print();
1783       }
1784     }
1785     if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1786       AliMagF *newMap = new AliMagF(*map);
1787       if (!newMap->LoadParameterization()) {
1788         Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
1789         return;
1790       }
1791       TGeoGlobalMagField::Instance()->SetField(newMap);
1792       TGeoGlobalMagField::Instance()->Lock();
1793     }
1794     if (!fAnalysis) {
1795        // Attempt to get the analysis manager from the input list
1796        fAnalysis = (AliAnalysisManager*)fInput->FindObject("Analysis");
1797        if (fAnalysis) AliInfo("==== Analysis manager retrieved from input list ====");
1798     }   
1799     if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
1800       fProofOutputFileName = outputFileName->GetTitle();
1801     if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
1802       fProofOutputLocation = outputLocation->GetTitle();
1803     if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
1804       fProofOutputDataset = kTRUE;
1805     if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
1806       fProofOutputArchive = archiveList->GetTitle();
1807     if (!fProofOutputFileName.IsNull() &&
1808         !fProofOutputLocation.IsNull() &&
1809         fProofOutputArchive.IsNull()) {
1810       if (!fProofOutputDataset) {
1811         outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
1812         outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
1813       }
1814       else {
1815         outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
1816       }
1817       if (AliDebugLevel() > 0) outProofFile->Dump();
1818       fOutput->Add(outProofFile);
1819     }
1820     AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1821   }
1822   // Check if analysis was requested in the reconstruction event loop
1823   if (!fAnalysis) {
1824     // Attempt to connect in-memory singleton
1825     fAnalysis = AliAnalysisManager::GetAnalysisManager();
1826     if (fAnalysis) AliInfo(Form("==== Analysis manager <%s> found in memory ====", fAnalysis->GetName()));
1827     // Check if an analysis macro was specified
1828     if (!fAnalysis && !fAnalysisMacro.IsNull()) {
1829       // Run specified analysis macro
1830       gROOT->ProcessLine(Form(".x %s",fAnalysisMacro.Data()));
1831       fAnalysis = AliAnalysisManager::GetAnalysisManager();
1832       if (!fAnalysis) AliError(Form("No analysis manager produced by analysis macro %s", fAnalysisMacro.Data()));
1833       else AliInfo(Form("==== Analysis manager <%s> produced by analysis macro <%s> ====", 
1834                         fAnalysis->GetName(), fAnalysisMacro.Data()));
1835     }
1836   }
1837   
1838   // get the run loader
1839   if (!InitRunLoader()) {
1840     Abort("InitRunLoader", TSelector::kAbortProcess);
1841     return;
1842   }
1843   AliSysInfo::AddStamp("LoadLoader");
1844  
1845   CheckRecoCDBvsSimuCDB();
1846
1847   ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1848
1849   // get trackers
1850   if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1851     Abort("CreateTrackers", TSelector::kAbortProcess);
1852     return;
1853   }      
1854   AliSysInfo::AddStamp("CreateTrackers");
1855
1856   // create the ESD output file and tree
1857   if (!outProofFile) {
1858     ffile = TFile::Open("AliESDs.root", "RECREATE");
1859     ffile->SetCompressionLevel(2);
1860     if (!ffile->IsOpen()) {
1861       Abort("OpenESDFile", TSelector::kAbortProcess);
1862       return;
1863     }
1864   }
1865   else {
1866     AliInfo(Form("Opening output PROOF file: %s/%s",
1867                  outProofFile->GetDir(), outProofFile->GetFileName()));
1868     if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1869       Abort(Form("Problems opening output PROOF file: %s/%s",
1870                  outProofFile->GetDir(), outProofFile->GetFileName()),
1871             TSelector::kAbortProcess);
1872       return;
1873     }
1874   }
1875
1876   ftree = new TTree("esdTree", "Tree with ESD objects");
1877   fesd = new AliESDEvent();
1878   fesd->CreateStdContent();
1879   // add a so far non-std object to the ESD, this will
1880   // become part of the std content
1881   fesd->AddObject(new AliESDHLTDecision);
1882
1883   fesd->WriteToTree(ftree);
1884   if (fWriteESDfriend) {
1885     ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
1886     ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
1887     fesdf  = new AliESDfriend();
1888     ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
1889     fesd->AddObject(fesdf);
1890     ffile->cd();
1891   }
1892   ftree->GetUserInfo()->Add(fesd);
1893
1894   fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1895   fhltesd = new AliESDEvent();
1896   fhltesd->CreateStdContent();
1897   // read the ESD template from CDB
1898   // HLT is allowed to put non-std content to its ESD, the non-std
1899   // objects need to be created before invocation of WriteToTree in
1900   // order to create all branches. Initialization is done from an
1901   // ESD layout template in CDB
1902   AliCDBManager* man = AliCDBManager::Instance();
1903   AliCDBEntry* hltESDConfig = man->Get("HLT/Calib/esdLayout");
1904   if(!hltESDConfig){
1905       AliError(Form("Error getting \"HLT/Calib/esdLayout\""));
1906       return;
1907   }
1908   AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1909   if (pESDLayout) {
1910       // init all internal variables from the list of objects
1911       pESDLayout->GetStdContent();
1912
1913       // copy content and create non-std objects
1914       *fhltesd=*pESDLayout;
1915       fhltesd->Reset();
1916   } else {
1917       AliError(Form("error setting hltEsd layout from \"HLT/Calib/esdLayout\": invalid object type"));
1918   }
1919
1920   fhltesd->WriteToTree(fhlttree);
1921   fhlttree->GetUserInfo()->Add(fhltesd);
1922
1923   ProcInfo_t procInfo;
1924   gSystem->GetProcInfo(&procInfo);
1925   AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
1926   
1927   // PID
1928   fESDpid = new AliESDpid();
1929
1930   //QA
1931   //Initialize the QA and start of cycle 
1932   if (fRunQA || fRunGlobalQA) 
1933     InitQA() ; 
1934
1935   //Initialize the Plane Efficiency framework
1936   if (fRunPlaneEff && !InitPlaneEff()) {
1937     Abort("InitPlaneEff", TSelector::kAbortProcess);
1938     return;
1939   }
1940
1941   if (strcmp(gProgName,"alieve") == 0)
1942     fRunAliEVE = InitAliEVE();
1943   // If we have an analysis manager, connect the AliRecoInputHandler here  
1944   if (fAnalysis) {
1945     if (!dynamic_cast<AliRecoInputHandler*>(fAnalysis->GetInputEventHandler())) {
1946        AliError("Analysis manager used in reconstruction should use AliRecoInputHandler - \
1947                  \n  ->Replacing with AliRecoInputHandler instance.");
1948        delete fAnalysis->GetInputEventHandler();
1949     }
1950     // Set the event and other data pointers
1951     fRecoHandler = new AliRecoInputHandler();
1952 //    fRecoHandler->Init(ftree, "LOCAL");
1953     fRecoHandler->SetEvent(fesd);
1954     fRecoHandler->SetESDfriend(fesdf);
1955     fRecoHandler->SetHLTEvent(fhltesd);
1956     fRecoHandler->SetHLTTree(fhlttree);
1957     fAnalysis->SetInputEventHandler(fRecoHandler);
1958     // Enter external loop mode
1959     fAnalysis->SetExternalLoop(kTRUE);
1960     // Initialize analysis
1961     fAnalysis->SlaveBegin(ftree);
1962     fAnalysis->StartAnalysis("local", (TTree*)0);
1963     // Connect ESD tree with the input container
1964     fAnalysis->GetCommonInputContainer()->SetData(ftree);
1965   }  
1966   //
1967   ProcessTriggerAliases();
1968   //
1969   return;
1970 }
1971
1972 //_____________________________________________________________________________
1973 Bool_t AliReconstruction::Process(Long64_t entry)
1974 {
1975   // run the reconstruction over a single entry
1976   // from the chain with raw data
1977   AliCodeTimerAuto("",0);
1978
1979   TTree *currTree = fChain->GetTree();
1980   AliRawVEvent *event = NULL;
1981   currTree->SetBranchAddress("rawevent",&event);
1982   currTree->GetEntry(entry);
1983   fRawReader = new AliRawReaderRoot(event,entry);
1984   // check if process has enough resources 
1985   if (!HasEnoughResources(entry)) return kFALSE;
1986   fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1987   delete fRawReader;
1988   fRawReader = NULL;
1989   delete event;
1990
1991   if (!fStatus) Abort("ProcessEvent",TSelector::kAbortFile);  
1992   CleanProcessedEvent();
1993   return fStatus;
1994 }
1995
1996 //_____________________________________________________________________________
1997 void AliReconstruction::Init(TTree *tree)
1998 {
1999   // Implementation of TSelector::Init()
2000   // method
2001   if (tree == 0) {
2002     AliError("The input tree is not found!");
2003     return;
2004   }
2005   fChain = tree;
2006 }
2007
2008 //_____________________________________________________________________________
2009 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
2010 {
2011   // run the reconstruction over a single event
2012   // The event loop is steered in Run method
2013
2014
2015   static Long_t oldMres=0;
2016   static Long_t oldMvir=0;
2017   static Float_t oldCPU=0;
2018   static Long_t aveDMres=0;
2019   static Long_t aveDMvir=0;
2020   static Float_t aveDCPU=0;
2021
2022   AliCodeTimerAuto("",0);
2023
2024   AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
2025
2026   if (iEvent >= fRunLoader->GetNumberOfEvents()) {
2027     fRunLoader->SetEventNumber(iEvent);
2028     if (fRawReader)
2029       fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(), 
2030                                      iEvent, iEvent);
2031     fRunLoader->TreeE()->Fill();
2032
2033     if (fRawReader && fRawReader->UseAutoSaveESD())
2034       fRunLoader->TreeE()->AutoSave("SaveSelf");
2035   }
2036
2037   if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
2038     return kTRUE;
2039   }
2040
2041
2042   fRunLoader->GetEvent(iEvent);
2043
2044   // Fill Event-info object
2045   GetEventInfo();
2046   fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
2047   
2048   ProcInfo_t procInfo;
2049   if(iEvent==fFirstEvent) {
2050     gSystem->GetProcInfo(&procInfo);
2051     oldMres=procInfo.fMemResident;
2052     oldMvir=procInfo.fMemVirtual;
2053     oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
2054   }
2055   AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
2056   fEventInfo.Print();
2057
2058   AliSysInfo::AddStamp(Form("StartReco_%d",iEvent), 0,0,iEvent);
2059   // Set the reco-params
2060   {
2061     TString detStr = fLoadCDB;
2062     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2063       if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2064       AliReconstructor *reconstructor = GetReconstructor(iDet);
2065       if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
2066         const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2067         reconstructor->SetRecoParam(par);
2068         reconstructor->GetPidSettings(fESDpid);
2069         reconstructor->SetEventInfo(&fEventInfo);
2070         if (fRunQA) {
2071           AliQAManager::QAManager()->SetEventInfo(&fEventInfo) ;
2072           AliQAManager::QAManager()->SetRecoParam(iDet, par) ; 
2073           if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
2074         }
2075       }
2076     }
2077     //
2078     if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
2079     //
2080     if (fRunQA) {
2081       const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
2082       AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ; 
2083       AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
2084     }
2085   }
2086
2087     // QA on single raw 
2088   if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
2089     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2090     AliQAManager::QAManager()->RunOneEvent(fRawReader) ;  
2091     AliSysInfo::AddStamp(Form("RawQA_%d",iEvent), 0,0,iEvent);
2092   }
2093
2094     // fill Event header information from the RawEventHeader
2095     if (fRawReader){FillRawEventHeaderESD(fesd);}
2096     if (fRawReader){FillRawEventHeaderESD(fhltesd);}
2097     if (fRawReader){
2098       // Store DAQ detector pattern and attributes
2099       fesd->SetDAQDetectorPattern(fRawReader->GetDetectorPattern()[0]);
2100       fesd->SetDAQAttributes(fRawReader->GetAttributes()[2]);
2101     }
2102
2103     fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
2104     fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
2105     
2106     ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
2107     ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
2108     ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
2109     ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
2110
2111     fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
2112     fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
2113
2114     fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
2115     fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
2116     
2117     // Set magnetic field from the tracker
2118     fesd->SetMagneticField(AliTracker::GetBz());
2119     fhltesd->SetMagneticField(AliTracker::GetBz());
2120     //
2121     AliESDRun *esdRun,*esdRunH;
2122     esdRun  = (AliESDRun*)fesd->GetESDRun();
2123     esdRunH = (AliESDRun*)fhltesd->GetESDRun();
2124     esdRun->SetBeamEnergyIsSqrtSHalfGeV();
2125     esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
2126     //
2127     for (int ib=2;ib--;) for (int it=2;it--;) {
2128         esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]); 
2129         esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]); 
2130       }
2131     //
2132     fesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2133     fesd->SetBeamType(fGRPData->GetBeamType().Data());
2134     fesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2135     fesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2136     fhltesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2137     fhltesd->SetBeamType(fGRPData->GetBeamType().Data());
2138     fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2139     fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2140     //
2141     AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2142     if (fld) { // set info needed for field initialization
2143       fesd->SetCurrentL3(fld->GetCurrentSol());
2144       fesd->SetCurrentDip(fld->GetCurrentDip());
2145       fesd->SetUniformBMap(fld->IsUniform());
2146       fesd->SetBInfoStored();
2147       //
2148       fhltesd->SetCurrentL3(fld->GetCurrentSol());
2149       fhltesd->SetCurrentDip(fld->GetCurrentDip());
2150       fhltesd->SetUniformBMap(fld->IsUniform());
2151       fhltesd->SetBInfoStored();
2152     }
2153
2154     //
2155     // run full HLT reconstruction first
2156     //
2157     {
2158       TString detectors=fRunLocalReconstruction;
2159       if (IsSelected("HLT", detectors) &&
2160           !RunLocalEventReconstruction("HLT")) {
2161         if (fStopOnError) {CleanUp(); return kFALSE;}
2162       }
2163       detectors=fFillESD;
2164       // run HLT on hltesd
2165       if (IsSelected("HLT", detectors) &&
2166           !FillESD(fhltesd, "HLT")) {
2167         if (fStopOnError) {CleanUp(); return kFALSE;}
2168       }
2169     }
2170
2171     // local single event reconstruction
2172     if (!fRunLocalReconstruction.IsNull()) {
2173       TString detectors=fRunLocalReconstruction;
2174       // the logic for selection and correct sequence of reconstruction relies on the
2175       // full list of detectors. Keyword 'ALL' should have been replaced at this point.
2176       if (detectors.Contains("ALL")) {
2177         AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
2178                  "fRunLocalReconstruction. This should have been done by the framework");
2179       }
2180       detectors.ReplaceAll("HLT", "");
2181       if (!RunLocalEventReconstruction(detectors)) {
2182         if (fStopOnError) {
2183           CleanUp(); 
2184           return kFALSE;
2185         }
2186       }
2187     }
2188
2189   
2190     //
2191     // Set most probable pt, for B=0 tracking
2192     // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
2193     const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
2194     if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
2195     
2196     // Fill raw-data error log into the ESD
2197     if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2198
2199     AliSysInfo::AddStamp(Form("FillHeadErrs_%d",iEvent), 0,0,iEvent);
2200
2201     // vertex finder
2202     if (fRunVertexFinder) {
2203       if (!RunVertexFinder(fesd)) {
2204         if (fStopOnError) {CleanUp(); return kFALSE;}
2205       }
2206       AliSysInfo::AddStamp(Form("VtxFinder_%d",iEvent), 0,0,iEvent);
2207     }
2208
2209     // For Plane Efficiency: run the SPD trackleter
2210     if (fRunPlaneEff && fSPDTrackleter) {
2211       if (!RunSPDTrackleting(fesd)) {
2212         if (fStopOnError) {CleanUp(); return kFALSE;}
2213       }
2214       AliSysInfo::AddStamp(Form("TrackletEff_%d",iEvent), 0,0,iEvent);
2215     }
2216
2217     // Muon tracking
2218     if (!fRunTracking.IsNull()) {
2219       if (fRunMuonTracking) {
2220         if (!RunMuonTracking(fesd)) {
2221           if (fStopOnError) {CleanUp(); return kFALSE;}
2222         }
2223       }
2224       AliSysInfo::AddStamp(Form("TrackingMUON_%d",iEvent), 0,0,iEvent);      
2225     }
2226
2227     //---------------- AU From here...
2228
2229     // MFT tracking of MUON tracks
2230     if (!fRunTracking.IsNull()) {
2231       if (fRunMFTTrackingMU && fRunMuonTracking) {
2232         if (!RunMFTTrackingMU(fesd)) {
2233           if (fStopOnError) {CleanUp(); return kFALSE;}
2234         }
2235       }
2236       AliSysInfo::AddStamp(Form("TrackingMFT_MUON_%d",iEvent), 0,0,iEvent);      
2237     }
2238
2239     //---------------- ...to here
2240
2241     // barrel tracking
2242     if (!fRunTracking.IsNull()) {
2243       if (!RunTracking(fesd,*fESDpid)) {
2244         if (fStopOnError) {CleanUp(); return kFALSE;}
2245       }
2246     }
2247
2248     // fill ESD
2249     if (!fFillESD.IsNull()) {
2250       TString detectors=fFillESD;
2251       // the logic for selection and correct sequence of reconstruction relies on the
2252       // full list of detectors. Keyword 'ALL' should have been replaced at this point.
2253       if (detectors.Contains("ALL")) {
2254         AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
2255                  "fFillESD. This should have been done by the framework");
2256       }
2257       // remove HLT as this has been executed at the beginning of the event reconstruction
2258       detectors.ReplaceAll("HLT", "");
2259       if (!FillESD(fesd, detectors)) {
2260         if (fStopOnError) {CleanUp(); return kFALSE;}
2261       }
2262     }
2263
2264     ffile->cd();
2265
2266     //
2267     // Propagate track to the beam pipe  (if not already done by ITS)
2268     //
2269     const Int_t ntracks = fesd->GetNumberOfTracks();
2270     const Double_t kRadius  = 2.8; //something less than the beam pipe radius
2271
2272     TObjArray trkArray;
2273     UShort_t selectedIdx[ntracks];
2274
2275     for (Int_t itrack=0; itrack<ntracks; itrack++){
2276       const Double_t kMaxStep = 1;   //max step over the material
2277       Bool_t ok;
2278
2279       AliESDtrack *track = fesd->GetTrack(itrack);
2280       if (!track) continue;
2281
2282       AliExternalTrackParam *tpcTrack =
2283            (AliExternalTrackParam *)track->GetTPCInnerParam();
2284       ok = kFALSE;
2285       if (tpcTrack)
2286         ok = AliTracker::
2287           PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMassForTracking(),kMaxStep,kFALSE);
2288
2289       if (ok) {
2290         Int_t n=trkArray.GetEntriesFast();
2291         selectedIdx[n]=track->GetID();
2292         trkArray.AddLast(tpcTrack);
2293       }
2294
2295       //Tracks refitted by ITS should already be at the SPD vertex
2296       if (track->IsOn(AliESDtrack::kITSrefit)) continue;
2297
2298       AliTracker::
2299          PropagateTrackToBxByBz(track,kRadius,track->GetMassForTracking(),kMaxStep,kFALSE);
2300       Double_t x[3]; track->GetXYZ(x);
2301       Double_t b[3]; AliTracker::GetBxByBz(x,b);
2302       track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
2303
2304     }
2305     AliSysInfo::AddStamp(Form("RelToSPDVtx_%d",iEvent), 0,0,iEvent);      
2306     //
2307     // Improve the reconstructed primary vertex position using the tracks
2308     //
2309     Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
2310     if(fesd->GetPrimaryVertexSPD()) {
2311       TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
2312       if(vtitle.Contains("cosmics")) {
2313         runVertexFinderTracks=kFALSE;
2314       }
2315     }
2316
2317     if (runVertexFinderTracks) {
2318        // TPC + ITS primary vertex
2319        ftVertexer->SetITSMode();
2320        ftVertexer->SetConstraintOff();
2321        // get cuts for vertexer from AliGRPRecoParam
2322        Bool_t constrSPD=kFALSE;
2323        if (grpRecoParam) {
2324          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2325          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2326          grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer,nCutsVertexer);
2327          ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2328          delete [] cutsVertexer; cutsVertexer = NULL; 
2329          if(grpRecoParam->GetVertexerTracksConstraintITS()) { 
2330            if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
2331              ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius 
2332            }else{
2333              if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
2334                ftVertexer->SetVtxStart(fDiamondProfileSPD);
2335                constrSPD=kTRUE;
2336              }
2337            }
2338          } 
2339        }
2340        AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
2341        if (pvtx) {
2342          if(constrSPD){
2343            TString title=pvtx->GetTitle();
2344            title.Append("SPD");
2345            pvtx->SetTitle(title);
2346          }
2347           if (pvtx->GetStatus()) {
2348              fesd->SetPrimaryVertexTracks(pvtx);
2349              for (Int_t i=0; i<ntracks; i++) {
2350                  AliESDtrack *t = fesd->GetTrack(i);
2351                  Double_t x[3]; t->GetXYZ(x);
2352                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
2353                  t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
2354              } 
2355           }
2356           delete pvtx; pvtx=NULL;
2357        }
2358        AliSysInfo::AddStamp(Form("VtxTrk_%d",iEvent), 0,0,iEvent);      
2359
2360        // TPC-only primary vertex
2361        ftVertexer->SetTPCMode();
2362        ftVertexer->SetConstraintOff();
2363        // get cuts for vertexer from AliGRPRecoParam
2364        if (grpRecoParam) {
2365          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2366          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2367          grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer,nCutsVertexer);
2368          ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2369          delete [] cutsVertexer; cutsVertexer = NULL; 
2370          if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) { 
2371            if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius 
2372          } 
2373        }
2374        pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
2375        if (pvtx) {
2376           if (pvtx->GetStatus()) {
2377              fesd->SetPrimaryVertexTPC(pvtx);
2378              for (Int_t i=0; i<ntracks; i++) {
2379                  AliESDtrack *t = fesd->GetTrack(i);
2380                  Double_t x[3]; t->GetXYZ(x);
2381                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
2382                  t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
2383              } 
2384           }
2385           delete pvtx; pvtx=NULL;
2386        }
2387        AliSysInfo::AddStamp(Form("VtxTPC_%d",iEvent), 0,0,iEvent);      
2388
2389     }
2390     
2391     if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
2392     else fesd->SetDiamond(fDiamondProfileSPD);
2393
2394     if (fRunV0Finder) {
2395        // V0 finding
2396        AliV0vertexer vtxer;
2397        // get cuts for V0vertexer from AliGRPRecoParam
2398        if (grpRecoParam) {
2399          Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
2400          Double_t cutsV0vertexer[nCutsV0vertexer];
2401          grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
2402          vtxer.SetCuts(cutsV0vertexer);
2403        }
2404        vtxer.Tracks2V0vertices(fesd);
2405        AliSysInfo::AddStamp(Form("V0Finder_%d",iEvent), 0,0,iEvent); 
2406
2407        if (fRunCascadeFinder) {
2408           // Cascade finding
2409           AliCascadeVertexer cvtxer;
2410           // get cuts for CascadeVertexer from AliGRPRecoParam
2411           if (grpRecoParam) {
2412             Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
2413             Double_t cutsCascadeVertexer[nCutsCascadeVertexer];
2414             grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
2415             cvtxer.SetCuts(cutsCascadeVertexer);
2416           }
2417           cvtxer.V0sTracks2CascadeVertices(fesd);
2418           AliSysInfo::AddStamp(Form("CascadeFinder_%d",iEvent), 0,0,iEvent); 
2419        }
2420     }
2421
2422     // AdC+FN
2423     if (fReconstructor[3])
2424       GetReconstructor(3)->FillEventTimeWithTOF(fesd,fESDpid);
2425
2426     // combined PID
2427     //    fESDpid->MakePID(fesd);
2428
2429     if (fFillTriggerESD) {
2430       if (!FillTriggerESD(fesd)) {
2431         if (fStopOnError) {CleanUp(); return kFALSE;}
2432       }
2433     }
2434     // Always fill scalers
2435     if (!FillTriggerScalers(fesd)) {
2436        if (fStopOnError) {CleanUp(); return kFALSE;}
2437     }
2438
2439     AliSysInfo::AddStamp(Form("FillVaria_%d",iEvent), 0,0,iEvent); 
2440
2441     // write ESD
2442     UInt_t specie = fesd->GetEventSpecie();
2443     Bool_t keepAll = (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib);
2444     if (fCleanESD && (!keepAll) ) {
2445       CleanESD(fesd);
2446       AliSysInfo::AddStamp(Form("CleanESD_%d",iEvent), 0,0,iEvent); 
2447     }
2448     // 
2449     // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the 
2450     // tracks interpreted as primary, this step should be done in the very end, when full 
2451     // ESD info is available (particulalry, V0s)
2452     // vertex finder
2453     if (fRunMultFinder) {
2454       if (!RunMultFinder(fesd)) {
2455         if (fStopOnError) {CleanUp(); return kFALSE;}
2456       }
2457       AliSysInfo::AddStamp(Form("MultFinder_%d",iEvent), 0,0,iEvent); 
2458     }
2459
2460   if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
2461     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2462     AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ; 
2463     AliSysInfo::AddStamp(Form("RunQA_%d",iEvent), 0,0,iEvent); 
2464   }
2465   if (fRunGlobalQA) {
2466     AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2467     if (qadm)
2468       qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2469     if (qadm && IsInTasks(AliQAv1::kESDS))
2470       qadm->Exec(AliQAv1::kESDS, fesd);
2471     AliSysInfo::AddStamp(Form("RunGlobQA_%d",iEvent), 0,0,iEvent);     
2472   }
2473
2474   // copy HLT decision from HLTesd to esd
2475   // the most relevant information is stored in a reduced container in the esd,
2476   // while the full information can be found in the HLTesd
2477   TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
2478   TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
2479   if (pHLTSrc && pHLTTgt) {
2480     pHLTSrc->Copy(*pHLTTgt);
2481   }
2482   //
2483   // Perform analysis of this event if requested
2484   // RS: Should be done before WriteESDfriend, since the latter may clean the esdfriend
2485   if (fAnalysis) {
2486     fRecoHandler->BeginEvent(iEvent);
2487     fAnalysis->ExecAnalysis();
2488     fRecoHandler->FinishEvent();
2489     AliSysInfo::AddStamp(Form("Analysis_%d",iEvent), 0,0,iEvent);     
2490   }  
2491   //
2492   if (fWriteESDfriend) {
2493     fesd->GetESDfriend(fesdf);
2494     AliSysInfo::AddStamp(Form("CreateFriend_%d",iEvent), 0,0,iEvent);     
2495   
2496   }
2497   //
2498   Long64_t nbf;
2499   nbf = ftree->Fill();
2500   if (fTreeBuffSize>0 && ftree->GetAutoFlush()<0 && (fMemCountESD += nbf)>fTreeBuffSize ) { // default limit is still not reached
2501     nbf = ftree->GetZipBytes();
2502     if (nbf>0) nbf = -nbf;
2503     else       nbf = ftree->GetEntries();
2504     ftree->SetAutoFlush(nbf);
2505     AliInfo(Form("Calling ftree->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
2506                  nbf,fMemCountESD,ftree->GetTotBytes(),ftree->GetZipBytes()));        
2507   }
2508   AliSysInfo::AddStamp(Form("ESDFill_%d",iEvent), 0,0,iEvent);     
2509   //
2510   if (fWriteESDfriend) {
2511     WriteESDfriend();
2512     AliSysInfo::AddStamp(Form("WriteFriend_%d",iEvent), 0,0,iEvent);     
2513   }
2514   //
2515   //
2516   // Auto-save the ESD tree in case of prompt reco @P2
2517   if (fRawReader && fRawReader->UseAutoSaveESD()) {
2518     ftree->AutoSave("SaveSelf");
2519     if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
2520   }
2521   // write HLT ESD
2522   
2523   nbf = fhlttree->Fill();
2524   if (fTreeBuffSize>0 && fhlttree->GetAutoFlush()<0 && (fMemCountESDHLT += nbf)>fTreeBuffSize ) { // default limit is still not reached
2525     nbf = fhlttree->GetZipBytes();
2526     if (nbf>0) nbf = -nbf;
2527     else       nbf = fhlttree->GetEntries();
2528     fhlttree->SetAutoFlush(nbf);
2529     AliInfo(Form("Calling fhlttree->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
2530                  nbf,fMemCountESDHLT,fhlttree->GetTotBytes(),fhlttree->GetZipBytes()));        
2531   }
2532     
2533     gSystem->GetProcInfo(&procInfo);
2534     Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
2535     Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
2536     Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
2537     aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
2538     aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
2539     aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
2540     AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
2541                 iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
2542     oldMres=procInfo.fMemResident;
2543     oldMvir=procInfo.fMemVirtual;
2544     oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
2545   
2546     
2547   return kTRUE;
2548 }
2549
2550 void AliReconstruction::CleanProcessedEvent()
2551 {
2552     //
2553     fesd->Reset();
2554     fhltesd->Reset();
2555     if (fWriteESDfriend) {
2556       fesdf->~AliESDfriend();
2557       new (fesdf) AliESDfriend(); // Reset...
2558     }
2559
2560     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2561       if (fReconstructor[iDet]) fReconstructor[iDet]->FinishEvent();
2562     }
2563  
2564     AliInfo("======================= End Event ===================");
2565     
2566
2567     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2568       if (fReconstructor[iDet]) {
2569         fReconstructor[iDet]->SetRecoParam(NULL);
2570         fReconstructor[iDet]->SetEventInfo(NULL);
2571       }
2572       if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
2573     }
2574         
2575   if (fRunQA || fRunGlobalQA) 
2576     AliQAManager::QAManager()->Increment() ; 
2577
2578   DeleteRecPoints(fDeleteRecPoints);
2579   DeleteDigits(fDeleteDigits);
2580   //
2581
2582 }
2583
2584 //_____________________________________________________________________________
2585 void AliReconstruction::SlaveTerminate()
2586 {
2587   // Finalize the run on the slave side
2588   // Called after the exit
2589   // from the event loop
2590   AliCodeTimerAuto("",0);
2591   // If analysis was done during reconstruction, we need to call SlaveTerminate for it
2592   if (fAnalysis) {
2593      fAnalysis->PackOutput(fOutput);
2594      fAnalysis->SetSkipTerminate(kTRUE);
2595      fAnalysis->Terminate();
2596   }   
2597
2598   if (fIsNewRunLoader) { // galice.root didn't exist
2599     fRunLoader->WriteHeader("OVERWRITE");
2600     fRunLoader->WriteTrigger("OVERWRITE");
2601     fRunLoader->CdGAFile();
2602     fRunLoader->Write(0, TObject::kOverwrite);
2603   }
2604
2605   const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();       
2606   const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();   
2607                  
2608    TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());    
2609    cdbMapCopy->SetOwner(1);      
2610    cdbMapCopy->SetName("cdbMap");        
2611    TIter iter(cdbMap->GetTable());       
2612          
2613    TPair* pair = 0;      
2614    while((pair = dynamic_cast<TPair*> (iter.Next()))){   
2615          TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());   
2616          TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2617          if (keyStr && valStr)
2618            cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));        
2619    }     
2620          
2621    TList *cdbListCopy = new TList();     
2622    cdbListCopy->SetOwner(1);     
2623    cdbListCopy->SetName("cdbList");      
2624          
2625    TIter iter2(cdbList);         
2626          
2627         AliCDBId* id=0;
2628         while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){    
2629          cdbListCopy->Add(new TObjString(id->ToString().Data()));        
2630    }     
2631          
2632    ftree->GetUserInfo()->Add(cdbMapCopy);        
2633    ftree->GetUserInfo()->Add(cdbListCopy);
2634
2635    // Add the AliRoot version that created this file
2636    TString sVersion("aliroot ");
2637    sVersion += ALIROOT_VERSION;
2638    sVersion += ":";
2639    sVersion += ALIROOT_REVISION;
2640    sVersion += "; root ";
2641 #ifdef ROOT_SVN_BRANCH
2642    sVersion += ROOT_SVN_BRANCH;
2643 #elif defined(ROOT_GIT_BRANCH)
2644    sVersion += ROOT_GIT_BRANCH;
2645 #else
2646    sVersion += "?";
2647 #endif
2648    sVersion += ":";
2649 #ifdef ROOT_SVN_REVSION
2650    sVersion += ROOT_SVN_REVISION;
2651 #elif defined(ROOT_GIT_COMMIT)
2652    sVersion += ROOT_GIT_COMMIT;
2653 #else 
2654    sVersion += "?";
2655 #endif
2656    sVersion += "; metadata ";
2657    sVersion += getenv("PRODUCTION_METADATA");
2658                     
2659
2660    TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
2661    ftree->GetUserInfo()->Add(alirootVersion); // The list becomes owner of alirootVersion
2662
2663   ffile->cd();
2664
2665   // we want to have only one tree version number
2666   ftree->Write(ftree->GetName(),TObject::kOverwrite);
2667   fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
2668
2669   if (fWriteESDfriend) {
2670     ffileF->cd();
2671     ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
2672   }
2673
2674 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
2675   if (fRunPlaneEff && !FinishPlaneEff()) {
2676    AliWarning("Finish PlaneEff evaluation failed");
2677   }
2678
2679   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2680     if (fReconstructor[iDet]) fReconstructor[iDet]->Terminate();
2681   }
2682   // End of cycle for the in-loop  
2683
2684   if (fRunQA || fRunGlobalQA) {
2685     AliQAManager::QAManager()->EndOfCycle() ;
2686     if (fInput &&
2687         !fProofOutputLocation.IsNull() &&
2688         fProofOutputArchive.IsNull() &&
2689         !fProofOutputDataset) {
2690       TString qaOutputFile(Form("%sMerged.%s.Data.root",
2691                                 fProofOutputLocation.Data(),
2692                                 AliQAv1::GetQADataFileName()));
2693       TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2694                                                                 AliQAv1::GetQADataFileName()));
2695       qaProofFile->SetOutputFileName(qaOutputFile.Data());
2696       if (AliDebugLevel() > 0) qaProofFile->Dump();
2697       fOutput->Add(qaProofFile);
2698       MergeQA(qaProofFile->GetFileName());
2699     }
2700     else {
2701       MergeQA();
2702     }
2703   }
2704
2705   gROOT->cd();
2706   CleanUp();
2707
2708   if (fInput) {
2709     if (!fProofOutputFileName.IsNull() &&
2710         !fProofOutputLocation.IsNull() &&
2711         fProofOutputDataset &&
2712         !fProofOutputArchive.IsNull()) {
2713       TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2714                                                             "DROV",
2715                                                             fProofOutputLocation.Data());
2716       if (AliDebugLevel() > 0) zipProofFile->Dump();
2717       fOutput->Add(zipProofFile);
2718       TString fileList(fProofOutputArchive.Data());
2719       fileList.ReplaceAll(","," ");
2720       TString command;
2721 #if ROOT_SVN_REVISION >= 30174
2722       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2723 #else
2724       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2725 #endif
2726       AliInfo(Form("Executing: %s",command.Data()));
2727       gSystem->Exec(command.Data());
2728     }
2729   }
2730 }
2731     
2732 //_____________________________________________________________________________
2733 void AliReconstruction::Terminate()
2734 {
2735   // Create tags for the events in the ESD tree (the ESD tree is always present)
2736   // In case of empty events the tags will contain dummy values
2737   AliCodeTimerAuto("",0);
2738
2739   // Do not call the ESD tag creator in case of PROOF-based reconstruction
2740   if (!fInput) {
2741     AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2742     esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2743     delete esdtagCreator;
2744   }
2745
2746   // Cleanup of CDB manager: cache and active storages!
2747   AliCDBManager::Instance()->ClearCache();
2748 }
2749
2750 //_____________________________________________________________________________
2751 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2752 {
2753 // run the local reconstruction
2754
2755   static Int_t eventNr=0;
2756   AliCodeTimerAuto("",0)
2757
2758   TString detStr = detectors;
2759   // execute HLT reconstruction first since other detector reconstruction
2760   // might depend on HLT data
2761   // key 'HLT' is removed from detStr by IsSelected
2762   if (IsSelected("HLT", detStr)) {
2763     AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
2764     if (reconstructor) {
2765       // there is no AliLoader for HLT, see
2766       // https://savannah.cern.ch/bugs/?35473
2767       AliInfo("running reconstruction for HLT");
2768       if (fRawReader) {
2769         AliInfo("reconstructor->Reconstruct(fRawReader, NULL)");
2770         reconstructor->Reconstruct(fRawReader, NULL);
2771       } 
2772       else {
2773         AliInfo("reconstructor->Reconstruct(dummy, NULL)");
2774         TTree* dummy=NULL;
2775         reconstructor->Reconstruct(dummy, NULL);
2776       }
2777     }
2778     AliSysInfo::AddStamp(Form("LRecHLT_%d",eventNr), -1,1,eventNr);
2779   }
2780
2781   AliInfo(Form("kNDetectors = %d",kNDetectors));
2782
2783   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2784     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2785     AliDebug(1, Form("Detector: %s", fgkDetectorName[iDet]));
2786     AliReconstructor* reconstructor = GetReconstructor(iDet);
2787     if (!reconstructor) continue;
2788     AliLoader* loader = fLoader[iDet];
2789     if (!loader) {
2790       AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2791       continue;
2792     }
2793     // conversion of digits
2794     if (fRawReader && reconstructor->HasDigitConversion()) {
2795       AliInfo(Form("converting raw data digits into root objects for %s", 
2796                    fgkDetectorName[iDet]));
2797 //      AliCodeTimerAuto(Form("converting raw data digits into root objects for %s", 
2798 //                            fgkDetectorName[iDet]),0);
2799       loader->LoadDigits("update");
2800       loader->CleanDigits();
2801       loader->MakeDigitsContainer();
2802       TTree* digitsTree = loader->TreeD();
2803       reconstructor->ConvertDigits(fRawReader, digitsTree);
2804       loader->WriteDigits("OVERWRITE");
2805       loader->UnloadDigits();
2806     }
2807     // local reconstruction
2808     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
2809     //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
2810     AliDebug(1, "Loading Rec Points");
2811     loader->LoadRecPoints("update");
2812     AliDebug(1, "Cleaning Rec Points");
2813     loader->CleanRecPoints();
2814     AliDebug(1, "Making Rec Points Container");
2815     loader->MakeRecPointsContainer();
2816     TTree* clustersTree = loader->TreeR();
2817     if (fRawReader && !reconstructor->HasDigitConversion()) {
2818       reconstructor->Reconstruct(fRawReader, clustersTree);
2819     } 
2820     else {
2821       AliDebug(1, "Loading Digits");
2822       loader->LoadDigits("read");
2823       TTree* digitsTree = loader->TreeD();
2824       AliDebug(1, Form("Digits Tree = %p",digitsTree));
2825       if (!digitsTree) {
2826         AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2827         if (fStopOnError) 
2828           return kFALSE;
2829       } 
2830       else {
2831         AliDebug(1, "Digits -> Clusters");
2832         reconstructor->Reconstruct(digitsTree, clustersTree);
2833         if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
2834           AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2835           AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ; 
2836         }
2837       }
2838       loader->UnloadDigits();
2839     }
2840     if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
2841       AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2842       AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ; 
2843     }
2844     loader->WriteRecPoints("OVERWRITE");
2845     loader->UnloadRecPoints();
2846     AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
2847   }
2848   if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
2849   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2850     AliError(Form("the following detectors were not found: %s",
2851                   detStr.Data()));
2852     if (fStopOnError) 
2853       return kFALSE;
2854   }
2855   eventNr++;
2856   return kTRUE;
2857 }
2858 //_____________________________________________________________________________
2859 Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2860 {
2861 // run the SPD trackleting (for SPD efficiency purpouses)
2862
2863   AliCodeTimerAuto("",0)
2864
2865   Double_t vtxPos[3] = {0, 0, 0};
2866   Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2867 /*
2868   TArrayF m
2869 /
2870 cVertex(3);
2871   // if(MC)
2872   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2873     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2874     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2875   }
2876 */
2877   const AliESDVertex *vertex = esd->GetVertex();
2878   if(!vertex){
2879     AliWarning("Vertex not found");
2880     return kFALSE;
2881   }
2882   vertex->GetXYZ(vtxPos);
2883   vertex->GetSigmaXYZ(vtxErr);
2884   if (fSPDTrackleter) {
2885     AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2886
2887     // load clusters
2888     fLoader[0]->LoadRecPoints("read");
2889     TTree* tree = fLoader[0]->TreeR();
2890     if (!tree) {
2891       AliError("Can't get the ITS cluster tree");
2892       return kFALSE;
2893     }
2894     fSPDTrackleter->LoadClusters(tree);
2895     fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2896     // run trackleting
2897     if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2898       AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
2899      // fLoader[0]->UnloadRecPoints();
2900       return kFALSE;
2901     }
2902 //fSPDTrackleter->UnloadRecPoints();
2903   } else {
2904     AliWarning("SPDTrackleter not available");
2905     return kFALSE;
2906   }
2907   return kTRUE;
2908 }
2909
2910 //_____________________________________________________________________________
2911 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
2912 {
2913 // run the barrel tracking
2914
2915   AliCodeTimerAuto("",0)
2916
2917   AliVertexer *vertexer = CreateVertexer();
2918   if (!vertexer) return kFALSE;
2919
2920   AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
2921   AliESDVertex* vertex = NULL;
2922   if (fLoader[0]) {
2923     fLoader[0]->LoadRecPoints();
2924     TTree* cltree = fLoader[0]->TreeR();
2925     if (cltree) {
2926       if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2927       vertex = vertexer->FindVertexForCurrentEvent(cltree);
2928     }
2929     else {
2930       AliError("Can't get the ITS cluster tree");
2931     }
2932     fLoader[0]->UnloadRecPoints();
2933   }
2934   else {
2935     AliError("Can't get the ITS loader");
2936   }
2937   if(!vertex){
2938     AliWarning("Vertex not found");
2939     vertex = new AliESDVertex();
2940     vertex->SetName("default");
2941   }
2942   else {
2943     vertex->SetName("reconstructed");
2944   }
2945
2946   Double_t vtxPos[3];
2947   Double_t vtxErr[3];
2948   vertex->GetXYZ(vtxPos);
2949   vertex->GetSigmaXYZ(vtxErr);
2950
2951   esd->SetPrimaryVertexSPD(vertex);
2952   AliESDVertex *vpileup = NULL;
2953   Int_t novertices = 0;
2954   vpileup = vertexer->GetAllVertices(novertices);
2955   if(novertices>1){
2956     for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2957   }
2958   /*
2959   // if SPD multiplicity has been determined, it is stored in the ESD
2960   AliMultiplicity *mult = vertexer->GetMultiplicity();
2961   if(mult)esd->SetMultiplicity(mult);
2962   */
2963   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2964     if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2965   }  
2966   delete vertex;
2967
2968   delete vertexer;
2969
2970   return kTRUE;
2971 }
2972
2973 //_____________________________________________________________________________
2974 Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
2975 {
2976   // run the trackleter for multiplicity study
2977
2978   AliCodeTimerAuto("",0)
2979
2980   AliTrackleter *trackleter = CreateMultFinder();
2981   if (!trackleter) return kFALSE;
2982
2983   AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
2984
2985   if (fLoader[0]) {
2986     fLoader[0]->LoadRecPoints();
2987     TTree* cltree = fLoader[0]->TreeR();
2988     if (cltree) {
2989       trackleter->Reconstruct(esd,cltree);
2990       AliMultiplicity *mult = trackleter->GetMultiplicity();
2991       if(mult) esd->SetMultiplicity(mult);
2992     }
2993     else {
2994       AliError("Can't get the ITS cluster tree");
2995     }
2996     fLoader[0]->UnloadRecPoints();
2997   }
2998   else {
2999     AliError("Can't get the ITS loader");
3000   }
3001
3002   delete trackleter;
3003
3004   return kTRUE;
3005 }
3006
3007 //_____________________________________________________________________________
3008 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
3009 {
3010 // run the muon spectrometer tracking
3011
3012   AliCodeTimerAuto("",0)
3013
3014   if (!fRunLoader) {
3015     AliError("Missing runLoader!");
3016     return kFALSE;
3017   }
3018   Int_t iDet =  GetDetIndex("MUON"); // for MUON
3019
3020   // Get a pointer to the MUON reconstructor
3021   AliReconstructor *reconstructor = GetReconstructor(iDet);
3022   if (!reconstructor) return kFALSE;
3023
3024   
3025   TString detName = fgkDetectorName[iDet];
3026   AliDebug(1, Form("%s tracking", detName.Data()));
3027   AliTracker *tracker =  reconstructor->CreateTracker();
3028   if (!tracker) {
3029     AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
3030     return kFALSE;
3031   }
3032      
3033   // read RecPoints
3034   fLoader[iDet]->LoadRecPoints("read");  
3035
3036   tracker->LoadClusters(fLoader[iDet]->TreeR());
3037   
3038   Int_t rv = tracker->Clusters2Tracks(esd);
3039   
3040   fLoader[iDet]->UnloadRecPoints();
3041
3042   tracker->UnloadClusters();
3043   
3044   if ( rv )
3045   {
3046     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
3047     return kFALSE;
3048   }
3049   
3050   return kTRUE;
3051 }
3052
3053
3054 //_____________________________________________________________________________
3055 Bool_t AliReconstruction::RunMFTTrackingMU(AliESDEvent*& esd) {
3056
3057   // AU
3058
3059   // run the global muon tracking: matching the MUON tracks with the MFT clusters
3060
3061   AliCodeTimerAuto("",0)
3062
3063   if (!fRunLoader) {
3064     AliError("Missing runLoader!");
3065     return kFALSE;
3066   }
3067   Int_t iDet = GetDetIndex("MFT"); // for MFT
3068
3069   // Get a pointer to the MFT reconstructor
3070   AliReconstructor *reconstructor = GetReconstructor(iDet);
3071   if (!reconstructor) return kFALSE;
3072   
3073   TString detName = fgkDetectorName[iDet];
3074   AliDebug(1, Form("%s tracking for muon tracks", detName.Data()));
3075   AliTracker *tracker = reconstructor->CreateTracker();
3076   if (!tracker) {
3077     AliWarning(Form("couldn't create a Muon tracker for %s", detName.Data()));
3078     return kFALSE;
3079   }
3080      
3081   // read RecPoints
3082   fLoader[iDet]->LoadRecPoints("read");  
3083
3084   tracker->LoadClusters(fLoader[iDet]->TreeR());
3085   
3086   Int_t rv = tracker->Clusters2Tracks(esd);
3087   
3088   fLoader[iDet]->UnloadRecPoints();
3089
3090   tracker->UnloadClusters();
3091   
3092   if (rv) {
3093     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
3094     return kFALSE;
3095   }
3096   
3097   return kTRUE;
3098
3099 }
3100
3101 //_____________________________________________________________________________
3102 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
3103 {
3104 // run the barrel tracking
3105   static Int_t eventNr=0;
3106   AliCodeTimerAuto("",0)
3107
3108   AliInfo("running tracking");
3109
3110   // Set the event info which is used
3111   // by the trackers in order to obtain
3112   // information about read-out detectors,
3113   // trigger etc.
3114   AliDebug(1, "Setting event info");
3115   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3116     if (!fTracker[iDet]) continue;
3117     fTracker[iDet]->SetEventInfo(&fEventInfo);
3118   }
3119
3120   //Fill the ESD with the T0 info (will be used by the TOF) 
3121   if (fReconstructor[11] && fLoader[11]) {
3122     fLoader[11]->LoadRecPoints("READ");
3123     TTree *treeR = fLoader[11]->TreeR();
3124     if (treeR) {
3125       GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
3126     }
3127   }
3128
3129   // pass 1: TPC + ITS inwards
3130   for (Int_t iDet = 1; iDet >= 0; iDet--) {
3131     if (!fTracker[iDet]) continue;
3132     AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
3133
3134     // load clusters
3135     fLoader[iDet]->LoadRecPoints("read");
3136     AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
3137     TTree* tree = fLoader[iDet]->TreeR();
3138     if (!tree) {
3139       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
3140       return kFALSE;
3141     }
3142     fTracker[iDet]->LoadClusters(tree);
3143     AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
3144     // run tracking
3145     if (fTracker[iDet]->Clusters2TracksHLT(esd, fhltesd) != 0) {
3146       AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
3147       return kFALSE;
3148     }
3149     AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
3150     // preliminary PID in TPC needed by the ITS tracker
3151     if (iDet == 1) {
3152       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
3153       PID.MakePIDForTracking(esd);
3154       AliSysInfo::AddStamp(Form("MakePID0%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
3155     } 
3156   }
3157
3158   // pass 2: ALL backwards
3159
3160   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3161     if (!fTracker[iDet]) continue;
3162     AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
3163
3164     // load clusters
3165     if (iDet > 1) {     // all except ITS, TPC
3166       TTree* tree = NULL;
3167       fLoader[iDet]->LoadRecPoints("read");
3168       AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
3169       tree = fLoader[iDet]->TreeR();
3170       if (!tree) {
3171         AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
3172         return kFALSE;
3173       }
3174       fTracker[iDet]->LoadClusters(tree); 
3175       AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
3176     }
3177
3178     // run tracking
3179     if (iDet>1) // start filling residuals for the "outer" detectors
3180       if (fRunGlobalQA) {
3181         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);     
3182         TObjArray ** arr = AliTracker::GetResidualsArray() ; 
3183         if (arr) {
3184           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
3185           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
3186           if ( elem && (! elem->At(0)) ) {
3187             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
3188             if (qadm) qadm->InitRecPointsForTracker() ; 
3189           }
3190         }
3191         //      AliSysInfo::AddStamp(Form("QAInitResid%s_%d",fgkDetectorName[iDet],eventNr), iDet,0, eventNr);
3192       }
3193     if (fTracker[iDet]->PropagateBack(esd) != 0) {
3194       AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
3195       //      return kFALSE;
3196     }
3197     AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3198
3199     // unload clusters
3200     if (iDet > 3) {     // all except ITS, TPC, TRD and TOF
3201       fTracker[iDet]->UnloadClusters();
3202       fLoader[iDet]->UnloadRecPoints();
3203     }
3204     // updated PID in TPC needed by the ITS tracker -MI
3205     if (iDet == 1) {
3206       //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
3207       //AliESDpid::MakePID(esd);
3208       PID.MakePIDForTracking(esd);
3209       AliSysInfo::AddStamp(Form("MakePID1%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
3210     }
3211
3212   }
3213   //stop filling residuals for the "outer" detectors
3214   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);     
3215
3216   // pass 3: TRD + TPC + ITS refit inwards
3217
3218   for (Int_t iDet = 2; iDet >= 0; iDet--) {
3219     if (!fTracker[iDet]) continue;
3220     AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
3221
3222     // run tracking
3223     if (iDet<2) // start filling residuals for TPC and ITS
3224       if (fRunGlobalQA) {
3225         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);     
3226         TObjArray ** arr = AliTracker::GetResidualsArray() ; 
3227         if (arr) {
3228           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
3229           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
3230           if ( elem && (! elem->At(0)) ) {
3231             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
3232             if (qadm) qadm->InitRecPointsForTracker() ; 
3233           }
3234         }
3235       }
3236     
3237     if (fTracker[iDet]->RefitInward(esd) != 0) {
3238       AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
3239       //      return kFALSE;
3240     }
3241     // run postprocessing
3242     if (fTracker[iDet]->PostProcess(esd) != 0) {
3243       AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
3244       //      return kFALSE;
3245     }
3246     AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3247   }
3248
3249   // write space-points to the ESD in case alignment data output
3250   // is switched on
3251   if (fWriteAlignmentData) {
3252     WriteAlignmentData(esd);
3253     AliSysInfo::AddStamp(Form("WrtAlignData_%d",eventNr), 0,0, eventNr);
3254   }
3255   
3256   for (Int_t iDet = 3; iDet >= 0; iDet--) {
3257     if (!fTracker[iDet]) continue;
3258     // unload clusters
3259     fTracker[iDet]->UnloadClusters();
3260     AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
3261     fLoader[iDet]->UnloadRecPoints();
3262     AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
3263   }
3264   // stop filling residuals for TPC and ITS
3265   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);     
3266
3267   eventNr++;
3268   return kTRUE;
3269 }
3270
3271 //_____________________________________________________________________________
3272 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
3273   //
3274   // Remove the data which are not needed for the physics analysis.
3275   //
3276
3277   Int_t nTracks=esd->GetNumberOfTracks();
3278   Int_t nV0s=esd->GetNumberOfV0s();
3279   AliInfo
3280   (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
3281
3282   Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
3283   Bool_t rc=esd->Clean(cleanPars);
3284
3285   nTracks=esd->GetNumberOfTracks();
3286   nV0s=esd->GetNumberOfV0s();
3287   AliInfo
3288   (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
3289
3290   return rc;
3291 }
3292
3293 //_____________________________________________________________________________
3294 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
3295 {
3296 // fill the event summary data
3297
3298   AliCodeTimerAuto("",0)
3299     static Int_t eventNr=0; 
3300   TString detStr = detectors;
3301   
3302   AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
3303   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3304   if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3305     AliReconstructor* reconstructor = GetReconstructor(iDet);
3306     if (!reconstructor) continue;
3307     AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
3308     TTree* clustersTree = NULL;
3309     if (fLoader[iDet]) {
3310       fLoader[iDet]->LoadRecPoints("read");
3311       clustersTree = fLoader[iDet]->TreeR();
3312       if (!clustersTree) {
3313         AliError(Form("Can't get the %s clusters tree", 
3314                       fgkDetectorName[iDet]));
3315         if (fStopOnError) return kFALSE;
3316       }
3317     }
3318     if (fRawReader && !reconstructor->HasDigitConversion()) {
3319       reconstructor->FillESD(fRawReader, clustersTree, esd);
3320     } else {
3321       TTree* digitsTree = NULL;
3322       if (fLoader[iDet]) {
3323         fLoader[iDet]->LoadDigits("read");
3324         digitsTree = fLoader[iDet]->TreeD();
3325         if (!digitsTree) {
3326           AliError(Form("Can't get the %s digits tree", 
3327                         fgkDetectorName[iDet]));
3328           if (fStopOnError) return kFALSE;
3329         }
3330       }
3331       reconstructor->FillESD(digitsTree, clustersTree, esd);
3332       if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
3333     }
3334     if (fLoader[iDet]) {
3335       fLoader[iDet]->UnloadRecPoints();
3336     }
3337   }
3338   
3339   if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
3340   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
3341     AliError(Form("the following detectors were not found: %s", 
3342                   detStr.Data()));
3343     if (fStopOnError) return kFALSE;
3344   }
3345   AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
3346   eventNr++;
3347   return kTRUE;
3348 }
3349
3350 //_____________________________________________________________________________
3351 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
3352 {
3353   // Reads the trigger decision which is
3354   // stored in Trigger.root file and fills
3355   // the corresponding esd entries
3356
3357   AliCodeTimerAuto("",0)
3358   
3359   AliInfo("Filling trigger information into the ESD");
3360
3361   if (fRawReader) {
3362     AliCTPRawStream input(fRawReader);
3363     if (!input.Next()) {
3364       AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
3365     }
3366     else {
3367       if (esd->GetTriggerMask() != input.GetClassMask())
3368         AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
3369                       input.GetClassMask(),esd->GetTriggerMask()));
3370       if (esd->GetTriggerMaskNext50() != input.GetClassMaskNext50())
3371         AliError(Form("Invalid trigger pattern found in CTP raw-data Next50: %llx %llx",
3372                       input.GetClassMaskNext50(),esd->GetTriggerMaskNext50()));
3373       if (esd->GetOrbitNumber() != input.GetOrbitID())
3374         AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
3375                       input.GetOrbitID(),esd->GetOrbitNumber()));
3376       if (esd->GetBunchCrossNumber() != input.GetBCID())
3377         AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
3378                       input.GetBCID(),esd->GetBunchCrossNumber()));
3379       AliESDHeader* esdheader = esd->GetHeader();
3380       esdheader->SetL0TriggerInputs(input.GetL0Inputs());
3381       esdheader->SetL1TriggerInputs(input.GetL1Inputs());
3382       esdheader->SetL2TriggerInputs(input.GetL2Inputs());
3383       // IR
3384       //      UInt_t orbit=input.GetOrbitID();
3385       for(Int_t i=0 ; i<input.GetNIRs() ; i++ ) {
3386         esdheader->AddTriggerIR(input.GetIR(i));
3387       }
3388        AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3389        if (rlCTP) {
3390          rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
3391          rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
3392          rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
3393        }
3394     }
3395     if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
3396   }
3397   return kTRUE;
3398 }
3399 //____________________________