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