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