solved problems with the cycles when running QA during reconstruction
[u/mrichter/AliRoot.git] / STEER / AliReconstruction.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 // class for running the reconstruction                                      //
21 //                                                                           //
22 // Clusters and tracks are created for all detectors and all events by       //
23 // typing:                                                                   //
24 //                                                                           //
25 //   AliReconstruction rec;                                                  //
26 //   rec.Run();                                                              //
27 //                                                                           //
28 // The Run method returns kTRUE in case of successful execution.             //
29 //                                                                           //
30 // If the input to the reconstruction are not simulated digits but raw data, //
31 // this can be specified by an argument of the Run method or by the method   //
32 //                                                                           //
33 //   rec.SetInput("...");                                                    //
34 //                                                                           //
35 // The input formats and the corresponding argument are:                     //
36 // - DDL raw data files: directory name, ends with "/"                       //
37 // - raw data root file: root file name, extension ".root"                   //
38 // - raw data DATE file: DATE file name, any other non-empty string          //
39 // - MC root files     : empty string, default                               //
40 //                                                                           //
41 // By default all events are reconstructed. The reconstruction can be        //
42 // limited to a range of events by giving the index of the first and the     //
43 // last event as an argument to the Run method or by calling                 //
44 //                                                                           //
45 //   rec.SetEventRange(..., ...);                                            //
46 //                                                                           //
47 // The index -1 (default) can be used for the last event to indicate no      //
48 // upper limit of the event range.                                           //
49 //                                                                           //
50 // In case of raw-data reconstruction the user can modify the default        //
51 // number of events per digits/clusters/tracks file. In case the option      //
52 // is not used the number is set 1. In case the user provides 0, than        //
53 // the number of events is equal to the number of events inside the          //
54 // raw-data file (i.e. one digits/clusters/tracks file):                     //
55 //                                                                           //
56 //   rec.SetNumberOfEventsPerFile(...);                                      //
57 //                                                                           //
58 //                                                                           //
59 // The name of the galice file can be changed from the default               //
60 // "galice.root" by passing it as argument to the AliReconstruction          //
61 // constructor or by                                                         //
62 //                                                                           //
63 //   rec.SetGAliceFile("...");                                               //
64 //                                                                           //
65 // The local reconstruction can be switched on or off for individual         //
66 // detectors by                                                              //
67 //                                                                           //
68 //   rec.SetRunLocalReconstruction("...");                                   //
69 //                                                                           //
70 // The argument is a (case sensitive) string with the names of the           //
71 // detectors separated by a space. The special string "ALL" selects all      //
72 // available detectors. This is the default.                                 //
73 //                                                                           //
74 // The reconstruction of the primary vertex position can be switched off by  //
75 //                                                                           //
76 //   rec.SetRunVertexFinder(kFALSE);                                         //
77 //                                                                           //
78 // The tracking and the creation of ESD tracks can be switched on for        //
79 // selected detectors by                                                     //
80 //                                                                           //
81 //   rec.SetRunTracking("...");                                              //
82 //                                                                           //
83 // Uniform/nonuniform field tracking switches (default: uniform field)       //
84 //                                                                           //
85 //   rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
86 //                                                                           //
87 // The filling of additional ESD information can be steered by               //
88 //                                                                           //
89 //   rec.SetFillESD("...");                                                  //
90 //                                                                           //
91 // Again, for both methods the string specifies the list of detectors.       //
92 // The default is "ALL".                                                     //
93 //                                                                           //
94 // The call of the shortcut method                                           //
95 //                                                                           //
96 //   rec.SetRunReconstruction("...");                                        //
97 //                                                                           //
98 // is equivalent to calling SetRunLocalReconstruction, SetRunTracking and    //
99 // SetFillESD with the same detector selecting string as argument.           //
100 //                                                                           //
101 // The reconstruction requires digits or raw data as input. For the creation //
102 // of digits and raw data have a look at the class AliSimulation.            //
103 //                                                                           //
104 // The input data of a detector can be replaced by the corresponding HLT     //
105 // data by calling (usual detector string)                                   //
106 // SetUseHLTData("...");                                                     //
107 //                                                                           //
108 // For debug purposes the method SetCheckPointLevel can be used. If the      //
109 // argument is greater than 0, files with ESD events will be written after   //
110 // selected steps of the reconstruction for each event:                      //
111 //   level 1: after tracking and after filling of ESD (final)                //
112 //   level 2: in addition after each tracking step                           //
113 //   level 3: in addition after the filling of ESD for each detector         //
114 // If a final check point file exists for an event, this event will be       //
115 // skipped in the reconstruction. The tracking and the filling of ESD for    //
116 // a detector will be skipped as well, if the corresponding check point      //
117 // file exists. The ESD event will then be loaded from the file instead.     //
118 //                                                                           //
119 ///////////////////////////////////////////////////////////////////////////////
120
121 #include <TArrayF.h>
122 #include <TFile.h>
123 #include <TList.h>
124 #include <TSystem.h>
125 #include <TROOT.h>
126 #include <TPluginManager.h>
127 #include <TGeoManager.h>
128 #include <TLorentzVector.h>
129 #include <TArrayS.h>
130 #include <TArrayD.h>
131 #include <TObjArray.h>
132
133 #include "AliReconstruction.h"
134 #include "AliCodeTimer.h"
135 #include "AliReconstructor.h"
136 #include "AliLog.h"
137 #include "AliRunLoader.h"
138 #include "AliRun.h"
139 #include "AliRawReaderFile.h"
140 #include "AliRawReaderDate.h"
141 #include "AliRawReaderRoot.h"
142 #include "AliRawEventHeaderBase.h"
143 #include "AliESDEvent.h"
144 #include "AliESDMuonTrack.h"
145 #include "AliESDfriend.h"
146 #include "AliESDVertex.h"
147 #include "AliESDcascade.h"
148 #include "AliESDkink.h"
149 #include "AliESDtrack.h"
150 #include "AliESDCaloCluster.h"
151 #include "AliESDCaloCells.h"
152 #include "AliMultiplicity.h"
153 #include "AliTracker.h"
154 #include "AliVertexer.h"
155 #include "AliVertexerTracks.h"
156 #include "AliV0vertexer.h"
157 #include "AliCascadeVertexer.h"
158 #include "AliHeader.h"
159 #include "AliGenEventHeader.h"
160 #include "AliPID.h"
161 #include "AliESDpid.h"
162 #include "AliESDtrack.h"
163 #include "AliESDPmdTrack.h"
164
165 #include "AliESDTagCreator.h"
166 #include "AliAODTagCreator.h"
167
168 #include "AliGeomManager.h"
169 #include "AliTrackPointArray.h"
170 #include "AliCDBManager.h"
171 #include "AliCDBStorage.h"
172 #include "AliCDBEntry.h"
173 #include "AliAlignObj.h"
174
175 #include "AliCentralTrigger.h"
176 #include "AliTriggerConfiguration.h"
177 #include "AliTriggerClass.h"
178 #include "AliCTPRawStream.h"
179
180 #include "AliQADataMakerRec.h" 
181 #include "AliGlobalQADataMaker.h" 
182 #include "AliQA.h"
183 #include "AliQADataMakerSteer.h"
184
185 #include "AliPlaneEff.h"
186
187 #include "AliSysInfo.h" // memory snapshots
188 #include "AliRawHLTManager.h"
189
190
191 ClassImp(AliReconstruction)
192
193
194 //_____________________________________________________________________________
195 const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
196
197 //_____________________________________________________________________________
198 AliReconstruction::AliReconstruction(const char* gAliceFilename,
199                                      const char* name, const char* title) :
200   TNamed(name, title),
201
202   fUniformField(kTRUE),
203   fRunVertexFinder(kTRUE),
204   fRunVertexFinderTracks(kTRUE),
205   fRunHLTTracking(kFALSE),
206   fRunMuonTracking(kFALSE),
207   fRunV0Finder(kTRUE),
208   fRunCascadeFinder(kTRUE),
209   fStopOnError(kFALSE),
210   fWriteAlignmentData(kFALSE),
211   fWriteESDfriend(kFALSE),
212   fWriteAOD(kFALSE),
213   fFillTriggerESD(kTRUE),
214
215   fCleanESD(kTRUE),
216   fV0DCAmax(3.),
217   fV0CsPmin(0.),
218   fDmax(50.),
219   fZmax(50.),
220
221   fRunLocalReconstruction("ALL"),
222   fRunTracking("ALL"),
223   fFillESD("ALL"),
224   fUseTrackingErrorsForAlignment(""),
225   fGAliceFileName(gAliceFilename),
226   fInput(""),
227   fpEvent(NULL),
228   fEquipIdMap(""),
229   fFirstEvent(0),
230   fLastEvent(-1),
231   fNumberOfEventsPerFile(1),
232   fCheckPointLevel(0),
233   fOptions(),
234   fLoadAlignFromCDB(kTRUE),
235   fLoadAlignData("ALL"),
236   fESDPar(""),
237   fUseHLTData(),
238
239   fRunLoader(NULL),
240   fRawReader(NULL),
241   fParentRawReader(NULL),
242
243   fVertexer(NULL),
244   fDiamondProfile(NULL),
245   fDiamondProfileTPC(NULL),
246   fMeanVertexConstraint(kTRUE),
247
248   fGRPList(NULL),
249
250   fAlignObjArray(NULL),
251   fCDBUri(),
252   fSpecCDBUri(), 
253   fInitCDBCalled(kFALSE),
254   fSetRunNumberFromDataCalled(kFALSE),
255   fRunQA(kTRUE),  
256   fRunGlobalQA(kTRUE),
257   fInLoopQA(kFALSE),
258   fSameQACycle(kFALSE),
259
260   fRunPlaneEff(kFALSE),
261
262   fesd(NULL),
263   fhltesd(NULL),
264   fesdf(NULL),
265   ffile(NULL),
266   ftree(NULL),
267   fhlttree(NULL),
268   ffileOld(NULL),
269   ftreeOld(NULL),
270   fhlttreeOld(NULL),
271   ftVertexer(NULL),
272   fIsNewRunLoader(kFALSE)
273 {
274 // create reconstruction object with default parameters
275   
276   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
277     fReconstructor[iDet] = NULL;
278     fLoader[iDet] = NULL;
279     fTracker[iDet] = NULL;
280     fQADataMaker[iDet] = NULL;
281         fQACycles[iDet] = 999999;       
282   }
283   fQADataMaker[fgkNDetectors]=NULL;  //Global QA
284   AliPID pid;
285 }
286
287 //_____________________________________________________________________________
288 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
289   TNamed(rec),
290
291   fUniformField(rec.fUniformField),
292   fRunVertexFinder(rec.fRunVertexFinder),
293   fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
294   fRunHLTTracking(rec.fRunHLTTracking),
295   fRunMuonTracking(rec.fRunMuonTracking),
296   fRunV0Finder(rec.fRunV0Finder),
297   fRunCascadeFinder(rec.fRunCascadeFinder),
298   fStopOnError(rec.fStopOnError),
299   fWriteAlignmentData(rec.fWriteAlignmentData),
300   fWriteESDfriend(rec.fWriteESDfriend),
301   fWriteAOD(rec.fWriteAOD),
302   fFillTriggerESD(rec.fFillTriggerESD),
303
304   fCleanESD(rec.fCleanESD),
305   fV0DCAmax(rec.fV0DCAmax),
306   fV0CsPmin(rec.fV0CsPmin),
307   fDmax(rec.fDmax),
308   fZmax(rec.fZmax),
309
310   fRunLocalReconstruction(rec.fRunLocalReconstruction),
311   fRunTracking(rec.fRunTracking),
312   fFillESD(rec.fFillESD),
313   fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
314   fGAliceFileName(rec.fGAliceFileName),
315   fInput(rec.fInput),
316   fpEvent(rec.fpEvent),
317   fEquipIdMap(rec.fEquipIdMap),
318   fFirstEvent(rec.fFirstEvent),
319   fLastEvent(rec.fLastEvent),
320   fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
321   fCheckPointLevel(0),
322   fOptions(),
323   fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
324   fLoadAlignData(rec.fLoadAlignData),
325   fESDPar(rec.fESDPar),
326   fUseHLTData(rec.fUseHLTData),
327
328   fRunLoader(NULL),
329   fRawReader(NULL),
330   fParentRawReader(NULL),
331
332   fVertexer(NULL),
333   fDiamondProfile(NULL),
334   fDiamondProfileTPC(NULL),
335   fMeanVertexConstraint(rec.fMeanVertexConstraint),
336
337   fGRPList(NULL),
338
339   fAlignObjArray(rec.fAlignObjArray),
340   fCDBUri(rec.fCDBUri),
341   fSpecCDBUri(), 
342   fInitCDBCalled(rec.fInitCDBCalled),
343   fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
344   fRunQA(rec.fRunQA),  
345   fRunGlobalQA(rec.fRunGlobalQA),
346   fInLoopQA(rec.fInLoopQA),
347   fSameQACycle(rec.fSameQACycle),
348   fRunPlaneEff(rec.fRunPlaneEff),
349
350   fesd(NULL),
351   fhltesd(NULL),
352   fesdf(NULL),
353   ffile(NULL),
354   ftree(NULL),
355   fhlttree(NULL),
356   ffileOld(NULL),
357   ftreeOld(NULL),
358   fhlttreeOld(NULL),
359   ftVertexer(NULL),
360   fIsNewRunLoader(rec.fIsNewRunLoader)
361 {
362 // copy constructor
363
364   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
365     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
366   }
367   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
368     fReconstructor[iDet] = NULL;
369     fLoader[iDet] = NULL;
370     fTracker[iDet] = NULL;
371     fQADataMaker[iDet] = NULL;
372         fQACycles[iDet] = rec.fQACycles[iDet];  
373   }
374   fQADataMaker[fgkNDetectors]=NULL;  //Global QA
375   for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
376     if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
377   }
378 }
379
380 //_____________________________________________________________________________
381 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
382 {
383 // assignment operator
384
385   this->~AliReconstruction();
386   new(this) AliReconstruction(rec);
387   return *this;
388 }
389
390 //_____________________________________________________________________________
391 AliReconstruction::~AliReconstruction()
392 {
393 // clean up
394
395   CleanUp();
396   fOptions.Delete();
397   fSpecCDBUri.Delete();
398
399   AliCodeTimer::Instance()->Print();
400 }
401
402 //_____________________________________________________________________________
403 void AliReconstruction::InitCDB()
404 {
405 // activate a default CDB storage
406 // First check if we have any CDB storage set, because it is used 
407 // to retrieve the calibration and alignment constants
408
409   if (fInitCDBCalled) return;
410   fInitCDBCalled = kTRUE;
411
412   AliCDBManager* man = AliCDBManager::Instance();
413   if (man->IsDefaultStorageSet())
414   {
415     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
416     AliWarning("Default CDB storage has been already set !");
417     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
418     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
419     fCDBUri = man->GetDefaultStorage()->GetURI();
420   }
421   else {
422     if (fCDBUri.Length() > 0) 
423     {
424         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
425         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
426         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
427     } else {
428         fCDBUri="local://$ALICE_ROOT";
429         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
430         AliWarning("Default CDB storage not yet set !!!!");
431         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
432         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
433                 
434     }
435     man->SetDefaultStorage(fCDBUri);
436   }
437
438   // Now activate the detector specific CDB storage locations
439   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
440     TObject* obj = fSpecCDBUri[i];
441     if (!obj) continue;
442     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
443     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
444     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
445     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
446   }
447   
448 }
449
450 //_____________________________________________________________________________
451 void AliReconstruction::SetDefaultStorage(const char* uri) {
452 // Store the desired default CDB storage location
453 // Activate it later within the Run() method
454
455   fCDBUri = uri;
456
457 }
458
459 //_____________________________________________________________________________
460 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
461 // Store a detector-specific CDB storage location
462 // Activate it later within the Run() method
463
464   AliCDBPath aPath(calibType);
465   if(!aPath.IsValid()){
466         // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
467         for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
468                 if(!strcmp(calibType, fgkDetectorName[iDet])) {
469                         aPath.SetPath(Form("%s/*", calibType));
470                         AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
471                         break;
472                 }
473         }
474         if(!aPath.IsValid()){
475                 AliError(Form("Not a valid path or detector: %s", calibType));
476                 return;
477         }
478   }
479
480 //  // check that calibType refers to a "valid" detector name
481 //  Bool_t isDetector = kFALSE;
482 //  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
483 //    TString detName = fgkDetectorName[iDet];
484 //    if(aPath.GetLevel0() == detName) {
485 //      isDetector = kTRUE;
486 //      break;
487 //    }
488 //  }
489 //
490 //  if(!isDetector) {
491 //      AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
492 //      return;
493 //  }
494
495   TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
496   if (obj) fSpecCDBUri.Remove(obj);
497   fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
498
499 }
500
501 //_____________________________________________________________________________
502 Bool_t AliReconstruction::SetRunNumberFromData()
503 {
504   // The method is called in Run() in order
505   // to set a correct run number.
506   // In case of raw data reconstruction the
507   // run number is taken from the raw data header
508
509   if (fSetRunNumberFromDataCalled) return kTRUE;
510   fSetRunNumberFromDataCalled = kTRUE;
511   
512   AliCDBManager* man = AliCDBManager::Instance();
513   
514   if(man->GetRun() > 0) {
515         AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
516   } 
517   
518   if (!fRunLoader) {
519       AliError("No run loader is found !"); 
520       return kFALSE;
521     }
522     // read run number from gAlice
523     if(fRunLoader->GetAliRun())
524       AliCDBManager::Instance()->SetRun(fRunLoader->GetHeader()->GetRun());
525     else {
526       if(fRawReader) {
527         if(fRawReader->NextEvent()) {
528           AliCDBManager::Instance()->SetRun(fRawReader->GetRunNumber());
529           fRawReader->RewindEvents();
530         }
531         else {
532           if(man->GetRun() > 0) {
533             AliWarning("No raw events is found ! Using settings in AliCDBManager !");
534             man->Print();  
535             return kTRUE;
536           }
537           else {
538             AliWarning("Neither raw events nor settings in AliCDBManager are found !");
539             return kFALSE;
540           }
541         }
542       }
543       else {
544         AliError("Neither gAlice nor RawReader objects are found !");
545         return kFALSE;
546       }
547   }
548
549   man->Print();  
550   
551   return kTRUE;
552 }
553
554 //_____________________________________________________________________________
555 void AliReconstruction::SetCDBLock() {
556   // Set CDB lock: from now on it is forbidden to reset the run number
557   // or the default storage or to activate any further storage!
558   
559   AliCDBManager::Instance()->SetLock(1);
560 }
561
562 //_____________________________________________________________________________
563 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
564 {
565   // Read the alignment objects from CDB.
566   // Each detector is supposed to have the
567   // alignment objects in DET/Align/Data CDB path.
568   // All the detector objects are then collected,
569   // sorted by geometry level (starting from ALIC) and
570   // then applied to the TGeo geometry.
571   // Finally an overlaps check is performed.
572
573   // Load alignment data from CDB and fill fAlignObjArray 
574   if(fLoadAlignFromCDB){
575         
576     TString detStr = detectors;
577     TString loadAlObjsListOfDets = "";
578     
579     for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
580       if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
581       loadAlObjsListOfDets += fgkDetectorName[iDet];
582       loadAlObjsListOfDets += " ";
583     } // end loop over detectors
584     loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
585     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
586   }else{
587     // Check if the array with alignment objects was
588     // provided by the user. If yes, apply the objects
589     // to the present TGeo geometry
590     if (fAlignObjArray) {
591       if (gGeoManager && gGeoManager->IsClosed()) {
592         if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
593           AliError("The misalignment of one or more volumes failed!"
594                    "Compare the list of simulated detectors and the list of detector alignment data!");
595           return kFALSE;
596         }
597       }
598       else {
599         AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
600         return kFALSE;
601       }
602     }
603   }
604   
605   delete fAlignObjArray; fAlignObjArray=0;
606
607   return kTRUE;
608 }
609
610 //_____________________________________________________________________________
611 void AliReconstruction::SetGAliceFile(const char* fileName)
612 {
613 // set the name of the galice file
614
615   fGAliceFileName = fileName;
616 }
617
618 //_____________________________________________________________________________
619 void AliReconstruction::SetInput(const char* input,void **pEvent) 
620 {
621   // In case event pointer is given, we run in an online mode
622   // and the first argument is ignored.
623   // In case event pointer is NULL, we run in a normal
624   // mode over a raw-data file and the first argument points
625   // to the name of that file
626   if (!pEvent) {
627     fInput = input;
628     fpEvent = NULL;
629   }
630   else {
631     fInput = "";
632     fpEvent = pEvent;
633   }
634 }
635
636 //_____________________________________________________________________________
637 void AliReconstruction::SetOption(const char* detector, const char* option)
638 {
639 // set options for the reconstruction of a detector
640
641   TObject* obj = fOptions.FindObject(detector);
642   if (obj) fOptions.Remove(obj);
643   fOptions.Add(new TNamed(detector, option));
644 }
645
646 //_____________________________________________________________________________
647 Bool_t AliReconstruction::Run(const char* input)
648 {
649   // Run Run Run
650   AliCodeTimerAuto("");
651
652   if (!InitRun(input)) return kFALSE;
653   
654   //******* The loop over events
655   Int_t iEvent = 0;
656   while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
657          (fRawReader && fRawReader->NextEvent())) {
658     if (!RunEvent(iEvent)) return kFALSE;
659     iEvent++;
660   }
661
662   if (!FinishRun()) return kFALSE;
663
664   return kTRUE;
665 }
666
667 //_____________________________________________________________________________
668 Bool_t AliReconstruction::InitRun(const char* input, void **pEvent)
669 {
670   // Initialize all the stuff before
671   // going into the event loop
672   // If the second argument is given, the first one is ignored and
673   // the reconstruction works in an online mode
674   AliCodeTimerAuto("");
675
676   if (pEvent) fpEvent = pEvent;
677   if (input) fInput = input;
678
679   // set the input in case of raw data
680   if (!fInput.IsNull() || fpEvent) {
681     if (!fInput.IsNull()) {
682       AliInfo(Form("Reconstruction will run over a raw-data file: %s",fInput.Data()));
683       TString fileName(fInput);
684       if (fInput.EndsWith("/")) {
685         fRawReader = new AliRawReaderFile(fInput);
686       } else if (fInput.EndsWith(".root")) {
687         fRawReader = new AliRawReaderRoot(fInput);
688       } else {
689         fRawReader = new AliRawReaderDate(fInput);
690       }
691     }
692     else {
693       AliInfo(Form("Reconstruction will run over an event in memory at: %p",*fpEvent));
694       fRawReader = new AliRawReaderDate((void *)(*fpEvent));
695     }
696   }
697   else {
698     AliInfo("Reconstruction will run over digits");
699   }
700
701   if (!fEquipIdMap.IsNull() && fRawReader)
702     fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
703
704   if (!fUseHLTData.IsNull()) {
705     // create the RawReaderHLT which performs redirection of HLT input data for
706     // the specified detectors
707     AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
708     if (pRawReader) {
709       fParentRawReader=fRawReader;
710       fRawReader=pRawReader;
711     } else {
712       AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
713     }
714   }
715
716    AliSysInfo::AddStamp("Start");
717   // get the run loader
718   if (!InitRunLoader()) return kFALSE;
719    AliSysInfo::AddStamp("LoadLoader");
720
721   // Initialize the CDB storage
722   InitCDB();
723   
724   AliSysInfo::AddStamp("LoadCDB");
725
726   // Set run number in CDBManager (if it is not already set by the user)
727   if (!SetRunNumberFromData()) if (fStopOnError) return kFALSE;
728   
729   // Set CDB lock: from now on it is forbidden to reset the run number
730   // or the default storage or to activate any further storage!
731   SetCDBLock();
732   
733   // Import ideal TGeo geometry and apply misalignment
734   if (!gGeoManager) {
735     TString geom(gSystem->DirName(fGAliceFileName));
736     geom += "/geometry.root";
737     AliGeomManager::LoadGeometry(geom.Data());
738     if (!gGeoManager) if (fStopOnError) return kFALSE;
739   }
740
741   if (!MisalignGeometry(fLoadAlignData)) if (fStopOnError) return kFALSE;
742    AliSysInfo::AddStamp("LoadGeom");
743
744   //QA
745   AliQADataMakerSteer qas ; 
746   if (fRunQA && fRawReader) { 
747     qas.Run(fRunLocalReconstruction, fRawReader) ; 
748         fSameQACycle = kTRUE ; 
749   }
750   // checking the QA of previous steps
751   //CheckQA() ; 
752  
753   /*
754   // local reconstruction
755   if (!fRunLocalReconstruction.IsNull()) {
756     if (!RunLocalReconstruction(fRunLocalReconstruction)) {
757       if (fStopOnError) {CleanUp(); return kFALSE;}
758     }
759   }
760   */
761
762   // get vertexer
763   if (fRunVertexFinder && !CreateVertexer()) {
764     if (fStopOnError) {
765       CleanUp(); 
766       return kFALSE;
767     }
768   }
769    AliSysInfo::AddStamp("Vertexer");
770
771   // get trackers
772   if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
773     if (fStopOnError) {
774       CleanUp(); 
775       return kFALSE;
776     }      
777   }
778    AliSysInfo::AddStamp("LoadTrackers");
779
780   // get the possibly already existing ESD file and tree
781   fesd = new AliESDEvent(); fhltesd = new AliESDEvent();
782   if (!gSystem->AccessPathName("AliESDs.root")){
783     gSystem->CopyFile("AliESDs.root", "AliESDs.old.root", kTRUE);
784     ffileOld = TFile::Open("AliESDs.old.root");
785     if (ffileOld && ffileOld->IsOpen()) {
786       ftreeOld = (TTree*) ffileOld->Get("esdTree");
787       if (ftreeOld)fesd->ReadFromTree(ftreeOld);
788       fhlttreeOld = (TTree*) ffileOld->Get("HLTesdTree");
789       if (fhlttreeOld)  fhltesd->ReadFromTree(fhlttreeOld);
790     }
791   }
792
793   // create the ESD output file and tree
794   ffile = TFile::Open("AliESDs.root", "RECREATE");
795   ffile->SetCompressionLevel(2);
796   if (!ffile->IsOpen()) {
797     AliError("opening AliESDs.root failed");
798     if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}    
799   }
800
801   ftree = new TTree("esdTree", "Tree with ESD objects");
802   fesd = new AliESDEvent();
803   fesd->CreateStdContent();
804   fesd->WriteToTree(ftree);
805
806   fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
807   fhltesd = new AliESDEvent();
808   fhltesd->CreateStdContent();
809   fhltesd->WriteToTree(fhlttree);
810
811   /* CKB Why?
812   delete esd; delete hltesd;
813   esd = NULL; hltesd = NULL;
814   */
815   // create the branch with ESD additions
816
817
818
819   if (fWriteESDfriend) {
820     fesdf = new AliESDfriend();
821     TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
822     br->SetFile("AliESDfriends.root");
823     fesd->AddObject(fesdf);
824   }
825
826   
827   // Get the GRP CDB entry
828   AliCDBEntry* entryGRP = AliCDBManager::Instance()->Get("GRP/GRP/Data");
829         
830   if(entryGRP) {
831         fGRPList = dynamic_cast<TList*> (entryGRP->GetObject());  
832   } else {
833         AliError("No GRP entry found in OCDB!");
834   }
835
836   // Get the diamond profile from OCDB
837   AliCDBEntry* entry = AliCDBManager::Instance()
838         ->Get("GRP/Calib/MeanVertex");
839         
840   if(entry) {
841         fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());  
842   } else {
843         AliError("No diamond profile found in OCDB!");
844   }
845
846   entry = 0;
847   entry = AliCDBManager::Instance()
848         ->Get("GRP/Calib/MeanVertexTPC");
849         
850   if(entry) {
851         fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());  
852   } else {
853         AliError("No diamond profile found in OCDB!");
854   }
855
856   ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
857   if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
858
859   if (fRawReader) fRawReader->RewindEvents();
860
861   ProcInfo_t ProcInfo;
862   gSystem->GetProcInfo(&ProcInfo);
863   AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
864   
865
866   //Initialize the QA and start of cycle for out-of-cycle QA
867   if (fRunQA) {
868      TString detStr(fFillESD); 
869      for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
870         if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
871         AliQADataMakerRec *qadm = GetQADataMaker(iDet);  
872         if (!qadm) continue;
873         AliInfo(Form("Initializing the QA data maker for %s", 
874                fgkDetectorName[iDet]));
875         qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
876         qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
877         if (!fInLoopQA) {
878                         qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
879                         qadm->StartOfCycle(AliQA::kESDS,"same");
880         }
881      }
882           if (fRunGlobalQA) {
883                   AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
884                   AliInfo(Form("Initializing the global QA data maker"));
885                   TObjArray *arr=
886                         qadm->Init(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun());
887                   AliTracker::SetResidualsArray(arr);
888                   qadm->Init(AliQA::kESDS, AliCDBManager::Instance()->GetRun());
889                   if (!fInLoopQA) {
890                           qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
891                           qadm->StartOfCycle(AliQA::kESDS, "same");
892                   }
893           }
894           if (!fInLoopQA) 
895                   fSameQACycle = kTRUE; 
896   }
897
898   //Initialize the Plane Efficiency framework
899   if (fRunPlaneEff && !InitPlaneEff()) {
900     if(fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
901   }
902
903   return kTRUE;
904 }
905
906 //_____________________________________________________________________________
907 Bool_t AliReconstruction::RunEvent(Int_t iEvent)
908 {
909   // run the reconstruction over a single event
910   // The event loop is steered in Run method
911
912   AliCodeTimerAuto("");
913
914   if (iEvent >= fRunLoader->GetNumberOfEvents()) {
915     fRunLoader->SetEventNumber(iEvent);
916     fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(), 
917                                    iEvent, iEvent);
918     //??      fRunLoader->MakeTree("H");
919     fRunLoader->TreeE()->Fill();
920   }
921
922   if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
923     // copy old ESD to the new one
924     if (ftreeOld) {
925       fesd->ReadFromTree(ftreeOld);
926       ftreeOld->GetEntry(iEvent);
927       ftree->Fill();
928     }
929     if (fhlttreeOld) {
930       fesd->ReadFromTree(fhlttreeOld);
931       fhlttreeOld->GetEntry(iEvent);
932       fhlttree->Fill();
933     }
934     return kTRUE;
935   }
936
937   AliInfo(Form("processing event %d", iEvent));
938
939     //Start of cycle for the in-loop QA
940     if (fInLoopQA) {
941        if (fRunQA) {
942           TString detStr(fFillESD); 
943           for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
944              if (!IsSelected(fgkDetectorName[iDet], detStr)) 
945                                  continue;
946              AliQADataMakerRec *qadm = GetQADataMaker(iDet);  
947              if (!qadm) 
948                                  continue;
949              qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
950              qadm->StartOfCycle(AliQA::kESDS, "same") ;         
951           }
952                    if (fRunGlobalQA) {
953                            AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
954                            qadm->StartOfCycle(AliQA::kRECPOINTS, fSameQACycle);
955                            qadm->StartOfCycle(AliQA::kESDS, "same");
956                    }               
957            }
958     }
959
960     fRunLoader->GetEvent(iEvent);
961
962     char aFileName[256];
963     sprintf(aFileName, "ESD_%d.%d_final.root", 
964             fRunLoader->GetHeader()->GetRun(), 
965             fRunLoader->GetHeader()->GetEventNrInRun());
966     if (!gSystem->AccessPathName(aFileName)) return kTRUE;
967
968     // local signle event reconstruction
969     if (!fRunLocalReconstruction.IsNull()) {
970       if (!RunLocalEventReconstruction(fRunLocalReconstruction)) {
971         if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
972       }
973     }
974
975     fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
976     fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
977     fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
978     fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
979     
980     // Set magnetic field from the tracker
981     fesd->SetMagneticField(AliTracker::GetBz());
982     fhltesd->SetMagneticField(AliTracker::GetBz());
983
984     
985     
986     // Fill raw-data error log into the ESD
987     if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
988
989     // vertex finder
990     if (fRunVertexFinder) {
991       if (!ReadESD(fesd, "vertex")) {
992         if (!RunVertexFinder(fesd)) {
993           if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
994         }
995         if (fCheckPointLevel > 0) WriteESD(fesd, "vertex");
996       }
997     }
998
999     // HLT tracking
1000     if (!fRunTracking.IsNull()) {
1001       if (fRunHLTTracking) {
1002         fhltesd->SetPrimaryVertexSPD(fesd->GetVertex());
1003         if (!RunHLTTracking(fhltesd)) {
1004           if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1005         }
1006       }
1007     }
1008
1009     // Muon tracking
1010     if (!fRunTracking.IsNull()) {
1011       if (fRunMuonTracking) {
1012         if (!RunMuonTracking(fesd)) {
1013           if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1014         }
1015       }
1016     }
1017
1018     // barrel tracking
1019     if (!fRunTracking.IsNull()) {
1020       if (!ReadESD(fesd, "tracking")) {
1021         if (!RunTracking(fesd)) {
1022           if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1023         }
1024         if (fCheckPointLevel > 0) WriteESD(fesd, "tracking");
1025       }
1026     }
1027
1028     // fill ESD
1029     if (!fFillESD.IsNull()) {
1030       if (!FillESD(fesd, fFillESD)) {
1031         if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1032       }
1033     }
1034   
1035     // fill Event header information from the RawEventHeader
1036     if (fRawReader){FillRawEventHeaderESD(fesd);}
1037
1038     // combined PID
1039     AliESDpid::MakePID(fesd);
1040     if (fCheckPointLevel > 1) WriteESD(fesd, "PID");
1041
1042     if (fFillTriggerESD) {
1043       if (!ReadESD(fesd, "trigger")) {
1044         if (!FillTriggerESD(fesd)) {
1045           if (fStopOnError) {CleanUp(ffile, ffileOld); return kFALSE;}
1046         }
1047         if (fCheckPointLevel > 1) WriteESD(fesd, "trigger");
1048       }
1049     }
1050
1051     ffile->cd();
1052
1053     //
1054     // Propagate track to the beam pipe  (if not laready done by ITS)
1055     //
1056     const Int_t ntracks = fesd->GetNumberOfTracks();
1057     const Double_t kBz = fesd->GetMagneticField();
1058     const Double_t kRadius  = 2.8; //something less than the beam pipe radius
1059
1060     TObjArray trkArray;
1061     UShort_t *selectedIdx=new UShort_t[ntracks];
1062
1063     for (Int_t itrack=0; itrack<ntracks; itrack++){
1064       const Double_t kMaxStep = 5;   //max step over the material
1065       Bool_t ok;
1066
1067       AliESDtrack *track = fesd->GetTrack(itrack);
1068       if (!track) continue;
1069
1070       AliExternalTrackParam *tpcTrack =
1071            (AliExternalTrackParam *)track->GetTPCInnerParam();
1072       ok = kFALSE;
1073       if (tpcTrack)
1074         ok = AliTracker::
1075           PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
1076
1077
1078
1079       if (ok) {
1080         Int_t n=trkArray.GetEntriesFast();
1081         selectedIdx[n]=track->GetID();
1082         trkArray.AddLast(tpcTrack);
1083       }
1084
1085       if (track->GetX() < kRadius) continue;
1086
1087       ok = AliTracker::
1088            PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
1089       if (ok) {
1090          track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kRadius);
1091       }
1092     }
1093
1094     //
1095     // Improve the reconstructed primary vertex position using the tracks
1096     //
1097     TObject *obj = fOptions.FindObject("ITS");
1098     if (obj) {
1099       TString optITS = obj->GetTitle();
1100       if (optITS.Contains("cosmics") || optITS.Contains("COSMICS")) 
1101         fRunVertexFinderTracks=kFALSE;
1102     }
1103     if (fRunVertexFinderTracks) {
1104        // TPC + ITS primary vertex
1105        ftVertexer->SetITSrefitRequired();
1106        if(fDiamondProfile && fMeanVertexConstraint) {
1107          ftVertexer->SetVtxStart(fDiamondProfile);
1108        } else {
1109          ftVertexer->SetConstraintOff();
1110        }
1111        AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
1112        if (pvtx) {
1113           if (pvtx->GetStatus()) {
1114              fesd->SetPrimaryVertex(pvtx);
1115              for (Int_t i=0; i<ntracks; i++) {
1116                  AliESDtrack *t = fesd->GetTrack(i);
1117                  t->RelateToVertex(pvtx, kBz, kRadius);
1118              } 
1119           }
1120        }
1121
1122        // TPC-only primary vertex
1123        ftVertexer->SetITSrefitNotRequired();
1124        if(fDiamondProfileTPC && fMeanVertexConstraint) {
1125          ftVertexer->SetVtxStart(fDiamondProfileTPC);
1126        } else {
1127          ftVertexer->SetConstraintOff();
1128        }
1129        pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
1130        if (pvtx) {
1131           if (pvtx->GetStatus()) {
1132              fesd->SetPrimaryVertexTPC(pvtx);
1133              Int_t nsel=trkArray.GetEntriesFast();
1134              for (Int_t i=0; i<nsel; i++) {
1135                  AliExternalTrackParam *t = 
1136                    (AliExternalTrackParam *)trkArray.UncheckedAt(i);
1137                  t->PropagateToDCA(pvtx, kBz, kRadius);
1138              } 
1139           }
1140        }
1141
1142     }
1143     delete[] selectedIdx;
1144
1145     if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
1146     
1147
1148     if (fRunV0Finder) {
1149        // V0 finding
1150        AliV0vertexer vtxer;
1151        vtxer.Tracks2V0vertices(fesd);
1152
1153        if (fRunCascadeFinder) {
1154           // Cascade finding
1155           AliCascadeVertexer cvtxer;
1156           cvtxer.V0sTracks2CascadeVertices(fesd);
1157        }
1158     }
1159  
1160     // write ESD
1161     if (fCleanESD) CleanESD(fesd);
1162
1163     if (fRunGlobalQA) {
1164        AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1165        if (qadm) qadm->Exec(AliQA::kESDS, fesd);
1166     }
1167
1168     if (fWriteESDfriend) {
1169       fesdf->~AliESDfriend();
1170       new (fesdf) AliESDfriend(); // Reset...
1171       fesd->GetESDfriend(fesdf);
1172     }
1173     ftree->Fill();
1174
1175     // write HLT ESD
1176     fhlttree->Fill();
1177
1178     if (fCheckPointLevel > 0)  WriteESD(fesd, "final"); 
1179     fesd->Reset();
1180     fhltesd->Reset();
1181     if (fWriteESDfriend) {
1182       fesdf->~AliESDfriend();
1183       new (fesdf) AliESDfriend(); // Reset...
1184     }
1185  
1186     ProcInfo_t ProcInfo;
1187     gSystem->GetProcInfo(&ProcInfo);
1188     AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
1189   
1190
1191   // End of cycle for the in-loop QA
1192      if (fInLoopQA) {
1193         if (fRunQA) {
1194            RunQA(fFillESD.Data(), fesd);
1195            TString detStr(fFillESD); 
1196            for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1197                            if (!IsSelected(fgkDetectorName[iDet], detStr)) 
1198                                    continue;
1199                            AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1200                            if (!qadm) 
1201                                    continue;
1202                            qadm->EndOfCycle(AliQA::kRECPOINTS);
1203                            qadm->EndOfCycle(AliQA::kESDS);
1204                            qadm->Finish();
1205                    }
1206         }
1207         if (fRunGlobalQA) {
1208            AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1209            if (qadm) {
1210               qadm->EndOfCycle(AliQA::kRECPOINTS);
1211               qadm->EndOfCycle(AliQA::kESDS);
1212               qadm->Finish();
1213            }
1214         }
1215      }
1216
1217      return kTRUE;
1218 }
1219
1220 //_____________________________________________________________________________
1221 Bool_t AliReconstruction::AddEventAndRun()
1222 {
1223   // for online usage only
1224   // Add an event to the run-loader
1225   // and
1226   // re-creates AliRawReaderDate for this new event
1227   AliCodeTimerAuto("");
1228
1229   if (!fpEvent) {
1230     AliError("No raw-data event in memory given as an input! Do nothing!");
1231     return kFALSE;
1232   }
1233
1234   // New raw-reader. Could be redone in a better way... To do
1235   fRawReader->~AliRawReader();
1236   new (fRawReader) AliRawReaderDate((void*)(*fpEvent));
1237   if (!fRawReader->NextEvent()) return kFALSE;
1238
1239   // Expand the number of events in the run-loader
1240
1241   Int_t nEvents = fRunLoader->GetNumberOfEvents();
1242
1243   return RunEvent(nEvents);
1244 }
1245
1246 //_____________________________________________________________________________
1247 Bool_t AliReconstruction::FinishRun()
1248 {
1249   // Finalize the run
1250   // Called after the exit
1251   // from the event loop
1252   AliCodeTimerAuto("");
1253
1254   if (fIsNewRunLoader) { // galice.root didn't exist
1255     fRunLoader->WriteHeader("OVERWRITE");
1256     fRunLoader->CdGAFile();
1257     fRunLoader->Write(0, TObject::kOverwrite);
1258   }
1259
1260   ftree->GetUserInfo()->Add(fesd);
1261   fhlttree->GetUserInfo()->Add(fhltesd);
1262   
1263   const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();       
1264   const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();   
1265                  
1266    TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());    
1267    cdbMapCopy->SetOwner(1);      
1268    cdbMapCopy->SetName("cdbMap");        
1269    TIter iter(cdbMap->GetTable());       
1270          
1271    TPair* pair = 0;      
1272    while((pair = dynamic_cast<TPair*> (iter.Next()))){   
1273          TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());   
1274          TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());         
1275          cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));  
1276    }     
1277          
1278    TList *cdbListCopy = new TList();     
1279    cdbListCopy->SetOwner(1);     
1280    cdbListCopy->SetName("cdbList");      
1281          
1282    TIter iter2(cdbList);         
1283          
1284    AliCDBId* id=0;       
1285    while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){         
1286          cdbListCopy->Add(new TObjString(id->ToString().Data()));        
1287    }     
1288          
1289    ftree->GetUserInfo()->Add(cdbMapCopy);        
1290    ftree->GetUserInfo()->Add(cdbListCopy);
1291
1292
1293   if(fESDPar.Contains("ESD.par")){
1294     AliInfo("Attaching ESD.par to Tree");
1295     TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
1296     ftree->GetUserInfo()->Add(fn);
1297   }
1298
1299
1300   ffile->cd();
1301
1302   if (fWriteESDfriend)
1303     ftree->SetBranchStatus("ESDfriend*",0);
1304   // we want to have only one tree version number
1305   ftree->Write(ftree->GetName(),TObject::kOverwrite);
1306   fhlttree->Write();
1307
1308 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
1309   if (fRunPlaneEff && !FinishPlaneEff()) {
1310    AliWarning("Finish PlaneEff evaluation failed");
1311   }
1312
1313   gROOT->cd();
1314   CleanUp(ffile, ffileOld);
1315     
1316   if (fWriteAOD) {
1317     AliWarning("AOD creation not supported anymore during reconstruction. See ANALYSIS/AliAnalysisTaskESDfilter.cxx instead.");
1318   }
1319
1320   // Create tags for the events in the ESD tree (the ESD tree is always present)
1321   // In case of empty events the tags will contain dummy values
1322   AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
1323   esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPList);
1324   if (fWriteAOD) {
1325     AliWarning("AOD tag creation not supported anymore during reconstruction.");
1326   }
1327
1328   //Finish QA and end of cycle for out-of-loop QA
1329   if (!fInLoopQA) {
1330      if (fRunQA) {
1331        AliQADataMakerSteer qas;
1332        qas.Run(fRunLocalReconstruction.Data(), AliQA::kRECPOINTS, fSameQACycle);
1333        //qas.Reset() ;
1334        qas.Run(fRunTracking.Data(), AliQA::kESDS, fSameQACycle);
1335      }
1336      if (fRunGlobalQA) {
1337         AliQADataMakerRec *qadm = GetQADataMaker(AliQA::kGLOBAL);
1338         if (qadm) {
1339            qadm->EndOfCycle(AliQA::kRECPOINTS);
1340            qadm->EndOfCycle(AliQA::kESDS);
1341            qadm->Finish();
1342         }
1343      }
1344   }
1345   
1346   // Cleanup of CDB manager: cache and active storages!
1347   AliCDBManager::Instance()->ClearCache();
1348   
1349   return kTRUE;
1350 }
1351
1352
1353 //_____________________________________________________________________________
1354 Bool_t AliReconstruction::RunLocalReconstruction(const TString& /*detectors*/)
1355 {
1356 // run the local reconstruction
1357   static Int_t eventNr=0;
1358   AliCodeTimerAuto("")
1359
1360  //  AliCDBManager* man = AliCDBManager::Instance();
1361 //   Bool_t origCache = man->GetCacheFlag();
1362
1363 //   TString detStr = detectors;
1364 //   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1365 //     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1366 //     AliReconstructor* reconstructor = GetReconstructor(iDet);
1367 //     if (!reconstructor) continue;
1368 //     if (reconstructor->HasLocalReconstruction()) continue;
1369
1370 //     AliCodeTimerStart(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1371 //     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1372     
1373 //     AliCodeTimerStart(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));                          
1374 //     AliInfo(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1375
1376 //     man->SetCacheFlag(kTRUE);
1377 //     TString calibPath = Form("%s/Calib/*", fgkDetectorName[iDet]);
1378 //     man->GetAll(calibPath); // entries are cached!
1379
1380 //     AliCodeTimerStop(Form("Loading calibration data from OCDB for %s", fgkDetectorName[iDet]));
1381      
1382 //     if (fRawReader) {
1383 //       fRawReader->RewindEvents();
1384 //       reconstructor->Reconstruct(fRunLoader, fRawReader);
1385 //     } else {
1386 //       reconstructor->Reconstruct(fRunLoader);
1387 //     }
1388      
1389 //      AliCodeTimerStop(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1390     // AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr));
1391
1392 //     // unload calibration data
1393 //     man->UnloadFromCache(calibPath);
1394 //     //man->ClearCache();
1395 //   }
1396
1397 //   man->SetCacheFlag(origCache);
1398
1399 //   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1400 //     AliError(Form("the following detectors were not found: %s",
1401 //                   detStr.Data()));
1402 //     if (fStopOnError) return kFALSE;
1403 //   }
1404
1405           eventNr++;
1406   return kTRUE;
1407 }
1408
1409 //_____________________________________________________________________________
1410 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1411 {
1412 // run the local reconstruction
1413
1414   static Int_t eventNr=0;
1415   AliCodeTimerAuto("")
1416
1417   TString detStr = detectors;
1418   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1419     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1420     AliReconstructor* reconstructor = GetReconstructor(iDet);
1421     if (!reconstructor) continue;
1422     AliLoader* loader = fLoader[iDet];
1423     if (!loader) {
1424       AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1425       continue;
1426     }
1427     // conversion of digits
1428     if (fRawReader && reconstructor->HasDigitConversion()) {
1429       AliInfo(Form("converting raw data digits into root objects for %s", 
1430                    fgkDetectorName[iDet]));
1431       AliCodeTimerAuto(Form("converting raw data digits into root objects for %s", 
1432                             fgkDetectorName[iDet]));
1433       loader->LoadDigits("update");
1434       loader->CleanDigits();
1435       loader->MakeDigitsContainer();
1436       TTree* digitsTree = loader->TreeD();
1437       reconstructor->ConvertDigits(fRawReader, digitsTree);
1438       loader->WriteDigits("OVERWRITE");
1439       loader->UnloadDigits();
1440     }
1441     // local reconstruction
1442     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1443     AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1444     loader->LoadRecPoints("update");
1445     loader->CleanRecPoints();
1446     loader->MakeRecPointsContainer();
1447     TTree* clustersTree = loader->TreeR();
1448     if (fRawReader && !reconstructor->HasDigitConversion()) {
1449       reconstructor->Reconstruct(fRawReader, clustersTree);
1450     } else {
1451       loader->LoadDigits("read");
1452       TTree* digitsTree = loader->TreeD();
1453       if (!digitsTree) {
1454         AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1455         if (fStopOnError) return kFALSE;
1456       } else {
1457         reconstructor->Reconstruct(digitsTree, clustersTree);
1458       }
1459       loader->UnloadDigits();
1460     }
1461
1462     // In-loop QA for local reconstrucion 
1463     if (fRunQA && fInLoopQA) {
1464        AliQADataMakerRec * qadm = GetQADataMaker(iDet);
1465        if (qadm) {
1466           //AliCodeTimerStart
1467           //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1468           //AliInfo
1469           //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1470
1471           qadm->Exec(AliQA::kRECPOINTS, clustersTree) ;
1472  
1473           //AliCodeTimerStop
1474           //(Form("Running QA data maker for %s", fgkDetectorName[iDet]));
1475        }
1476     }
1477
1478     loader->WriteRecPoints("OVERWRITE");
1479     loader->UnloadRecPoints();
1480     AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
1481   }
1482
1483   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1484     AliError(Form("the following detectors were not found: %s",
1485                   detStr.Data()));
1486     if (fStopOnError) return kFALSE;
1487   }
1488   eventNr++;
1489   return kTRUE;
1490 }
1491
1492 //_____________________________________________________________________________
1493 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
1494 {
1495 // run the barrel tracking
1496
1497   AliCodeTimerAuto("")
1498
1499   AliESDVertex* vertex = NULL;
1500   Double_t vtxPos[3] = {0, 0, 0};
1501   Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1502   TArrayF mcVertex(3); 
1503   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1504     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1505     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1506   }
1507
1508   if (fVertexer) {
1509     if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
1510     AliInfo("running the ITS vertex finder");
1511     if (fLoader[0]) fLoader[0]->LoadRecPoints();
1512     vertex = fVertexer->FindVertexForCurrentEvent(fRunLoader->GetEventNumber());
1513     if (fLoader[0]) fLoader[0]->UnloadRecPoints();
1514     if(!vertex){
1515       AliWarning("Vertex not found");
1516       vertex = new AliESDVertex();
1517       vertex->SetName("default");
1518     }
1519     else {
1520       vertex->SetName("reconstructed");
1521     }
1522
1523   } else {
1524     AliInfo("getting the primary vertex from MC");
1525     vertex = new AliESDVertex(vtxPos, vtxErr);
1526   }
1527
1528   if (vertex) {
1529     vertex->GetXYZ(vtxPos);
1530     vertex->GetSigmaXYZ(vtxErr);
1531   } else {
1532     AliWarning("no vertex reconstructed");
1533     vertex = new AliESDVertex(vtxPos, vtxErr);
1534   }
1535   esd->SetPrimaryVertexSPD(vertex);
1536   // if SPD multiplicity has been determined, it is stored in the ESD
1537   AliMultiplicity *mult = fVertexer->GetMultiplicity();
1538   if(mult)esd->SetMultiplicity(mult);
1539
1540   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1541     if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1542   }  
1543   delete vertex;
1544
1545   return kTRUE;
1546 }
1547
1548 //_____________________________________________________________________________
1549 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1550 {
1551 // run the HLT barrel tracking
1552
1553   AliCodeTimerAuto("")
1554
1555   if (!fRunLoader) {
1556     AliError("Missing runLoader!");
1557     return kFALSE;
1558   }
1559
1560   AliInfo("running HLT tracking");
1561
1562   // Get a pointer to the HLT reconstructor
1563   AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1564   if (!reconstructor) return kFALSE;
1565
1566   // TPC + ITS
1567   for (Int_t iDet = 1; iDet >= 0; iDet--) {
1568     TString detName = fgkDetectorName[iDet];
1569     AliDebug(1, Form("%s HLT tracking", detName.Data()));
1570     reconstructor->SetOption(detName.Data());
1571     AliTracker *tracker = reconstructor->CreateTracker();
1572     if (!tracker) {
1573       AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1574       if (fStopOnError) return kFALSE;
1575       continue;
1576     }
1577     Double_t vtxPos[3];
1578     Double_t vtxErr[3]={0.005,0.005,0.010};
1579     const AliESDVertex *vertex = esd->GetVertex();
1580     vertex->GetXYZ(vtxPos);
1581     tracker->SetVertex(vtxPos,vtxErr);
1582     if(iDet != 1) {
1583       fLoader[iDet]->LoadRecPoints("read");
1584       TTree* tree = fLoader[iDet]->TreeR();
1585       if (!tree) {
1586         AliError(Form("Can't get the %s cluster tree", detName.Data()));
1587         return kFALSE;
1588       }
1589       tracker->LoadClusters(tree);
1590     }
1591     if (tracker->Clusters2Tracks(esd) != 0) {
1592       AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1593       return kFALSE;
1594     }
1595     if(iDet != 1) {
1596       tracker->UnloadClusters();
1597     }
1598     delete tracker;
1599   }
1600
1601   return kTRUE;
1602 }
1603
1604 //_____________________________________________________________________________
1605 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
1606 {
1607 // run the muon spectrometer tracking
1608
1609   AliCodeTimerAuto("")
1610
1611   if (!fRunLoader) {
1612     AliError("Missing runLoader!");
1613     return kFALSE;
1614   }
1615   Int_t iDet = 7; // for MUON
1616
1617   AliInfo("is running...");
1618
1619   // Get a pointer to the MUON reconstructor
1620   AliReconstructor *reconstructor = GetReconstructor(iDet);
1621   if (!reconstructor) return kFALSE;
1622
1623   
1624   TString detName = fgkDetectorName[iDet];
1625   AliDebug(1, Form("%s tracking", detName.Data()));
1626   AliTracker *tracker =  reconstructor->CreateTracker();
1627   if (!tracker) {
1628     AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
1629     return kFALSE;
1630   }
1631      
1632   // read RecPoints
1633   fLoader[iDet]->LoadRecPoints("read");  
1634
1635   tracker->LoadClusters(fLoader[iDet]->TreeR());
1636   
1637   Int_t rv = tracker->Clusters2Tracks(esd);
1638   
1639   if ( rv )
1640   {
1641     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1642     return kFALSE;
1643   }
1644   
1645   fLoader[iDet]->UnloadRecPoints();
1646
1647   tracker->UnloadClusters();
1648   
1649   delete tracker;
1650   
1651   return kTRUE;
1652 }
1653
1654
1655 //_____________________________________________________________________________
1656 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
1657 {
1658 // run the barrel tracking
1659   static Int_t eventNr=0;
1660   AliCodeTimerAuto("")
1661
1662   AliInfo("running tracking");
1663
1664   //Fill the ESD with the T0 info (will be used by the TOF) 
1665   if (fReconstructor[11] && fLoader[11]) {
1666     fLoader[11]->LoadRecPoints("READ");
1667     TTree *treeR = fLoader[11]->TreeR();
1668     GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
1669   }
1670
1671   // pass 1: TPC + ITS inwards
1672   for (Int_t iDet = 1; iDet >= 0; iDet--) {
1673     if (!fTracker[iDet]) continue;
1674     AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
1675
1676     // load clusters
1677     fLoader[iDet]->LoadRecPoints("read");
1678     AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
1679     TTree* tree = fLoader[iDet]->TreeR();
1680     if (!tree) {
1681       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1682       return kFALSE;
1683     }
1684     fTracker[iDet]->LoadClusters(tree);
1685     AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1686     // run tracking
1687     if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
1688       AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
1689       return kFALSE;
1690     }
1691     if (fCheckPointLevel > 1) {
1692       WriteESD(esd, Form("%s.tracking", fgkDetectorName[iDet]));
1693     }
1694     // preliminary PID in TPC needed by the ITS tracker
1695     if (iDet == 1) {
1696       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1697       AliESDpid::MakePID(esd);
1698     } 
1699     AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
1700   }
1701
1702   // pass 2: ALL backwards
1703
1704   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1705     if (!fTracker[iDet]) continue;
1706     AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
1707
1708     // load clusters
1709     if (iDet > 1) {     // all except ITS, TPC
1710       TTree* tree = NULL;
1711       fLoader[iDet]->LoadRecPoints("read");
1712       AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
1713       tree = fLoader[iDet]->TreeR();
1714       if (!tree) {
1715         AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
1716         return kFALSE;
1717       }
1718       fTracker[iDet]->LoadClusters(tree); 
1719       AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
1720     }
1721
1722     // run tracking
1723     if (iDet>1) // start filling residuals for the "outer" detectors
1724     if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);     
1725
1726     if (fTracker[iDet]->PropagateBack(esd) != 0) {
1727       AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
1728       //      return kFALSE;
1729     }
1730     if (fCheckPointLevel > 1) {
1731       WriteESD(esd, Form("%s.back", fgkDetectorName[iDet]));
1732     }
1733
1734     // unload clusters
1735     if (iDet > 2) {     // all except ITS, TPC, TRD
1736       fTracker[iDet]->UnloadClusters();
1737       fLoader[iDet]->UnloadRecPoints();
1738     }
1739     // updated PID in TPC needed by the ITS tracker -MI
1740     if (iDet == 1) {
1741       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
1742       AliESDpid::MakePID(esd);
1743     }
1744     AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1745   }
1746   //stop filling residuals for the "outer" detectors
1747   if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);     
1748
1749   // write space-points to the ESD in case alignment data output
1750   // is switched on
1751   if (fWriteAlignmentData)
1752     WriteAlignmentData(esd);
1753
1754   // pass 3: TRD + TPC + ITS refit inwards
1755
1756   for (Int_t iDet = 2; iDet >= 0; iDet--) {
1757     if (!fTracker[iDet]) continue;
1758     AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
1759
1760     // run tracking
1761     if (iDet<2) // start filling residuals for TPC and ITS
1762     if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);     
1763
1764     if (fTracker[iDet]->RefitInward(esd) != 0) {
1765       AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
1766       //      return kFALSE;
1767     }
1768     // run postprocessing
1769     if (fTracker[iDet]->PostProcess(esd) != 0) {
1770       AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
1771       //      return kFALSE;
1772     }
1773     if (fCheckPointLevel > 1) {
1774       WriteESD(esd, Form("%s.refit", fgkDetectorName[iDet]));
1775     }
1776     AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
1777     // unload clusters
1778     fTracker[iDet]->UnloadClusters();
1779     AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
1780     fLoader[iDet]->UnloadRecPoints();
1781     AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
1782   }
1783   // stop filling residuals for TPC and ITS
1784   if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);     
1785
1786   eventNr++;
1787   return kTRUE;
1788 }
1789
1790 //_____________________________________________________________________________
1791 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
1792   //
1793   // Remove the data which are not needed for the physics analysis.
1794   //
1795
1796   Int_t nTracks=esd->GetNumberOfTracks();
1797   Int_t nV0s=esd->GetNumberOfV0s();
1798   AliInfo
1799   (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
1800
1801   Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
1802   Bool_t rc=esd->Clean(cleanPars);
1803
1804   nTracks=esd->GetNumberOfTracks();
1805   nV0s=esd->GetNumberOfV0s();
1806   AliInfo
1807   (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
1808
1809   return rc;
1810 }
1811
1812 //_____________________________________________________________________________
1813 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
1814 {
1815 // fill the event summary data
1816
1817   AliCodeTimerAuto("")
1818     static Int_t eventNr=0; 
1819   TString detStr = detectors;
1820   
1821   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1822   if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1823     AliReconstructor* reconstructor = GetReconstructor(iDet);
1824     if (!reconstructor) continue;
1825     if (!ReadESD(esd, fgkDetectorName[iDet])) {
1826       AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
1827       TTree* clustersTree = NULL;
1828       if (fLoader[iDet]) {
1829         fLoader[iDet]->LoadRecPoints("read");
1830         clustersTree = fLoader[iDet]->TreeR();
1831         if (!clustersTree) {
1832           AliError(Form("Can't get the %s clusters tree", 
1833                         fgkDetectorName[iDet]));
1834           if (fStopOnError) return kFALSE;
1835         }
1836       }
1837       if (fRawReader && !reconstructor->HasDigitConversion()) {
1838         reconstructor->FillESD(fRawReader, clustersTree, esd);
1839       } else {
1840         TTree* digitsTree = NULL;
1841         if (fLoader[iDet]) {
1842           fLoader[iDet]->LoadDigits("read");
1843           digitsTree = fLoader[iDet]->TreeD();
1844           if (!digitsTree) {
1845             AliError(Form("Can't get the %s digits tree", 
1846                           fgkDetectorName[iDet]));
1847             if (fStopOnError) return kFALSE;
1848           }
1849         }
1850         reconstructor->FillESD(digitsTree, clustersTree, esd);
1851         if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
1852       }
1853       if (fLoader[iDet]) {
1854         fLoader[iDet]->UnloadRecPoints();
1855       }
1856
1857       if (fCheckPointLevel > 2) WriteESD(esd, fgkDetectorName[iDet]);
1858     }
1859   }
1860
1861   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1862     AliError(Form("the following detectors were not found: %s", 
1863                   detStr.Data()));
1864     if (fStopOnError) return kFALSE;
1865   }
1866   AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
1867   eventNr++;
1868   return kTRUE;
1869 }
1870
1871 //_____________________________________________________________________________
1872 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
1873 {
1874   // Reads the trigger decision which is
1875   // stored in Trigger.root file and fills
1876   // the corresponding esd entries
1877
1878   AliCodeTimerAuto("")
1879   
1880   AliInfo("Filling trigger information into the ESD");
1881
1882   AliCentralTrigger *aCTP = NULL;
1883
1884   if (fRawReader) {
1885     AliCTPRawStream input(fRawReader);
1886     if (!input.Next()) {
1887       AliError("No valid CTP (trigger) DDL raw data is found ! The trigger information is not stored in the ESD !");
1888       return kFALSE;
1889     }
1890     esd->SetTriggerMask(input.GetClassMask());
1891     esd->SetTriggerCluster(input.GetClusterMask());
1892
1893     aCTP = new AliCentralTrigger();
1894     TString configstr("");
1895     if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
1896       AliError("No trigger configuration found in OCDB! The trigger classes information will no be stored in ESD!");
1897       delete aCTP;
1898       return kFALSE;
1899     }
1900   }
1901   else {
1902     AliRunLoader *runloader = AliRunLoader::GetRunLoader();
1903     if (runloader) {
1904       if (!runloader->LoadTrigger()) {
1905         aCTP = runloader->GetTrigger();
1906         esd->SetTriggerMask(aCTP->GetClassMask());
1907         esd->SetTriggerCluster(aCTP->GetClusterMask());
1908       }
1909       else {
1910         AliWarning("No trigger can be loaded! The trigger information is not stored in the ESD !");
1911         return kFALSE;
1912       }
1913     }
1914     else {
1915       AliError("No run loader is available! The trigger information is not stored in the ESD !");
1916       return kFALSE;
1917     }
1918   }
1919
1920   // Now fill the trigger class names into AliESDRun object
1921   AliTriggerConfiguration *config = aCTP->GetConfiguration();
1922   if (!config) {
1923     AliError("No trigger configuration has been found! The trigger classes information will no be stored in ESD!");
1924     if (fRawReader) delete aCTP;
1925     return kFALSE;
1926   }
1927
1928   const TObjArray& classesArray = config->GetClasses();
1929   Int_t nclasses = classesArray.GetEntriesFast();
1930   for( Int_t j=0; j<nclasses; j++ ) {
1931     AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At( j );
1932     Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
1933     esd->SetTriggerClass(trclass->GetName(),trindex);
1934   }
1935
1936   if (fRawReader) delete aCTP;
1937   return kTRUE;
1938 }
1939
1940
1941
1942
1943
1944 //_____________________________________________________________________________
1945 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
1946 {
1947   // 
1948   // Filling information from RawReader Header
1949   // 
1950
1951   AliInfo("Filling information from RawReader Header");
1952   esd->SetBunchCrossNumber(0);
1953   esd->SetOrbitNumber(0);
1954   esd->SetPeriodNumber(0);
1955   esd->SetTimeStamp(0);
1956   esd->SetEventType(0);
1957   const AliRawEventHeaderBase * eventHeader = fRawReader->GetEventHeader();
1958   if (eventHeader){
1959
1960     const UInt_t *id = eventHeader->GetP("Id");
1961     esd->SetBunchCrossNumber((id)[1]&0x00000fff);
1962     esd->SetOrbitNumber((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff));
1963     esd->SetPeriodNumber(((id)[0]>>4)&0x0fffffff);
1964
1965     esd->SetTimeStamp((eventHeader->Get("Timestamp")));  
1966     esd->SetEventType((eventHeader->Get("Type")));
1967   }
1968
1969   return kTRUE;
1970 }
1971
1972
1973 //_____________________________________________________________________________
1974 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
1975 {
1976 // check whether detName is contained in detectors
1977 // if yes, it is removed from detectors
1978
1979   // check if all detectors are selected
1980   if ((detectors.CompareTo("ALL") == 0) ||
1981       detectors.BeginsWith("ALL ") ||
1982       detectors.EndsWith(" ALL") ||
1983       detectors.Contains(" ALL ")) {
1984     detectors = "ALL";
1985     return kTRUE;
1986   }
1987
1988   // search for the given detector
1989   Bool_t result = kFALSE;
1990   if ((detectors.CompareTo(detName) == 0) ||
1991       detectors.BeginsWith(detName+" ") ||
1992       detectors.EndsWith(" "+detName) ||
1993       detectors.Contains(" "+detName+" ")) {
1994     detectors.ReplaceAll(detName, "");
1995     result = kTRUE;
1996   }
1997
1998   // clean up the detectors string
1999   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
2000   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2001   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2002
2003   return result;
2004 }
2005
2006 //_____________________________________________________________________________
2007 Bool_t AliReconstruction::InitRunLoader()
2008 {
2009 // get or create the run loader
2010
2011   if (gAlice) delete gAlice;
2012   gAlice = NULL;
2013
2014   if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2015     // load all base libraries to get the loader classes
2016     TString libs = gSystem->GetLibraries();
2017     for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2018       TString detName = fgkDetectorName[iDet];
2019       if (detName == "HLT") continue;
2020       if (libs.Contains("lib" + detName + "base.so")) continue;
2021       gSystem->Load("lib" + detName + "base.so");
2022     }
2023     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2024     if (!fRunLoader) {
2025       AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2026       CleanUp();
2027       return kFALSE;
2028     }
2029     fRunLoader->CdGAFile();
2030     if (gFile->GetKey(AliRunLoader::GetGAliceName())) {
2031       if (fRunLoader->LoadgAlice() == 0) {
2032         gAlice = fRunLoader->GetAliRun();
2033         AliTracker::SetFieldMap(gAlice->Field(),fUniformField);
2034       }
2035     }
2036     if (!gAlice && !fRawReader) {
2037       AliError(Form("no gAlice object found in file %s",
2038                     fGAliceFileName.Data()));
2039       CleanUp();
2040       return kFALSE;
2041     }
2042
2043     //PH This is a temporary fix to give access to the kinematics
2044     //PH that is needed for the labels of ITS clusters
2045     fRunLoader->LoadHeader();
2046     fRunLoader->LoadKinematics();
2047
2048   } else {               // galice.root does not exist
2049     if (!fRawReader) {
2050       AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2051       CleanUp();
2052       return kFALSE;
2053     }
2054     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2055                                     AliConfig::GetDefaultEventFolderName(),
2056                                     "recreate");
2057     if (!fRunLoader) {
2058       AliError(Form("could not create run loader in file %s", 
2059                     fGAliceFileName.Data()));
2060       CleanUp();
2061       return kFALSE;
2062     }
2063     fIsNewRunLoader = kTRUE;
2064     fRunLoader->MakeTree("E");
2065
2066     if (fNumberOfEventsPerFile > 0)
2067       fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2068     else
2069       fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
2070   }
2071
2072   return kTRUE;
2073 }
2074
2075 //_____________________________________________________________________________
2076 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
2077 {
2078 // get the reconstructor object and the loader for a detector
2079
2080   if (fReconstructor[iDet]) return fReconstructor[iDet];
2081
2082   // load the reconstructor object
2083   TPluginManager* pluginManager = gROOT->GetPluginManager();
2084   TString detName = fgkDetectorName[iDet];
2085   TString recName = "Ali" + detName + "Reconstructor";
2086   if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) return NULL;
2087
2088   AliReconstructor* reconstructor = NULL;
2089   // first check if a plugin is defined for the reconstructor
2090   TPluginHandler* pluginHandler = 
2091     pluginManager->FindHandler("AliReconstructor", detName);
2092   // if not, add a plugin for it
2093   if (!pluginHandler) {
2094     AliDebug(1, Form("defining plugin for %s", recName.Data()));
2095     TString libs = gSystem->GetLibraries();
2096     if (libs.Contains("lib" + detName + "base.so") ||
2097         (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2098       pluginManager->AddHandler("AliReconstructor", detName, 
2099                                 recName, detName + "rec", recName + "()");
2100     } else {
2101       pluginManager->AddHandler("AliReconstructor", detName, 
2102                                 recName, detName, recName + "()");
2103     }
2104     pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2105   }
2106   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2107     reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
2108   }
2109   if (reconstructor) {
2110     TObject* obj = fOptions.FindObject(detName.Data());
2111     if (obj) reconstructor->SetOption(obj->GetTitle());
2112     reconstructor->Init();
2113     fReconstructor[iDet] = reconstructor;
2114   }
2115
2116   // get or create the loader
2117   if (detName != "HLT") {
2118     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2119     if (!fLoader[iDet]) {
2120       AliConfig::Instance()
2121         ->CreateDetectorFolders(fRunLoader->GetEventFolder(), 
2122                                 detName, detName);
2123       // first check if a plugin is defined for the loader
2124       pluginHandler = 
2125         pluginManager->FindHandler("AliLoader", detName);
2126       // if not, add a plugin for it
2127       if (!pluginHandler) {
2128         TString loaderName = "Ali" + detName + "Loader";
2129         AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2130         pluginManager->AddHandler("AliLoader", detName, 
2131                                   loaderName, detName + "base", 
2132                                   loaderName + "(const char*, TFolder*)");
2133         pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2134       }
2135       if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2136         fLoader[iDet] = 
2137           (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(), 
2138                                                  fRunLoader->GetEventFolder());
2139       }
2140       if (!fLoader[iDet]) {   // use default loader
2141         fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2142       }
2143       if (!fLoader[iDet]) {
2144         AliWarning(Form("couldn't get loader for %s", detName.Data()));
2145         if (fStopOnError) return NULL;
2146       } else {
2147         fRunLoader->AddLoader(fLoader[iDet]);
2148         fRunLoader->CdGAFile();
2149         if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2150         fRunLoader->Write(0, TObject::kOverwrite);
2151       }
2152     }
2153   }
2154       
2155   return reconstructor;
2156 }
2157
2158 //_____________________________________________________________________________
2159 Bool_t AliReconstruction::CreateVertexer()
2160 {
2161 // create the vertexer
2162
2163   fVertexer = NULL;
2164   AliReconstructor* itsReconstructor = GetReconstructor(0);
2165   if (itsReconstructor) {
2166     fVertexer = itsReconstructor->CreateVertexer();
2167   }
2168   if (!fVertexer) {
2169     AliWarning("couldn't create a vertexer for ITS");
2170     if (fStopOnError) return kFALSE;
2171   }
2172
2173   return kTRUE;
2174 }
2175
2176 //_____________________________________________________________________________
2177 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
2178 {
2179 // create the trackers
2180
2181   TString detStr = detectors;
2182   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2183     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2184     AliReconstructor* reconstructor = GetReconstructor(iDet);
2185     if (!reconstructor) continue;
2186     TString detName = fgkDetectorName[iDet];
2187     if (detName == "HLT") {
2188       fRunHLTTracking = kTRUE;
2189       continue;
2190     }
2191     if (detName == "MUON") {
2192       fRunMuonTracking = kTRUE;
2193       continue;
2194     }
2195
2196
2197     fTracker[iDet] = reconstructor->CreateTracker();
2198     if (!fTracker[iDet] && (iDet < 7)) {
2199       AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2200       if (fStopOnError) return kFALSE;
2201     }
2202     AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
2203   }
2204
2205   return kTRUE;
2206 }
2207
2208 //_____________________________________________________________________________
2209 void AliReconstruction::CleanUp(TFile* file, TFile* fileOld)
2210 {
2211 // delete trackers and the run loader and close and delete the file
2212
2213   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2214     delete fReconstructor[iDet];
2215     fReconstructor[iDet] = NULL;
2216     fLoader[iDet] = NULL;
2217     delete fTracker[iDet];
2218     fTracker[iDet] = NULL;
2219 //    delete fQADataMaker[iDet];
2220 //    fQADataMaker[iDet] = NULL;
2221   }
2222   delete fVertexer;
2223   fVertexer = NULL;
2224
2225   if (ftVertexer) delete ftVertexer;
2226   ftVertexer = NULL;
2227   
2228   if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2229         delete fDiamondProfile;
2230         fDiamondProfile = NULL;
2231         delete fDiamondProfileTPC;
2232         fDiamondProfileTPC = NULL;
2233         delete fGRPList;
2234         fGRPList = NULL;
2235   }
2236
2237
2238   delete fRunLoader;
2239   fRunLoader = NULL;
2240   delete fRawReader;
2241   fRawReader = NULL;
2242   if (fParentRawReader) delete fParentRawReader;
2243   fParentRawReader=NULL;
2244
2245   if (file) {
2246     file->Close();
2247     delete file;
2248   }
2249
2250   if (fileOld) {
2251     fileOld->Close();
2252     delete fileOld;
2253     gSystem->Unlink("AliESDs.old.root");
2254   }
2255
2256 }
2257
2258 //_____________________________________________________________________________
2259
2260 Bool_t AliReconstruction::ReadESD(AliESDEvent*& esd, const char* recStep) const
2261 {
2262 // read the ESD event from a file
2263
2264   if (!esd) return kFALSE;
2265   char fileName[256];
2266   sprintf(fileName, "ESD_%d.%d_%s.root", 
2267           esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
2268   if (gSystem->AccessPathName(fileName)) return kFALSE;
2269
2270   AliInfo(Form("reading ESD from file %s", fileName));
2271   AliDebug(1, Form("reading ESD from file %s", fileName));
2272   TFile* file = TFile::Open(fileName);
2273   if (!file || !file->IsOpen()) {
2274     AliError(Form("opening %s failed", fileName));
2275     delete file;
2276     return kFALSE;
2277   }
2278
2279   gROOT->cd();
2280   delete esd;
2281   esd = (AliESDEvent*) file->Get("ESD");
2282   file->Close();
2283   delete file;
2284   return kTRUE;
2285
2286 }
2287
2288
2289
2290 //_____________________________________________________________________________
2291 void AliReconstruction::WriteESD(AliESDEvent* esd, const char* recStep) const
2292 {
2293 // write the ESD event to a file
2294
2295   if (!esd) return;
2296   char fileName[256];
2297   sprintf(fileName, "ESD_%d.%d_%s.root", 
2298           esd->GetRunNumber(), esd->GetEventNumberInFile(), recStep);
2299
2300   AliDebug(1, Form("writing ESD to file %s", fileName));
2301   TFile* file = TFile::Open(fileName, "recreate");
2302   if (!file || !file->IsOpen()) {
2303     AliError(Form("opening %s failed", fileName));
2304   } else {
2305     esd->Write("ESD");
2306     file->Close();
2307   }
2308   delete file;
2309 }
2310
2311
2312 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
2313 {
2314   // Write space-points which are then used in the alignment procedures
2315   // For the moment only ITS, TRD and TPC
2316
2317   // Load TOF clusters
2318   if (fTracker[3]){
2319     fLoader[3]->LoadRecPoints("read");
2320     TTree* tree = fLoader[3]->TreeR();
2321     if (!tree) {
2322       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[3]));
2323       return;
2324     }
2325     fTracker[3]->LoadClusters(tree);
2326   }
2327   Int_t ntracks = esd->GetNumberOfTracks();
2328   for (Int_t itrack = 0; itrack < ntracks; itrack++)
2329     {
2330       AliESDtrack *track = esd->GetTrack(itrack);
2331       Int_t nsp = 0;
2332       Int_t idx[200];
2333       for (Int_t iDet = 3; iDet >= 0; iDet--)
2334         nsp += track->GetNcls(iDet);
2335       if (nsp) {
2336         AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2337         track->SetTrackPointArray(sp);
2338         Int_t isptrack = 0;
2339         for (Int_t iDet = 3; iDet >= 0; iDet--) {
2340           AliTracker *tracker = fTracker[iDet];
2341           if (!tracker) continue;
2342           Int_t nspdet = track->GetNcls(iDet);
2343           if (nspdet <= 0) continue;
2344           track->GetClusters(iDet,idx);
2345           AliTrackPoint p;
2346           Int_t isp = 0;
2347           Int_t isp2 = 0;
2348           while (isp2 < nspdet) {
2349             Bool_t isvalid;
2350             TString dets = fgkDetectorName[iDet];
2351             if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2352             fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2353             fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2354             fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2355               isvalid = tracker->GetTrackPointTrackingError(idx[isp2],p,track);
2356             } else {
2357               isvalid = tracker->GetTrackPoint(idx[isp2],p); 
2358             } 
2359             isp2++;
2360             const Int_t kNTPCmax = 159;
2361             if (iDet==1 && isp2>kNTPCmax) break;   // to be fixed
2362             if (!isvalid) continue;
2363             sp->AddPoint(isptrack,&p); isptrack++; isp++;
2364           }
2365         }       
2366       }
2367     }
2368   if (fTracker[3]){
2369     fTracker[3]->UnloadClusters();
2370     fLoader[3]->UnloadRecPoints();
2371   }
2372 }
2373
2374 //_____________________________________________________________________________
2375 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2376 {
2377   // The method reads the raw-data error log
2378   // accumulated within the rawReader.
2379   // It extracts the raw-data errors related to
2380   // the current event and stores them into
2381   // a TClonesArray inside the esd object.
2382
2383   if (!fRawReader) return;
2384
2385   for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2386
2387     AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2388     if (!log) continue;
2389     if (iEvent != log->GetEventNumber()) continue;
2390
2391     esd->AddRawDataErrorLog(log);
2392   }
2393
2394 }
2395
2396 TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString fName){
2397   // Dump a file content into a char in TNamed
2398   ifstream in;
2399   in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2400   Int_t kBytes = (Int_t)in.tellg();
2401   printf("Size: %d \n",kBytes);
2402   TNamed *fn = 0;
2403   if(in.good()){
2404     char* memblock = new char [kBytes];
2405     in.seekg (0, ios::beg);
2406     in.read (memblock, kBytes);
2407     in.close();
2408     TString fData(memblock,kBytes);
2409     fn = new TNamed(fName,fData);
2410     printf("fData Size: %d \n",fData.Sizeof());
2411     printf("fName Size: %d \n",fName.Sizeof());
2412     printf("fn    Size: %d \n",fn->Sizeof());
2413     delete[] memblock;
2414   }
2415   else{
2416     AliInfo(Form("Could not Open %s\n",fPath.Data()));
2417   }
2418
2419   return fn;
2420 }
2421
2422 void AliReconstruction::TNamedToFile(TTree* fTree, TString fName){
2423   // This is not really needed in AliReconstruction at the moment
2424   // but can serve as a template
2425
2426   TList *fList = fTree->GetUserInfo();
2427   TNamed *fn = (TNamed*)fList->FindObject(fName.Data());
2428   printf("fn Size: %d \n",fn->Sizeof());
2429
2430   TString fTmp(fn->GetName()); // to be 100% sure in principle fName also works
2431   const char* cdata = fn->GetTitle();
2432   printf("fTmp Size %d\n",fTmp.Sizeof());
2433
2434   int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2435   printf("calculated size %d\n",size);
2436   ofstream out(fName.Data(),ios::out | ios::binary);
2437   out.write(cdata,size);
2438   out.close();
2439
2440 }
2441   
2442 //_____________________________________________________________________________
2443 AliQADataMakerRec * AliReconstruction::GetQADataMaker(Int_t iDet)
2444 {
2445  // get the quality assurance data maker object and the loader for a detector
2446
2447   if (fQADataMaker[iDet]) 
2448     return fQADataMaker[iDet];
2449
2450   AliQADataMakerRec * qadm = NULL;
2451   if (iDet == fgkNDetectors) { //Global QA
2452      qadm = new AliGlobalQADataMaker();
2453      fQADataMaker[iDet] = qadm;
2454      return qadm;
2455   }
2456
2457   // load the QA data maker object
2458   TPluginManager* pluginManager = gROOT->GetPluginManager();
2459   TString detName = fgkDetectorName[iDet];
2460   TString qadmName = "Ali" + detName + "QADataMakerRec";
2461   if (gAlice && !gAlice->GetDetector(detName) && (detName != "HLT")) 
2462     return NULL;
2463
2464   // first check if a plugin is defined for the quality assurance data maker
2465   TPluginHandler* pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
2466   // if not, add a plugin for it
2467   if (!pluginHandler) {
2468     AliDebug(1, Form("defining plugin for %s", qadmName.Data()));
2469     TString libs = gSystem->GetLibraries();
2470     if (libs.Contains("lib" + detName + "base.so") ||
2471         (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2472       pluginManager->AddHandler("AliQADataMakerRec", detName, 
2473                                 qadmName, detName + "qadm", qadmName + "()");
2474     } else {
2475       pluginManager->AddHandler("AliQADataMakerRec", detName, 
2476                                 qadmName, detName, qadmName + "()");
2477     }
2478     pluginHandler = pluginManager->FindHandler("AliQADataMakerRec", detName);
2479   }
2480   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2481     qadm = (AliQADataMakerRec *) pluginHandler->ExecPlugin(0);
2482   }
2483
2484   fQADataMaker[iDet] = qadm;
2485
2486   return qadm;
2487 }
2488
2489 //_____________________________________________________________________________
2490 Bool_t AliReconstruction::RunQA(const char* detectors, AliESDEvent *& esd)
2491 {
2492   // run the Quality Assurance data producer
2493
2494   AliCodeTimerAuto("")
2495   TString detStr = detectors;
2496   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2497    if (!IsSelected(fgkDetectorName[iDet], detStr)) 
2498      continue;
2499    AliQADataMakerRec * qadm = GetQADataMaker(iDet);
2500    if (!qadm) 
2501      continue;
2502    AliCodeTimerStart(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2503    AliInfo(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2504     
2505    qadm->Exec(AliQA::kESDS, esd) ; 
2506    qadm->Increment() ; 
2507
2508    AliCodeTimerStop(Form("running quality assurance data maker for %s", fgkDetectorName[iDet]));
2509  }
2510  if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2511    AliError(Form("the following detectors were not found: %s",
2512                  detStr.Data()));
2513    if (fStopOnError) 
2514      return kFALSE;
2515  }
2516  
2517  return kTRUE;
2518   
2519 }
2520
2521 //_____________________________________________________________________________
2522 void AliReconstruction::CheckQA()
2523 {
2524 // check the QA of SIM for this run and remove the detectors 
2525 // with status Fatal
2526   
2527         TString newRunLocalReconstruction ; 
2528         TString newRunTracking ;
2529         TString newFillESD ;
2530          
2531         for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2532                 TString detName(AliQA::GetDetName(iDet)) ;
2533                 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ; 
2534                 if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
2535                                 AliInfo(Form("QA status for %s in Hits and/or SDIGITS  and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
2536                 } else {
2537                         if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) || 
2538                                         fRunLocalReconstruction.Contains("ALL") )  {
2539                                 newRunLocalReconstruction += detName ; 
2540                                 newRunLocalReconstruction += " " ;                      
2541                         }
2542                         if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) || 
2543                                         fRunTracking.Contains("ALL") )  {
2544                                 newRunTracking += detName ; 
2545                                 newRunTracking += " " ;                         
2546                         }
2547                         if ( fFillESD.Contains(AliQA::GetDetName(iDet)) || 
2548                                         fFillESD.Contains("ALL") )  {
2549                                 newFillESD += detName ; 
2550                                 newFillESD += " " ;                     
2551                         }
2552                 }
2553         }
2554         fRunLocalReconstruction = newRunLocalReconstruction ; 
2555         fRunTracking            = newRunTracking ; 
2556         fFillESD                = newFillESD ; 
2557 }
2558
2559 //_____________________________________________________________________________
2560 Int_t AliReconstruction::GetDetIndex(const char* detector)
2561 {
2562   // return the detector index corresponding to detector
2563   Int_t index = -1 ; 
2564   for (index = 0; index < fgkNDetectors ; index++) {
2565     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2566         break ; 
2567   }     
2568   return index ; 
2569 }
2570 //_____________________________________________________________________________
2571 Bool_t AliReconstruction::FinishPlaneEff() {
2572  //
2573  // Here execute all the necessary operationis, at the end of the tracking phase,
2574  // in case that evaluation of PlaneEfficiencies was required for some detector. 
2575  // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated. 
2576  //
2577  // This Preliminary version works only FOR ITS !!!!!
2578  // other detectors (TOF,TRD, etc. have to develop their specific codes)
2579  //
2580  //  Input: none
2581  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise 
2582  //
2583  Bool_t ret=kFALSE;
2584  //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2585  for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS  
2586    //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2587    if(fTracker[iDet]) {
2588       AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff(); 
2589       ret=planeeff->WriteIntoCDB();
2590       if(planeeff->GetCreateHistos()) {
2591         TString name="PlaneEffHisto";
2592         name+=fgkDetectorName[iDet];
2593         name+=".root";
2594         ret*=planeeff->WriteHistosToFile(name,"RECREATE");
2595       }
2596    }
2597  }
2598  return ret;
2599 }
2600 //_____________________________________________________________________________
2601 Bool_t AliReconstruction::InitPlaneEff() {
2602 //
2603  // Here execute all the necessary operations, before of the tracking phase,
2604  // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2605  // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency 
2606  // which should be updated/recalculated.
2607  //
2608  // This Preliminary version will work only FOR ITS !!!!!
2609  // other detectors (TOF,TRD, etc. have to develop their specific codes)
2610  //
2611  //  Input: none
2612  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
2613  //
2614  AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
2615  return kTRUE;
2616 }