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