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