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