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