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