* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
+/* $Id: AliReconstruction.cxx 63911 2013-08-19 16:46:41Z hristov $ */
///////////////////////////////////////////////////////////////////////////////
// //
//_____________________________________________________________________________
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"
+const char* AliReconstruction::fgkDetectorName[AliReconstruction::kNDetectors] = {"ITS", "TPC", "TRD", "TOF", "PHOS", "HMPID", "EMCAL", "MUON", "FMD", "ZDC", "PMD", "T0", "VZERO", "ACORDE","AD"
// #ifdef MFT_UPGRADE
// , "MFT"
// #endif
fWriteQAExpertData(kTRUE),
fRunPlaneEff(kFALSE),
+ fESDpid(NULL),
+
fesd(NULL),
fhltesd(NULL),
fesdf(NULL),
fSspecie(0),
fNhighPt(0),
fShighPt(0),
+ //
+ fTreeBuffSize(30000000),
+ fMemCountESD(0),
+ fMemCountESDF(0),
+ fMemCountESDHLT(0),
+ //
fUpgradeModule(""),
fAnalysisMacro(),
fAnalysis(0),
fWriteQAExpertData(rec.fWriteQAExpertData),
fRunPlaneEff(rec.fRunPlaneEff),
+ 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),
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;
}
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)) ;
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",
// 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;
}
Abort("ProcessEvent",TSelector::kAbortFile);
return kFALSE;
}
+ CleanProcessedEvent();
iEvent++;
}
if (!iEvent) AliWarning("No events passed trigger selection");
}
// Import ideal TGeo geometry and apply misalignment
- if (!gGeoManager) {
+ if (!AliGeomManager::GetGeometry()) {
TString geom(gSystem->DirName(fGAliceFileName));
geom += "/geometry.root";
AliGeomManager::LoadGeometry(geom.Data());
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");
return;
}
AliSysInfo::AddStamp("InitGRP");
- if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
+ if(!toCDBSnapshot)
+ if(cdbCache->Contains("GRP/Calib/CosmicTriggers"))
+ AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
if(!fCDBSnapshotMode || toCDBSnapshot){
if (!LoadCDB()) {
{
AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
- AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
+ if(cdbCache->Contains("GRP/Calib/CosmicTriggers"))
+ AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
}
if (fInput && gProof) {
// ESD layout template in CDB
AliCDBManager* man = AliCDBManager::Instance();
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
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)
AliCodeTimerAuto("",0);
- AliESDpid pid;
-
AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
if (iEvent >= fRunLoader->GetNumberOfEvents()) {
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) ;
// 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());
// barrel tracking
if (!fRunTracking.IsNull()) {
- if (!RunTracking(fesd,pid)) {
+ if (!RunTracking(fesd,*fESDpid)) {
if (fStopOnError) {CleanUp(); return kFALSE;}
}
}
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);
// AdC+FN
if (fReconstructor[3])
- GetReconstructor(3)->FillEventTimeWithTOF(fesd,&pid);
+ GetReconstructor(3)->FillEventTimeWithTOF(fesd,fESDpid);
// combined PID
- pid.MakePID(fesd);
+ // fESDpid->MakePID(fesd);
if (fFillTriggerESD) {
if (!FillTriggerESD(fesd)) {
}
//
- ftree->Fill();
+ 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) {
ftree->AutoSave("SaveSelf");
if (fWriteESDfriend) ftreeF->AutoSave("SaveSelf");
}
- // write HLT ESD
- fhlttree->Fill();
+ // 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;
+}
- // call AliEVE
- if (fRunAliEVE) RunAliEVE();
+void AliReconstruction::CleanProcessedEvent()
+{
//
fesd->Reset();
fhltesd->Reset();
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]) {
DeleteRecPoints(fDeleteRecPoints);
DeleteDigits(fDeleteDigits);
//
- return kTRUE;
+
}
//_____________________________________________________________________________
// 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 += getenv("PRODUCTION_METADATA");
// 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);
}
}
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);
}
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;
}
// 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());
fesdf->SetSkipBit(kTRUE);
}
//
- ftreeF->Fill();
+ 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()));
+ }
+
}
//_________________________________________________________________
}
return res;
}
+
+Bool_t AliReconstruction::HasNextEventAfter(Int_t eventId)
+{
+ return ( (eventId < fRunLoader->GetNumberOfEvents()) ||
+ (fRawReader && fRawReader->NextEvent()) );
+}