STEER/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: AliReconstruction.cxx 63911 2013-08-19 16:46:41Z hristov $ */
  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 <TArrayD.h>
 112 #include <TArrayF.h>
 113 #include <TArrayS.h>
 114 #include <TChain.h>
 115 #include <TFile.h>
 116 #include <TGeoGlobalMagField.h>
 117 #include <TGeoManager.h>
 118 #include <TList.h>
 119 #include <TLorentzVector.h>
 120 #include <TMap.h>
 121 #include <TObjArray.h>
 122 #include <TPRegexp.h>
 123 #include <TParameter.h>
 124 #include <TPluginManager.h>
 125 #include <TProof.h>
 126 #include <TProofOutputFile.h>
 127 #include <TROOT.h>
 128 #include <TSystem.h>
 129 #include <THashTable.h>
 130 #include <TGrid.h>
 131 #include <TMessage.h>
 132 #include <TUrl.h>
 133 #include <TRandom.h>
 134 #include <THashList.h>
 135
 136 #include "AliAlignObj.h"
 137 #include "AliAnalysisManager.h"
 138 #include "AliAnalysisDataContainer.h"
 139 #include "AliCDBEntry.h"
 140 #include "AliCDBManager.h"
 141 #include "AliCDBStorage.h"
 142 #include "AliCTPRawStream.h"
 143 #include "AliCascadeVertexer.h"
 144 #include "AliCentralTrigger.h"
 145 #include "AliCodeTimer.h"
 146 #include "AliDAQ.h"
 147 #include "AliDetectorRecoParam.h"
 148 #include "AliESDCaloCells.h"
 149 #include "AliESDCaloCluster.h"
 150 #include "AliESDEvent.h"
 151 #include "AliESDMuonTrack.h"
 152 #include "AliESDPmdTrack.h"
 153 #include "AliESDTagCreator.h"
 154 #include "AliESDVertex.h"
 155 #include "AliESDcascade.h"
 156 #include "AliESDfriend.h"
 157 #include "AliESDkink.h"
 158 #include "AliESDpid.h"
 159 #include "AliESDtrack.h"
 160 #include "AliESDtrack.h"
 161 #include "AliEventInfo.h"
 162 #include "AliGRPObject.h"
 163 #include "AliGRPRecoParam.h"
 164 #include "AliGenEventHeader.h"
 165 #include "AliGeomManager.h"
 166 #include "AliGlobalQADataMaker.h"
 167 #include "AliHeader.h"
 168 #include "AliLog.h"
 169 #include "AliMagF.h"
 170 #include "AliMultiplicity.h"
 171 #include "AliPID.h"
 172 #include "AliPlaneEff.h"
 173 #include "AliQAv1.h"
 174 #include "AliQADataMakerRec.h"
 175 #include "AliQAManager.h"
 176 #include "AliRawVEvent.h"
 177 #include "AliRawEventHeaderBase.h"
 178 #include "AliRawHLTManager.h"
 179 #include "AliRawReaderDate.h"
 180 #include "AliRawReaderFile.h"
 181 #include "AliRawReaderRoot.h"
 182 #include "AliRecoInputHandler.h"
 183 #include "AliReconstruction.h"
 184 #include "AliReconstructor.h"
 185 #include "AliRun.h"
 186 #include "AliRunInfo.h"
 187 #include "AliRunLoader.h"
 188 #include "AliSysInfo.h" // memory snapshots
 189 #include "AliTrackPointArray.h"
 190 #include "AliTracker.h"
 191 #include "AliTriggerClass.h"
 192 #include "AliTriggerCluster.h"
 193 #include "AliTriggerIR.h"
 194 #include "AliTriggerConfiguration.h"
 195 #include "AliV0vertexer.h"
 196 #include "AliVertexer.h"
 197 #include "AliTrackleter.h"
 198 #include "AliVertexerTracks.h"
 199 #include "AliTriggerRunScalers.h"
 200 #include "AliCTPTimeParams.h"
 201 #include "AliESDHLTDecision.h"
 202 #include "AliTriggerInput.h"
 203 #include "AliLHCData.h"
 204 #include "ARVersion.h"
 205 #include <RVersion.h>
 206 #include <stdlib.h>
 207 #include <unistd.h>
 208 #include <sys/resource.h>
 209 ClassImp(AliReconstruction)
 210
 211 using std::endl;
 212
 213 //_____________________________________________________________________________
 214 const char* AliReconstruction::fgkStopEvFName = "_stopEvent_";
 215 const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD",
 216 "TOF", "PHOS",
 217 "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE","AD","FIT","MFT", "HLT"};
 218
 219 //_____________________________________________________________________________
 220 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
 221   TSelector(),
 222   fRunVertexFinder(kTRUE),
 223   fRunVertexFinderTracks(kTRUE),
 224   fRunMuonTracking(kFALSE),
 225   fRunMFTTrackingMU(kFALSE),
 226   fRunV0Finder(kTRUE),
 227   fRunCascadeFinder(kTRUE),
 228   fRunMultFinder(kTRUE),
 229   fStopOnError(kTRUE),
 230   fStopOnMissingTriggerFile(kTRUE),
 231   fWriteAlignmentData(kFALSE),
 232   fWriteESDfriend(kFALSE),
 233   fFillTriggerESD(kTRUE),
 234
 235   fCleanESD(kTRUE),
 236   fV0DCAmax(3.),
 237   fV0CsPmin(0.),
 238   fDmax(50.),
 239   fZmax(50.),
 240
 241   fRunLocalReconstruction("ALL"),
 242   fRunTracking("ALL"),
 243   fFillESD("ALL"),
 244   fDeleteRecPoints(""),
 245   fDeleteDigits(""),
 246   fLoadCDB(""),
 247   fUseTrackingErrorsForAlignment(""),
 248   fGAliceFileName(gAliceFilename),
 249   fRawInput(""),
 250   fESDOutput(""),
 251   fProofOutputFileName(""),
 252   fProofOutputLocation(""),
 253   fProofOutputDataset(kFALSE),
 254   fProofOutputArchive(""),
 255   fEquipIdMap(""),
 256   fFirstEvent(0),
 257   fLastEvent(-1),
 258   fNumberOfEventsPerFile((UInt_t)-1),
 259   fFractionFriends(0.04),
 260   fOptions(),
 261   fLoadAlignFromCDB(kTRUE),
 262   fLoadAlignData("ALL"),
 263   fUseHLTData(),
 264   fRunInfo(NULL),
 265   fEventInfo(),
 266   fRunScalers(NULL),
 267   fCTPTimeParams(NULL),
 268   fCTPTimeAlign(NULL),
 269
 270   fRunLoader(NULL),
 271   fRawReader(NULL),
 272   fParentRawReader(NULL),
 273
 274   fRecoParam(),
 275
 276   fSPDTrackleter(NULL),
 277
 278   fDiamondProfileSPD(NULL),
 279   fDiamondProfile(NULL),
 280   fDiamondProfileTPC(NULL),
 281   fListOfCosmicTriggers(NULL),
 282
 283   fGRPData(NULL),
 284
 285   fAlignObjArray(NULL),
 286   fCDBUri(),
 287   fQARefUri(),
 288   fSpecCDBUri(),
 289   fCheckRecoCDBvsSimuCDB(),
 290   fInitCDBCalled(kFALSE),
 291   fCDBSnapshotMode(kFALSE),
 292   fSetRunNumberFromDataCalled(kFALSE),
 293   fQADetectors("ALL"),
 294   fQATasks("ALL"),
 295   fRunQA(kTRUE),
 296   fRunGlobalQA(kTRUE),
 297   fSameQACycle(kFALSE),
 298   fInitQACalled(kFALSE),
 299   fWriteQAExpertData(kTRUE),
 300   fRunPlaneEff(kFALSE),
 301
 302   fESDpid(NULL),
 303
 304   fesd(NULL),
 305   fhltesd(NULL),
 306   fesdf(NULL),
 307   ffile(NULL),
 308   ffileF(NULL),
 309   ftree(NULL),
 310   ftreeF(NULL),
 311   fhlttree(NULL),
 312   ftVertexer(NULL),
 313   fIsNewRunLoader(kFALSE),
 314   fRunAliEVE(kFALSE),
 315   fChain(NULL),
 316   fNall(0),
 317   fNspecie(0),
 318   fSspecie(0),
 319   fNhighPt(0),
 320   fShighPt(0),
 321   //
 322   fTreeBuffSize(30000000),
 323   fMemCountESD(0),
 324   fMemCountESDF(0),
 325   fMemCountESDHLT(0),
 326   //
 327   fUpgradeModule(""),
 328   fAnalysisMacro(),
 329   fAnalysis(0),
 330   fRecoHandler(0),
 331   fDeclTriggerClasses(""),
 332   fStopped(kFALSE),
 333   fMaxRSS(0),
 334   fMaxVMEM(0)
 335 {
 336 // create reconstruction object with default parameters
 337   gGeoManager = NULL;
 338
 339   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 340     fReconstructor[iDet] = NULL;
 341     fUpgradeMask[iDet]=kFALSE;
 342     fLoader[iDet] = NULL;
 343     fTracker[iDet] = NULL;
 344   }
 345   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
 346     fQACycles[iDet] = 999999 ;
 347     fQAWriteExpert[iDet] = kFALSE ;
 348   }
 349   fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
 350   //
 351   AddCheckRecoCDBvsSimuCDB("TPC/Calib/RecoParam"); // check for similarity in the sim and rec
 352   //
 353   AliPID pid;
 354 }
 355
 356 //_____________________________________________________________________________
 357 AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
 358   TSelector(),
 359   fRunVertexFinder(rec.fRunVertexFinder),
 360   fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
 361   fRunMuonTracking(rec.fRunMuonTracking),
 362   fRunMFTTrackingMU(rec.fRunMFTTrackingMU),
 363   fRunV0Finder(rec.fRunV0Finder),
 364   fRunCascadeFinder(rec.fRunCascadeFinder),
 365   fRunMultFinder(rec.fRunMultFinder),
 366   fStopOnError(rec.fStopOnError),
 367   fStopOnMissingTriggerFile(rec.fStopOnMissingTriggerFile),
 368   fWriteAlignmentData(rec.fWriteAlignmentData),
 369   fWriteESDfriend(rec.fWriteESDfriend),
 370   fFillTriggerESD(rec.fFillTriggerESD),
 371
 372   fCleanESD(rec.fCleanESD),
 373   fV0DCAmax(rec.fV0DCAmax),
 374   fV0CsPmin(rec.fV0CsPmin),
 375   fDmax(rec.fDmax),
 376   fZmax(rec.fZmax),
 377
 378   fRunLocalReconstruction(rec.fRunLocalReconstruction),
 379   fRunTracking(rec.fRunTracking),
 380   fFillESD(rec.fFillESD),
 381   fDeleteRecPoints(""),
 382   fDeleteDigits(""),
 383   fLoadCDB(rec.fLoadCDB),
 384   fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
 385   fGAliceFileName(rec.fGAliceFileName),
 386   fRawInput(rec.fRawInput),
 387   fESDOutput(rec.fESDOutput),
 388   fProofOutputFileName(rec.fProofOutputFileName),
 389   fProofOutputLocation(rec.fProofOutputLocation),
 390   fProofOutputDataset(rec.fProofOutputDataset),
 391   fProofOutputArchive(rec.fProofOutputArchive),
 392   fEquipIdMap(rec.fEquipIdMap),
 393   fFirstEvent(rec.fFirstEvent),
 394   fLastEvent(rec.fLastEvent),
 395   fNumberOfEventsPerFile(rec.fNumberOfEventsPerFile),
 396   fFractionFriends(rec.fFractionFriends),
 397   fOptions(),
 398   fLoadAlignFromCDB(rec.fLoadAlignFromCDB),
 399   fLoadAlignData(rec.fLoadAlignData),
 400   fUseHLTData(rec.fUseHLTData),
 401   fRunInfo(NULL),
 402   fEventInfo(),
 403   fRunScalers(NULL),
 404   fCTPTimeParams(NULL),
 405   fCTPTimeAlign(NULL),
 406
 407   fRunLoader(NULL),
 408   fRawReader(NULL),
 409   fParentRawReader(NULL),
 410
 411   fRecoParam(rec.fRecoParam),
 412
 413   fSPDTrackleter(NULL),
 414
 415   fDiamondProfileSPD(rec.fDiamondProfileSPD),
 416   fDiamondProfile(rec.fDiamondProfile),
 417   fDiamondProfileTPC(rec.fDiamondProfileTPC),
 418   fListOfCosmicTriggers(NULL),
 419
 420   fGRPData(NULL),
 421
 422   fAlignObjArray(rec.fAlignObjArray),
 423   fCDBUri(rec.fCDBUri),
 424   fQARefUri(rec.fQARefUri),
 425   fSpecCDBUri(),
 426   fCheckRecoCDBvsSimuCDB(),
 427   fInitCDBCalled(rec.fInitCDBCalled),
 428   fCDBSnapshotMode(rec.fCDBSnapshotMode),
 429   fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
 430   fQADetectors(rec.fQADetectors),
 431   fQATasks(rec.fQATasks),
 432   fRunQA(rec.fRunQA),
 433   fRunGlobalQA(rec.fRunGlobalQA),
 434   fSameQACycle(rec.fSameQACycle),
 435   fInitQACalled(rec.fInitQACalled),
 436   fWriteQAExpertData(rec.fWriteQAExpertData),
 437   fRunPlaneEff(rec.fRunPlaneEff),
 438
 439   fESDpid(NULL),
 440
 441   fesd(NULL),
 442   fhltesd(NULL),
 443   fesdf(NULL),
 444   ffile(NULL),
 445   ffileF(NULL),
 446   ftree(NULL),
 447   ftreeF(NULL),
 448   fhlttree(NULL),
 449   ftVertexer(NULL),
 450   fIsNewRunLoader(rec.fIsNewRunLoader),
 451   fRunAliEVE(kFALSE),
 452   fChain(NULL),
 453   fNall(0),
 454   fNspecie(0),
 455   fSspecie(0),
 456   fNhighPt(0),
 457   fShighPt(0),
 458   //
 459   fTreeBuffSize(rec.fTreeBuffSize),
 460   fMemCountESD(0),
 461   fMemCountESDF(0),
 462   fMemCountESDHLT(0),
 463   //
 464   fUpgradeModule(""),
 465   fAnalysisMacro(rec.fAnalysisMacro),
 466   fAnalysis(0),
 467   fRecoHandler(0),
 468   fDeclTriggerClasses(rec.fDeclTriggerClasses),
 469   fStopped(kFALSE),
 470   fMaxRSS(0),
 471   fMaxVMEM(0)
 472 {
 473 // copy constructor
 474
 475   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
 476     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
 477   }
 478   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 479     fReconstructor[iDet] = NULL;
 480     fUpgradeMask[iDet] = kFALSE;
 481     fLoader[iDet] = NULL;
 482     fTracker[iDet] = NULL;
 483   }
 484
 485   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
 486     fQACycles[iDet] = rec.fQACycles[iDet];
 487     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
 488   }
 489
 490   for (Int_t i = 0; i < rec.fSpecCDBUri.GetEntriesFast(); i++) {
 491     if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
 492   }
 493
 494   for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
 495     if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
 496   }
 497
 498   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
 499
 500 }
 501
 502 //_____________________________________________________________________________
 503 AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
 504 {
 505 // assignment operator
 506 // Used in PROOF mode
 507 // Be very careful while modifing it!
 508 // Simple rules to follow:
 509 // for persistent data members - use their assignment operators
 510 // for non-persistent ones - do nothing or take the default values from constructor
 511 // TSelector members should not be touched
 512   if(&rec == this) return *this;
 513
 514   fRunVertexFinder       = rec.fRunVertexFinder;
 515   fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
 516   fRunMuonTracking       = rec.fRunMuonTracking;
 517   fRunMFTTrackingMU      = rec.fRunMFTTrackingMU;
 518   fRunV0Finder           = rec.fRunV0Finder;
 519   fRunCascadeFinder      = rec.fRunCascadeFinder;
 520   fRunMultFinder         = rec.fRunMultFinder;
 521   fStopOnError           = rec.fStopOnError;
 522   fStopOnMissingTriggerFile = rec.fStopOnMissingTriggerFile;
 523   fWriteAlignmentData    = rec.fWriteAlignmentData;
 524   fWriteESDfriend        = rec.fWriteESDfriend;
 525   fFillTriggerESD        = rec.fFillTriggerESD;
 526
 527   fCleanESD  = rec.fCleanESD;
 528   fV0DCAmax  = rec.fV0DCAmax;
 529   fV0CsPmin  = rec.fV0CsPmin;
 530   fDmax      = rec.fDmax;
 531   fZmax      = rec.fZmax;
 532
 533   fRunLocalReconstruction        = rec.fRunLocalReconstruction;
 534   fRunTracking                   = rec.fRunTracking;
 535   fFillESD                       = rec.fFillESD;
 536   fDeleteRecPoints               = rec.fDeleteRecPoints;
 537   fDeleteDigits                  = rec.fDeleteDigits;
 538   fLoadCDB                       = rec.fLoadCDB;
 539   fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
 540   fGAliceFileName                = rec.fGAliceFileName;
 541   fRawInput                      = rec.fRawInput;
 542   fESDOutput                     = rec.fESDOutput;
 543   fProofOutputFileName           = rec.fProofOutputFileName;
 544   fProofOutputLocation           = rec.fProofOutputLocation;
 545   fProofOutputDataset            = rec.fProofOutputDataset;
 546   fProofOutputArchive            = rec.fProofOutputArchive;
 547   fEquipIdMap                    = rec.fEquipIdMap;
 548   fFirstEvent                    = rec.fFirstEvent;
 549   fLastEvent                     = rec.fLastEvent;
 550   fNumberOfEventsPerFile         = rec.fNumberOfEventsPerFile;
 551   fFractionFriends               = rec.fFractionFriends;
 552
 553   for (Int_t i = 0; i < rec.fOptions.GetEntriesFast(); i++) {
 554     if (rec.fOptions[i]) fOptions.Add(rec.fOptions[i]->Clone());
 555   }
 556
 557   fLoadAlignFromCDB              = rec.fLoadAlignFromCDB;
 558   fLoadAlignData                 = rec.fLoadAlignData;
 559   fUseHLTData                    = rec.fUseHLTData;
 560
 561   delete fRunInfo; fRunInfo = NULL;
 562   if (rec.fRunInfo) fRunInfo = new AliRunInfo(*rec.fRunInfo);
 563
 564   fEventInfo                     = rec.fEventInfo;
 565
 566   delete fRunScalers; fRunScalers = NULL;
 567   if (rec.fRunScalers) fRunScalers = new AliTriggerRunScalers(*rec.fRunScalers);
 568
 569   delete fCTPTimeParams; fCTPTimeParams = NULL;
 570   if (rec.fCTPTimeParams) fCTPTimeParams = new AliCTPTimeParams(*rec.fCTPTimeParams);
 571   delete fCTPTimeAlign; fCTPTimeAlign = NULL;
 572   if (rec.fCTPTimeAlign) fCTPTimeAlign = new AliCTPTimeParams(*rec.fCTPTimeAlign);
 573
 574   fRunLoader       = NULL;
 575   fRawReader       = NULL;
 576   fParentRawReader = NULL;
 577
 578   fRecoParam = rec.fRecoParam;
 579
 580   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 581     fUpgradeMask[iDet] = kFALSE;
 582     delete fReconstructor[iDet]; fReconstructor[iDet] = NULL;
 583     delete fLoader[iDet]; fLoader[iDet] = NULL;
 584     delete fTracker[iDet]; fTracker[iDet] = NULL;
 585   }
 586
 587   for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
 588     fQACycles[iDet] = rec.fQACycles[iDet];
 589     fQAWriteExpert[iDet] = rec.fQAWriteExpert[iDet] ;
 590   }
 591
 592   delete fSPDTrackleter; fSPDTrackleter = NULL;
 593
 594   delete fDiamondProfileSPD; fDiamondProfileSPD = NULL;
 595   if (rec.fDiamondProfileSPD) fDiamondProfileSPD = new AliESDVertex(*rec.fDiamondProfileSPD);
 596   delete fDiamondProfile; fDiamondProfile = NULL;
 597   if (rec.fDiamondProfile) fDiamondProfile = new AliESDVertex(*rec.fDiamondProfile);
 598   delete fDiamondProfileTPC; fDiamondProfileTPC = NULL;
 599   if (rec.fDiamondProfileTPC) fDiamondProfileTPC = new AliESDVertex(*rec.fDiamondProfileTPC);
 600
 601   delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
 602   if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
 603
 604   delete fGRPData; fGRPData = NULL;
 605   //  if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
 606   if (rec.fGRPData) fGRPData = (AliGRPObject*)((rec.fGRPData)->Clone());
 607
 608   delete fAlignObjArray; fAlignObjArray = NULL;
 609
 610   fCDBUri        = "";
 611   fQARefUri      = rec.fQARefUri;
 612   fSpecCDBUri.Delete();
 613   fCheckRecoCDBvsSimuCDB.Delete();
 614   //
 615   for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
 616     if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
 617   }
 618   //
 619   fInitCDBCalled               = rec.fInitCDBCalled;
 620   fCDBSnapshotMode             = rec.fCDBSnapshotMode;
 621   fSetRunNumberFromDataCalled  = rec.fSetRunNumberFromDataCalled;
 622   fQADetectors                 = rec.fQADetectors;
 623   fQATasks                     = rec.fQATasks;
 624   fRunQA                       = rec.fRunQA;
 625   fRunGlobalQA                 = rec.fRunGlobalQA;
 626   fSameQACycle                 = rec.fSameQACycle;
 627   fInitQACalled                = rec.fInitQACalled;
 628   fWriteQAExpertData           = rec.fWriteQAExpertData;
 629   fRunPlaneEff                 = rec.fRunPlaneEff;
 630   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
 631   fESDpid  = NULL;
 632   fesd     = NULL;
 633   fhltesd  = NULL;
 634   fesdf    = NULL;
 635   ffile    = NULL;
 636   ffileF   = NULL;
 637   ftree    = NULL;
 638   ftreeF   = NULL;
 639   fhlttree = NULL;
 640   ftVertexer = NULL;
 641   fIsNewRunLoader = rec.fIsNewRunLoader;
 642   fRunAliEVE = kFALSE;
 643   fChain = NULL;
 644   fNall = 0;
 645   fNspecie = 0;
 646   fSspecie = 0;
 647   fNhighPt = 0;
 648   fShighPt = 0;
 649   //
 650   fTreeBuffSize = rec.fTreeBuffSize;
 651   fMemCountESD = 0;
 652   fMemCountESDF = 0;
 653   fMemCountESDHLT = 0;
 654   //
 655   fUpgradeModule="";
 656   fAnalysisMacro = rec.fAnalysisMacro;
 657   fAnalysis = 0;
 658   fRecoHandler = 0;
 659   fDeclTriggerClasses = rec.fDeclTriggerClasses;
 660
 661   return *this;
 662 }
 663
 664 //_____________________________________________________________________________
 665 AliReconstruction::~AliReconstruction()
 666 {
 667 // clean up
 668
 669   CleanUp();
 670   if (fListOfCosmicTriggers) {
 671     fListOfCosmicTriggers->Delete();
 672     delete fListOfCosmicTriggers;
 673   }
 674   delete fGRPData;
 675   delete fRunScalers;
 676   delete fCTPTimeParams;
 677   delete fCTPTimeAlign;
 678   fOptions.Delete();
 679   if (fAlignObjArray) {
 680     fAlignObjArray->Delete();
 681     delete fAlignObjArray;
 682   }
 683   fSpecCDBUri.Delete();
 684   fCheckRecoCDBvsSimuCDB.Delete();
 685   AliCodeTimer::Instance()->Print();
 686 }
 687
 688 //_____________________________________________________________________________
 689 void AliReconstruction::InitQA()
 690 {
 691   //Initialize the QA and start of cycle
 692   AliCodeTimerAuto("",0);
 693
 694   if (fInitQACalled) return;
 695   fInitQACalled = kTRUE;
 696
 697   if (fGRPData) AliQADataMaker::SetCloningRequest( fGRPData->GetQATrigClasses(), fGRPData->GetQACloningRequest());
 698
 699
 700   AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
 701   qam->SetSaveData(kTRUE);
 702   qam->SetCycleLength(AliQAv1::kITS, 5) ;
 703   if (fWriteQAExpertData)
 704     qam->SetWriteExpert() ;
 705
 706   if (qam->IsDefaultStorageSet()) {
 707     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 708     AliWarning("Default QA reference storage has been already set !");
 709     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fQARefUri.Data()));
 710     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 711     fQARefUri = qam->GetDefaultStorage()->GetURI();
 712   } else {
 713     if (fQARefUri.Length() > 0) {
 714         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 715         AliDebug(2, Form("Default QA reference storage is set to: %s", fQARefUri.Data()));
 716         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 717       } else {
 718         fQARefUri="local://$ALICE_ROOT/QAref";
 719         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 720         AliWarning("Default QA refeference storage not yet set !!!!");
 721         AliWarning(Form("Setting it now to: %s", fQARefUri.Data()));
 722         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 723
 724       }
 725     qam->SetDefaultStorage(fQARefUri);
 726   }
 727
 728   if (fRunQA) {
 729   qam->SetActiveDetectors(fQADetectors) ;
 730   qam->SetActiveOnlineDetectors(fRunInfo->GetActiveDetectors());
 731
 732   for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
 733     qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;
 734     qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
 735   }
 736   if (!fRawReader && !fInput && IsInTasks(AliQAv1::kRAWS))
 737     fQATasks.ReplaceAll(Form("%d",AliQAv1::kRAWS), "") ;
 738   qam->SetTasks(fQATasks) ;
 739   qam->InitQADataMaker(AliCDBManager::Instance()->GetRun()) ;
 740   }
 741   if (fRunGlobalQA) {
 742     Bool_t sameCycle = kFALSE ;
 743     AliQADataMaker *qadm = qam->GetQADataMaker(AliQAv1::kGLOBAL);
 744     AliInfo(Form("Initializing the global QA data maker"));
 745     if (IsInTasks(AliQAv1::kRECPOINTS)) {
 746       qadm->StartOfCycle(AliQAv1::kRECPOINTS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
 747       TObjArray **arr=qadm->Init(AliQAv1::kRECPOINTS);
 748       AliTracker::SetResidualsArray(arr);
 749       sameCycle = kTRUE ;
 750     }
 751     if (IsInTasks(AliQAv1::kESDS)) {
 752       qadm->StartOfCycle(AliQAv1::kESDS, AliCDBManager::Instance()->GetRun(), sameCycle) ;
 753       qadm->Init(AliQAv1::kESDS);
 754     }
 755   }
 756     AliSysInfo::AddStamp("InitQA") ;
 757 }
 758
 759 //_____________________________________________________________________________
 760 void AliReconstruction::MergeQA(const char *fileName)
 761 {
 762   //Initialize the QA and start of cycle
 763   AliCodeTimerAuto("",0) ;
 764   AliQAManager::QAManager()->Merge(AliCDBManager::Instance()->GetRun(),fileName) ;
 765   AliSysInfo::AddStamp("MergeQA") ;
 766 }
 767
 768 //_____________________________________________________________________________
 769 void AliReconstruction::InitCDB()
 770 {
 771 // activate a default CDB storage
 772 // First check if we have any CDB storage set, because it is used
 773 // to retrieve the calibration and alignment constants
 774   AliCodeTimerAuto("",0);
 775
 776   if (fInitCDBCalled) return;
 777   fInitCDBCalled = kTRUE;
 778
 779   AliCDBManager* man = AliCDBManager::Instance();
 780   if (man->IsDefaultStorageSet())
 781   {
 782     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 783     AliWarning("Default CDB storage has been already set !");
 784     AliWarning(Form("Ignoring the default storage declared in AliReconstruction: %s",fCDBUri.Data()));
 785     AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 786     fCDBUri = man->GetDefaultStorage()->GetURI();
 787   }
 788   else {
 789     if (fCDBUri.Length() > 0)
 790     {
 791         AliDebug(2,"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 792         AliDebug(2, Form("Default CDB storage is set to: %s", fCDBUri.Data()));
 793         AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 794         man->SetDefaultStorage(fCDBUri);
 795     }
 796     else if (!man->GetRaw()){
 797         fCDBUri="local://$ALICE_ROOT/OCDB";
 798         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 799         AliWarning("Default CDB storage not yet set !!!!");
 800         AliWarning(Form("Setting it now to: %s", fCDBUri.Data()));
 801         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 802         man->SetDefaultStorage(fCDBUri);
 803     }
 804     else {
 805         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 806         AliWarning("Default storage will be set after setting the Run Number!!!");
 807         AliWarning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 808     }
 809   }
 810
 811   // Now activate the detector specific CDB storage locations
 812   for (Int_t i = 0; i < fSpecCDBUri.GetEntriesFast(); i++) {
 813     TObject* obj = fSpecCDBUri[i];
 814     if (!obj) continue;
 815     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 816     AliDebug(2, Form("Specific CDB storage for %s is set to: %s",obj->GetName(),obj->GetTitle()));
 817     AliDebug(2, "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
 818     man->SetSpecificStorage(obj->GetName(), obj->GetTitle());
 819   }
 820   AliSysInfo::AddStamp("InitCDB");
 821 }
 822
 823 //_____________________________________________________________________________
 824 void AliReconstruction::SetCDBSnapshotMode(const char* snapshotFileName) {
 825     fCDBSnapshotMode = kTRUE;
 826     AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName);
 827 }
 828
 829 //_____________________________________________________________________________
 830 void AliReconstruction::SetDefaultStorage(const char* uri) {
 831 // Store the desired default CDB storage location
 832 // Activate it later within the Run() method
 833
 834   fCDBUri = uri;
 835
 836 }
 837
 838 //_____________________________________________________________________________
 839 void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
 840   // Store the desired default CDB storage location
 841   // Activate it later within the Run() method
 842
 843   fQARefUri = uri;
 844   AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
 845
 846 }
 847
 848 //_____________________________________________________________________________
 849 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
 850 // Store a detector-specific CDB storage location
 851 // Activate it later within the Run() method
 852
 853   AliCDBPath aPath(calibType);
 854   if(!aPath.IsValid()){
 855         // if calibType is not wildcard but it is a valid detector, add "/*" to make it a valid path
 856         for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 857                 if(!strcmp(calibType, fgkDetectorName[iDet])) {
 858                         aPath.SetPath(Form("%s/*", calibType));
 859                         AliInfo(Form("Path for specific storage set to %s", aPath.GetPath().Data()));
 860                         break;
 861                 }
 862         }
 863         if(!aPath.IsValid()){
 864                 AliError(Form("Not a valid path or detector: %s", calibType));
 865                 return;
 866         }
 867   }
 868
 869 //  // check that calibType refers to a "valid" detector name
 870 //  Bool_t isDetector = kFALSE;
 871 //  for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
 872 //    TString detName = fgkDetectorName[iDet];
 873 //    if(aPath.GetLevel0() == detName) {
 874 //      isDetector = kTRUE;
 875 //      break;
 876 //    }
 877 //  }
 878 //
 879 //  if(!isDetector) {
 880 //      AliError(Form("Not a valid detector: %s", aPath.GetLevel0().Data()));
 881 //      return;
 882 //  }
 883
 884   TObject* obj = fSpecCDBUri.FindObject(aPath.GetPath().Data());
 885   if (obj) fSpecCDBUri.Remove(obj);
 886   fSpecCDBUri.Add(new TNamed(aPath.GetPath().Data(), uri));
 887
 888 }
 889
 890 //_____________________________________________________________________________
 891 void AliReconstruction::AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment)
 892 {
 893   // require the cdb item to be the same in the rec as in the sim
 894   // Activate it later within the Run() method
 895   TString newent = cdbpath;
 896   if (newent.IsNull()) return;
 897   TIter nextit(&fCheckRecoCDBvsSimuCDB);
 898   TNamed* cdbent=0;
 899   while ((cdbent=(TNamed*)nextit())) {
 900     TString str = cdbent->GetName();
 901     if (str==newent) {
 902       AliInfo(Form("%s is already in the list to check",cdbpath));
 903       return;
 904     }
 905   }
 906   fCheckRecoCDBvsSimuCDB.AddLast(new TNamed(cdbpath,comment));
 907   //
 908 }
 909
 910 //_____________________________________________________________________________
 911 void AliReconstruction::RemCheckRecoCDBvsSimuCDB(const char* cdbpath)
 912 {
 913   // require the cdb item to be the same in the rec as in the sim
 914   // Activate it later within the Run() method
 915   TString newent = cdbpath;
 916   if (newent.IsNull()) return;
 917   TIter nextit(&fCheckRecoCDBvsSimuCDB);
 918   TNamed* cdbent=0;
 919   while ((cdbent=(TNamed*)nextit())) {
 920     TString str = cdbent->GetName();
 921     if (str==newent) {
 922       AliInfo(Form("Removing %s from the list to check",cdbpath));
 923       delete fCheckRecoCDBvsSimuCDB.Remove(cdbent);
 924       fCheckRecoCDBvsSimuCDB.Compress();
 925       return;
 926     }
 927   }
 928   AliInfo(Form("%s is not in the list to check",cdbpath));
 929   //
 930 }
 931
 932 //_____________________________________________________________________________
 933 Bool_t AliReconstruction::SetRunNumberFromData()
 934 {
 935   // The method is called in Run() in order
 936   // to set a correct run number.
 937   // In case of raw data reconstruction the
 938   // run number is taken from the raw data header
 939
 940   if (fSetRunNumberFromDataCalled) return kTRUE;
 941   fSetRunNumberFromDataCalled = kTRUE;
 942
 943   AliCDBManager* man = AliCDBManager::Instance();
 944
 945   if(fRawReader) {
 946     if(fRawReader->NextEvent()) {
 947       if(man->GetRun() > 0) {
 948         AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
 949       }
 950       man->SetRun(fRawReader->GetRunNumber());
 951       GetEventInfo();
 952       fRawReader->RewindEvents();
 953     }
 954     else {
 955       if(man->GetRun() > 0) {
 956         AliWarning("No raw-data events are found ! Using settings in AliCDBManager !");
 957       }
 958       else {
 959         AliWarning("Neither raw events nor settings in AliCDBManager are found !");
 960         return kFALSE;
 961       }
 962     }
 963   }
 964   else {
 965     AliRunLoader *rl = AliRunLoader::Open(fGAliceFileName.Data());
 966     if (!rl) {
 967       AliError(Form("No run loader found in file %s", fGAliceFileName.Data()));
 968       return kFALSE;
 969     }
 970     else {
 971       rl->LoadHeader();
 972       // read run number from gAlice
 973       if(rl->GetHeader()) {
 974         man->SetRun(rl->GetHeader()->GetRun());
 975         rl->UnloadHeader();
 976         delete rl;
 977       }
 978       else {
 979         AliError("Neither run-loader header nor RawReader objects are found !");
 980         delete rl;
 981         return kFALSE;
 982       }
 983     }
 984   }
 985
 986   man->Print();
 987
 988   return kTRUE;
 989 }
 990
 991 //_____________________________________________________________________________
 992 void AliReconstruction::SetCDBLock() {
 993   // Set CDB lock: from now on it is forbidden to reset the run number
 994   // or the default storage or to activate any further storage!
 995
 996   AliCDBManager::Instance()->SetLock(1);
 997 }
 998
 999 //_____________________________________________________________________________
1000 void AliReconstruction::MatchUpgradeDetector() {
1001   // Translates detector name in a boolean.
1002   // The boolean is used in GetReconstructor to load the
1003   // upgrade reconstructor instead of the standard one.
1004    for(Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1005     if(fUpgradeModule.Contains(fgkDetectorName[iDet])) fUpgradeMask[iDet]=kTRUE;
1006    }
1007 }
1008 //_____________________________________________________________________________
1009 Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
1010 {
1011   // Read the alignment objects from CDB.
1012   // Each detector is supposed to have the
1013   // alignment objects in DET/Align/Data CDB path.
1014   // All the detector objects are then collected,
1015   // sorted by geometry level (starting from ALIC) and
1016   // then applied to the TGeo geometry.
1017   // Finally an overlaps check is performed.
1018
1019   // Load alignment data from CDB and fill fAlignObjArray
1020   if(fLoadAlignFromCDB){
1021
1022     TString detStr = detectors;
1023     TString loadAlObjsListOfDets = "";
1024
1025     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1026       if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1027       if(!strcmp(fgkDetectorName[iDet],"HLT")) continue;
1028
1029       if(AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
1030       {
1031         loadAlObjsListOfDets += fgkDetectorName[iDet];
1032         loadAlObjsListOfDets += " ";
1033       }
1034     } // end loop over detectors
1035
1036     if(AliGeomManager::GetNalignable("GRP") != 0)
1037       loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
1038     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
1039   }else{
1040     // Check if the array with alignment objects was
1041     // provided by the user. If yes, apply the objects
1042     // to the present TGeo geometry
1043     if (fAlignObjArray) {
1044       if (gGeoManager && gGeoManager->IsClosed()) {
1045         if (AliGeomManager::ApplyAlignObjsToGeom(*fAlignObjArray) == kFALSE) {
1046           AliError("The misalignment of one or more volumes failed!"
1047                    "Compare the list of simulated detectors and the list of detector alignment data!");
1048           return kFALSE;
1049         }
1050       }
1051       else {
1052         AliError("Can't apply the misalignment! gGeoManager doesn't exist or it is still opened!");
1053         return kFALSE;
1054       }
1055     }
1056   }
1057
1058   if (fAlignObjArray) {
1059     fAlignObjArray->Delete();
1060     delete fAlignObjArray; fAlignObjArray=NULL;
1061   }
1062
1063   return kTRUE;
1064 }
1065
1066 //_____________________________________________________________________________
1067 void AliReconstruction::SetGAliceFile(const char* fileName)
1068 {
1069 // set the name of the galice file
1070
1071   fGAliceFileName = fileName;
1072 }
1073
1074 //_____________________________________________________________________________
1075 void AliReconstruction::SetInput(const char* input)
1076 {
1077   // In case the input string starts with 'mem://', we run in an online mode
1078   // and AliRawReaderDateOnline object is created. In all other cases a raw-data
1079   // file is assumed. One can give as an input:
1080   // mem://: - events taken from DAQ monitoring libs online
1081   //  or
1082   // mem://<filename> - emulation of the above mode (via DATE monitoring libs)
1083   if (input) fRawInput = input;
1084 }
1085
1086 //_____________________________________________________________________________
1087 void AliReconstruction::SetOutput(const char* output)
1088 {
1089   // Set the output ESD filename
1090   // 'output' is a normalt ROOT url
1091   // The method is used in case of raw-data reco with PROOF
1092   if (output) fESDOutput = output;
1093 }
1094
1095 //_____________________________________________________________________________
1096 void AliReconstruction::SetOption(const char* detector, const char* option)
1097 {
1098 // set options for the reconstruction of a detector
1099
1100   TObject* obj = fOptions.FindObject(detector);
1101   if (obj) fOptions.Remove(obj);
1102   fOptions.Add(new TNamed(detector, option));
1103 }
1104
1105 //_____________________________________________________________________________
1106 void AliReconstruction::SetRecoParam(const char* detector, AliDetectorRecoParam *par)
1107 {
1108   // Set custom reconstruction parameters for a given detector
1109   // Single set of parameters for all the events
1110
1111   // First check if the reco-params are global
1112   if(!strcmp(detector, "GRP")) {
1113     par->SetAsDefault();
1114     fRecoParam.AddDetRecoParam(kNDetectors,par);
1115     return;
1116   }
1117
1118   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1119     if(!strcmp(detector, fgkDetectorName[iDet])) {
1120       par->SetAsDefault();
1121       fRecoParam.AddDetRecoParam(iDet,par);
1122       break;
1123     }
1124   }
1125
1126 }
1127
1128 //_____________________________________________________________________________
1129 Bool_t AliReconstruction::InitGRP() {
1130   //------------------------------------
1131   // Initialization of the GRP entry
1132   //------------------------------------
1133   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data");
1134
1135   if (entry) {
1136
1137     TMap* m = dynamic_cast<TMap*>(entry->GetObject());  // old GRP entry
1138
1139     if (m) {
1140        AliInfo("Found a TMap in GRP/GRP/Data, converting it into an AliGRPObject");
1141        m->Print();
1142        fGRPData = new AliGRPObject();
1143        fGRPData->ReadValuesFromMap(m);
1144     }
1145
1146     else {
1147        AliInfo("Found an AliGRPObject in GRP/GRP/Data, reading it");
1148        fGRPData = dynamic_cast<AliGRPObject*>(entry->GetObject());  // new GRP entry
1149        entry->SetOwner(0);
1150     }
1151
1152     //    FIX ME: The unloading of GRP entry is temporarily disabled
1153     //    because ZDC and VZERO are using it in order to initialize
1154     //    their reconstructor objects. In the future one has to think
1155     //    of propagating AliRunInfo to the reconstructors.
1156     //    AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
1157   }
1158
1159   if (!fGRPData) {
1160      AliError("No GRP entry found in OCDB!");
1161      return kFALSE;
1162   }
1163
1164   TString lhcState = fGRPData->GetLHCState();
1165   if (lhcState==AliGRPObject::GetInvalidString()) {
1166     AliError("GRP/GRP/Data entry:  missing value for the LHC state ! Using UNKNOWN");
1167     lhcState = "UNKNOWN";
1168   }
1169
1170   TString beamType = fGRPData->GetBeamType();
1171   if (beamType==AliGRPObject::GetInvalidString()) {
1172     AliError("GRP/GRP/Data entry:  missing value for the beam type ! Using UNKNOWN");
1173     beamType = "UNKNOWN";
1174   }
1175
1176   Float_t beamEnergy = fGRPData->GetBeamEnergy();
1177   if (beamEnergy==AliGRPObject::GetInvalidFloat()) {
1178     AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
1179     beamEnergy = 0;
1180   }
1181
1182   TString runType = fGRPData->GetRunType();
1183   if (runType==AliGRPObject::GetInvalidString()) {
1184     AliError("GRP/GRP/Data entry:  missing value for the run type ! Using UNKNOWN");
1185     runType = "UNKNOWN";
1186   }
1187
1188   Int_t activeDetectors = fGRPData->GetDetectorMask();
1189   if (activeDetectors==AliGRPObject::GetInvalidUInt()) {
1190     AliError("GRP/GRP/Data entry:  missing value for the detector mask ! Using 1074790399");
1191     activeDetectors = 1074790399;
1192   }
1193   AliDebug(1, Form("activeDetectors = %d", activeDetectors));
1194
1195   fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
1196   fRunInfo->Dump();
1197
1198
1199   // Process the list of active detectors
1200   if (activeDetectors) {
1201     UInt_t detMask = activeDetectors;
1202     AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1203     fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
1204     AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
1205     fRunTracking = MatchDetectorList(fRunTracking,detMask);
1206     fFillESD = MatchDetectorList(fFillESD,detMask);
1207     fQADetectors = MatchDetectorList(fQADetectors,detMask);
1208     AliInfo(Form("fQADetectors=%s",fQADetectors.Data()));
1209     fDeleteRecPoints = MatchDetectorList(fDeleteRecPoints,detMask);
1210     fDeleteDigits    = MatchDetectorList(fDeleteDigits,detMask);
1211     fLoadCDB.Form("%s %s %s %s",
1212                   fRunLocalReconstruction.Data(),
1213                   fRunTracking.Data(),
1214                   fFillESD.Data(),
1215                   fQADetectors.Data());
1216     fLoadCDB = MatchDetectorList(fLoadCDB,detMask);
1217     if (!((detMask >> AliDAQ::DetectorID("ITSSPD")) & 0x1) &&
1218         !((detMask >> AliDAQ::DetectorID("ITSSDD")) & 0x1) &&
1219         !((detMask >> AliDAQ::DetectorID("ITSSSD")) & 0x1) ) {
1220       // switch off the vertexer
1221       AliInfo("SPD,SDD,SSD is not in the list of active detectors. Vertexer and Trackleter are switched off.");
1222       fRunVertexFinder = kFALSE;
1223       fRunMultFinder = kFALSE;
1224     }
1225     if (!((detMask >> AliDAQ::DetectorID("TRG")) & 0x1)) {
1226       // switch off the reading of CTP raw-data payload
1227       if (fFillTriggerESD) {
1228         AliInfo("CTP is not in the list of active detectors. CTP data reading switched off.");
1229         fFillTriggerESD = kFALSE;
1230       }
1231     }
1232   }
1233
1234   AliInfo("===================================================================================");
1235   AliInfo(Form("Running local reconstruction for detectors: %s",fRunLocalReconstruction.Data()));
1236   AliInfo(Form("Running tracking for detectors: %s",fRunTracking.Data()));
1237   AliInfo(Form("Filling ESD for detectors: %s",fFillESD.Data()));
1238   AliInfo(Form("Quality assurance is active for detectors: %s",fQADetectors.Data()));
1239   AliInfo(Form("CDB and reconstruction parameters are loaded for detectors: %s",fLoadCDB.Data()));
1240   AliInfo("===================================================================================");
1241
1242   //*** Dealing with the magnetic field map
1243   if ( TGeoGlobalMagField::Instance()->IsLocked() ) {
1244     if (TGeoGlobalMagField::Instance()->GetField()->TestBit(AliMagF::kOverrideGRP)) {
1245       AliInfo("ExpertMode!!! GRP information will be ignored !");
1246       AliInfo("ExpertMode!!! Running with the externally locked B field !");
1247     }
1248     else {
1249       AliInfo("Destroying existing B field instance!");
1250       delete TGeoGlobalMagField::Instance();
1251     }
1252   }
1253   if ( !TGeoGlobalMagField::Instance()->IsLocked() ) {
1254     // Construct the field map out of the information retrieved from GRP.
1255     Bool_t ok = kTRUE;
1256     // L3
1257     Float_t l3Current = fGRPData->GetL3Current((AliGRPObject::Stats)0);
1258     if (l3Current == AliGRPObject::GetInvalidFloat()) {
1259       AliError("GRP/GRP/Data entry:  missing value for the L3 current !");
1260       ok = kFALSE;
1261     }
1262
1263     Char_t l3Polarity = fGRPData->GetL3Polarity();
1264     if (l3Polarity == AliGRPObject::GetInvalidChar()) {
1265       AliError("GRP/GRP/Data entry:  missing value for the L3 polarity !");
1266       ok = kFALSE;
1267     }
1268
1269     // Dipole
1270     Float_t diCurrent = fGRPData->GetDipoleCurrent((AliGRPObject::Stats)0);
1271     if (diCurrent == AliGRPObject::GetInvalidFloat()) {
1272       AliError("GRP/GRP/Data entry:  missing value for the dipole current !");
1273       ok = kFALSE;
1274     }
1275
1276     Char_t diPolarity = fGRPData->GetDipolePolarity();
1277     if (diPolarity == AliGRPObject::GetInvalidChar()) {
1278       AliError("GRP/GRP/Data entry:  missing value for the dipole polarity !");
1279       ok = kFALSE;
1280     }
1281
1282     // read special bits for the polarity convention and map type
1283     Int_t  polConvention = fGRPData->IsPolarityConventionLHC() ? AliMagF::kConvLHC : AliMagF::kConvDCS2008;
1284     Bool_t uniformB = fGRPData->IsUniformBMap();
1285
1286     if (ok) {
1287       AliMagF* fld = AliMagF::CreateFieldMap(TMath::Abs(l3Current) * (l3Polarity ? -1:1),
1288                                              TMath::Abs(diCurrent) * (diPolarity ? -1:1),
1289                                              polConvention,uniformB,beamEnergy, beamType.Data());
1290       if (fld) {
1291         TGeoGlobalMagField::Instance()->SetField( fld );
1292         TGeoGlobalMagField::Instance()->Lock();
1293         AliInfo("Running with the B field constructed out of GRP !");
1294       }
1295       else AliFatal("Failed to create a B field map !");
1296     }
1297     else AliFatal("B field is neither set nor constructed from GRP ! Exitig...");
1298   }
1299
1300   //*** Get the diamond profiles from OCDB
1301   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexSPD");
1302   if (entry) {
1303     fDiamondProfileSPD = dynamic_cast<AliESDVertex*> (entry->GetObject());
1304   } else {
1305      AliError("No SPD diamond profile found in OCDB!");
1306   }
1307
1308   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertex");
1309   if (entry) {
1310     fDiamondProfile = dynamic_cast<AliESDVertex*> (entry->GetObject());
1311   } else {
1312      AliError("No diamond profile found in OCDB!");
1313   }
1314
1315   entry = AliCDBManager::Instance()->Get("GRP/Calib/MeanVertexTPC");
1316   if (entry) {
1317     fDiamondProfileTPC = dynamic_cast<AliESDVertex*> (entry->GetObject());
1318   } else {
1319      AliError("No TPC diamond profile found in OCDB!");
1320   }
1321
1322   entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
1323   if (entry) {
1324     fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
1325     entry->SetOwner(0);
1326   }
1327
1328   if (!fListOfCosmicTriggers) {
1329     AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
1330   }
1331
1332   return kTRUE;
1333 }
1334
1335 //_____________________________________________________________________________
1336 Bool_t AliReconstruction::LoadCDB()
1337 {
1338   // Load CDB entries for all active detectors.
1339   // By default we load all the entries in <det>/Calib
1340   // folder.
1341
1342   AliCodeTimerAuto("",0);
1343
1344   AliCDBManager::Instance()->Get("GRP/CTP/Config");
1345
1346   AliCDBManager::Instance()->Get("GRP/Calib/LHCClockPhase");
1347
1348   TString detStr = fLoadCDB;
1349   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1350     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1351     AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
1352     AliCDBManager::Instance()->GetAll(Form("%s/Trigger/*",fgkDetectorName[iDet]));
1353   }
1354
1355   // Temporary fix - one has to define the correct policy in order
1356   // to load the trigger OCDB entries only for the detectors that
1357   // in the trigger or that are needed in order to put correct
1358   // information in ESD
1359   AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
1360   AliCDBManager::Instance()->GetAll("HLT/*/*");
1361
1362   return kTRUE;
1363 }
1364 //_____________________________________________________________________________
1365 Bool_t AliReconstruction::LoadTriggerScalersCDB()
1366 {
1367   // Load CTP scalers from OCDB.
1368   // The scalers are checked for consistency.
1369
1370   AliCodeTimerAuto("",0);
1371
1372   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/Scalers");
1373
1374   if (entry) {
1375
1376        AliInfo("Found an AliTriggerRunScalers in GRP/CTP/Scalers, reading it");
1377        fRunScalers = dynamic_cast<AliTriggerRunScalers*> (entry->GetObject());
1378        entry->SetOwner(0);
1379        if (fRunScalers && (fRunScalers->CorrectScalersOverflow() == 0)) AliInfo("32bit Trigger counters corrected for overflow");
1380
1381   }
1382   return kTRUE;
1383 }
1384 //_____________________________________________________________________________
1385 Bool_t AliReconstruction::LoadCTPTimeParamsCDB()
1386 {
1387   // Load CTP timing information (alignment)
1388   // from OCDB.
1389
1390   AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/CTP/CTPtiming");
1391   if (!entry) return kFALSE;
1392
1393   AliInfo("Found an AliCTPTimeParams in GRP/CTP/CTPtiming, reading it");
1394   fCTPTimeParams = dynamic_cast<AliCTPTimeParams*> (entry->GetObject());
1395   entry->SetOwner(0);
1396
1397   AliCDBEntry* entry2 = AliCDBManager::Instance()->Get("GRP/CTP/TimeAlign");
1398   if (!entry2) return kFALSE;
1399
1400   AliInfo("Found an AliCTPTimeParams in GRP/CTP/TimeAlign, reading it");
1401   fCTPTimeAlign = dynamic_cast<AliCTPTimeParams*> (entry2->GetObject());
1402   entry2->SetOwner(0);
1403
1404   return kTRUE;
1405 }
1406
1407 //_____________________________________________________________________________
1408 Bool_t AliReconstruction::ReadIntensityInfoCDB()
1409 {
1410   // Load LHC DIP data
1411   AliCDBEntry* entry    = AliCDBManager::Instance()->Get("GRP/GRP/LHCData");
1412   AliCDBEntry* entryCTP = AliCDBManager::Instance()->Get("GRP/CTP/Config");
1413   //
1414   if (!entry || !entryCTP) {
1415     AliError(Form("Failed to extract CDB objects GRP/GRP/LHCData: %p or GRP/CTP/Config: %p",entry,entryCTP));
1416     return kFALSE;
1417   }
1418   // extract BC masks
1419   enum {kA,kB,kC,kE,kNMasks};
1420   AliTriggerConfiguration* conf = (AliTriggerConfiguration*)entryCTP->GetObject();
1421   const TObjArray& clArr = conf->GetClasses();
1422   TObjArray masks(kNMasks);
1423   TIter next(&clArr);
1424   AliTriggerClass* trClass = 0;
1425   int nFound = 0;
1426   masks.SetOwner(kFALSE);
1427   //
1428   while ( (trClass=(AliTriggerClass*)next()) ) {
1429     TString trName = trClass->GetName();
1430     int ind = trName.Index("-"); // prefix in front of A,B,C,E
1431     if (ind<1) continue;   // anomaly
1432     //
1433     trName = trName.Data() + ind;
1434     AliTriggerBCMask* bcMask = trClass->GetBCMask();
1435     if (!bcMask) continue;
1436     UInt_t which = 0;
1437     if      (trName.BeginsWith("-A-"))  which |= 0x1<<kA;
1438     else if (trName.BeginsWith("-B-"))  which |= 0x1<<kB;
1439     else if (trName.BeginsWith("-C-"))  which |= 0x1<<kC;
1440     else if (trName.BeginsWith("-E-"))  which |= 0x1<<kE;
1441     else if (trName.BeginsWith("-AC-")) which |= (0x1<<kA) | (0x1<<kC);
1442     else if (trName.BeginsWith("-CA-")) which |= (0x1<<kA) | (0x1<<kC);
1443     else { AliWarning(Form("Unknown trigger type %s\n",trClass->GetName())); continue;}
1444     //
1445     for (int ip=kNMasks;ip--;) {
1446       if ( !(which&(0x1<<ip)) || masks[ip] ) continue; // does not match or already done
1447       masks[ip] = (TObject*)bcMask;
1448       nFound++;
1449     }
1450     if (nFound==kNMasks) break;
1451   }
1452   //
1453   AliInfo("Reading mean bunch intensities from GRP/GRP/LHCData");
1454   AliLHCData* dipData = dynamic_cast<AliLHCData*> (entry->GetObject());
1455   //
1456   for (int ib=2;ib--;) {
1457     double intI,intNI;
1458     if (dipData && (dipData->GetMeanIntensity(ib,intI,intNI,&masks)>=0)) {
1459       fBeamInt[ib][0] = intI;
1460       fBeamInt[ib][1] = intNI;
1461       AliInfo(Form("Mean intensity for beam %d: Interacting:%.2e Non-Interacting:%.2e",ib,intI,intNI));
1462     }
1463   }
1464   return kTRUE;
1465   //
1466 }
1467
1468
1469 //_____________________________________________________________________________
1470 Bool_t AliReconstruction::Run(const char* input)
1471 {
1472   // Run Run Run
1473   AliCodeTimerAuto("",0);
1474
1475   InitRun(input);
1476   if (GetAbort() != TSelector::kContinue) return kFALSE;
1477
1478   TChain *chain = NULL;
1479   if (fRawReader && (chain = fRawReader->GetChain())) {
1480     Long64_t nEntries = (fLastEvent < 0) ? (TChain::kBigNumber) : (fLastEvent - fFirstEvent + 1);
1481     // Proof mode
1482     if (gProof) {
1483       // Temporary fix for long raw-data runs (until socket timeout handling in PROOF is revised)
1484       gProof->Exec("gEnv->SetValue(\"Proof.SocketActivityTimeout\",-1)", kTRUE);
1485
1486       if (gGrid)
1487         gProof->Exec("TGrid::Connect(\"alien://\")",kTRUE);
1488
1489       TMessage::EnableSchemaEvolutionForAll(kTRUE);
1490       gProof->Exec("TMessage::EnableSchemaEvolutionForAll(kTRUE)",kTRUE);
1491
1492       gProof->AddInput(this);
1493
1494       if (!ParseOutput()) return kFALSE;
1495
1496       gProof->SetParameter("PROOF_MaxSlavesPerNode", 9999);
1497       chain->SetProof();
1498       chain->Process("AliReconstruction","",nEntries,fFirstEvent);
1499     }
1500     else {
1501       chain->Process(this,"",nEntries,fFirstEvent);
1502     }
1503   }
1504   else {
1505     Begin(NULL);
1506     if (GetAbort() != TSelector::kContinue) return kFALSE;
1507     SlaveBegin(NULL);
1508     if (GetAbort() != TSelector::kContinue) return kFALSE;
1509     //******* The loop over events
1510     AliInfo("Starting looping over events");
1511     Int_t iEvent = 0;
1512     while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
1513            (fRawReader && fRawReader->NextEvent())) {
1514       //
1515       // check if process has enough resources
1516       if (!HasEnoughResources(iEvent)) break;
1517       if (!ProcessEvent(iEvent)) {
1518         Abort("ProcessEvent",TSelector::kAbortFile);
1519         return kFALSE;
1520       }
1521       CleanProcessedEvent();
1522       iEvent++;
1523     }
1524     if (!iEvent) AliWarning("No events passed trigger selection");
1525     SlaveTerminate();
1526     if (GetAbort() != TSelector::kContinue) return kFALSE;
1527     Terminate();
1528     if (GetAbort() != TSelector::kContinue) return kFALSE;
1529   }
1530
1531   return kTRUE;
1532 }
1533
1534 //_____________________________________________________________________________
1535 void AliReconstruction::InitRawReader(const char* input)
1536 {
1537   // Init raw-reader and
1538   // set the input in case of raw data
1539
1540   AliCodeTimerAuto("",0);
1541
1542   if (input) fRawInput = input;
1543   fRawReader = AliRawReader::Create(fRawInput.Data());
1544   if (!fRawReader) {
1545     if (fRawInput.IsNull()) {
1546       AliInfo("Reconstruction will run over digits");
1547     }
1548     else {
1549       AliFatal("Can not create raw-data reader ! Exiting...");
1550     }
1551   }
1552
1553   if (!fEquipIdMap.IsNull() && fRawReader)
1554     fRawReader->LoadEquipmentIdsMap(fEquipIdMap);
1555
1556   if (!fUseHLTData.IsNull()) {
1557     // create the RawReaderHLT which performs redirection of HLT input data for
1558     // the specified detectors
1559     AliRawReader* pRawReader=AliRawHLTManager::CreateRawReaderHLT(fRawReader, fUseHLTData.Data());
1560     if (pRawReader) {
1561       fParentRawReader=fRawReader;
1562       fRawReader=pRawReader;
1563     } else {
1564       AliError(Form("can not create Raw Reader for HLT input %s", fUseHLTData.Data()));
1565     }
1566   }
1567   AliSysInfo::AddStamp("CreateRawReader");
1568 }
1569
1570 //_____________________________________________________________________________
1571 void AliReconstruction::InitRun(const char* input)
1572 {
1573   // Initialization of raw-reader,
1574   // run number, CDB etc.
1575   AliCodeTimerAuto("",0);
1576   AliSysInfo::AddStamp("Start");
1577
1578   // Initialize raw-reader if any
1579   InitRawReader(input);
1580
1581   // Initialize the CDB storage
1582   InitCDB();
1583
1584   // Set run number in CDBManager (if it is not already set by the user)
1585   if (!SetRunNumberFromData()) {
1586     Abort("SetRunNumberFromData", TSelector::kAbortProcess);
1587     return;
1588   }
1589
1590   // Set CDB lock: from now on it is forbidden to reset the run number
1591   // or the default storage or to activate any further storage!
1592   SetCDBLock();
1593
1594 }
1595
1596 //_____________________________________________________________________________
1597 void AliReconstruction::Begin(TTree *)
1598 {
1599   // Initialize AlReconstruction before
1600   // going into the event loop
1601   // Should follow the TSelector convention
1602   // i.e. initialize only the object on the client side
1603   AliCodeTimerAuto("",0);
1604
1605   AliReconstruction *reco = NULL;
1606   if (fInput) {
1607     if ((reco = (AliReconstruction*)fInput->FindObject("AliReconstruction"))) {
1608       *this = *reco;
1609     }
1610     AliSysInfo::AddStamp("ReadInputInBegin");
1611   }
1612
1613   // Import ideal TGeo geometry and apply misalignment
1614   if (!AliGeomManager::GetGeometry()) {
1615     TString geom(gSystem->DirName(fGAliceFileName));
1616     geom += "/geometry.root";
1617     AliGeomManager::LoadGeometry(geom.Data());
1618     if (!gGeoManager) {
1619       Abort("LoadGeometry", TSelector::kAbortProcess);
1620       return;
1621     }
1622     AliSysInfo::AddStamp("LoadGeom");
1623     TString detsToCheck=fRunLocalReconstruction;
1624     if(!AliGeomManager::CheckSymNamesLUT(detsToCheck.Data())) {
1625       Abort("CheckSymNamesLUT", TSelector::kAbortProcess);
1626       return;
1627     }
1628     AliSysInfo::AddStamp("CheckGeom");
1629   }
1630
1631   Bool_t toCDBSnapshot=kFALSE;
1632   TString snapshotFileOut(""); // we could use fSnapshotFileName if we are not interested
1633   // in reading from and writing to a snapshot file at the same time
1634   if(TString(getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
1635       toCDBSnapshot=kTRUE;
1636       //fFromCDBSnapshot=kFALSE;
1637       TString snapshotFile(getenv("OCDB_SNAPSHOT_FILENAME"));
1638       if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
1639           snapshotFileOut = snapshotFile;
1640       else
1641           snapshotFileOut="OCDB.root";
1642   }
1643
1644   if (!MisalignGeometry(fLoadAlignData)) {
1645     Abort("MisalignGeometry", TSelector::kAbortProcess);
1646     return;
1647   }
1648
1649   const TMap* cdbCache = AliCDBManager::Instance()->GetEntryCache();
1650   if(cdbCache->Contains("GRP/Geometry/Data"))
1651           AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
1652   if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
1653   AliSysInfo::AddStamp("MisalignGeom");
1654
1655   if (!InitGRP()) {
1656     Abort("InitGRP", TSelector::kAbortProcess);
1657     return;
1658   }
1659   AliSysInfo::AddStamp("InitGRP");
1660   if(!toCDBSnapshot)
1661       if(cdbCache->Contains("GRP/Calib/CosmicTriggers"))
1662           AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
1663
1664   if(!fCDBSnapshotMode || toCDBSnapshot){
1665       if (!LoadCDB()) {
1666           Abort("LoadCDB", TSelector::kAbortProcess);
1667           return;
1668       }
1669       AliSysInfo::AddStamp("LoadCDB");
1670   }
1671
1672   if (!LoadTriggerScalersCDB()) {
1673     Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
1674     return;
1675   }
1676   AliSysInfo::AddStamp("LoadTriggerScalersCDB");
1677
1678   if (!LoadCTPTimeParamsCDB()) {
1679     Abort("LoadCTPTimeParamsCDB", TSelector::kAbortProcess);
1680     return;
1681   }
1682   AliSysInfo::AddStamp("LoadCTPTimeParamsCDB");
1683
1684   if (!ReadIntensityInfoCDB()) {
1685     Abort("ReadIntensityInfoCDB", TSelector::kAbortProcess);
1686     return;
1687   }
1688   AliSysInfo::AddStamp("ReadIntensityInfoCDB");
1689
1690   // Read the reconstruction parameters from OCDB
1691   if (!InitRecoParams()) {
1692     AliWarning("Not all detectors have correct RecoParam objects initialized");
1693   }
1694   AliSysInfo::AddStamp("InitRecoParams");
1695
1696   if(toCDBSnapshot)
1697   {
1698       AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
1699       exit(0);
1700   }
1701
1702   if (fInput && gProof) {
1703     if (reco) *reco = *this;
1704
1705     gGeoManager->SetName("Geometry");
1706     gProof->AddInputData(gGeoManager,kTRUE);
1707     gGeoManager = NULL;
1708     gProof->AddInputData(const_cast<TMap*>(AliCDBManager::Instance()->GetEntryCache()),kTRUE);
1709     fInput->Add(new TParameter<Int_t>("RunNumber",AliCDBManager::Instance()->GetRun()));
1710     AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1711     magFieldMap->SetName("MagneticFieldMap");
1712     gProof->AddInputData(magFieldMap,kTRUE);
1713     if (fAnalysis) {
1714       fAnalysis->SetName("Analysis");
1715       gProof->AddInputData(fAnalysis,kTRUE);
1716     }
1717   }
1718
1719 }
1720
1721 //_____________________________________________________________________________
1722 void AliReconstruction::SlaveBegin(TTree*)
1723 {
1724   // Initialization related to run-loader,
1725   // vertexer, trackers, recontructors
1726   // In proof mode it is executed on the slave
1727   AliCodeTimerAuto("",0);
1728
1729   TProofOutputFile *outProofFile = NULL;
1730   if (fInput) {
1731     if (AliDebugLevel() > 0) fInput->Print();
1732     if (AliDebugLevel() > 10) fInput->Dump();
1733     if (AliReconstruction *reco = (AliReconstruction*)fInput->FindObject("AliReconstruction")) {
1734       *this = *reco;
1735     }
1736     if (TGeoManager *tgeo = (TGeoManager*)fInput->FindObject("Geometry")) {
1737       gGeoManager = tgeo;
1738       AliGeomManager::SetGeometry(tgeo);
1739     }
1740     if (TMap *entryCache = (TMap*)fInput->FindObject("CDBEntryCache")) {
1741       Int_t runNumber = -1;
1742       if (TProof::GetParameter(fInput,"RunNumber",runNumber) == 0) {
1743         AliCDBManager *man = AliCDBManager::Instance(entryCache,runNumber);
1744         man->SetCacheFlag(kTRUE);
1745         man->SetLock(kTRUE);
1746         man->Print();
1747       }
1748     }
1749     if (AliMagF *map = (AliMagF*)fInput->FindObject("MagneticFieldMap")) {
1750       AliMagF *newMap = new AliMagF(*map);
1751       if (!newMap->LoadParameterization()) {
1752         Abort("AliMagF::LoadParameterization", TSelector::kAbortProcess);
1753         return;
1754       }
1755       TGeoGlobalMagField::Instance()->SetField(newMap);
1756       TGeoGlobalMagField::Instance()->Lock();
1757     }
1758     if (!fAnalysis) {
1759        // Attempt to get the analysis manager from the input list
1760        fAnalysis = (AliAnalysisManager*)fInput->FindObject("Analysis");
1761        if (fAnalysis) AliInfo("==== Analysis manager retrieved from input list ====");
1762     }
1763     if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
1764       fProofOutputFileName = outputFileName->GetTitle();
1765     if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
1766       fProofOutputLocation = outputLocation->GetTitle();
1767     if (fInput->FindObject("PROOF_OUTPUTFILE_DATASET"))
1768       fProofOutputDataset = kTRUE;
1769     if (TNamed *archiveList = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_ARCHIVE"))
1770       fProofOutputArchive = archiveList->GetTitle();
1771     if (!fProofOutputFileName.IsNull() &&
1772         !fProofOutputLocation.IsNull() &&
1773         fProofOutputArchive.IsNull()) {
1774       if (!fProofOutputDataset) {
1775         outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"M");
1776         outProofFile->SetOutputFileName(Form("%s%s",fProofOutputLocation.Data(),fProofOutputFileName.Data()));
1777       }
1778       else {
1779         outProofFile = new TProofOutputFile(fProofOutputFileName.Data(),"DROV",fProofOutputLocation.Data());
1780       }
1781       if (AliDebugLevel() > 0) outProofFile->Dump();
1782       fOutput->Add(outProofFile);
1783     }
1784     AliSysInfo::AddStamp("ReadInputInSlaveBegin");
1785   }
1786   // Check if analysis was requested in the reconstruction event loop
1787   if (!fAnalysis) {
1788     // Attempt to connect in-memory singleton
1789     fAnalysis = AliAnalysisManager::GetAnalysisManager();
1790     if (fAnalysis) AliInfo(Form("==== Analysis manager <%s> found in memory ====", fAnalysis->GetName()));
1791     // Check if an analysis macro was specified
1792     if (!fAnalysis && !fAnalysisMacro.IsNull()) {
1793       // Run specified analysis macro
1794       gROOT->ProcessLine(Form(".x %s",fAnalysisMacro.Data()));
1795       fAnalysis = AliAnalysisManager::GetAnalysisManager();
1796       if (!fAnalysis) AliError(Form("No analysis manager produced by analysis macro %s", fAnalysisMacro.Data()));
1797       else AliInfo(Form("==== Analysis manager <%s> produced by analysis macro <%s> ====",
1798                         fAnalysis->GetName(), fAnalysisMacro.Data()));
1799     }
1800   }
1801
1802   // get the run loader
1803   if (!InitRunLoader()) {
1804     Abort("InitRunLoader", TSelector::kAbortProcess);
1805     return;
1806   }
1807   AliSysInfo::AddStamp("LoadLoader");
1808
1809   CheckRecoCDBvsSimuCDB();
1810
1811   ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
1812
1813   // get trackers
1814   if (!fRunTracking.IsNull() && !CreateTrackers(fRunTracking)) {
1815     Abort("CreateTrackers", TSelector::kAbortProcess);
1816     return;
1817   }
1818   AliSysInfo::AddStamp("CreateTrackers");
1819
1820   // create the ESD output file and tree
1821   if (!outProofFile) {
1822     ffile = TFile::Open("AliESDs.root", "RECREATE");
1823     ffile->SetCompressionLevel(2);
1824     if (!ffile->IsOpen()) {
1825       Abort("OpenESDFile", TSelector::kAbortProcess);
1826       return;
1827     }
1828   }
1829   else {
1830     AliInfo(Form("Opening output PROOF file: %s/%s",
1831                  outProofFile->GetDir(), outProofFile->GetFileName()));
1832     if (!(ffile = outProofFile->OpenFile("RECREATE"))) {
1833       Abort(Form("Problems opening output PROOF file: %s/%s",
1834                  outProofFile->GetDir(), outProofFile->GetFileName()),
1835             TSelector::kAbortProcess);
1836       return;
1837     }
1838   }
1839
1840   ftree = new TTree("esdTree", "Tree with ESD objects");
1841   fesd = new AliESDEvent();
1842   fesd->CreateStdContent();
1843   // add a so far non-std object to the ESD, this will
1844   // become part of the std content
1845   fesd->AddObject(new AliESDHLTDecision);
1846
1847   fesd->WriteToTree(ftree);
1848   if (fWriteESDfriend) {
1849     ffileF = TFile::Open("AliESDfriends.root", "RECREATE");
1850     ftreeF = new TTree("esdFriendTree", "Tree with ESD Friend objects");
1851     fesdf  = new AliESDfriend();
1852     ftreeF->Branch("ESDfriend.","AliESDfriend", &fesdf);
1853     fesd->AddObject(fesdf);
1854     ffile->cd();
1855   }
1856   ftree->GetUserInfo()->Add(fesd);
1857
1858   fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1859   fhltesd = new AliESDEvent();
1860   fhltesd->CreateStdContent();
1861   // read the ESD template from CDB
1862   // HLT is allowed to put non-std content to its ESD, the non-std
1863   // objects need to be created before invocation of WriteToTree in
1864   // order to create all branches. Initialization is done from an
1865   // ESD layout template in CDB
1866   AliCDBManager* man = AliCDBManager::Instance();
1867   AliCDBEntry* hltESDConfig = man->Get("HLT/Calib/esdLayout");
1868   if(!hltESDConfig){
1869       AliError(Form("Error getting \"HLT/Calib/esdLayout\""));
1870       return;
1871   }
1872   AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1873   if (pESDLayout) {
1874       // init all internal variables from the list of objects
1875       pESDLayout->GetStdContent();
1876
1877       // copy content and create non-std objects
1878       *fhltesd=*pESDLayout;
1879       fhltesd->Reset();
1880   } else {
1881       AliError(Form("error setting hltEsd layout from \"HLT/Calib/esdLayout\": invalid object type"));
1882   }
1883
1884   fhltesd->WriteToTree(fhlttree);
1885   fhlttree->GetUserInfo()->Add(fhltesd);
1886
1887   ProcInfo_t procInfo;
1888   gSystem->GetProcInfo(&procInfo);
1889   AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
1890
1891   // PID
1892   fESDpid = new AliESDpid();
1893
1894   //QA
1895   //Initialize the QA and start of cycle
1896   if (fRunQA || fRunGlobalQA)
1897     InitQA() ;
1898
1899   //Initialize the Plane Efficiency framework
1900   if (fRunPlaneEff && !InitPlaneEff()) {
1901     Abort("InitPlaneEff", TSelector::kAbortProcess);
1902     return;
1903   }
1904
1905   if (strcmp(gProgName,"alieve") == 0)
1906     fRunAliEVE = InitAliEVE();
1907   // If we have an analysis manager, connect the AliRecoInputHandler here
1908   if (fAnalysis) {
1909     if (!dynamic_cast<AliRecoInputHandler*>(fAnalysis->GetInputEventHandler())) {
1910        AliError("Analysis manager used in reconstruction should use AliRecoInputHandler - \
1911                  \n  ->Replacing with AliRecoInputHandler instance.");
1912        delete fAnalysis->GetInputEventHandler();
1913     }
1914     // Set the event and other data pointers
1915     fRecoHandler = new AliRecoInputHandler();
1916 //    fRecoHandler->Init(ftree, "LOCAL");
1917     fRecoHandler->SetEvent(fesd);
1918     fRecoHandler->SetESDfriend(fesdf);
1919     fRecoHandler->SetHLTEvent(fhltesd);
1920     fRecoHandler->SetHLTTree(fhlttree);
1921     fAnalysis->SetInputEventHandler(fRecoHandler);
1922     // Enter external loop mode
1923     fAnalysis->SetExternalLoop(kTRUE);
1924     // Initialize analysis
1925     fAnalysis->SlaveBegin(ftree);
1926     fAnalysis->StartAnalysis("local", (TTree*)0);
1927     // Connect ESD tree with the input container
1928     fAnalysis->GetCommonInputContainer()->SetData(ftree);
1929   }
1930   return;
1931 }
1932
1933 //_____________________________________________________________________________
1934 Bool_t AliReconstruction::Process(Long64_t entry)
1935 {
1936   // run the reconstruction over a single entry
1937   // from the chain with raw data
1938   AliCodeTimerAuto("",0);
1939
1940   TTree *currTree = fChain->GetTree();
1941   AliRawVEvent *event = NULL;
1942   currTree->SetBranchAddress("rawevent",&event);
1943   currTree->GetEntry(entry);
1944   fRawReader = new AliRawReaderRoot(event);
1945   // check if process has enough resources
1946   if (!HasEnoughResources(entry)) return kFALSE;
1947   fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1948   delete fRawReader;
1949   fRawReader = NULL;
1950   delete event;
1951
1952   return fStatus;
1953 }
1954
1955 //_____________________________________________________________________________
1956 void AliReconstruction::Init(TTree *tree)
1957 {
1958   // Implementation of TSelector::Init()
1959   // method
1960   if (tree == 0) {
1961     AliError("The input tree is not found!");
1962     return;
1963   }
1964   fChain = tree;
1965 }
1966
1967 //_____________________________________________________________________________
1968 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1969 {
1970   // run the reconstruction over a single event
1971   // The event loop is steered in Run method
1972
1973
1974   static Long_t oldMres=0;
1975   static Long_t oldMvir=0;
1976   static Float_t oldCPU=0;
1977   // static Long_t aveDMres=0;
1978   // static Long_t aveDMvir=0;
1979   // static Float_t aveDCPU=0;
1980
1981   AliCodeTimerAuto("",0);
1982
1983   AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
1984
1985   if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1986     fRunLoader->SetEventNumber(iEvent);
1987     if (fRawReader)
1988       fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1989                                      iEvent, iEvent);
1990     fRunLoader->TreeE()->Fill();
1991
1992     if (fRawReader && fRawReader->UseAutoSaveESD())
1993       fRunLoader->TreeE()->AutoSave("SaveSelf");
1994   }
1995
1996   if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1997     return kTRUE;
1998   }
1999
2000
2001   fRunLoader->GetEvent(iEvent);
2002
2003   // Fill Event-info object
2004   GetEventInfo();
2005   fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
2006
2007   ProcInfo_t procInfo;
2008   if(iEvent==fFirstEvent) {
2009     gSystem->GetProcInfo(&procInfo);
2010     oldMres=procInfo.fMemResident;
2011     oldMvir=procInfo.fMemVirtual;
2012     oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
2013   }
2014   AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
2015
2016   AliSysInfo::AddStamp(Form("StartReco_%d",iEvent), 0,0,iEvent);
2017
2018   // Set the reco-params
2019   {
2020     TString detStr = fLoadCDB;
2021     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2022       if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2023       AliReconstructor *reconstructor = GetReconstructor(iDet);
2024       if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
2025         const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2026         reconstructor->SetRecoParam(par);
2027         reconstructor->GetPidSettings(fESDpid);
2028         reconstructor->SetEventInfo(&fEventInfo);
2029         if (fRunQA) {
2030           AliQAManager::QAManager()->SetEventInfo(&fEventInfo) ;
2031           AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
2032           if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
2033         }
2034       }
2035     }
2036     //
2037     if (fRunQA || fRunGlobalQA) AliQADataMaker::SetEventTrigClasses(fEventInfo.GetTriggerClasses()); // RS: select which histo clones are to be filled
2038     //
2039     if (fRunQA) {
2040       const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
2041       AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
2042       AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
2043     }
2044   }
2045
2046     // QA on single raw
2047   if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
2048     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2049     AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
2050     AliSysInfo::AddStamp(Form("RawQA_%d",iEvent), 0,0,iEvent);
2051   }
2052
2053     // fill Event header information from the RawEventHeader
2054     if (fRawReader){FillRawEventHeaderESD(fesd);}
2055     if (fRawReader){FillRawEventHeaderESD(fhltesd);}
2056     if (fRawReader){
2057       // Store DAQ detector pattern and attributes
2058       fesd->SetDAQDetectorPattern(fRawReader->GetDetectorPattern()[0]);
2059       fesd->SetDAQAttributes(fRawReader->GetAttributes()[2]);
2060     }
2061
2062     fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
2063     fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
2064
2065     ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
2066     ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInDAQ(fRunInfo->GetDetectorMask());
2067     ((AliESDRun*)fesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
2068     ((AliESDRun*)fhltesd->GetESDRun())->SetDetectorsInReco(AliDAQ::DetectorPatternOffline(fFillESD.Data()));
2069
2070     fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
2071     fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
2072
2073     fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
2074     fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
2075
2076     // Set magnetic field from the tracker
2077     fesd->SetMagneticField(AliTracker::GetBz());
2078     fhltesd->SetMagneticField(AliTracker::GetBz());
2079     //
2080     AliESDRun *esdRun,*esdRunH;
2081     esdRun  = (AliESDRun*)fesd->GetESDRun();
2082     esdRunH = (AliESDRun*)fhltesd->GetESDRun();
2083     esdRun->SetBeamEnergyIsSqrtSHalfGeV();
2084     esdRunH->SetBeamEnergyIsSqrtSHalfGeV();
2085     //
2086     for (int ib=2;ib--;) for (int it=2;it--;) {
2087         esdRun->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
2088         esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]);
2089       }
2090     //
2091     fesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2092     fesd->SetBeamType(fGRPData->GetBeamType().Data());
2093     fesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2094     fesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2095     fhltesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
2096     fhltesd->SetBeamType(fGRPData->GetBeamType().Data());
2097     fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
2098     fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
2099     //
2100     AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
2101     if (fld) { // set info needed for field initialization
2102       fesd->SetCurrentL3(fld->GetCurrentSol());
2103       fesd->SetCurrentDip(fld->GetCurrentDip());
2104       fesd->SetUniformBMap(fld->IsUniform());
2105       fesd->SetBInfoStored();
2106       //
2107       fhltesd->SetCurrentL3(fld->GetCurrentSol());
2108       fhltesd->SetCurrentDip(fld->GetCurrentDip());
2109       fhltesd->SetUniformBMap(fld->IsUniform());
2110       fhltesd->SetBInfoStored();
2111     }
2112
2113     //
2114     // run full HLT reconstruction first
2115     //
2116     {
2117       TString detectors=fRunLocalReconstruction;
2118       if (IsSelected("HLT", detectors) &&
2119           !RunLocalEventReconstruction("HLT")) {
2120         if (fStopOnError) {CleanUp(); return kFALSE;}
2121       }
2122       detectors=fFillESD;
2123       // run HLT on hltesd
2124       if (IsSelected("HLT", detectors) &&
2125           !FillESD(fhltesd, "HLT")) {
2126         if (fStopOnError) {CleanUp(); return kFALSE;}
2127       }
2128     }
2129
2130     // local single event reconstruction
2131     if (!fRunLocalReconstruction.IsNull()) {
2132       TString detectors=fRunLocalReconstruction;
2133       // the logic for selection and correct sequence of reconstruction relies on the
2134       // full list of detectors. Keyword 'ALL' should have been replaced at this point.
2135       if (detectors.Contains("ALL")) {
2136         AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
2137                  "fRunLocalReconstruction. This should have been done by the framework");
2138       }
2139       detectors.ReplaceAll("HLT", "");
2140       if (!RunLocalEventReconstruction(detectors)) {
2141         if (fStopOnError) {
2142           CleanUp();
2143           return kFALSE;
2144         }
2145       }
2146     }
2147
2148
2149     //
2150     // Set most probable pt, for B=0 tracking
2151     // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
2152     const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
2153     if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
2154
2155     // Fill raw-data error log into the ESD
2156     if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
2157
2158     AliSysInfo::AddStamp(Form("FillHeadErrs_%d",iEvent), 0,0,iEvent);
2159
2160     // vertex finder
2161     if (fRunVertexFinder) {
2162       if (!RunVertexFinder(fesd)) {
2163         if (fStopOnError) {CleanUp(); return kFALSE;}
2164       }
2165       AliSysInfo::AddStamp(Form("VtxFinder_%d",iEvent), 0,0,iEvent);
2166     }
2167
2168     // For Plane Efficiency: run the SPD trackleter
2169     if (fRunPlaneEff && fSPDTrackleter) {
2170       if (!RunSPDTrackleting(fesd)) {
2171         if (fStopOnError) {CleanUp(); return kFALSE;}
2172       }
2173       AliSysInfo::AddStamp(Form("TrackletEff_%d",iEvent), 0,0,iEvent);
2174     }
2175
2176     // Muon tracking
2177     if (!fRunTracking.IsNull()) {
2178       if (fRunMuonTracking) {
2179         if (!RunMuonTracking(fesd)) {
2180           if (fStopOnError) {CleanUp(); return kFALSE;}
2181         }
2182       }
2183       AliSysInfo::AddStamp(Form("TrackingMUON_%d",iEvent), 0,0,iEvent);
2184     }
2185
2186     //---------------- AU From here...
2187
2188     // MFT tracking of MUON tracks
2189     if (!fRunTracking.IsNull()) {
2190       if (fRunMFTTrackingMU && fRunMuonTracking) {
2191         if (!RunMFTTrackingMU(fesd)) {
2192           if (fStopOnError) {CleanUp(); return kFALSE;}
2193         }
2194       }
2195       AliSysInfo::AddStamp(Form("TrackingMFT_MUON_%d",iEvent), 0,0,iEvent);
2196     }
2197
2198     //---------------- ...to here
2199
2200     // barrel tracking
2201     if (!fRunTracking.IsNull()) {
2202       if (!RunTracking(fesd,*fESDpid)) {
2203         if (fStopOnError) {CleanUp(); return kFALSE;}
2204       }
2205     }
2206
2207     // fill ESD
2208     if (!fFillESD.IsNull()) {
2209       TString detectors=fFillESD;
2210       // the logic for selection and correct sequence of reconstruction relies on the
2211       // full list of detectors. Keyword 'ALL' should have been replaced at this point.
2212       if (detectors.Contains("ALL")) {
2213         AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
2214                  "fFillESD. This should have been done by the framework");
2215       }
2216       // remove HLT as this has been executed at the beginning of the event reconstruction
2217       detectors.ReplaceAll("HLT", "");
2218       if (!FillESD(fesd, detectors)) {
2219         if (fStopOnError) {CleanUp(); return kFALSE;}
2220       }
2221     }
2222
2223     ffile->cd();
2224
2225     //
2226     // Propagate track to the beam pipe  (if not already done by ITS)
2227     //
2228     const Int_t ntracks = fesd->GetNumberOfTracks();
2229     const Double_t kRadius  = 2.8; //something less than the beam pipe radius
2230
2231     TObjArray trkArray;
2232     UShort_t selectedIdx[ntracks];
2233
2234     for (Int_t itrack=0; itrack<ntracks; itrack++){
2235       const Double_t kMaxStep = 1;   //max step over the material
2236       Bool_t ok;
2237
2238       AliESDtrack *track = fesd->GetTrack(itrack);
2239       if (!track) continue;
2240
2241       AliExternalTrackParam *tpcTrack =
2242            (AliExternalTrackParam *)track->GetTPCInnerParam();
2243       ok = kFALSE;
2244       if (tpcTrack)
2245         ok = AliTracker::
2246           PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMassForTracking(),kMaxStep,kFALSE);
2247
2248       if (ok) {
2249         Int_t n=trkArray.GetEntriesFast();
2250         selectedIdx[n]=track->GetID();
2251         trkArray.AddLast(tpcTrack);
2252       }
2253
2254       //Tracks refitted by ITS should already be at the SPD vertex
2255       if (track->IsOn(AliESDtrack::kITSrefit)) continue;
2256
2257       AliTracker::
2258          PropagateTrackToBxByBz(track,kRadius,track->GetMassForTracking(),kMaxStep,kFALSE);
2259       Double_t x[3]; track->GetXYZ(x);
2260       Double_t b[3]; AliTracker::GetBxByBz(x,b);
2261       track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
2262
2263     }
2264     AliSysInfo::AddStamp(Form("RelToSPDVtx_%d",iEvent), 0,0,iEvent);
2265     //
2266     // Improve the reconstructed primary vertex position using the tracks
2267     //
2268     Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
2269     if(fesd->GetPrimaryVertexSPD()) {
2270       TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
2271       if(vtitle.Contains("cosmics")) {
2272         runVertexFinderTracks=kFALSE;
2273       }
2274     }
2275
2276     if (runVertexFinderTracks) {
2277        // TPC + ITS primary vertex
2278        ftVertexer->SetITSMode();
2279        ftVertexer->SetConstraintOff();
2280        // get cuts for vertexer from AliGRPRecoParam
2281        Bool_t constrSPD=kFALSE;
2282        if (grpRecoParam) {
2283          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2284          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2285          grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer,nCutsVertexer);
2286          ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2287          delete [] cutsVertexer; cutsVertexer = NULL;
2288          if(grpRecoParam->GetVertexerTracksConstraintITS()) {
2289            if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
2290              ftVertexer->SetVtxStart(fDiamondProfile); // apply constraint only if sigmax is smaller than the beam pipe radius
2291            }else{
2292              if(fDiamondProfileSPD && fDiamondProfileSPD->GetXRes()<kRadius){
2293                ftVertexer->SetVtxStart(fDiamondProfileSPD);
2294                constrSPD=kTRUE;
2295              }
2296            }
2297          }
2298        }
2299        AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
2300        if (pvtx) {
2301          if(constrSPD){
2302            TString title=pvtx->GetTitle();
2303            title.Append("SPD");
2304            pvtx->SetTitle(title);
2305          }
2306           if (pvtx->GetStatus()) {
2307              fesd->SetPrimaryVertexTracks(pvtx);
2308              for (Int_t i=0; i<ntracks; i++) {
2309                  AliESDtrack *t = fesd->GetTrack(i);
2310                  Double_t x[3]; t->GetXYZ(x);
2311                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
2312                  t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
2313              }
2314           }
2315           delete pvtx; pvtx=NULL;
2316        }
2317        AliSysInfo::AddStamp(Form("VtxTrk_%d",iEvent), 0,0,iEvent);
2318
2319        // TPC-only primary vertex
2320        ftVertexer->SetTPCMode();
2321        ftVertexer->SetConstraintOff();
2322        // get cuts for vertexer from AliGRPRecoParam
2323        if (grpRecoParam) {
2324          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
2325          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
2326          grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer,nCutsVertexer);
2327          ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
2328          delete [] cutsVertexer; cutsVertexer = NULL;
2329          if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) {
2330            if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius
2331          }
2332        }
2333        pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
2334        if (pvtx) {
2335           if (pvtx->GetStatus()) {
2336              fesd->SetPrimaryVertexTPC(pvtx);
2337              for (Int_t i=0; i<ntracks; i++) {
2338                  AliESDtrack *t = fesd->GetTrack(i);
2339                  Double_t x[3]; t->GetXYZ(x);
2340                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
2341                  t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
2342              }
2343           }
2344           delete pvtx; pvtx=NULL;
2345        }
2346        AliSysInfo::AddStamp(Form("VtxTPC_%d",iEvent), 0,0,iEvent);
2347
2348     }
2349
2350     if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
2351     else fesd->SetDiamond(fDiamondProfileSPD);
2352
2353     if (fRunV0Finder) {
2354        // V0 finding
2355        AliV0vertexer vtxer;
2356        // get cuts for V0vertexer from AliGRPRecoParam
2357        if (grpRecoParam) {
2358          Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
2359          Double_t cutsV0vertexer[nCutsV0vertexer];
2360          grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
2361          vtxer.SetCuts(cutsV0vertexer);
2362        }
2363        vtxer.Tracks2V0vertices(fesd);
2364        AliSysInfo::AddStamp(Form("V0Finder_%d",iEvent), 0,0,iEvent);
2365
2366        if (fRunCascadeFinder) {
2367           // Cascade finding
2368           AliCascadeVertexer cvtxer;
2369           // get cuts for CascadeVertexer from AliGRPRecoParam
2370           if (grpRecoParam) {
2371             Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
2372             Double_t cutsCascadeVertexer[nCutsCascadeVertexer];
2373             grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
2374             cvtxer.SetCuts(cutsCascadeVertexer);
2375           }
2376           cvtxer.V0sTracks2CascadeVertices(fesd);
2377           AliSysInfo::AddStamp(Form("CascadeFinder_%d",iEvent), 0,0,iEvent);
2378        }
2379     }
2380
2381     // AdC+FN
2382     if (fReconstructor[3])
2383       GetReconstructor(3)->FillEventTimeWithTOF(fesd,fESDpid);
2384
2385     // combined PID
2386     //    fESDpid->MakePID(fesd);
2387
2388     if (fFillTriggerESD) {
2389       if (!FillTriggerESD(fesd)) {
2390         if (fStopOnError) {CleanUp(); return kFALSE;}
2391       }
2392     }
2393     // Always fill scalers
2394     if (!FillTriggerScalers(fesd)) {
2395        if (fStopOnError) {CleanUp(); return kFALSE;}
2396     }
2397
2398     AliSysInfo::AddStamp(Form("FillVaria_%d",iEvent), 0,0,iEvent);
2399
2400     // write ESD
2401     UInt_t specie = fesd->GetEventSpecie();
2402     Bool_t keepAll = (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib);
2403     if (fCleanESD && (!keepAll) ) {
2404       CleanESD(fesd);
2405       AliSysInfo::AddStamp(Form("CleanESD_%d",iEvent), 0,0,iEvent);
2406     }
2407     //
2408     // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the
2409     // tracks interpreted as primary, this step should be done in the very end, when full
2410     // ESD info is available (particulalry, V0s)
2411     // vertex finder
2412     if (fRunMultFinder) {
2413       if (!RunMultFinder(fesd)) {
2414         if (fStopOnError) {CleanUp(); return kFALSE;}
2415       }
2416       AliSysInfo::AddStamp(Form("MultFinder_%d",iEvent), 0,0,iEvent);
2417     }
2418
2419   if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
2420     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2421     AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ;
2422     AliSysInfo::AddStamp(Form("RunQA_%d",iEvent), 0,0,iEvent);
2423   }
2424   if (fRunGlobalQA) {
2425     AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2426     if (qadm)
2427       qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2428     if (qadm && IsInTasks(AliQAv1::kESDS))
2429       qadm->Exec(AliQAv1::kESDS, fesd);
2430     AliSysInfo::AddStamp(Form("RunGlobQA_%d",iEvent), 0,0,iEvent);
2431   }
2432
2433   // copy HLT decision from HLTesd to esd
2434   // the most relevant information is stored in a reduced container in the esd,
2435   // while the full information can be found in the HLTesd
2436   TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
2437   TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
2438   if (pHLTSrc && pHLTTgt) {
2439     pHLTSrc->Copy(*pHLTTgt);
2440   }
2441   //
2442   // Perform analysis of this event if requested
2443   // RS: Should be done before WriteESDfriend, since the latter may clean the esdfriend
2444   if (fAnalysis) {
2445     fRecoHandler->BeginEvent(iEvent);
2446     fAnalysis->ExecAnalysis();
2447     fRecoHandler->FinishEvent();
2448     AliSysInfo::AddStamp(Form("Analysis_%d",iEvent), 0,0,iEvent);
2449   }
2450   //
2451   if (fWriteESDfriend) {
2452     fesd->GetESDfriend(fesdf);
2453     AliSysInfo::AddStamp(Form("CreateFriend_%d",iEvent), 0,0,iEvent);
2454
2455   }
2456   //
2457   Long64_t nbf;
2458   nbf = ftree->Fill();
2459   if (fTreeBuffSize>0 && ftree->GetAutoFlush()<0 && (fMemCountESD += nbf)>fTreeBuffSize ) { // default limit is still not reached
2460     nbf = ftree->GetZipBytes();
2461     if (nbf>0) nbf = -nbf;
2462     else       nbf = ftree->GetEntries();
2463     ftree->SetAutoFlush(nbf);
2464     AliInfo(Form("Calling ftree->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
2465                  nbf,fMemCountESD,ftree->GetTotBytes(),ftree->GetZipBytes()));
2466   }
2467   AliSysInfo::AddStamp(Form("ESDFill_%d",iEvent), 0,0,iEvent);
2468   //
2469   if (fWriteESDfriend) {
2470     WriteESDfriend();
2471     AliSysInfo::AddStamp(Form("WriteFriend_%d",iEvent), 0,0,iEvent);
2472   }
2473   //
2474   //
2475   // Auto-save the ESD tree in case of prompt reco @P2
2476   if (fRawReader && fRawReader->UseAutoSaveESD()) {
2477     ftree->AutoSave("SaveSelf");
2478     if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
2479   }
2480   // write HLT ESD
2481
2482   nbf = fhlttree->Fill();
2483   if (fTreeBuffSize>0 && fhlttree->GetAutoFlush()<0 && (fMemCountESDHLT += nbf)>fTreeBuffSize ) { // default limit is still not reached
2484     nbf = fhlttree->GetZipBytes();
2485     if (nbf>0) nbf = -nbf;
2486     else       nbf = fhlttree->GetEntries();
2487     fhlttree->SetAutoFlush(nbf);
2488     AliInfo(Form("Calling fhlttree->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
2489                  nbf,fMemCountESDHLT,fhlttree->GetTotBytes(),fhlttree->GetZipBytes()));
2490   }
2491
2492
2493   return kTRUE;
2494 }
2495
2496 void AliReconstruction::CleanProcessedEvent()
2497 {
2498     //
2499     fesd->Reset();
2500     fhltesd->Reset();
2501     if (fWriteESDfriend) {
2502       fesdf->~AliESDfriend();
2503       new (fesdf) AliESDfriend(); // Reset...
2504     }
2505
2506     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2507       if (fReconstructor[iDet]) fReconstructor[iDet]->FinishEvent();
2508     }
2509
2510     AliInfo("======================= End Event ===================");
2511
2512     fEventInfo.Reset();
2513     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2514       if (fReconstructor[iDet]) {
2515         fReconstructor[iDet]->SetRecoParam(NULL);
2516         fReconstructor[iDet]->SetEventInfo(NULL);
2517       }
2518       if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
2519     }
2520
2521   if (fRunQA || fRunGlobalQA)
2522     AliQAManager::QAManager()->Increment() ;
2523
2524   DeleteRecPoints(fDeleteRecPoints);
2525   DeleteDigits(fDeleteDigits);
2526   //
2527
2528 }
2529
2530 //_____________________________________________________________________________
2531 void AliReconstruction::SlaveTerminate()
2532 {
2533   // Finalize the run on the slave side
2534   // Called after the exit
2535   // from the event loop
2536   AliCodeTimerAuto("",0);
2537   // If analysis was done during reconstruction, we need to call SlaveTerminate for it
2538   if (fAnalysis) {
2539      fAnalysis->PackOutput(fOutput);
2540      fAnalysis->SetSkipTerminate(kTRUE);
2541      fAnalysis->Terminate();
2542   }
2543
2544   if (fIsNewRunLoader) { // galice.root didn't exist
2545     fRunLoader->WriteHeader("OVERWRITE");
2546     fRunLoader->WriteTrigger("OVERWRITE");
2547     fRunLoader->CdGAFile();
2548     fRunLoader->Write(0, TObject::kOverwrite);
2549   }
2550
2551   const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
2552   const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
2553
2554    TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
2555    cdbMapCopy->SetOwner(1);
2556    cdbMapCopy->SetName("cdbMap");
2557    TIter iter(cdbMap->GetTable());
2558
2559    TPair* pair = 0;
2560    while((pair = dynamic_cast<TPair*> (iter.Next()))){
2561          TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
2562          TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2563          if (keyStr && valStr)
2564            cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
2565    }
2566
2567    TList *cdbListCopy = new TList();
2568    cdbListCopy->SetOwner(1);
2569    cdbListCopy->SetName("cdbList");
2570
2571    TIter iter2(cdbList);
2572
2573         AliCDBId* id=0;
2574         while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
2575          cdbListCopy->Add(new TObjString(id->ToString().Data()));
2576    }
2577
2578    ftree->GetUserInfo()->Add(cdbMapCopy);
2579    ftree->GetUserInfo()->Add(cdbListCopy);
2580
2581    // Add the AliRoot version that created this file
2582    TString sVersion("aliroot ");
2583    sVersion += ALIROOT_BRANCH;
2584    sVersion += ":";
2585    sVersion += ALIROOT_REVISION;
2586    sVersion += "; root ";
2587 #ifdef ROOT_SVN_BRANCH
2588    sVersion += ROOT_SVN_BRANCH;
2589 #elif defined(ROOT_GIT_BRANCH)
2590    sVersion += ROOT_GIT_BRANCH;
2591 #else
2592    sVersion += "?";
2593 #endif
2594    sVersion += ":";
2595 #ifdef ROOT_SVN_REVSION
2596    sVersion += ROOT_SVN_REVISION;
2597 #elif defined(ROOT_GIT_COMMIT)
2598    sVersion += ROOT_GIT_COMMIT;
2599 #else
2600    sVersion += "?";
2601 #endif
2602    sVersion += "; metadata ";
2603    sVersion += getenv("PRODUCTION_METADATA");
2604
2605
2606    TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
2607    ftree->GetUserInfo()->Add(alirootVersion); // The list becomes owner of alirootVersion
2608
2609   ffile->cd();
2610
2611   // we want to have only one tree version number
2612   ftree->Write(ftree->GetName(),TObject::kOverwrite);
2613   fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
2614
2615   if (fWriteESDfriend) {
2616     ffileF->cd();
2617     ftreeF->Write(ftreeF->GetName(),TObject::kOverwrite);
2618   }
2619
2620 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
2621   if (fRunPlaneEff && !FinishPlaneEff()) {
2622    AliWarning("Finish PlaneEff evaluation failed");
2623   }
2624
2625   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2626     if (fReconstructor[iDet]) fReconstructor[iDet]->Terminate();
2627   }
2628   // End of cycle for the in-loop
2629
2630   if (fRunQA || fRunGlobalQA) {
2631     AliQAManager::QAManager()->EndOfCycle() ;
2632     if (fInput &&
2633         !fProofOutputLocation.IsNull() &&
2634         fProofOutputArchive.IsNull() &&
2635         !fProofOutputDataset) {
2636       TString qaOutputFile(Form("%sMerged.%s.Data.root",
2637                                 fProofOutputLocation.Data(),
2638                                 AliQAv1::GetQADataFileName()));
2639       TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2640                                                                 AliQAv1::GetQADataFileName()));
2641       qaProofFile->SetOutputFileName(qaOutputFile.Data());
2642       if (AliDebugLevel() > 0) qaProofFile->Dump();
2643       fOutput->Add(qaProofFile);
2644       MergeQA(qaProofFile->GetFileName());
2645     }
2646     else {
2647       MergeQA();
2648     }
2649   }
2650
2651   gROOT->cd();
2652   CleanUp();
2653
2654   if (fInput) {
2655     if (!fProofOutputFileName.IsNull() &&
2656         !fProofOutputLocation.IsNull() &&
2657         fProofOutputDataset &&
2658         !fProofOutputArchive.IsNull()) {
2659       TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2660                                                             "DROV",
2661                                                             fProofOutputLocation.Data());
2662       if (AliDebugLevel() > 0) zipProofFile->Dump();
2663       fOutput->Add(zipProofFile);
2664       TString fileList(fProofOutputArchive.Data());
2665       fileList.ReplaceAll(","," ");
2666       TString command;
2667 #if ROOT_SVN_REVISION >= 30174
2668       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2669 #else
2670       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2671 #endif
2672       AliInfo(Form("Executing: %s",command.Data()));
2673       gSystem->Exec(command.Data());
2674     }
2675   }
2676 }
2677
2678 //_____________________________________________________________________________
2679 void AliReconstruction::Terminate()
2680 {
2681   // Create tags for the events in the ESD tree (the ESD tree is always present)
2682   // In case of empty events the tags will contain dummy values
2683   AliCodeTimerAuto("",0);
2684
2685   // Do not call the ESD tag creator in case of PROOF-based reconstruction
2686   if (!fInput) {
2687     AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2688     esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2689     delete esdtagCreator;
2690   }
2691
2692   // Cleanup of CDB manager: cache and active storages!
2693   AliCDBManager::Instance()->ClearCache();
2694 }
2695
2696 //_____________________________________________________________________________
2697 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2698 {
2699 // run the local reconstruction
2700
2701   static Int_t eventNr=0;
2702   AliCodeTimerAuto("",0)
2703
2704   TString detStr = detectors;
2705   // execute HLT reconstruction first since other detector reconstruction
2706   // might depend on HLT data
2707   // key 'HLT' is removed from detStr by IsSelected
2708   if (IsSelected("HLT", detStr)) {
2709     AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
2710     if (reconstructor) {
2711       // there is no AliLoader for HLT, see
2712       // https://savannah.cern.ch/bugs/?35473
2713       AliInfo("running reconstruction for HLT");
2714       if (fRawReader) {
2715         AliInfo("reconstructor->Reconstruct(fRawReader, NULL)");
2716         reconstructor->Reconstruct(fRawReader, NULL);
2717       }
2718       else {
2719         AliInfo("reconstructor->Reconstruct(dummy, NULL)");
2720         TTree* dummy=NULL;
2721         reconstructor->Reconstruct(dummy, NULL);
2722       }
2723     }
2724     AliSysInfo::AddStamp(Form("LRecHLT_%d",eventNr), -1,1,eventNr);
2725   }
2726
2727   AliInfo(Form("kNDetectors = %d",kNDetectors));
2728
2729   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2730     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2731     AliDebug(1, Form("Detector: %s", fgkDetectorName[iDet]));
2732     AliReconstructor* reconstructor = GetReconstructor(iDet);
2733     if (!reconstructor) continue;
2734     AliLoader* loader = fLoader[iDet];
2735     if (!loader) {
2736       AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2737       continue;
2738     }
2739     // conversion of digits
2740     if (fRawReader && reconstructor->HasDigitConversion()) {
2741       AliInfo(Form("converting raw data digits into root objects for %s",
2742                    fgkDetectorName[iDet]));
2743 //      AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2744 //                            fgkDetectorName[iDet]),0);
2745       loader->LoadDigits("update");
2746       loader->CleanDigits();
2747       loader->MakeDigitsContainer();
2748       TTree* digitsTree = loader->TreeD();
2749       reconstructor->ConvertDigits(fRawReader, digitsTree);
2750       loader->WriteDigits("OVERWRITE");
2751       loader->UnloadDigits();
2752     }
2753     // local reconstruction
2754     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
2755     //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
2756     AliDebug(1, "Loading Rec Points");
2757     loader->LoadRecPoints("update");
2758     AliDebug(1, "Cleaning Rec Points");
2759     loader->CleanRecPoints();
2760     AliDebug(1, "Making Rec Points Container");
2761     loader->MakeRecPointsContainer();
2762     TTree* clustersTree = loader->TreeR();
2763     if (fRawReader && !reconstructor->HasDigitConversion()) {
2764       reconstructor->Reconstruct(fRawReader, clustersTree);
2765     }
2766     else {
2767       AliDebug(1, "Loading Digits");
2768       loader->LoadDigits("read");
2769       TTree* digitsTree = loader->TreeD();
2770       AliDebug(1, Form("Digits Tree = %p",digitsTree));
2771       if (!digitsTree) {
2772         AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2773         if (fStopOnError)
2774           return kFALSE;
2775       }
2776       else {
2777         AliDebug(1, "Digits -> Clusters");
2778         reconstructor->Reconstruct(digitsTree, clustersTree);
2779         if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
2780           AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2781           AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
2782         }
2783       }
2784       loader->UnloadDigits();
2785     }
2786     if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
2787       AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2788       AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
2789     }
2790     loader->WriteRecPoints("OVERWRITE");
2791     loader->UnloadRecPoints();
2792     AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
2793   }
2794   if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
2795   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2796     AliError(Form("the following detectors were not found: %s",
2797                   detStr.Data()));
2798     if (fStopOnError)
2799       return kFALSE;
2800   }
2801   eventNr++;
2802   return kTRUE;
2803 }
2804 //_____________________________________________________________________________
2805 Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2806 {
2807 // run the SPD trackleting (for SPD efficiency purpouses)
2808
2809   AliCodeTimerAuto("",0)
2810
2811   Double_t vtxPos[3] = {0, 0, 0};
2812   Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2813 /*
2814   TArrayF m
2815 /
2816 cVertex(3);
2817   // if(MC)
2818   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2819     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2820     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2821   }
2822 */
2823   const AliESDVertex *vertex = esd->GetVertex();
2824   if(!vertex){
2825     AliWarning("Vertex not found");
2826     return kFALSE;
2827   }
2828   vertex->GetXYZ(vtxPos);
2829   vertex->GetSigmaXYZ(vtxErr);
2830   if (fSPDTrackleter) {
2831     AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2832
2833     // load clusters
2834     fLoader[0]->LoadRecPoints("read");
2835     TTree* tree = fLoader[0]->TreeR();
2836     if (!tree) {
2837       AliError("Can't get the ITS cluster tree");
2838       return kFALSE;
2839     }
2840     fSPDTrackleter->LoadClusters(tree);
2841     fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2842     // run trackleting
2843     if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2844       AliWarning("AliITSTrackleterSPDEff Clusters2Tracks failed");
2845      // fLoader[0]->UnloadRecPoints();
2846       return kFALSE;
2847     }
2848 //fSPDTrackleter->UnloadRecPoints();
2849   } else {
2850     AliWarning("SPDTrackleter not available");
2851     return kFALSE;
2852   }
2853   return kTRUE;
2854 }
2855
2856 //_____________________________________________________________________________
2857 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
2858 {
2859 // run the barrel tracking
2860
2861   AliCodeTimerAuto("",0)
2862
2863   AliVertexer *vertexer = CreateVertexer();
2864   if (!vertexer) return kFALSE;
2865
2866   AliInfo(Form("running the ITS vertex finder: %s",vertexer->ClassName()));
2867   AliESDVertex* vertex = NULL;
2868   if (fLoader[0]) {
2869     fLoader[0]->LoadRecPoints();
2870     TTree* cltree = fLoader[0]->TreeR();
2871     if (cltree) {
2872       if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2873       vertex = vertexer->FindVertexForCurrentEvent(cltree);
2874     }
2875     else {
2876       AliError("Can't get the ITS cluster tree");
2877     }
2878     fLoader[0]->UnloadRecPoints();
2879   }
2880   else {
2881     AliError("Can't get the ITS loader");
2882   }
2883   if(!vertex){
2884     AliWarning("Vertex not found");
2885     vertex = new AliESDVertex();
2886     vertex->SetName("default");
2887   }
2888   else {
2889     vertex->SetName("reconstructed");
2890   }
2891
2892   Double_t vtxPos[3];
2893   Double_t vtxErr[3];
2894   vertex->GetXYZ(vtxPos);
2895   vertex->GetSigmaXYZ(vtxErr);
2896
2897   esd->SetPrimaryVertexSPD(vertex);
2898   AliESDVertex *vpileup = NULL;
2899   Int_t novertices = 0;
2900   vpileup = vertexer->GetAllVertices(novertices);
2901   if(novertices>1){
2902     for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2903   }
2904   /*
2905   // if SPD multiplicity has been determined, it is stored in the ESD
2906   AliMultiplicity *mult = vertexer->GetMultiplicity();
2907   if(mult)esd->SetMultiplicity(mult);
2908   */
2909   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2910     if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2911   }
2912   delete vertex;
2913
2914   delete vertexer;
2915
2916   return kTRUE;
2917 }
2918
2919 //_____________________________________________________________________________
2920 Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
2921 {
2922   // run the trackleter for multiplicity study
2923
2924   AliCodeTimerAuto("",0)
2925
2926   AliTrackleter *trackleter = CreateMultFinder();
2927   if (!trackleter) return kFALSE;
2928
2929   AliInfo(Form("running the ITS multiplicity finder: %s",trackleter->ClassName()));
2930
2931   if (fLoader[0]) {
2932     fLoader[0]->LoadRecPoints();
2933     TTree* cltree = fLoader[0]->TreeR();
2934     if (cltree) {
2935       trackleter->Reconstruct(esd,cltree);
2936       AliMultiplicity *mult = trackleter->GetMultiplicity();
2937       if(mult) esd->SetMultiplicity(mult);
2938     }
2939     else {
2940       AliError("Can't get the ITS cluster tree");
2941     }
2942     fLoader[0]->UnloadRecPoints();
2943   }
2944   else {
2945     AliError("Can't get the ITS loader");
2946   }
2947
2948   delete trackleter;
2949
2950   return kTRUE;
2951 }
2952
2953 //_____________________________________________________________________________
2954 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2955 {
2956 // run the muon spectrometer tracking
2957
2958   AliCodeTimerAuto("",0)
2959
2960   if (!fRunLoader) {
2961     AliError("Missing runLoader!");
2962     return kFALSE;
2963   }
2964   Int_t iDet =  GetDetIndex("MUON"); // for MUON
2965
2966   // Get a pointer to the MUON reconstructor
2967   AliReconstructor *reconstructor = GetReconstructor(iDet);
2968   if (!reconstructor) return kFALSE;
2969
2970
2971   TString detName = fgkDetectorName[iDet];
2972   AliDebug(1, Form("%s tracking", detName.Data()));
2973   AliTracker *tracker =  reconstructor->CreateTracker();
2974   if (!tracker) {
2975     AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2976     return kFALSE;
2977   }
2978
2979   // read RecPoints
2980   fLoader[iDet]->LoadRecPoints("read");
2981
2982   tracker->LoadClusters(fLoader[iDet]->TreeR());
2983
2984   Int_t rv = tracker->Clusters2Tracks(esd);
2985
2986   fLoader[iDet]->UnloadRecPoints();
2987
2988   tracker->UnloadClusters();
2989
2990   if ( rv )
2991   {
2992     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2993     return kFALSE;
2994   }
2995
2996   return kTRUE;
2997 }
2998
2999
3000 //_____________________________________________________________________________
3001 Bool_t AliReconstruction::RunMFTTrackingMU(AliESDEvent*& esd) {
3002
3003   // AU
3004
3005   // run the global muon tracking: matching the MUON tracks with the MFT clusters
3006
3007   AliCodeTimerAuto("",0)
3008
3009   if (!fRunLoader) {
3010     AliError("Missing runLoader!");
3011     return kFALSE;
3012   }
3013   Int_t iDet = GetDetIndex("MFT"); // for MFT
3014
3015   // Get a pointer to the MFT reconstructor
3016   AliReconstructor *reconstructor = GetReconstructor(iDet);
3017   if (!reconstructor) return kFALSE;
3018
3019   TString detName = fgkDetectorName[iDet];
3020   AliDebug(1, Form("%s tracking for muon tracks", detName.Data()));
3021   AliTracker *tracker = reconstructor->CreateTracker();
3022   if (!tracker) {
3023     AliWarning(Form("couldn't create a Muon tracker for %s", detName.Data()));
3024     return kFALSE;
3025   }
3026
3027   // read RecPoints
3028   fLoader[iDet]->LoadRecPoints("read");
3029
3030   tracker->LoadClusters(fLoader[iDet]->TreeR());
3031
3032   Int_t rv = tracker->Clusters2Tracks(esd);
3033
3034   fLoader[iDet]->UnloadRecPoints();
3035
3036   tracker->UnloadClusters();
3037
3038   if (rv) {
3039     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
3040     return kFALSE;
3041   }
3042
3043   return kTRUE;
3044
3045 }
3046
3047 //_____________________________________________________________________________
3048 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
3049 {
3050 // run the barrel tracking
3051   static Int_t eventNr=0;
3052   AliCodeTimerAuto("",0)
3053
3054   AliInfo("running tracking");
3055
3056   // Set the event info which is used
3057   // by the trackers in order to obtain
3058   // information about read-out detectors,
3059   // trigger etc.
3060   AliDebug(1, "Setting event info");
3061   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3062     if (!fTracker[iDet]) continue;
3063     fTracker[iDet]->SetEventInfo(&fEventInfo);
3064   }
3065
3066   //Fill the ESD with the T0 info (will be used by the TOF)
3067   if (fReconstructor[11] && fLoader[11]) {
3068     fLoader[11]->LoadRecPoints("READ");
3069     TTree *treeR = fLoader[11]->TreeR();
3070     if (treeR) {
3071       GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
3072     }
3073   }
3074
3075   // pass 1: TPC + ITS inwards
3076   for (Int_t iDet = 1; iDet >= 0; iDet--) {
3077     if (!fTracker[iDet]) continue;
3078     AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
3079
3080     // load clusters
3081     fLoader[iDet]->LoadRecPoints("read");
3082     AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
3083     TTree* tree = fLoader[iDet]->TreeR();
3084     if (!tree) {
3085       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
3086       return kFALSE;
3087     }
3088     fTracker[iDet]->LoadClusters(tree);
3089     AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
3090     // run tracking
3091     if (fTracker[iDet]->Clusters2TracksHLT(esd, fhltesd) != 0) {
3092       AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
3093       return kFALSE;
3094     }
3095     AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
3096     // preliminary PID in TPC needed by the ITS tracker
3097     if (iDet == 1) {
3098       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
3099       PID.MakePIDForTracking(esd);
3100       AliSysInfo::AddStamp(Form("MakePID0%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
3101     }
3102   }
3103
3104   // pass 2: ALL backwards
3105
3106   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3107     if (!fTracker[iDet]) continue;
3108     AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
3109
3110     // load clusters
3111     if (iDet > 1) {     // all except ITS, TPC
3112       TTree* tree = NULL;
3113       fLoader[iDet]->LoadRecPoints("read");
3114       AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
3115       tree = fLoader[iDet]->TreeR();
3116       if (!tree) {
3117         AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
3118         return kFALSE;
3119       }
3120       fTracker[iDet]->LoadClusters(tree);
3121       AliSysInfo::AddStamp(Form("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
3122     }
3123
3124     // run tracking
3125     if (iDet>1) // start filling residuals for the "outer" detectors
3126       if (fRunGlobalQA) {
3127         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
3128         TObjArray ** arr = AliTracker::GetResidualsArray() ;
3129         if (arr) {
3130           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
3131           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
3132           if ( elem && (! elem->At(0)) ) {
3133             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
3134             if (qadm) qadm->InitRecPointsForTracker() ;
3135           }
3136         }
3137         //      AliSysInfo::AddStamp(Form("QAInitResid%s_%d",fgkDetectorName[iDet],eventNr), iDet,0, eventNr);
3138       }
3139     if (fTracker[iDet]->PropagateBack(esd) != 0) {
3140       AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
3141       //      return kFALSE;
3142     }
3143     AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3144
3145     // unload clusters
3146     if (iDet > 3) {     // all except ITS, TPC, TRD and TOF
3147       fTracker[iDet]->UnloadClusters();
3148       fLoader[iDet]->UnloadRecPoints();
3149     }
3150     // updated PID in TPC needed by the ITS tracker -MI
3151     if (iDet == 1) {
3152       //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
3153       //AliESDpid::MakePID(esd);
3154       PID.MakePIDForTracking(esd);
3155       AliSysInfo::AddStamp(Form("MakePID1%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
3156     }
3157
3158   }
3159   //stop filling residuals for the "outer" detectors
3160   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
3161
3162   // pass 3: TRD + TPC + ITS refit inwards
3163
3164   for (Int_t iDet = 2; iDet >= 0; iDet--) {
3165     if (!fTracker[iDet]) continue;
3166     AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
3167
3168     // run tracking
3169     if (iDet<2) // start filling residuals for TPC and ITS
3170       if (fRunGlobalQA) {
3171         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
3172         TObjArray ** arr = AliTracker::GetResidualsArray() ;
3173         if (arr) {
3174           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
3175           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
3176           if ( elem && (! elem->At(0)) ) {
3177             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
3178             if (qadm) qadm->InitRecPointsForTracker() ;
3179           }
3180         }
3181       }
3182
3183     if (fTracker[iDet]->RefitInward(esd) != 0) {
3184       AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
3185       //      return kFALSE;
3186     }
3187     // run postprocessing
3188     if (fTracker[iDet]->PostProcess(esd) != 0) {
3189       AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
3190       //      return kFALSE;
3191     }
3192     AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
3193   }
3194
3195   // write space-points to the ESD in case alignment data output
3196   // is switched on
3197   if (fWriteAlignmentData) {
3198     WriteAlignmentData(esd);
3199     AliSysInfo::AddStamp(Form("WrtAlignData_%d",eventNr), 0,0, eventNr);
3200   }
3201
3202   for (Int_t iDet = 3; iDet >= 0; iDet--) {
3203     if (!fTracker[iDet]) continue;
3204     // unload clusters
3205     fTracker[iDet]->UnloadClusters();
3206     AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
3207     fLoader[iDet]->UnloadRecPoints();
3208     AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
3209   }
3210   // stop filling residuals for TPC and ITS
3211   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
3212
3213   eventNr++;
3214   return kTRUE;
3215 }
3216
3217 //_____________________________________________________________________________
3218 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
3219   //
3220   // Remove the data which are not needed for the physics analysis.
3221   //
3222
3223   Int_t nTracks=esd->GetNumberOfTracks();
3224   Int_t nV0s=esd->GetNumberOfV0s();
3225   AliInfo
3226   (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
3227
3228   Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
3229   Bool_t rc=esd->Clean(cleanPars);
3230
3231   nTracks=esd->GetNumberOfTracks();
3232   nV0s=esd->GetNumberOfV0s();
3233   AliInfo
3234   (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
3235
3236   return rc;
3237 }
3238
3239 //_____________________________________________________________________________
3240 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
3241 {
3242 // fill the event summary data
3243
3244   AliCodeTimerAuto("",0)
3245     static Int_t eventNr=0;
3246   TString detStr = detectors;
3247
3248   AliSysInfo::AddStamp(Form("FillESDb%d",eventNr), -19,-19, eventNr);
3249   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3250   if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3251     AliReconstructor* reconstructor = GetReconstructor(iDet);
3252     if (!reconstructor) continue;
3253     AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
3254     TTree* clustersTree = NULL;
3255     if (fLoader[iDet]) {
3256       fLoader[iDet]->LoadRecPoints("read");
3257       clustersTree = fLoader[iDet]->TreeR();
3258       if (!clustersTree) {
3259         AliError(Form("Can't get the %s clusters tree",
3260                       fgkDetectorName[iDet]));
3261         if (fStopOnError) return kFALSE;
3262       }
3263     }
3264     if (fRawReader && !reconstructor->HasDigitConversion()) {
3265       reconstructor->FillESD(fRawReader, clustersTree, esd);
3266     } else {
3267       TTree* digitsTree = NULL;
3268       if (fLoader[iDet]) {
3269         fLoader[iDet]->LoadDigits("read");
3270         digitsTree = fLoader[iDet]->TreeD();
3271         if (!digitsTree) {
3272           AliError(Form("Can't get the %s digits tree",
3273                         fgkDetectorName[iDet]));
3274           if (fStopOnError) return kFALSE;
3275         }
3276       }
3277       reconstructor->FillESD(digitsTree, clustersTree, esd);
3278       if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
3279     }
3280     if (fLoader[iDet]) {
3281       fLoader[iDet]->UnloadRecPoints();
3282     }
3283   }
3284
3285   if (!IsSelected("CTP", detStr)) AliDebug(10,"No CTP");
3286   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
3287     AliError(Form("the following detectors were not found: %s",
3288                   detStr.Data()));
3289     if (fStopOnError) return kFALSE;
3290   }
3291   AliSysInfo::AddStamp(Form("FillESDe%d",eventNr), -20,-20, eventNr);
3292   eventNr++;
3293   return kTRUE;
3294 }
3295
3296 //_____________________________________________________________________________
3297 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
3298 {
3299   // Reads the trigger decision which is
3300   // stored in Trigger.root file and fills
3301   // the corresponding esd entries
3302
3303   AliCodeTimerAuto("",0)
3304
3305   AliInfo("Filling trigger information into the ESD");
3306
3307   if (fRawReader) {
3308     AliCTPRawStream input(fRawReader);
3309     if (!input.Next()) {
3310       AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
3311     }
3312     else {
3313       if (esd->GetTriggerMask() != input.GetClassMask())
3314         AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
3315                       input.GetClassMask(),esd->GetTriggerMask()));
3316       if (esd->GetOrbitNumber() != input.GetOrbitID())
3317         AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
3318                       input.GetOrbitID(),esd->GetOrbitNumber()));
3319       if (esd->GetBunchCrossNumber() != input.GetBCID())
3320         AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
3321                       input.GetBCID(),esd->GetBunchCrossNumber()));
3322       AliESDHeader* esdheader = esd->GetHeader();
3323       esdheader->SetL0TriggerInputs(input.GetL0Inputs());
3324       esdheader->SetL1TriggerInputs(input.GetL1Inputs());
3325       esdheader->SetL2TriggerInputs(input.GetL2Inputs());
3326       // IR
3327       //      UInt_t orbit=input.GetOrbitID();
3328       for(Int_t i=0 ; i<input.GetNIRs() ; i++ ) {
3329         esdheader->AddTriggerIR(input.GetIR(i));
3330       }
3331        AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
3332        if (rlCTP) {
3333          rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
3334          rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
3335          rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
3336        }
3337     }
3338     if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
3339   }
3340   return kTRUE;
3341 }
3342 //_____________________________________________________________________________
3343 Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
3344 {
3345   //Scalers
3346   //fRunScalers->Print();
3347   if(fRunScalers && fRunScalers->CheckRunScalers()){
3348      AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
3349      //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
3350      AliESDHeader* esdheader = fesd->GetHeader();
3351      for(Int_t i=0;i<50;i++){
3352           if((1ull<<i) & esd->GetTriggerMask()){
3353           AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
3354           if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
3355         }
3356      }
3357      const AliTriggerScalersRecordESD* scalrecEvent = fRunScalers->GetScalersDeltaForEvent( timestamp);
3358      const AliTriggerScalersRecordESD* scalrecRun = fRunScalers->GetScalersDeltaForRun();
3359      if (scalrecEvent) esdheader->SetTriggerScalersDeltaEvent(scalrecEvent);
3360      if (scalrecRun) esdheader->SetTriggerScalersDeltaRun(scalrecRun);
3361   }
3362   return kTRUE;
3363 }
3364 //_____________________________________________________________________________
3365 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
3366 {
3367   //
3368   // Filling information from RawReader Header
3369   //
3370
3371   if (!fRawReader) return kFALSE;
3372
3373   AliInfo("Filling information from RawReader Header");
3374
3375   esd->SetBunchCrossNumber(fRawReader->GetBCID());
3376   esd->SetOrbitNumber(fRawReader->GetOrbitID());
3377   esd->SetPeriodNumber(fRawReader->GetPeriod());
3378
3379   esd->SetTimeStamp(fRawReader->GetTimestamp());
3380   esd->SetEventType(fRawReader->GetType());
3381
3382   return kTRUE;
3383 }
3384
3385
3386 //_____________________________________________________________________________
3387 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
3388 {
3389 // check whether detName is contained in detectors
3390 // if yes, it is removed from detectors
3391
3392   // check if all detectors are selected
3393   if ((detectors.CompareTo("ALL") == 0) ||
3394       detectors.BeginsWith("ALL ") ||
3395       detectors.EndsWith(" ALL") ||
3396       detectors.Contains(" ALL ")) {
3397     detectors = "ALL";
3398     return kTRUE;
3399   }
3400
3401   // search for the given detector
3402   Bool_t result = kFALSE;
3403   if ((detectors.CompareTo(detName) == 0) ||
3404       detectors.BeginsWith(detName+" ") ||
3405       detectors.EndsWith(" "+detName) ||
3406       detectors.Contains(" "+detName+" ")) {
3407     detectors.ReplaceAll(detName, "");
3408     result = kTRUE;
3409   }
3410
3411   // clean up the detectors string
3412   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
3413   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
3414   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
3415
3416   return result;
3417 }
3418
3419 //_____________________________________________________________________________
3420 Bool_t AliReconstruction::InitRunLoader()
3421 {
3422 // get or create the run loader
3423
3424   if (gAlice) delete gAlice;
3425   gAlice = NULL;
3426
3427   TFile *gafile = TFile::Open(fGAliceFileName.Data());
3428   //  if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
3429   if (gafile) { // galice.root exists
3430     gafile->Close();
3431     delete gafile;
3432
3433     // load all base libraries to get the loader classes
3434     TString libs = gSystem->GetLibraries();
3435     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3436       TString detName = fgkDetectorName[iDet];
3437       if (libs.Contains("lib" + detName + "base.so")) continue;
3438       gSystem->Load("lib" + detName + "base.so");
3439     }
3440     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
3441     if (!fRunLoader) {
3442       AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
3443       CleanUp();
3444       return kFALSE;
3445     }
3446
3447     fRunLoader->CdGAFile();
3448     fRunLoader->LoadgAlice();
3449
3450     //PH This is a temporary fix to give access to the kinematics
3451     //PH that is needed for the labels of ITS clusters
3452     fRunLoader->LoadHeader();
3453     fRunLoader->LoadKinematics();
3454
3455   } else {               // galice.root does not exist
3456     if (!fRawReader) {
3457       AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
3458     }
3459     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
3460                                     AliConfig::GetDefaultEventFolderName(),
3461                                     "recreate");
3462     if (!fRunLoader) {
3463       AliError(Form("could not create run loader in file %s",
3464                     fGAliceFileName.Data()));
3465       CleanUp();
3466       return kFALSE;
3467     }
3468     fIsNewRunLoader = kTRUE;
3469     fRunLoader->MakeTree("E");
3470     fRunLoader->MakeTree("GG");
3471
3472     if (fNumberOfEventsPerFile > 0)
3473       fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
3474     else
3475       fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
3476   }
3477
3478   return kTRUE;
3479 }
3480
3481 //_____________________________________________________________________________
3482 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
3483 {
3484 // get the reconstructor object and the loader for a detector
3485
3486   if (fReconstructor[iDet]) {
3487     if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3488       const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3489       fReconstructor[iDet]->SetRecoParam(par);
3490       fReconstructor[iDet]->SetRunInfo(fRunInfo);
3491     }
3492     return fReconstructor[iDet];
3493   }
3494
3495   // load the reconstructor object
3496   TPluginManager* pluginManager = gROOT->GetPluginManager();
3497   TString detName = fgkDetectorName[iDet];
3498   TString recName = "Ali" + detName + "Reconstructor";
3499
3500   if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
3501
3502   AliReconstructor* reconstructor = NULL;
3503   // first check if a plugin is defined for the reconstructor
3504   TPluginHandler* pluginHandler =
3505     pluginManager->FindHandler("AliReconstructor", detName);
3506   // if not, add a plugin for it
3507   if (!pluginHandler) {
3508     AliDebug(1, Form("defining plugin for %s", recName.Data()));
3509     TString libs = gSystem->GetLibraries();
3510     if (libs.Contains("lib" + detName + "base.so") ||
3511         (gSystem->Load("lib" + detName + "base.so") >= 0)) {
3512       pluginManager->AddHandler("AliReconstructor", detName,
3513                                 recName, detName + "rec", recName + "()");
3514     } else {
3515       pluginManager->AddHandler("AliReconstructor", detName,
3516                                 recName, detName, recName + "()");
3517     }
3518     pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
3519   }
3520   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3521     reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
3522   }
3523
3524    // check if the upgrade reconstructor should be used instead of the standard one
3525   if(fUpgradeMask[iDet]) {
3526     if(reconstructor) delete reconstructor;
3527     TClass *cl = new TClass(Form("Ali%sUpgradeReconstructor",fgkDetectorName[iDet]));
3528     reconstructor = (AliReconstructor*)(cl->New());
3529    }
3530
3531   if (reconstructor) {
3532     TObject* obj = fOptions.FindObject(detName.Data());
3533     if (obj) reconstructor->SetOption(obj->GetTitle());
3534     reconstructor->SetRunInfo(fRunInfo);
3535     reconstructor->SetHLTESD(fhltesd);
3536     reconstructor->Init();
3537     fReconstructor[iDet] = reconstructor;
3538   }
3539
3540   // get or create the loader
3541   if (detName != "HLT") {
3542     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
3543     if (!fLoader[iDet]) {
3544       AliConfig::Instance()
3545         ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
3546                                 detName, detName);
3547       // first check if a plugin is defined for the loader
3548       pluginHandler =
3549         pluginManager->FindHandler("AliLoader", detName);
3550       // if not, add a plugin for it
3551       if (!pluginHandler) {
3552         TString loaderName = "Ali" + detName + "Loader";
3553         AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
3554         pluginManager->AddHandler("AliLoader", detName,
3555                                   loaderName, detName + "base",
3556                                   loaderName + "(const char*, TFolder*)");
3557         pluginHandler = pluginManager->FindHandler("AliLoader", detName);
3558       }
3559       if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
3560         fLoader[iDet] =
3561           (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
3562                                                  fRunLoader->GetEventFolder());
3563       }
3564       if (!fLoader[iDet]) {   // use default loader
3565         fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
3566       }
3567       if (!fLoader[iDet]) {
3568         AliWarning(Form("couldn't get loader for %s", detName.Data()));
3569         if (fStopOnError) return NULL;
3570       } else {
3571         fRunLoader->AddLoader(fLoader[iDet]);
3572         fRunLoader->CdGAFile();
3573         if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
3574         fRunLoader->Write(0, TObject::kOverwrite);
3575       }
3576     }
3577   }
3578
3579   if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
3580     const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
3581     if (reconstructor) {
3582       reconstructor->SetRecoParam(par);
3583       reconstructor->SetRunInfo(fRunInfo);
3584     }
3585   }
3586   return reconstructor;
3587 }
3588
3589 //_____________________________________________________________________________
3590 AliVertexer* AliReconstruction::CreateVertexer()
3591 {
3592 // create the vertexer
3593 // Please note that the caller is the owner of the
3594 // vertexer
3595
3596   AliVertexer* vertexer = NULL;
3597   AliReconstructor* itsReconstructor = GetReconstructor(0);
3598   if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3599                            fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3600     vertexer = itsReconstructor->CreateVertexer();
3601   }
3602   if (!vertexer) {
3603     AliWarning("couldn't create a vertexer for ITS");
3604   }
3605
3606   return vertexer;
3607 }
3608
3609 //_____________________________________________________________________________
3610 AliTrackleter* AliReconstruction::CreateMultFinder()
3611 {
3612 // create the ITS trackleter for mult. estimation
3613 // Please note that the caller is the owner of the
3614 // trackleter
3615
3616   AliTrackleter* trackleter = NULL;
3617   AliReconstructor* itsReconstructor = GetReconstructor(0);
3618   if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) ||
3619                            fRunTracking.Contains("ITS") || fFillESD.Contains("ITS") )) {
3620     trackleter = itsReconstructor->CreateMultFinder();
3621   }
3622   else {
3623     AliWarning("ITS is not in reconstruction, switching off RunMultFinder");
3624     fRunMultFinder = kFALSE;
3625   }
3626
3627   return trackleter;
3628 }
3629
3630 //_____________________________________________________________________________
3631 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
3632 {
3633 // create the trackers
3634         AliInfo("Creating trackers");
3635
3636   TString detStr = detectors;
3637   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3638     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3639     AliReconstructor* reconstructor = GetReconstructor(iDet);
3640     if (!reconstructor) continue;
3641     TString detName = fgkDetectorName[iDet];
3642     if (detName == "MUON") {
3643       fRunMuonTracking = kTRUE;
3644       continue;
3645     }
3646     if (detName == "MFT") {           // AU
3647       fRunMFTTrackingMU = kTRUE;      // AU
3648       continue;                       // AU
3649     }                                 // AU
3650
3651     fTracker[iDet] = reconstructor->CreateTracker();
3652     if (!fTracker[iDet] && (iDet < 7)) {
3653       AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
3654       if (fStopOnError) return kFALSE;
3655     }
3656     AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
3657   }
3658
3659   return kTRUE;
3660 }
3661
3662 //_____________________________________________________________________________
3663 void AliReconstruction::CleanUp()
3664 {
3665 // delete trackers and the run loader and close and delete the file
3666   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3667     delete fReconstructor[iDet];
3668     fReconstructor[iDet] = NULL;
3669     fLoader[iDet] = NULL;
3670     delete fTracker[iDet];
3671     fTracker[iDet] = NULL;
3672   }
3673
3674   delete fRunInfo;
3675   fRunInfo = NULL;
3676
3677   delete fSPDTrackleter;
3678   fSPDTrackleter = NULL;
3679
3680   delete ftVertexer;
3681   ftVertexer = NULL;
3682
3683   delete fRunLoader;
3684   fRunLoader = NULL;
3685   delete fRawReader;
3686   fRawReader = NULL;
3687   delete fParentRawReader;
3688   fParentRawReader=NULL;
3689
3690   delete fESDpid;
3691   fESDpid = NULL;
3692
3693   if (ffile) {
3694     ffile->Close();
3695     delete ffile;
3696     ffile = NULL;
3697   }
3698
3699   if (AliQAManager::QAManager())
3700     AliQAManager::QAManager()->ShowQA() ;
3701   //  AliQAManager::Destroy() ;
3702   delete fAnalysis;
3703   fAnalysis = NULL;
3704 }
3705
3706 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
3707 {
3708   // Write space-points which are then used in the alignment procedures
3709   // For the moment only ITS, TPC, TRD and TOF
3710
3711   Int_t ntracks = esd->GetNumberOfTracks();
3712   for (Int_t itrack = 0; itrack < ntracks; itrack++)
3713     {
3714       AliESDtrack *track = esd->GetTrack(itrack);
3715       Int_t nsp = 0;
3716       Int_t idx[200];
3717       for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
3718       for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
3719           nsp += (iDet==GetDetIndex("TRD")) ? track->GetTRDntracklets():track->GetNcls(iDet);
3720
3721           if (iDet==GetDetIndex("ITS")) { // ITS "extra" clusters
3722              track->GetClusters(iDet,idx);
3723              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
3724           }
3725       }
3726
3727       if (nsp) {
3728         AliTrackPointArray *sp = new AliTrackPointArray(nsp);
3729         track->SetTrackPointArray(sp);
3730         Int_t isptrack = 0;
3731         for (Int_t iDet = 5; iDet >= 0; iDet--) {
3732           AliTracker *tracker = fTracker[iDet];
3733           if (!tracker) continue;
3734           Int_t nspdet = (iDet==GetDetIndex("TRD")) ? track->GetTRDtracklets(idx):track->GetClusters(iDet,idx);
3735
3736           if (iDet==GetDetIndex("ITS")) // ITS "extra" clusters
3737              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
3738
3739           if (nspdet <= 0) continue;
3740           AliTrackPoint p;
3741           Int_t isp = 0;
3742           Int_t isp2 = 0;
3743           while (isp2 < nspdet) {
3744             Bool_t isvalid=kTRUE;
3745
3746             Int_t index=idx[isp++];
3747             if (index < 0) continue;
3748
3749             TString dets = fgkDetectorName[iDet];
3750             if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
3751             fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
3752             fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
3753             fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
3754               isvalid = tracker->GetTrackPointTrackingError(index,p,track);
3755             } else {
3756               isvalid = tracker->GetTrackPoint(index,p);
3757             }
3758             isp2++;
3759             if (!isvalid) continue;
3760             if (iDet==GetDetIndex("ITS") && (isp-1)>=6) p.SetExtra();
3761             sp->AddPoint(isptrack,&p); isptrack++;
3762           }
3763         }
3764       }
3765     }
3766 }
3767
3768 //_____________________________________________________________________________
3769 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
3770 {
3771   // The method reads the raw-data error log
3772   // accumulated within the rawReader.
3773   // It extracts the raw-data errors related to
3774   // the current event and stores them into
3775   // a TClonesArray inside the esd object.
3776
3777   if (!fRawReader) return;
3778
3779   for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3780
3781     AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3782     if (!log) continue;
3783     if (iEvent != log->GetEventNumber()) continue;
3784
3785     esd->AddRawDataErrorLog(log);
3786   }
3787
3788 }
3789
3790 //_____________________________________________________________________________
3791 // void AliReconstruction::CheckQA()
3792 // {
3793 // check the QA of SIM for this run and remove the detectors
3794 // with status Fatal
3795
3796 //      TString newRunLocalReconstruction ;
3797 //      TString newRunTracking ;
3798 //      TString newFillESD ;
3799 //
3800 //      for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3801 //              TString detName(AliQAv1::GetDetName(iDet)) ;
3802 //              AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
3803 //      if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
3804 //        AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS  and/or Digits was Fatal; No reconstruction performed",
3805 //                   detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3806 //                      } else {
3807 //                      if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
3808 //                                      fRunLocalReconstruction.Contains("ALL") )  {
3809 //                              newRunLocalReconstruction += detName ;
3810 //                              newRunLocalReconstruction += " " ;
3811 //                      }
3812 //                      if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
3813 //                                      fRunTracking.Contains("ALL") )  {
3814 //                              newRunTracking += detName ;
3815 //                              newRunTracking += " " ;
3816 //                      }
3817 //                      if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
3818 //                                      fFillESD.Contains("ALL") )  {
3819 //                              newFillESD += detName ;
3820 //                              newFillESD += " " ;
3821 //                      }
3822 //              }
3823 //      }
3824 //      fRunLocalReconstruction = newRunLocalReconstruction ;
3825 //      fRunTracking            = newRunTracking ;
3826 //      fFillESD                = newFillESD ;
3827 // }
3828
3829 //_____________________________________________________________________________
3830 Int_t AliReconstruction::GetDetIndex(const char* detector)
3831 {
3832   // return the detector index corresponding to detector
3833   Int_t index = -1 ;
3834   for (index = 0; index < kNDetectors ; index++) {
3835     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3836         break ;
3837   }
3838   return index ;
3839 }
3840 //_____________________________________________________________________________
3841 Bool_t AliReconstruction::FinishPlaneEff() {
3842  //
3843  // Here execute all the necessary operationis, at the end of the tracking phase,
3844  // in case that evaluation of PlaneEfficiencies was required for some detector.
3845  // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
3846  //
3847  // This Preliminary version works only FOR ITS !!!!!
3848  // other detectors (TOF,TRD, etc. have to develop their specific codes)
3849  //
3850  //  Input: none
3851  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
3852  //
3853  Bool_t ret=kFALSE;
3854  TString detStr = fLoadCDB;
3855  //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
3856  for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
3857    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3858    if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
3859       AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3860       TString name=planeeff->GetName();
3861       name+=".root";
3862       TFile* pefile = TFile::Open(name, "RECREATE");
3863       ret=(Bool_t)planeeff->Write();
3864       pefile->Close();
3865       if(planeeff->GetCreateHistos()) {
3866         TString hname=planeeff->GetName();
3867         hname+="Histo.root";
3868         ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
3869       }
3870    }
3871    if(fSPDTrackleter) {
3872      AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3873       TString name="AliITSPlaneEffSPDtracklet.root";
3874       TFile* pefile = TFile::Open(name, "RECREATE");
3875       ret=(Bool_t)planeeff->Write();
3876       pefile->Close();
3877       AliESDEvent *dummy=NULL;
3878       ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3879    }
3880  }
3881  return ret;
3882 }
3883 //_____________________________________________________________________________
3884 Bool_t AliReconstruction::InitPlaneEff() {
3885 //
3886  // Here execute all the necessary operations, before of the tracking phase,
3887  // for the evaluation of PlaneEfficiencies, in case required for some detectors.
3888  // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
3889  // which should be updated/recalculated.
3890  //
3891  // This Preliminary version will work only FOR ITS !!!!!
3892  // other detectors (TOF,TRD, etc. have to develop their specific codes)
3893  //
3894  //  Input: none
3895  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
3896  //
3897
3898   fSPDTrackleter = NULL;
3899   TString detStr = fLoadCDB;
3900   if (IsSelected(fgkDetectorName[0], detStr)) {
3901     AliReconstructor* itsReconstructor = GetReconstructor(0);
3902     if (itsReconstructor) {
3903       fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3904     }
3905     if (fSPDTrackleter) {
3906       AliInfo("Trackleter for SPD has been created");
3907     }
3908   }
3909  return kTRUE;
3910 }
3911
3912 //_____________________________________________________________________________
3913 Bool_t AliReconstruction::InitAliEVE()
3914 {
3915   // This method should be called only in case
3916   // AliReconstruction is run
3917   // within the alieve environment.
3918   // It will initialize AliEVE in a way
3919   // so that it can visualize event processed
3920   // by AliReconstruction.
3921   // The return flag shows whenever the
3922   // AliEVE initialization was successful or not.
3923
3924   TString macroStr(getenv("ALIEVE_ONLINE_MACRO"));
3925
3926   if (macroStr.IsNull())
3927     macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3928
3929   AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3930
3931   if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3932
3933   gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
3934   gROOT->ProcessLine("alieve_online_init()");
3935
3936   return kTRUE;
3937 }
3938
3939 //_____________________________________________________________________________
3940 void AliReconstruction::RunAliEVE()
3941 {
3942   // Runs AliEVE visualisation of
3943   // the current event.
3944   // Should be executed only after
3945   // successful initialization of AliEVE.
3946
3947   AliInfo("Running AliEVE...");
3948   gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)%p,(AliRawReader*)%p,(AliESDEvent*)%p,(AliESDfriend*)%p);",fRunLoader,fRawReader,fesd,fesdf));
3949   gSystem->Run();
3950 }
3951
3952 //_____________________________________________________________________________
3953 Bool_t AliReconstruction::SetRunQA(TString detAndAction)
3954 {
3955         // Allows to run QA for a selected set of detectors
3956         // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
3957         // all selected detectors run the same selected tasks
3958
3959         if (!detAndAction.Contains(":")) {
3960                 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3961                 fRunQA = kFALSE ;
3962                 return kFALSE ;
3963         }
3964         Int_t colon = detAndAction.Index(":") ;
3965         fQADetectors = detAndAction(0, colon) ;
3966         fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ;
3967         if (fQATasks.Contains("ALL") ) {
3968                 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
3969         } else {
3970                 fQATasks.ToUpper() ;
3971                 TString tempo("") ;
3972                 if ( fQATasks.Contains("RAW") )
3973                         tempo = Form("%d ", AliQAv1::kRAWS) ;
3974                 if ( fQATasks.Contains("DIGIT") )
3975                         tempo += Form("%d ", AliQAv1::kDIGITSR) ;
3976                 if ( fQATasks.Contains("RECPOINT") )
3977                         tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
3978                 if ( fQATasks.Contains("ESD") )
3979                         tempo += Form("%d ", AliQAv1::kESDS) ;
3980                 fQATasks = tempo ;
3981                 if (fQATasks.IsNull()) {
3982                         AliInfo("No QA requested\n")  ;
3983                         fRunQA = kFALSE ;
3984                         return kTRUE ;
3985                 }
3986         }
3987         TString tempo(fQATasks) ;
3988         tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS))      ;
3989         tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
3990         tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
3991         tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
3992         AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
3993         fRunQA = kTRUE ;
3994         return kTRUE;
3995 }
3996
3997 //_____________________________________________________________________________
3998 Bool_t AliReconstruction::InitRecoParams()
3999 {
4000   // The method accesses OCDB and retrieves all
4001   // the available reco-param objects from there.
4002
4003   Bool_t isOK = kTRUE;
4004
4005   if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
4006     AliInfo("Using custom GRP reconstruction parameters");
4007   }
4008   else {
4009     AliInfo("Loading GRP reconstruction parameter objects");
4010
4011     AliCDBPath path("GRP","Calib","RecoParam");
4012     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
4013     if(!entry){
4014       AliWarning("Couldn't find GRP RecoParam entry in OCDB");
4015       isOK = kFALSE;
4016     }
4017     else {
4018       TObject *recoParamObj = entry->GetObject();
4019       if (dynamic_cast<TObjArray*>(recoParamObj)) {
4020         // GRP has a normal TobjArray of AliDetectorRecoParam objects
4021         // Registering them in AliRecoParam
4022         fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
4023       }
4024       else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
4025         // GRP has only onse set of reco parameters
4026         // Registering it in AliRecoParam
4027         AliInfo("Single set of GRP reconstruction parameters found");
4028         dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
4029         fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
4030       }
4031       else {
4032         AliError("No valid GRP RecoParam object found in the OCDB");
4033         isOK = kFALSE;
4034       }
4035       entry->SetOwner(0);
4036     }
4037   }
4038
4039   TString detStr = fLoadCDB;
4040   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4041
4042     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
4043
4044     if (fRecoParam.GetDetRecoParamArray(iDet)) {
4045       AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
4046       continue;
4047     }
4048
4049     AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
4050
4051     AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
4052     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
4053     if(!entry){
4054       AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
4055       isOK = kFALSE;
4056     }
4057     else {
4058       TObject *recoParamObj = entry->GetObject();
4059       if (dynamic_cast<TObjArray*>(recoParamObj)) {
4060         // The detector has a normal TobjArray of AliDetectorRecoParam objects
4061         // Registering them in AliRecoParam
4062         fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
4063       }
4064       else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
4065         // The detector has only onse set of reco parameters
4066         // Registering it in AliRecoParam
4067         AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
4068         dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
4069         fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
4070       }
4071       else {
4072         AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
4073         isOK = kFALSE;
4074       }
4075       entry->SetOwner(0);
4076       //      FIX ME: We have to disable the unloading of reco-param CDB
4077       //      entries because QA framework is using them. Has to be fix in
4078       //      a way that the QA takes the objects already constructed in
4079       //      this method.
4080       //      AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
4081     }
4082   }
4083
4084   if (AliDebugLevel() > 0) fRecoParam.Print();
4085
4086   return isOK;
4087 }
4088
4089 //_____________________________________________________________________________
4090 Bool_t AliReconstruction::GetEventInfo()
4091 {
4092   // Fill the event info object
4093   // ...
4094   AliCodeTimerAuto("",0)
4095
4096   AliCentralTrigger *aCTP = NULL;
4097   if (fRawReader) {
4098     fEventInfo.SetEventType(fRawReader->GetType());
4099
4100     ULong64_t mask = fRawReader->GetClassMask();
4101     fEventInfo.SetTriggerMask(mask);
4102     UInt_t clmask = fRawReader->GetDetectorPattern()[0];
4103     fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
4104
4105     aCTP = new AliCentralTrigger();
4106     TString configstr("");
4107     if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
4108       AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
4109       delete aCTP;
4110       return kFALSE;
4111     }
4112     aCTP->SetClassMask(mask);
4113     aCTP->SetClusterMask(clmask);
4114
4115     if (fRunLoader) {
4116       AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
4117       if (rlCTP) {
4118         rlCTP->SetClassMask(mask);
4119         rlCTP->SetClusterMask(clmask);
4120       }
4121     }
4122   }
4123   else {
4124     fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
4125
4126     if (fRunLoader && (!fRunLoader->LoadTrigger())) {
4127       aCTP = fRunLoader->GetTrigger();
4128       fEventInfo.SetTriggerMask(aCTP->GetClassMask());
4129       // get inputs from actp - just get
4130       AliESDHeader* esdheader = fesd->GetHeader();
4131       esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
4132       esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
4133       esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
4134       fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
4135     }
4136     else {
4137       if (fStopOnMissingTriggerFile) AliFatal("No trigger can be loaded! Stopping reconstruction!");
4138       AliWarning("No trigger can be loaded! The trigger information will not be used!");
4139       return kFALSE;
4140     }
4141   }
4142
4143   AliTriggerConfiguration *config = aCTP->GetConfiguration();
4144   if (!config) {
4145     AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
4146     if (fRawReader) delete aCTP;
4147     return kFALSE;
4148   }
4149
4150   // Load trigger aliases and declare the trigger classes included in aliases
4151   //PH Why do we do it in each event and not only once in the beginning of the chunk??
4152   //PH Temporary fix for #99725: AliReconstruction::GetEventInfo bug
4153   fDeclTriggerClasses.Clear();
4154   AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
4155   if (entry) {
4156     THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
4157     if (lst) {
4158       lst->Sort(kSortDescending); // to avoid problems with substrungs
4159       if (fRawReader) fRawReader->LoadTriggerAlias(lst);
4160       // Now declare all the triggers present in the aliases
4161       TIter iter(lst);
4162       TNamed *nmd = 0;
4163       while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
4164         fDeclTriggerClasses += " ";
4165         fDeclTriggerClasses += nmd->GetName();
4166       }
4167     }
4168     else {
4169       AliError("Cannot cast the object with trigger aliases to THashList!");
4170     }
4171   }
4172   else {
4173     AliError("No OCDB ebtry for the trigger aliases!");
4174   }
4175   // Load trigger classes for this run
4176   UChar_t clustmask = 0;
4177   TString trclasses;
4178   ULong64_t trmask = fEventInfo.GetTriggerMask();
4179   const TObjArray& classesArray = config->GetClasses();
4180   Int_t nclasses = classesArray.GetEntriesFast();
4181   for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
4182     AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
4183     if (trclass && trclass->GetMask()>0) {
4184       Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
4185       if (fesd) fesd->SetTriggerClass(trclass->GetName(),trindex);
4186       if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
4187       if (trmask & (1ull << trindex)) {
4188         trclasses += " ";
4189         trclasses += trclass->GetName();
4190         trclasses += " ";
4191         clustmask |= trclass->GetCluster()->GetClusterMask();
4192       }
4193     }
4194   }
4195   fEventInfo.SetTriggerClasses(trclasses);
4196   // Now put the declared trigger classes (not present in the run)
4197   // to 0/false in the event selection
4198   if (!fDeclTriggerClasses.IsNull()) {
4199     TObjArray *tokens = fDeclTriggerClasses.Tokenize(" ");
4200     Int_t ntokens = tokens->GetEntriesFast();
4201     for (Int_t itoken = 0; itoken < ntokens; ++itoken) {
4202       if (fRawReader) fRawReader->LoadTriggerClass((((TObjString*)tokens->At(itoken))->String()).Data(),-1);
4203     }
4204     delete tokens;
4205   }
4206
4207   // Write names of active trigger inputs in ESD Header
4208   const TObjArray& inputsArray = config->GetInputs();
4209   Int_t ninputs = inputsArray.GetEntriesFast();
4210   for( Int_t iinput=0; iinput < ninputs; iinput++ ) {
4211     AliTriggerInput* trginput = (AliTriggerInput*)inputsArray.At(iinput);
4212     if (trginput && trginput->GetMask()>0) {
4213       Int_t inputIndex = (Int_t)TMath::Nint(TMath::Log2(trginput->GetMask()));
4214       AliESDHeader* headeresd = 0x0;
4215       if (fesd) headeresd = fesd->GetHeader();
4216       if (headeresd) {
4217         Int_t trglevel = (Int_t)trginput->GetLevel();
4218         if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
4219         if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
4220         if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
4221       }
4222     }
4223   }
4224
4225   // Set the information in ESD
4226   if (fesd) {
4227     fesd->SetTriggerMask(trmask);
4228     fesd->SetTriggerCluster(clustmask);
4229   }
4230
4231   if (!aCTP->CheckTriggeredDetectors()) {
4232     if (fRawReader) delete aCTP;
4233     return kFALSE;
4234   }
4235
4236   if (fRawReader) delete aCTP;
4237
4238   // We have to fill also the HLT decision here!!
4239   // ...
4240
4241   return kTRUE;
4242 }
4243
4244 const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
4245 {
4246   // Match the detector list found in the rec.C or the default 'ALL'
4247   // to the list found in the GRP (stored there by the shuttle PP which
4248   // gets the information from ECS)
4249   static TString resultList;
4250   TString detList = detectorList;
4251
4252   resultList = "";
4253
4254   for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
4255     if ((detectorMask >> iDet) & 0x1) {
4256       TString det = AliDAQ::OfflineModuleName(iDet);
4257       if ((detList.CompareTo("ALL") == 0) ||
4258           ((detList.BeginsWith("ALL ") ||
4259             detList.EndsWith(" ALL") ||
4260             detList.Contains(" ALL ")) &&
4261            !(detList.BeginsWith("-"+det+" ") ||
4262              detList.EndsWith(" -"+det) ||
4263              detList.Contains(" -"+det+" "))) ||
4264           (detList.CompareTo(det) == 0) ||
4265           detList.BeginsWith(det+" ") ||
4266           detList.EndsWith(" "+det) ||
4267           detList.Contains( " "+det+" " )) {
4268         if (!resultList.EndsWith(det + " ")) {
4269           resultList += det;
4270           resultList += " ";
4271         }
4272       }
4273     }
4274   }
4275
4276   // HLT
4277   if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
4278     TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
4279     if ((detList.CompareTo("ALL") == 0) ||
4280         ((detList.BeginsWith("ALL ") ||
4281           detList.EndsWith(" ALL") ||
4282           detList.Contains(" ALL ")) &&
4283          !(detList.BeginsWith("-"+hltDet+" ") ||
4284            detList.EndsWith(" -"+hltDet) ||
4285            detList.Contains(" -"+hltDet+" "))) ||
4286         (detList.CompareTo(hltDet) == 0) ||
4287         detList.BeginsWith(hltDet+" ") ||
4288         detList.EndsWith(" "+hltDet) ||
4289         detList.Contains( " "+hltDet+" " )) {
4290       resultList += hltDet;
4291     }
4292   }
4293
4294   return resultList.Data();
4295
4296 }
4297
4298 //______________________________________________________________________________
4299 void AliReconstruction::Abort(const char *method, EAbort what)
4300 {
4301   // Abort processing. If what = kAbortProcess, the Process() loop will be
4302   // aborted. If what = kAbortFile, the current file in a chain will be
4303   // aborted and the processing will continue with the next file, if there
4304   // is no next file then Process() will be aborted. Abort() can also  be
4305   // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
4306   // the SlaveTerminate() and Terminate() are always called. The abort flag
4307   // can be checked in these methods using GetAbort().
4308   //
4309   // The method is overwritten in AliReconstruction for better handling of
4310   // reco specific errors
4311
4312   if (!fStopOnError) return;
4313
4314   CleanUp();
4315
4316   TString whyMess = method;
4317   whyMess += " failed! Aborting...";
4318
4319   AliError(whyMess.Data());
4320
4321   fAbort = what;
4322   TString mess = "Abort";
4323   if (fAbort == kAbortProcess)
4324     mess = "AbortProcess";
4325   else if (fAbort == kAbortFile)
4326     mess = "AbortFile";
4327
4328   Info(mess.Data(), "%s", whyMess.Data());
4329 }
4330
4331 //______________________________________________________________________________
4332 Bool_t AliReconstruction::ProcessEvent(void* event)
4333 {
4334   // Method that is used in case the event loop
4335   // is steered from outside, for example by AMORE
4336   // 'event' is a pointer to the DATE event in the memory
4337
4338   if (fRawReader) delete fRawReader;
4339   fRawReader = new AliRawReaderDate(event);
4340   fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
4341   delete fRawReader;
4342   fRawReader = NULL;
4343
4344   return fStatus;
4345 }
4346
4347 //______________________________________________________________________________
4348 Bool_t AliReconstruction::ParseOutput()
4349 {
4350   // The method parses the output file
4351   // location string in order to steer
4352   // properly the selector
4353
4354   TPMERegexp re1("(\\w+\\.zip#\\w+\\.root):([,*\\w+\\.root,*]+)@dataset://(\\w++)");
4355   TPMERegexp re2("(\\w+\\.root)?@?dataset://(\\w++)");
4356
4357   if (re1.Match(fESDOutput) == 4) {
4358     // root archive with output files stored and regustered
4359     // in proof dataset
4360     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",re1[1].Data()));
4361     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re1[3].Data()));
4362     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4363     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_ARCHIVE",re1[2].Data()));
4364     AliInfo(Form("%s files will be stored within %s in dataset %s",
4365                  re1[2].Data(),
4366                  re1[1].Data(),
4367                  re1[3].Data()));
4368   }
4369   else if (re2.Match(fESDOutput) == 3) {
4370     // output file stored and registered
4371     // in proof dataset
4372     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",(re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data()));
4373     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re2[2].Data()));
4374     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
4375     AliInfo(Form("%s will be stored in dataset %s",
4376                  (re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data(),
4377                  re2[2].Data()));
4378   }
4379   else {
4380     if (fESDOutput.IsNull()) {
4381       // Output location not given.
4382       // Assuming xrootd has been already started and
4383       // the output file has to be sent back
4384       // to the client machine
4385       TString esdUrl(Form("root://%s/%s/",
4386                           TUrl(gSystem->HostName()).GetHostFQDN(),
4387                           gSystem->pwd()));
4388       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE","AliESDs.root"));
4389       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",esdUrl.Data()));
4390       AliInfo(Form("AliESDs.root will be stored in %s",
4391                    esdUrl.Data()));
4392     }
4393     else {
4394       // User specified an output location.
4395       // Ones has just to parse it here
4396       TUrl outputUrl(fESDOutput.Data());
4397       TString outputFile(gSystem->BaseName(outputUrl.GetFile()));
4398       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.IsNull() ? "AliESDs.root" : outputFile.Data()));
4399       TString outputLocation(outputUrl.GetUrl());
4400       outputLocation.ReplaceAll(outputFile.Data(),"");
4401       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",outputLocation.Data()));
4402       AliInfo(Form("%s will be stored in %s",
4403                    outputFile.IsNull() ? "AliESDs.root" : outputFile.Data(),
4404                    outputLocation.Data()));
4405     }
4406   }
4407
4408   return kTRUE;
4409 }
4410
4411 //______________________________________________________________________________
4412 Bool_t AliReconstruction::IsHighPt() const {
4413   // Selection of events containing "high" pT tracks
4414   // If at least one track is found within 1.5 and 100 GeV (pT)
4415   // that was reconstructed by both ITS and TPC, the event is accepted
4416
4417   // Track cuts
4418   const Double_t pTmin = 1.5;
4419   const Double_t pTmax = 100;
4420   ULong_t mask = 0;
4421   mask |= (AliESDtrack::kITSrefit);
4422   mask |= (AliESDtrack::kTPCrefit);
4423   const Double_t pTminCosmic = 5.;
4424   const Double_t pTmaxCosmic = 100;
4425   ULong_t maskCosmic = 0;
4426   Int_t cosmicCount=0;
4427   maskCosmic |= (AliESDtrack::kTPCrefit);
4428
4429   Bool_t isOK = kFALSE;
4430
4431   if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4432     // Check if this ia a physics event (code 7)
4433     Int_t ntrk = fesd->GetNumberOfTracks();
4434     for (Int_t itrk=0; itrk<ntrk; ++itrk) {
4435
4436       AliESDtrack * trk = fesd->GetTrack(itrk);
4437       if (trk
4438           && trk->Pt() > pTmin
4439           && trk->Pt() < pTmax
4440           && (trk->GetStatus() & mask) == mask ) {
4441
4442         isOK = kTRUE;
4443         break;
4444       }
4445       if (trk
4446           && trk->GetInnerParam()
4447           && trk->GetInnerParam()->Pt() > pTminCosmic
4448           && trk->GetInnerParam()->Pt() < pTmaxCosmic
4449           && (trk->GetStatus() & maskCosmic) == maskCosmic ) {
4450
4451         cosmicCount++;
4452         break;
4453       }
4454     }
4455     if (cosmicCount>1) isOK=kTRUE;
4456   }
4457   return isOK;
4458 }
4459
4460 //______________________________________________________________________________
4461 Bool_t AliReconstruction::IsCosmicOrCalibSpecie() const {
4462   // Select cosmic or calibration events
4463
4464   Bool_t isOK = kFALSE;
4465
4466   if (fesd && fesd->GetEventType()==AliRawEventHeaderBase::kPhysicsEvent) {
4467       // Check if this ia a physics event (code 7)
4468
4469       UInt_t specie = fesd->GetEventSpecie();
4470       if (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib) {
4471         isOK = kTRUE;
4472       }
4473   }
4474   return isOK;
4475 }
4476
4477 //______________________________________________________________________________
4478 void AliReconstruction::WriteESDfriend() {
4479   // Fill the ESD friend in the tree. The required fraction of ESD friends is stored
4480   // in fFractionFriends. We select events where we store the ESD friends according
4481   // to the following algorithm:
4482   // 1. Store all Cosmic or Calibration events within the required fraction
4483   // 2. Sample "high Pt" events within the remaining fraction after step 1.
4484   // 3. Sample randomly events if we still have remaining slot
4485
4486   fNall++;
4487   Bool_t isSelected = kFALSE;
4488   //
4489   // Store all friends for B field OFF
4490   if (TMath::Abs(AliTrackerBase::GetBz())<0.5) isSelected=kTRUE;
4491
4492   if (IsCosmicOrCalibSpecie()) { // Selection of calib or cosmic events
4493     fNspecie++;
4494
4495     isSelected = kTRUE;
4496     fSspecie++;
4497   }
4498
4499   Double_t remainingFraction = fFractionFriends;
4500   remainingFraction -= ((Double_t)(fSspecie)/(Double_t)(fNall));
4501
4502   if (IsHighPt())  { // Selection of "high Pt" events
4503     fNhighPt++;
4504     Double_t curentHighPtFraction = ((Double_t)(fNhighPt+1))/((Double_t)(fNall+1));
4505     // "Bayesian" estimate supposing that without events all the events are of the required type
4506
4507     if (!isSelected) {
4508       Double_t rnd = gRandom->Rndm()*curentHighPtFraction;
4509       if (rnd<remainingFraction) {
4510         isSelected = kTRUE;
4511         fShighPt++;
4512       }
4513     }
4514   }
4515   remainingFraction -= ((Double_t)(fShighPt)/(Double_t)(fNall));
4516
4517   // Random selection to fill the remaining fraction (if any)
4518   if (!isSelected) {
4519     Double_t rnd = gRandom->Rndm();
4520     if (rnd<remainingFraction) {
4521       isSelected = kTRUE;
4522     }
4523   }
4524
4525   if (!isSelected) {
4526     fesdf->~AliESDfriend();
4527     new (fesdf) AliESDfriend(); // Reset...
4528     fesdf->SetSkipBit(kTRUE);
4529   }
4530   //
4531   Long64_t nbf = ftreeF->Fill();
4532   if (fTreeBuffSize>0 && ftreeF->GetAutoFlush()<0 && (fMemCountESDF += nbf)>fTreeBuffSize ) { // default limit is still not reached
4533     nbf = ftreeF->GetZipBytes();
4534     if (nbf>0) nbf = -nbf;
4535     else       nbf = ftreeF->GetEntries();
4536     ftreeF->SetAutoFlush(nbf);
4537     AliInfo(Form("Calling ftreeF->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
4538                  nbf,fMemCountESDF,ftreeF->GetTotBytes(),ftreeF->GetZipBytes()));
4539   }
4540
4541 }
4542
4543 //_________________________________________________________________
4544 void AliReconstruction::DeleteDigits(const TString& detectors)
4545 {
4546   // delete requested digit files produced at current event
4547   static int iEvent = 0;
4548   if (detectors.IsNull()) return;
4549   TString detStr = detectors;
4550   AliInfo(Form("Deleting Digits: %s",detectors.Data()));
4551
4552   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4553     if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
4554     unlink(Form("%s.Digits.root",fgkDetectorName[iDet]));
4555   }
4556   AliSysInfo::AddStamp(Form("DelDigits_%d",iEvent), 0,0,iEvent);
4557   iEvent++;
4558 }
4559
4560 //_________________________________________________________________
4561 void AliReconstruction::DeleteRecPoints(const TString& detectors)
4562 {
4563   // delete requested recpoint files produced at current event
4564   static int iEvent = 0;
4565   if (detectors.IsNull()) return;
4566   TString detStr = detectors;
4567   AliInfo(Form("Deleting Recpoints: %s",detectors.Data()));
4568   //
4569   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
4570     if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
4571     unlink(Form("%s.RecPoints.root",fgkDetectorName[iDet]));
4572   }
4573   AliSysInfo::AddStamp(Form("DelRecPoints_%d",iEvent), 0,0,iEvent);
4574   iEvent++;
4575 }
4576
4577 //_________________________________________________________________
4578 void AliReconstruction::SetStopOnResourcesExcess(Int_t vRSS,Int_t vVMEM)
4579 {
4580   // require checking the resources left and stopping on excess
4581   // if 0  : no check is done
4582   // if >0 : stop reconstruction if exceeds this value
4583   // if <0 : use as margin to system limits
4584   //
4585   const int kKB2MB = 1024;
4586   const int kInfMem = 9999999;
4587   //
4588   struct rlimit r;
4589   int pgSize = getpagesize();
4590   //
4591   if (vRSS>0) {
4592     fMaxRSS = vRSS;
4593     AliInfo(Form("Setting max. RSS usage to user value %d MB",fMaxRSS));
4594   }
4595   else if (vRSS<0) {
4596     getrlimit(RLIMIT_RSS,&r);
4597     fMaxRSS = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vRSS;
4598     AliInfo(Form("Setting max. RSS usage to system hard limit %d%s MB (%d margin)",fMaxRSS,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vRSS));
4599   }
4600   else {AliInfo("No check on RSS memory usage will be applied");}
4601   //
4602   if (vVMEM>0) {
4603     fMaxVMEM = vVMEM;
4604     AliInfo(Form("Setting max. VMEM usage to user value %d MB",fMaxVMEM));
4605   }
4606   else if (vVMEM<0) {
4607     getrlimit(RLIMIT_AS,&r);
4608     fMaxVMEM = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vVMEM;
4609     AliInfo(Form("Setting max. VMEM usage to system hard limit %d%s MB (%d margin)",fMaxVMEM,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vVMEM));
4610   }
4611   else {AliInfo("No check on RSS memory usage will be applied");}
4612   //
4613 }
4614
4615 //_________________________________________________________________
4616 Bool_t AliReconstruction::HasEnoughResources(int ev)
4617 {
4618   // check if process consumed more than allowed resources
4619   const int kKB2MB = 1024;
4620   Bool_t res = kTRUE;
4621   if (!fMaxRSS && !fMaxVMEM) return res;
4622   //
4623   ProcInfo_t procInfo;
4624   gSystem->GetProcInfo(&procInfo);
4625   if (procInfo.fMemResident/kKB2MB > fMaxRSS)  res = kFALSE;
4626   if (procInfo.fMemVirtual/kKB2MB  > fMaxVMEM) res = kFALSE;
4627   //
4628   if (!res) {
4629     AliInfo(Form("Job exceeded allowed limits: RSS:%d (%d) VMEM:%d (%d), will stop",
4630                  int(procInfo.fMemResident/kKB2MB),fMaxRSS,
4631                  int(procInfo.fMemVirtual/kKB2MB) ,fMaxVMEM));
4632     //
4633     unlink(Form("%s",fgkStopEvFName));
4634     ofstream outfile(fgkStopEvFName);
4635     outfile << ev << std::endl;
4636     outfile.close();
4637     fStopped = kTRUE;
4638   }
4639   return res;
4640 }
4641
4642 Bool_t AliReconstruction::HasNextEventAfter(Int_t eventId)
4643 {
4644          return ( (eventId < fRunLoader->GetNumberOfEvents()) ||
4645            (fRawReader && fRawReader->NextEvent()) );
4646 }
4647
4648 //_________________________________________________________________
4649 void AliReconstruction::CheckRecoCDBvsSimuCDB()
4650 {
4651   // if some CDB entries must be the same in the simulation
4652   // and reconstruction, check here
4653   int nent = fCheckRecoCDBvsSimuCDB.GetEntriesFast();
4654   AliInfo(Form("Check %d entries for matching between sim and rec",nent));
4655   //
4656   // get simulation CDB
4657   fRunLoader->CdGAFile();
4658   TMap*  cdbMapSim  = (TMap*)gDirectory->Get("cdbMap");
4659   TList* cdbListSim = (TList*)gDirectory->Get("cdbList");
4660   if (!(cdbMapSim && cdbListSim)) {
4661     AliInfo(Form("No CDBMap/List found in %s, nothing to check",fGAliceFileName.Data()));
4662     return;
4663   }
4664   // read the requested objects to make sure they will appear in the reco list
4665   for (Int_t i=0;i<nent;i++) {
4666     TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
4667     if (!cdbent) continue;
4668     AliCDBManager::Instance()->Get(cdbent->GetName());
4669   }
4670   // get default path for simulation
4671   TPair* pair;
4672   TObjString* stro;
4673   pair = (TPair*)cdbMapSim->FindObject("default");
4674   if (!pair) {AliFatal("Did not find default storage used for simulations"); return;}
4675   TString defSimStore = ((TObjString*)pair->Value())->GetString();
4676   RectifyCDBurl(defSimStore);
4677   //
4678   // get reconstruction CDB
4679   const TMap *cdbMapRec = AliCDBManager::Instance()->GetStorageMap();
4680   const TList *cdbListRec = AliCDBManager::Instance()->GetRetrievedIds();
4681   //
4682   // get default path for reconstruction
4683   pair = (TPair*)cdbMapRec->FindObject("default");
4684   if (!pair) {AliFatal("Did not find default storage used for reconstruction"); return;}
4685   TString defRecStore = ((TObjString*)pair->Value())->GetString();
4686   RectifyCDBurl(defRecStore);
4687   //
4688   for (Int_t i=0;i<nent;i++) {
4689     TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
4690     if (!cdbent) continue;
4691     //
4692     AliInfo(Form("#%d Checking %s",i,cdbent->GetName()));
4693     //
4694     // find cdbID used for sim
4695     TString idSim="",storSim="";
4696     TIter nextSim(cdbListSim);
4697     while ((stro=(TObjString*)nextSim())) {
4698       if (stro->GetString().Contains(cdbent->GetName())) {
4699         idSim = stro->GetString();
4700         break;
4701       }
4702     }
4703     // find the storage used for sim
4704     // check in the simuCDB special paths
4705     pair = (TPair*)cdbMapSim->FindObject(cdbent->GetName());
4706     if (pair) { // specific path is used
4707       storSim = ((TObjString*)pair->Value())->GetString();
4708       RectifyCDBurl(storSim);
4709     }
4710     else storSim = defSimStore;  // default storage list is used
4711     //
4712     if (!idSim.IsNull()) AliInfo(Form("Sim. used %s from %s",idSim.Data(), storSim.Data()));
4713     else                 AliInfo("Sim. did not use this object");
4714     //
4715     // find cdbID used for rec
4716     TString idRec="",storRec="";
4717     TIter nextRec(cdbListRec);
4718     AliCDBId* id=0;
4719     while ((id=(AliCDBId*)nextRec())) {
4720       idRec = id->ToString();
4721       if (idRec.Contains(cdbent->GetName())) break;
4722       idRec="";
4723     }
4724     //
4725     // find storage used for the rec
4726     pair = (TPair*)cdbMapRec->FindObject(cdbent->GetName());
4727     if (pair) {  // specific path is used
4728       storRec = ((TObjString*)pair->Value())->GetString();
4729       RectifyCDBurl(storRec);
4730     }
4731     else storRec = defRecStore; // default storage list is used
4732     //
4733     if (!idRec.IsNull()) AliInfo(Form("Rec. used %s from %s",idRec.Data(), storRec.Data()));
4734     else                 AliInfo("Rec. did not use this object");
4735     //
4736     if (!idSim.IsNull() && !idRec.IsNull() && ((idSim!=idRec) || (storSim!=storRec)) )
4737       AliFatal("Different objects were used in sim and rec");
4738   }
4739
4740 }
4741
4742 //_________________________________________________________
4743 void AliReconstruction::RectifyCDBurl(TString& url)
4744 {
4745   // TBD RS
4746   // remove everything but the url
4747   TString sbs;
4748   if (!(sbs=url("\\?User=[^?]*")).IsNull())                url.ReplaceAll(sbs,"");
4749   if (!(sbs=url("\\?DBFolder=[^?]*")).IsNull())            url.ReplaceAll("?DB","");
4750   if (!(sbs=url("\\?SE=[^?]*")).IsNull())                  url.ReplaceAll(sbs,"");
4751   if (!(sbs=url("\\?CacheFolder=[^?]*")).IsNull())         url.ReplaceAll(sbs,"");
4752   if (!(sbs=url("\\?OperateDisconnected=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
4753   if (!(sbs=url("\\?CacheSize=[^?]*")).IsNull())           url.ReplaceAll(sbs,"");
4754   if (!(sbs=url("\\?CleanupInterval=[^?]*")).IsNull())     url.ReplaceAll(sbs,"");
4755   Bool_t slash=kFALSE,space=kFALSE;
4756   while ( (slash=url.EndsWith("/")) || (space=url.EndsWith(" ")) ) {
4757     if (slash) url = url.Strip(TString::kTrailing,'/');
4758     if (space) url = url.Strip(TString::kTrailing,' ');
4759   }
4760   //url.ToLower();
4761   //
4762 }