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