STEER/AliReconstruction.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /* $Id$ */
  17
  18 ///////////////////////////////////////////////////////////////////////////////
  19 //                                                                           //
  20 // class for running the reconstruction                                      //
  21 //                                                                           //
  22 // Clusters and tracks are created for all detectors and all events by       //
  23 // typing:                                                                   //
  24 //                                                                           //
  25 //   AliReconstruction rec;                                                  //
  26 //   rec.Run();                                                              //
  27 //                                                                           //
  28 // The Run method returns kTRUE in case of successful execution.             //
  29 //                                                                           //
  30 // If the input to the reconstruction are not simulated digits but raw data, //
  31 // this can be specified by an argument of the Run method or by the method   //
  32 //                                                                           //
  33 //   rec.SetInput("...");                                                    //
  34 //                                                                           //
  35 // The input formats and the corresponding argument are:                     //
  36 // - DDL raw data files: directory name, ends with "/"                       //
  37 // - raw data root file: root file name, extension ".root"                   //
  38 // - raw data DATE file: DATE file name, any other non-empty string          //
  39 // - MC root files     : empty string, default                               //
  40 //                                                                           //
  41 // By default all events are reconstructed. The reconstruction can be        //
  42 // limited to a range of events by giving the index of the first and the     //
  43 // last event as an argument to the Run method or by calling                 //
  44 //                                                                           //
  45 //   rec.SetEventRange(..., ...);                                            //
  46 //                                                                           //
  47 // The index -1 (default) can be used for the last event to indicate no      //
  48 // upper limit of the event range.                                           //
  49 //                                                                           //
  50 // In case of raw-data reconstruction the user can modify the default        //
  51 // number of events per digits/clusters/tracks file. In case the option      //
  52 // is not used the number is set 1. In case the user provides 0, than        //
  53 // the number of events is equal to the number of events inside the          //
  54 // raw-data file (i.e. one digits/clusters/tracks file):                     //
  55 //                                                                           //
  56 //   rec.SetNumberOfEventsPerFile(...);                                      //
  57 //                                                                           //
  58 //                                                                           //
  59 // The name of the galice file can be changed from the default               //
  60 // "galice.root" by passing it as argument to the AliReconstruction          //
  61 // constructor or by                                                         //
  62 //                                                                           //
  63 //   rec.SetGAliceFile("...");                                               //
  64 //                                                                           //
  65 // The local reconstruction can be switched on or off for individual         //
  66 // detectors by                                                              //
  67 //                                                                           //
  68 //   rec.SetRunLocalReconstruction("...");                                   //
  69 //                                                                           //
  70 // The argument is a (case sensitive) string with the names of the           //
  71 // detectors separated by a space. The special string "ALL" selects all      //
  72 // available detectors. This is the default.                                 //
  73 //                                                                           //
  74 // The reconstruction of the primary vertex position can be switched off by  //
  75 //                                                                           //
  76 //   rec.SetRunVertexFinder(kFALSE);                                         //
  77 //                                                                           //
  78 // The tracking and the creation of ESD tracks can be switched on for        //
  79 // selected detectors by                                                     //
  80 //                                                                           //
  81 //   rec.SetRunTracking("...");                                              //
  82 //                                                                           //
  83 // Uniform/nonuniform field tracking switches (default: uniform field)       //
  84 //                                                                           //
  85 //   rec.SetUniformFieldTracking(); ( rec.SetUniformFieldTracking(kFALSE); ) //
  86 //                                                                           //
  87 // The filling of additional ESD information can be steered by               //
  88 //                                                                           //
  89 //   rec.SetFillESD("...");                                                  //
  90 //                                                                           //
  91 // Again, for both methods the string specifies the list of detectors.       //
  92 // The default is "ALL".                                                     //
  93 //                                                                           //
  94 // The call of the shortcut method                                           //
  95 //                                                                           //
  96 //   rec.SetRunReconstruction("...");                                        //
  97 //                                                                           //
  98 // is equivalent to calling SetRunLocalReconstruction, SetRunTracking and    //
  99 // SetFillESD with the same detector selecting string as argument.           //
 100 //                                                                           //
 101 // The reconstruction requires digits or raw data as input. For the creation //
 102 // of digits and raw data have a look at the class AliSimulation.            //
 103 //                                                                           //
 104 // The input data of a detector can be replaced by the corresponding HLT     //
 105 // data by calling (usual detector string)                                   //
 106 // SetUseHLTData("...");                                                     //
 107 //                                                                           //
 108 //                                                                           //
 109 ///////////////////////////////////////////////////////////////////////////////
 110
 111 #include <TArrayF.h>
 112 #include <TFile.h>
 113 #include <TList.h>
 114 #include <TSystem.h>
 115 #include <TROOT.h>
 116 #include <TPluginManager.h>
 117 #include <TGeoManager.h>
 118 #include <TLorentzVector.h>
 119 #include <TArrayS.h>
 120 #include <TArrayD.h>
 121 #include <TObjArray.h>
 122 #include <TMap.h>
 123 #include <TChain.h>
 124 #include <TProof.h>
 125 #include <TProofOutputFile.h>
 126 #include <TParameter.h>
 127
 128 #include "AliReconstruction.h"
 129 #include "AliCodeTimer.h"
 130 #include "AliReconstructor.h"
 131 #include "AliLog.h"
 132 #include "AliRunLoader.h"
 133 #include "AliRun.h"
 134 #include "AliRawReaderFile.h"
 135 #include "AliRawReaderDate.h"
 136 #include "AliRawReaderRoot.h"
 137 #include "AliRawEventHeaderBase.h"
 138 #include "AliRawEvent.h"
 139 #include "AliESDEvent.h"
 140 #include "AliESDMuonTrack.h"
 141 #include "AliESDfriend.h"
 142 #include "AliESDVertex.h"
 143 #include "AliESDcascade.h"
 144 #include "AliESDkink.h"
 145 #include "AliESDtrack.h"
 146 #include "AliESDCaloCluster.h"
 147 #include "AliESDCaloCells.h"
 148 #include "AliMultiplicity.h"
 149 #include "AliTracker.h"
 150 #include "AliVertexer.h"
 151 #include "AliVertexerTracks.h"
 152 #include "AliV0vertexer.h"
 153 #include "AliCascadeVertexer.h"
 154 #include "AliHeader.h"
 155 #include "AliGenEventHeader.h"
 156 #include "AliPID.h"
 157 #include "AliESDpid.h"
 158 #include "AliESDtrack.h"
 159 #include "AliESDPmdTrack.h"
 160
 161 #include "AliESDTagCreator.h"
 162
 163 #include "AliGeomManager.h"
 164 #include "AliTrackPointArray.h"
 165 #include "AliCDBManager.h"
 166 #include "AliCDBStorage.h"
 167 #include "AliCDBEntry.h"
 168 #include "AliAlignObj.h"
 169
 170 #include "AliCentralTrigger.h"
 171 #include "AliTriggerConfiguration.h"
 172 #include "AliTriggerClass.h"
 173 #include "AliTriggerCluster.h"
 174 #include "AliCTPRawStream.h"
 175
 176 #include "AliQADataMakerRec.h"
 177 #include "AliGlobalQADataMaker.h"
 178 #include "AliQA.h"
 179 #include "AliQADataMakerSteer.h"
 180
 181 #include "AliPlaneEff.h"
 182
 183 #include "AliSysInfo.h" // memory snapshots
 184 #include "AliRawHLTManager.h"
 185
 186 #include "AliMagWrapCheb.h"
 187
 188 #include "AliDetectorRecoParam.h"
 189 #include "AliGRPRecoParam.h"
 190 #include "AliRunInfo.h"
 191 #include "AliEventInfo.h"
 192
 193 #include "AliDAQ.h"
 194
 195 ClassImp(AliReconstruction)
 196
 197 //_____________________________________________________________________________
 198 const char* AliReconstruction::fgkDetectorName[AliReconstruction::fgkNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
 199
 200 //_____________________________________________________________________________
 201 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
 202   TSelector(),
 203   fUniformField(kFALSE),
 204   fForcedFieldMap(NULL),
 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   fFillTriggerESD(kTRUE),
 215
 216   fCleanESD(kTRUE),
 217   fV0DCAmax(3.),
 218   fV0CsPmin(0.),
 219   fDmax(50.),
 220   fZmax(50.),
 221
 222   fRunLocalReconstruction("ALL"),
 223   fRunTracking("ALL"),
 224   fFillESD("ALL"),
 225   fLoadCDB(""),
 226   fUseTrackingErrorsForAlignment(""),
 227   fGAliceFileName(gAliceFilename),
 228   fRawInput(""),
 229   fEquipIdMap(""),
 230   fFirstEvent(0),
 231   fLastEvent(-1),
 232   fNumberOfEventsPerFile(1),
 233   fOptions(),
 234   fLoadAlignFromCDB(kTRUE),
 235   fLoadAlignData("ALL"),
 236   fESDPar(""),
 237   fUseHLTData(),
 238   fRunInfo(NULL),
 239   fEventInfo(),
 240
 241   fRunLoader(NULL),
 242   fRawReader(NULL),
 243   fParentRawReader(NULL),
 244
 245   fRecoParam(),
 246
 247   fVertexer(NULL),
 248   fDiamondProfile(NULL),
 249   fDiamondProfileTPC(NULL),
 250   fMeanVertexConstraint(kTRUE),
 251
 252   fGRPData(NULL),
 253
 254   fAlignObjArray(NULL),
 255   fCDBUri(),
 256   fSpecCDBUri(),
 257   fInitCDBCalled(kFALSE),
 258   fSetRunNumberFromDataCalled(kFALSE),
 259   fQADetectors("ALL"),
 260   fQASteer(NULL),
 261   fQATasks("ALL"),
 262   fRunQA(kTRUE),
 263   fRunGlobalQA(kTRUE),
 264   fSameQACycle(kFALSE),
 265
 266   fRunPlaneEff(kFALSE),
 267
 268   fesd(NULL),
 269   fhltesd(NULL),
 270   fesdf(NULL),
 271   ffile(NULL),
 272   ftree(NULL),
 273   fhlttree(NULL),
 274   ftVertexer(NULL),
 275   fIsNewRunLoader(kFALSE),
 276   fRunAliEVE(kFALSE),
 277   fChain(NULL)
 278 {
 279 // create reconstruction object with default parameters
 280   gGeoManager = NULL;
 281
 282   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 283     fReconstructor[iDet] = NULL;
 284     fLoader[iDet] = NULL;
 285     fTracker[iDet] = NULL;
 286   }
 287   for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
 288     fQACycles[iDet] = 999999 ;
 289     fQAWriteExpert[iDet] = kFALSE ;
 290   }
 291
 292   AliPID pid;
 293 }
 294
 295 //_____________________________________________________________________________
 296 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
 297   TSelector(),
 298   fUniformField(rec.fUniformField),
 299   fForcedFieldMap(NULL),
 300   fRunVertexFinder(rec.fRunVertexFinder),
 301   fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
 302   fRunHLTTracking(rec.fRunHLTTracking),
 303   fRunMuonTracking(rec.fRunMuonTracking),
 304   fRunV0Finder(rec.fRunV0Finder),
 305   fRunCascadeFinder(rec.fRunCascadeFinder),
 306   fStopOnError(rec.fStopOnError),
 307   fWriteAlignmentData(rec.fWriteAlignmentData),
 308   fWriteESDfriend(rec.fWriteESDfriend),
 309   fFillTriggerESD(rec.fFillTriggerESD),
 310
 311   fCleanESD(rec.fCleanESD),
 312   fV0DCAmax(rec.fV0DCAmax),
 313   fV0CsPmin(rec.fV0CsPmin),
 314   fDmax(rec.fDmax),
 315   fZmax(rec.fZmax),
 316
 317   fRunLocalReconstruction(rec.fRunLocalReconstruction),
 318   fRunTracking(rec.fRunTracking),
 319   fFillESD(rec.fFillESD),
 320   fLoadCDB(rec.fLoadCDB),
 321   fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
 322   fGAliceFileName(rec.fGAliceFileName),
 323   fRawInput(rec.fRawInput),
 324   fEquipIdMap(rec.fEquipIdMap),
 325   fFirstEvent(rec.fFirstEvent),
 326   fLastEvent(rec.fLastEvent),
 327   fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
 328   fOptions(),
 329   fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
 330   fLoadAlignData(rec.fLoadAlignData),
 331   fESDPar(rec.fESDPar),
 332   fUseHLTData(rec.fUseHLTData),
 333   fRunInfo(NULL),
 334   fEventInfo(),
 335
 336   fRunLoader(NULL),
 337   fRawReader(NULL),
 338   fParentRawReader(NULL),
 339
 340   fRecoParam(rec.fRecoParam),
 341
 342   fVertexer(NULL),
 343   fDiamondProfile(rec.fDiamondProfile),
 344   fDiamondProfileTPC(rec.fDiamondProfileTPC),
 345   fMeanVertexConstraint(rec.fMeanVertexConstraint),
 346
 347   fGRPData(NULL),
 348
 349   fAlignObjArray(rec.fAlignObjArray),
 350   fCDBUri(rec.fCDBUri),
 351   fSpecCDBUri(),
 352   fInitCDBCalled(rec.fInitCDBCalled),
 353   fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
 354   fQADetectors(rec.fQADetectors),
 355   fQASteer(NULL),
 356   fQATasks(rec.fQATasks),
 357   fRunQA(rec.fRunQA),
 358   fRunGlobalQA(rec.fRunGlobalQA),
 359   fSameQACycle(rec.fSameQACycle),
 360   fRunPlaneEff(rec.fRunPlaneEff),
 361
 362   fesd(NULL),
 363   fhltesd(NULL),
 364   fesdf(NULL),
 365   ffile(NULL),
 366   ftree(NULL),
 367   fhlttree(NULL),
 368   ftVertexer(NULL),
 369   fIsNewRunLoader(rec.fIsNewRunLoader),
 370   fRunAliEVE(kFALSE),
 371   fChain(NULL)
 372 {
 373 // copy constructor
 374
 375   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
 376     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
 377   }
 378   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 379     fReconstructor[iDet] = NULL;
 380     fLoader[iDet] = NULL;
 381     fTracker[iDet] = NULL;
 382   }
 383
 384   for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
 385     fQACycles[iDet] = rec.fQACycles[iDet];
 386     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
 387   }
 388
 389   for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
 390     if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
 391   }
 392 }
 393
 394 //_____________________________________________________________________________
 395 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
 396 {
 397 // assignment operator
 398 // Used in PROOF mode
 399 // Be very careful while modifing it!
 400 // Simple rules to follow:
 401 // for persistent data members - use their assignment operators
 402 // for non-persistent ones - do nothing or take the default values from constructor
 403 // TSelector members should not be touched
 404   if(&rec == this) return *this;
 405
 406   fUniformField          = rec.fUniformField;
 407   fForcedFieldMap        = NULL;
 408   fRunVertexFinder       = rec.fRunVertexFinder;
 409   fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
 410   fRunHLTTracking        = rec.fRunHLTTracking;
 411   fRunMuonTracking       = rec.fRunMuonTracking;
 412   fRunV0Finder           = rec.fRunV0Finder;
 413   fRunCascadeFinder      = rec.fRunCascadeFinder;
 414   fStopOnError           = rec.fStopOnError;
 415   fWriteAlignmentData    = rec.fWriteAlignmentData;
 416   fWriteESDfriend        = rec.fWriteESDfriend;
 417   fFillTriggerESD        = rec.fFillTriggerESD;
 418
 419   fCleanESD  = rec.fCleanESD;
 420   fV0DCAmax  = rec.fV0DCAmax;
 421   fV0CsPmin  = rec.fV0CsPmin;
 422   fDmax      = rec.fDmax;
 423   fZmax      = rec.fZmax;
 424
 425   fRunLocalReconstruction        = rec.fRunLocalReconstruction;
 426   fRunTracking                   = rec.fRunTracking;
 427   fFillESD                       = rec.fFillESD;
 428   fLoadCDB                       = rec.fLoadCDB;
 429   fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
 430   fGAliceFileName                = rec.fGAliceFileName;
 431   fRawInput                      = rec.fRawInput;
 432   fEquipIdMap                    = rec.fEquipIdMap;
 433   fFirstEvent                    = rec.fFirstEvent;
 434   fLastEvent                     = rec.fLastEvent;
 435   fNumberOfEventsPerFile         = rec.fNumberOfEventsPerFile;
 436
 437   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
 438     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
 439   }
 440
 441   fLoadAlignFromCDB              = rec.fLoadAlignFromCDB;
 442   fLoadAlignData                 = rec.fLoadAlignData;
 443   fESDPar                        = rec.fESDPar;
 444   fUseHLTData                    = rec.fUseHLTData;
 445
 446   delete fRunInfo; fRunInfo = NULL;
 447   if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
 448
 449   fEventInfo                     = rec.fEventInfo;
 450
 451   fRunLoader       = NULL;
 452   fRawReader       = NULL;
 453   fParentRawReader = NULL;
 454
 455   fRecoParam = rec.fRecoParam;
 456
 457   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 458     delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
 459     delete fLoader[iDet]; fLoader[iDet] = NULL;
 460     delete fTracker[iDet]; fTracker[iDet] = NULL;
 461   }
 462
 463   for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
 464     fQACycles[iDet] = rec.fQACycles[iDet];
 465     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
 466   }
 467
 468   fVertexer             = NULL;
 469   delete fDiamondProfile; fDiamondProfile = NULL;
 470   if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
 471   delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
 472   if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
 473   fMeanVertexConstraint = rec.fMeanVertexConstraint;
 474
 475   delete fGRPData; fGRPData = NULL;
 476   if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
 477
 478   delete fAlignObjArray; fAlignObjArray = NULL;
 479
 480   fCDBUri        = "";
 481   fSpecCDBUri.Delete();
 482   fInitCDBCalled               = rec.fInitCDBCalled;
 483   fSetRunNumberFromDataCalled  = rec.fSetRunNumberFromDataCalled;
 484   fQADetectors                 = rec.fQADetectors;
 485   fQASteer                     = NULL;
 486   fQATasks                     = rec.fQATasks;
 487   fRunQA                       = rec.fRunQA;
 488   fRunGlobalQA                 = rec.fRunGlobalQA;
 489   fSameQACycle                 = rec.fSameQACycle;
 490   fRunPlaneEff                 = rec.fRunPlaneEff;
 491
 492   fesd     = NULL;
 493   fhltesd  = NULL;
 494   fesdf    = NULL;
 495   ffile    = NULL;
 496   ftree    = NULL;
 497   fhlttree = NULL;
 498   ftVertexer = NULL;
 499   fIsNewRunLoader = rec.fIsNewRunLoader;
 500   fRunAliEVE = kFALSE;
 501   fChain = NULL;
 502
 503   return *this;
 504 }
 505
 506 //_____________________________________________________________________________
 507 AliReconstruction::~AliReconstruction()
 508 {
 509 // clean up
 510
 511   CleanUp();
 512   delete fGRPData;
 513   delete fForcedFieldMap;
 514   fOptions.Delete();
 515   if (fAlignObjArray) {
 516     fAlignObjArray->Delete();
 517     delete fAlignObjArray;
 518   }
 519   fSpecCDBUri.Delete();
 520   delete fQASteer;
 521   AliCodeTimer::Instance()->Print();
 522 }
 523
 524 //_____________________________________________________________________________
 525 void AliReconstruction::InitCDB()
 526 {
 527 // activate a default CDB storage
 528 // First check if we have any CDB storage set, because it is used
 529 // to retrieve the calibration and alignment constants
 530   AliCodeTimerAuto("");
 531
 532   if (fInitCDBCalled) return;
 533   fInitCDBCalled = kTRUE;
 534
 535   AliCDBManager* man = AliCDBManager::Instance();
 536   if (man->IsDefaultStorageSet())
 537   {
 538     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 539     AliWarning("Default CDB storage has been already set !");
 540     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
 541     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 542     fCDBUri = man->GetDefaultStorage()->GetURI();
 543   }
 544   else {
 545     if (fCDBUri.Length() > 0)
 546     {
 547         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 548         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
 549         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 550     } else {
 551         fCDBUri="local://$ALICE_ROOT";
 552         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 553         AliWarning("Default CDB storage not yet set !!!!");
 554         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
 555         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 556
 557     }
 558     man->SetDefaultStorage(fCDBUri);
 559   }
 560
 561   // Now activate the detector specific CDB storage locations
 562   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
 563     TObject* obj = fSpecCDBUri[i];
 564     if (!obj) continue;
 565     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 566     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
 567     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 568     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
 569   }
 570   AliSysInfo::AddStamp("InitCDB");
 571 }
 572
 573 //_____________________________________________________________________________
 574 void AliReconstruction::SetDefaultStorage(const char* uri) {
 575 // Store the desired default CDB storage location
 576 // Activate it later within the Run() method
 577
 578   fCDBUri = uri;
 579
 580 }
 581
 582 //_____________________________________________________________________________
 583 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
 584 // Store a detector-specific CDB storage location
 585 // Activate it later within the Run() method
 586
 587   AliCDBPath aPath(calibType);
 588   if(!aPath.IsValid()){
 589         // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
 590         for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 591                 if(!strcmp(calibType, fgkDetectorName[iDet])) {
 592                         aPath.SetPath(Form("%s/*", calibType));
 593                         AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
 594                         break;
 595                 }
 596         }
 597         if(!aPath.IsValid()){
 598                 AliError(Form("Not a valid path or detector: %s", calibType));
 599                 return;
 600         }
 601   }
 602
 603 //  // check that calibType refers to a "valid" detector name
 604 //  Bool_t isDetector = kFALSE;
 605 //  for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 606 //    TString detName = fgkDetectorName[iDet];
 607 //    if(aPath.GetLevel0() == detName) {
 608 //      isDetector = kTRUE;
 609 //      break;
 610 //    }
 611 //  }
 612 //
 613 //  if(!isDetector) {
 614 //      AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
 615 //      return;
 616 //  }
 617
 618   TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
 619   if (obj) fSpecCDBUri.Remove(obj);
 620   fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
 621
 622 }
 623
 624 //_____________________________________________________________________________
 625 Bool_t AliReconstruction::SetRunNumberFromData()
 626 {
 627   // The method is called in Run() in order
 628   // to set a correct run number.
 629   // In case of raw data reconstruction the
 630   // run number is taken from the raw data header
 631
 632   if (fSetRunNumberFromDataCalled) return kTRUE;
 633   fSetRunNumberFromDataCalled = kTRUE;
 634
 635   AliCDBManager* man = AliCDBManager::Instance();
 636
 637   if(fRawReader) {
 638     if(fRawReader->NextEvent()) {
 639       if(man->GetRun() > 0) {
 640         AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
 641       }
 642       man->SetRun(fRawReader->GetRunNumber());
 643       fRawReader->RewindEvents();
 644     }
 645     else {
 646       if(man->GetRun() > 0) {
 647         AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
 648       }
 649       else {
 650         AliWarning("Neither raw events nor settings in AliCDBManager are found !");
 651         return kFALSE;
 652       }
 653     }
 654   }
 655   else {
 656     AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
 657     if (!rl) {
 658       AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
 659       return kFALSE;
 660     }
 661     else {
 662       rl->LoadHeader();
 663       // read run number from gAlice
 664       if(rl->GetHeader()) {
 665         man->SetRun(rl->GetHeader()->GetRun());
 666         rl->UnloadHeader();
 667         delete rl;
 668       }
 669       else {
 670         AliError("Neither run-loader header nor RawReader objects are found !");
 671         delete rl;
 672         return kFALSE;
 673       }
 674     }
 675   }
 676
 677   man->Print();
 678
 679   return kTRUE;
 680 }
 681
 682 //_____________________________________________________________________________
 683 void AliReconstruction::SetCDBLock() {
 684   // Set CDB lock: from now on it is forbidden to reset the run number
 685   // or the default storage or to activate any further storage!
 686
 687   AliCDBManager::Instance()->SetLock(1);
 688 }
 689
 690 //_____________________________________________________________________________
 691 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
 692 {
 693   // Read the alignment objects from CDB.
 694   // Each detector is supposed to have the
 695   // alignment objects in DET/Align/Data CDB path.
 696   // All the detector objects are then collected,
 697   // sorted by geometry level (starting from ALIC) and
 698   // then applied to the TGeo geometry.
 699   // Finally an overlaps check is performed.
 700
 701   // Load alignment data from CDB and fill fAlignObjArray
 702   if(fLoadAlignFromCDB){
 703
 704     TString detStr = detectors;
 705     TString loadAlObjsListOfDets = "";
 706
 707     for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 708       if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
 709       if(fgkDetectorName[iDet]=="HLT") continue;
 710       if(AliGeomManager::IsModuleInGeom(fgkDetectorName[iDet]))
 711       {
 712         loadAlObjsListOfDets += fgkDetectorName[iDet];
 713         loadAlObjsListOfDets += " ";
 714       }
 715     } // end loop over detectors
 716     if(AliGeomManager::IsModuleInGeom("FRAME"))
 717       loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
 718     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
 719     AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
 720   }else{
 721     // Check if the array with alignment objects was
 722     // provided by the user. If yes, apply the objects
 723     // to the present TGeo geometry
 724     if (fAlignObjArray) {
 725       if (gGeoManager && gGeoManager->IsClosed()) {
 726         if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
 727           AliError("The misalignment of one or more volumes failed!"
 728                    "Compare the list of simulated detectors and the list of detector alignment data!");
 729           return kFALSE;
 730         }
 731       }
 732       else {
 733         AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
 734         return kFALSE;
 735       }
 736     }
 737   }
 738
 739   if (fAlignObjArray) {
 740     fAlignObjArray->Delete();
 741     delete fAlignObjArray; fAlignObjArray=NULL;
 742   }
 743
 744   return kTRUE;
 745 }
 746
 747 //_____________________________________________________________________________
 748 void AliReconstruction::SetGAliceFile(const char* fileName)
 749 {
 750 // set the name of the galice file
 751
 752   fGAliceFileName = fileName;
 753 }
 754
 755 //_____________________________________________________________________________
 756 void AliReconstruction::SetInput(const char* input)
 757 {
 758   // In case the input string starts with 'mem://', we run in an online mode
 759   // and AliRawReaderDateOnline object is created. In all other cases a raw-data
 760   // file is assumed. One can give as an input:
 761   // mem://: - events taken from DAQ monitoring libs online
 762   //  or
 763   // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
 764   if (input) fRawInput = input;
 765 }
 766
 767 //_____________________________________________________________________________
 768 void AliReconstruction::SetOption(const char* detector, const char* option)
 769 {
 770 // set options for the reconstruction of a detector
 771
 772   TObject* obj = fOptions.FindObject(detector);
 773   if (obj) fOptions.Remove(obj);
 774   fOptions.Add(new TNamed(detector, option));
 775 }
 776
 777 //_____________________________________________________________________________
 778 void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
 779 {
 780   // Set custom reconstruction parameters for a given detector
 781   // Single set of parameters for all the events
 782
 783   // First check if the reco-params are global
 784   if(!strcmp(detector, "GRP")) {
 785     par->SetAsDefault();
 786     fRecoParam.AddDetRecoParam(fgkNDetectors,par);
 787     return;
 788   }
 789
 790   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
 791     if(!strcmp(detector, fgkDetectorName[iDet])) {
 792       par->SetAsDefault();
 793       fRecoParam.AddDetRecoParam(iDet,par);
 794       break;
 795     }
 796   }
 797
 798 }
 799
 800 //_____________________________________________________________________________
 801 Bool_t AliReconstruction::SetFieldMap(Float_t l3Current, Float_t diCurrent, Float_t factor, const char *path) {
 802   //------------------------------------------------
 803   // The magnetic field map, defined externally...
 804   // L3 current 30000 A  -> 0.5 T
 805   // L3 current 12000 A  -> 0.2 T
 806   // dipole current 6000 A
 807   // The polarities must be the same
 808   //------------------------------------------------
 809   const Float_t l3NominalCurrent1=30000.; // (A)
 810   const Float_t l3NominalCurrent2=12000.; // (A)
 811   const Float_t diNominalCurrent =6000. ; // (A)
 812
 813   const Float_t tolerance=0.03; // relative current tolerance
 814   const Float_t zero=77.;       // "zero" current (A)
 815
 816   Int_t map=0;
 817   Bool_t dipoleON=kFALSE;
 818
 819   TString s=(factor < 0) ? "L3: -" : "L3: +";
 820
 821   l3Current = TMath::Abs(l3Current);
 822   if (TMath::Abs(l3Current-l3NominalCurrent1)/l3NominalCurrent1 < tolerance) {
 823     map=AliMagWrapCheb::k5kG;
 824     s+="0.5 T;  ";
 825   } else
 826   if (TMath::Abs(l3Current-l3NominalCurrent2)/l3NominalCurrent2 < tolerance) {
 827     map=AliMagWrapCheb::k2kG;
 828     s+="0.2 T;  ";
 829   } else
 830   if (l3Current < zero) {
 831     map=AliMagWrapCheb::k2kG;
 832     s+="0.0 T;  ";
 833     factor=0.;                  // in fact, this is a global factor...
 834     fUniformField=kTRUE;        // track with the uniform (zero) B field
 835   } else {
 836     AliError(Form("Wrong L3 current (%f A)!",l3Current));
 837     return kFALSE;
 838   }
 839
 840   diCurrent = TMath::Abs(diCurrent);
 841   if (TMath::Abs(diCurrent-diNominalCurrent)/diNominalCurrent < tolerance) {
 842     // 3% current tolerance...
 843     dipoleON=kTRUE;
 844     s+="Dipole ON";
 845   } else
 846   if (diCurrent < zero) { // some small current..
 847     dipoleON=kFALSE;
 848     s+="Dipole OFF";
 849   } else {
 850     AliError(Form("Wrong dipole current (%f A)!",diCurrent));
 851     return kFALSE;
 852   }
 853
 854   delete fForcedFieldMap;
 855   fForcedFieldMap=
 856     new AliMagWrapCheb("B field map  ",s,2,factor,10.,map,dipoleON,path);
 857
 858   fForcedFieldMap->Print();
 859
 860   AliTracker::SetFieldMap(fForcedFieldMap,fUniformField);
 861
 862   return kTRUE;
 863 }
 864
 865
 866 Bool_t AliReconstruction::InitGRP() {
 867   //------------------------------------
 868   // Initialization of the GRP entry
 869   //------------------------------------
 870   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
 871
 872   if (entry) {
 873     fGRPData = dynamic_cast<TMap*>(entry->GetObject());
 874     entry->SetOwner(0);
 875     AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
 876   }
 877
 878   if (!fGRPData) {
 879      AliError("No GRP entry found in OCDB!");
 880      return kFALSE;
 881   }
 882
 883   TObjString *lhcState=
 884     dynamic_cast<TObjString*>(fGRPData->GetValue("fLHCState"));
 885   if (!lhcState) {
 886     AliError("GRP/GRP/Data entry:  missing value for the LHC state ! Using UNKNOWN");
 887   }
 888
 889   TObjString *beamType=
 890     dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamType"));
 891   if (!beamType) {
 892     AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
 893   }
 894
 895   TObjString *beamEnergyStr=
 896     dynamic_cast<TObjString*>(fGRPData->GetValue("fAliceBeamEnergy"));
 897   if (!beamEnergyStr) {
 898     AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
 899   }
 900
 901   TObjString *runType=
 902     dynamic_cast<TObjString*>(fGRPData->GetValue("fRunType"));
 903   if (!runType) {
 904     AliError("GRP/GRP/Data entry:  missing value for the run type ! Using UNKNOWN");
 905   }
 906
 907   TObjString *activeDetectors=
 908     dynamic_cast<TObjString*>(fGRPData->GetValue("fDetectorMask"));
 909   if (!activeDetectors) {
 910     AliError("GRP/GRP/Data entry:  missing value for the detector mask ! Using 1074790399");
 911   }
 912
 913   fRunInfo = new AliRunInfo(lhcState ? lhcState->GetString().Data() : "UNKNOWN",
 914                             beamType ? beamType->GetString().Data() : "UNKNOWN",
 915                             beamEnergyStr ? beamEnergyStr->GetString().Atof() : 0,
 916                             runType  ? runType->GetString().Data()  : "UNKNOWN",
 917                             activeDetectors ? activeDetectors->GetString().Atoi() : 1074790399);
 918
 919   // Process the list of active detectors
 920   if (activeDetectors && activeDetectors->GetString().IsDigit()) {
 921     UInt_t detMask = activeDetectors->GetString().Atoi();
 922     fLoadCDB.Form("%s %s %s %s",
 923                   fRunLocalReconstruction.Data(),
 924                   fRunTracking.Data(),
 925                   fFillESD.Data(),
 926                   fQADetectors.Data());
 927     fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
 928     fRunTracking = MatchDetectorList(fRunTracking,detMask);
 929     fFillESD = MatchDetectorList(fFillESD,detMask);
 930     fQADetectors = MatchDetectorList(fQADetectors,detMask);
 931     fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
 932   }
 933
 934   AliInfo("===================================================================================");
 935   AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
 936   AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
 937   AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
 938   AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
 939   AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
 940   AliInfo("===================================================================================");
 941
 942   //*** Dealing with the magnetic field map
 943   if (AliTracker::GetFieldMap()) {
 944     AliInfo("Running with the externally set B field !");
 945   } else {
 946     // Construct the field map out of the information retrieved from GRP.
 947
 948     Bool_t ok = kTRUE;
 949
 950     // L3
 951     TObjString *l3Current=
 952        dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Current"));
 953     if (!l3Current) {
 954       AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
 955       ok = kFALSE;
 956     }
 957     TObjString *l3Polarity=
 958        dynamic_cast<TObjString*>(fGRPData->GetValue("fL3Polarity"));
 959     if (!l3Polarity) {
 960       AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
 961       ok = kFALSE;
 962     }
 963
 964     // Dipole
 965     TObjString *diCurrent=
 966        dynamic_cast<TObjString*>(fGRPData->GetValue("fDipoleCurrent"));
 967     if (!diCurrent) {
 968       AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
 969       ok = kFALSE;
 970     }
 971     TObjString *diPolarity=
 972        dynamic_cast<TObjString*>(fGRPData->GetValue("fDipolePolarity"));
 973     if (!diPolarity) {
 974       AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
 975       ok = kFALSE;
 976     }
 977
 978     if (ok) {
 979        Float_t l3Cur=TMath::Abs(atof(l3Current->GetName()));
 980        Float_t diCur=TMath::Abs(atof(diCurrent->GetName()));
 981        Float_t l3Pol=atof(l3Polarity->GetName());
 982        Float_t factor=1.;
 983        if (l3Pol != 0.) factor=-1.;
 984
 985
 986       if (!SetFieldMap(l3Cur, diCur, factor)) {
 987          AliFatal("Failed to creat a B field map ! Exiting...");
 988       }
 989       AliInfo("Running with the B field constructed out of GRP !");
 990     }
 991     else {
 992       AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
 993     }
 994
 995   }
 996
 997   //*** Get the diamond profile from OCDB
 998   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
 999   if (entry) {
1000     if (fMeanVertexConstraint)
1001       fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1002   } else {
1003      AliError("No diamond profile found in OCDB!");
1004   }
1005
1006   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1007   if (entry) {
1008     if (fMeanVertexConstraint)
1009       fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1010   } else {
1011      AliError("No diamond profile found in OCDB!");
1012   }
1013
1014   return kTRUE;
1015 }
1016
1017 //_____________________________________________________________________________
1018 Bool_t AliReconstruction::LoadCDB()
1019 {
1020   AliCodeTimerAuto("");
1021
1022   AliCDBManager::Instance()->Get("GRP/CTP/Config");
1023
1024   TString detStr = fLoadCDB;
1025   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1026     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1027     AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1028   }
1029   return kTRUE;
1030 }
1031
1032 //_____________________________________________________________________________
1033 Bool_t AliReconstruction::Run(const char* input)
1034 {
1035   // Run Run Run
1036   AliCodeTimerAuto("");
1037
1038   InitRun(input);
1039   if (GetAbort() != TSelector::kContinue) return kFALSE;
1040
1041   TChain *chain = NULL;
1042   if (fRawReader && (chain = fRawReader->GetChain())) {
1043     // Proof mode
1044     if (gProof) {
1045       gProof->AddInput(this);
1046       TUrl outputFile;
1047       outputFile.SetProtocol("root",kTRUE);
1048       outputFile.SetHost(gSystem->HostName());
1049       outputFile.SetFile(Form("%s/AliESDs.root",gSystem->pwd()));
1050       AliInfo(Form("Output file with ESDs is %s",outputFile.GetUrl()));
1051       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.GetUrl()));
1052       chain->SetProof();
1053       chain->Process("AliReconstruction");
1054     }
1055     else {
1056       chain->Process(this);
1057     }
1058   }
1059   else {
1060     Begin(NULL);
1061     if (GetAbort() != TSelector::kContinue) return kFALSE;
1062     SlaveBegin(NULL);
1063     if (GetAbort() != TSelector::kContinue) return kFALSE;
1064     //******* The loop over events
1065     Int_t iEvent = 0;
1066     while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1067            (fRawReader && fRawReader->NextEvent())) {
1068       if (!ProcessEvent(iEvent)) {
1069         Abort("ProcessEvent",TSelector::kAbortFile);
1070         return kFALSE;
1071       }
1072       iEvent++;
1073     }
1074     SlaveTerminate();
1075     if (GetAbort() != TSelector::kContinue) return kFALSE;
1076     Terminate();
1077     if (GetAbort() != TSelector::kContinue) return kFALSE;
1078   }
1079
1080   return kTRUE;
1081 }
1082
1083 //_____________________________________________________________________________
1084 void AliReconstruction::InitRawReader(const char* input)
1085 {
1086   AliCodeTimerAuto("");
1087
1088   // Init raw-reader and
1089   // set the input in case of raw data
1090   if (input) fRawInput = input;
1091   fRawReader = AliRawReader::Create(fRawInput.Data());
1092   if (!fRawReader)
1093     AliInfo("Reconstruction will run over digits");
1094
1095   if (!fEquipIdMap.IsNull() && fRawReader)
1096     fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1097
1098   if (!fUseHLTData.IsNull()) {
1099     // create the RawReaderHLT which performs redirection of HLT input data for
1100     // the specified detectors
1101     AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1102     if (pRawReader) {
1103       fParentRawReader=fRawReader;
1104       fRawReader=pRawReader;
1105     } else {
1106       AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1107     }
1108   }
1109   AliSysInfo::AddStamp("CreateRawReader");
1110 }
1111
1112 //_____________________________________________________________________________
1113 void AliReconstruction::InitRun(const char* input)
1114 {
1115   // Initialization of raw-reader,
1116   // run number, CDB etc.
1117   AliCodeTimerAuto("");
1118   AliSysInfo::AddStamp("Start");
1119
1120   // Initialize raw-reader if any
1121   InitRawReader(input);
1122
1123   // Initialize the CDB storage
1124   InitCDB();
1125
1126   // Set run number in CDBManager (if it is not already set by the user)
1127   if (!SetRunNumberFromData()) {
1128     Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1129     return;
1130   }
1131
1132   // Set CDB lock: from now on it is forbidden to reset the run number
1133   // or the default storage or to activate any further storage!
1134   SetCDBLock();
1135
1136 }
1137
1138 //_____________________________________________________________________________
1139 void AliReconstruction::Begin(TTree *)
1140 {
1141   // Initialize AlReconstruction before
1142   // going into the event loop
1143   // Should follow the TSelector convention
1144   // i.e. initialize only the object on the client side
1145   AliCodeTimerAuto("");
1146
1147   AliReconstruction *reco = NULL;
1148   if (fInput) {
1149     if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1150       *this = *reco;
1151     }
1152     AliSysInfo::AddStamp("ReadInputInBegin");
1153   }
1154
1155   // Import ideal TGeo geometry and apply misalignment
1156   if (!gGeoManager) {
1157     TString geom(gSystem->DirName(fGAliceFileName));
1158     geom += "/geometry.root";
1159     AliGeomManager::LoadGeometry(geom.Data());
1160     if (!gGeoManager) {
1161       Abort("LoadGeometry", TSelector::kAbortProcess);
1162       return;
1163     }
1164     AliSysInfo::AddStamp("LoadGeom");
1165     TString detsToCheck=fRunLocalReconstruction;
1166     if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1167       Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1168       return;
1169     }
1170     AliSysInfo::AddStamp("CheckGeom");
1171   }
1172
1173   if (!MisalignGeometry(fLoadAlignData)) {
1174     Abort("MisalignGeometry", TSelector::kAbortProcess);
1175     return;
1176   }
1177   AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1178   AliSysInfo::AddStamp("MisalignGeom");
1179
1180   if (!InitGRP()) {
1181     Abort("InitGRP", TSelector::kAbortProcess);
1182     return;
1183   }
1184   AliSysInfo::AddStamp("InitGRP");
1185
1186   if (!LoadCDB()) {
1187     Abort("LoadCDB", TSelector::kAbortProcess);
1188     return;
1189   }
1190   AliSysInfo::AddStamp("LoadCDB");
1191
1192   // Read the reconstruction parameters from OCDB
1193   if (!InitRecoParams()) {
1194     AliWarning("Not all detectors have correct RecoParam objects initialized");
1195   }
1196   AliSysInfo::AddStamp("InitRecoParams");
1197
1198   if (fInput) {
1199     if (reco) *reco = *this;
1200     fInput->Add(gGeoManager);
1201     gGeoManager = NULL;
1202     fInput->Add(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()));
1203     fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1204     AliMagF *magFieldMap = (AliMagF*)AliTracker::GetFieldMap();
1205     magFieldMap->SetName("MagneticFieldMap");
1206     fInput->Add(magFieldMap);
1207   }
1208
1209 }
1210
1211 //_____________________________________________________________________________
1212 void AliReconstruction::SlaveBegin(TTree*)
1213 {
1214   // Initialization related to run-loader,
1215   // vertexer, trackers, recontructors
1216   // In proof mode it is executed on the slave
1217   AliCodeTimerAuto("");
1218
1219   TProofOutputFile *outProofFile = NULL;
1220   if (fInput) {
1221     if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1222       *this = *reco;
1223     }
1224     if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1225       gGeoManager = tgeo;
1226       AliGeomManager::SetGeometry(tgeo);
1227     }
1228     if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1229       Int_t runNumber = -1;
1230       if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1231         AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1232         man->SetCacheFlag(kTRUE);
1233         man->SetLock(kTRUE);
1234         man->Print();
1235       }
1236     }
1237     if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1238       AliTracker::SetFieldMap(map,fUniformField);
1239     }
1240     if (TNamed *outputFileName = (TNamed *) fInput->FindObject("PROOF_OUTPUTFILE")) {
1241       outProofFile = new TProofOutputFile(gSystem->BaseName(TUrl(outputFileName->GetTitle()).GetFile()));
1242       outProofFile->SetOutputFileName(outputFileName->GetTitle());
1243       fOutput->Add(outProofFile);
1244     }
1245     AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1246   }
1247
1248   // get the run loader
1249   if (!InitRunLoader()) {
1250     Abort("InitRunLoader", TSelector::kAbortProcess);
1251     return;
1252   }
1253   AliSysInfo::AddStamp("LoadLoader");
1254
1255   ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1256   if(fDiamondProfile && fMeanVertexConstraint) ftVertexer->SetVtxStart(fDiamondProfile);
1257
1258   // get vertexer
1259   if (fRunVertexFinder && !CreateVertexer()) {
1260     Abort("CreateVertexer", TSelector::kAbortProcess);
1261     return;
1262   }
1263   AliSysInfo::AddStamp("CreateVertexer");
1264
1265   // get trackers
1266   if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1267     Abort("CreateTrackers", TSelector::kAbortProcess);
1268     return;
1269   }
1270   AliSysInfo::AddStamp("CreateTrackers");
1271
1272   // create the ESD output file and tree
1273   if (!outProofFile) {
1274     ffile = TFile::Open("AliESDs.root", "RECREATE");
1275     ffile->SetCompressionLevel(2);
1276     if (!ffile->IsOpen()) {
1277       Abort("OpenESDFile", TSelector::kAbortProcess);
1278       return;
1279     }
1280   }
1281   else {
1282     if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1283       Abort(Form("Problems opening output PROOF file: %s/%s",
1284                  outProofFile->GetDir(), outProofFile->GetFileName()),
1285             TSelector::kAbortProcess);
1286       return;
1287     }
1288   }
1289
1290   ftree = new TTree("esdTree", "Tree with ESD objects");
1291   fesd = new AliESDEvent();
1292   fesd->CreateStdContent();
1293   if (fWriteESDfriend) {
1294     fesdf = new AliESDfriend();
1295     TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
1296     br->SetFile("AliESDfriends.root");
1297     fesd->AddObject(fesdf);
1298   }
1299   fesd->WriteToTree(ftree);
1300   ftree->GetUserInfo()->Add(fesd);
1301
1302   fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1303   fhltesd = new AliESDEvent();
1304   fhltesd->CreateStdContent();
1305   fhltesd->WriteToTree(fhlttree);
1306   fhlttree->GetUserInfo()->Add(fhltesd);
1307
1308   ProcInfo_t ProcInfo;
1309   gSystem->GetProcInfo(&ProcInfo);
1310   AliInfo(Form("Current memory usage %d %d", ProcInfo.fMemResident, ProcInfo.fMemVirtual));
1311
1312   //QA
1313   //Initialize the QA and start of cycle
1314   if (fRunQA) {
1315     fQASteer = new AliQADataMakerSteer("rec") ;
1316     fQASteer->SetActiveDetectors(fQADetectors) ;
1317     for (Int_t det = 0 ; det < AliQA::kNDET ; det++) {
1318       fQASteer->SetCycleLength(AliQA::DETECTORINDEX_t(det), fQACycles[det]) ;
1319       if (fQAWriteExpert[det])
1320         fQASteer->SetWriteExpert(AliQA::DETECTORINDEX_t(det)) ;
1321     }
1322
1323     if (!fRawReader && fQATasks.Contains(AliQA::kRAWS))
1324       fQATasks.ReplaceAll(Form("%d",AliQA::kRAWS), "") ;
1325     fQASteer->SetTasks(fQATasks) ;
1326     fQASteer->InitQADataMaker(AliCDBManager::Instance()->GetRun(), fRecoParam) ;
1327   }
1328
1329   if (fRunGlobalQA) {
1330     Bool_t sameCycle = kFALSE ;
1331     if (!fQASteer) fQASteer = new AliQADataMakerSteer("rec") ;
1332     AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1333     AliInfo(Form("Initializing the global QA data maker"));
1334     if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS))) {
1335       qadm->StartOfCycle(AliQA::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
1336       TObjArray *arr=qadm->Init(AliQA::kRECPOINTS);
1337       AliTracker::SetResidualsArray(arr);
1338       sameCycle = kTRUE ;
1339     }
1340     if (fQATasks.Contains(Form("%d", AliQA::kESDS))) {
1341       qadm->StartOfCycle(AliQA::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
1342       qadm->Init(AliQA::kESDS);
1343     }
1344   }
1345
1346   //Initialize the Plane Efficiency framework
1347   if (fRunPlaneEff && !InitPlaneEff()) {
1348     Abort("InitPlaneEff", TSelector::kAbortProcess);
1349     return;
1350   }
1351
1352   if (strcmp(gProgName,"alieve") == 0)
1353     fRunAliEVE = InitAliEVE();
1354
1355   return;
1356 }
1357
1358 //_____________________________________________________________________________
1359 Bool_t AliReconstruction::Process(Long64_t entry)
1360 {
1361   // run the reconstruction over a single entry
1362   // from the chain with raw data
1363   AliCodeTimerAuto("");
1364
1365   TTree *currTree = fChain->GetTree();
1366   AliRawEvent *event = new AliRawEvent;
1367   currTree->SetBranchAddress("rawevent",&event);
1368   currTree->GetEntry(entry);
1369   fRawReader = new AliRawReaderRoot(event);
1370   fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1371   delete fRawReader;
1372   fRawReader = NULL;
1373   delete event;
1374
1375   return fStatus;
1376 }
1377
1378 //_____________________________________________________________________________
1379 void AliReconstruction::Init(TTree *tree)
1380 {
1381   if (tree == 0) {
1382     AliError("The input tree is not found!");
1383     return;
1384   }
1385   fChain = tree;
1386 }
1387
1388 //_____________________________________________________________________________
1389 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1390 {
1391   // run the reconstruction over a single event
1392   // The event loop is steered in Run method
1393
1394   AliCodeTimerAuto("");
1395
1396   if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1397     fRunLoader->SetEventNumber(iEvent);
1398     fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1399                                    iEvent, iEvent);
1400     fRunLoader->TreeE()->Fill();
1401     if (fRawReader && fRawReader->UseAutoSaveESD())
1402       fRunLoader->TreeE()->AutoSave("SaveSelf");
1403   }
1404
1405   if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1406     return kTRUE;
1407   }
1408
1409   AliInfo(Form("processing event %d", iEvent));
1410
1411   // Fill Event-info object
1412   GetEventInfo();
1413   fRecoParam.SetEventSpecie(fRunInfo,fEventInfo);
1414
1415   // Set the reco-params
1416   {
1417     TString detStr = fLoadCDB;
1418     for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1419       if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1420       AliReconstructor *reconstructor = GetReconstructor(iDet);
1421       if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1422         const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1423         reconstructor->SetRecoParam(par);
1424       }
1425     }
1426   }
1427
1428   fRunLoader->GetEvent(iEvent);
1429
1430     // QA on single raw
1431     if (fRunQA)
1432                         fQASteer->RunOneEvent(fRawReader) ;
1433
1434     // local single event reconstruction
1435     if (!fRunLocalReconstruction.IsNull()) {
1436       TString detectors=fRunLocalReconstruction;
1437       // run HLT event reconstruction first
1438       // ;-( IsSelected changes the string
1439       if (IsSelected("HLT", detectors) &&
1440           !RunLocalEventReconstruction("HLT")) {
1441         if (fStopOnError) {CleanUp(); return kFALSE;}
1442       }
1443       detectors=fRunLocalReconstruction;
1444       detectors.ReplaceAll("HLT", "");
1445       if (!RunLocalEventReconstruction(detectors)) {
1446         if (fStopOnError) {CleanUp(); return kFALSE;}
1447       }
1448     }
1449
1450     fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1451     fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1452     fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1453     fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1454
1455     // Set magnetic field from the tracker
1456     fesd->SetMagneticField(AliTracker::GetBz());
1457     fhltesd->SetMagneticField(AliTracker::GetBz());
1458
1459     // Set most probable pt, for B=0 tracking
1460     const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(fgkNDetectors));
1461     if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
1462
1463     // Fill raw-data error log into the ESD
1464     if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
1465
1466     // vertex finder
1467     if (fRunVertexFinder) {
1468       if (!RunVertexFinder(fesd)) {
1469         if (fStopOnError) {CleanUp(); return kFALSE;}
1470       }
1471     }
1472
1473     // Muon tracking
1474     if (!fRunTracking.IsNull()) {
1475       if (fRunMuonTracking) {
1476         if (!RunMuonTracking(fesd)) {
1477           if (fStopOnError) {CleanUp(); return kFALSE;}
1478         }
1479       }
1480     }
1481
1482     // barrel tracking
1483     if (!fRunTracking.IsNull()) {
1484       if (!RunTracking(fesd)) {
1485         if (fStopOnError) {CleanUp(); return kFALSE;}
1486       }
1487     }
1488
1489     // fill ESD
1490     if (!fFillESD.IsNull()) {
1491       TString detectors=fFillESD;
1492       // run HLT first and on hltesd
1493       // ;-( IsSelected changes the string
1494       if (IsSelected("HLT", detectors) &&
1495           !FillESD(fhltesd, "HLT")) {
1496         if (fStopOnError) {CleanUp(); return kFALSE;}
1497       }
1498       detectors=fFillESD;
1499       // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1500       if (detectors.Contains("ALL")) {
1501         detectors="";
1502         for (Int_t idet=0; idet<fgkNDetectors; ++idet){
1503           detectors += fgkDetectorName[idet];
1504           detectors += " ";
1505         }
1506       }
1507       detectors.ReplaceAll("HLT", "");
1508       if (!FillESD(fesd, detectors)) {
1509         if (fStopOnError) {CleanUp(); return kFALSE;}
1510       }
1511     }
1512
1513     // fill Event header information from the RawEventHeader
1514     if (fRawReader){FillRawEventHeaderESD(fesd);}
1515
1516     // combined PID
1517     AliESDpid::MakePID(fesd);
1518
1519     if (fFillTriggerESD) {
1520       if (!FillTriggerESD(fesd)) {
1521         if (fStopOnError) {CleanUp(); return kFALSE;}
1522       }
1523     }
1524
1525     ffile->cd();
1526
1527     //
1528     // Propagate track to the beam pipe  (if not already done by ITS)
1529     //
1530     const Int_t ntracks = fesd->GetNumberOfTracks();
1531     const Double_t kBz = fesd->GetMagneticField();
1532     const Double_t kRadius  = 2.8; //something less than the beam pipe radius
1533
1534     TObjArray trkArray;
1535     UShort_t *selectedIdx=new UShort_t[ntracks];
1536
1537     for (Int_t itrack=0; itrack<ntracks; itrack++){
1538       const Double_t kMaxStep = 5;   //max step over the material
1539       Bool_t ok;
1540
1541       AliESDtrack *track = fesd->GetTrack(itrack);
1542       if (!track) continue;
1543
1544       AliExternalTrackParam *tpcTrack =
1545            (AliExternalTrackParam *)track->GetTPCInnerParam();
1546       ok = kFALSE;
1547       if (tpcTrack)
1548         ok = AliTracker::
1549           PropagateTrackTo(tpcTrack,kRadius,track->GetMass(),kMaxStep,kTRUE);
1550
1551       if (ok) {
1552         Int_t n=trkArray.GetEntriesFast();
1553         selectedIdx[n]=track->GetID();
1554         trkArray.AddLast(tpcTrack);
1555       }
1556
1557       //Tracks refitted by ITS should already be at the SPD vertex
1558       if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1559
1560       AliTracker::
1561          PropagateTrackTo(track,kRadius,track->GetMass(),kMaxStep,kTRUE);
1562       track->RelateToVertex(fesd->GetPrimaryVertexSPD(), kBz, kVeryBig);
1563
1564     }
1565
1566     //
1567     // Improve the reconstructed primary vertex position using the tracks
1568     //
1569     Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1570     if(fesd->GetPrimaryVertexSPD()) {
1571       TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1572       if(vtitle.Contains("cosmics")) {
1573         runVertexFinderTracks=kFALSE;
1574       }
1575     }
1576
1577     if (runVertexFinderTracks) {
1578       // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
1579       const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(fgkNDetectors));
1580
1581        // TPC + ITS primary vertex
1582        ftVertexer->SetITSMode();
1583        // get cuts for vertexer from AliGRPRecoParam
1584        if (grpRecoParam) {
1585          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1586          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1587          grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1588          ftVertexer->SetCuts(cutsVertexer);
1589          delete [] cutsVertexer; cutsVertexer = NULL;
1590        }
1591        if(fDiamondProfile && fMeanVertexConstraint) {
1592          ftVertexer->SetVtxStart(fDiamondProfile);
1593        } else {
1594          ftVertexer->SetConstraintOff();
1595        }
1596        AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
1597        if (pvtx) {
1598           if (pvtx->GetStatus()) {
1599              fesd->SetPrimaryVertex(pvtx);
1600              for (Int_t i=0; i<ntracks; i++) {
1601                  AliESDtrack *t = fesd->GetTrack(i);
1602                  t->RelateToVertex(pvtx, kBz, kVeryBig);
1603              }
1604           }
1605        }
1606
1607        // TPC-only primary vertex
1608        ftVertexer->SetTPCMode();
1609        // get cuts for vertexer from AliGRPRecoParam
1610        if (grpRecoParam) {
1611          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1612          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1613          grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
1614          ftVertexer->SetCuts(cutsVertexer);
1615          delete [] cutsVertexer; cutsVertexer = NULL;
1616        }
1617        if(fDiamondProfileTPC && fMeanVertexConstraint) {
1618          ftVertexer->SetVtxStart(fDiamondProfileTPC);
1619        } else {
1620          ftVertexer->SetConstraintOff();
1621        }
1622        pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
1623        if (pvtx) {
1624           if (pvtx->GetStatus()) {
1625              fesd->SetPrimaryVertexTPC(pvtx);
1626              for (Int_t i=0; i<ntracks; i++) {
1627                  AliESDtrack *t = fesd->GetTrack(i);
1628                  t->RelateToVertexTPC(pvtx, kBz, kVeryBig);
1629              }
1630           }
1631        }
1632
1633     }
1634     delete[] selectedIdx;
1635
1636     if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
1637
1638
1639     if (fRunV0Finder) {
1640        // V0 finding
1641        AliV0vertexer vtxer;
1642        vtxer.Tracks2V0vertices(fesd);
1643
1644        if (fRunCascadeFinder) {
1645           // Cascade finding
1646           AliCascadeVertexer cvtxer;
1647           cvtxer.V0sTracks2CascadeVertices(fesd);
1648        }
1649     }
1650
1651     // write ESD
1652     if (fCleanESD) CleanESD(fesd);
1653
1654   if (fRunQA)
1655     fQASteer->RunOneEvent(fesd) ;
1656
1657   if (fRunGlobalQA) {
1658       AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1659       if (qadm && fQATasks.Contains(Form("%d", AliQA::kESDS)))
1660         qadm->Exec(AliQA::kESDS, fesd);
1661     }
1662
1663     if (fWriteESDfriend) {
1664       //      fesdf->~AliESDfriend();
1665       //  new (fesdf) AliESDfriend(); // Reset...
1666       fesd->GetESDfriend(fesdf);
1667     }
1668     ftree->Fill();
1669
1670     // Auto-save the ESD tree in case of prompt reco @P2
1671     if (fRawReader && fRawReader->UseAutoSaveESD()) {
1672       ftree->AutoSave("SaveSelf");
1673       TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
1674       if (friendfile) friendfile->Save();
1675     }
1676
1677     // write HLT ESD
1678     fhlttree->Fill();
1679
1680     // call AliEVE
1681     if (fRunAliEVE) RunAliEVE();
1682
1683     fesd->Reset();
1684     fhltesd->Reset();
1685     if (fWriteESDfriend) {
1686       fesdf->~AliESDfriend();
1687       new (fesdf) AliESDfriend(); // Reset...
1688     }
1689
1690     ProcInfo_t ProcInfo;
1691     gSystem->GetProcInfo(&ProcInfo);
1692     AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, ProcInfo.fMemResident, ProcInfo.fMemVirtual));
1693
1694     fEventInfo.Reset();
1695     for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1696       if (fReconstructor[iDet])
1697         fReconstructor[iDet]->SetRecoParam(NULL);
1698     }
1699
1700   if (fRunQA || fRunGlobalQA)
1701       fQASteer->Increment() ;
1702
1703     return kTRUE;
1704 }
1705
1706 //_____________________________________________________________________________
1707 void AliReconstruction::SlaveTerminate()
1708 {
1709   // Finalize the run on the slave side
1710   // Called after the exit
1711   // from the event loop
1712   AliCodeTimerAuto("");
1713
1714   if (fIsNewRunLoader) { // galice.root didn't exist
1715     fRunLoader->WriteHeader("OVERWRITE");
1716     fRunLoader->CdGAFile();
1717     fRunLoader->Write(0, TObject::kOverwrite);
1718   }
1719
1720   const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1721   const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1722
1723    TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
1724    cdbMapCopy->SetOwner(1);
1725    cdbMapCopy->SetName("cdbMap");
1726    TIter iter(cdbMap->GetTable());
1727
1728    TPair* pair = 0;
1729    while((pair = dynamic_cast<TPair*> (iter.Next()))){
1730          TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
1731          TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
1732          cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
1733    }
1734
1735    TList *cdbListCopy = new TList();
1736    cdbListCopy->SetOwner(1);
1737    cdbListCopy->SetName("cdbList");
1738
1739    TIter iter2(cdbList);
1740
1741         AliCDBId* id=0;
1742         while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
1743          cdbListCopy->Add(new TObjString(id->ToString().Data()));
1744    }
1745
1746    ftree->GetUserInfo()->Add(cdbMapCopy);
1747    ftree->GetUserInfo()->Add(cdbListCopy);
1748
1749
1750   if(fESDPar.Contains("ESD.par")){
1751     AliInfo("Attaching ESD.par to Tree");
1752     TNamed *fn = CopyFileToTNamed(fESDPar.Data(),"ESD.par");
1753     ftree->GetUserInfo()->Add(fn);
1754   }
1755
1756
1757   ffile->cd();
1758
1759   if (fWriteESDfriend)
1760     ftree->SetBranchStatus("ESDfriend*",0);
1761   // we want to have only one tree version number
1762   ftree->Write(ftree->GetName(),TObject::kOverwrite);
1763   fhlttree->Write();
1764
1765 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
1766   if (fRunPlaneEff && !FinishPlaneEff()) {
1767    AliWarning("Finish PlaneEff evaluation failed");
1768   }
1769
1770   // End of cycle for the in-loop
1771   if (fRunQA) {
1772     fQASteer->EndOfCycle() ;
1773   }
1774   if (fRunGlobalQA) {
1775     AliQADataMaker *qadm = fQASteer->GetQADataMaker(AliQA::kGLOBAL);
1776     if (qadm) {
1777       if (fQATasks.Contains(Form("%d", AliQA::kRECPOINTS)))
1778         qadm->EndOfCycle(AliQA::kRECPOINTS);
1779       if (fQATasks.Contains(Form("%d", AliQA::kESDS)))
1780         qadm->EndOfCycle(AliQA::kESDS);
1781       qadm->Finish();
1782     }
1783   }
1784   gROOT->cd();
1785   CleanUp();
1786 }
1787
1788 //_____________________________________________________________________________
1789 void AliReconstruction::Terminate()
1790 {
1791   // Create tags for the events in the ESD tree (the ESD tree is always present)
1792   // In case of empty events the tags will contain dummy values
1793   AliCodeTimerAuto("");
1794
1795   AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
1796   esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData);
1797
1798   // Cleanup of CDB manager: cache and active storages!
1799   AliCDBManager::Instance()->ClearCache();
1800 }
1801
1802 //_____________________________________________________________________________
1803 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
1804 {
1805 // run the local reconstruction
1806
1807   static Int_t eventNr=0;
1808   AliCodeTimerAuto("")
1809
1810   TString detStr = detectors;
1811   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1812     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1813     AliReconstructor* reconstructor = GetReconstructor(iDet);
1814     if (!reconstructor) continue;
1815     AliLoader* loader = fLoader[iDet];
1816     // Matthias April 2008: temporary fix to run HLT reconstruction
1817     // although the HLT loader is missing
1818     if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
1819       if (fRawReader) {
1820         reconstructor->Reconstruct(fRawReader, NULL);
1821       } else {
1822         TTree* dummy=NULL;
1823         reconstructor->Reconstruct(dummy, NULL);
1824       }
1825       continue;
1826     }
1827     if (!loader) {
1828       AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
1829       continue;
1830     }
1831     // conversion of digits
1832     if (fRawReader && reconstructor->HasDigitConversion()) {
1833       AliInfo(Form("converting raw data digits into root objects for %s",
1834                    fgkDetectorName[iDet]));
1835 //      AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
1836 //                            fgkDetectorName[iDet]));
1837       loader->LoadDigits("update");
1838       loader->CleanDigits();
1839       loader->MakeDigitsContainer();
1840       TTree* digitsTree = loader->TreeD();
1841       reconstructor->ConvertDigits(fRawReader, digitsTree);
1842       loader->WriteDigits("OVERWRITE");
1843       loader->UnloadDigits();
1844     }
1845     // local reconstruction
1846     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1847     //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]));
1848     loader->LoadRecPoints("update");
1849     loader->CleanRecPoints();
1850     loader->MakeRecPointsContainer();
1851     TTree* clustersTree = loader->TreeR();
1852     if (fRawReader && !reconstructor->HasDigitConversion()) {
1853       reconstructor->Reconstruct(fRawReader, clustersTree);
1854     } else {
1855       loader->LoadDigits("read");
1856       TTree* digitsTree = loader->TreeD();
1857       if (!digitsTree) {
1858         AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
1859         if (fStopOnError) return kFALSE;
1860       } else {
1861         reconstructor->Reconstruct(digitsTree, clustersTree);
1862       }
1863       loader->UnloadDigits();
1864     }
1865
1866                 TString detQAStr(fQADetectors) ;
1867                 if (fRunQA)
1868                         fQASteer->RunOneEventInOneDetector(iDet, clustersTree) ;
1869
1870         loader->WriteRecPoints("OVERWRITE");
1871         loader->UnloadRecPoints();
1872         AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
1873   }
1874   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
1875     AliError(Form("the following detectors were not found: %s",
1876                   detStr.Data()));
1877     if (fStopOnError) return kFALSE;
1878   }
1879   eventNr++;
1880   return kTRUE;
1881 }
1882
1883 //_____________________________________________________________________________
1884 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
1885 {
1886 // run the barrel tracking
1887
1888   AliCodeTimerAuto("")
1889
1890   AliESDVertex* vertex = NULL;
1891   Double_t vtxPos[3] = {0, 0, 0};
1892   Double_t vtxErr[3] = {0.07, 0.07, 0.1};
1893   TArrayF mcVertex(3);
1894   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
1895     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
1896     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
1897   }
1898
1899   if (fVertexer) {
1900     AliInfo("running the ITS vertex finder");
1901     if (fLoader[0]) {
1902       fLoader[0]->LoadRecPoints();
1903       TTree* cltree = fLoader[0]->TreeR();
1904       if (cltree) {
1905         if(fDiamondProfile) fVertexer->SetVtxStart(fDiamondProfile);
1906         vertex = fVertexer->FindVertexForCurrentEvent(cltree);
1907       }
1908       else {
1909         AliError("Can't get the ITS cluster tree");
1910       }
1911       fLoader[0]->UnloadRecPoints();
1912     }
1913     else {
1914       AliError("Can't get the ITS loader");
1915     }
1916     if(!vertex){
1917       AliWarning("Vertex not found");
1918       vertex = new AliESDVertex();
1919       vertex->SetName("default");
1920     }
1921     else {
1922       vertex->SetName("reconstructed");
1923     }
1924
1925   } else {
1926     AliInfo("getting the primary vertex from MC");
1927     vertex = new AliESDVertex(vtxPos, vtxErr);
1928   }
1929
1930   if (vertex) {
1931     vertex->GetXYZ(vtxPos);
1932     vertex->GetSigmaXYZ(vtxErr);
1933   } else {
1934     AliWarning("no vertex reconstructed");
1935     vertex = new AliESDVertex(vtxPos, vtxErr);
1936   }
1937   esd->SetPrimaryVertexSPD(vertex);
1938   // if SPD multiplicity has been determined, it is stored in the ESD
1939   AliMultiplicity *mult = fVertexer->GetMultiplicity();
1940   if(mult)esd->SetMultiplicity(mult);
1941
1942   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
1943     if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
1944   }
1945   delete vertex;
1946
1947   return kTRUE;
1948 }
1949
1950 //_____________________________________________________________________________
1951 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
1952 {
1953 // run the HLT barrel tracking
1954
1955   AliCodeTimerAuto("")
1956
1957   if (!fRunLoader) {
1958     AliError("Missing runLoader!");
1959     return kFALSE;
1960   }
1961
1962   AliInfo("running HLT tracking");
1963
1964   // Get a pointer to the HLT reconstructor
1965   AliReconstructor *reconstructor = GetReconstructor(fgkNDetectors-1);
1966   if (!reconstructor) return kFALSE;
1967
1968   // TPC + ITS
1969   for (Int_t iDet = 1; iDet >= 0; iDet--) {
1970     TString detName = fgkDetectorName[iDet];
1971     AliDebug(1, Form("%s HLT tracking", detName.Data()));
1972     reconstructor->SetOption(detName.Data());
1973     AliTracker *tracker = reconstructor->CreateTracker();
1974     if (!tracker) {
1975       AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
1976       if (fStopOnError) return kFALSE;
1977       continue;
1978     }
1979     Double_t vtxPos[3];
1980     Double_t vtxErr[3]={0.005,0.005,0.010};
1981     const AliESDVertex *vertex = esd->GetVertex();
1982     vertex->GetXYZ(vtxPos);
1983     tracker->SetVertex(vtxPos,vtxErr);
1984     if(iDet != 1) {
1985       fLoader[iDet]->LoadRecPoints("read");
1986       TTree* tree = fLoader[iDet]->TreeR();
1987       if (!tree) {
1988         AliError(Form("Can't get the %s cluster tree", detName.Data()));
1989         return kFALSE;
1990       }
1991       tracker->LoadClusters(tree);
1992     }
1993     if (tracker->Clusters2Tracks(esd) != 0) {
1994       AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
1995       return kFALSE;
1996     }
1997     if(iDet != 1) {
1998       tracker->UnloadClusters();
1999     }
2000     delete tracker;
2001   }
2002
2003   return kTRUE;
2004 }
2005
2006 //_____________________________________________________________________________
2007 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2008 {
2009 // run the muon spectrometer tracking
2010
2011   AliCodeTimerAuto("")
2012
2013   if (!fRunLoader) {
2014     AliError("Missing runLoader!");
2015     return kFALSE;
2016   }
2017   Int_t iDet = 7; // for MUON
2018
2019   AliInfo("is running...");
2020
2021   // Get a pointer to the MUON reconstructor
2022   AliReconstructor *reconstructor = GetReconstructor(iDet);
2023   if (!reconstructor) return kFALSE;
2024
2025
2026   TString detName = fgkDetectorName[iDet];
2027   AliDebug(1, Form("%s tracking", detName.Data()));
2028   AliTracker *tracker =  reconstructor->CreateTracker();
2029   if (!tracker) {
2030     AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2031     return kFALSE;
2032   }
2033
2034   // read RecPoints
2035   fLoader[iDet]->LoadRecPoints("read");
2036
2037   tracker->LoadClusters(fLoader[iDet]->TreeR());
2038
2039   Int_t rv = tracker->Clusters2Tracks(esd);
2040
2041   if ( rv )
2042   {
2043     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2044     return kFALSE;
2045   }
2046
2047   fLoader[iDet]->UnloadRecPoints();
2048
2049   tracker->UnloadClusters();
2050
2051   delete tracker;
2052
2053   return kTRUE;
2054 }
2055
2056
2057 //_____________________________________________________________________________
2058 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2059 {
2060 // run the barrel tracking
2061   static Int_t eventNr=0;
2062   AliCodeTimerAuto("")
2063
2064   AliInfo("running tracking");
2065
2066   //Fill the ESD with the T0 info (will be used by the TOF)
2067   if (fReconstructor[11] && fLoader[11]) {
2068     fLoader[11]->LoadRecPoints("READ");
2069     TTree *treeR = fLoader[11]->TreeR();
2070     GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2071   }
2072
2073   // pass 1: TPC + ITS inwards
2074   for (Int_t iDet = 1; iDet >= 0; iDet--) {
2075     if (!fTracker[iDet]) continue;
2076     AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
2077
2078     // load clusters
2079     fLoader[iDet]->LoadRecPoints("read");
2080     AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
2081     TTree* tree = fLoader[iDet]->TreeR();
2082     if (!tree) {
2083       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2084       return kFALSE;
2085     }
2086     fTracker[iDet]->LoadClusters(tree);
2087     AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2088     // run tracking
2089     if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2090       AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2091       return kFALSE;
2092     }
2093     // preliminary PID in TPC needed by the ITS tracker
2094     if (iDet == 1) {
2095       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2096       AliESDpid::MakePID(esd);
2097     }
2098     AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
2099   }
2100
2101   // pass 2: ALL backwards
2102
2103   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2104     if (!fTracker[iDet]) continue;
2105     AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2106
2107     // load clusters
2108     if (iDet > 1) {     // all except ITS, TPC
2109       TTree* tree = NULL;
2110       fLoader[iDet]->LoadRecPoints("read");
2111       AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
2112       tree = fLoader[iDet]->TreeR();
2113       if (!tree) {
2114         AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2115         return kFALSE;
2116       }
2117       fTracker[iDet]->LoadClusters(tree);
2118       AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2119     }
2120
2121     // run tracking
2122     if (iDet>1) // start filling residuals for the "outer" detectors
2123     if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
2124
2125     if (fTracker[iDet]->PropagateBack(esd) != 0) {
2126       AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
2127       //      return kFALSE;
2128     }
2129
2130     // unload clusters
2131     if (iDet > 3) {     // all except ITS, TPC, TRD and TOF
2132       fTracker[iDet]->UnloadClusters();
2133       fLoader[iDet]->UnloadRecPoints();
2134     }
2135     // updated PID in TPC needed by the ITS tracker -MI
2136     if (iDet == 1) {
2137       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2138       AliESDpid::MakePID(esd);
2139     }
2140     AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2141   }
2142   //stop filling residuals for the "outer" detectors
2143   if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
2144
2145   // pass 3: TRD + TPC + ITS refit inwards
2146
2147   for (Int_t iDet = 2; iDet >= 0; iDet--) {
2148     if (!fTracker[iDet]) continue;
2149     AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
2150
2151     // run tracking
2152     if (iDet<2) // start filling residuals for TPC and ITS
2153     if (fRunGlobalQA) AliTracker::SetFillResiduals(kTRUE);
2154
2155     if (fTracker[iDet]->RefitInward(esd) != 0) {
2156       AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
2157       //      return kFALSE;
2158     }
2159     // run postprocessing
2160     if (fTracker[iDet]->PostProcess(esd) != 0) {
2161       AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2162       //      return kFALSE;
2163     }
2164     AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2165   }
2166
2167   // write space-points to the ESD in case alignment data output
2168   // is switched on
2169   if (fWriteAlignmentData)
2170     WriteAlignmentData(esd);
2171
2172   for (Int_t iDet = 3; iDet >= 0; iDet--) {
2173     if (!fTracker[iDet]) continue;
2174     // unload clusters
2175     fTracker[iDet]->UnloadClusters();
2176     AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
2177     fLoader[iDet]->UnloadRecPoints();
2178     AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
2179   }
2180   // stop filling residuals for TPC and ITS
2181   if (fRunGlobalQA) AliTracker::SetFillResiduals(kFALSE);
2182
2183   eventNr++;
2184   return kTRUE;
2185 }
2186
2187 //_____________________________________________________________________________
2188 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2189   //
2190   // Remove the data which are not needed for the physics analysis.
2191   //
2192
2193   Int_t nTracks=esd->GetNumberOfTracks();
2194   Int_t nV0s=esd->GetNumberOfV0s();
2195   AliInfo
2196   (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
2197
2198   Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
2199   Bool_t rc=esd->Clean(cleanPars);
2200
2201   nTracks=esd->GetNumberOfTracks();
2202   nV0s=esd->GetNumberOfV0s();
2203   AliInfo
2204   (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
2205
2206   return rc;
2207 }
2208
2209 //_____________________________________________________________________________
2210 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
2211 {
2212 // fill the event summary data
2213
2214   AliCodeTimerAuto("")
2215     static Int_t eventNr=0;
2216   TString detStr = detectors;
2217
2218   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2219   if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2220     AliReconstructor* reconstructor = GetReconstructor(iDet);
2221     if (!reconstructor) continue;
2222     AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2223     TTree* clustersTree = NULL;
2224     if (fLoader[iDet]) {
2225       fLoader[iDet]->LoadRecPoints("read");
2226       clustersTree = fLoader[iDet]->TreeR();
2227       if (!clustersTree) {
2228         AliError(Form("Can't get the %s clusters tree",
2229                       fgkDetectorName[iDet]));
2230         if (fStopOnError) return kFALSE;
2231       }
2232     }
2233     if (fRawReader && !reconstructor->HasDigitConversion()) {
2234       reconstructor->FillESD(fRawReader, clustersTree, esd);
2235     } else {
2236       TTree* digitsTree = NULL;
2237       if (fLoader[iDet]) {
2238         fLoader[iDet]->LoadDigits("read");
2239         digitsTree = fLoader[iDet]->TreeD();
2240         if (!digitsTree) {
2241           AliError(Form("Can't get the %s digits tree",
2242                         fgkDetectorName[iDet]));
2243           if (fStopOnError) return kFALSE;
2244         }
2245       }
2246       reconstructor->FillESD(digitsTree, clustersTree, esd);
2247       if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2248     }
2249     if (fLoader[iDet]) {
2250       fLoader[iDet]->UnloadRecPoints();
2251     }
2252   }
2253
2254   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2255     AliError(Form("the following detectors were not found: %s",
2256                   detStr.Data()));
2257     if (fStopOnError) return kFALSE;
2258   }
2259   AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
2260   eventNr++;
2261   return kTRUE;
2262 }
2263
2264 //_____________________________________________________________________________
2265 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
2266 {
2267   // Reads the trigger decision which is
2268   // stored in Trigger.root file and fills
2269   // the corresponding esd entries
2270
2271   AliCodeTimerAuto("")
2272
2273   AliInfo("Filling trigger information into the ESD");
2274
2275   if (fRawReader) {
2276     AliCTPRawStream input(fRawReader);
2277     if (!input.Next()) {
2278       AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
2279     }
2280     else {
2281       if (esd->GetTriggerMask() != input.GetClassMask())
2282         AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2283                       input.GetClassMask(),esd->GetTriggerMask()));
2284       if (esd->GetOrbitNumber() != input.GetOrbitID())
2285         AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2286                       input.GetOrbitID(),esd->GetOrbitNumber()));
2287       if (esd->GetBunchCrossNumber() != input.GetBCID())
2288         AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2289                       input.GetBCID(),esd->GetBunchCrossNumber()));
2290     }
2291
2292   // Here one has to add the filling of trigger inputs and
2293   // interaction records
2294   // ...
2295   }
2296   return kTRUE;
2297 }
2298
2299
2300
2301
2302
2303 //_____________________________________________________________________________
2304 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
2305 {
2306   //
2307   // Filling information from RawReader Header
2308   //
2309
2310   if (!fRawReader) return kFALSE;
2311
2312   AliInfo("Filling information from RawReader Header");
2313
2314   esd->SetBunchCrossNumber(fRawReader->GetBCID());
2315   esd->SetOrbitNumber(fRawReader->GetOrbitID());
2316   esd->SetPeriodNumber(fRawReader->GetPeriod());
2317
2318   esd->SetTimeStamp(fRawReader->GetTimestamp());
2319   esd->SetEventType(fRawReader->GetType());
2320
2321   return kTRUE;
2322 }
2323
2324
2325 //_____________________________________________________________________________
2326 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2327 {
2328 // check whether detName is contained in detectors
2329 // if yes, it is removed from detectors
2330
2331   // check if all detectors are selected
2332   if ((detectors.CompareTo("ALL") == 0) ||
2333       detectors.BeginsWith("ALL ") ||
2334       detectors.EndsWith(" ALL") ||
2335       detectors.Contains(" ALL ")) {
2336     detectors = "ALL";
2337     return kTRUE;
2338   }
2339
2340   // search for the given detector
2341   Bool_t result = kFALSE;
2342   if ((detectors.CompareTo(detName) == 0) ||
2343       detectors.BeginsWith(detName+" ") ||
2344       detectors.EndsWith(" "+detName) ||
2345       detectors.Contains(" "+detName+" ")) {
2346     detectors.ReplaceAll(detName, "");
2347     result = kTRUE;
2348   }
2349
2350   // clean up the detectors string
2351   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
2352   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2353   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2354
2355   return result;
2356 }
2357
2358 //_____________________________________________________________________________
2359 Bool_t AliReconstruction::InitRunLoader()
2360 {
2361 // get or create the run loader
2362
2363   if (gAlice) delete gAlice;
2364   gAlice = NULL;
2365
2366   if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2367     // load all base libraries to get the loader classes
2368     TString libs = gSystem->GetLibraries();
2369     for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2370       TString detName = fgkDetectorName[iDet];
2371       if (detName == "HLT") continue;
2372       if (libs.Contains("lib" + detName + "base.so")) continue;
2373       gSystem->Load("lib" + detName + "base.so");
2374     }
2375     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2376     if (!fRunLoader) {
2377       AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2378       CleanUp();
2379       return kFALSE;
2380     }
2381
2382     fRunLoader->CdGAFile();
2383     fRunLoader->LoadgAlice();
2384
2385     //PH This is a temporary fix to give access to the kinematics
2386     //PH that is needed for the labels of ITS clusters
2387     fRunLoader->LoadHeader();
2388     fRunLoader->LoadKinematics();
2389
2390   } else {               // galice.root does not exist
2391     if (!fRawReader) {
2392       AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2393     }
2394     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2395                                     AliConfig::GetDefaultEventFolderName(),
2396                                     "recreate");
2397     if (!fRunLoader) {
2398       AliError(Form("could not create run loader in file %s",
2399                     fGAliceFileName.Data()));
2400       CleanUp();
2401       return kFALSE;
2402     }
2403     fIsNewRunLoader = kTRUE;
2404     fRunLoader->MakeTree("E");
2405
2406     if (fNumberOfEventsPerFile > 0)
2407       fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2408     else
2409       fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
2410   }
2411
2412   return kTRUE;
2413 }
2414
2415 //_____________________________________________________________________________
2416 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
2417 {
2418 // get the reconstructor object and the loader for a detector
2419
2420   if (fReconstructor[iDet]) {
2421     if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2422       const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2423       fReconstructor[iDet]->SetRecoParam(par);
2424     }
2425     return fReconstructor[iDet];
2426   }
2427
2428   // load the reconstructor object
2429   TPluginManager* pluginManager = gROOT->GetPluginManager();
2430   TString detName = fgkDetectorName[iDet];
2431   TString recName = "Ali" + detName + "Reconstructor";
2432
2433   if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
2434
2435   AliReconstructor* reconstructor = NULL;
2436   // first check if a plugin is defined for the reconstructor
2437   TPluginHandler* pluginHandler =
2438     pluginManager->FindHandler("AliReconstructor", detName);
2439   // if not, add a plugin for it
2440   if (!pluginHandler) {
2441     AliDebug(1, Form("defining plugin for %s", recName.Data()));
2442     TString libs = gSystem->GetLibraries();
2443     if (libs.Contains("lib" + detName + "base.so") ||
2444         (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2445       pluginManager->AddHandler("AliReconstructor", detName,
2446                                 recName, detName + "rec", recName + "()");
2447     } else {
2448       pluginManager->AddHandler("AliReconstructor", detName,
2449                                 recName, detName, recName + "()");
2450     }
2451     pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2452   }
2453   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2454     reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
2455   }
2456   if (reconstructor) {
2457     TObject* obj = fOptions.FindObject(detName.Data());
2458     if (obj) reconstructor->SetOption(obj->GetTitle());
2459     reconstructor->Init();
2460     fReconstructor[iDet] = reconstructor;
2461   }
2462
2463   // get or create the loader
2464   if (detName != "HLT") {
2465     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2466     if (!fLoader[iDet]) {
2467       AliConfig::Instance()
2468         ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2469                                 detName, detName);
2470       // first check if a plugin is defined for the loader
2471       pluginHandler =
2472         pluginManager->FindHandler("AliLoader", detName);
2473       // if not, add a plugin for it
2474       if (!pluginHandler) {
2475         TString loaderName = "Ali" + detName + "Loader";
2476         AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2477         pluginManager->AddHandler("AliLoader", detName,
2478                                   loaderName, detName + "base",
2479                                   loaderName + "(const char*, TFolder*)");
2480         pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2481       }
2482       if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2483         fLoader[iDet] =
2484           (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2485                                                  fRunLoader->GetEventFolder());
2486       }
2487       if (!fLoader[iDet]) {   // use default loader
2488         fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2489       }
2490       if (!fLoader[iDet]) {
2491         AliWarning(Form("couldn't get loader for %s", detName.Data()));
2492         if (fStopOnError) return NULL;
2493       } else {
2494         fRunLoader->AddLoader(fLoader[iDet]);
2495         fRunLoader->CdGAFile();
2496         if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2497         fRunLoader->Write(0, TObject::kOverwrite);
2498       }
2499     }
2500   }
2501
2502   if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2503     const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2504     reconstructor->SetRecoParam(par);
2505   }
2506   return reconstructor;
2507 }
2508
2509 //_____________________________________________________________________________
2510 Bool_t AliReconstruction::CreateVertexer()
2511 {
2512 // create the vertexer
2513
2514   fVertexer = NULL;
2515   AliReconstructor* itsReconstructor = GetReconstructor(0);
2516   if (itsReconstructor) {
2517     fVertexer = itsReconstructor->CreateVertexer();
2518   }
2519   if (!fVertexer) {
2520     AliWarning("couldn't create a vertexer for ITS");
2521     if (fStopOnError) return kFALSE;
2522   }
2523
2524   return kTRUE;
2525 }
2526
2527 //_____________________________________________________________________________
2528 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
2529 {
2530 // create the trackers
2531
2532   TString detStr = detectors;
2533   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2534     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2535     AliReconstructor* reconstructor = GetReconstructor(iDet);
2536     if (!reconstructor) continue;
2537     TString detName = fgkDetectorName[iDet];
2538     if (detName == "HLT") {
2539       fRunHLTTracking = kTRUE;
2540       continue;
2541     }
2542     if (detName == "MUON") {
2543       fRunMuonTracking = kTRUE;
2544       continue;
2545     }
2546
2547
2548     fTracker[iDet] = reconstructor->CreateTracker();
2549     if (!fTracker[iDet] && (iDet < 7)) {
2550       AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2551       if (fStopOnError) return kFALSE;
2552     }
2553     AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
2554   }
2555
2556   return kTRUE;
2557 }
2558
2559 //_____________________________________________________________________________
2560 void AliReconstruction::CleanUp()
2561 {
2562 // delete trackers and the run loader and close and delete the file
2563
2564   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2565     delete fReconstructor[iDet];
2566     fReconstructor[iDet] = NULL;
2567     fLoader[iDet] = NULL;
2568     delete fTracker[iDet];
2569     fTracker[iDet] = NULL;
2570   }
2571   delete fRunInfo;
2572   fRunInfo = NULL;
2573
2574   delete fVertexer;
2575   fVertexer = NULL;
2576
2577   delete ftVertexer;
2578   ftVertexer = NULL;
2579
2580   if(!(AliCDBManager::Instance()->GetCacheFlag())) {
2581     delete fDiamondProfile;
2582     fDiamondProfile = NULL;
2583     delete fDiamondProfileTPC;
2584     fDiamondProfileTPC = NULL;
2585   }
2586   delete fRunLoader;
2587   fRunLoader = NULL;
2588   delete fRawReader;
2589   fRawReader = NULL;
2590   delete fParentRawReader;
2591   fParentRawReader=NULL;
2592
2593   if (ffile) {
2594     ffile->Close();
2595     delete ffile;
2596     ffile = NULL;
2597   }
2598 }
2599
2600 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
2601 {
2602   // Write space-points which are then used in the alignment procedures
2603   // For the moment only ITS, TPC, TRD and TOF
2604
2605   Int_t ntracks = esd->GetNumberOfTracks();
2606   for (Int_t itrack = 0; itrack < ntracks; itrack++)
2607     {
2608       AliESDtrack *track = esd->GetTrack(itrack);
2609       Int_t nsp = 0;
2610       Int_t idx[200];
2611       for (Int_t iDet = 3; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
2612           nsp += track->GetNcls(iDet);
2613
2614           if (iDet==0) { // ITS "extra" clusters
2615              track->GetClusters(iDet,idx);
2616              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
2617           }
2618       }
2619
2620       if (nsp) {
2621         AliTrackPointArray *sp = new AliTrackPointArray(nsp);
2622         track->SetTrackPointArray(sp);
2623         Int_t isptrack = 0;
2624         for (Int_t iDet = 3; iDet >= 0; iDet--) {
2625           AliTracker *tracker = fTracker[iDet];
2626           if (!tracker) continue;
2627           Int_t nspdet = track->GetClusters(iDet,idx);
2628
2629           if (iDet==0) // ITS "extra" clusters
2630              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
2631
2632           if (nspdet <= 0) continue;
2633           AliTrackPoint p;
2634           Int_t isp = 0;
2635           Int_t isp2 = 0;
2636           while (isp2 < nspdet) {
2637             Bool_t isvalid=kTRUE;
2638
2639             Int_t index=idx[isp++];
2640             if (index < 0) continue;
2641
2642             TString dets = fgkDetectorName[iDet];
2643             if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
2644             fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
2645             fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
2646             fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
2647               isvalid = tracker->GetTrackPointTrackingError(index,p,track);
2648             } else {
2649               isvalid = tracker->GetTrackPoint(index,p);
2650             }
2651             isp2++;
2652             if (!isvalid) continue;
2653             sp->AddPoint(isptrack,&p); isptrack++;
2654           }
2655         }
2656       }
2657     }
2658 }
2659
2660 //_____________________________________________________________________________
2661 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
2662 {
2663   // The method reads the raw-data error log
2664   // accumulated within the rawReader.
2665   // It extracts the raw-data errors related to
2666   // the current event and stores them into
2667   // a TClonesArray inside the esd object.
2668
2669   if (!fRawReader) return;
2670
2671   for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
2672
2673     AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
2674     if (!log) continue;
2675     if (iEvent != log->GetEventNumber()) continue;
2676
2677     esd->AddRawDataErrorLog(log);
2678   }
2679
2680 }
2681
2682 TNamed* AliReconstruction::CopyFileToTNamed(TString fPath,TString pName){
2683   // Dump a file content into a char in TNamed
2684   ifstream in;
2685   in.open(fPath.Data(),ios::in | ios::binary|ios::ate);
2686   Int_t kBytes = (Int_t)in.tellg();
2687   printf("Size: %d \n",kBytes);
2688   TNamed *fn = 0;
2689   if(in.good()){
2690     char* memblock = new char [kBytes];
2691     in.seekg (0, ios::beg);
2692     in.read (memblock, kBytes);
2693     in.close();
2694     TString fData(memblock,kBytes);
2695     fn = new TNamed(pName,fData);
2696     printf("fData Size: %d \n",fData.Sizeof());
2697     printf("pName Size: %d \n",pName.Sizeof());
2698     printf("fn    Size: %d \n",fn->Sizeof());
2699     delete[] memblock;
2700   }
2701   else{
2702     AliInfo(Form("Could not Open %s\n",fPath.Data()));
2703   }
2704
2705   return fn;
2706 }
2707
2708 void AliReconstruction::TNamedToFile(TTree* fTree, TString pName){
2709   // This is not really needed in AliReconstruction at the moment
2710   // but can serve as a template
2711
2712   TList *fList = fTree->GetUserInfo();
2713   TNamed *fn = (TNamed*)fList->FindObject(pName.Data());
2714   printf("fn Size: %d \n",fn->Sizeof());
2715
2716   TString fTmp(fn->GetName()); // to be 100% sure in principle pName also works
2717   const char* cdata = fn->GetTitle();
2718   printf("fTmp Size %d\n",fTmp.Sizeof());
2719
2720   int size = fn->Sizeof()-fTmp.Sizeof()-sizeof(UChar_t)-sizeof(Int_t); // see dfinition of TString::SizeOf()...
2721   printf("calculated size %d\n",size);
2722   ofstream out(pName.Data(),ios::out | ios::binary);
2723   out.write(cdata,size);
2724   out.close();
2725
2726 }
2727
2728 //_____________________________________________________________________________
2729 void AliReconstruction::CheckQA()
2730 {
2731 // check the QA of SIM for this run and remove the detectors
2732 // with status Fatal
2733
2734         TString newRunLocalReconstruction ;
2735         TString newRunTracking ;
2736         TString newFillESD ;
2737
2738         for (Int_t iDet = 0; iDet < AliQA::kNDET; iDet++) {
2739                 TString detName(AliQA::GetDetName(iDet)) ;
2740                 AliQA * qa = AliQA::Instance(AliQA::DETECTORINDEX_t(iDet)) ;
2741                 if ( qa->IsSet(AliQA::DETECTORINDEX_t(iDet), AliQA::kSIM, AliQA::kFATAL)) {
2742                                 AliInfo(Form("QA status for %s in Hits and/or SDIGITS  and/or Digits was Fatal; No reconstruction performed", detName.Data())) ;
2743                 } else {
2744                         if ( fRunLocalReconstruction.Contains(AliQA::GetDetName(iDet)) ||
2745                                         fRunLocalReconstruction.Contains("ALL") )  {
2746                                 newRunLocalReconstruction += detName ;
2747                                 newRunLocalReconstruction += " " ;
2748                         }
2749                         if ( fRunTracking.Contains(AliQA::GetDetName(iDet)) ||
2750                                         fRunTracking.Contains("ALL") )  {
2751                                 newRunTracking += detName ;
2752                                 newRunTracking += " " ;
2753                         }
2754                         if ( fFillESD.Contains(AliQA::GetDetName(iDet)) ||
2755                                         fFillESD.Contains("ALL") )  {
2756                                 newFillESD += detName ;
2757                                 newFillESD += " " ;
2758                         }
2759                 }
2760         }
2761         fRunLocalReconstruction = newRunLocalReconstruction ;
2762         fRunTracking            = newRunTracking ;
2763         fFillESD                = newFillESD ;
2764 }
2765
2766 //_____________________________________________________________________________
2767 Int_t AliReconstruction::GetDetIndex(const char* detector)
2768 {
2769   // return the detector index corresponding to detector
2770   Int_t index = -1 ;
2771   for (index = 0; index < fgkNDetectors ; index++) {
2772     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
2773         break ;
2774   }
2775   return index ;
2776 }
2777 //_____________________________________________________________________________
2778 Bool_t AliReconstruction::FinishPlaneEff() {
2779  //
2780  // Here execute all the necessary operationis, at the end of the tracking phase,
2781  // in case that evaluation of PlaneEfficiencies was required for some detector.
2782  // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
2783  //
2784  // This Preliminary version works only FOR ITS !!!!!
2785  // other detectors (TOF,TRD, etc. have to develop their specific codes)
2786  //
2787  //  Input: none
2788  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
2789  //
2790  Bool_t ret=kFALSE;
2791  //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2792  for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
2793    //if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2794    if(fTracker[iDet]) {
2795       AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
2796       TString name=planeeff->GetName();
2797       name+=".root";
2798       TFile* pefile = TFile::Open(name, "RECREATE");
2799       ret=(Bool_t)planeeff->Write();
2800       pefile->Close();
2801       if(planeeff->GetCreateHistos()) {
2802         TString hname=planeeff->GetName();
2803         hname+="Histo.root";
2804         ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
2805       }
2806    }
2807  }
2808  return ret;
2809 }
2810 //_____________________________________________________________________________
2811 Bool_t AliReconstruction::InitPlaneEff() {
2812 //
2813  // Here execute all the necessary operations, before of the tracking phase,
2814  // for the evaluation of PlaneEfficiencies, in case required for some detectors.
2815  // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
2816  // which should be updated/recalculated.
2817  //
2818  // This Preliminary version will work only FOR ITS !!!!!
2819  // other detectors (TOF,TRD, etc. have to develop their specific codes)
2820  //
2821  //  Input: none
2822  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
2823  //
2824  AliWarning(Form("Implementation of this method not yet done !! Method return kTRUE"));
2825  return kTRUE;
2826 }
2827
2828 //_____________________________________________________________________________
2829 Bool_t AliReconstruction::InitAliEVE()
2830 {
2831   // This method should be called only in case
2832   // AliReconstruction is run
2833   // within the alieve environment.
2834   // It will initialize AliEVE in a way
2835   // so that it can visualize event processed
2836   // by AliReconstruction.
2837   // The return flag shows whenever the
2838   // AliEVE initialization was successful or not.
2839
2840   TString macroStr;
2841   macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
2842   AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
2843   if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
2844
2845   gROOT->ProcessLine("if (!gAliEveEvent) {gAliEveEvent = new AliEveEventManager();gAliEveEvent->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(gAliEveEvent);};");
2846   gROOT->ProcessLine("alieve_online_init()");
2847
2848   return kTRUE;
2849 }
2850
2851 //_____________________________________________________________________________
2852 void AliReconstruction::RunAliEVE()
2853 {
2854   // Runs AliEVE visualisation of
2855   // the current event.
2856   // Should be executed only after
2857   // successful initialization of AliEVE.
2858
2859   AliInfo("Running AliEVE...");
2860   gROOT->ProcessLine(Form("gAliEveEvent->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p);",fRunLoader,fRawReader,fesd));
2861   gSystem->Run();
2862 }
2863
2864 //_____________________________________________________________________________
2865 Bool_t AliReconstruction::SetRunQA(TString detAndAction)
2866 {
2867         // Allows to run QA for a selected set of detectors
2868         // and a selected set of tasks among RAWS, RECPOINTS and ESDS
2869         // all selected detectors run the same selected tasks
2870
2871         if (!detAndAction.Contains(":")) {
2872                 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
2873                 fRunQA = kFALSE ;
2874                 return kFALSE ;
2875         }
2876         Int_t colon = detAndAction.Index(":") ;
2877         fQADetectors = detAndAction(0, colon) ;
2878         if (fQADetectors.Contains("ALL") )
2879                 fQADetectors = fFillESD ;
2880                 fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ;
2881         if (fQATasks.Contains("ALL") ) {
2882                 fQATasks = Form("%d %d %d", AliQA::kRAWS, AliQA::kRECPOINTS, AliQA::kESDS) ;
2883         } else {
2884                 fQATasks.ToUpper() ;
2885                 TString tempo("") ;
2886                 if ( fQATasks.Contains("RAW") )
2887                         tempo = Form("%d ", AliQA::kRAWS) ;
2888                 if ( fQATasks.Contains("RECPOINT") )
2889                         tempo += Form("%d ", AliQA::kRECPOINTS) ;
2890                 if ( fQATasks.Contains("ESD") )
2891                         tempo += Form("%d ", AliQA::kESDS) ;
2892                 fQATasks = tempo ;
2893                 if (fQATasks.IsNull()) {
2894                         AliInfo("No QA requested\n")  ;
2895                         fRunQA = kFALSE ;
2896                         return kTRUE ;
2897                 }
2898         }
2899         TString tempo(fQATasks) ;
2900         tempo.ReplaceAll(Form("%d", AliQA::kRAWS), AliQA::GetTaskName(AliQA::kRAWS))    ;
2901         tempo.ReplaceAll(Form("%d", AliQA::kRECPOINTS), AliQA::GetTaskName(AliQA::kRECPOINTS)) ;
2902         tempo.ReplaceAll(Form("%d", AliQA::kESDS), AliQA::GetTaskName(AliQA::kESDS)) ;
2903         AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
2904         fRunQA = kTRUE ;
2905         return kTRUE;
2906 }
2907
2908 //_____________________________________________________________________________
2909 Bool_t AliReconstruction::InitRecoParams()
2910 {
2911   // The method accesses OCDB and retrieves all
2912   // the available reco-param objects from there.
2913
2914   Bool_t isOK = kTRUE;
2915
2916   TString detStr = fLoadCDB;
2917   for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
2918
2919     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2920
2921     if (fRecoParam.GetDetRecoParamArray(iDet)) {
2922       AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
2923       continue;
2924     }
2925
2926     AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
2927
2928     AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
2929     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
2930     if(!entry){
2931       AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
2932       isOK = kFALSE;
2933     }
2934     else {
2935       TObject *recoParamObj = entry->GetObject();
2936       if (dynamic_cast<TObjArray*>(recoParamObj)) {
2937         // The detector has a normal TobjArray of AliDetectorRecoParam objects
2938         // Registering them in AliRecoParam
2939         fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
2940       }
2941       else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
2942         // The detector has only onse set of reco parameters
2943         // Registering it in AliRecoParam
2944         AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
2945         dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
2946         fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
2947       }
2948       else {
2949         AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
2950         isOK = kFALSE;
2951       }
2952       entry->SetOwner(0);
2953       AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
2954     }
2955   }
2956
2957   if (AliDebugLevel() > 0) fRecoParam.Print();
2958
2959   return isOK;
2960 }
2961
2962 //_____________________________________________________________________________
2963 Bool_t AliReconstruction::GetEventInfo()
2964 {
2965   // Fill the event info object
2966   // ...
2967   AliCodeTimerAuto("")
2968
2969   AliCentralTrigger *aCTP = NULL;
2970   if (fRawReader) {
2971     fEventInfo.SetEventType(fRawReader->GetType());
2972
2973     ULong64_t mask = fRawReader->GetClassMask();
2974     fEventInfo.SetTriggerMask(mask);
2975     UInt_t clmask = fRawReader->GetDetectorPattern()[0];
2976     fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
2977
2978     aCTP = new AliCentralTrigger();
2979     TString configstr("");
2980     if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
2981       AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
2982       delete aCTP;
2983       return kFALSE;
2984     }
2985     aCTP->SetClassMask(mask);
2986     aCTP->SetClusterMask(clmask);
2987   }
2988   else {
2989     fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
2990
2991     if (fRunLoader && (!fRunLoader->LoadTrigger())) {
2992       aCTP = fRunLoader->GetTrigger();
2993       fEventInfo.SetTriggerMask(aCTP->GetClassMask());
2994       fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
2995     }
2996     else {
2997       AliWarning("No trigger can be loaded! The trigger information will not be used!");
2998       return kFALSE;
2999     }
3000   }
3001
3002   AliTriggerConfiguration *config = aCTP->GetConfiguration();
3003   if (!config) {
3004     AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3005     if (fRawReader) delete aCTP;
3006     return kFALSE;
3007   }
3008
3009   UChar_t clustmask = 0;
3010   TString trclasses;
3011   ULong64_t trmask = fEventInfo.GetTriggerMask();
3012   const TObjArray& classesArray = config->GetClasses();
3013   Int_t nclasses = classesArray.GetEntriesFast();
3014   for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
3015     AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
3016     if (trclass) {
3017       Int_t trindex = (Int_t)TMath::Log2(trclass->GetMask());
3018       fesd->SetTriggerClass(trclass->GetName(),trindex);
3019       if (trmask & (1 << trindex)) {
3020         trclasses += " ";
3021         trclasses += trclass->GetName();
3022         trclasses += " ";
3023         clustmask |= trclass->GetCluster()->GetClusterMask();
3024       }
3025     }
3026   }
3027   fEventInfo.SetTriggerClasses(trclasses);
3028
3029   // Set the information in ESD
3030   fesd->SetTriggerMask(trmask);
3031   fesd->SetTriggerCluster(clustmask);
3032
3033   if (!aCTP->CheckTriggeredDetectors()) {
3034     if (fRawReader) delete aCTP;
3035     return kFALSE;
3036   }
3037
3038   if (fRawReader) delete aCTP;
3039
3040   // We have to fill also the HLT decision here!!
3041   // ...
3042
3043   return kTRUE;
3044 }
3045
3046 const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
3047 {
3048   // Match the detector list found in the rec.C or the default 'ALL'
3049   // to the list found in the GRP (stored there by the shuttle PP which
3050   // gets the information from ECS)
3051   static TString resultList;
3052   TString detList = detectorList;
3053
3054   resultList = "";
3055
3056   for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
3057     if ((detectorMask >> iDet) & 0x1) {
3058       TString det = AliDAQ::OfflineModuleName(iDet);
3059       if ((detList.CompareTo("ALL") == 0) ||
3060           detList.BeginsWith("ALL ") ||
3061           detList.EndsWith(" ALL") ||
3062           detList.Contains(" ALL ") ||
3063           (detList.CompareTo(det) == 0) ||
3064           detList.BeginsWith(det) ||
3065           detList.EndsWith(det) ||
3066           detList.Contains( " "+det+" " )) {
3067         if (!resultList.EndsWith(det + " ")) {
3068           resultList += det;
3069           resultList += " ";
3070         }
3071       }
3072     }
3073   }
3074
3075   // HLT
3076   if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
3077     TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
3078     if ((detList.CompareTo("ALL") == 0) ||
3079         detList.BeginsWith("ALL ") ||
3080         detList.EndsWith(" ALL") ||
3081         detList.Contains(" ALL ") ||
3082         (detList.CompareTo(hltDet) == 0) ||
3083         detList.BeginsWith(hltDet) ||
3084         detList.EndsWith(hltDet) ||
3085         detList.Contains( " "+hltDet+" " )) {
3086       resultList += hltDet;
3087     }
3088   }
3089
3090   return resultList.Data();
3091
3092 }
3093
3094 //______________________________________________________________________________
3095 void AliReconstruction::Abort(const char *method, EAbort what)
3096 {
3097   // Abort processing. If what = kAbortProcess, the Process() loop will be
3098   // aborted. If what = kAbortFile, the current file in a chain will be
3099   // aborted and the processing will continue with the next file, if there
3100   // is no next file then Process() will be aborted. Abort() can also  be
3101   // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
3102   // the SlaveTerminate() and Terminate() are always called. The abort flag
3103   // can be checked in these methods using GetAbort().
3104   //
3105   // The method is overwritten in AliReconstruction for better handling of
3106   // reco specific errors
3107
3108   if (!fStopOnError) return;
3109
3110   CleanUp();
3111
3112   TString whyMess = method;
3113   whyMess += " failed! Aborting...";
3114
3115   AliError(whyMess.Data());
3116
3117   fAbort = what;
3118   TString mess = "Abort";
3119   if (fAbort == kAbortProcess)
3120     mess = "AbortProcess";
3121   else if (fAbort == kAbortFile)
3122     mess = "AbortFile";
3123
3124   Info(mess, whyMess.Data());
3125 }
3126