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