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