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
 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   if (fesd->GetESDRun()) ((AliESDRun*)fesd->GetESDRun())->SetBeamEnergyIsSqrtSHalfGeV();
1499   // add a so far non-std object to the ESD, this will
1500   // become part of the std content
1501   fesd->AddObject(new AliESDHLTDecision);
1502
1503   fesd->WriteToTree(ftree);
1504   if (fWriteESDfriend) {
1505     // careful:
1506     // Since we add the branch manually we must
1507     // book and add it after WriteToTree
1508     // otherwise it is created twice,
1509     // once via writetotree and once here.
1510     // The case for AliESDfriend is now
1511     // caught also in AlIESDEvent::WriteToTree but
1512     // be careful when changing the name (AliESDfriend is not
1513     // a TNamed so we had to hardwire it)
1514     fesdf = new AliESDfriend();
1515     TBranch *br=ftree->Branch("ESDfriend.","AliESDfriend", &fesdf);
1516     br->SetFile("AliESDfriends.root");
1517     fesd->AddObject(fesdf);
1518   }
1519   ftree->GetUserInfo()->Add(fesd);
1520
1521   fhlttree = new TTree("HLTesdTree", "Tree with HLT ESD objects");
1522   fhltesd = new AliESDEvent();
1523   fhltesd->CreateStdContent();
1524   if (fhltesd->GetESDRun()) ((AliESDRun*)fhltesd->GetESDRun())->SetBeamEnergyIsSqrtSHalfGeV();
1525   // read the ESD template from CDB
1526   // HLT is allowed to put non-std content to its ESD, the non-std
1527   // objects need to be created before invocation of WriteToTree in
1528   // order to create all branches. Initialization is done from an
1529   // ESD layout template in CDB
1530   AliCDBManager* man = AliCDBManager::Instance();
1531   AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
1532   AliCDBEntry* hltESDConfig=NULL;
1533   if (man->GetId(hltESDConfigPath)!=NULL &&
1534       (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
1535     AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
1536     if (pESDLayout) {
1537       // init all internal variables from the list of objects
1538       pESDLayout->GetStdContent();
1539
1540       // copy content and create non-std objects
1541       *fhltesd=*pESDLayout;
1542       fhltesd->Reset();
1543     } else {
1544       AliError(Form("error setting hltEsd layout from %s: invalid object type",
1545                     hltESDConfigPath.GetPath().Data()));
1546     }
1547   }
1548
1549   fhltesd->WriteToTree(fhlttree);
1550   fhlttree->GetUserInfo()->Add(fhltesd);
1551
1552   ProcInfo_t procInfo;
1553   gSystem->GetProcInfo(&procInfo);
1554   AliInfo(Form("Current memory usage %d %d", procInfo.fMemResident, procInfo.fMemVirtual));
1555
1556   //QA
1557   //Initialize the QA and start of cycle
1558   if (fRunQA || fRunGlobalQA)
1559     InitQA() ;
1560
1561   //Initialize the Plane Efficiency framework
1562   if (fRunPlaneEff && !InitPlaneEff()) {
1563     Abort("InitPlaneEff", TSelector::kAbortProcess);
1564     return;
1565   }
1566
1567   if (strcmp(gProgName,"alieve") == 0)
1568     fRunAliEVE = InitAliEVE();
1569
1570   return;
1571 }
1572
1573 //_____________________________________________________________________________
1574 Bool_t AliReconstruction::Process(Long64_t entry)
1575 {
1576   // run the reconstruction over a single entry
1577   // from the chain with raw data
1578   AliCodeTimerAuto("",0);
1579
1580   TTree *currTree = fChain->GetTree();
1581   AliRawVEvent *event = NULL;
1582   currTree->SetBranchAddress("rawevent",&event);
1583   currTree->GetEntry(entry);
1584   fRawReader = new AliRawReaderRoot(event);
1585   fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
1586   delete fRawReader;
1587   fRawReader = NULL;
1588   delete event;
1589
1590   return fStatus;
1591 }
1592
1593 //_____________________________________________________________________________
1594 void AliReconstruction::Init(TTree *tree)
1595 {
1596   if (tree == 0) {
1597     AliError("The input tree is not found!");
1598     return;
1599   }
1600   fChain = tree;
1601 }
1602
1603 //_____________________________________________________________________________
1604 Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
1605 {
1606   // run the reconstruction over a single event
1607   // The event loop is steered in Run method
1608
1609   AliCodeTimerAuto("",0);
1610
1611   if (iEvent >= fRunLoader->GetNumberOfEvents()) {
1612     fRunLoader->SetEventNumber(iEvent);
1613     fRunLoader->GetHeader()->Reset(fRawReader->GetRunNumber(),
1614                                    iEvent, iEvent);
1615     fRunLoader->TreeE()->Fill();
1616     if (fRawReader && fRawReader->UseAutoSaveESD())
1617       fRunLoader->TreeE()->AutoSave("SaveSelf");
1618   }
1619
1620   if ((iEvent < fFirstEvent) || ((fLastEvent >= 0) && (iEvent > fLastEvent))) {
1621     return kTRUE;
1622   }
1623
1624   AliInfo(Form("processing event %d", iEvent));
1625
1626   fRunLoader->GetEvent(iEvent);
1627
1628   // Fill Event-info object
1629   GetEventInfo();
1630   fRecoParam.SetEventSpecie(fRunInfo,fEventInfo,fListOfCosmicTriggers);
1631   AliInfo(Form("Current event specie: %s",fRecoParam.PrintEventSpecie()));
1632
1633   // Set the reco-params
1634   {
1635     TString detStr = fLoadCDB;
1636     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1637       if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
1638       AliReconstructor *reconstructor = GetReconstructor(iDet);
1639       if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
1640         const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
1641         reconstructor->SetRecoParam(par);
1642         reconstructor->SetEventInfo(&fEventInfo);
1643         if (fRunQA) {
1644           AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
1645           AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
1646         }
1647       }
1648     }
1649     const AliDetectorRecoParam *grppar = fRecoParam.GetDetRecoParam(kNDetectors);
1650     AliQAManager::QAManager()->SetRecoParam(AliQAv1::kGLOBAL, grppar) ;
1651     AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(grppar->GetEventSpecie())) ;
1652   }
1653
1654     // QA on single raw
1655   if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
1656     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1657     AliQAManager::QAManager()->RunOneEvent(fRawReader) ;
1658   }
1659     // local single event reconstruction
1660     if (!fRunLocalReconstruction.IsNull()) {
1661       TString detectors=fRunLocalReconstruction;
1662       // run HLT event reconstruction first
1663       // ;-( IsSelected changes the string
1664       if (IsSelected("HLT", detectors) &&
1665           !RunLocalEventReconstruction("HLT")) {
1666         if (fStopOnError) {CleanUp(); return kFALSE;}
1667       }
1668       detectors=fRunLocalReconstruction;
1669       detectors.ReplaceAll("HLT", "");
1670       if (!RunLocalEventReconstruction(detectors)) {
1671         if (fStopOnError) {
1672           CleanUp();
1673           return kFALSE;
1674         }
1675       }
1676     }
1677
1678     fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1679     fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
1680     fesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1681     fhltesd->SetEventNumberInFile(fRunLoader->GetHeader()->GetEventNrInRun());
1682
1683     fesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1684     fhltesd->SetEventSpecie(fRecoParam.GetEventSpecie());
1685
1686     // Set magnetic field from the tracker
1687     fesd->SetMagneticField(AliTracker::GetBz());
1688     fhltesd->SetMagneticField(AliTracker::GetBz());
1689     //
1690     AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
1691     if (fld) { // set info needed for field initialization
1692       fesd->SetCurrentL3(fld->GetCurrentSol());
1693       fesd->SetCurrentDip(fld->GetCurrentDip());
1694       fesd->SetBeamEnergy(fld->GetBeamEnergy());
1695       fesd->SetBeamType(fld->GetBeamTypeText());
1696       fesd->SetUniformBMap(fld->IsUniform());
1697       fesd->SetBInfoStored();
1698       //
1699       fhltesd->SetCurrentL3(fld->GetCurrentSol());
1700       fhltesd->SetCurrentDip(fld->GetCurrentDip());
1701       fhltesd->SetBeamEnergy(fld->GetBeamEnergy());
1702       fhltesd->SetBeamType(fld->GetBeamTypeText());
1703       fhltesd->SetUniformBMap(fld->IsUniform());
1704       fhltesd->SetBInfoStored();
1705     }
1706     //
1707     // Set most probable pt, for B=0 tracking
1708     // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
1709     const AliGRPRecoParam *grpRecoParam = dynamic_cast<const AliGRPRecoParam*>(fRecoParam.GetDetRecoParam(kNDetectors));
1710     if (grpRecoParam) AliExternalTrackParam::SetMostProbablePt(grpRecoParam->GetMostProbablePt());
1711
1712     // Fill raw-data error log into the ESD
1713     if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
1714
1715     // vertex finder
1716     if (fRunVertexFinder) {
1717       if (!RunVertexFinder(fesd)) {
1718         if (fStopOnError) {CleanUp(); return kFALSE;}
1719       }
1720     }
1721
1722     // For Plane Efficiency: run the SPD trackleter
1723     if (fRunPlaneEff && fSPDTrackleter) {
1724       if (!RunSPDTrackleting(fesd)) {
1725         if (fStopOnError) {CleanUp(); return kFALSE;}
1726       }
1727     }
1728
1729     // Muon tracking
1730     if (!fRunTracking.IsNull()) {
1731       if (fRunMuonTracking) {
1732         if (!RunMuonTracking(fesd)) {
1733           if (fStopOnError) {CleanUp(); return kFALSE;}
1734         }
1735       }
1736     }
1737
1738     // barrel tracking
1739     if (!fRunTracking.IsNull()) {
1740       if (!RunTracking(fesd)) {
1741         if (fStopOnError) {CleanUp(); return kFALSE;}
1742       }
1743     }
1744
1745     // fill ESD
1746     if (!fFillESD.IsNull()) {
1747       TString detectors=fFillESD;
1748       // run HLT first and on hltesd
1749       // ;-( IsSelected changes the string
1750       if (IsSelected("HLT", detectors) &&
1751           !FillESD(fhltesd, "HLT")) {
1752         if (fStopOnError) {CleanUp(); return kFALSE;}
1753       }
1754       detectors=fFillESD;
1755       // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
1756       if (detectors.Contains("ALL")) {
1757         detectors="";
1758         for (Int_t idet=0; idet<kNDetectors; ++idet){
1759           detectors += fgkDetectorName[idet];
1760           detectors += " ";
1761         }
1762       }
1763       detectors.ReplaceAll("HLT", "");
1764       if (!FillESD(fesd, detectors)) {
1765         if (fStopOnError) {CleanUp(); return kFALSE;}
1766       }
1767     }
1768
1769     // fill Event header information from the RawEventHeader
1770     if (fRawReader){FillRawEventHeaderESD(fesd);}
1771     if (fRawReader){FillRawEventHeaderESD(fhltesd);}
1772
1773     // combined PID
1774     AliESDpid::MakePID(fesd);
1775
1776     if (fFillTriggerESD) {
1777       if (!FillTriggerESD(fesd)) {
1778         if (fStopOnError) {CleanUp(); return kFALSE;}
1779       }
1780     }
1781     // Always fill scalers
1782     if (!FillTriggerScalers(fesd)) {
1783        if (fStopOnError) {CleanUp(); return kFALSE;}
1784     }
1785
1786
1787     ffile->cd();
1788
1789     //
1790     // Propagate track to the beam pipe  (if not already done by ITS)
1791     //
1792     const Int_t ntracks = fesd->GetNumberOfTracks();
1793     const Double_t kRadius  = 2.8; //something less than the beam pipe radius
1794
1795     TObjArray trkArray;
1796     UShort_t *selectedIdx=new UShort_t[ntracks];
1797
1798     for (Int_t itrack=0; itrack<ntracks; itrack++){
1799       const Double_t kMaxStep = 1;   //max step over the material
1800       Bool_t ok;
1801
1802       AliESDtrack *track = fesd->GetTrack(itrack);
1803       if (!track) continue;
1804
1805       AliExternalTrackParam *tpcTrack =
1806            (AliExternalTrackParam *)track->GetTPCInnerParam();
1807       ok = kFALSE;
1808       if (tpcTrack)
1809         ok = AliTracker::
1810           PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
1811
1812       if (ok) {
1813         Int_t n=trkArray.GetEntriesFast();
1814         selectedIdx[n]=track->GetID();
1815         trkArray.AddLast(tpcTrack);
1816       }
1817
1818       //Tracks refitted by ITS should already be at the SPD vertex
1819       if (track->IsOn(AliESDtrack::kITSrefit)) continue;
1820
1821       AliTracker::
1822          PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
1823       Double_t x[3]; track->GetXYZ(x);
1824       Double_t b[3]; AliTracker::GetBxByBz(x,b);
1825       track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
1826
1827     }
1828
1829     //
1830     // Improve the reconstructed primary vertex position using the tracks
1831     //
1832     Bool_t runVertexFinderTracks = fRunVertexFinderTracks;
1833     if(fesd->GetPrimaryVertexSPD()) {
1834       TString vtitle = fesd->GetPrimaryVertexSPD()->GetTitle();
1835       if(vtitle.Contains("cosmics")) {
1836         runVertexFinderTracks=kFALSE;
1837       }
1838     }
1839
1840     if (runVertexFinderTracks) {
1841        // TPC + ITS primary vertex
1842        ftVertexer->SetITSMode();
1843        ftVertexer->SetConstraintOff();
1844        // get cuts for vertexer from AliGRPRecoParam
1845        if (grpRecoParam) {
1846          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1847          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1848          grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
1849          ftVertexer->SetCuts(cutsVertexer);
1850          delete [] cutsVertexer; cutsVertexer = NULL;
1851          if(fDiamondProfile && grpRecoParam->GetVertexerTracksConstraintITS())
1852            ftVertexer->SetVtxStart(fDiamondProfile);
1853        }
1854        AliESDVertex *pvtx=ftVertexer->FindPrimaryVertex(fesd);
1855        if (pvtx) {
1856           if (pvtx->GetStatus()) {
1857              fesd->SetPrimaryVertexTracks(pvtx);
1858              for (Int_t i=0; i<ntracks; i++) {
1859                  AliESDtrack *t = fesd->GetTrack(i);
1860                  Double_t x[3]; t->GetXYZ(x);
1861                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
1862                  t->RelateToVertexBxByBz(pvtx, b, kVeryBig);
1863              }
1864           }
1865           delete pvtx; pvtx=NULL;
1866        }
1867
1868        // TPC-only primary vertex
1869        ftVertexer->SetTPCMode();
1870        ftVertexer->SetConstraintOff();
1871        // get cuts for vertexer from AliGRPRecoParam
1872        if (grpRecoParam) {
1873          Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
1874          Double_t *cutsVertexer = new Double_t[nCutsVertexer];
1875          grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
1876          ftVertexer->SetCuts(cutsVertexer);
1877          delete [] cutsVertexer; cutsVertexer = NULL;
1878          if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC())
1879            ftVertexer->SetVtxStart(fDiamondProfileTPC);
1880        }
1881        pvtx=ftVertexer->FindPrimaryVertex(&trkArray,selectedIdx);
1882        if (pvtx) {
1883           if (pvtx->GetStatus()) {
1884              fesd->SetPrimaryVertexTPC(pvtx);
1885              for (Int_t i=0; i<ntracks; i++) {
1886                  AliESDtrack *t = fesd->GetTrack(i);
1887                  Double_t x[3]; t->GetXYZ(x);
1888                  Double_t b[3]; AliTracker::GetBxByBz(x,b);
1889                  t->RelateToVertexTPCBxByBz(pvtx, b, kVeryBig);
1890              }
1891           }
1892           delete pvtx; pvtx=NULL;
1893        }
1894
1895     }
1896     delete[] selectedIdx;
1897
1898     if(fDiamondProfile) fesd->SetDiamond(fDiamondProfile);
1899
1900
1901     if (fRunV0Finder) {
1902        // V0 finding
1903        AliV0vertexer vtxer;
1904        vtxer.Tracks2V0vertices(fesd);
1905
1906        if (fRunCascadeFinder) {
1907           // Cascade finding
1908           AliCascadeVertexer cvtxer;
1909           cvtxer.V0sTracks2CascadeVertices(fesd);
1910        }
1911     }
1912
1913     // write ESD
1914     if (fCleanESD) CleanESD(fesd);
1915
1916   if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
1917     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1918     AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ;
1919   }
1920   if (fRunGlobalQA) {
1921     AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
1922       qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
1923     if (qadm && IsInTasks(AliQAv1::kESDS))
1924       qadm->Exec(AliQAv1::kESDS, fesd);
1925   }
1926
1927   // copy HLT decision from HLTesd to esd
1928   // the most relevant information is stored in a reduced container in the esd,
1929   // while the full information can be found in the HLTesd
1930   TObject* pHLTSrc=fhltesd->FindListObject(AliESDHLTDecision::Name());
1931   TObject* pHLTTgt=fesd->FindListObject(AliESDHLTDecision::Name());
1932   if (pHLTSrc && pHLTTgt) {
1933     pHLTSrc->Copy(*pHLTTgt);
1934   }
1935
1936     if (fWriteESDfriend) {
1937       //      fesdf->~AliESDfriend();
1938       //  new (fesdf) AliESDfriend(); // Reset...
1939       fesd->GetESDfriend(fesdf);
1940     }
1941     ftree->Fill();
1942
1943     // Auto-save the ESD tree in case of prompt reco @P2
1944     if (fRawReader && fRawReader->UseAutoSaveESD()) {
1945       ftree->AutoSave("SaveSelf");
1946       TFile *friendfile = (TFile *)(gROOT->GetListOfFiles()->FindObject("AliESDfriends.root"));
1947       if (friendfile) friendfile->Save();
1948     }
1949
1950     // write HLT ESD
1951     fhlttree->Fill();
1952
1953     // call AliEVE
1954     if (fRunAliEVE) RunAliEVE();
1955
1956     fesd->Reset();
1957     fhltesd->Reset();
1958     if (fWriteESDfriend) {
1959       fesdf->~AliESDfriend();
1960       new (fesdf) AliESDfriend(); // Reset...
1961     }
1962
1963     ProcInfo_t procInfo;
1964     gSystem->GetProcInfo(&procInfo);
1965     AliInfo(Form("Event %d -> Current memory usage %d %d",iEvent, procInfo.fMemResident, procInfo.fMemVirtual));
1966
1967     fEventInfo.Reset();
1968     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
1969       if (fReconstructor[iDet]) {
1970         fReconstructor[iDet]->SetRecoParam(NULL);
1971         fReconstructor[iDet]->SetEventInfo(NULL);
1972       }
1973       if (fTracker[iDet]) fTracker[iDet]->SetEventInfo(NULL);
1974     }
1975
1976   if (fRunQA || fRunGlobalQA)
1977     AliQAManager::QAManager()->Increment() ;
1978
1979     return kTRUE;
1980 }
1981
1982 //_____________________________________________________________________________
1983 void AliReconstruction::SlaveTerminate()
1984 {
1985   // Finalize the run on the slave side
1986   // Called after the exit
1987   // from the event loop
1988   AliCodeTimerAuto("",0);
1989
1990   if (fIsNewRunLoader) { // galice.root didn't exist
1991     fRunLoader->WriteHeader("OVERWRITE");
1992     fRunLoader->CdGAFile();
1993     fRunLoader->Write(0, TObject::kOverwrite);
1994   }
1995
1996   const TMap *cdbMap = AliCDBManager::Instance()->GetStorageMap();
1997   const TList *cdbList = AliCDBManager::Instance()->GetRetrievedIds();
1998
1999    TMap *cdbMapCopy = new TMap(cdbMap->GetEntries());
2000    cdbMapCopy->SetOwner(1);
2001    cdbMapCopy->SetName("cdbMap");
2002    TIter iter(cdbMap->GetTable());
2003
2004    TPair* pair = 0;
2005    while((pair = dynamic_cast<TPair*> (iter.Next()))){
2006          TObjString* keyStr = dynamic_cast<TObjString*> (pair->Key());
2007          TObjString* valStr = dynamic_cast<TObjString*> (pair->Value());
2008          cdbMapCopy->Add(new TObjString(keyStr->GetName()), new TObjString(valStr->GetName()));
2009    }
2010
2011    TList *cdbListCopy = new TList();
2012    cdbListCopy->SetOwner(1);
2013    cdbListCopy->SetName("cdbList");
2014
2015    TIter iter2(cdbList);
2016
2017         AliCDBId* id=0;
2018         while((id = dynamic_cast<AliCDBId*> (iter2.Next()))){
2019          cdbListCopy->Add(new TObjString(id->ToString().Data()));
2020    }
2021
2022    ftree->GetUserInfo()->Add(cdbMapCopy);
2023    ftree->GetUserInfo()->Add(cdbListCopy);
2024
2025
2026   ffile->cd();
2027
2028   if (fWriteESDfriend)
2029     ftree->SetBranchStatus("ESDfriend*",0);
2030   // we want to have only one tree version number
2031   ftree->Write(ftree->GetName(),TObject::kOverwrite);
2032   fhlttree->Write(fhlttree->GetName(),TObject::kOverwrite);
2033
2034 // Finish with Plane Efficiency evaluation: before of CleanUp !!!
2035   if (fRunPlaneEff && !FinishPlaneEff()) {
2036    AliWarning("Finish PlaneEff evaluation failed");
2037   }
2038
2039   // End of cycle for the in-loop
2040
2041   if (fRunQA || fRunGlobalQA) {
2042     AliQAManager::QAManager()->EndOfCycle() ;
2043     if (fInput &&
2044         !fProofOutputLocation.IsNull() &&
2045         fProofOutputArchive.IsNull() &&
2046         !fProofOutputDataset) {
2047       TString qaOutputFile(Form("%sMerged.%s.Data.root",
2048                                 fProofOutputLocation.Data(),
2049                                 AliQAv1::GetQADataFileName()));
2050       TProofOutputFile *qaProofFile = new TProofOutputFile(Form("Merged.%s.Data.root",
2051                                                                 AliQAv1::GetQADataFileName()));
2052       qaProofFile->SetOutputFileName(qaOutputFile.Data());
2053       if (AliDebugLevel() > 0) qaProofFile->Dump();
2054       fOutput->Add(qaProofFile);
2055       MergeQA(qaProofFile->GetFileName());
2056     }
2057     else {
2058       MergeQA();
2059     }
2060   }
2061
2062   gROOT->cd();
2063   CleanUp();
2064
2065   if (fInput) {
2066     if (!fProofOutputFileName.IsNull() &&
2067         !fProofOutputLocation.IsNull() &&
2068         fProofOutputDataset &&
2069         !fProofOutputArchive.IsNull()) {
2070       TProofOutputFile *zipProofFile = new TProofOutputFile(fProofOutputFileName.Data(),
2071                                                             "DROV",
2072                                                             fProofOutputLocation.Data());
2073       if (AliDebugLevel() > 0) zipProofFile->Dump();
2074       fOutput->Add(zipProofFile);
2075       TString fileList(fProofOutputArchive.Data());
2076       fileList.ReplaceAll(","," ");
2077       TString command;
2078 #if ROOT_SVN_REVISION >= 30174
2079       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(kTRUE),zipProofFile->GetFileName(),fileList.Data());
2080 #else
2081       command.Form("zip -n root %s/%s %s",zipProofFile->GetDir(),zipProofFile->GetFileName(),fileList.Data());
2082 #endif
2083       AliInfo(Form("Executing: %s",command.Data()));
2084       gSystem->Exec(command.Data());
2085     }
2086   }
2087 }
2088
2089 //_____________________________________________________________________________
2090 void AliReconstruction::Terminate()
2091 {
2092   // Create tags for the events in the ESD tree (the ESD tree is always present)
2093   // In case of empty events the tags will contain dummy values
2094   AliCodeTimerAuto("",0);
2095
2096   // Do not call the ESD tag creator in case of PROOF-based reconstruction
2097   if (!fInput) {
2098     AliESDTagCreator *esdtagCreator = new AliESDTagCreator();
2099     esdtagCreator->CreateESDTags(fFirstEvent,fLastEvent,fGRPData, AliQAv1::Instance()->GetQA(), AliQAv1::Instance()->GetEventSpecies(), AliQAv1::kNDET, AliRecoParam::kNSpecies);
2100     delete esdtagCreator;
2101   }
2102
2103   // Cleanup of CDB manager: cache and active storages!
2104   AliCDBManager::Instance()->ClearCache();
2105 }
2106
2107 //_____________________________________________________________________________
2108 Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
2109 {
2110 // run the local reconstruction
2111
2112   static Int_t eventNr=0;
2113   AliCodeTimerAuto("",0)
2114
2115   TString detStr = detectors;
2116   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2117     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2118     AliReconstructor* reconstructor = GetReconstructor(iDet);
2119     if (!reconstructor) continue;
2120     AliLoader* loader = fLoader[iDet];
2121     // Matthias April 2008: temporary fix to run HLT reconstruction
2122     // although the HLT loader is missing
2123     if (strcmp(fgkDetectorName[iDet], "HLT")==0) {
2124       if (fRawReader) {
2125         reconstructor->Reconstruct(fRawReader, NULL);
2126       } else {
2127         TTree* dummy=NULL;
2128         reconstructor->Reconstruct(dummy, NULL);
2129       }
2130       continue;
2131     }
2132     if (!loader) {
2133       AliWarning(Form("No loader is defined for %s!",fgkDetectorName[iDet]));
2134       continue;
2135     }
2136     // conversion of digits
2137     if (fRawReader && reconstructor->HasDigitConversion()) {
2138       AliInfo(Form("converting raw data digits into root objects for %s",
2139                    fgkDetectorName[iDet]));
2140 //      AliCodeTimerAuto(Form("converting raw data digits into root objects for %s",
2141 //                            fgkDetectorName[iDet]),0);
2142       loader->LoadDigits("update");
2143       loader->CleanDigits();
2144       loader->MakeDigitsContainer();
2145       TTree* digitsTree = loader->TreeD();
2146       reconstructor->ConvertDigits(fRawReader, digitsTree);
2147       loader->WriteDigits("OVERWRITE");
2148       loader->UnloadDigits();
2149     }
2150     // local reconstruction
2151     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
2152     //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
2153     loader->LoadRecPoints("update");
2154     loader->CleanRecPoints();
2155     loader->MakeRecPointsContainer();
2156     TTree* clustersTree = loader->TreeR();
2157     if (fRawReader && !reconstructor->HasDigitConversion()) {
2158       reconstructor->Reconstruct(fRawReader, clustersTree);
2159     } else {
2160       loader->LoadDigits("read");
2161       TTree* digitsTree = loader->TreeD();
2162       if (!digitsTree) {
2163         AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
2164         if (fStopOnError)
2165           return kFALSE;
2166       } else {
2167         reconstructor->Reconstruct(digitsTree, clustersTree);
2168         if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
2169           AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2170           AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, digitsTree) ;
2171         }
2172       }
2173       loader->UnloadDigits();
2174     }
2175                 if (fRunQA && IsInTasks(AliQAv1::kRECPOINTS)) {
2176       AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
2177                         AliQAManager::QAManager()->RunOneEventInOneDetector(iDet, clustersTree) ;
2178     }
2179     loader->WriteRecPoints("OVERWRITE");
2180     loader->UnloadRecPoints();
2181     AliSysInfo::AddStamp(Form("LRec%s_%d",fgkDetectorName[iDet],eventNr), iDet,1,eventNr);
2182   }
2183   IsSelected("CTP", detStr);
2184   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2185     AliError(Form("the following detectors were not found: %s",
2186                   detStr.Data()));
2187     if (fStopOnError)
2188       return kFALSE;
2189   }
2190   eventNr++;
2191   return kTRUE;
2192 }
2193 //_____________________________________________________________________________
2194 Bool_t AliReconstruction::RunSPDTrackleting(AliESDEvent*& esd)
2195 {
2196 // run the SPD trackleting (for SPD efficiency purpouses)
2197
2198   AliCodeTimerAuto("",0)
2199
2200   Double_t vtxPos[3] = {0, 0, 0};
2201   Double_t vtxErr[3] = {0.0, 0.0, 0.0};
2202 /*
2203   TArrayF mcVertex(3);
2204   // if(MC)
2205   if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
2206     fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
2207     for (Int_t i = 0; i < 3; i++) vtxPos[i] = mcVertex[i];
2208   }
2209 */
2210   const AliESDVertex *vertex = esd->GetVertex();
2211   if(!vertex){
2212     AliWarning("Vertex not found");
2213     return kFALSE;
2214   }
2215   vertex->GetXYZ(vtxPos);
2216   vertex->GetSigmaXYZ(vtxErr);
2217   if (fSPDTrackleter) {
2218     AliInfo("running the SPD Trackleter for Plane Efficiency Evaluation");
2219
2220     // load clusters
2221     fLoader[0]->LoadRecPoints("read");
2222     TTree* tree = fLoader[0]->TreeR();
2223     if (!tree) {
2224       AliError("Can't get the ITS cluster tree");
2225       return kFALSE;
2226     }
2227     fSPDTrackleter->LoadClusters(tree);
2228     fSPDTrackleter->SetVertex(vtxPos, vtxErr);
2229     // run trackleting
2230     if (fSPDTrackleter->Clusters2Tracks(esd) != 0) {
2231       AliError("AliITSTrackleterSPDEff Clusters2Tracks failed");
2232      // fLoader[0]->UnloadRecPoints();
2233       return kFALSE;
2234     }
2235 //fSPDTrackleter->UnloadRecPoints();
2236   } else {
2237     AliWarning("SPDTrackleter not available");
2238     return kFALSE;
2239   }
2240   return kTRUE;
2241 }
2242
2243 //_____________________________________________________________________________
2244 Bool_t AliReconstruction::RunVertexFinder(AliESDEvent*& esd)
2245 {
2246 // run the barrel tracking
2247
2248   AliCodeTimerAuto("",0)
2249
2250   AliVertexer *vertexer = CreateVertexer();
2251   if (!vertexer) return kFALSE;
2252
2253   AliInfo("running the ITS vertex finder");
2254   AliESDVertex* vertex = NULL;
2255   if (fLoader[0]) {
2256     fLoader[0]->LoadRecPoints();
2257     TTree* cltree = fLoader[0]->TreeR();
2258     if (cltree) {
2259       if(fDiamondProfileSPD) vertexer->SetVtxStart(fDiamondProfileSPD);
2260       vertex = vertexer->FindVertexForCurrentEvent(cltree);
2261     }
2262     else {
2263       AliError("Can't get the ITS cluster tree");
2264     }
2265     fLoader[0]->UnloadRecPoints();
2266   }
2267   else {
2268     AliError("Can't get the ITS loader");
2269   }
2270   if(!vertex){
2271     AliWarning("Vertex not found");
2272     vertex = new AliESDVertex();
2273     vertex->SetName("default");
2274   }
2275   else {
2276     vertex->SetName("reconstructed");
2277   }
2278
2279   Double_t vtxPos[3];
2280   Double_t vtxErr[3];
2281   vertex->GetXYZ(vtxPos);
2282   vertex->GetSigmaXYZ(vtxErr);
2283
2284   esd->SetPrimaryVertexSPD(vertex);
2285   AliESDVertex *vpileup = NULL;
2286   Int_t novertices = 0;
2287   vpileup = vertexer->GetAllVertices(novertices);
2288   if(novertices>1){
2289     for (Int_t kk=1; kk<novertices; kk++)esd->AddPileupVertexSPD(&vpileup[kk]);
2290   }
2291   // if SPD multiplicity has been determined, it is stored in the ESD
2292   AliMultiplicity *mult = vertexer->GetMultiplicity();
2293   if(mult)esd->SetMultiplicity(mult);
2294
2295   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2296     if (fTracker[iDet]) fTracker[iDet]->SetVertex(vtxPos, vtxErr);
2297   }
2298   delete vertex;
2299
2300   delete vertexer;
2301
2302   return kTRUE;
2303 }
2304
2305 //_____________________________________________________________________________
2306 Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
2307 {
2308 // run the HLT barrel tracking
2309
2310   AliCodeTimerAuto("",0)
2311
2312   if (!fRunLoader) {
2313     AliError("Missing runLoader!");
2314     return kFALSE;
2315   }
2316
2317   AliInfo("running HLT tracking");
2318
2319   // Get a pointer to the HLT reconstructor
2320   AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
2321   if (!reconstructor) return kFALSE;
2322
2323   // TPC + ITS
2324   for (Int_t iDet = 1; iDet >= 0; iDet--) {
2325     TString detName = fgkDetectorName[iDet];
2326     AliDebug(1, Form("%s HLT tracking", detName.Data()));
2327     reconstructor->SetOption(detName.Data());
2328     AliTracker *tracker = reconstructor->CreateTracker();
2329     if (!tracker) {
2330       AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
2331       if (fStopOnError) return kFALSE;
2332       continue;
2333     }
2334     Double_t vtxPos[3];
2335     Double_t vtxErr[3]={0.005,0.005,0.010};
2336     const AliESDVertex *vertex = esd->GetVertex();
2337     vertex->GetXYZ(vtxPos);
2338     tracker->SetVertex(vtxPos,vtxErr);
2339     if(iDet != 1) {
2340       fLoader[iDet]->LoadRecPoints("read");
2341       TTree* tree = fLoader[iDet]->TreeR();
2342       if (!tree) {
2343         AliError(Form("Can't get the %s cluster tree", detName.Data()));
2344         return kFALSE;
2345       }
2346       tracker->LoadClusters(tree);
2347     }
2348     if (tracker->Clusters2Tracks(esd) != 0) {
2349       AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
2350       return kFALSE;
2351     }
2352     if(iDet != 1) {
2353       tracker->UnloadClusters();
2354     }
2355     delete tracker;
2356   }
2357
2358   return kTRUE;
2359 }
2360
2361 //_____________________________________________________________________________
2362 Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
2363 {
2364 // run the muon spectrometer tracking
2365
2366   AliCodeTimerAuto("",0)
2367
2368   if (!fRunLoader) {
2369     AliError("Missing runLoader!");
2370     return kFALSE;
2371   }
2372   Int_t iDet = 7; // for MUON
2373
2374   AliInfo("is running...");
2375
2376   // Get a pointer to the MUON reconstructor
2377   AliReconstructor *reconstructor = GetReconstructor(iDet);
2378   if (!reconstructor) return kFALSE;
2379
2380
2381   TString detName = fgkDetectorName[iDet];
2382   AliDebug(1, Form("%s tracking", detName.Data()));
2383   AliTracker *tracker =  reconstructor->CreateTracker();
2384   if (!tracker) {
2385     AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2386     return kFALSE;
2387   }
2388
2389   // read RecPoints
2390   fLoader[iDet]->LoadRecPoints("read");
2391
2392   tracker->LoadClusters(fLoader[iDet]->TreeR());
2393
2394   Int_t rv = tracker->Clusters2Tracks(esd);
2395
2396   fLoader[iDet]->UnloadRecPoints();
2397
2398   tracker->UnloadClusters();
2399
2400   delete tracker;
2401
2402   if ( rv )
2403   {
2404     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2405     return kFALSE;
2406   }
2407
2408   return kTRUE;
2409 }
2410
2411
2412 //_____________________________________________________________________________
2413 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd)
2414 {
2415 // run the barrel tracking
2416   static Int_t eventNr=0;
2417   AliCodeTimerAuto("",0)
2418
2419   AliInfo("running tracking");
2420
2421   // Set the event info which is used
2422   // by the trackers in order to obtain
2423   // information about read-out detectors,
2424   // trigger etc.
2425   AliDebug(1, "Setting event info");
2426   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2427     if (!fTracker[iDet]) continue;
2428     fTracker[iDet]->SetEventInfo(&fEventInfo);
2429   }
2430
2431   //Fill the ESD with the T0 info (will be used by the TOF)
2432   if (fReconstructor[11] && fLoader[11]) {
2433     fLoader[11]->LoadRecPoints("READ");
2434     TTree *treeR = fLoader[11]->TreeR();
2435     if (treeR) {
2436       GetReconstructor(11)->FillESD((TTree *)NULL,treeR,esd);
2437     }
2438   }
2439
2440   // pass 1: TPC + ITS inwards
2441   for (Int_t iDet = 1; iDet >= 0; iDet--) {
2442     if (!fTracker[iDet]) continue;
2443     AliDebug(1, Form("%s tracking", fgkDetectorName[iDet]));
2444
2445     // load clusters
2446     fLoader[iDet]->LoadRecPoints("read");
2447     AliSysInfo::AddStamp(Form("RLoadCluster%s_%d",fgkDetectorName[iDet],eventNr),iDet,1, eventNr);
2448     TTree* tree = fLoader[iDet]->TreeR();
2449     if (!tree) {
2450       AliError(Form("Can't get the %s cluster tree", fgkDetectorName[iDet]));
2451       return kFALSE;
2452     }
2453     fTracker[iDet]->LoadClusters(tree);
2454     AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2455     // run tracking
2456     if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
2457       AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
2458       return kFALSE;
2459     }
2460     // preliminary PID in TPC needed by the ITS tracker
2461     if (iDet == 1) {
2462       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2463       AliESDpid::MakePID(esd);
2464     }
2465     AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
2466   }
2467
2468   // pass 2: ALL backwards
2469
2470   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2471     if (!fTracker[iDet]) continue;
2472     AliDebug(1, Form("%s back propagation", fgkDetectorName[iDet]));
2473
2474     // load clusters
2475     if (iDet > 1) {     // all except ITS, TPC
2476       TTree* tree = NULL;
2477       fLoader[iDet]->LoadRecPoints("read");
2478       AliSysInfo::AddStamp(Form("RLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,1, eventNr);
2479       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("TLoadCluster0%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
2486     }
2487
2488     // run tracking
2489     if (iDet>1) // start filling residuals for the "outer" detectors
2490       if (fRunGlobalQA) {
2491         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2492         TObjArray ** arr = AliTracker::GetResidualsArray() ;
2493         if (arr) {
2494           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2495           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
2496           if ( elem && (! elem->At(0)) ) {
2497             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2498             if (qadm) qadm->InitRecPointsForTracker() ;
2499           }
2500         }
2501       }
2502     if (fTracker[iDet]->PropagateBack(esd) != 0) {
2503       AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
2504       //      return kFALSE;
2505     }
2506
2507     // unload clusters
2508     if (iDet > 3) {     // all except ITS, TPC, TRD and TOF
2509       fTracker[iDet]->UnloadClusters();
2510       fLoader[iDet]->UnloadRecPoints();
2511     }
2512     // updated PID in TPC needed by the ITS tracker -MI
2513     if (iDet == 1) {
2514       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
2515       AliESDpid::MakePID(esd);
2516     }
2517     AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2518   }
2519   //stop filling residuals for the "outer" detectors
2520   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
2521
2522   // pass 3: TRD + TPC + ITS refit inwards
2523
2524   for (Int_t iDet = 2; iDet >= 0; iDet--) {
2525     if (!fTracker[iDet]) continue;
2526     AliDebug(1, Form("%s inward refit", fgkDetectorName[iDet]));
2527
2528     // run tracking
2529     if (iDet<2) // start filling residuals for TPC and ITS
2530       if (fRunGlobalQA) {
2531         AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kTRUE);
2532         TObjArray ** arr = AliTracker::GetResidualsArray() ;
2533         if (arr) {
2534           AliRecoParam::EventSpecie_t es=fRecoParam.GetEventSpecie();
2535           TObjArray * elem = arr[AliRecoParam::AConvert(es)];
2536           if ( elem && (! elem->At(0)) ) {
2537             AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
2538             if (qadm) qadm->InitRecPointsForTracker() ;
2539           }
2540         }
2541       }
2542
2543     if (fTracker[iDet]->RefitInward(esd) != 0) {
2544       AliError(Form("%s inward refit failed", fgkDetectorName[iDet]));
2545       //      return kFALSE;
2546     }
2547     // run postprocessing
2548     if (fTracker[iDet]->PostProcess(esd) != 0) {
2549       AliError(Form("%s postprocessing failed", fgkDetectorName[iDet]));
2550       //      return kFALSE;
2551     }
2552     AliSysInfo::AddStamp(Form("Tracking2%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
2553   }
2554
2555   // write space-points to the ESD in case alignment data output
2556   // is switched on
2557   if (fWriteAlignmentData)
2558     WriteAlignmentData(esd);
2559
2560   for (Int_t iDet = 3; iDet >= 0; iDet--) {
2561     if (!fTracker[iDet]) continue;
2562     // unload clusters
2563     fTracker[iDet]->UnloadClusters();
2564     AliSysInfo::AddStamp(Form("TUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,4, eventNr);
2565     fLoader[iDet]->UnloadRecPoints();
2566     AliSysInfo::AddStamp(Form("RUnloadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,5, eventNr);
2567   }
2568   // stop filling residuals for TPC and ITS
2569   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);
2570
2571   eventNr++;
2572   return kTRUE;
2573 }
2574
2575 //_____________________________________________________________________________
2576 Bool_t AliReconstruction::CleanESD(AliESDEvent *esd){
2577   //
2578   // Remove the data which are not needed for the physics analysis.
2579   //
2580
2581   Int_t nTracks=esd->GetNumberOfTracks();
2582   Int_t nV0s=esd->GetNumberOfV0s();
2583   AliInfo
2584   (Form("Number of ESD tracks and V0s before cleaning: %d %d",nTracks,nV0s));
2585
2586   Float_t cleanPars[]={fV0DCAmax,fV0CsPmin,fDmax,fZmax};
2587   Bool_t rc=esd->Clean(cleanPars);
2588
2589   nTracks=esd->GetNumberOfTracks();
2590   nV0s=esd->GetNumberOfV0s();
2591   AliInfo
2592   (Form("Number of ESD tracks and V0s after cleaning %d %d",nTracks,nV0s));
2593
2594   return rc;
2595 }
2596
2597 //_____________________________________________________________________________
2598 Bool_t AliReconstruction::FillESD(AliESDEvent*& esd, const TString& detectors)
2599 {
2600 // fill the event summary data
2601
2602   AliCodeTimerAuto("",0)
2603     static Int_t eventNr=0;
2604   TString detStr = detectors;
2605
2606   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2607   if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2608     AliReconstructor* reconstructor = GetReconstructor(iDet);
2609     if (!reconstructor) continue;
2610     AliDebug(1, Form("filling ESD for %s", fgkDetectorName[iDet]));
2611     TTree* clustersTree = NULL;
2612     if (fLoader[iDet]) {
2613       fLoader[iDet]->LoadRecPoints("read");
2614       clustersTree = fLoader[iDet]->TreeR();
2615       if (!clustersTree) {
2616         AliError(Form("Can't get the %s clusters tree",
2617                       fgkDetectorName[iDet]));
2618         if (fStopOnError) return kFALSE;
2619       }
2620     }
2621     if (fRawReader && !reconstructor->HasDigitConversion()) {
2622       reconstructor->FillESD(fRawReader, clustersTree, esd);
2623     } else {
2624       TTree* digitsTree = NULL;
2625       if (fLoader[iDet]) {
2626         fLoader[iDet]->LoadDigits("read");
2627         digitsTree = fLoader[iDet]->TreeD();
2628         if (!digitsTree) {
2629           AliError(Form("Can't get the %s digits tree",
2630                         fgkDetectorName[iDet]));
2631           if (fStopOnError) return kFALSE;
2632         }
2633       }
2634       reconstructor->FillESD(digitsTree, clustersTree, esd);
2635       if (fLoader[iDet]) fLoader[iDet]->UnloadDigits();
2636     }
2637     if (fLoader[iDet]) {
2638       fLoader[iDet]->UnloadRecPoints();
2639     }
2640   }
2641
2642   IsSelected("CTP", detStr);
2643   if ((detStr.CompareTo("ALL") != 0) && !detStr.IsNull()) {
2644     AliError(Form("the following detectors were not found: %s",
2645                   detStr.Data()));
2646     if (fStopOnError) return kFALSE;
2647   }
2648   AliSysInfo::AddStamp(Form("FillESD%d",eventNr), 0,1, eventNr);
2649   eventNr++;
2650   return kTRUE;
2651 }
2652
2653 //_____________________________________________________________________________
2654 Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
2655 {
2656   // Reads the trigger decision which is
2657   // stored in Trigger.root file and fills
2658   // the corresponding esd entries
2659
2660   AliCodeTimerAuto("",0)
2661
2662   AliInfo("Filling trigger information into the ESD");
2663
2664   if (fRawReader) {
2665     AliCTPRawStream input(fRawReader);
2666     if (!input.Next()) {
2667       AliWarning("No valid CTP (trigger) DDL raw data is found ! The trigger info is taken from the event header!");
2668     }
2669     else {
2670       if (esd->GetTriggerMask() != input.GetClassMask())
2671         AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
2672                       input.GetClassMask(),esd->GetTriggerMask()));
2673       if (esd->GetOrbitNumber() != input.GetOrbitID())
2674         AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
2675                       input.GetOrbitID(),esd->GetOrbitNumber()));
2676       if (esd->GetBunchCrossNumber() != input.GetBCID())
2677         AliError(Form("Invalid bunch-crossing id found in CTP raw-data: %x %x",
2678                       input.GetBCID(),esd->GetBunchCrossNumber()));
2679       AliESDHeader* esdheader = esd->GetHeader();
2680       esdheader->SetL0TriggerInputs(input.GetL0Inputs());
2681       esdheader->SetL1TriggerInputs(input.GetL1Inputs());
2682       esdheader->SetL2TriggerInputs(input.GetL2Inputs());
2683       // IR
2684       UInt_t orbit=input.GetOrbitID();
2685        for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
2686           if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
2687              esdheader->AddTriggerIR(input.GetIR(i));
2688           }
2689     }
2690   }
2691   return kTRUE;
2692 }
2693 //_____________________________________________________________________________
2694 Bool_t AliReconstruction::FillTriggerScalers(AliESDEvent*& esd)
2695 {
2696   //Scalers
2697   //fRunScalers->Print();
2698   if(fRunScalers && fRunScalers->CheckRunScalers()){
2699      AliTimeStamp* timestamp = new AliTimeStamp(esd->GetOrbitNumber(), esd->GetPeriodNumber(), esd->GetBunchCrossNumber());
2700      //AliTimeStamp* timestamp = new AliTimeStamp(10308000, 0, (ULong64_t)486238);
2701      AliESDHeader* esdheader = fesd->GetHeader();
2702      for(Int_t i=0;i<50;i++){
2703           if((1ull<<i) & esd->GetTriggerMask()){
2704           AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+1);
2705           if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
2706         }
2707      }
2708   }
2709   return kTRUE;
2710 }
2711 //_____________________________________________________________________________
2712 Bool_t AliReconstruction::FillRawEventHeaderESD(AliESDEvent*& esd)
2713 {
2714   //
2715   // Filling information from RawReader Header
2716   //
2717
2718   if (!fRawReader) return kFALSE;
2719
2720   AliInfo("Filling information from RawReader Header");
2721
2722   esd->SetBunchCrossNumber(fRawReader->GetBCID());
2723   esd->SetOrbitNumber(fRawReader->GetOrbitID());
2724   esd->SetPeriodNumber(fRawReader->GetPeriod());
2725
2726   esd->SetTimeStamp(fRawReader->GetTimestamp());
2727   esd->SetEventType(fRawReader->GetType());
2728
2729   return kTRUE;
2730 }
2731
2732
2733 //_____________________________________________________________________________
2734 Bool_t AliReconstruction::IsSelected(TString detName, TString& detectors) const
2735 {
2736 // check whether detName is contained in detectors
2737 // if yes, it is removed from detectors
2738
2739   // check if all detectors are selected
2740   if ((detectors.CompareTo("ALL") == 0) ||
2741       detectors.BeginsWith("ALL ") ||
2742       detectors.EndsWith(" ALL") ||
2743       detectors.Contains(" ALL ")) {
2744     detectors = "ALL";
2745     return kTRUE;
2746   }
2747
2748   // search for the given detector
2749   Bool_t result = kFALSE;
2750   if ((detectors.CompareTo(detName) == 0) ||
2751       detectors.BeginsWith(detName+" ") ||
2752       detectors.EndsWith(" "+detName) ||
2753       detectors.Contains(" "+detName+" ")) {
2754     detectors.ReplaceAll(detName, "");
2755     result = kTRUE;
2756   }
2757
2758   // clean up the detectors string
2759   while (detectors.Contains("  ")) detectors.ReplaceAll("  ", " ");
2760   while (detectors.BeginsWith(" ")) detectors.Remove(0, 1);
2761   while (detectors.EndsWith(" ")) detectors.Remove(detectors.Length()-1, 1);
2762
2763   return result;
2764 }
2765
2766 //_____________________________________________________________________________
2767 Bool_t AliReconstruction::InitRunLoader()
2768 {
2769 // get or create the run loader
2770
2771   if (gAlice) delete gAlice;
2772   gAlice = NULL;
2773
2774   TFile *gafile = TFile::Open(fGAliceFileName.Data());
2775   //  if (!gSystem->AccessPathName(fGAliceFileName.Data())) { // galice.root exists
2776   if (gafile) { // galice.root exists
2777     gafile->Close();
2778     delete gafile;
2779
2780     // load all base libraries to get the loader classes
2781     TString libs = gSystem->GetLibraries();
2782     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2783       TString detName = fgkDetectorName[iDet];
2784       if (detName == "HLT") continue;
2785       if (libs.Contains("lib" + detName + "base.so")) continue;
2786       gSystem->Load("lib" + detName + "base.so");
2787     }
2788     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
2789     if (!fRunLoader) {
2790       AliError(Form("no run loader found in file %s", fGAliceFileName.Data()));
2791       CleanUp();
2792       return kFALSE;
2793     }
2794
2795     fRunLoader->CdGAFile();
2796     fRunLoader->LoadgAlice();
2797
2798     //PH This is a temporary fix to give access to the kinematics
2799     //PH that is needed for the labels of ITS clusters
2800     fRunLoader->LoadHeader();
2801     fRunLoader->LoadKinematics();
2802
2803   } else {               // galice.root does not exist
2804     if (!fRawReader) {
2805       AliError(Form("the file %s does not exist", fGAliceFileName.Data()));
2806     }
2807     fRunLoader = AliRunLoader::Open(fGAliceFileName.Data(),
2808                                     AliConfig::GetDefaultEventFolderName(),
2809                                     "recreate");
2810     if (!fRunLoader) {
2811       AliError(Form("could not create run loader in file %s",
2812                     fGAliceFileName.Data()));
2813       CleanUp();
2814       return kFALSE;
2815     }
2816     fIsNewRunLoader = kTRUE;
2817     fRunLoader->MakeTree("E");
2818
2819     if (fNumberOfEventsPerFile > 0)
2820       fRunLoader->SetNumberOfEventsPerFile(fNumberOfEventsPerFile);
2821     else
2822       fRunLoader->SetNumberOfEventsPerFile((UInt_t)-1);
2823   }
2824
2825   return kTRUE;
2826 }
2827
2828 //_____________________________________________________________________________
2829 AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
2830 {
2831 // get the reconstructor object and the loader for a detector
2832
2833   if (fReconstructor[iDet]) {
2834     if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2835       const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2836       fReconstructor[iDet]->SetRecoParam(par);
2837       fReconstructor[iDet]->SetRunInfo(fRunInfo);
2838     }
2839     return fReconstructor[iDet];
2840   }
2841
2842   // load the reconstructor object
2843   TPluginManager* pluginManager = gROOT->GetPluginManager();
2844   TString detName = fgkDetectorName[iDet];
2845   TString recName = "Ali" + detName + "Reconstructor";
2846
2847   if (!fIsNewRunLoader && !fRunLoader->GetLoader(detName+"Loader") && (detName != "HLT")) return NULL;
2848
2849   AliReconstructor* reconstructor = NULL;
2850   // first check if a plugin is defined for the reconstructor
2851   TPluginHandler* pluginHandler =
2852     pluginManager->FindHandler("AliReconstructor", detName);
2853   // if not, add a plugin for it
2854   if (!pluginHandler) {
2855     AliDebug(1, Form("defining plugin for %s", recName.Data()));
2856     TString libs = gSystem->GetLibraries();
2857     if (libs.Contains("lib" + detName + "base.so") ||
2858         (gSystem->Load("lib" + detName + "base.so") >= 0)) {
2859       pluginManager->AddHandler("AliReconstructor", detName,
2860                                 recName, detName + "rec", recName + "()");
2861     } else {
2862       pluginManager->AddHandler("AliReconstructor", detName,
2863                                 recName, detName, recName + "()");
2864     }
2865     pluginHandler = pluginManager->FindHandler("AliReconstructor", detName);
2866   }
2867   if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2868     reconstructor = (AliReconstructor*) pluginHandler->ExecPlugin(0);
2869   }
2870   if (reconstructor) {
2871     TObject* obj = fOptions.FindObject(detName.Data());
2872     if (obj) reconstructor->SetOption(obj->GetTitle());
2873     reconstructor->SetRunInfo(fRunInfo);
2874     reconstructor->Init();
2875     fReconstructor[iDet] = reconstructor;
2876   }
2877
2878   // get or create the loader
2879   if (detName != "HLT") {
2880     fLoader[iDet] = fRunLoader->GetLoader(detName + "Loader");
2881     if (!fLoader[iDet]) {
2882       AliConfig::Instance()
2883         ->CreateDetectorFolders(fRunLoader->GetEventFolder(),
2884                                 detName, detName);
2885       // first check if a plugin is defined for the loader
2886       pluginHandler =
2887         pluginManager->FindHandler("AliLoader", detName);
2888       // if not, add a plugin for it
2889       if (!pluginHandler) {
2890         TString loaderName = "Ali" + detName + "Loader";
2891         AliDebug(1, Form("defining plugin for %s", loaderName.Data()));
2892         pluginManager->AddHandler("AliLoader", detName,
2893                                   loaderName, detName + "base",
2894                                   loaderName + "(const char*, TFolder*)");
2895         pluginHandler = pluginManager->FindHandler("AliLoader", detName);
2896       }
2897       if (pluginHandler && (pluginHandler->LoadPlugin() == 0)) {
2898         fLoader[iDet] =
2899           (AliLoader*) pluginHandler->ExecPlugin(2, detName.Data(),
2900                                                  fRunLoader->GetEventFolder());
2901       }
2902       if (!fLoader[iDet]) {   // use default loader
2903         fLoader[iDet] = new AliLoader(detName, fRunLoader->GetEventFolder());
2904       }
2905       if (!fLoader[iDet]) {
2906         AliWarning(Form("couldn't get loader for %s", detName.Data()));
2907         if (fStopOnError) return NULL;
2908       } else {
2909         fRunLoader->AddLoader(fLoader[iDet]);
2910         fRunLoader->CdGAFile();
2911         if (gFile && !gFile->IsWritable()) gFile->ReOpen("UPDATE");
2912         fRunLoader->Write(0, TObject::kOverwrite);
2913       }
2914     }
2915   }
2916
2917   if (fRecoParam.GetDetRecoParamArray(iDet) && !AliReconstructor::GetRecoParam(iDet)) {
2918     const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
2919     reconstructor->SetRecoParam(par);
2920     reconstructor->SetRunInfo(fRunInfo);
2921   }
2922   return reconstructor;
2923 }
2924
2925 //_____________________________________________________________________________
2926 AliVertexer* AliReconstruction::CreateVertexer()
2927 {
2928 // create the vertexer
2929 // Please note that the caller is the owner of the
2930 // vertexer
2931
2932   AliVertexer* vertexer = NULL;
2933   AliReconstructor* itsReconstructor = GetReconstructor(0);
2934   if (itsReconstructor && ((fRunLocalReconstruction.Contains("ITS")) || fRunTracking.Contains("ITS"))) {
2935     vertexer = itsReconstructor->CreateVertexer();
2936   }
2937   if (!vertexer) {
2938     AliWarning("couldn't create a vertexer for ITS");
2939   }
2940
2941   return vertexer;
2942 }
2943
2944 //_____________________________________________________________________________
2945 Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
2946 {
2947 // create the trackers
2948         AliInfo("Creating trackers");
2949
2950   TString detStr = detectors;
2951   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2952     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
2953     AliReconstructor* reconstructor = GetReconstructor(iDet);
2954     if (!reconstructor) continue;
2955     TString detName = fgkDetectorName[iDet];
2956     if (detName == "HLT") {
2957       fRunHLTTracking = kTRUE;
2958       continue;
2959     }
2960     if (detName == "MUON") {
2961       fRunMuonTracking = kTRUE;
2962       continue;
2963     }
2964
2965
2966     fTracker[iDet] = reconstructor->CreateTracker();
2967     if (!fTracker[iDet] && (iDet < 7)) {
2968       AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
2969       if (fStopOnError) return kFALSE;
2970     }
2971     AliSysInfo::AddStamp(Form("LTracker%s",fgkDetectorName[iDet]), iDet,0);
2972   }
2973
2974   return kTRUE;
2975 }
2976
2977 //_____________________________________________________________________________
2978 void AliReconstruction::CleanUp()
2979 {
2980 // delete trackers and the run loader and close and delete the file
2981
2982   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
2983     delete fReconstructor[iDet];
2984     fReconstructor[iDet] = NULL;
2985     fLoader[iDet] = NULL;
2986     delete fTracker[iDet];
2987     fTracker[iDet] = NULL;
2988   }
2989   delete fRunInfo;
2990   fRunInfo = NULL;
2991
2992   delete fSPDTrackleter;
2993   fSPDTrackleter = NULL;
2994
2995   delete ftVertexer;
2996   ftVertexer = NULL;
2997
2998   delete fRunLoader;
2999   fRunLoader = NULL;
3000   delete fRawReader;
3001   fRawReader = NULL;
3002   delete fParentRawReader;
3003   fParentRawReader=NULL;
3004
3005   if (ffile) {
3006     ffile->Close();
3007     delete ffile;
3008     ffile = NULL;
3009   }
3010
3011   if (AliQAManager::QAManager())
3012     AliQAManager::QAManager()->ShowQA() ;
3013   AliQAManager::Destroy() ;
3014
3015 }
3016
3017 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
3018 {
3019   // Write space-points which are then used in the alignment procedures
3020   // For the moment only ITS, TPC, TRD and TOF
3021
3022   Int_t ntracks = esd->GetNumberOfTracks();
3023   for (Int_t itrack = 0; itrack < ntracks; itrack++)
3024     {
3025       AliESDtrack *track = esd->GetTrack(itrack);
3026       Int_t nsp = 0;
3027       Int_t idx[200];
3028       for (Int_t i=0; i<200; ++i) idx[i] = -1; //PH avoid uninitialized values
3029       for (Int_t iDet = 5; iDet >= 0; iDet--) {// TOF, TRD, TPC, ITS clusters
3030           nsp += (iDet==GetDetIndex("TRD")) ? track->GetTRDntracklets():track->GetNcls(iDet);
3031
3032           if (iDet==GetDetIndex("ITS")) { // ITS "extra" clusters
3033              track->GetClusters(iDet,idx);
3034              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nsp++;
3035           }
3036       }
3037
3038       if (nsp) {
3039         AliTrackPointArray *sp = new AliTrackPointArray(nsp);
3040         track->SetTrackPointArray(sp);
3041         Int_t isptrack = 0;
3042         for (Int_t iDet = 5; iDet >= 0; iDet--) {
3043           AliTracker *tracker = fTracker[iDet];
3044           if (!tracker) continue;
3045           Int_t nspdet = (iDet==GetDetIndex("TRD")) ? track->GetTRDtracklets(idx):track->GetClusters(iDet,idx);
3046
3047           if (iDet==GetDetIndex("ITS")) // ITS "extra" clusters
3048              for (Int_t i=6; i<12; i++) if(idx[i] >= 0) nspdet++;
3049
3050           if (nspdet <= 0) continue;
3051           AliTrackPoint p;
3052           Int_t isp = 0;
3053           Int_t isp2 = 0;
3054           while (isp2 < nspdet) {
3055             Bool_t isvalid=kTRUE;
3056
3057             Int_t index=idx[isp++];
3058             if (index < 0) continue;
3059
3060             TString dets = fgkDetectorName[iDet];
3061             if ((fUseTrackingErrorsForAlignment.CompareTo(dets) == 0) ||
3062             fUseTrackingErrorsForAlignment.BeginsWith(dets+" ") ||
3063             fUseTrackingErrorsForAlignment.EndsWith(" "+dets) ||
3064             fUseTrackingErrorsForAlignment.Contains(" "+dets+" ")) {
3065               isvalid = tracker->GetTrackPointTrackingError(index,p,track);
3066             } else {
3067               isvalid = tracker->GetTrackPoint(index,p);
3068             }
3069             isp2++;
3070             if (!isvalid) continue;
3071             if (iDet==GetDetIndex("ITS") && (isp-1)>=6) p.SetExtra();
3072             sp->AddPoint(isptrack,&p); isptrack++;
3073           }
3074         }
3075       }
3076     }
3077 }
3078
3079 //_____________________________________________________________________________
3080 void AliReconstruction::FillRawDataErrorLog(Int_t iEvent, AliESDEvent* esd)
3081 {
3082   // The method reads the raw-data error log
3083   // accumulated within the rawReader.
3084   // It extracts the raw-data errors related to
3085   // the current event and stores them into
3086   // a TClonesArray inside the esd object.
3087
3088   if (!fRawReader) return;
3089
3090   for(Int_t i = 0; i < fRawReader->GetNumberOfErrorLogs(); i++) {
3091
3092     AliRawDataErrorLog *log = fRawReader->GetErrorLog(i);
3093     if (!log) continue;
3094     if (iEvent != log->GetEventNumber()) continue;
3095
3096     esd->AddRawDataErrorLog(log);
3097   }
3098
3099 }
3100
3101 //_____________________________________________________________________________
3102 void AliReconstruction::CheckQA()
3103 {
3104 // check the QA of SIM for this run and remove the detectors
3105 // with status Fatal
3106
3107 //      TString newRunLocalReconstruction ;
3108 //      TString newRunTracking ;
3109 //      TString newFillESD ;
3110 //
3111 //      for (Int_t iDet = 0; iDet < AliQAv1::kNDET; iDet++) {
3112 //              TString detName(AliQAv1::GetDetName(iDet)) ;
3113 //              AliQAv1 * qa = AliQAv1::Instance(AliQAv1::DETECTORINDEX_t(iDet)) ;
3114 //      if ( qa->IsSet(AliQAv1::DETECTORINDEX_t(iDet), AliQAv1::kSIM, specie, AliQAv1::kFATAL)) {
3115 //        AliInfo(Form("QA status for %s %s in Hits and/or SDIGITS  and/or Digits was Fatal; No reconstruction performed",
3116 //                   detName.Data(), AliRecoParam::GetEventSpecieName(es))) ;
3117 //                      } else {
3118 //                      if ( fRunLocalReconstruction.Contains(AliQAv1::GetDetName(iDet)) ||
3119 //                                      fRunLocalReconstruction.Contains("ALL") )  {
3120 //                              newRunLocalReconstruction += detName ;
3121 //                              newRunLocalReconstruction += " " ;
3122 //                      }
3123 //                      if ( fRunTracking.Contains(AliQAv1::GetDetName(iDet)) ||
3124 //                                      fRunTracking.Contains("ALL") )  {
3125 //                              newRunTracking += detName ;
3126 //                              newRunTracking += " " ;
3127 //                      }
3128 //                      if ( fFillESD.Contains(AliQAv1::GetDetName(iDet)) ||
3129 //                                      fFillESD.Contains("ALL") )  {
3130 //                              newFillESD += detName ;
3131 //                              newFillESD += " " ;
3132 //                      }
3133 //              }
3134 //      }
3135 //      fRunLocalReconstruction = newRunLocalReconstruction ;
3136 //      fRunTracking            = newRunTracking ;
3137 //      fFillESD                = newFillESD ;
3138 }
3139
3140 //_____________________________________________________________________________
3141 Int_t AliReconstruction::GetDetIndex(const char* detector)
3142 {
3143   // return the detector index corresponding to detector
3144   Int_t index = -1 ;
3145   for (index = 0; index < kNDetectors ; index++) {
3146     if ( strcmp(detector, fgkDetectorName[index]) == 0 )
3147         break ;
3148   }
3149   return index ;
3150 }
3151 //_____________________________________________________________________________
3152 Bool_t AliReconstruction::FinishPlaneEff() {
3153  //
3154  // Here execute all the necessary operationis, at the end of the tracking phase,
3155  // in case that evaluation of PlaneEfficiencies was required for some detector.
3156  // E.g., write into a DataBase file the PlaneEfficiency which have been evaluated.
3157  //
3158  // This Preliminary version works only FOR ITS !!!!!
3159  // other detectors (TOF,TRD, etc. have to develop their specific codes)
3160  //
3161  //  Input: none
3162  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
3163  //
3164  Bool_t ret=kFALSE;
3165  TString detStr = fLoadCDB;
3166  //for (Int_t iDet = 0; iDet < fgkNDetectors; iDet++) {
3167  for (Int_t iDet = 0; iDet < 1; iDet++) { // for the time being only ITS
3168    if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3169    if(fTracker[iDet] && fTracker[iDet]->GetPlaneEff()) {
3170       AliPlaneEff *planeeff=fTracker[iDet]->GetPlaneEff();
3171       TString name=planeeff->GetName();
3172       name+=".root";
3173       TFile* pefile = TFile::Open(name, "RECREATE");
3174       ret=(Bool_t)planeeff->Write();
3175       pefile->Close();
3176       if(planeeff->GetCreateHistos()) {
3177         TString hname=planeeff->GetName();
3178         hname+="Histo.root";
3179         ret*=planeeff->WriteHistosToFile(hname,"RECREATE");
3180       }
3181    }
3182    if(fSPDTrackleter) {
3183      AliPlaneEff *planeeff=fSPDTrackleter->GetPlaneEff();
3184       TString name="AliITSPlaneEffSPDtracklet.root";
3185       TFile* pefile = TFile::Open(name, "RECREATE");
3186       ret=(Bool_t)planeeff->Write();
3187       pefile->Close();
3188       AliESDEvent *dummy=NULL;
3189       ret=(Bool_t)fSPDTrackleter->PostProcess(dummy); // take care of writing other files
3190    }
3191  }
3192  return ret;
3193 }
3194 //_____________________________________________________________________________
3195 Bool_t AliReconstruction::InitPlaneEff() {
3196 //
3197  // Here execute all the necessary operations, before of the tracking phase,
3198  // for the evaluation of PlaneEfficiencies, in case required for some detectors.
3199  // E.g., read from a DataBase file a first evaluation of the PlaneEfficiency
3200  // which should be updated/recalculated.
3201  //
3202  // This Preliminary version will work only FOR ITS !!!!!
3203  // other detectors (TOF,TRD, etc. have to develop their specific codes)
3204  //
3205  //  Input: none
3206  //  Return: kTRUE if all operations have been done properly, kFALSE otherwise
3207  //
3208  AliWarning(Form("Implementation of this method not yet completed !! Method return kTRUE"));
3209
3210   fSPDTrackleter = NULL;
3211   TString detStr = fLoadCDB;
3212   if (IsSelected(fgkDetectorName[0], detStr)) {
3213     AliReconstructor* itsReconstructor = GetReconstructor(0);
3214     if (itsReconstructor) {
3215       fSPDTrackleter = itsReconstructor->CreateTrackleter(); // this is NULL unless required in RecoParam
3216     }
3217     if (fSPDTrackleter) {
3218       AliInfo("Trackleter for SPD has been created");
3219     }
3220   }
3221  return kTRUE;
3222 }
3223
3224 //_____________________________________________________________________________
3225 Bool_t AliReconstruction::InitAliEVE()
3226 {
3227   // This method should be called only in case
3228   // AliReconstruction is run
3229   // within the alieve environment.
3230   // It will initialize AliEVE in a way
3231   // so that it can visualize event processed
3232   // by AliReconstruction.
3233   // The return flag shows whenever the
3234   // AliEVE initialization was successful or not.
3235
3236   TString macroStr;
3237   macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
3238   AliInfo(Form("Loading AliEVE macro: %s",macroStr.Data()));
3239   if (gROOT->LoadMacro(macroStr.Data()) != 0) return kFALSE;
3240
3241   gROOT->ProcessLine("if (!AliEveEventManager::GetMaster()){new AliEveEventManager();AliEveEventManager::GetMaster()->AddNewEventCommand(\"alieve_online_on_new_event()\");gEve->AddEvent(AliEveEventManager::GetMaster());};");
3242   gROOT->ProcessLine("alieve_online_init()");
3243
3244   return kTRUE;
3245 }
3246
3247 //_____________________________________________________________________________
3248 void AliReconstruction::RunAliEVE()
3249 {
3250   // Runs AliEVE visualisation of
3251   // the current event.
3252   // Should be executed only after
3253   // successful initialization of AliEVE.
3254
3255   AliInfo("Running AliEVE...");
3256   gROOT->ProcessLine(Form("AliEveEventManager::GetMaster()->SetEvent((AliRunLoader*)0x%lx,(AliRawReader*)0x%lx,(AliESDEvent*)0x%lx,(AliESDfriend*)0x%lx);",fRunLoader,fRawReader,fesd,fesdf));
3257   gSystem->Run();
3258 }
3259
3260 //_____________________________________________________________________________
3261 Bool_t AliReconstruction::SetRunQA(TString detAndAction)
3262 {
3263         // Allows to run QA for a selected set of detectors
3264         // and a selected set of tasks among RAWS, DIGITSR, RECPOINTS and ESDS
3265         // all selected detectors run the same selected tasks
3266
3267         if (!detAndAction.Contains(":")) {
3268                 AliError( Form("%s is a wrong syntax, use \"DetectorList:ActionList\" \n", detAndAction.Data()) ) ;
3269                 fRunQA = kFALSE ;
3270                 return kFALSE ;
3271         }
3272         Int_t colon = detAndAction.Index(":") ;
3273         fQADetectors = detAndAction(0, colon) ;
3274         fQATasks   = detAndAction(colon+1, detAndAction.Sizeof() ) ;
3275         if (fQATasks.Contains("ALL") ) {
3276                 fQATasks = Form("%d %d %d %d", AliQAv1::kRAWS, AliQAv1::kDIGITSR, AliQAv1::kRECPOINTS, AliQAv1::kESDS) ;
3277         } else {
3278                 fQATasks.ToUpper() ;
3279                 TString tempo("") ;
3280                 if ( fQATasks.Contains("RAW") )
3281                         tempo = Form("%d ", AliQAv1::kRAWS) ;
3282                 if ( fQATasks.Contains("DIGIT") )
3283                         tempo += Form("%d ", AliQAv1::kDIGITSR) ;
3284                 if ( fQATasks.Contains("RECPOINT") )
3285                         tempo += Form("%d ", AliQAv1::kRECPOINTS) ;
3286                 if ( fQATasks.Contains("ESD") )
3287                         tempo += Form("%d ", AliQAv1::kESDS) ;
3288                 fQATasks = tempo ;
3289                 if (fQATasks.IsNull()) {
3290                         AliInfo("No QA requested\n")  ;
3291                         fRunQA = kFALSE ;
3292                         return kTRUE ;
3293                 }
3294         }
3295         TString tempo(fQATasks) ;
3296         tempo.ReplaceAll(Form("%d", AliQAv1::kRAWS), AliQAv1::GetTaskName(AliQAv1::kRAWS))      ;
3297         tempo.ReplaceAll(Form("%d", AliQAv1::kDIGITSR), AliQAv1::GetTaskName(AliQAv1::kDIGITSR)) ;
3298         tempo.ReplaceAll(Form("%d", AliQAv1::kRECPOINTS), AliQAv1::GetTaskName(AliQAv1::kRECPOINTS)) ;
3299         tempo.ReplaceAll(Form("%d", AliQAv1::kESDS), AliQAv1::GetTaskName(AliQAv1::kESDS)) ;
3300         AliInfo( Form("QA will be done on \"%s\" for \"%s\"\n", fQADetectors.Data(), tempo.Data()) ) ;
3301         fRunQA = kTRUE ;
3302         return kTRUE;
3303 }
3304
3305 //_____________________________________________________________________________
3306 Bool_t AliReconstruction::InitRecoParams()
3307 {
3308   // The method accesses OCDB and retrieves all
3309   // the available reco-param objects from there.
3310
3311   Bool_t isOK = kTRUE;
3312
3313   if (fRecoParam.GetDetRecoParamArray(kNDetectors)) {
3314     AliInfo("Using custom GRP reconstruction parameters");
3315   }
3316   else {
3317     AliInfo("Loading GRP reconstruction parameter objects");
3318
3319     AliCDBPath path("GRP","Calib","RecoParam");
3320     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3321     if(!entry){
3322       AliWarning("Couldn't find GRP RecoParam entry in OCDB");
3323       isOK = kFALSE;
3324     }
3325     else {
3326       TObject *recoParamObj = entry->GetObject();
3327       if (dynamic_cast<TObjArray*>(recoParamObj)) {
3328         // GRP has a normal TobjArray of AliDetectorRecoParam objects
3329         // Registering them in AliRecoParam
3330         fRecoParam.AddDetRecoParamArray(kNDetectors,dynamic_cast<TObjArray*>(recoParamObj));
3331       }
3332       else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3333         // GRP has only onse set of reco parameters
3334         // Registering it in AliRecoParam
3335         AliInfo("Single set of GRP reconstruction parameters found");
3336         dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3337         fRecoParam.AddDetRecoParam(kNDetectors,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3338       }
3339       else {
3340         AliError("No valid GRP RecoParam object found in the OCDB");
3341         isOK = kFALSE;
3342       }
3343       entry->SetOwner(0);
3344     }
3345   }
3346
3347   TString detStr = fLoadCDB;
3348   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
3349
3350     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
3351
3352     if (fRecoParam.GetDetRecoParamArray(iDet)) {
3353       AliInfo(Form("Using custom reconstruction parameters for detector %s",fgkDetectorName[iDet]));
3354       continue;
3355     }
3356
3357     AliInfo(Form("Loading reconstruction parameter objects for detector %s",fgkDetectorName[iDet]));
3358
3359     AliCDBPath path(fgkDetectorName[iDet],"Calib","RecoParam");
3360     AliCDBEntry *entry=AliCDBManager::Instance()->Get(path.GetPath());
3361     if(!entry){
3362       AliWarning(Form("Couldn't find RecoParam entry in OCDB for detector %s",fgkDetectorName[iDet]));
3363       isOK = kFALSE;
3364     }
3365     else {
3366       TObject *recoParamObj = entry->GetObject();
3367       if (dynamic_cast<TObjArray*>(recoParamObj)) {
3368         // The detector has a normal TobjArray of AliDetectorRecoParam objects
3369         // Registering them in AliRecoParam
3370         fRecoParam.AddDetRecoParamArray(iDet,dynamic_cast<TObjArray*>(recoParamObj));
3371       }
3372       else if (dynamic_cast<AliDetectorRecoParam*>(recoParamObj)) {
3373         // The detector has only onse set of reco parameters
3374         // Registering it in AliRecoParam
3375         AliInfo(Form("Single set of reconstruction parameters found for detector %s",fgkDetectorName[iDet]));
3376         dynamic_cast<AliDetectorRecoParam*>(recoParamObj)->SetAsDefault();
3377         fRecoParam.AddDetRecoParam(iDet,dynamic_cast<AliDetectorRecoParam*>(recoParamObj));
3378       }
3379       else {
3380         AliError(Form("No valid RecoParam object found in the OCDB for detector %s",fgkDetectorName[iDet]));
3381         isOK = kFALSE;
3382       }
3383       entry->SetOwner(0);
3384       //      FIX ME: We have to disable the unloading of reco-param CDB
3385       //      entries because QA framework is using them. Has to be fix in
3386       //      a way that the QA takes the objects already constructed in
3387       //      this method.
3388       //      AliCDBManager::Instance()->UnloadFromCache(path.GetPath());
3389     }
3390   }
3391
3392   if (AliDebugLevel() > 0) fRecoParam.Print();
3393
3394   return isOK;
3395 }
3396
3397 //_____________________________________________________________________________
3398 Bool_t AliReconstruction::GetEventInfo()
3399 {
3400   // Fill the event info object
3401   // ...
3402   AliCodeTimerAuto("",0)
3403
3404   AliCentralTrigger *aCTP = NULL;
3405   if (fRawReader) {
3406     fEventInfo.SetEventType(fRawReader->GetType());
3407
3408     ULong64_t mask = fRawReader->GetClassMask();
3409     fEventInfo.SetTriggerMask(mask);
3410     UInt_t clmask = fRawReader->GetDetectorPattern()[0];
3411     fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
3412
3413     aCTP = new AliCentralTrigger();
3414     TString configstr("");
3415     if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
3416       AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
3417       delete aCTP;
3418       return kFALSE;
3419     }
3420     aCTP->SetClassMask(mask);
3421     aCTP->SetClusterMask(clmask);
3422   }
3423   else {
3424     fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
3425
3426     if (fRunLoader && (!fRunLoader->LoadTrigger())) {
3427       aCTP = fRunLoader->GetTrigger();
3428       fEventInfo.SetTriggerMask(aCTP->GetClassMask());
3429       // get inputs from actp - just get
3430       AliESDHeader* esdheader = fesd->GetHeader();
3431       esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
3432       esdheader->SetL1TriggerInputs(aCTP->GetL1TriggerInputs());
3433       esdheader->SetL2TriggerInputs(aCTP->GetL2TriggerInputs());
3434       fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
3435     }
3436     else {
3437       AliWarning("No trigger can be loaded! The trigger information will not be used!");
3438       return kFALSE;
3439     }
3440   }
3441
3442   AliTriggerConfiguration *config = aCTP->GetConfiguration();
3443   if (!config) {
3444     AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
3445     if (fRawReader) delete aCTP;
3446     return kFALSE;
3447   }
3448
3449   UChar_t clustmask = 0;
3450   TString trclasses;
3451   ULong64_t trmask = fEventInfo.GetTriggerMask();
3452   const TObjArray& classesArray = config->GetClasses();
3453   Int_t nclasses = classesArray.GetEntriesFast();
3454   for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
3455     AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
3456     if (trclass) {
3457       Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
3458       fesd->SetTriggerClass(trclass->GetName(),trindex);
3459       if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
3460       if (trmask & (1ull << trindex)) {
3461         trclasses += " ";
3462         trclasses += trclass->GetName();
3463         trclasses += " ";
3464         clustmask |= trclass->GetCluster()->GetClusterMask();
3465       }
3466     }
3467   }
3468   fEventInfo.SetTriggerClasses(trclasses);
3469
3470   // Set the information in ESD
3471   fesd->SetTriggerMask(trmask);
3472   fesd->SetTriggerCluster(clustmask);
3473
3474   if (!aCTP->CheckTriggeredDetectors()) {
3475     if (fRawReader) delete aCTP;
3476     return kFALSE;
3477   }
3478
3479   if (fRawReader) delete aCTP;
3480
3481   // We have to fill also the HLT decision here!!
3482   // ...
3483
3484   return kTRUE;
3485 }
3486
3487 const char *AliReconstruction::MatchDetectorList(const char *detectorList, UInt_t detectorMask)
3488 {
3489   // Match the detector list found in the rec.C or the default 'ALL'
3490   // to the list found in the GRP (stored there by the shuttle PP which
3491   // gets the information from ECS)
3492   static TString resultList;
3493   TString detList = detectorList;
3494
3495   resultList = "";
3496
3497   for(Int_t iDet = 0; iDet < (AliDAQ::kNDetectors-1); iDet++) {
3498     if ((detectorMask >> iDet) & 0x1) {
3499       TString det = AliDAQ::OfflineModuleName(iDet);
3500       if ((detList.CompareTo("ALL") == 0) ||
3501           ((detList.BeginsWith("ALL ") ||
3502             detList.EndsWith(" ALL") ||
3503             detList.Contains(" ALL ")) &&
3504            !(detList.BeginsWith("-"+det+" ") ||
3505              detList.EndsWith(" -"+det) ||
3506              detList.Contains(" -"+det+" "))) ||
3507           (detList.CompareTo(det) == 0) ||
3508           detList.BeginsWith(det+" ") ||
3509           detList.EndsWith(" "+det) ||
3510           detList.Contains( " "+det+" " )) {
3511         if (!resultList.EndsWith(det + " ")) {
3512           resultList += det;
3513           resultList += " ";
3514         }
3515       }
3516     }
3517   }
3518
3519   // HLT
3520   if ((detectorMask >> AliDAQ::kHLTId) & 0x1) {
3521     TString hltDet = AliDAQ::OfflineModuleName(AliDAQ::kNDetectors-1);
3522     if ((detList.CompareTo("ALL") == 0) ||
3523         ((detList.BeginsWith("ALL ") ||
3524           detList.EndsWith(" ALL") ||
3525           detList.Contains(" ALL ")) &&
3526          !(detList.BeginsWith("-"+hltDet+" ") ||
3527            detList.EndsWith(" -"+hltDet) ||
3528            detList.Contains(" -"+hltDet+" "))) ||
3529         (detList.CompareTo(hltDet) == 0) ||
3530         detList.BeginsWith(hltDet+" ") ||
3531         detList.EndsWith(" "+hltDet) ||
3532         detList.Contains( " "+hltDet+" " )) {
3533       resultList += hltDet;
3534     }
3535   }
3536
3537   return resultList.Data();
3538
3539 }
3540
3541 //______________________________________________________________________________
3542 void AliReconstruction::Abort(const char *method, EAbort what)
3543 {
3544   // Abort processing. If what = kAbortProcess, the Process() loop will be
3545   // aborted. If what = kAbortFile, the current file in a chain will be
3546   // aborted and the processing will continue with the next file, if there
3547   // is no next file then Process() will be aborted. Abort() can also  be
3548   // called from Begin(), SlaveBegin(), Init() and Notify(). After abort
3549   // the SlaveTerminate() and Terminate() are always called. The abort flag
3550   // can be checked in these methods using GetAbort().
3551   //
3552   // The method is overwritten in AliReconstruction for better handling of
3553   // reco specific errors
3554
3555   if (!fStopOnError) return;
3556
3557   CleanUp();
3558
3559   TString whyMess = method;
3560   whyMess += " failed! Aborting...";
3561
3562   AliError(whyMess.Data());
3563
3564   fAbort = what;
3565   TString mess = "Abort";
3566   if (fAbort == kAbortProcess)
3567     mess = "AbortProcess";
3568   else if (fAbort == kAbortFile)
3569     mess = "AbortFile";
3570
3571   Info(mess, whyMess.Data());
3572 }
3573
3574 //______________________________________________________________________________
3575 Bool_t AliReconstruction::ProcessEvent(void* event)
3576 {
3577   // Method that is used in case the event loop
3578   // is steered from outside, for example by AMORE
3579   // 'event' is a pointer to the DATE event in the memory
3580
3581   if (fRawReader) delete fRawReader;
3582   fRawReader = new AliRawReaderDate(event);
3583   fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
3584   delete fRawReader;
3585   fRawReader = NULL;
3586
3587   return fStatus;
3588 }
3589
3590 //______________________________________________________________________________
3591 Bool_t AliReconstruction::ParseOutput()
3592 {
3593   // The method parses the output file
3594   // location string in order to steer
3595   // properly the selector
3596
3597   TPMERegexp re1("(\\w+\\.zip#\\w+\\.root):([,*\\w+\\.root,*]+)@dataset://(\\w++)");
3598   TPMERegexp re2("(\\w+\\.root)?@?dataset://(\\w++)");
3599
3600   if (re1.Match(fESDOutput) == 4) {
3601     // root archive with output files stored and regustered
3602     // in proof dataset
3603     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",re1[1].Data()));
3604     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re1[3].Data()));
3605     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
3606     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_ARCHIVE",re1[2].Data()));
3607     AliInfo(Form("%s files will be stored within %s in dataset %s",
3608                  re1[2].Data(),
3609                  re1[1].Data(),
3610                  re1[3].Data()));
3611   }
3612   else if (re2.Match(fESDOutput) == 3) {
3613     // output file stored and registered
3614     // in proof dataset
3615     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",(re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data()));
3616     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",re2[2].Data()));
3617     gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_DATASET",""));
3618     AliInfo(Form("%s will be stored in dataset %s",
3619                  (re2[1].IsNull()) ? "AliESDs.root" : re2[1].Data(),
3620                  re2[2].Data()));
3621   }
3622   else {
3623     if (fESDOutput.IsNull()) {
3624       // Output location not given.
3625       // Assuming xrootd has been already started and
3626       // the output file has to be sent back
3627       // to the client machine
3628       TString esdUrl(Form("root://%s/%s/",
3629                           TUrl(gSystem->HostName()).GetHostFQDN(),
3630                           gSystem->pwd()));
3631       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE","AliESDs.root"));
3632       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",esdUrl.Data()));
3633       AliInfo(Form("AliESDs.root will be stored in %s",
3634                    esdUrl.Data()));
3635     }
3636     else {
3637       // User specified an output location.
3638       // Ones has just to parse it here
3639       TUrl outputUrl(fESDOutput.Data());
3640       TString outputFile(gSystem->BaseName(outputUrl.GetFile()));
3641       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE",outputFile.IsNull() ? "AliESDs.root" : outputFile.Data()));
3642       TString outputLocation(outputUrl.GetUrl());
3643       outputLocation.ReplaceAll(outputFile.Data(),"");
3644       gProof->AddInput(new TNamed("PROOF_OUTPUTFILE_LOCATION",outputLocation.Data()));
3645       AliInfo(Form("%s will be stored in %s",
3646                    outputFile.IsNull() ? "AliESDs.root" : outputFile.Data(),
3647                    outputLocation.Data()));
3648     }
3649   }
3650
3651   return kTRUE;
3652 }