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