* 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 "AliESDHLTDecision.h"
#include "AliTriggerInput.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),
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
+ fDeleteRecPoints(""),
+ fDeleteDigits(""),
fLoadCDB(""),
fUseTrackingErrorsForAlignment(""),
fGAliceFileName(gAliceFilename),
fCDBUri(),
fQARefUri(),
fSpecCDBUri(),
+ fCheckRecoCDBvsSimuCDB(),
fInitCDBCalled(kFALSE),
+ fCDBSnapshotMode(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
fQADetectors("ALL"),
fQATasks("ALL"),
fWriteQAExpertData(kTRUE),
fRunPlaneEff(kFALSE),
+ fESDpid(NULL),
+
fesd(NULL),
fhltesd(NULL),
fesdf(NULL),
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;
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;
}
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),
fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
+ fDeleteRecPoints(""),
+ fDeleteDigits(""),
fLoadCDB(rec.fLoadCDB),
fUseTrackingErrorsForAlignment(rec.fUseTrackingErrorsForAlignment),
fGAliceFileName(rec.fGAliceFileName),
fCDBUri(rec.fCDBUri),
fQARefUri(rec.fQARefUri),
fSpecCDBUri(),
+ fCheckRecoCDBvsSimuCDB(),
fInitCDBCalled(rec.fInitCDBCalled),
+ fCDBSnapshotMode(rec.fCDBSnapshotMode),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
fQADetectors(rec.fQADetectors),
fQATasks(rec.fQATasks),
fWriteQAExpertData(rec.fWriteQAExpertData),
fRunPlaneEff(rec.fRunPlaneEff),
+ fESDpid(NULL),
+
fesd(NULL),
fhltesd(NULL),
fesdf(NULL),
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
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];
}
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;
fRunLocalReconstruction = rec.fRunLocalReconstruction;
fRunTracking = rec.fRunTracking;
fFillESD = rec.fFillESD;
+ fDeleteRecPoints = rec.fDeleteRecPoints;
+ fDeleteDigits = rec.fDeleteDigits;
fLoadCDB = rec.fLoadCDB;
fUseTrackingErrorsForAlignment = rec.fUseTrackingErrorsForAlignment;
fGAliceFileName = rec.fGAliceFileName;
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;
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;
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;
}
delete fAlignObjArray;
}
fSpecCDBUri.Delete();
-
+ fCheckRecoCDBvsSimuCDB.Delete();
AliCodeTimer::Instance()->Print();
}
AliQAManager * qam = AliQAManager::QAManager(AliQAv1::kRECMODE) ;
+ qam->SetSaveData(kTRUE);
+ qam->SetCycleLength(AliQAv1::kITS, 5) ;
if (fWriteQAExpertData)
qam->SetWriteExpert() ;
}
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)) ;
AliSysInfo::AddStamp("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
AliQAv1::SetQARefStorage(fQARefUri.Data()) ;
}
+
//_____________________________________________________________________________
void AliReconstruction::SetSpecificStorage(const char* calibType, const char* uri) {
// Store a detector-specific CDB storage location
}
+//_____________________________________________________________________________
+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()
{
AliWarning("Run number is taken from raw-event header! Ignoring settings in AliCDBManager!");
}
man->SetRun(fRawReader->GetRunNumber());
+ GetEventInfo();
fRawReader->RewindEvents();
}
else {
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
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();
// 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(),
if (entry) {
fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
entry->SetOwner(0);
- AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
}
if (!fListOfCosmicTriggers) {
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
// 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;
}
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();
}
// Import ideal TGeo geometry and apply misalignment
- if (!gGeoManager) {
+ if (!AliGeomManager::GetGeometry()) {
TString geom(gSystem->DirName(fGAliceFileName));
geom += "/geometry.root";
AliGeomManager::LoadGeometry(geom.Data());
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()) {
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);
}
AliSysInfo::AddStamp("InitRecoParams");
+ if(toCDBSnapshot)
+ {
+ AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
+ exit(0);
+ }
+
if (fInput && gProof) {
if (reco) *reco = *this;
AliMagF *magFieldMap = (AliMagF*)TGeoGlobalMagField::Instance()->GetField();
magFieldMap->SetName("MagneticFieldMap");
gProof->AddInputData(magFieldMap,kTRUE);
+ if (fAnalysis) {
+ fAnalysis->SetName("Analysis");
+ gProof->AddInputData(fAnalysis,kTRUE);
+ }
}
}
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"))
}
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);
}
AliSysInfo::AddStamp("LoadLoader");
+ CheckRecoCDBvsSimuCDB();
+
ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
// get trackers
// 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);
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)
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;
}
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;
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);
}
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;
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) ;
AliQAManager::QAManager()->SetRecoParam(iDet, par) ;
if (par) AliQAManager::QAManager()->SetEventSpecie(AliRecoParam::Convert(par->GetEventSpecie())) ;
}
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());
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
// 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
if (!RunSPDTrackleting(fesd)) {
if (fStopOnError) {CleanUp(); return kFALSE;}
}
+ AliSysInfo::AddStamp(Form("TrackletEff_%d",iEvent), 0,0,iEvent);
}
// Muon tracking
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;}
}
}
// 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();
//
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
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();
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
//
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){
}
delete pvtx; pvtx=NULL;
}
+ AliSysInfo::AddStamp(Form("VtxTrk_%d",iEvent), 0,0,iEvent);
// TPC-only primary vertex
ftVertexer->SetTPCMode();
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
}
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);
// 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
// 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
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);
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
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]) {
if (fRunQA || fRunGlobalQA)
AliQAManager::QAManager()->Increment() ;
-
- return kTRUE;
+
+ DeleteRecPoints(fDeleteRecPoints);
+ DeleteDigits(fDeleteDigits);
+ //
+
}
//_____________________________________________________________________________
// 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");
ftree->GetUserInfo()->Add(cdbMapCopy);
ftree->GetUserInfo()->Add(cdbListCopy);
+ // Add the AliRoot version that created this file
+ TString sVersion("aliroot ");
+ sVersion += ALIROOT_BRANCH;
+ sVersion += ":";
+ 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 += getenv("PRODUCTION_METADATA");
+
+
+ TNamed * alirootVersion = new TNamed("alirootVersion",sVersion.Data());
+ ftree->GetUserInfo()->Add(alirootVersion); // The list becomes owner of alirootVersion
ffile->cd();
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) {
// 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];
// 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()) ;
Double_t vtxPos[3] = {0, 0, 0};
Double_t vtxErr[3] = {0.0, 0.0, 0.0};
/*
- TArrayF mcVertex(3);
+ TArrayF m
+/
+cVertex(3);
// if(MC)
if (fRunLoader->GetHeader() && fRunLoader->GetHeader()->GenEventHeader()) {
fRunLoader->GetHeader()->GenEventHeader()->PrimaryVertex(mcVertex);
}
//_____________________________________________________________________________
-Bool_t AliReconstruction::RunHLTTracking(AliESDEvent*& esd)
+Bool_t AliReconstruction::RunMuonTracking(AliESDEvent*& esd)
{
-// run the HLT barrel tracking
+// run the muon spectrometer tracking
AliCodeTimerAuto("",0)
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)
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;
}
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)
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
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
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);
// 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
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();
}
if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
}
}
+ const AliTriggerScalersRecordESD* scalrecEvent = fRunScalers->GetScalersDeltaForEvent( timestamp);
+ const AliTriggerScalersRecordESD* scalrecRun = fRunScalers->GetScalersDeltaForRun();
+ if (scalrecEvent) esdheader->SetTriggerScalersDeltaEvent(scalrecEvent);
+ if (scalrecRun) esdheader->SetTriggerScalersDeltaRun(scalrecRun);
}
return kTRUE;
}
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");
}
TObject* obj = fOptions.FindObject(detName.Data());
if (obj) reconstructor->SetOption(obj->GetTitle());
reconstructor->SetRunInfo(fRunInfo);
+ reconstructor->SetHLTESD(fhltesd);
reconstructor->Init();
fReconstructor[iDet] = reconstructor;
}
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)) {
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;
delete fTracker[iDet];
fTracker[iDet] = NULL;
}
-*/
delete fRunInfo;
fRunInfo = NULL;
delete fParentRawReader;
fParentRawReader=NULL;
+ delete fESDpid;
+ fESDpid = NULL;
+
if (ffile) {
ffile->Close();
delete ffile;
if (AliQAManager::QAManager())
AliQAManager::QAManager()->ShowQA() ;
- // AliQAManager::Destroy() ;
-
+ // AliQAManager::Destroy() ;
+ delete fAnalysis;
+ fAnalysis = NULL;
}
void AliReconstruction::WriteAlignmentData(AliESDEvent* esd)
// 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"));
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);
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;
}
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();
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 += " ";
}
}
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();
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;
else if (fAbort == kAbortFile)
mess = "AbortFile";
- Info(mess, whyMess.Data());
+ Info(mess.Data(), "%s", whyMess.Data());
}
//______________________________________________________________________________
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;
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();
+ //
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff