Bool_t AliEveEventManager::fgAssertRaw = kFALSE;
TString AliEveEventManager::fgESDFileName("AliESDs.root");
+AliEveEventManager::EVisibleESDTrees AliEveEventManager::fgESDvisibleTrees(AliEveEventManager::kOfflineTree);
TString AliEveEventManager::fgESDfriendsFileName("AliESDfriends.root");
TString AliEveEventManager::fgAODFileName("AliAOD.root");
TString AliEveEventManager::fgGAliceFileName("galice.root");
fEventId(-1),
fRunLoader (0),
- fESDFile (0), fESDTree (0), fESD (0),
+ fESDFile (0), fESDTree (0), fHLTESDTree(0), fESD (0),
fESDfriend (0), fESDfriendExists(kFALSE),
fAODFile (0), fAODTree (0), fAOD (0),
fRawReader (0), fEventInfo(),
/******************************************************************************/
-void AliEveEventManager::SetESDFileName(const TString& esd)
+void AliEveEventManager::SetESDFileName(const TString& esd, EVisibleESDTrees shown)
{
+ fgESDvisibleTrees = shown;
// Set file-name for opening ESD, default "AliESDs.root".
if (esd.IsNull()) return;
-
+
fgESDFileName = esd;
if (esd.EndsWith(".zip")) fgESDFileName.Form("%s#AliESDs.root",esd.Data());
-
+
}
void AliEveEventManager::SetESDfriendFileName(const TString& esdf)
// Set file-name for opening gAlice, default "galice.root".
if ( galice.IsNull()) return;
- fgGAliceFileName = galice;
+ fgGAliceFileName = galice;
if (galice.EndsWith(".zip")) fgGAliceFileName.Form("%s#galice.root",galice.Data());
}
void AliEveEventManager::SetFilesPath(const TString& urlPath)
{
- TString path = urlPath;
+ TString path = urlPath;
gSystem->ExpandPathName(path);
if (path.IsNull() || path == ".")
{
path = gSystem->WorkingDirectory();
}
-
- TString sep;
- if(path.EndsWith(".zip")) // if given a path to root_archive.zip
- sep= "#";
- else if(!path.EndsWith("/"))
- sep = "/";
+
+ TString sep;
+ if(path.EndsWith(".zip")) // if given a path to root_archive.zip
+ sep= "#";
+ else if(!path.EndsWith("/"))
+ sep = "/";
SetESDFileName( TString(Form("%s%sAliESDs.root", path.Data(), sep.Data())) );
SetESDfriendFileName( TString(Form("%s%sAliESDfriends.root", path.Data(), sep.Data())) );
if ((fESDFile = TFile::Open(fgESDFileName)))
{
fESD = new AliESDEvent();
- fESDTree = (TTree*) fESDFile->Get("esdTree");
- if (fESDTree != 0)
- {
- // Check if ESDfriends exists and attach the branch.
- // We use TFile::Open() instead of gSystem->AccessPathName
- // as it seems to work better when attachine alieve to a
- // running reconstruction process with auto-save on.
- TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
- if (esdFriendFile)
- {
- if (!esdFriendFile->IsZombie())
- {
- esdFriendFile->Close();
- fESDfriendExists = kTRUE;
- fESDTree->SetBranchStatus ("ESDfriend*", 1);
- }
- delete esdFriendFile;
- }
- fESD->ReadFromTree(fESDTree);
- if (fESDfriendExists)
- {
- fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
- Info(kEH, "found and attached ESD friend.");
- }
- else
- {
- Warning(kEH, "ESDfriend not found.");
- }
-
- if (fESDTree->GetEntry(0) <= 0)
- {
- delete fESDFile; fESDFile = 0;
- delete fESD; fESD = 0;
- Warning(kEH, "failed getting the first entry from esdTree.");
- }
- else
- {
- if (runNo < 0)
- runNo = fESD->GetESDRun()->GetRunNumber();
- }
+ switch(fgESDvisibleTrees){
+ case AliEveEventManager::kOfflineTree :
+ fESDTree = readESDTree("esdTree", runNo);
+ break;
+ case AliEveEventManager::kHLTTree :
+ fHLTESDTree = readESDTree("HLTesdTree", runNo);
+ break;
+ default:
+ fESDTree = readESDTree("esdTree", runNo);
+ fHLTESDTree = readESDTree("HLTesdTree", runNo);
}
- else // esdtree == 0
- {
+
+ if(!fESDTree && !fHLTESDTree){
+ // both ESD trees are == 0
delete fESDFile; fESDFile = 0;
delete fESD; fESD = 0;
- Warning(kEH, "failed getting the esdTree.");
}
+
+
}
- else // esd not readable
+ else // esd file not readable
{
Warning(kEH, "can not read ESD file '%s'.", fgESDFileName.Data());
}
- if (fESDTree == 0)
+ if (fESDTree == 0 && fHLTESDTree==0)
{
if (fgAssertESD)
{
return -1;
}
- if (fESDTree)
+ if ((fESDTree!=0) || (fHLTESDTree!=0))
{
if (refreshESD)
{
- fESDTree->Refresh();
+ if(fESDTree) fESDTree->Refresh();
+ if(fHLTESDTree) fHLTESDTree->Refresh();
fPEventSelector->Update();
}
- return fESDTree->GetEntries() - 1;
+
+ Int_t maxEventId=0;
+ switch(fgESDvisibleTrees){
+ default:
+ case AliEveEventManager::kOfflineTree :
+ maxEventId = fESDTree->GetEntries() - 1;
+ break;
+ case AliEveEventManager::kHLTTree :
+ maxEventId = fHLTESDTree->GetEntries() - 1;
+ break;
+ }
+
+ return maxEventId;
}
else if (fAODTree)
{
fHasEvent = kFALSE;
Int_t maxEvent = 0;
- if (fESDTree)
+ if ((fESDTree!=0) || (fHLTESDTree!=0))
{
- if (event >= fESDTree->GetEntries())
- fESDTree->Refresh();
- maxEvent = fESDTree->GetEntries() - 1;
- if (event < 0)
- event = fESDTree->GetEntries() + event;
+ if(fESDTree){
+ if (event >= fESDTree->GetEntries())
+ fESDTree->Refresh();
+ maxEvent = fESDTree->GetEntries() - 1;
+ if (event < 0)
+ event = fESDTree->GetEntries() + event;
+ }
+
+ if(fHLTESDTree){
+ if (event >= fHLTESDTree->GetEntries())
+ fHLTESDTree->Refresh();
+ maxEvent = fHLTESDTree->GetEntries() - 1;
+ if (event < 0)
+ event = fHLTESDTree->GetEntries() + event;
+
+ }
}
else if (fAODTree)
{
fESD->SetESDfriend(fESDfriend);
}
+ if (fHLTESDTree) {
+ if (fHLTESDTree->GetEntry(event) <= 0)
+ throw (kEH + "failed getting required event from HLT ESD.");
+
+ if (fESDfriendExists)
+ fESD->SetESDfriend(fESDfriend);
+ }
+
if (fAODTree) {
if (fAODTree->GetEntry(event) <= 0)
throw (kEH + "failed getting required event from AOD.");
gSystem->ExitLoop();
}
- else if (fESDTree)
+ else if ((fESDTree!=0) || (fHLTESDTree!=0))
{
Int_t nextevent=0;
if (fPEventSelector->FindNext(nextevent))
throw (kEH + "Event-loop is under external control.");
}
- if (fESDTree)
+ if ((fESDTree!=0) || (fHLTESDTree!=0))
{
Int_t nextevent=0;
if (fPEventSelector->FindPrev(nextevent))
if (fAutoLoadTimerRunning)
StopAutoLoadTimer();
- if (fESDTree) {
+ if ((fESDTree!=0) || (fHLTESDTree!=0)) {
delete fESD; fESD = 0;
// delete fESDfriend; // friend tree is deleted with the tree
fESDfriend = 0;
fESDfriendExists = kFALSE;
- delete fESDTree; fESDTree = 0;
+ if(fESDTree) { delete fESDTree; fESDTree = 0; }
+ if(fHLTESDTree) { delete fHLTESDTree; fHLTESDTree = 0; }
delete fESDFile; fESDFile = 0;
}
fgRecoParam = new AliRecoParam;
const Int_t kNDetectors = 14;
- static const TEveException kEH("AliEveEventManager::InitRecoParam ");
+ static const TEveException kEH("AliEveEventManager::InitRecoParam");
Bool_t isOK = kTRUE;
return isOK;
}
+TTree *AliEveEventManager::readESDTree(const char *treeName, int &runNo)
+{
+ if(!fESDFile && !fESD) return 0;
+
+ static const TEveException kEH("AliEveEventManager::readESDTree ");
+
+ TTree* tempTree = 0;
+
+ tempTree =(TTree*) fESDFile->Get(treeName);
+ if (tempTree != 0)
+ {
+ TFile *esdFriendFile = TFile::Open(fgESDfriendsFileName);
+ if (esdFriendFile)
+ {
+ if (!esdFriendFile->IsZombie())
+ {
+ esdFriendFile->Close();
+ fESDfriendExists = kTRUE;
+ tempTree->SetBranchStatus ("ESDfriend*", 1);
+ }
+ delete esdFriendFile;
+ }
+
+ fESD->ReadFromTree(tempTree);
+ if (fESDfriendExists)
+ {
+ fESDfriend = (AliESDfriend*) fESD->FindListObject("AliESDfriend");
+ Info(kEH, "found and attached ESD friend.");
+ }
+ else
+ {
+ Warning(kEH, "ESDfriend not found.");
+ }
+
+ if (tempTree->GetEntry(0) <= 0)
+ {
+ Warning(kEH, "failed getting the first entry from tree: %s", treeName);
+ }
+ else
+ {
+ if (runNo < 0)
+ runNo = fESD->GetESDRun()->GetRunNumber();
+ }
+ }
+ else // tree == 0
+ {
+ Warning(kEH, "failed getting the tree:%s", treeName);
+ }
+
+ return tempTree;
+}
+
//------------------------------------------------------------------------------
class AliEveEventManager : public TEveEventManager,
- public TQObject
+ public TQObject
{
public:
- static void SetESDFileName(const TString& esd);
- static void SetESDfriendFileName(const TString& esdf);
- static void SetAODFileName(const TString& aod);
- static void AddAODfriend (const TString& friendFileName);
- static void SetRawFileName(const TString& raw);
- static void SetCdbUri (const TString& cdb);
- static void SetGAliceFileName(const TString& galice);
-
- // set Local Directory or URL where the files are located
- // it can also be a path to root_archive.zip
- // assumes the filenames of ESD, AOD, etc are standard ALICE names
- // (AliESDs.root, AliESDfriends.root, AliAOD.root, AliAODfriend.root, galice.root,raw.root)
- static void SetFilesPath(const TString& path);
-
- static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
- Bool_t assertAod, Bool_t assertRaw);
- static void SearchRawForCentralReconstruction();
-
- AliEveEventManager(const TString& name="Event", Int_t ev=0);
- virtual ~AliEveEventManager();
-
- virtual void Open();
- void SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf);
- virtual Int_t GetMaxEventId(Bool_t refreshESD=kFALSE) const;
- virtual void GotoEvent(Int_t event);
- virtual void NextEvent();
- virtual void PrevEvent();
- virtual void Close();
- void Timeout(); // * SIGNAL*
-
- Int_t GetEventId() const { return fEventId; }
- AliRunLoader* GetRunLoader() const { return fRunLoader; }
- TFile* GetESDFile() const { return fESDFile; }
- TTree* GetESDTree() const { return fESDTree; }
- AliESDEvent* GetESD() const { return fESD; }
- AliESDfriend* GetESDfriend() const { return fESDfriend; }
- Bool_t GetESDfriendExists() const { return fESDfriendExists; }
- TFile* GetAODFile() const { return fAODFile; }
- TTree* GetAODTree() const { return fAODTree; }
- AliAODEvent* GetAOD() const { return fAOD; }
- AliEveEventSelector* GetEventSelector() const { return fPEventSelector; }
- TString GetEventInfoHorizontal() const;
- TString GetEventInfoVertical() const;
- const AliEventInfo* GetEventInfo();
-
- static Int_t CurrentEventId();
-
- static Bool_t HasRunLoader();
- static Bool_t HasESD();
- static Bool_t HasESDfriend();
- static Bool_t HasAOD();
- static Bool_t HasRawReader();
-
- static AliRunLoader* AssertRunLoader();
- static AliESDEvent* AssertESD();
- static AliESDfriend* AssertESDfriend();
- static AliAODEvent* AssertAOD();
- static AliRawReader* AssertRawReader();
-
- static AliMagF* AssertMagField();
- static TGeoManager* AssertGeometry();
- static AliRecoParam* AssertRecoParams();
-
- static AliEveEventManager* AddDependentManager(const TString& name, const TString& path);
- static AliEveEventManager* GetDependentManager(const TString& name);
-
- static AliEveEventManager* GetMaster();
- static AliEveEventManager* GetCurrent();
-
- static void RegisterTransient (TEveElement* element);
- static void RegisterTransientList(TEveElement* element);
-
-
- Double_t GetAutoLoadTime() const { return fAutoLoadTime; }
- Bool_t GetAutoLoad() const { return fAutoLoad; }
- void SetAutoLoadTime(Float_t time);
- void SetAutoLoad(Bool_t autoLoad);
- void SetTrigSel(Int_t trig);
- void AutoLoadNextEvent();
-
- Bool_t AreEventFilesOpened() const { return fIsOpen; }
- Bool_t IsEventAvailable() const { return fHasEvent; }
- Bool_t IsUnderExternalControl() const { return fExternalCtrl; }
-
- Bool_t InsertGlobal(const TString& tag, TEveElement* model);
- Bool_t InsertGlobal(const TString& tag, TEveElement* model,
- Bool_t replace, Bool_t update);
- TEveElement* FindGlobal(const TString& tag);
-
- virtual void AfterNewEventLoaded();
- void NewEventDataLoaded(); // *SIGNAL*
- void NewEventLoaded(); // *SIGNAL*
-
- AliEveMacroExecutor* GetExecutor() const { return fExecutor; }
+ enum EVisibleESDTrees{ kOfflineTree, kHLTTree };
+
+ static void SetESDFileName(const TString& esd, EVisibleESDTrees shown=kOfflineTree);
+ static void SetESDfriendFileName(const TString& esdf);
+ static void SetAODFileName(const TString& aod);
+ static void AddAODfriend (const TString& friendFileName);
+ static void SetRawFileName(const TString& raw);
+ static void SetCdbUri (const TString& cdb);
+ static void SetGAliceFileName(const TString& galice);
+
+ // set Local Directory or URL where the files are located
+ // it can also be a path to root_archive.zip
+ // assumes the filenames of ESD, AOD, etc are standard ALICE names
+ // (AliESDs.root, AliESDfriends.root, AliAOD.root, AliAODfriend.root, galice.root,raw.root)
+ static void SetFilesPath(const TString& path);
+
+ static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
+ Bool_t assertAod, Bool_t assertRaw);
+ static void SearchRawForCentralReconstruction();
+
+ AliEveEventManager(const TString& name="Event", Int_t ev=0);
+ virtual ~AliEveEventManager();
+
+ virtual void Open();
+ void SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf);
+ virtual Int_t GetMaxEventId(Bool_t refreshESD=kFALSE) const;
+ virtual void GotoEvent(Int_t event);
+ virtual void NextEvent();
+ virtual void PrevEvent();
+ virtual void Close();
+ void Timeout(); // * SIGNAL*
+
+ Int_t GetEventId() const { return fEventId; }
+ AliRunLoader* GetRunLoader() const { return fRunLoader; }
+ TFile* GetESDFile() const { return fESDFile; }
+ TTree* GetESDTree() const { return fESDTree; }
+ TTree* GetHLTESDTree() const { return fHLTESDTree; }
+ AliESDEvent* GetESD() const { return fESD; }
+ AliESDfriend* GetESDfriend() const { return fESDfriend; }
+ Bool_t GetESDfriendExists() const { return fESDfriendExists; }
+ TFile* GetAODFile() const { return fAODFile; }
+ TTree* GetAODTree() const { return fAODTree; }
+ AliAODEvent* GetAOD() const { return fAOD; }
+ AliEveEventSelector* GetEventSelector() const { return fPEventSelector; }
+ TString GetEventInfoHorizontal() const;
+ TString GetEventInfoVertical() const;
+ const AliEventInfo* GetEventInfo();
+
+ static Int_t CurrentEventId();
+
+ static Bool_t HasRunLoader();
+ static Bool_t HasESD();
+ static Bool_t HasESDfriend();
+ static Bool_t HasAOD();
+ static Bool_t HasRawReader();
+
+ static AliRunLoader* AssertRunLoader();
+ static AliESDEvent* AssertESD();
+ static AliESDfriend* AssertESDfriend();
+ static AliAODEvent* AssertAOD();
+ static AliRawReader* AssertRawReader();
+
+ static AliMagF* AssertMagField();
+ static TGeoManager* AssertGeometry();
+ static AliRecoParam* AssertRecoParams();
+
+ static AliEveEventManager* AddDependentManager(const TString& name, const TString& path);
+ static AliEveEventManager* GetDependentManager(const TString& name);
+
+ static AliEveEventManager* GetMaster();
+ static AliEveEventManager* GetCurrent();
+
+ static void RegisterTransient (TEveElement* element);
+ static void RegisterTransientList(TEveElement* element);
+
+
+ Double_t GetAutoLoadTime() const { return fAutoLoadTime; }
+ Bool_t GetAutoLoad() const { return fAutoLoad; }
+ void SetAutoLoadTime(Float_t time);
+ void SetAutoLoad(Bool_t autoLoad);
+ void SetTrigSel(Int_t trig);
+ void AutoLoadNextEvent();
+
+ Bool_t AreEventFilesOpened() const { return fIsOpen; }
+ Bool_t IsEventAvailable() const { return fHasEvent; }
+ Bool_t IsUnderExternalControl() const { return fExternalCtrl; }
+
+ Bool_t InsertGlobal(const TString& tag, TEveElement* model);
+ Bool_t InsertGlobal(const TString& tag, TEveElement* model,
+ Bool_t replace, Bool_t update);
+ TEveElement* FindGlobal(const TString& tag);
+
+ virtual void AfterNewEventLoaded();
+ void NewEventDataLoaded(); // *SIGNAL*
+ void NewEventLoaded(); // *SIGNAL*
+
+ AliEveMacroExecutor* GetExecutor() const { return fExecutor; }
protected:
- Int_t fEventId; // Id of current event.
+ Int_t fEventId; // Id of current event.
- AliRunLoader* fRunLoader; // Run loader.
+ AliRunLoader* fRunLoader; // Run loader.
- TFile *fESDFile; // ESD file.
- TTree *fESDTree; // ESD tree.
- AliESDEvent *fESD; // ESDEvent object.
- AliESDfriend *fESDfriend; // ESDfriend object.
- Bool_t fESDfriendExists; // Flag specifying if ESDfriend was found during opening of the event-data.
- TFile *fAODFile; // AOD file.
- TTree *fAODTree; // AOD tree.
- AliAODEvent *fAOD; // AODEvent object.
+ TFile *fESDFile; // ESD file.
+ TTree *fESDTree; // ESD tree.
+ TTree *fHLTESDTree; // HLT ESD tree.
+ AliESDEvent *fESD; // ESDEvent object.
+ AliESDfriend *fESDfriend; // ESDfriend object.
+ Bool_t fESDfriendExists; // Flag specifying if ESDfriend was found during opening of the event-data.
+ TFile *fAODFile; // AOD file.
+ TTree *fAODTree; // AOD tree.
+ AliAODEvent *fAOD; // AODEvent object.
- AliRawReader *fRawReader; // Raw-data reader.
- AliEventInfo fEventInfo; // Current Event Info
-
- Bool_t fAutoLoad; // Automatic loading of events (online)
- Float_t fAutoLoadTime; // Auto-load time in seconds
- TTimer *fAutoLoadTimer; // Timer for automatic event loading
+ AliRawReader *fRawReader; // Raw-data reader.
+ AliEventInfo fEventInfo; // Current Event Info
- Bool_t fIsOpen; // Are event-files opened.
- Bool_t fHasEvent; // Is an event available.
- Bool_t fExternalCtrl; // Are we under external event-loop.
+ Bool_t fAutoLoad; // Automatic loading of events (online)
+ Float_t fAutoLoadTime; // Auto-load time in seconds
+ TTimer *fAutoLoadTimer; // Timer for automatic event loading
- TMap* fGlobal;
- Bool_t fGlobalReplace; // Are global replace
- Bool_t fGlobalUpdate; // Are global updates
+ Bool_t fIsOpen; // Are event-files opened.
+ Bool_t fHasEvent; // Is an event available.
+ Bool_t fExternalCtrl; // Are we under external event-loop.
- AliEveMacroExecutor *fExecutor; // Executor for std macros
+ TMap* fGlobal;
+ Bool_t fGlobalReplace; // Are global replace
+ Bool_t fGlobalUpdate; // Are global updates
- TEveElementList *fTransients; // Container for additional transient (per event) elements.
- TEveElementList *fTransientLists; // Container for lists of transient (per event) elements.
+ AliEveMacroExecutor *fExecutor; // Executor for std macros
- AliEveEventSelector* fPEventSelector; // Event filter
+ TEveElementList *fTransients; // Container for additional transient (per event) elements.
+ TEveElementList *fTransientLists; // Container for lists of transient (per event) elements.
- TList *fSubManagers; // Dependent event-managers, used for event embedding.
+ AliEveEventSelector* fPEventSelector; // Event filter
- static TString fgGAliceFileName; // galice.root file
- static TString fgESDFileName; // Name by which to open ESD.
- static TString fgESDfriendsFileName;
- static TString fgAODFileName; // Name by which to open AOD.
- static TString fgRawFileName; // Name by which to open raw-data file.
- static TString fgCdbUri; // Global URI to CDB.
- static Bool_t fgAssertRunLoader; // Global flag specifying if AliRunLoader must be asserted during opening of the event-data.
- static Bool_t fgAssertESD; // Global flag specifying if ESDEvent must be asserted during opening of the event-data.
- static Bool_t fgAssertAOD; // Global flag specifying if AODEvent must be asserted during opening of the event-data.
- static Bool_t fgAssertRaw; // Global flag specifying if raw-data presence must be asserted during opening of the event-data.
+ TList *fSubManagers; // Dependent event-managers, used for event embedding.
- static TList *fgAODfriends; // Global list of AOD friend names to be attached during opening of the event-data (empty by default).
+ static TString fgGAliceFileName; // galice.root file
+ static TString fgESDFileName; // Name by which to open ESD.
+ static EVisibleESDTrees fgESDvisibleTrees; // trees to open from ESD
+ static TString fgESDfriendsFileName;
+ static TString fgAODFileName; // Name by which to open AOD.
+ static TString fgRawFileName; // Name by which to open raw-data file.
+ static TString fgCdbUri; // Global URI to CDB.
+ static Bool_t fgAssertRunLoader; // Global flag specifying if AliRunLoader must be asserted during opening of the event-data.
+ static Bool_t fgAssertESD; // Global flag specifying if ESDEvent must be asserted during opening of the event-data.
+ static Bool_t fgAssertAOD; // Global flag specifying if AODEvent must be asserted during opening of the event-data.
+ static Bool_t fgAssertRaw; // Global flag specifying if raw-data presence must be asserted during opening of the event-data.
- static Bool_t fgRawFromStandardLoc; // Global flag to enable looking for raw data in ../../../raw/, as it is stored for central reco.
+ static TList *fgAODfriends; // Global list of AOD friend names to be attached during opening of the event-data (empty by default).
- static Bool_t fgGRPLoaded; // Global run parameters loaded?
- static AliMagF *fgMagField; // Global pointer to magnetic field.
- static AliRecoParam* fgRecoParam;
- static Bool_t fgUniformField; // Track with uniform field.
+ static Bool_t fgRawFromStandardLoc; // Global flag to enable looking for raw data in ../../../raw/, as it is stored for central reco.
+
+ static Bool_t fgGRPLoaded; // Global run parameters loaded?
+ static AliMagF *fgMagField; // Global pointer to magnetic field.
+ static AliRecoParam* fgRecoParam;
+ static Bool_t fgUniformField; // Track with uniform field.
private:
- AliEveEventManager(const AliEveEventManager&); // Not implemented
- AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented
+ AliEveEventManager(const AliEveEventManager&); // Not implemented
+ AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented
+
+ void InitInternals();
+ void StartAutoLoadTimer();
+ void StopAutoLoadTimer();
- void InitInternals();
- void StartAutoLoadTimer();
- void StopAutoLoadTimer();
+ static Bool_t InitGRP();
+ static Bool_t InitRecoParam();
- static Bool_t InitGRP();
- static Bool_t InitRecoParam();
+ TTree* readESDTree(const char* treeName, int &run);
- Bool_t fAutoLoadTimerRunning; // State of auto-load timer.
+ Bool_t fAutoLoadTimerRunning; // State of auto-load timer.
- static AliEveEventManager* fgMaster;
- static AliEveEventManager* fgCurrent;
+ static AliEveEventManager* fgMaster;
+ static AliEveEventManager* fgCurrent;
- ClassDef(AliEveEventManager, 0); // Interface for getting all event components in a uniform way.
+ ClassDef(AliEveEventManager, 0); // Interface for getting all event components in a uniform way.
};
#endif
//_____________________________________________________________________________
AliEveEventSelector::AliEveEventSelector(AliEveEventManager* evman):
- fPEventManager(evman),
- fWrapAround(kFALSE),
- fSelectOnString(kFALSE),
- fString(""),
- fPEntryList(0),
- fEntryListId(0),
- fLastTreeSize(-1),
- fSelectOnTriggerType(kFALSE),
- fTriggerType(""),
- fSelectOnTriggerString(kFALSE),
- fTriggerSelectionString(""),
- fTriggerMaskPatternString("trgmask"),
- fSelectOnMultiplicity(kFALSE),
- fMultiplicityLow(0),
- fMultiplicityHigh(0)
+ fPEventManager(evman),
+ fWrapAround(kFALSE),
+ fSelectOnString(kFALSE),
+ fString(""),
+ fPEntryList(0),
+ fEntryListId(0),
+ fLastTreeSize(-1),
+ fSelectOnTriggerType(kFALSE),
+ fTriggerType(""),
+ fSelectOnTriggerString(kFALSE),
+ fTriggerSelectionString(""),
+ fTriggerMaskPatternString("trgmask"),
+ fSelectOnMultiplicity(kFALSE),
+ fMultiplicityLow(0),
+ fMultiplicityHigh(0)
{
- //ctor
+ //ctor
}
//_____________________________________________________________________________
void AliEveEventSelector::SetSelectionString( const TString& str )
{
- //selection string setter
- //takes care of producing a list of entries passing selection
-
- TTree* pESDTree = fPEventManager->GetESDTree();
- if (!pESDTree || fString==str) return;//don't waist time
- fString = str;
- if (str == "" ) return;//on reset don't recalculate
- pESDTree->Draw( ">>listofentries", fString, "entrylist");
- fPEntryList = dynamic_cast<TEntryList*>(gDirectory->Get("listofentries"));
+ //selection string setter
+ //takes care of producing a list of entries passing selection
+
+ TTree* pESDTree = fPEventManager->GetESDTree();
+ TTree* pHLTESDTree = fPEventManager->GetHLTESDTree();
+ if ((!pESDTree && !pHLTESDTree) || fString==str) return;//don't waist time
+ fString = str;
+ if (str == "" ) return;//on reset don't recalculate
+
+ if(pESDTree) pESDTree->Draw( ">>listofentries", fString, "entrylist");
+ if(pHLTESDTree) pESDTree->Draw( ">>listofentries", fString, "entrylist");
+
+ fPEntryList = dynamic_cast<TEntryList*>(gDirectory->Get("listofentries"));
}
//_____________________________________________________________________________
void AliEveEventSelector::SetSelectionString( const char* str )
{
- //selection string setter
+ //selection string setter
- TString ts = str;
- SetSelectionString(ts);
+ TString ts = str;
+ SetSelectionString(ts);
}
//_____________________________________________________________________________
void AliEveEventSelector::SetTriggerType( const TString& type )
{
- //trigger type setter
+ //trigger type setter
- fTriggerType = type;
+ fTriggerType = type;
}
//_____________________________________________________________________________
void AliEveEventSelector::SetTriggerType( const char* type)
{
- //trigger type setter
+ //trigger type setter
- TString ts = type;
- SetTriggerType(ts);
+ TString ts = type;
+ SetTriggerType(ts);
}
//_____________________________________________________________________________
void AliEveEventSelector::UpdateEntryList()
{
- //update the entrylist from if file changed
-
- TTree* pESDTree = fPEventManager->GetESDTree();
- if (!pESDTree) return;
-
- Long64_t treesize = fPEventManager->GetMaxEventId()+1;
- if (treesize<=fLastTreeSize) return; //nothing changed, do nothing
- pESDTree->Draw(">>+fPEntryList", fString, "entrylist",
- fLastTreeSize+1, treesize-fLastTreeSize );
- fLastTreeSize = treesize;
+ //update the entrylist from if file changed
+
+ TTree* pESDTree = fPEventManager->GetESDTree();
+ TTree* pHLTESDTree = fPEventManager->GetHLTESDTree();
+
+ if (!pESDTree && !pHLTESDTree) return;
+
+ Long64_t treesize = fPEventManager->GetMaxEventId()+1;
+ if (treesize<=fLastTreeSize) return; //nothing changed, do nothing
+
+
+ if(pESDTree) pESDTree->Draw(">>+fPEntryList", fString, "entrylist", fLastTreeSize+1, treesize-fLastTreeSize );
+ if(pHLTESDTree) pHLTESDTree->Draw(">>+fPEntryList", fString, "entrylist", fLastTreeSize+1, treesize-fLastTreeSize );
+
+ fLastTreeSize = treesize;
}
//_____________________________________________________________________________
void AliEveEventSelector::Update()
{
- //refresh stuff
+ //refresh stuff
- UpdateEntryList();
+ UpdateEntryList();
}
//_____________________________________________________________________________
Bool_t AliEveEventSelector::FindNext( Int_t& output )
{
- //does the magick of selecting the next event
-
- static const TEveException kEH("AliEveEventSelector::GetNext ");
-
- TTree* pESDTree = fPEventManager->GetESDTree();
- if (!pESDTree) return kFALSE;
- AliESDEvent* pESDEvent = fPEventManager->GetESD();
- Int_t eventId = fPEventManager->GetEventId();
- Int_t fMaxEventId = fPEventManager->GetMaxEventId();
-
- if (!fSelectOnString)
- {
- // pure non-string
- for (Int_t i = eventId+1; i<fMaxEventId+1; i++)
- {
- if (pESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = i;
- return kTRUE;
- }
- }
- if (!fWrapAround) return kFALSE;
- for (Int_t i = 0; i<eventId+1; i++)
- {
- if (pESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = i;
- return kTRUE;
- }
- }
- return kFALSE;
- }
- else
- {
- //select using the entrylist
- UpdateEntryList(); //update entry list if tree got bigger
- for (Long64_t i=fEntryListId+1; i<fPEntryList->GetN(); i++ )
+ //does the magick of selecting the next event
+
+ static const TEveException kEH("AliEveEventSelector::GetNext ");
+
+ TTree* pESDTree = fPEventManager->GetESDTree();
+ TTree* pHLTESDTree = fPEventManager->GetHLTESDTree();
+
+ if (!pESDTree && !pHLTESDTree) return kFALSE;
+
+ Bool_t OfflineHasNext=kFALSE;
+ Bool_t HLTHasNext=kFALSE;
+
+ if(pESDTree) OfflineHasNext = FindNextInTree(pESDTree, output);
+ if(pHLTESDTree)HLTHasNext = FindNextInTree(pHLTESDTree,output);
+
+ return (OfflineHasNext | HLTHasNext);
+}
+
+Bool_t AliEveEventSelector::FindNextInTree(TTree* tree, Int_t& output)
+{
+ if(!tree) return kFALSE;
+
+ static const TEveException kEH("AliEveEventSelector::FindNextInTree ");
+
+ AliESDEvent* pESDEvent = fPEventManager->GetESD();
+ Int_t eventId = fPEventManager->GetEventId();
+ Int_t fMaxEventId = fPEventManager->GetMaxEventId();
+
+ if (!fSelectOnString)
{
- Long64_t entry = fPEntryList->GetEntry(i);
- if (pESDTree->GetEntry(entry) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = entry;
- fEntryListId = i;
- return kTRUE;
- }
+ // pure non-string
+ for (Int_t i = eventId+1; i<fMaxEventId+1; i++)
+ {
+ if (tree->GetEntry(i) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = i;
+ return kTRUE;
+ }
+ }
+ if (!fWrapAround) return kFALSE;
+ for (Int_t i = 0; i<eventId+1; i++)
+ {
+ if (tree->GetEntry(i) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = i;
+ return kTRUE;
+ }
+ }
+ return kFALSE;
}
- if (!fWrapAround) return kFALSE;
- for (Long64_t i=0; i<fEntryListId+1; i++ )
+ else
{
- Long64_t entry = fPEntryList->GetEntry(i);
- if (pESDTree->GetEntry(entry) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = entry;
- fEntryListId=i;
- return kTRUE;
- }
+ //select using the entrylist
+ UpdateEntryList(); //update entry list if tree got bigger
+ for (Long64_t i=fEntryListId+1; i<fPEntryList->GetN(); i++ )
+ {
+ Long64_t entry = fPEntryList->GetEntry(i);
+ if (tree->GetEntry(entry) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = entry;
+ fEntryListId = i;
+ return kTRUE;
+ }
+ }
+ if (!fWrapAround) return kFALSE;
+ for (Long64_t i=0; i<fEntryListId+1; i++ )
+ {
+ Long64_t entry = fPEntryList->GetEntry(i);
+ if (tree->GetEntry(entry) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = entry;
+ fEntryListId=i;
+ return kTRUE;
+ }
+ }
+ return kFALSE;
}
return kFALSE;
- }
- return kFALSE;
}
//_____________________________________________________________________________
Bool_t AliEveEventSelector::FindPrev( Int_t& output )
{
- //does the magick of selecting the previous event
-
- static const TEveException kEH("AliEveEventSelector::GetNext ");
-
- TTree* pESDTree = fPEventManager->GetESDTree();
- if (!pESDTree) return kFALSE;
- AliESDEvent* pESDEvent = fPEventManager->GetESD();
- Int_t eventId = fPEventManager->GetEventId();
- Int_t fMaxEventId = fPEventManager->GetMaxEventId();
-
- if (!fSelectOnString)
- {
- // pure non-string
- for (Int_t i = eventId-1; i>-1; i--)
- {
- if (pESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = i;
- return kTRUE;
- }
- }
- if (!fWrapAround) return kFALSE;
- for (Int_t i = fMaxEventId; i>eventId-1; i--)
- {
- if (pESDTree->GetEntry(i) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = i;
- return kTRUE;
- }
- }
- return kFALSE;
- }
- else
- {
- //select using the entrylist
- for (Long64_t i=fEntryListId-1; i>-1; i--)
+ //does the magick of selecting the previous event
+ TTree* pESDTree = fPEventManager->GetESDTree();
+ TTree* pHLTESDTree = fPEventManager->GetHLTESDTree();
+
+ if (!pESDTree && !pHLTESDTree) return kFALSE;
+
+ Bool_t OfflineHasNext=kFALSE;
+ Bool_t HLTHasNext=kFALSE;
+
+ if(pESDTree) OfflineHasNext = FindPrevInTree(pESDTree, output);
+ if(pHLTESDTree) HLTHasNext = FindPrevInTree(pHLTESDTree,output);
+
+ return (OfflineHasNext | HLTHasNext);
+}
+
+
+Bool_t AliEveEventSelector::FindPrevInTree(TTree* tree, Int_t& output)
+{
+ static const TEveException kEH("AliEveEventSelector::FindPrevInTree ");
+
+ AliESDEvent* pESDEvent = fPEventManager->GetESD();
+ Int_t eventId = fPEventManager->GetEventId();
+ Int_t fMaxEventId = fPEventManager->GetMaxEventId();
+
+ if (!fSelectOnString)
{
- Long64_t entry = fPEntryList->GetEntry(i);
- if (pESDTree->GetEntry(entry) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = entry;
- fEntryListId = i;
- return kTRUE;
- }
+ // pure non-string
+ for (Int_t i = eventId-1; i>-1; i--)
+ {
+ if (tree->GetEntry(i) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = i;
+ return kTRUE;
+ }
+ }
+ if (!fWrapAround) return kFALSE;
+ for (Int_t i = fMaxEventId; i>eventId-1; i--)
+ {
+ if (tree->GetEntry(i) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = i;
+ return kTRUE;
+ }
+ }
+ return kFALSE;
}
- if (!fWrapAround) return kFALSE;
- for (Long64_t i=fPEntryList->GetN()-1; i>fEntryListId-1; i--)
+ else
{
- Long64_t entry = fPEntryList->GetEntry(i);
- if (pESDTree->GetEntry(entry) <= 0)
- throw (kEH + "failed getting required event from ESD.");
- if (CheckOtherSelection(pESDEvent))
- {
- output = entry;
- fEntryListId=i;
- return kTRUE;
- }
+ //select using the entrylist
+ for (Long64_t i=fEntryListId-1; i>-1; i--)
+ {
+ Long64_t entry = fPEntryList->GetEntry(i);
+ if (tree->GetEntry(entry) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = entry;
+ fEntryListId = i;
+ return kTRUE;
+ }
+ }
+ if (!fWrapAround) return kFALSE;
+ for (Long64_t i=fPEntryList->GetN()-1; i>fEntryListId-1; i--)
+ {
+ Long64_t entry = fPEntryList->GetEntry(i);
+ if (tree->GetEntry(entry) <= 0)
+ throw (kEH + "failed getting required event from ESD.");
+ if (CheckOtherSelection(pESDEvent))
+ {
+ output = entry;
+ fEntryListId=i;
+ return kTRUE;
+ }
+ }
+ return kFALSE;
}
return kFALSE;
- }
- return kFALSE;
}
//_____________________________________________________________________________
Bool_t AliEveEventSelector::CheckOtherSelection( AliESDEvent* pESDEvent )
{
- //checks the event for any other hardcoded selection criteria
-
- Bool_t ret=kTRUE;
-
- //trigger stuff
- if (fSelectOnTriggerType)
- {
- TString firedtrclasses = pESDEvent->GetFiredTriggerClasses();
- if (!(firedtrclasses.Contains(fTriggerType))) return kFALSE;
- //if (!pESDEvent->IsTriggerClassFired(fTriggerType.Data())) return kFALSE;
- }
-
- if (fSelectOnMultiplicity)
- {
- Int_t mult = pESDEvent->GetNumberOfTracks();
- Int_t mhigh = (fMultiplicityHigh==0)?100000000:fMultiplicityHigh;
- if (mult<fMultiplicityLow || mult>mhigh) return kFALSE;
- }
-
- if (fSelectOnTriggerString)
- {
- ULong64_t triggermask = pESDEvent->GetTriggerMask();
- TString triggermaskstr;
- triggermaskstr += triggermask;
- TString selstr(fTriggerSelectionString); //make copy
- selstr.ReplaceAll(fTriggerMaskPatternString,triggermaskstr);
- //Int_t returncode;
- Bool_t result = static_cast<Bool_t>(gROOT->ProcessLine(selstr));//,&returncode));
- //if (!returncode) return kFALSE;
- if (!result) return kFALSE;
- }
-
- return ret;
+ //checks the event for any other hardcoded selection criteria
+
+ Bool_t ret=kTRUE;
+
+ //trigger stuff
+ if (fSelectOnTriggerType)
+ {
+ TString firedtrclasses = pESDEvent->GetFiredTriggerClasses();
+ if (!(firedtrclasses.Contains(fTriggerType))) return kFALSE;
+ //if (!pESDEvent->IsTriggerClassFired(fTriggerType.Data())) return kFALSE;
+ }
+
+ if (fSelectOnMultiplicity)
+ {
+ Int_t mult = pESDEvent->GetNumberOfTracks();
+ Int_t mhigh = (fMultiplicityHigh==0)?100000000:fMultiplicityHigh;
+ if (mult<fMultiplicityLow || mult>mhigh) return kFALSE;
+ }
+
+ if (fSelectOnTriggerString)
+ {
+ ULong64_t triggermask = pESDEvent->GetTriggerMask();
+ TString triggermaskstr;
+ triggermaskstr += triggermask;
+ TString selstr(fTriggerSelectionString); //make copy
+ selstr.ReplaceAll(fTriggerMaskPatternString,triggermaskstr);
+ //Int_t returncode;
+ Bool_t result = static_cast<Bool_t>(gROOT->ProcessLine(selstr));//,&returncode));
+ //if (!returncode) return kFALSE;
+ if (!result) return kFALSE;
+ }
+
+ return ret;
}
//_____________________________________________________________________________
void AliEveEventSelector::SetTriggerSelectionString( TString str )
{
- //parses and sets the trigger selection formula
-
- const AliESDRun* run = fPEventManager->GetESD()->GetESDRun();
- for (Int_t i=0; i<run->kNTriggerClasses; i++)
- {
- TString name(run->GetTriggerClass(i));
- if (name.IsNull()) continue;
- TString valuestr("(");
- valuestr += fTriggerMaskPatternString;
- valuestr += "&";
- valuestr += static_cast<ULong64_t>(1)<<i;
- valuestr += ")";
- str.ReplaceAll(name,valuestr);
- }//for i
- fTriggerSelectionString = str;
+ //parses and sets the trigger selection formula
+
+ const AliESDRun* run = fPEventManager->GetESD()->GetESDRun();
+ for (Int_t i=0; i<run->kNTriggerClasses; i++)
+ {
+ TString name(run->GetTriggerClass(i));
+ if (name.IsNull()) continue;
+ TString valuestr("(");
+ valuestr += fTriggerMaskPatternString;
+ valuestr += "&";
+
valuestr += static_cast<ULong64_t>(1)<<i;
+ valuestr += ")";
+ str.ReplaceAll(name,valuestr);
+ }//for i
+ fTriggerSelectionString = str;
}
protected:
void UpdateEntryList();
Bool_t CheckOtherSelection(AliESDEvent* ESD);
+
+ Bool_t FindNextInTree(TTree* tree, Int_t& i);
+ Bool_t FindPrevInTree(TTree* tree, Int_t& i);
private:
AliEveEventSelector(const AliEveEventSelector&);
/// \file alieve_init.C
void alieve_init(const TString& cdburi = "",
- const TString& path = ".", Int_t event=0,
+ const TString& path = ".", Int_t event=0,Bool_t showHLTESDTree=kFALSE,
const Text_t* esdfile = 0,
const Text_t* aodfile = 0,
const Text_t* rawfile = 0,
AliEveEventManager::SetFilesPath(path);
- AliEveEventManager::SetESDFileName(esdfile);
+ if(showHLTESDTree){
+ AliEveEventManager::SetESDFileName(esdfile, AliEveEventManager::kHLTTree);
+ }
+ else
+ {
+ AliEveEventManager::SetESDFileName(esdfile, AliEveEventManager::kOfflineTree);
+ }
+
AliEveEventManager::SetRawFileName(rawfile);
AliEveEventManager::SetCdbUri(cdburi);
AliEveEventManager::SetAssertElements(assert_runloader, assert_esd,
Info("alieve_init", "AliEn requested - connecting.");
if (gSystem->Getenv("GSHELL_ROOT") == 0)
{
- Error("alieve_init", "AliEn environment not initialized. Aborting.");
- gSystem->Exit(1);
+ Error("alieve_init", "AliEn environment not initialized. Aborting.");
+ gSystem->Exit(1);
}
if (TGrid::Connect("alien") == 0)
{
- Error("alieve_init", "TGrid::Connect() failed. Aborting.");
- gSystem->Exit(1);
+ Error("alieve_init", "TGrid::Connect() failed. Aborting.");
+ gSystem->Exit(1);
}
}
}
gSystem->Load("libTPCbase");
gSystem->Load("libTPCrec");
gSystem->Load("libTPCsim");
+ gSystem->Load("libTPCfast");
gSystem->Load("libITSbase");
gSystem->Load("libITSsim");
gSystem->Load("libITSrec");
Int_t status;
- // create screenshots from OpenGL views
- TEveUtil::LoadMacro("saveViews.C+");
- saveViews(pic.Data());
+ status = gSystem->Exec(TString::Format("xwd -id %u | convert - %s",
+ gEve->GetBrowser()->GetId(), pic.Data()));
+
+ printf("Post capture -- status=%d.\n", status);
- // send screenshot to AMORE
status = gSystem->Exec(TString::Format("SendImageToAmore %s %s %d",
id.Data(), pic.Data(),
AliEveEventManager::AssertRawReader()->GetRunNumber()));
void visscan_init(const TString& cdburi = "",
const TString& path = ".",
+ Bool_t showHLTESDTree=kFALSE,
Bool_t showMuon = kTRUE,
Bool_t showTrd = kFALSE)
{
AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
TEveUtil::LoadMacro("alieve_init.C");
- alieve_init(cdburi, path, -1);
+ alieve_init(cdburi, path, -1, showHLTESDTree);
// TEveLine::SetDefaultSmooth(1);
#include <TString.h>
#include <TROOT.h>
+// In order to open the HLT ESD Tree, instead of the Offline ESD Tree:
+// run in the current directory:
+// alieve mf_fix.C visscan_local.C'(".", kTRUE)'
-void visscan_local(const TString& path = ".", Bool_t showMuon = kTRUE, Bool_t showTrd = kFALSE)
+void visscan_local(const TString& path = ".", Bool_t showHLTESDTree=kFALSE, Bool_t showMuon = kTRUE, Bool_t showTrd = kFALSE)
{
gROOT->ProcessLine(TString::Format(".x visscan_init.C(\"local://$ALICE_ROOT/OCDB\", \"%s\", %d, %d)",
- path.Data(), showMuon, showTrd));
+ path.Data(), showHLTESDTree, showMuon, showTrd));
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff