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