* provided "as is" without express or implied warranty. *
**************************************************************************/
-/* $Id$ */
+/* $Id: AliReconstruction.cxx 63911 2013-08-19 16:46:41Z hristov $ */
///////////////////////////////////////////////////////////////////////////////
// //
#include "AliLHCData.h"
#include "ARVersion.h"
#include <RVersion.h>
+#include <stdlib.h>
#include <unistd.h>
#include <sys/resource.h>
ClassImp(AliReconstruction)
//_____________________________________________________________________________
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"
-// #ifdef MFT_UPGRADE
-// , "MFT"
-// #endif
- , "MFT" // AU
- , "HLT"
-};
+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) :
fRunVertexFinder(kTRUE),
fRunVertexFinderTracks(kTRUE),
fRunMuonTracking(kFALSE),
+ fRunMFTTrackingMU(kFALSE),
fRunV0Finder(kTRUE),
fRunCascadeFinder(kTRUE),
fRunMultFinder(kTRUE),
fDmax(50.),
fZmax(50.),
+ fCosmicAlias("kCosmic"),
+ fLaserAlias("kCalibLaser"),
fRunLocalReconstruction("ALL"),
fRunTracking("ALL"),
fFillESD("ALL"),
fDiamondProfileSPD(NULL),
fDiamondProfile(NULL),
fDiamondProfileTPC(NULL),
- fListOfCosmicTriggers(NULL),
+ fListOfCosmicTriggers(NULL), //RS for BWD comp.
+ fAlias2Trigger(NULL),
fGRPData(NULL),
fCDBUri(),
fQARefUri(),
fSpecCDBUri(),
+ fCheckRecoCDBvsSimuCDB(),
fInitCDBCalled(kFALSE),
fCDBSnapshotMode(kFALSE),
fSetRunNumberFromDataCalled(kFALSE),
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),
fMaxVMEM(0)
{
// create reconstruction object with default parameters
- gGeoManager = NULL;
+ AliGeomManager::Destroy();
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
fReconstructor[iDet] = 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;
}
fRunVertexFinder(rec.fRunVertexFinder),
fRunVertexFinderTracks(rec.fRunVertexFinderTracks),
fRunMuonTracking(rec.fRunMuonTracking),
+ fRunMFTTrackingMU(rec.fRunMFTTrackingMU),
fRunV0Finder(rec.fRunV0Finder),
fRunCascadeFinder(rec.fRunCascadeFinder),
fRunMultFinder(rec.fRunMultFinder),
fDmax(rec.fDmax),
fZmax(rec.fZmax),
+ fCosmicAlias(rec.fCosmicAlias),
+ fLaserAlias(rec.fLaserAlias),
fRunLocalReconstruction(rec.fRunLocalReconstruction),
fRunTracking(rec.fRunTracking),
fFillESD(rec.fFillESD),
fDiamondProfileSPD(rec.fDiamondProfileSPD),
fDiamondProfile(rec.fDiamondProfile),
fDiamondProfileTPC(rec.fDiamondProfileTPC),
- fListOfCosmicTriggers(NULL),
+ fListOfCosmicTriggers(NULL), //RS for BWD comp.
+ fAlias2Trigger(NULL),
fGRPData(NULL),
fCDBUri(rec.fCDBUri),
fQARefUri(rec.fQARefUri),
fSpecCDBUri(),
+ fCheckRecoCDBvsSimuCDB(),
fInitCDBCalled(rec.fInitCDBCalled),
fCDBSnapshotMode(rec.fCDBSnapshotMode),
fSetRunNumberFromDataCalled(rec.fSetRunNumberFromDataCalled),
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),
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;
fRunMuonTracking = rec.fRunMuonTracking;
+ fRunMFTTrackingMU = rec.fRunMFTTrackingMU;
fRunV0Finder = rec.fRunV0Finder;
fRunCascadeFinder = rec.fRunCascadeFinder;
fRunMultFinder = rec.fRunMultFinder;
fDmax = rec.fDmax;
fZmax = rec.fZmax;
+ fCosmicAlias = rec.fCosmicAlias;
+ fLaserAlias = rec.fLaserAlias;
+
fRunLocalReconstruction = rec.fRunLocalReconstruction;
fRunTracking = rec.fRunTracking;
fFillESD = rec.fFillESD;
delete fListOfCosmicTriggers; fListOfCosmicTriggers = NULL;
if (rec.fListOfCosmicTriggers) fListOfCosmicTriggers = (THashTable*)((rec.fListOfCosmicTriggers)->Clone());
+ //
+ delete fAlias2Trigger; fAlias2Trigger = NULL;
+ if (rec.fAlias2Trigger) fAlias2Trigger = (THashList*)((rec.fAlias2Trigger)->Clone());
delete fGRPData; fGRPData = NULL;
// if (rec.fGRPData) fGRPData = (TMap*)((rec.fGRPData)->Clone());
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;
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;
fListOfCosmicTriggers->Delete();
delete fListOfCosmicTriggers;
}
+ if (fAlias2Trigger) {
+ fAlias2Trigger->Delete();
+ delete fAlias2Trigger;
+ }
delete fGRPData;
delete fRunScalers;
delete fCTPTimeParams;
delete fAlignObjArray;
}
fSpecCDBUri.Delete();
-
+ fCheckRecoCDBvsSimuCDB.Delete();
AliCodeTimer::Instance()->Print();
}
//_____________________________________________________________________________
void AliReconstruction::SetCDBSnapshotMode(const char* snapshotFileName) {
+ if (!AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName))
+ AliFatal("Setting CDB snapshot mode failed.");
fCDBSnapshotMode = kTRUE;
- AliCDBManager::Instance()->SetSnapshotMode(snapshotFileName);
}
//_____________________________________________________________________________
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()
{
AliError("No TPC diamond profile found in OCDB!");
}
- entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
- if (entry) {
- fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
- entry->SetOwner(0);
- }
-
- if (!fListOfCosmicTriggers) {
- AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will be effectively disabled!");
- }
-
return kTRUE;
}
// in the trigger or that are needed in order to put correct
// information in ESD
AliCDBManager::Instance()->GetAll("TRIGGER/*/*");
+ AliCDBManager::Instance()->GetAll("HLT/*/*");
+
+ AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/Calib/CosmicTriggers");
+ if (entry) {
+ fListOfCosmicTriggers = dynamic_cast<THashTable*>(entry->GetObject());
+ entry->SetOwner(0);
+ }
+ //
+ if (!fListOfCosmicTriggers) {
+ AliWarning("Can not get list of cosmic triggers from OCDB! Cosmic event specie will rely on aliases if defined");
+ }
+
return kTRUE;
}
Abort("ProcessEvent",TSelector::kAbortFile);
return kFALSE;
}
+ CleanProcessedEvent();
iEvent++;
}
if (!iEvent) AliWarning("No events passed trigger selection");
// Set CDB lock: from now on it is forbidden to reset the run number
// or the default storage or to activate any further storage!
SetCDBLock();
-
+ //
+ ProcessTriggerAliases();
+ //
}
//_____________________________________________________________________________
}
// Import ideal TGeo geometry and apply misalignment
- if (!gGeoManager) {
+ if (!AliGeomManager::GetGeometry()) {
TString geom(gSystem->DirName(fGAliceFileName));
geom += "/geometry.root";
AliGeomManager::LoadGeometry(geom.Data());
snapshotFileOut="OCDB.root";
}
- if (!MisalignGeometry(fLoadAlignData)) {
- Abort("MisalignGeometry", TSelector::kAbortProcess);
- return;
+ TString detStr(fLoadAlignData);
+ if (!toCDBSnapshot) {
+ if (!MisalignGeometry(fLoadAlignData)) {
+ Abort("MisalignGeometry", TSelector::kAbortProcess);
+ return;
+ }
+ } else {
+ // when creating the snapshot, load the CDB alignment objects without applying them to the geometry
+ for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
+ if (!IsSelected(fgkDetectorName[iDet], detStr)) continue;
+ if (!strcmp(fgkDetectorName[iDet],"HLT")) continue;
+ if (AliGeomManager::GetNalignable(fgkDetectorName[iDet]) != 0)
+ {
+ TString detAlignPath = fgkDetectorName[iDet];
+ detAlignPath += "/Align/Data";
+ AliCDBManager::Instance()->Get(detAlignPath);
+ }
+ } // end loop over detectors
+ if(AliGeomManager::GetNalignable("GRP") != 0)
+ AliCDBManager::Instance()->Get("GRP/Align/Data");
+ }
+
+ const TMap* cdbCache = AliCDBManager::Instance()->GetEntryCache();
+ if(!toCDBSnapshot) {
+ if(cdbCache->Contains("GRP/Geometry/Data"))
+ AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
+ AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
}
- AliCDBManager::Instance()->UnloadFromCache("GRP/Geometry/Data");
- if(!toCDBSnapshot) AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
AliSysInfo::AddStamp("MisalignGeom");
if (!InitGRP()) {
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()) {
if(toCDBSnapshot)
{
AliCDBManager::Instance()->DumpToSnapshotFile(snapshotFileOut.Data(),kFALSE);
- AliCDBManager::Instance()->UnloadFromCache("*/Align/*");
- AliCDBManager::Instance()->UnloadFromCache("GRP/Calib/CosmicTriggers");
+ exit(0);
}
if (fInput && gProof) {
}
AliSysInfo::AddStamp("LoadLoader");
+ CheckRecoCDBvsSimuCDB();
+
ftVertexer = new AliVertexerTracks(AliTracker::GetBz());
// get trackers
// 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)
AliRawVEvent *event = NULL;
currTree->SetBranchAddress("rawevent",&event);
currTree->GetEntry(entry);
- fRawReader = new AliRawReaderRoot(event);
+ fRawReader = new AliRawReaderRoot(event,entry);
// check if process has enough resources
if (!HasEnoughResources(entry)) return kFALSE;
fStatus = ProcessEvent(fRunLoader->GetNumberOfEvents());
fRawReader = NULL;
delete event;
+ if (!fStatus) Abort("ProcessEvent",TSelector::kAbortFile);
+ CleanProcessedEvent();
return fStatus;
}
AliCodeTimerAuto("",0);
- AliESDpid pid;
-
AliSysInfo::AddStamp(Form("StartEv_%d",iEvent), 0,0,iEvent);
if (iEvent >= fRunLoader->GetNumberOfEvents()) {
oldCPU=procInfo.fCpuUser+procInfo.fCpuSys;
}
AliInfo(Form("================================= Processing event %d of type %-10s ==================================", iEvent,fRecoParam.PrintEventSpecie()));
+ fEventInfo.Print();
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) ;
// 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());
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;}
}
}
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()));
+ }
+
+ 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;
+
+
+ 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;
-
- fEventInfo.Reset();
+ AliInfo("======================= End Event ===================");
+
+
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
if (fReconstructor[iDet]) {
fReconstructor[iDet]->SetRecoParam(NULL);
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");
}
+//_____________________________________________________________________________
+Bool_t AliReconstruction::RunMFTTrackingMU(AliESDEvent*& esd) {
+
+ // AU
+
+ // run the global muon tracking: matching the MUON tracks with the MFT clusters
+
+ AliCodeTimerAuto("",0)
+
+ if (!fRunLoader) {
+ AliError("Missing runLoader!");
+ return kFALSE;
+ }
+ Int_t iDet = GetDetIndex("MFT"); // for MFT
+
+ // Get a pointer to the MFT reconstructor
+ AliReconstructor *reconstructor = GetReconstructor(iDet);
+ if (!reconstructor) return kFALSE;
+
+ TString detName = fgkDetectorName[iDet];
+ AliDebug(1, Form("%s tracking for muon tracks", detName.Data()));
+ AliTracker *tracker = reconstructor->CreateTracker();
+ if (!tracker) {
+ AliWarning(Form("couldn't create a Muon 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::RunTracking(AliESDEvent*& esd,AliESDpid &PID)
{
// 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);
}
if (esd->GetTriggerMask() != input.GetClassMask())
AliError(Form("Invalid trigger pattern found in CTP raw-data: %llx %llx",
input.GetClassMask(),esd->GetTriggerMask()));
+ if (esd->GetTriggerMaskNext50() != input.GetClassMaskNext50())
+ AliError(Form("Invalid trigger pattern found in CTP raw-data Next50: %llx %llx",
+ input.GetClassMaskNext50(),esd->GetTriggerMaskNext50()));
if (esd->GetOrbitNumber() != input.GetOrbitID())
AliError(Form("Invalid orbit id found in CTP raw-data: %x %x",
input.GetOrbitID(),esd->GetOrbitNumber()));
if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
}
}
+ for(Int_t i=0;i<50;i++){
+ if((1ull<<i) & esd->GetTriggerMaskNext50()){
+ AliTriggerScalersESD* scalesd = fRunScalers->GetScalersForEventClass( timestamp, i+51);
+ if(scalesd)esdheader->SetTriggerScalersRecord(scalesd);
+ }
+ }
const AliTriggerScalersRecordESD* scalrecEvent = fRunScalers->GetScalersDeltaForEvent( timestamp);
const AliTriggerScalersRecordESD* scalrecRun = fRunScalers->GetScalersDeltaForRun();
if (scalrecEvent) esdheader->SetTriggerScalersDeltaEvent(scalrecEvent);
for (Int_t iDet = 0; iDet < kNDetectors; iDet++) {
TString detName = fgkDetectorName[iDet];
if (libs.Contains("lib" + detName + "base.so")) continue;
- gSystem->Load("lib" + detName + "base.so");
+ gSystem->Load("lib" + detName + "base");
}
fRunLoader = AliRunLoader::Open(fGAliceFileName.Data());
if (!fRunLoader) {
AliDebug(1, Form("defining plugin for %s", recName.Data()));
TString libs = gSystem->GetLibraries();
if (libs.Contains("lib" + detName + "base.so") ||
- (gSystem->Load("lib" + detName + "base.so") >= 0)) {
+ (gSystem->Load("lib" + detName + "base") >= 0)) {
pluginManager->AddHandler("AliReconstructor", detName,
recName, detName + "rec", recName + "()");
} else {
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++) {
+ if (fReconstructor[iDet]) fReconstructor[iDet]->SetRecoParam(NULL);
delete fReconstructor[iDet];
fReconstructor[iDet] = NULL;
fLoader[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;
// Fill the event info object
// ...
AliCodeTimerAuto("",0)
-
+
AliCentralTrigger *aCTP = NULL;
+ fEventInfo.Reset();
if (fRawReader) {
fEventInfo.SetEventType(fRawReader->GetType());
ULong64_t mask = fRawReader->GetClassMask();
+ ULong64_t maskNext50 = fRawReader->GetClassMaskNext50();
fEventInfo.SetTriggerMask(mask);
+ fEventInfo.SetTriggerMaskNext50(maskNext50);
UInt_t clmask = fRawReader->GetDetectorPattern()[0];
fEventInfo.SetTriggerCluster(AliDAQ::ListOfTriggeredDetectors(clmask));
if (fRunLoader && (!fRunLoader->LoadTrigger())) {
aCTP = fRunLoader->GetTrigger();
fEventInfo.SetTriggerMask(aCTP->GetClassMask());
+ fEventInfo.SetTriggerMaskNext50(aCTP->GetClassMaskNext50());
// get inputs from actp - just get
AliESDHeader* esdheader = fesd->GetHeader();
esdheader->SetL0TriggerInputs(aCTP->GetL0TriggerInputs());
if (fRawReader) delete aCTP;
return kFALSE;
}
-
- // Load trigger aliases and declare the trigger classes included in aliases
- 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();
+ ULong64_t trmaskNext50 = fEventInfo.GetTriggerMaskNext50();
const TObjArray& classesArray = config->GetClasses();
Int_t nclasses = classesArray.GetEntriesFast();
for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
if (trclass && trclass->GetMask()>0) {
Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
if (fesd) fesd->SetTriggerClass(trclass->GetName(),trindex);
- if (fRawReader) fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
if (trmask & (1ull << trindex)) {
trclasses += " ";
trclasses += trclass->GetName();
trclasses += " ";
clustmask |= trclass->GetCluster()->GetClusterMask();
+ if (TriggerMatches2Alias(trclass->GetName(),fCosmicAlias)) fEventInfo.SetCosmicTrigger(kTRUE);
+ else if (TriggerMatches2Alias(trclass->GetName(),fLaserAlias)) fEventInfo.SetCalibLaserTrigger(kTRUE);
+ else fEventInfo.SetBeamTrigger(kTRUE);
}
}
- }
- 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);
+ if (trclass && trclass->GetMaskNext50()>0) {
+ Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMaskNext50()))+50;
+ if (fesd) fesd->SetTriggerClass(trclass->GetName(),trindex);
+ if (trmaskNext50 & (1ull << (trindex-50))) {
+ trclasses += " ";
+ trclasses += trclass->GetName();
+ trclasses += " ";
+ clustmask |= trclass->GetCluster()->GetClusterMask();
+ if (TriggerMatches2Alias(trclass->GetName(),fCosmicAlias)) fEventInfo.SetCosmicTrigger(kTRUE);
+ else if (TriggerMatches2Alias(trclass->GetName(),fLaserAlias)) fEventInfo.SetCalibLaserTrigger(kTRUE);
+ else fEventInfo.SetBeamTrigger(kTRUE);
+ }
}
- delete tokens;
}
+ fEventInfo.SetTriggerClasses(trclasses);
// Write names of active trigger inputs in ESD Header
const TObjArray& inputsArray = config->GetInputs();
// Set the information in ESD
if (fesd) {
fesd->SetTriggerMask(trmask);
+ fesd->SetTriggerMaskNext50(trmaskNext50);
fesd->SetTriggerCluster(clustmask);
}
// We have to fill also the HLT decision here!!
// ...
+ // check if event has cosmic or laser alias
+
return kTRUE;
}
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()) );
+}
+
+//_________________________________________________________________
+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();
+ //
+}
+
+//_________________________________________________________
+void AliReconstruction::ProcessTriggerAliases()
+{
+ // load trigger aliases, attach them to the reader
+ //
+ fDeclTriggerClasses.Clear();
+ AliCentralTrigger *aCTP = NULL;
+ if (fRawReader) {
+ aCTP = new AliCentralTrigger();
+ TString configstr("");
+ if (!aCTP->LoadConfiguration(configstr)) { // Load CTP config from OCDB
+ AliError("No trigger configuration found in OCDB! The trigger configuration information will not be used!");
+ delete aCTP;
+ return;
+ }
+ }
+ else if (fRunLoader && (!fRunLoader->LoadTrigger())) {
+ aCTP = fRunLoader->GetTrigger();
+ }
+ 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;
+ }
+ //
+ AliTriggerConfiguration *config = aCTP->GetConfiguration();
+ if (!config) {
+ AliError("No trigger configuration has been found! The trigger configuration information will not be used!");
+ if (fRawReader) delete aCTP;
+ return;
+ }
+ //
+ // here we have list of active triggers
+ const TObjArray& classesArray = config->GetClasses();
+ Int_t nclasses = classesArray.GetEntriesFast();
+ //
+ fAlias2Trigger = new THashList();
+ //
+ 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()))) { // account aliases of this trigger >>
+ fDeclTriggerClasses += " ";
+ fDeclTriggerClasses += nmd->GetName();
+ //
+ if (!classesArray.FindObject(nmd->GetName())) continue;
+ TString aliasList(nmd->GetTitle());
+ TObjArray* arrAliases = aliasList.Tokenize(',');
+ Int_t nAliases = arrAliases->GetEntries();
+ // Loop on aliases for the current trigger
+ for(Int_t i=0; i<nAliases; i++){
+ TObjString *alias = (TObjString*) arrAliases->At(i);
+ // Find the current alias in the hash list. If it is not there, add TNamed entry
+ TNamed * inlist = (TNamed*)fAlias2Trigger->FindObject((alias->GetString()).Data());
+ if (!inlist) {
+ inlist = new TNamed((alias->GetString()).Data(),Form(" %s ",nmd->GetName()));
+ fAlias2Trigger->Add(inlist);
+ }
+ else {
+ TString tt(inlist->GetTitle());
+ tt += "||";
+ tt += Form(" %s ",nmd->GetName());
+ inlist->SetTitle(tt.Data());
+ }
+ }
+ delete arrAliases;
+ } // account aliases of this trigger <<
+ }
+ else AliError("Cannot cast the object with trigger aliases to THashList!");
+ }
+ else AliError("No OCDB ebtry for the trigger aliases!");
+ //
+ AliInfo("Aliases defined:");
+ fAlias2Trigger->Print();
+ //
+ if (fRawReader) {
+ // active classes mentioned in the alias will be converted to their masks
+ for( Int_t iclass=0; iclass < nclasses; iclass++ ) {
+ AliTriggerClass* trclass = (AliTriggerClass*)classesArray.At(iclass);
+ if (trclass && trclass->GetMask()>0) {
+ Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMask()));
+ fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
+ }
+ if (trclass && trclass->GetMaskNext50()>0) {
+ Int_t trindex = TMath::Nint(TMath::Log2(trclass->GetMaskNext50()))+50;
+ fRawReader->LoadTriggerClass(trclass->GetName(),trindex);
+ }
+ }
+ //
+ // nullify all remaining triggers mentioned in the alias
+ if (!fDeclTriggerClasses.IsNull()) {
+ TObjArray *tokens = fDeclTriggerClasses.Tokenize(" ");
+ Int_t ntokens = tokens->GetEntriesFast();
+ for (Int_t itoken = 0; itoken < ntokens; ++itoken) {
+ fRawReader->LoadTriggerClass((((TObjString*)tokens->At(itoken))->String()).Data(),-1);
+ }
+ delete tokens;
+ }
+ }
+ //
+}
+
+//___________________________________________________
+Bool_t AliReconstruction::TriggerMatches2Alias(const char* trigName, const char* alias)
+{
+ // check if trigger matches to alias
+ TString trName = trigName;
+ if (!fAlias2Trigger) return kFALSE;
+ TNamed* al = (TNamed*)fAlias2Trigger->FindObject(alias);
+ if (!al) return kFALSE;
+ TString altrig = al->GetTitle();
+ return altrig.Contains(Form(" %s ",trigName));
+ //
+}