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