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