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