Fixes for coverity.
[u/mrichter/AliRoot.git] / STEER / STEER / AliReconstruction.cxx
index 0909ac2..c21aa1e 100644 (file)
@@ -13,7 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-/* $Id$ */
+/* $Id: AliReconstruction.cxx 63911 2013-08-19 16:46:41Z hristov $ */
 
 ///////////////////////////////////////////////////////////////////////////////
 //                                                                           //
 #include <TMessage.h>
 #include <TUrl.h>
 #include <TRandom.h>
+#include <THashList.h>
 
 #include "AliAlignObj.h"
+#include "AliAnalysisManager.h"
+#include "AliAnalysisDataContainer.h"
 #include "AliCDBEntry.h"
 #include "AliCDBManager.h"
 #include "AliCDBStorage.h"
 #include "AliRawReaderDate.h"
 #include "AliRawReaderFile.h"
 #include "AliRawReaderRoot.h"
+#include "AliRecoInputHandler.h"
 #include "AliReconstruction.h"
 #include "AliReconstructor.h"
 #include "AliRun.h"
 #include "AliLHCData.h"
 #include "ARVersion.h"
 #include <RVersion.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/resource.h>
 ClassImp(AliReconstruction)
 
+using std::endl;
+
 //_____________________________________________________________________________
-const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE", "HLT"};
+const char* AliReconstruction::fgkStopEvFName = "_stopEvent_";
+const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD",
+"TOF", "PHOS", 
+"HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE","AD","FIT","MFT", "HLT"};
 
 //_____________________________________________________________________________
 AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   TSelector(),
   fRunVertexFinder(kTRUE),
   fRunVertexFinderTracks(kTRUE),
-  fRunHLTTracking(kFALSE),
   fRunMuonTracking(kFALSE),
+  fRunMFTTrackingMU(kFALSE),
   fRunV0Finder(kTRUE),
   fRunCascadeFinder(kTRUE),
   fRunMultFinder(kTRUE),
   fStopOnError(kTRUE),
+  fStopOnMissingTriggerFile(kTRUE),
   fWriteAlignmentData(kFALSE),
   fWriteESDfriend(kFALSE),
   fFillTriggerESD(kTRUE),
@@ -228,6 +241,8 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   fRunLocalReconstruction("ALL"),
   fRunTracking("ALL"),
   fFillESD("ALL"),
+  fDeleteRecPoints(""),
+  fDeleteDigits(""),
   fLoadCDB(""),
   fUseTrackingErrorsForAlignment(""),
   fGAliceFileName(gAliceFilename),
@@ -271,7 +286,9 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   fCDBUri(),
   fQARefUri(),
   fSpecCDBUri(), 
+  fCheckRecoCDBvsSimuCDB(),
   fInitCDBCalled(kFALSE),
+  fCDBSnapshotMode(kFALSE),
   fSetRunNumberFromDataCalled(kFALSE),
   fQADetectors("ALL"), 
   fQATasks("ALL"), 
@@ -282,6 +299,8 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   fWriteQAExpertData(kTRUE), 
   fRunPlaneEff(kFALSE),
 
+  fESDpid(NULL),
+
   fesd(NULL),
   fhltesd(NULL),
   fesdf(NULL),
@@ -299,7 +318,20 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
   fSspecie(0),
   fNhighPt(0),
   fShighPt(0),
-  fUpgradeModule("") 
+  //
+  fTreeBuffSize(30000000),
+  fMemCountESD(0),
+  fMemCountESDF(0),
+  fMemCountESDHLT(0),
+  //
+  fUpgradeModule(""),
+  fAnalysisMacro(),
+  fAnalysis(0),
+  fRecoHandler(0),
+  fDeclTriggerClasses(""),
+  fStopped(kFALSE),
+  fMaxRSS(0),
+  fMaxVMEM(0)
 {
 // create reconstruction object with default parameters
   gGeoManager = NULL;
@@ -315,7 +347,9 @@ AliReconstruction::AliReconstruction(const char* gAliceFilename) :
     fQAWriteExpert[iDet] = kFALSE ; 
   }
   fBeamInt[0][0]=fBeamInt[0][1]=fBeamInt[1][0]=fBeamInt[1][1] = -1;
-
+  //
+  AddCheckRecoCDBvsSimuCDB("TPC/Calib/RecoParam"); // check for similarity in the sim and rec
+  //
   AliPID pid;
 }
 
@@ -324,12 +358,13 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   TSelector(),
   fRunVertexFinder(rec.fRunVertexFinder),
   fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
-  fRunHLTTracking(rec.fRunHLTTracking),
   fRunMuonTracking(rec.fRunMuonTracking),
+  fRunMFTTrackingMU(rec.fRunMFTTrackingMU),
   fRunV0Finder(rec.fRunV0Finder),
   fRunCascadeFinder(rec.fRunCascadeFinder),
   fRunMultFinder(rec.fRunMultFinder),
   fStopOnError(rec.fStopOnError),
+  fStopOnMissingTriggerFile(rec.fStopOnMissingTriggerFile),
   fWriteAlignmentData(rec.fWriteAlignmentData),
   fWriteESDfriend(rec.fWriteESDfriend),
   fFillTriggerESD(rec.fFillTriggerESD),
@@ -343,6 +378,8 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fRunLocalReconstruction(rec.fRunLocalReconstruction),
   fRunTracking(rec.fRunTracking),
   fFillESD(rec.fFillESD),
+  fDeleteRecPoints(""),
+  fDeleteDigits(""),
   fLoadCDB(rec.fLoadCDB),
   fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
   fGAliceFileName(rec.fGAliceFileName),
@@ -386,7 +423,9 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fCDBUri(rec.fCDBUri),
   fQARefUri(rec.fQARefUri),
   fSpecCDBUri(), 
+  fCheckRecoCDBvsSimuCDB(),
   fInitCDBCalled(rec.fInitCDBCalled),
+  fCDBSnapshotMode(rec.fCDBSnapshotMode),
   fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
   fQADetectors(rec.fQADetectors), 
   fQATasks(rec.fQATasks), 
@@ -397,6 +436,8 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fWriteQAExpertData(rec.fWriteQAExpertData), 
   fRunPlaneEff(rec.fRunPlaneEff),
 
+  fESDpid(NULL),
+
   fesd(NULL),
   fhltesd(NULL),
   fesdf(NULL),
@@ -414,7 +455,20 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
   fSspecie(0),
   fNhighPt(0),
   fShighPt(0),
-  fUpgradeModule("")
+  //
+  fTreeBuffSize(rec.fTreeBuffSize),
+  fMemCountESD(0),
+  fMemCountESDF(0),
+  fMemCountESDHLT(0),
+  //
+  fUpgradeModule(""),
+  fAnalysisMacro(rec.fAnalysisMacro),
+  fAnalysis(0),
+  fRecoHandler(0),
+  fDeclTriggerClasses(rec.fDeclTriggerClasses),
+  fStopped(kFALSE),
+  fMaxRSS(0),
+  fMaxVMEM(0)
 {
 // copy constructor
 
@@ -437,6 +491,10 @@ AliReconstruction::AliReconstruction(const AliReconstruction& rec) :
     if (rec.fSpecCDBUri[i]) fSpecCDBUri.Add(rec.fSpecCDBUri[i]->Clone());
   }
 
+  for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
+    if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
+  }
+
   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
 
 }
@@ -455,12 +513,13 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
 
   fRunVertexFinder       = rec.fRunVertexFinder;
   fRunVertexFinderTracks = rec.fRunVertexFinderTracks;
-  fRunHLTTracking        = rec.fRunHLTTracking;
   fRunMuonTracking       = rec.fRunMuonTracking;
+  fRunMFTTrackingMU      = rec.fRunMFTTrackingMU;
   fRunV0Finder           = rec.fRunV0Finder;
   fRunCascadeFinder      = rec.fRunCascadeFinder;
   fRunMultFinder         = rec.fRunMultFinder;
   fStopOnError           = rec.fStopOnError;
+  fStopOnMissingTriggerFile = rec.fStopOnMissingTriggerFile;
   fWriteAlignmentData    = rec.fWriteAlignmentData;
   fWriteESDfriend        = rec.fWriteESDfriend;
   fFillTriggerESD        = rec.fFillTriggerESD;
@@ -474,6 +533,8 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
   fRunLocalReconstruction        = rec.fRunLocalReconstruction;
   fRunTracking                   = rec.fRunTracking;
   fFillESD                       = rec.fFillESD;
+  fDeleteRecPoints               = rec.fDeleteRecPoints;
+  fDeleteDigits                  = rec.fDeleteDigits;
   fLoadCDB                       = rec.fLoadCDB;
   fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
   fGAliceFileName                = rec.fGAliceFileName;
@@ -549,7 +610,14 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
   fCDBUri        = "";
   fQARefUri      = rec.fQARefUri;
   fSpecCDBUri.Delete();
+  fCheckRecoCDBvsSimuCDB.Delete();
+  //
+  for (Int_t i = 0; i < rec.fCheckRecoCDBvsSimuCDB.GetEntriesFast(); i++) {
+    if (rec.fCheckRecoCDBvsSimuCDB[i]) fCheckRecoCDBvsSimuCDB.AddLast(rec.fCheckRecoCDBvsSimuCDB[i]->Clone());
+  }
+  //
   fInitCDBCalled               = rec.fInitCDBCalled;
+  fCDBSnapshotMode             = rec.fCDBSnapshotMode;
   fSetRunNumberFromDataCalled  = rec.fSetRunNumberFromDataCalled;
   fQADetectors                 = rec.fQADetectors;
   fQATasks                     = rec.fQATasks; 
@@ -560,6 +628,7 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
   fWriteQAExpertData           = rec.fWriteQAExpertData;
   fRunPlaneEff                 = rec.fRunPlaneEff;
   for (int i=2;i--;) for (int j=2;j--;) fBeamInt[i][j] = rec.fBeamInt[i][j];
+  fESDpid  = NULL;
   fesd     = NULL;
   fhltesd  = NULL;
   fesdf    = NULL;
@@ -577,7 +646,17 @@ AliReconstruction& AliReconstruction::operator = (const AliReconstruction& rec)
   fSspecie = 0;
   fNhighPt = 0;
   fShighPt = 0;
+  //
+  fTreeBuffSize = rec.fTreeBuffSize;
+  fMemCountESD = 0;
+  fMemCountESDF = 0;
+  fMemCountESDHLT = 0;
+  //
   fUpgradeModule="";
+  fAnalysisMacro = rec.fAnalysisMacro;
+  fAnalysis = 0;
+  fRecoHandler = 0;
+  fDeclTriggerClasses = rec.fDeclTriggerClasses;
 
   return *this;
 }
@@ -602,7 +681,7 @@ AliReconstruction::~AliReconstruction()
     delete fAlignObjArray;
   }
   fSpecCDBUri.Delete();
-
+  fCheckRecoCDBvsSimuCDB.Delete();
   AliCodeTimer::Instance()->Print();
 }
 
@@ -619,6 +698,8 @@ void AliReconstruction::InitQA()
 
 
   AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ; 
+  qam->SetSaveData(kTRUE); 
+  qam->SetCycleLength(AliQAv1::kITS, 5) ; 
   if (fWriteQAExpertData)
     qam->SetWriteExpert() ; 
  
@@ -645,7 +726,9 @@ void AliReconstruction::InitQA()
   }
   
   if (fRunQA) {
-  qam->SetActiveDetectors(fQADetectors) ; 
+  qam->SetActiveDetectors(fQADetectors) ;
+  qam->SetActiveOnlineDetectors(fRunInfo->GetActiveDetectors());
+    
   for (Int_t det = 0 ; det < AliQAv1::kNDET ; det++) {
     qam->SetCycleLength(AliQAv1::DETECTORINDEX_t(det), fQACycles[det]) ;  
     qam->SetWriteExpert(AliQAv1::DETECTORINDEX_t(det)) ;
@@ -738,6 +821,12 @@ void AliReconstruction::InitCDB()
 }
 
 //_____________________________________________________________________________
+void AliReconstruction::SetCDBSnapshotMode(const char* snapshotFileName) {
+    fCDBSnapshotMode = kTRUE;
+    AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName);
+}
+
+//_____________________________________________________________________________
 void AliReconstruction::SetDefaultStorage(const char* uri) {
 // Store the desired default CDB storage location
 // Activate it later within the Run() method
@@ -755,6 +844,7 @@ void AliReconstruction::SetQARefDefaultStorage(const char* uri) {
   AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
   
 }
+
 //_____________________________________________________________________________
 void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
 // Store a detector-specific CDB storage location
@@ -798,6 +888,48 @@ void AliReconstruction::SetSpecificStorage(const char* calibType, const char* ur
 }
 
 //_____________________________________________________________________________
+void AliReconstruction::AddCheckRecoCDBvsSimuCDB(const char* cdbpath,const char* comment) 
+{
+  // require the cdb item to be the same in the rec as in the sim
+  // Activate it later within the Run() method
+  TString newent = cdbpath;
+  if (newent.IsNull()) return;
+  TIter nextit(&fCheckRecoCDBvsSimuCDB);
+  TNamed* cdbent=0;
+  while ((cdbent=(TNamed*)nextit())) {
+    TString str = cdbent->GetName();
+    if (str==newent) {
+      AliInfo(Form("%s is already in the list to check",cdbpath));
+      return;
+    }
+  }
+  fCheckRecoCDBvsSimuCDB.AddLast(new TNamed(cdbpath,comment));
+  //
+}
+
+//_____________________________________________________________________________
+void AliReconstruction::RemCheckRecoCDBvsSimuCDB(const char* cdbpath) 
+{
+  // require the cdb item to be the same in the rec as in the sim
+  // Activate it later within the Run() method
+  TString newent = cdbpath;
+  if (newent.IsNull()) return;
+  TIter nextit(&fCheckRecoCDBvsSimuCDB);
+  TNamed* cdbent=0;
+  while ((cdbent=(TNamed*)nextit())) {
+    TString str = cdbent->GetName();
+    if (str==newent) {
+      AliInfo(Form("Removing %s from the list to check",cdbpath));
+      delete fCheckRecoCDBvsSimuCDB.Remove(cdbent);
+      fCheckRecoCDBvsSimuCDB.Compress();
+      return;
+    }
+  }
+  AliInfo(Form("%s is not in the list to check",cdbpath));
+  //
+}
+
+//_____________________________________________________________________________
 Bool_t AliReconstruction::SetRunNumberFromData()
 {
   // The method is called in Run() in order
@@ -816,6 +948,7 @@ Bool_t AliReconstruction::SetRunNumberFromData()
        AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
       } 
       man->SetRun(fRawReader->GetRunNumber());
+      GetEventInfo();
       fRawReader->RewindEvents();
     }
     else {
@@ -903,7 +1036,6 @@ Bool_t AliReconstruction::MisalignGeometry(const TString& detectors)
     if(AliGeomManager::GetNalignable("GRP") != 0)
       loadAlObjsListOfDets.Prepend("GRP "); //add alignment objects for non-sensitive modules
     AliGeomManager::ApplyAlignObjsFromCDB(loadAlObjsListOfDets.Data());
-    AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
   }else{
     // Check if the array with alignment objects was
     // provided by the user. If yes, apply the objects
@@ -1058,6 +1190,7 @@ Bool_t AliReconstruction::InitGRP() {
     AliError("GRP/GRP/Data entry:  missing value for the detector mask ! Using 1074790399");
     activeDetectors = 1074790399;
   }
+  AliDebug(1, Form("activeDetectors = %d", activeDetectors));
 
   fRunInfo = new AliRunInfo(lhcState, beamType, beamEnergy, runType, activeDetectors);
   fRunInfo->Dump();
@@ -1066,10 +1199,15 @@ Bool_t AliReconstruction::InitGRP() {
   // Process the list of active detectors
   if (activeDetectors) {
     UInt_t detMask = activeDetectors;
+    AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
     fRunLocalReconstruction = MatchDetectorList(fRunLocalReconstruction,detMask);
+    AliDebug(1, Form("Detector List = %s", fRunLocalReconstruction.Data()));
     fRunTracking = MatchDetectorList(fRunTracking,detMask);
     fFillESD = MatchDetectorList(fFillESD,detMask);
     fQADetectors = MatchDetectorList(fQADetectors,detMask);
+    AliInfo(Form("fQADetectors=%s",fQADetectors.Data()));
+    fDeleteRecPoints = MatchDetectorList(fDeleteRecPoints,detMask);
+    fDeleteDigits    = MatchDetectorList(fDeleteDigits,detMask);
     fLoadCDB.Form("%s %s %s %s",
                  fRunLocalReconstruction.Data(),
                  fRunTracking.Data(),
@@ -1185,7 +1323,6 @@ Bool_t AliReconstruction::InitGRP() {
   if (entry) {
     fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
     entry->SetOwner(0);
-    AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
   }
 
   if (!fListOfCosmicTriggers) {
@@ -1212,6 +1349,7 @@ Bool_t AliReconstruction::LoadCDB()
   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
     AliCDBManager::Instance()->GetAll(Form("%s/Calib/*",fgkDetectorName[iDet]));
+    AliCDBManager::Instance()->GetAll(Form("%s/Trigger/*",fgkDetectorName[iDet]));
   }
 
   // Temporary fix - one has to define the correct policy in order
@@ -1219,6 +1357,7 @@ Bool_t AliReconstruction::LoadCDB()
   // in the trigger or that are needed in order to put correct
   // information in ESD
   AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
+  AliCDBManager::Instance()->GetAll("HLT/*/*");
 
   return kTRUE;
 }
@@ -1372,12 +1511,17 @@ Bool_t AliReconstruction::Run(const char* input)
     Int_t iEvent = 0;
     while ((iEvent < fRunLoader->GetNumberOfEvents()) ||
           (fRawReader && fRawReader->NextEvent())) {
+      //
+      // check if process has enough resources 
+      if (!HasEnoughResources(iEvent)) break;
       if (!ProcessEvent(iEvent)) {
         Abort("ProcessEvent",TSelector::kAbortFile);
         return kFALSE;
       }
+      CleanProcessedEvent();
       iEvent++;
     }
+    if (!iEvent) AliWarning("No events passed trigger selection");
     SlaveTerminate();
     if (GetAbort() != TSelector::kContinue) return kFALSE;
     Terminate();
@@ -1467,7 +1611,7 @@ void AliReconstruction::Begin(TTree *)
   }
 
   // Import ideal TGeo geometry and apply misalignment
-  if (!gGeoManager) {
+  if (!AliGeomManager::GetGeometry()) {
     TString geom(gSystem->DirName(fGAliceFileName));
     geom += "/geometry.root";
     AliGeomManager::LoadGeometry(geom.Data());
@@ -1484,11 +1628,28 @@ void AliReconstruction::Begin(TTree *)
     AliSysInfo::AddStamp("CheckGeom");
   }
 
+  Bool_t toCDBSnapshot=kFALSE;
+  TString snapshotFileOut(""); // we could use fSnapshotFileName if we are not interested
+  // in reading from and writing to a snapshot file at the same time
+  if(TString(getenv("OCDB_SNAPSHOT_CREATE")) == TString("kTRUE")){
+      toCDBSnapshot=kTRUE;
+      //fFromCDBSnapshot=kFALSE;
+      TString snapshotFile(getenv("OCDB_SNAPSHOT_FILENAME"));
+      if(!(snapshotFile.IsNull() || snapshotFile.IsWhitespace()))
+         snapshotFileOut = snapshotFile;
+      else
+         snapshotFileOut="OCDB.root";
+  }
+
   if (!MisalignGeometry(fLoadAlignData)) {
     Abort("MisalignGeometry", TSelector::kAbortProcess);
     return;
   }
-  AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
+
+  const TMap* cdbCache = AliCDBManager::Instance()->GetEntryCache();
+  if(cdbCache->Contains("GRP/Geometry/Data"))
+         AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
+  if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
   AliSysInfo::AddStamp("MisalignGeom");
 
   if (!InitGRP()) {
@@ -1496,12 +1657,17 @@ void AliReconstruction::Begin(TTree *)
     return;
   }
   AliSysInfo::AddStamp("InitGRP");
-
-  if (!LoadCDB()) {
-    Abort("LoadCDB", TSelector::kAbortProcess);
-    return;
+  if(!toCDBSnapshot)
+      if(cdbCache->Contains("GRP/Calib/CosmicTriggers"))
+         AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
+
+  if(!fCDBSnapshotMode || toCDBSnapshot){
+      if (!LoadCDB()) {
+         Abort("LoadCDB", TSelector::kAbortProcess);
+         return;
+      }
+      AliSysInfo::AddStamp("LoadCDB"); 
   }
-  AliSysInfo::AddStamp("LoadCDB");
 
   if (!LoadTriggerScalersCDB()) {
     Abort("LoadTriggerScalersCDB", TSelector::kAbortProcess);
@@ -1527,6 +1693,12 @@ void AliReconstruction::Begin(TTree *)
   }
   AliSysInfo::AddStamp("InitRecoParams");
 
+  if(toCDBSnapshot)
+  {
+      AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
+      exit(0);
+  }
+
   if (fInput && gProof) {
     if (reco) *reco = *this;
 
@@ -1538,6 +1710,10 @@ void AliReconstruction::Begin(TTree *)
     AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
     magFieldMap->SetName("MagneticFieldMap");
     gProof->AddInputData(magFieldMap,kTRUE);
+    if (fAnalysis) {
+      fAnalysis->SetName("Analysis");
+      gProof->AddInputData(fAnalysis,kTRUE);
+    }  
   }
 
 }
@@ -1579,6 +1755,11 @@ void AliReconstruction::SlaveBegin(TTree*)
       TGeoGlobalMagField::Instance()->SetField(newMap);
       TGeoGlobalMagField::Instance()->Lock();
     }
+    if (!fAnalysis) {
+       // Attempt to get the analysis manager from the input list
+       fAnalysis = (AliAnalysisManager*)fInput->FindObject("Analysis");
+       if (fAnalysis) AliInfo("==== Analysis manager retrieved from input list ====");
+    }   
     if (TNamed *outputFileName = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE"))
       fProofOutputFileName = outputFileName->GetTitle();
     if (TNamed *outputLocation = (TNamed*)fInput->FindObject("PROOF_OUTPUTFILE_LOCATION"))
@@ -1602,7 +1783,22 @@ void AliReconstruction::SlaveBegin(TTree*)
     }
     AliSysInfo::AddStamp("ReadInputInSlaveBegin");
   }
-
+  // Check if analysis was requested in the reconstruction event loop
+  if (!fAnalysis) {
+    // Attempt to connect in-memory singleton
+    fAnalysis = AliAnalysisManager::GetAnalysisManager();
+    if (fAnalysis) AliInfo(Form("==== Analysis manager <%s> found in memory ====", fAnalysis->GetName()));
+    // Check if an analysis macro was specified
+    if (!fAnalysis && !fAnalysisMacro.IsNull()) {
+      // Run specified analysis macro
+      gROOT->ProcessLine(Form(".x %s",fAnalysisMacro.Data()));
+      fAnalysis = AliAnalysisManager::GetAnalysisManager();
+      if (!fAnalysis) AliError(Form("No analysis manager produced by analysis macro %s", fAnalysisMacro.Data()));
+      else AliInfo(Form("==== Analysis manager <%s> produced by analysis macro <%s> ====", 
+                        fAnalysis->GetName(), fAnalysisMacro.Data()));
+    }
+  }
+  
   // get the run loader
   if (!InitRunLoader()) {
     Abort("InitRunLoader", TSelector::kAbortProcess);
@@ -1610,6 +1806,8 @@ void AliReconstruction::SlaveBegin(TTree*)
   }
   AliSysInfo::AddStamp("LoadLoader");
  
+  CheckRecoCDBvsSimuCDB();
+
   ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
 
   // get trackers
@@ -1666,22 +1864,21 @@ void AliReconstruction::SlaveBegin(TTree*)
   // order to create all branches. Initialization is done from an
   // ESD layout template in CDB
   AliCDBManager* man = AliCDBManager::Instance();
-  AliCDBPath hltESDConfigPath("HLT/ConfigHLT/esdLayout");
-  AliCDBEntry* hltESDConfig=NULL;
-  if (man->GetId(hltESDConfigPath)!=NULL &&
-      (hltESDConfig=man->Get(hltESDConfigPath))!=NULL) {
-    AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
-    if (pESDLayout) {
+  AliCDBEntry* hltESDConfig = man->Get("HLT/Calib/esdLayout");
+  if(!hltESDConfig){
+      AliError(Form("Error getting \"HLT/Calib/esdLayout\""));
+      return;
+  }
+  AliESDEvent* pESDLayout=dynamic_cast<AliESDEvent*>(hltESDConfig->GetObject());
+  if (pESDLayout) {
       // init all internal variables from the list of objects
       pESDLayout->GetStdContent();
 
       // copy content and create non-std objects
       *fhltesd=*pESDLayout;
       fhltesd->Reset();
-    } else {
-      AliError(Form("error setting hltEsd layout from %s: invalid object type",
-                   hltESDConfigPath.GetPath().Data()));
-    }
+  } else {
+      AliError(Form("error setting hltEsd layout from \"HLT/Calib/esdLayout\": invalid object type"));
   }
 
   fhltesd->WriteToTree(fhlttree);
@@ -1691,6 +1888,9 @@ void AliReconstruction::SlaveBegin(TTree*)
   gSystem->GetProcInfo(&procInfo);
   AliInfo(Form("Current memory usage %ld %ld", procInfo.fMemResident, procInfo.fMemVirtual));
   
+  // PID
+  fESDpid = new AliESDpid();
+
   //QA
   //Initialize the QA and start of cycle 
   if (fRunQA || fRunGlobalQA) 
@@ -1704,7 +1904,29 @@ void AliReconstruction::SlaveBegin(TTree*)
 
   if (strcmp(gProgName,"alieve") == 0)
     fRunAliEVE = InitAliEVE();
-
+  // If we have an analysis manager, connect the AliRecoInputHandler here  
+  if (fAnalysis) {
+    if (!dynamic_cast<AliRecoInputHandler*>(fAnalysis->GetInputEventHandler())) {
+       AliError("Analysis manager used in reconstruction should use AliRecoInputHandler - \
+                 \n  ->Replacing with AliRecoInputHandler instance.");
+       delete fAnalysis->GetInputEventHandler();
+    }
+    // Set the event and other data pointers
+    fRecoHandler = new AliRecoInputHandler();
+//    fRecoHandler->Init(ftree, "LOCAL");
+    fRecoHandler->SetEvent(fesd);
+    fRecoHandler->SetESDfriend(fesdf);
+    fRecoHandler->SetHLTEvent(fhltesd);
+    fRecoHandler->SetHLTTree(fhlttree);
+    fAnalysis->SetInputEventHandler(fRecoHandler);
+    // Enter external loop mode
+    fAnalysis->SetExternalLoop(kTRUE);
+    // Initialize analysis
+    fAnalysis->SlaveBegin(ftree);
+    fAnalysis->StartAnalysis("local", (TTree*)0);
+    // Connect ESD tree with the input container
+    fAnalysis->GetCommonInputContainer()->SetData(ftree);
+  }  
   return;
 }
 
@@ -1720,7 +1942,9 @@ Bool_t AliReconstruction::Process(Long64_t entry)
   currTree->SetBranchAddress("rawevent",&event);
   currTree->GetEntry(entry);
   fRawReader = new AliRawReaderRoot(event);
-  fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());  
+  // check if process has enough resources 
+  if (!HasEnoughResources(entry)) return kFALSE;
+  fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
   delete fRawReader;
   fRawReader = NULL;
   delete event;
@@ -1750,13 +1974,13 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
   static Long_t oldMres=0;
   static Long_t oldMvir=0;
   static Float_t oldCPU=0;
-  static Long_t aveDMres=0;
-  static Long_t aveDMvir=0;
-  static Float_t aveDCPU=0;
+  // static Long_t aveDMres=0;
+  // static Long_t aveDMvir=0;
+  // static Float_t aveDCPU=0;
 
   AliCodeTimerAuto("",0);
 
-  AliESDpid pid;
+  AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
 
   if (iEvent >= fRunLoader->GetNumberOfEvents()) {
     fRunLoader->SetEventNumber(iEvent);
@@ -1789,6 +2013,8 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
   }
   AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
 
+  AliSysInfo::AddStamp(Form("StartReco_%d",iEvent), 0,0,iEvent);
+
   // Set the reco-params
   {
     TString detStr = fLoadCDB;
@@ -1798,7 +2024,7 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
       if (reconstructor && fRecoParam.GetDetRecoParamArray(iDet)) {
         const AliDetectorRecoParam *par = fRecoParam.GetDetRecoParam(iDet);
         reconstructor->SetRecoParam(par);
-       reconstructor->GetPidSettings(&pid);
+       reconstructor->GetPidSettings(fESDpid);
        reconstructor->SetEventInfo(&fEventInfo);
         if (fRunQA) {
           AliQAManager::QAManager()->SetEventInfo(&fEventInfo) ;
@@ -1821,30 +2047,17 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
   if (fRunQA && IsInTasks(AliQAv1::kRAWS)) {
     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
     AliQAManager::QAManager()->RunOneEvent(fRawReader) ;  
+    AliSysInfo::AddStamp(Form("RawQA_%d",iEvent), 0,0,iEvent);
   }
-    // local single event reconstruction
-    if (!fRunLocalReconstruction.IsNull()) {
-      TString detectors=fRunLocalReconstruction;
-      // run HLT event reconstruction first
-      // ;-( IsSelected changes the string
-      if (IsSelected("HLT", detectors) &&
-         !RunLocalEventReconstruction("HLT")) {
-       if (fStopOnError) {CleanUp(); return kFALSE;}
-      }
-      detectors=fRunLocalReconstruction;
-      detectors.ReplaceAll("HLT", "");
-      if (!RunLocalEventReconstruction(detectors)) {
-        if (fStopOnError) {
-          CleanUp(); 
-          return kFALSE;
-        }
-      }
-    }
 
-  
     // fill Event header information from the RawEventHeader
     if (fRawReader){FillRawEventHeaderESD(fesd);}
     if (fRawReader){FillRawEventHeaderESD(fhltesd);}
+    if (fRawReader){
+      // Store DAQ detector pattern and attributes
+      fesd->SetDAQDetectorPattern(fRawReader->GetDetectorPattern()[0]);
+      fesd->SetDAQAttributes(fRawReader->GetAttributes()[2]);
+    }
 
     fesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
     fhltesd->SetRunNumber(fRunLoader->GetHeader()->GetRun());
@@ -1875,22 +2088,64 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
        esdRunH->SetMeanIntensity(ib,it, fBeamInt[ib][it]); 
       }
     //
+    fesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
+    fesd->SetBeamType(fGRPData->GetBeamType().Data());
+    fesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
+    fesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
+    fhltesd->SetBeamEnergy(fGRPData->GetBeamEnergy());
+    fhltesd->SetBeamType(fGRPData->GetBeamType().Data());
+    fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(0).Atoi(),0);
+    fhltesd->SetBeamParticle(fGRPData->GetSingleBeamType(1).Atoi(),1);
+    //
     AliMagF* fld = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
     if (fld) { // set info needed for field initialization
       fesd->SetCurrentL3(fld->GetCurrentSol());
       fesd->SetCurrentDip(fld->GetCurrentDip());
-      fesd->SetBeamEnergy(fld->GetBeamEnergy());
-      fesd->SetBeamType(fld->GetBeamTypeText());
       fesd->SetUniformBMap(fld->IsUniform());
       fesd->SetBInfoStored();
       //
       fhltesd->SetCurrentL3(fld->GetCurrentSol());
       fhltesd->SetCurrentDip(fld->GetCurrentDip());
-      fhltesd->SetBeamEnergy(fld->GetBeamEnergy());
-      fhltesd->SetBeamType(fld->GetBeamTypeText());
       fhltesd->SetUniformBMap(fld->IsUniform());
       fhltesd->SetBInfoStored();
     }
+
+    //
+    // run full HLT reconstruction first
+    //
+    {
+      TString detectors=fRunLocalReconstruction;
+      if (IsSelected("HLT", detectors) &&
+         !RunLocalEventReconstruction("HLT")) {
+       if (fStopOnError) {CleanUp(); return kFALSE;}
+      }
+      detectors=fFillESD;
+      // run HLT on hltesd
+      if (IsSelected("HLT", detectors) &&
+         !FillESD(fhltesd, "HLT")) {
+       if (fStopOnError) {CleanUp(); return kFALSE;}
+      }
+    }
+
+    // local single event reconstruction
+    if (!fRunLocalReconstruction.IsNull()) {
+      TString detectors=fRunLocalReconstruction;
+      // the logic for selection and correct sequence of reconstruction relies on the
+      // full list of detectors. Keyword 'ALL' should have been replaced at this point.
+      if (detectors.Contains("ALL")) {
+       AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
+                "fRunLocalReconstruction. This should have been done by the framework");
+      }
+      detectors.ReplaceAll("HLT", "");
+      if (!RunLocalEventReconstruction(detectors)) {
+        if (fStopOnError) {
+          CleanUp(); 
+          return kFALSE;
+        }
+      }
+    }
+
+  
     //
     // Set most probable pt, for B=0 tracking
     // Get the global reco-params. They are atposition 16 inside the array of detectors in fRecoParam
@@ -1900,11 +2155,14 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
     // Fill raw-data error log into the ESD
     if (fRawReader) FillRawDataErrorLog(iEvent,fesd);
 
+    AliSysInfo::AddStamp(Form("FillHeadErrs_%d",iEvent), 0,0,iEvent);
+
     // vertex finder
     if (fRunVertexFinder) {
       if (!RunVertexFinder(fesd)) {
        if (fStopOnError) {CleanUp(); return kFALSE;}
       }
+      AliSysInfo::AddStamp(Form("VtxFinder_%d",iEvent), 0,0,iEvent);
     }
 
     // For Plane Efficiency: run the SPD trackleter
@@ -1912,6 +2170,7 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
       if (!RunSPDTrackleting(fesd)) {
         if (fStopOnError) {CleanUp(); return kFALSE;}
       }
+      AliSysInfo::AddStamp(Form("TrackletEff_%d",iEvent), 0,0,iEvent);
     }
 
     // Muon tracking
@@ -1921,11 +2180,26 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
          if (fStopOnError) {CleanUp(); return kFALSE;}
        }
       }
+      AliSysInfo::AddStamp(Form("TrackingMUON_%d",iEvent), 0,0,iEvent);      
     }
 
+    //---------------- AU From here...
+
+    // MFT tracking of MUON tracks
+    if (!fRunTracking.IsNull()) {
+      if (fRunMFTTrackingMU && fRunMuonTracking) {
+       if (!RunMFTTrackingMU(fesd)) {
+         if (fStopOnError) {CleanUp(); return kFALSE;}
+       }
+      }
+      AliSysInfo::AddStamp(Form("TrackingMFT_MUON_%d",iEvent), 0,0,iEvent);      
+    }
+
+    //---------------- ...to here
+
     // barrel tracking
     if (!fRunTracking.IsNull()) {
-      if (!RunTracking(fesd,pid)) {
+      if (!RunTracking(fesd,*fESDpid)) {
        if (fStopOnError) {CleanUp(); return kFALSE;}
       }
     }
@@ -1933,45 +2207,19 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
     // fill ESD
     if (!fFillESD.IsNull()) {
       TString detectors=fFillESD;
-      // run HLT first and on hltesd
-      // ;-( IsSelected changes the string
-      if (IsSelected("HLT", detectors) &&
-         !FillESD(fhltesd, "HLT")) {
-       if (fStopOnError) {CleanUp(); return kFALSE;}
-      }
-      detectors=fFillESD;
-      // Temporary fix to avoid problems with HLT that overwrites the offline ESDs
+      // the logic for selection and correct sequence of reconstruction relies on the
+      // full list of detectors. Keyword 'ALL' should have been replaced at this point.
       if (detectors.Contains("ALL")) {
-       detectors="";
-       for (Int_t idet=0; idet<kNDetectors; ++idet){
-         detectors += fgkDetectorName[idet];
-         detectors += " ";
-       }
+       AliFatal("Keyword 'ALL' needs to be replaced by the full list of detectors in "
+                "fFillESD. This should have been done by the framework");
       }
+      // remove HLT as this has been executed at the beginning of the event reconstruction
       detectors.ReplaceAll("HLT", "");
       if (!FillESD(fesd, detectors)) {
        if (fStopOnError) {CleanUp(); return kFALSE;}
       }
     }
 
-    // AdC+FN
-    if (fReconstructor[3])
-      GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
-
-    // combined PID
-    pid.MakePID(fesd);
-
-    if (fFillTriggerESD) {
-      if (!FillTriggerESD(fesd)) {
-       if (fStopOnError) {CleanUp(); return kFALSE;}
-      }
-    }
-    // Always fill scalers
-    if (!FillTriggerScalers(fesd)) {
-       if (fStopOnError) {CleanUp(); return kFALSE;}
-    }
-    
-
     ffile->cd();
 
     //
@@ -1981,7 +2229,7 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
     const Double_t kRadius  = 2.8; //something less than the beam pipe radius
 
     TObjArray trkArray;
-    UShort_t *selectedIdx=new UShort_t[ntracks];
+    UShort_t selectedIdx[ntracks];
 
     for (Int_t itrack=0; itrack<ntracks; itrack++){
       const Double_t kMaxStep = 1;   //max step over the material
@@ -1995,7 +2243,7 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
       ok = kFALSE;
       if (tpcTrack)
        ok = AliTracker::
-         PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMass(),kMaxStep,kFALSE);
+         PropagateTrackToBxByBz(tpcTrack,kRadius,track->GetMassForTracking(),kMaxStep,kFALSE);
 
       if (ok) {
        Int_t n=trkArray.GetEntriesFast();
@@ -2007,13 +2255,13 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
       if (track->IsOn(AliESDtrack::kITSrefit)) continue;
 
       AliTracker::
-         PropagateTrackToBxByBz(track,kRadius,track->GetMass(),kMaxStep,kFALSE);
+         PropagateTrackToBxByBz(track,kRadius,track->GetMassForTracking(),kMaxStep,kFALSE);
       Double_t x[3]; track->GetXYZ(x);
       Double_t b[3]; AliTracker::GetBxByBz(x,b);
       track->RelateToVertexBxByBz(fesd->GetPrimaryVertexSPD(), b, kVeryBig);
 
     }
-
+    AliSysInfo::AddStamp(Form("RelToSPDVtx_%d",iEvent), 0,0,iEvent);      
     //
     // Improve the reconstructed primary vertex position using the tracks
     //
@@ -2034,8 +2282,8 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
        if (grpRecoParam) {
         Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
         Double_t *cutsVertexer = new Double_t[nCutsVertexer];
-        grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer);
-        ftVertexer->SetCuts(cutsVertexer);
+        grpRecoParam->GetVertexerTracksCutsITS(cutsVertexer,nCutsVertexer);
+        ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
         delete [] cutsVertexer; cutsVertexer = NULL; 
         if(grpRecoParam->GetVertexerTracksConstraintITS()) { 
           if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius){
@@ -2066,6 +2314,7 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
           }
          delete pvtx; pvtx=NULL;
        }
+       AliSysInfo::AddStamp(Form("VtxTrk_%d",iEvent), 0,0,iEvent);      
 
        // TPC-only primary vertex
        ftVertexer->SetTPCMode();
@@ -2074,8 +2323,8 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
        if (grpRecoParam) {
         Int_t nCutsVertexer = grpRecoParam->GetVertexerTracksNCuts();
         Double_t *cutsVertexer = new Double_t[nCutsVertexer];
-        grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer);
-        ftVertexer->SetCuts(cutsVertexer);
+        grpRecoParam->GetVertexerTracksCutsTPC(cutsVertexer,nCutsVertexer);
+        ftVertexer->SetCuts(cutsVertexer,nCutsVertexer);
         delete [] cutsVertexer; cutsVertexer = NULL; 
         if(fDiamondProfileTPC && grpRecoParam->GetVertexerTracksConstraintTPC()) { 
           if(fDiamondProfileTPC->GetXRes()<kRadius) ftVertexer->SetVtxStart(fDiamondProfileTPC); // apply constraint only if sigmax is smaller than the beam pipe radius 
@@ -2094,10 +2343,10 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
           }
          delete pvtx; pvtx=NULL;
        }
+       AliSysInfo::AddStamp(Form("VtxTPC_%d",iEvent), 0,0,iEvent);      
 
     }
-    delete[] selectedIdx;
-
+    
     if(fDiamondProfile && fDiamondProfile->GetXRes()<kRadius) fesd->SetDiamond(fDiamondProfile);
     else fesd->SetDiamond(fDiamondProfileSPD);
 
@@ -2107,12 +2356,12 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
        // get cuts for V0vertexer from AliGRPRecoParam
        if (grpRecoParam) {
         Int_t nCutsV0vertexer = grpRecoParam->GetVertexerV0NCuts();
-        Double_t *cutsV0vertexer = new Double_t[nCutsV0vertexer];
+        Double_t cutsV0vertexer[nCutsV0vertexer];
         grpRecoParam->GetVertexerV0Cuts(cutsV0vertexer);
         vtxer.SetCuts(cutsV0vertexer);
-        delete [] cutsV0vertexer; cutsV0vertexer = NULL; 
        }
        vtxer.Tracks2V0vertices(fesd);
+       AliSysInfo::AddStamp(Form("V0Finder_%d",iEvent), 0,0,iEvent); 
 
        if (fRunCascadeFinder) {
           // Cascade finding
@@ -2120,17 +2369,41 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
          // get cuts for CascadeVertexer from AliGRPRecoParam
          if (grpRecoParam) {
            Int_t nCutsCascadeVertexer = grpRecoParam->GetVertexerCascadeNCuts();
-           Double_t *cutsCascadeVertexer = new Double_t[nCutsCascadeVertexer];
+           Double_t cutsCascadeVertexer[nCutsCascadeVertexer];
            grpRecoParam->GetVertexerCascadeCuts(cutsCascadeVertexer);
            cvtxer.SetCuts(cutsCascadeVertexer);
-           delete [] cutsCascadeVertexer; cutsCascadeVertexer = NULL; 
          }
           cvtxer.V0sTracks2CascadeVertices(fesd);
+         AliSysInfo::AddStamp(Form("CascadeFinder_%d",iEvent), 0,0,iEvent); 
        }
     }
 
+    // AdC+FN
+    if (fReconstructor[3])
+      GetReconstructor(3)->FillEventTimeWithTOF(fesd,fESDpid);
+
+    // combined PID
+    //    fESDpid->MakePID(fesd);
+
+    if (fFillTriggerESD) {
+      if (!FillTriggerESD(fesd)) {
+       if (fStopOnError) {CleanUp(); return kFALSE;}
+      }
+    }
+    // Always fill scalers
+    if (!FillTriggerScalers(fesd)) {
+       if (fStopOnError) {CleanUp(); return kFALSE;}
+    }
+
+    AliSysInfo::AddStamp(Form("FillVaria_%d",iEvent), 0,0,iEvent); 
+
     // write ESD
-    if (fCleanESD) CleanESD(fesd);
+    UInt_t specie = fesd->GetEventSpecie();
+    Bool_t keepAll = (specie==AliRecoParam::kCosmic || specie==AliRecoParam::kCalib);
+    if (fCleanESD && (!keepAll) ) {
+      CleanESD(fesd);
+      AliSysInfo::AddStamp(Form("CleanESD_%d",iEvent), 0,0,iEvent); 
+    }
     // 
     // RS run updated trackleter: since we want to mark the clusters used by tracks and also mark the 
     // tracks interpreted as primary, this step should be done in the very end, when full 
@@ -2140,11 +2413,13 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
       if (!RunMultFinder(fesd)) {
        if (fStopOnError) {CleanUp(); return kFALSE;}
       }
+      AliSysInfo::AddStamp(Form("MultFinder_%d",iEvent), 0,0,iEvent); 
     }
 
   if (fRunQA && IsInTasks(AliQAv1::kESDS)) {
     AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
     AliQAManager::QAManager()->RunOneEvent(fesd, fhltesd) ; 
+    AliSysInfo::AddStamp(Form("RunQA_%d",iEvent), 0,0,iEvent); 
   }
   if (fRunGlobalQA) {
     AliQADataMaker *qadm = AliQAManager::QAManager()->GetQADataMaker(AliQAv1::kGLOBAL);
@@ -2152,6 +2427,7 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
       qadm->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
     if (qadm && IsInTasks(AliQAv1::kESDS))
       qadm->Exec(AliQAv1::kESDS, fesd);
+    AliSysInfo::AddStamp(Form("RunGlobQA_%d",iEvent), 0,0,iEvent);     
   }
 
   // copy HLT decision from HLTesd to esd
@@ -2162,47 +2438,77 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
   if (pHLTSrc && pHLTTgt) {
     pHLTSrc->Copy(*pHLTTgt);
   }
+  //
+  // Perform analysis of this event if requested
+  // RS: Should be done before WriteESDfriend, since the latter may clean the esdfriend
+  if (fAnalysis) {
+    fRecoHandler->BeginEvent(iEvent);
+    fAnalysis->ExecAnalysis();
+    fRecoHandler->FinishEvent();
+    AliSysInfo::AddStamp(Form("Analysis_%d",iEvent), 0,0,iEvent);     
+  }  
+  //
+  if (fWriteESDfriend) {
+    fesd->GetESDfriend(fesdf);
+    AliSysInfo::AddStamp(Form("CreateFriend_%d",iEvent), 0,0,iEvent);     
+  
+  }
+  //
+  Long64_t nbf;
+  nbf = ftree->Fill();
+  if (fTreeBuffSize>0 && ftree->GetAutoFlush()<0 && (fMemCountESD += nbf)>fTreeBuffSize ) { // default limit is still not reached
+    nbf = ftree->GetZipBytes();
+    if (nbf>0) nbf = -nbf;
+    else       nbf = ftree->GetEntries();
+    ftree->SetAutoFlush(nbf);
+    AliInfo(Form("Calling ftree->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
+                nbf,fMemCountESD,ftree->GetTotBytes(),ftree->GetZipBytes()));        
+  }
+  AliSysInfo::AddStamp(Form("ESDFill_%d",iEvent), 0,0,iEvent);     
+  //
+  if (fWriteESDfriend) {
+    WriteESDfriend();
+    AliSysInfo::AddStamp(Form("WriteFriend_%d",iEvent), 0,0,iEvent);     
+  }
+  //
+  //
+  // Auto-save the ESD tree in case of prompt reco @P2
+  if (fRawReader && fRawReader->UseAutoSaveESD()) {
+    ftree->AutoSave("SaveSelf");
+    if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
+  }
+  // write HLT ESD
+  
+  nbf = fhlttree->Fill();
+  if (fTreeBuffSize>0 && fhlttree->GetAutoFlush()<0 && (fMemCountESDHLT += nbf)>fTreeBuffSize ) { // default limit is still not reached
+    nbf = fhlttree->GetZipBytes();
+    if (nbf>0) nbf = -nbf;
+    else       nbf = fhlttree->GetEntries();
+    fhlttree->SetAutoFlush(nbf);
+    AliInfo(Form("Calling fhlttree->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
+                nbf,fMemCountESDHLT,fhlttree->GetTotBytes(),fhlttree->GetZipBytes()));        
+  }
+    
+    
+  return kTRUE;
+}
 
-    if (fWriteESDfriend) 
-      fesd->GetESDfriend(fesdf);
-
-    ftree->Fill();
-    if (fWriteESDfriend) {
-      WriteESDfriend();
-    }
-
-    // Auto-save the ESD tree in case of prompt reco @P2
-    if (fRawReader && fRawReader->UseAutoSaveESD()) {
-      ftree->AutoSave("SaveSelf");
-      if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
-    }
-
-    // write HLT ESD
-    fhlttree->Fill();
-
-    // call AliEVE
-    if (fRunAliEVE) RunAliEVE();
-
+void AliReconstruction::CleanProcessedEvent()
+{
+    //
     fesd->Reset();
     fhltesd->Reset();
     if (fWriteESDfriend) {
       fesdf->~AliESDfriend();
       new (fesdf) AliESDfriend(); // Reset...
     }
+
+    for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+      if (fReconstructor[iDet]) fReconstructor[iDet]->FinishEvent();
+    }
  
-    gSystem->GetProcInfo(&procInfo);
-    Long_t dMres=(procInfo.fMemResident-oldMres)/1024;
-    Long_t dMvir=(procInfo.fMemVirtual-oldMvir)/1024;
-    Float_t dCPU=procInfo.fCpuUser+procInfo.fCpuSys-oldCPU;
-    aveDMres+=(dMres-aveDMres)/(iEvent-fFirstEvent+1);
-    aveDMvir+=(dMvir-aveDMvir)/(iEvent-fFirstEvent+1);
-    aveDCPU+=(dCPU-aveDCPU)/(iEvent-fFirstEvent+1);
-    AliInfo(Form("======================= End Event %d: Res %ld(%3ld <%3ld>) Vir %ld(%3ld <%3ld>) CPU %5.2f <%5.2f> ===================",
-                iEvent, procInfo.fMemResident/1024, dMres, aveDMres, procInfo.fMemVirtual/1024, dMvir, aveDMvir, dCPU, aveDCPU));
-    oldMres=procInfo.fMemResident;
-    oldMvir=procInfo.fMemVirtual;
-    oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
-  
+    AliInfo("======================= End Event ===================");
+    
     fEventInfo.Reset();
     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
       if (fReconstructor[iDet]) {
@@ -2214,8 +2520,11 @@ Bool_t AliReconstruction::ProcessEvent(Int_t iEvent)
        
   if (fRunQA || fRunGlobalQA) 
     AliQAManager::QAManager()->Increment() ; 
-  
-    return kTRUE;
+
+  DeleteRecPoints(fDeleteRecPoints);
+  DeleteDigits(fDeleteDigits);
+  //
+
 }
 
 //_____________________________________________________________________________
@@ -2225,6 +2534,12 @@ void AliReconstruction::SlaveTerminate()
   // Called after the exit
   // from the event loop
   AliCodeTimerAuto("",0);
+  // If analysis was done during reconstruction, we need to call SlaveTerminate for it
+  if (fAnalysis) {
+     fAnalysis->PackOutput(fOutput);
+     fAnalysis->SetSkipTerminate(kTRUE);
+     fAnalysis->Terminate();
+  }   
 
   if (fIsNewRunLoader) { // galice.root didn't exist
     fRunLoader->WriteHeader("OVERWRITE");
@@ -2265,15 +2580,27 @@ void AliReconstruction::SlaveTerminate()
 
    // Add the AliRoot version that created this file
    TString sVersion("aliroot ");
-   sVersion += ALIROOT_SVN_BRANCH;
+   sVersion += ALIROOT_BRANCH;
    sVersion += ":";
-   sVersion += ALIROOT_SVN_REVISION;
+   sVersion += ALIROOT_REVISION;
    sVersion += "; root ";
+#ifdef ROOT_SVN_BRANCH
    sVersion += ROOT_SVN_BRANCH;
+#elif defined(ROOT_GIT_BRANCH)
+   sVersion += ROOT_GIT_BRANCH;
+#else
+   sVersion += "?";
+#endif
    sVersion += ":";
+#ifdef ROOT_SVN_REVSION
    sVersion += ROOT_SVN_REVISION;
+#elif defined(ROOT_GIT_COMMIT)
+   sVersion += ROOT_GIT_COMMIT;
+#else 
+   sVersion += "?";
+#endif
    sVersion += "; metadata ";
-   sVersion += gSystem->Getenv("PRODUCTION_METADATA");
+   sVersion += getenv("PRODUCTION_METADATA");
                    
 
    TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
@@ -2295,6 +2622,9 @@ void AliReconstruction::SlaveTerminate()
    AliWarning("Finish PlaneEff evaluation failed");
   }
 
+  for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+    if (fReconstructor[iDet]) fReconstructor[iDet]->Terminate();
+  }
   // End of cycle for the in-loop  
 
   if (fRunQA || fRunGlobalQA) {
@@ -2375,22 +2705,30 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
   // execute HLT reconstruction first since other detector reconstruction
   // might depend on HLT data
   // key 'HLT' is removed from detStr by IsSelected
-  if (!IsSelected("HLT", detStr)) {
+  if (IsSelected("HLT", detStr)) {
     AliReconstructor* reconstructor = GetReconstructor(kNDetectors-1);
     if (reconstructor) {
       // there is no AliLoader for HLT, see
       // https://savannah.cern.ch/bugs/?35473
       AliInfo("running reconstruction for HLT");
       if (fRawReader) {
+       AliInfo("reconstructor->Reconstruct(fRawReader, NULL)");
         reconstructor->Reconstruct(fRawReader, NULL);
-      } else {
+      } 
+      else {
+       AliInfo("reconstructor->Reconstruct(dummy, NULL)");
         TTree* dummy=NULL;
         reconstructor->Reconstruct(dummy, NULL);
       }
     }
+    AliSysInfo::AddStamp(Form("LRecHLT_%d",eventNr), -1,1,eventNr);
   }
+
+  AliInfo(Form("kNDetectors = %d",kNDetectors));
+
   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
     if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+    AliDebug(1, Form("Detector: %s", fgkDetectorName[iDet]));
     AliReconstructor* reconstructor = GetReconstructor(iDet);
     if (!reconstructor) continue;
     AliLoader* loader = fLoader[iDet];
@@ -2415,20 +2753,28 @@ Bool_t AliReconstruction::RunLocalEventReconstruction(const TString& detectors)
     // local reconstruction
     AliInfo(Form("running reconstruction for %s", fgkDetectorName[iDet]));
     //AliCodeTimerAuto(Form("running reconstruction for %s", fgkDetectorName[iDet]),0);
+    AliDebug(1, "Loading Rec Points");
     loader->LoadRecPoints("update");
+    AliDebug(1, "Cleaning Rec Points");
     loader->CleanRecPoints();
+    AliDebug(1, "Making Rec Points Container");
     loader->MakeRecPointsContainer();
     TTree* clustersTree = loader->TreeR();
     if (fRawReader && !reconstructor->HasDigitConversion()) {
       reconstructor->Reconstruct(fRawReader, clustersTree);
-    } else {
+    } 
+    else {
+      AliDebug(1, "Loading Digits");
       loader->LoadDigits("read");
       TTree* digitsTree = loader->TreeD();
+      AliDebug(1, Form("Digits Tree = %p",digitsTree));
       if (!digitsTree) {
         AliError(Form("Can't get the %s digits tree", fgkDetectorName[iDet]));
         if (fStopOnError) 
           return kFALSE;
-      } else {
+      } 
+      else {
+       AliDebug(1, "Digits -> Clusters");
         reconstructor->Reconstruct(digitsTree, clustersTree);
         if (fRunQA && IsInTasks(AliQAv1::kDIGITSR)) {
           AliQAManager::QAManager()->SetEventSpecie(fRecoParam.GetEventSpecie()) ;
@@ -2605,9 +2951,9 @@ Bool_t AliReconstruction::RunMultFinder(AliESDEvent*& esd)
 }
 
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
+Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
 {
-// run the HLT barrel tracking
+// run the muon spectrometer tracking
 
   AliCodeTimerAuto("",0)
 
@@ -2615,55 +2961,48 @@ Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
     AliError("Missing runLoader!");
     return kFALSE;
   }
+  Int_t iDet =  GetDetIndex("MUON"); // for MUON
 
-  AliInfo("running HLT tracking");
-
-  // Get a pointer to the HLT reconstructor
-  AliReconstructor *reconstructor = GetReconstructor(kNDetectors-1);
+  // Get a pointer to the MUON reconstructor
+  AliReconstructor *reconstructor = GetReconstructor(iDet);
   if (!reconstructor) return kFALSE;
 
-  // TPC + ITS
-  for (Int_t iDet = 1; iDet >= 0; iDet--) {
-    TString detName = fgkDetectorName[iDet];
-    AliDebug(1, Form("%s HLT tracking", detName.Data()));
-    reconstructor->SetOption(detName.Data());
-    AliTracker *tracker = reconstructor->CreateTracker();
-    if (!tracker) {
-      AliWarning(Form("couldn't create a HLT tracker for %s", detName.Data()));
-      if (fStopOnError) return kFALSE;
-      continue;
-    }
-    Double_t vtxPos[3];
-    Double_t vtxErr[3]={0.005,0.005,0.010};
-    const AliESDVertex *vertex = esd->GetVertex();
-    vertex->GetXYZ(vtxPos);
-    tracker->SetVertex(vtxPos,vtxErr);
-    if(iDet != 1) {
-      fLoader[iDet]->LoadRecPoints("read");
-      TTree* tree = fLoader[iDet]->TreeR();
-      if (!tree) {
-       AliError(Form("Can't get the %s cluster tree", detName.Data()));
-       return kFALSE;
-      }
-      tracker->LoadClusters(tree);
-    }
-    if (tracker->Clusters2Tracks(esd) != 0) {
-      AliError(Form("HLT %s Clusters2Tracks failed", fgkDetectorName[iDet]));
-      return kFALSE;
-    }
-    if(iDet != 1) {
-      tracker->UnloadClusters();
-    }
-    delete tracker;
+  
+  TString detName = fgkDetectorName[iDet];
+  AliDebug(1, Form("%s tracking", detName.Data()));
+  AliTracker *tracker =  reconstructor->CreateTracker();
+  if (!tracker) {
+    AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
+    return kFALSE;
   }
+     
+  // read RecPoints
+  fLoader[iDet]->LoadRecPoints("read");  
+
+  tracker->LoadClusters(fLoader[iDet]->TreeR());
+  
+  Int_t rv = tracker->Clusters2Tracks(esd);
+  
+  fLoader[iDet]->UnloadRecPoints();
 
+  tracker->UnloadClusters();
+  
+  if ( rv )
+  {
+    AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
+    return kFALSE;
+  }
+  
   return kTRUE;
 }
 
+
 //_____________________________________________________________________________
-Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
-{
-// run the muon spectrometer tracking
+Bool_t AliReconstruction::RunMFTTrackingMU(AliESDEvent*& esd) {
+
+  // AU
+
+  // run the global muon tracking: matching the MUON tracks with the MFT clusters
 
   AliCodeTimerAuto("",0)
 
@@ -2671,20 +3010,17 @@ Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
     AliError("Missing runLoader!");
     return kFALSE;
   }
-  Int_t iDet = 7; // for MUON
+  Int_t iDet = GetDetIndex("MFT"); // for MFT
 
-  AliInfo("is running...");
-
-  // Get a pointer to the MUON reconstructor
+  // Get a pointer to the MFT reconstructor
   AliReconstructor *reconstructor = GetReconstructor(iDet);
   if (!reconstructor) return kFALSE;
-
   
   TString detName = fgkDetectorName[iDet];
-  AliDebug(1, Form("%s tracking", detName.Data()));
-  AliTracker *tracker =  reconstructor->CreateTracker();
+  AliDebug(1, Form("%s tracking for muon tracks", detName.Data()));
+  AliTracker *tracker = reconstructor->CreateTracker();
   if (!tracker) {
-    AliWarning(Form("couldn't create a tracker for %s", detName.Data()));
+    AliWarning(Form("couldn't create a Muon tracker for %s", detName.Data()));
     return kFALSE;
   }
      
@@ -2699,17 +3035,14 @@ Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
 
   tracker->UnloadClusters();
   
-  delete tracker;
-  
-  if ( rv )
-  {
+  if (rv) {
     AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
     return kFALSE;
   }
   
   return kTRUE;
-}
 
+}
 
 //_____________________________________________________________________________
 Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
@@ -2755,16 +3088,17 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
     fTracker[iDet]->LoadClusters(tree);
     AliSysInfo::AddStamp(Form("TLoadCluster%s_%d",fgkDetectorName[iDet],eventNr), iDet,2, eventNr);
     // run tracking
-    if (fTracker[iDet]->Clusters2Tracks(esd) != 0) {
+    if (fTracker[iDet]->Clusters2TracksHLT(esd, fhltesd) != 0) {
       AliError(Form("%s Clusters2Tracks failed", fgkDetectorName[iDet]));
       return kFALSE;
     }
+    AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
     // preliminary PID in TPC needed by the ITS tracker
     if (iDet == 1) {
       GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
-      PID.MakePID(esd,kTRUE);
+      PID.MakePIDForTracking(esd);
+      AliSysInfo::AddStamp(Form("MakePID0%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
     } 
-    AliSysInfo::AddStamp(Form("Tracking0%s_%d",fgkDetectorName[iDet],eventNr), iDet,3,eventNr);
   }
 
   // pass 2: ALL backwards
@@ -2800,11 +3134,13 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
            if (qadm) qadm->InitRecPointsForTracker() ; 
          }
        }
+       //      AliSysInfo::AddStamp(Form("QAInitResid%s_%d",fgkDetectorName[iDet],eventNr), iDet,0, eventNr);
       }
     if (fTracker[iDet]->PropagateBack(esd) != 0) {
       AliError(Form("%s backward propagation failed", fgkDetectorName[iDet]));
       //      return kFALSE;
     }
+    AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
 
     // unload clusters
     if (iDet > 3) {     // all except ITS, TPC, TRD and TOF
@@ -2815,9 +3151,10 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
     if (iDet == 1) {
       //GetReconstructor(1)->FillESD((TTree*)NULL, (TTree*)NULL, esd);
       //AliESDpid::MakePID(esd);
-      PID.MakePID(esd,kTRUE);
+      PID.MakePIDForTracking(esd);
+      AliSysInfo::AddStamp(Form("MakePID1%s_%d",fgkDetectorName[iDet],eventNr), iDet,4,eventNr);
     }
-    AliSysInfo::AddStamp(Form("Tracking1%s_%d",fgkDetectorName[iDet],eventNr), iDet,3, eventNr);
+
   }
   //stop filling residuals for the "outer" detectors
   if (fRunGlobalQA) AliTracker::SetFillResiduals(fRecoParam.GetEventSpecie(), kFALSE);     
@@ -2857,9 +3194,11 @@ Bool_t AliReconstruction::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
 
   // write space-points to the ESD in case alignment data output
   // is switched on
-  if (fWriteAlignmentData)
+  if (fWriteAlignmentData) {
     WriteAlignmentData(esd);
-
+    AliSysInfo::AddStamp(Form("WrtAlignData_%d",eventNr), 0,0, eventNr);
+  }
+  
   for (Int_t iDet = 3; iDet >= 0; iDet--) {
     if (!fTracker[iDet]) continue;
     // unload clusters
@@ -2985,15 +3324,16 @@ Bool_t AliReconstruction::FillTriggerESD(AliESDEvent*& esd)
       esdheader->SetL1TriggerInputs(input.GetL1Inputs());
       esdheader->SetL2TriggerInputs(input.GetL2Inputs());
       // IR
-      UInt_t orbit=input.GetOrbitID();
-       for(Int_t i=0 ; i<input.GetNIRs() ; i++ )
-          if(TMath::Abs(Int_t(orbit-(input.GetIR(i))->GetOrbit()))<=1){
-            esdheader->AddTriggerIR(input.GetIR(i));
-         }
+      //      UInt_t orbit=input.GetOrbitID();
+      for(Int_t i=0 ; i<input.GetNIRs() ; i++ ) {
+       esdheader->AddTriggerIR(input.GetIR(i));
+      }
        AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
-       rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
-       rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
-       rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
+       if (rlCTP) {
+        rlCTP->SetL0TriggerInputs(input.GetL0Inputs());
+        rlCTP->SetL1TriggerInputs(input.GetL1Inputs());
+        rlCTP->SetL2TriggerInputs(input.GetL2Inputs());
+       }
     }
     if (fIsNewRunLoader) fRunLoader->TreeCT()->Fill();
   }
@@ -3094,7 +3434,6 @@ Bool_t AliReconstruction::InitRunLoader()
     TString libs = gSystem->GetLibraries();
     for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
       TString detName = fgkDetectorName[iDet];
-      if (detName == "HLT") continue;
       if (libs.Contains("lib" + detName + "base.so")) continue;
       gSystem->Load("lib" + detName + "base.so");
     }
@@ -3193,6 +3532,7 @@ AliReconstructor* AliReconstruction::GetReconstructor(Int_t iDet)
     TObject* obj = fOptions.FindObject(detName.Data());
     if (obj) reconstructor->SetOption(obj->GetTitle());
     reconstructor->SetRunInfo(fRunInfo);
+    reconstructor->SetHLTESD(fhltesd);
     reconstructor->Init();
     fReconstructor[iDet] = reconstructor;
   }
@@ -3299,14 +3639,14 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
     AliReconstructor* reconstructor = GetReconstructor(iDet);
     if (!reconstructor) continue;
     TString detName = fgkDetectorName[iDet];
-    if (detName == "HLT") {
-      fRunHLTTracking = kTRUE;
-      continue;
-    }
     if (detName == "MUON") {
       fRunMuonTracking = kTRUE;
       continue;
     }
+    if (detName == "MFT") {           // AU    
+      fRunMFTTrackingMU = kTRUE;      // AU
+      continue;                              // AU
+    }                                 // AU
 
     fTracker[iDet] = reconstructor->CreateTracker();
     if (!fTracker[iDet] && (iDet < 7)) {
@@ -3323,7 +3663,6 @@ Bool_t AliReconstruction::CreateTrackers(const TString& detectors)
 void AliReconstruction::CleanUp()
 {
 // delete trackers and the run loader and close and delete the file
-/*
   for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
     delete fReconstructor[iDet];
     fReconstructor[iDet] = NULL;
@@ -3331,7 +3670,6 @@ void AliReconstruction::CleanUp()
     delete fTracker[iDet];
     fTracker[iDet] = NULL;
   }
-*/
 
   delete fRunInfo;
   fRunInfo = NULL;
@@ -3349,6 +3687,9 @@ void AliReconstruction::CleanUp()
   delete fParentRawReader;
   fParentRawReader=NULL;
 
+  delete fESDpid;
+  fESDpid = NULL;
+
   if (ffile) {
     ffile->Close();
     delete ffile;
@@ -3357,8 +3698,9 @@ void AliReconstruction::CleanUp()
 
   if (AliQAManager::QAManager())
     AliQAManager::QAManager()->ShowQA() ; 
-  //  AliQAManager::Destroy() ; 
-  
+  //  AliQAManager::Destroy() ;
+  delete fAnalysis; 
+  fAnalysis = NULL;
 }
 
 void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
@@ -3579,7 +3921,7 @@ Bool_t AliReconstruction::InitAliEVE()
   // The return flag shows whenever the
   // AliEVE initialization was successful or not.
 
-  TString macroStr(gSystem->Getenv("ALIEVE_ONLINE_MACRO"));
+  TString macroStr(getenv("ALIEVE_ONLINE_MACRO"));
 
   if (macroStr.IsNull())
     macroStr.Form("%s/EVE/macros/alieve_online.C",gSystem->ExpandPathName("$ALICE_ROOT"));
@@ -3770,9 +4112,13 @@ Bool_t AliReconstruction::GetEventInfo()
     aCTP->SetClassMask(mask);
     aCTP->SetClusterMask(clmask);
 
-    AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
-    rlCTP->SetClassMask(mask);
-    rlCTP->SetClusterMask(clmask);
+    if (fRunLoader) {
+      AliCentralTrigger* rlCTP = fRunLoader->GetTrigger();
+      if (rlCTP) {
+       rlCTP->SetClassMask(mask);
+       rlCTP->SetClusterMask(clmask);
+      }
+    }
   }
   else {
     fEventInfo.SetEventType(AliRawEventHeaderBase::kPhysicsEvent);
@@ -3788,6 +4134,7 @@ Bool_t AliReconstruction::GetEventInfo()
       fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(aCTP->GetClusterMask()));
     }
     else {
+      if (fStopOnMissingTriggerFile) AliFatal("No trigger can be loaded! Stopping reconstruction!");
       AliWarning("No trigger can be loaded! The trigger information will not be used!");
       return kFALSE;
     }
@@ -3800,6 +4147,32 @@ Bool_t AliReconstruction::GetEventInfo()
     return kFALSE;
   }
 
+  // Load trigger aliases and declare the trigger classes included in aliases
+  //PH Why do we do it in each event and not only once in the beginning of the chunk??
+  //PH Temporary fix for #99725: AliReconstruction::GetEventInfo bug
+  fDeclTriggerClasses.Clear();
+  AliCDBEntry * entry = AliCDBManager::Instance()->Get("GRP/CTP/Aliases");
+  if (entry) {
+    THashList * lst = dynamic_cast<THashList*>(entry->GetObject());
+    if (lst) {
+      lst->Sort(kSortDescending); // to avoid problems with substrungs
+      if (fRawReader) fRawReader->LoadTriggerAlias(lst);
+      // Now declare all the triggers present in the aliases
+      TIter iter(lst);
+      TNamed *nmd = 0;
+      while((nmd = dynamic_cast<TNamed*>(iter.Next()))){
+       fDeclTriggerClasses += " ";
+       fDeclTriggerClasses += nmd->GetName();
+      }
+    }
+    else {
+      AliError("Cannot cast the object with trigger aliases to THashList!");
+    }
+  }
+  else {
+    AliError("No OCDB ebtry for the trigger aliases!");
+  }
+  // Load trigger classes for this run
   UChar_t clustmask = 0;
   TString trclasses;
   ULong64_t trmask = fEventInfo.GetTriggerMask();
@@ -3809,7 +4182,7 @@ Bool_t AliReconstruction::GetEventInfo()
     AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
     if (trclass && trclass->GetMask()>0) {
       Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
-      fesd->SetTriggerClass(trclass->GetName(),trindex);
+      if (fesd) fesd->SetTriggerClass(trclass->GetName(),trindex);
       if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
       if (trmask & (1ull << trindex)) {
        trclasses += " ";
@@ -3820,6 +4193,16 @@ Bool_t AliReconstruction::GetEventInfo()
     }
   }
   fEventInfo.SetTriggerClasses(trclasses);
+  // Now put the declared trigger classes (not present in the run)
+  // to 0/false in the event selection
+  if (!fDeclTriggerClasses.IsNull()) {
+    TObjArray *tokens = fDeclTriggerClasses.Tokenize(" ");
+    Int_t ntokens = tokens->GetEntriesFast();
+    for (Int_t itoken = 0; itoken < ntokens; ++itoken) {
+      if (fRawReader) fRawReader->LoadTriggerClass((((TObjString*)tokens->At(itoken))->String()).Data(),-1);
+    }
+    delete tokens;
+  }
 
   // Write names of active trigger inputs in ESD Header
   const TObjArray& inputsArray = config->GetInputs(); 
@@ -3828,17 +4211,22 @@ Bool_t AliReconstruction::GetEventInfo()
     AliTriggerInput* trginput = (AliTriggerInput*)inputsArray.At(iinput);
     if (trginput && trginput->GetMask()>0) {
       Int_t inputIndex = (Int_t)TMath::Nint(TMath::Log2(trginput->GetMask()));
-      AliESDHeader* headeresd = fesd->GetHeader();
-      Int_t trglevel = (Int_t)trginput->GetLevel();
-      if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
-      if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
-      if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
+      AliESDHeader* headeresd = 0x0;
+      if (fesd) headeresd = fesd->GetHeader();
+      if (headeresd) {
+       Int_t trglevel = (Int_t)trginput->GetLevel();
+       if (trglevel == 0) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex);
+       if (trglevel == 1) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+24);
+       if (trglevel == 2) headeresd->SetActiveTriggerInputs(trginput->GetInputName(), inputIndex+48);
+      }
     }
   }
 
   // Set the information in ESD
-  fesd->SetTriggerMask(trmask);
-  fesd->SetTriggerCluster(clustmask);
+  if (fesd) {
+    fesd->SetTriggerMask(trmask);
+    fesd->SetTriggerCluster(clustmask);
+  }
 
   if (!aCTP->CheckTriggeredDetectors()) {
     if (fRawReader) delete aCTP;
@@ -3937,7 +4325,7 @@ void AliReconstruction::Abort(const char *method, EAbort what)
   else if (fAbort == kAbortFile)
     mess = "AbortFile";
 
-  Info(mess, whyMess.Data());
+  Info(mess.Data(), "%s", whyMess.Data());
 }
 
 //______________________________________________________________________________
@@ -4103,14 +4491,9 @@ void AliReconstruction::WriteESDfriend() {
 
   if (IsCosmicOrCalibSpecie()) { // Selection of calib or cosmic events
     fNspecie++;
-    Double_t curentSpecieFraction = ((Double_t)(fNspecie+1))/((Double_t)(fNall+1)); 
-    // "Bayesian" estimate supposing that without events all the events are of the required type
-    
-    Double_t rnd = gRandom->Rndm()*curentSpecieFraction;
-    if (rnd<fFractionFriends) {
-      isSelected = kTRUE;
-      fSspecie++;
-    }
+
+    isSelected = kTRUE;
+    fSspecie++;
   }
   
   Double_t remainingFraction = fFractionFriends;
@@ -4144,6 +4527,236 @@ void AliReconstruction::WriteESDfriend() {
     new (fesdf) AliESDfriend(); // Reset...
     fesdf->SetSkipBit(kTRUE);
   }
+  //
+  Long64_t nbf = ftreeF->Fill();
+  if (fTreeBuffSize>0 && ftreeF->GetAutoFlush()<0 && (fMemCountESDF += nbf)>fTreeBuffSize ) { // default limit is still not reached
+    nbf = ftreeF->GetZipBytes();
+    if (nbf>0) nbf = -nbf;
+    else       nbf = ftreeF->GetEntries();
+    ftreeF->SetAutoFlush(nbf);
+    AliInfo(Form("Calling ftreeF->SetAutoFlush(%lld) | W:%lld T:%lld Z:%lld",
+                nbf,fMemCountESDF,ftreeF->GetTotBytes(),ftreeF->GetZipBytes()));        
+  }
   
-  ftreeF->Fill();
+}
+
+//_________________________________________________________________
+void AliReconstruction::DeleteDigits(const TString& detectors)
+{
+  // delete requested digit files produced at current event
+  static int iEvent = 0;
+  if (detectors.IsNull()) return;
+  TString detStr = detectors;
+  AliInfo(Form("Deleting Digits: %s",detectors.Data()));
+
+  for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+    if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+    unlink(Form("%s.Digits.root",fgkDetectorName[iDet]));
+  }
+  AliSysInfo::AddStamp(Form("DelDigits_%d",iEvent), 0,0,iEvent);
+  iEvent++;
+}
+
+//_________________________________________________________________
+void AliReconstruction::DeleteRecPoints(const TString& detectors)
+{
+  // delete requested recpoint files produced at current event
+  static int iEvent = 0;
+  if (detectors.IsNull()) return;
+  TString detStr = detectors;
+  AliInfo(Form("Deleting Recpoints: %s",detectors.Data()));
+  //
+  for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+    if(!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+    unlink(Form("%s.RecPoints.root",fgkDetectorName[iDet]));
+  }
+  AliSysInfo::AddStamp(Form("DelRecPoints_%d",iEvent), 0,0,iEvent);
+  iEvent++;
+}
+
+//_________________________________________________________________
+void AliReconstruction::SetStopOnResourcesExcess(Int_t vRSS,Int_t vVMEM)
+{
+  // require checking the resources left and stopping on excess
+  // if 0  : no check is done
+  // if >0 : stop reconstruction if exceeds this value
+  // if <0 : use as margin to system limits
+  //
+  const int kKB2MB = 1024;
+  const int kInfMem = 9999999;
+  //
+  struct rlimit r;
+  int pgSize = getpagesize();
+  //
+  if (vRSS>0) {
+    fMaxRSS = vRSS;
+    AliInfo(Form("Setting max. RSS usage to user value %d MB",fMaxRSS));
+  }
+  else if (vRSS<0) {
+    getrlimit(RLIMIT_RSS,&r);
+    fMaxRSS = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vRSS;
+    AliInfo(Form("Setting max. RSS usage to system hard limit %d%s MB (%d margin)",fMaxRSS,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vRSS));
+  }
+  else {AliInfo("No check on RSS memory usage will be applied");}
+  //
+  if (vVMEM>0) {
+    fMaxVMEM = vVMEM;
+    AliInfo(Form("Setting max. VMEM usage to user value %d MB",fMaxVMEM));
+  }
+  else if (vVMEM<0) {
+    getrlimit(RLIMIT_AS,&r);
+    fMaxVMEM = r.rlim_max==RLIM_INFINITY ? kInfMem : int(r.rlim_max*pgSize/kKB2MB/kKB2MB) + vVMEM;
+    AliInfo(Form("Setting max. VMEM usage to system hard limit %d%s MB (%d margin)",fMaxVMEM,r.rlim_max==RLIM_INFINITY ? "(inf)":"",-vVMEM));
+  }
+  else {AliInfo("No check on RSS memory usage will be applied");}
+  //  
+}
+
+//_________________________________________________________________
+Bool_t AliReconstruction::HasEnoughResources(int ev)
+{
+  // check if process consumed more than allowed resources
+  const int kKB2MB = 1024;
+  Bool_t res = kTRUE;
+  if (!fMaxRSS && !fMaxVMEM) return res;
+  //
+  ProcInfo_t procInfo;
+  gSystem->GetProcInfo(&procInfo);
+  if (procInfo.fMemResident/kKB2MB > fMaxRSS)  res = kFALSE;
+  if (procInfo.fMemVirtual/kKB2MB  > fMaxVMEM) res = kFALSE;  
+  //
+  if (!res) {
+    AliInfo(Form("Job exceeded allowed limits: RSS:%d (%d) VMEM:%d (%d), will stop",
+                int(procInfo.fMemResident/kKB2MB),fMaxRSS,
+                int(procInfo.fMemVirtual/kKB2MB) ,fMaxVMEM));
+    //
+    unlink(Form("%s",fgkStopEvFName));
+    ofstream outfile(fgkStopEvFName);
+    outfile << ev << std::endl;
+    outfile.close();
+    fStopped = kTRUE;
+  }
+  return res;
+}
+
+Bool_t AliReconstruction::HasNextEventAfter(Int_t eventId)
+{
+        return ( (eventId < fRunLoader->GetNumberOfEvents()) ||
+          (fRawReader && fRawReader->NextEvent()) );
+}
+
+//_________________________________________________________________
+void AliReconstruction::CheckRecoCDBvsSimuCDB()
+{
+  // if some CDB entries must be the same in the simulation
+  // and reconstruction, check here
+  int nent = fCheckRecoCDBvsSimuCDB.GetEntriesFast();
+  AliInfo(Form("Check %d entries for matching between sim and rec",nent));
+  //
+  // get simulation CDB
+  fRunLoader->CdGAFile();
+  TMap*  cdbMapSim  = (TMap*)gDirectory->Get("cdbMap");
+  TList* cdbListSim = (TList*)gDirectory->Get("cdbList");
+  if (!(cdbMapSim && cdbListSim)) {
+    AliInfo(Form("No CDBMap/List found in %s, nothing to check",fGAliceFileName.Data()));
+    return;
+  }
+  // read the requested objects to make sure they will appear in the reco list
+  for (Int_t i=0;i<nent;i++) {
+    TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
+    if (!cdbent) continue;
+    AliCDBManager::Instance()->Get(cdbent->GetName());
+  }
+  // get default path for simulation
+  TPair* pair;
+  TObjString* stro;
+  pair = (TPair*)cdbMapSim->FindObject("default");
+  if (!pair) {AliFatal("Did not find default storage used for simulations"); return;}
+  TString defSimStore = ((TObjString*)pair->Value())->GetString();
+  RectifyCDBurl(defSimStore);
+  //
+  // get reconstruction CDB
+  const TMap *cdbMapRec = AliCDBManager::Instance()->GetStorageMap();   
+  const TList *cdbListRec = AliCDBManager::Instance()->GetRetrievedIds();
+  //
+  // get default path for reconstruction
+  pair = (TPair*)cdbMapRec->FindObject("default");
+  if (!pair) {AliFatal("Did not find default storage used for reconstruction"); return;}
+  TString defRecStore = ((TObjString*)pair->Value())->GetString();
+  RectifyCDBurl(defRecStore);
+  //
+  for (Int_t i=0;i<nent;i++) {
+    TNamed* cdbent = (TNamed*) fCheckRecoCDBvsSimuCDB[i];
+    if (!cdbent) continue;
+    //
+    AliInfo(Form("#%d Checking %s",i,cdbent->GetName()));
+    //
+    // find cdbID used for sim
+    TString idSim="",storSim="";
+    TIter nextSim(cdbListSim);
+    while ((stro=(TObjString*)nextSim())) {
+      if (stro->GetString().Contains(cdbent->GetName())) {
+       idSim = stro->GetString();
+       break;
+      }
+    }    
+    // find the storage used for sim
+    // check in the simuCDB special paths
+    pair = (TPair*)cdbMapSim->FindObject(cdbent->GetName());
+    if (pair) { // specific path is used
+      storSim = ((TObjString*)pair->Value())->GetString();
+      RectifyCDBurl(storSim);
+    }
+    else storSim = defSimStore;  // default storage list is used
+    //
+    if (!idSim.IsNull()) AliInfo(Form("Sim. used %s from %s",idSim.Data(), storSim.Data()));
+    else                 AliInfo("Sim. did not use this object");
+    //
+    // find cdbID used for rec
+    TString idRec="",storRec="";
+    TIter nextRec(cdbListRec);
+    AliCDBId* id=0;
+    while ((id=(AliCDBId*)nextRec())) {
+      idRec = id->ToString();
+      if (idRec.Contains(cdbent->GetName())) break;
+      idRec="";
+    }
+    //
+    // find storage used for the rec
+    pair = (TPair*)cdbMapRec->FindObject(cdbent->GetName());
+    if (pair) {  // specific path is used
+      storRec = ((TObjString*)pair->Value())->GetString();
+      RectifyCDBurl(storRec);
+    }
+    else storRec = defRecStore; // default storage list is used
+    //
+    if (!idRec.IsNull()) AliInfo(Form("Rec. used %s from %s",idRec.Data(), storRec.Data()));
+    else                 AliInfo("Rec. did not use this object");
+    //
+    if (!idSim.IsNull() && !idRec.IsNull() && ((idSim!=idRec) || (storSim!=storRec)) ) 
+      AliFatal("Different objects were used in sim and rec");
+  }
+  
+}
+
+//_________________________________________________________
+void AliReconstruction::RectifyCDBurl(TString& url)
+{
+  // TBD RS
+  // remove everything but the url
+  TString sbs;
+  if (!(sbs=url("\\?User=[^?]*")).IsNull())                url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?DBFolder=[^?]*")).IsNull())            url.ReplaceAll("?DB","");
+  if (!(sbs=url("\\?SE=[^?]*")).IsNull())                  url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?CacheFolder=[^?]*")).IsNull())         url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?OperateDisconnected=[^?]*")).IsNull()) url.ReplaceAll(sbs,"");
+  if (!(sbs=url("\\?CacheSize=[^?]*")).IsNull())           url.ReplaceAll(sbs,"");  
+  if (!(sbs=url("\\?CleanupInterval=[^?]*")).IsNull())     url.ReplaceAll(sbs,"");  
+  Bool_t slash=kFALSE,space=kFALSE;
+  while ( (slash=url.EndsWith("/")) || (space=url.EndsWith(" ")) ) {
+    if (slash) url = url.Strip(TString::kTrailing,'/');
+    if (space) url = url.Strip(TString::kTrailing,' ');
+  }
+  //url.ToLower();
+  //
 }