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