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