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