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