**************************************************************************/
#include "AliEveEventManager.h"
+#include "AliEveMacroExecutor.h"
#include <TEveManager.h>
#include <AliRunLoader.h>
#include <AliRun.h>
#include <AliESDEvent.h>
#include <AliESDfriend.h>
+#include <AliDAQ.h>
+#include <AliRawEventHeaderBase.h>
#include <AliRawReaderRoot.h>
#include <AliRawReaderFile.h>
#include <AliRawReaderDate.h>
#include <TFile.h>
#include <TTree.h>
+#include <TGeoManager.h>
#include <TSystem.h>
+#include <TTimeStamp.h>
//==============================================================================
//==============================================================================
AliMagF* AliEveEventManager::fgMagField = 0;
+void AliEveEventManager::InitInternals()
+{
+ // Initialize internal members.
+
+ fAutoLoadTimer = new TTimer;
+ fAutoLoadTimer->Connect("Timeout()", "AliEveEventManager", this, "AutoLoadNextEvent()");
+
+ fExecutor = new AliEveMacroExecutor;
+}
AliEveEventManager::AliEveEventManager() :
TEveEventManager(),
fESDFile (0), fESDTree (0), fESD (0),
fESDfriend (0), fESDfriendExists(kFALSE),
fRawReader (0),
- fAutoLoad(kFALSE),
- fAutoLoadTime(5.),
- fAutoLoadTimer(0),
- fIsOnline(kFALSE)
+ fAutoLoad (kFALSE), fAutoLoadTime (5.), fAutoLoadTimer(0),
+ fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
+ fExecutor (0),
+ fAutoLoadTimerRunning(kFALSE)
{
// Default constructor.
+
+ InitInternals();
}
AliEveEventManager::AliEveEventManager(TString path, Int_t ev) :
fESDFile (0), fESDTree (0), fESD (0),
fESDfriend (0), fESDfriendExists(kFALSE),
fRawReader (0),
- fAutoLoad(kFALSE),
- fAutoLoadTime(5.),
- fAutoLoadTimer(0),
- fIsOnline(kFALSE)
+ fAutoLoad (kFALSE), fAutoLoadTime (5), fAutoLoadTimer(0),
+ fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
+ fExecutor (0),
+ fAutoLoadTimerRunning(kFALSE)
{
// Constructor with event-directory URL and event-id.
+ InitInternals();
+
Open();
- if (ev >= 0) GotoEvent(ev);
+ if (ev >= 0)
+ {
+ GotoEvent(ev);
+ }
}
AliEveEventManager::~AliEveEventManager()
{
// Destructor.
- if (fAutoLoadTimer) delete fAutoLoadTimer;
+ if (fIsOpen)
+ {
+ Close();
+ }
+
// Somewhat unclear what to do here.
- // In principle should close all data sources and deregister from
+ // In principle should wipe event data and deregister from
// TEveManager.
}
static const TEveException kEH("AliEveEventManager::Open ");
+ if (fExternalCtrl)
+ {
+ throw (kEH + "Event-loop is under external control.");
+ }
+ if (fIsOpen)
+ {
+ throw (kEH + "Event-files already opened.");
+ }
+
gSystem->ExpandPathName(fPath);
- if (fPath[0] != '/')
- fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
+ // The following magick is required for ESDriends to be loaded properly
+ // from non-current directory.
+ if (fPath.IsNull() || fPath == ".")
+ {
+ fPath = gSystem->WorkingDirectory();
+ }
+ else if ( ! fPath.BeginsWith("file:/"))
+ {
+ TUrl url(fPath, kTRUE);
+ TString protocol(url.GetProtocol());
+ if (protocol == "file" && fPath[0] != '/')
+ fPath = Form("%s/%s", gSystem->WorkingDirectory(), fPath.Data());
+ }
Int_t runNo = -1;
+ // Open ESD and ESDfriends
+
+ TString esdPath(Form("%s/%s", fPath.Data(), fgESDFileName.Data()));
+ if ((fESDFile = TFile::Open(esdPath)))
+ {
+ 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.
+ // There was also a problem with TTree::Refresh() - it didn't
+ // save the friend branch on a separate file, fixed in 5.22.2 -
+ // so we might want to try the old way again soon.
+ TString p(Form("%s/AliESDfriends.root", fPath.Data()));
+ TFile *esdFriendFile = TFile::Open(p);
+ 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();
+ }
+ }
+ else // esdtree == 0
+ {
+ delete fESDFile; fESDFile = 0;
+ delete fESD; fESD = 0;
+ Warning(kEH, "failed getting the esdTree.");
+ }
+ }
+ else // esd not readable
+ {
+ Warning(kEH, "can not read ESD file '%s'.", esdPath.Data());
+ }
+ if (fESDTree == 0)
+ {
+ if (fgAssertESD)
+ {
+ throw (kEH + "ESD not initialized. Its precence was requested.");
+ } else {
+ Warning(kEH, "ESD not initialized.");
+ }
+ }
+
+ // Open RunLoader from galice.root
+
TString gaPath(Form("%s/galice.root", fPath.Data()));
// If i use open directly, we get fatal.
- // Is this (AccessPathName check) ok for xrootd / alien?
+ // Is AccessPathName check ok for xrootd / alien? Yes, not for http.
if (gSystem->AccessPathName(gaPath, kReadPermission) == kFALSE)
{
fRunLoader = AliRunLoader::Open(gaPath);
if (fRunLoader->LoadHeader() == 0)
{
- runNo = fRunLoader->GetHeader()->GetRun();
+ if (runNo < 0)
+ runNo = fRunLoader->GetHeader()->GetRun();
}
else
{
Warning(kEH, "Bootstraping of run-loader failed.");
}
+ // Open raw-data file
- TString esdPath(Form("%s/%s", fPath.Data(), fgESDFileName.Data()));
- if ((fESDFile = TFile::Open(esdPath)))
- {
- fESD = new AliESDEvent();
- fESDTree = (TTree*) fESDFile->Get("esdTree");
- if (fESDTree != 0)
- {
- fESD->ReadFromTree(fESDTree);
- runNo = fESD->GetESDRun()->GetRunNumber();
-
- // Check if ESDfriends exists and attach the branch
- TString p = Form("%s/AliESDfriends.root", fPath.Data());
- if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
- {
- fESDfriendExists = kTRUE;
- fESDTree->SetBranchStatus ("ESDfriend*", 1);
- fESDTree->SetBranchAddress("ESDfriend.", &fESDfriend);
- }
- }
- else // esdtree == 0
- {
- delete fESDFile; fESDFile = 0;
- Warning(kEH, "failed getting the esdTree.");
- }
- }
- else // esd not readable
+ TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
+ // If i use open directly, raw-reader reports an error but i have
+ // no way to detect it.
+ // Is this (AccessPathName check) ok for xrootd / alien? Yes, not for http.
+ if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
{
- Warning(kEH, "can not read ESD file '%s'.", esdPath.Data());
+ fRawReader = AliRawReader::Create(rawPath);
}
- if (fESDTree == 0)
+ else
{
- if (fgAssertESD)
- {
- throw (kEH + "ESD not initialized. Its precence was requested.");
- } else {
- Warning(kEH, "ESD not initialized.");
- }
+ fRawReader = AliRawReader::Create(fgRawFileName);
}
-
- TString rawPath(Form("%s/%s", fPath.Data(), fgRawFileName.Data()));
- // If i use open directly, raw-reader reports an error but i have
- // no way to detect it.
- // Is this (AccessPathName check) ok for xrootd / alien?
- if (gSystem->AccessPathName(rawPath, kReadPermission) == kFALSE)
- {
- if (fgRawFileName.EndsWith("/"))
- {
- fRawReader = new AliRawReaderFile(rawPath);
- }
- else if (fgRawFileName.EndsWith(".root"))
- {
- fRawReader = new AliRawReaderRoot(rawPath);
- }
- else if (!fgRawFileName.IsNull())
- {
- fRawReader = new AliRawReaderDate(rawPath);
- }
- }
-
if (fRawReader == 0)
{
if (fgAssertRaw)
{
fRawReader->NextEvent();
runNo = fRawReader->GetRunNumber();
- printf("Determining run-no from raw ... run=%d\n", runNo);
+ Info(kEH, "Determining run-no from raw ... run=%d.", runNo);
fRawReader->RewindEvents();
} else {
throw (kEH + "unknown run number.");
SetName(Form("Event %d", fEventId));
SetTitle(fPath);
+ fIsOpen = kTRUE;
}
void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd)
{
// Set an event from an external source
// The method is used in the online visualisation
+
+ static const TEveException kEH("AliEveEventManager::SetEvent ");
+
+ if (fIsOpen)
+ {
+ Warning(kEH, "Event-files were open. Closing and switching to external control.");
+ Close();
+ }
+
fRunLoader = runLoader;
fRawReader = rawReader;
- fESD = esd;
- fIsOnline = kTRUE;
+ fESD = esd;
+
+ fEventId++;
+ fHasEvent = kTRUE;
+ fExternalCtrl = kTRUE;
+
SetTitle("Online event in memory");
- SetName("Online Event");
+ SetName ("Online Event");
ElementChanged();
AfterNewEventLoaded();
+
+ if (fAutoLoad) StartAutoLoadTimer();
+}
+
+Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
+{
+ // Returns maximum available event id.
+ // If under external control or event is not opened -1 is returned.
+ // If raw-data is the only data-source this can not be known
+ // and 10,000,000 is returned.
+ // If neither data-source is initialised an exception is thrown.
+ // If refresh_esd is true and ESD is the primary event-data source
+ // its header is re-read from disk.
+
+ static const TEveException kEH("AliEveEventManager::GetMaxEventId ");
+
+ if (fExternalCtrl || fIsOpen == kFALSE)
+ {
+ return -1;
+ }
+
+ if (fESDTree)
+ {
+ // Refresh crashes with root-5.21.1-alice.
+ // Fixed by Philippe 5.8.2008 r25053, can be reactivated
+ // when we move to a newer root.
+ // if (refreshESD)
+ // fESDTree->Refresh();
+ return fESDTree->GetEntries() - 1;
+ }
+ else if (fRunLoader)
+ {
+ return fRunLoader->GetNumberOfEvents() - 1;
+ }
+ else if (fRawReader)
+ {
+ Int_t n = fRawReader->GetNumberOfEvents() - 1;
+ return n > -1 ? n : 10000000;
+ }
+ else
+ {
+ throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
+ }
}
void AliEveEventManager::GotoEvent(Int_t event)
// After successful loading of event, the virtual function
// AfterNewEventLoaded() is called. This executes commands that
// were registered via TEveEventManager::AddNewEventCommand().
+ //
+ // If event is negative, it is subtracted from the number of
+ // available events, thus passing -1 will load the last event.
+ // This is not supported when raw-data is the only data-source
+ // as the number of events is not known.
static const TEveException kEH("AliEveEventManager::GotoEvent ");
- if (event < 0) {
- Error(kEH, "event must be non-negative.");
- return;
+ if (fAutoLoadTimerRunning)
+ {
+ throw (kEH + "Event auto-load timer is running.");
}
+ if (fExternalCtrl)
+ {
+ throw (kEH + "Event-loop is under external control.");
+ }
+ else if (!fIsOpen)
+ {
+ throw (kEH + "Event-files not opened.");
+ }
+
+ fHasEvent = kFALSE;
Int_t maxEvent = 0;
- if (fRunLoader) {
- maxEvent = fRunLoader->GetNumberOfEvents() - 1;
- } else if (fESDTree) {
+ if (fESDTree)
+ {
+ // Refresh crashes with root-5.21.1-alice.
+ // Fixed by Philippe 5.8.2008 r25053, can be reactivated
+ // when we move to a newer root.
+ // fESDTree->Refresh();
maxEvent = fESDTree->GetEntries() - 1;
- } else if (fRawReader) {
- maxEvent = 10000000;
- Info(kEH, "number of events unknown for raw-data, setting max-event id to 10M.");
- } else {
+ if (event < 0)
+ event = fESDTree->GetEntries() + event;
+ }
+ else if (fRunLoader)
+ {
+ maxEvent = fRunLoader->GetNumberOfEvents() - 1;
+ if (event < 0)
+ event = fRunLoader->GetNumberOfEvents() + event;
+ }
+ else if (fRawReader)
+ {
+ maxEvent = fRawReader->GetNumberOfEvents() - 1;
+ if (maxEvent < 0)
+ {
+ maxEvent = 10000000;
+ if (event < 0) {
+ Error(kEH, "current raw-data source does not support direct event access.");
+ return;
+ }
+ Info(kEH, "number of events unknown for current raw-data source, setting max-event id to 10M.");
+ }
+ else
+ {
+ if (event < 0)
+ event = fRawReader->GetNumberOfEvents() + event;
+ }
+ }
+ else
+ {
throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
}
if (event < 0 || event > maxEvent)
+ {
throw (kEH + Form("event %d not present, available range [%d, %d].",
event, 0, maxEvent));
+ }
TEveManager::TRedrawDisabler rd(gEve);
gEve->Redraw3D(kFALSE, kTRUE); // Enforce drop of all logicals.
// additinal parents.
DestroyElements();
- if (fRunLoader) {
- if (fRunLoader->GetEvent(event) != 0)
- throw (kEH + "failed getting required event.");
- }
-
if (fESDTree) {
if (fESDTree->GetEntry(event) <= 0)
throw (kEH + "failed getting required event from ESD.");
fESD->SetESDfriend(fESDfriend);
}
+ if (fRunLoader) {
+ if (fRunLoader->GetEvent(event) != 0)
+ throw (kEH + "failed getting required event.");
+ }
+
if (fRawReader)
{
- Int_t rawEv = fEventId;
- if (event < rawEv)
- {
- fRawReader->RewindEvents();
- rawEv = -1;
- }
-
- while (rawEv < event)
+ // AliRawReader::GotoEvent(Int_t) works for AliRawReaderRoot/Chain.
+ if (fRawReader->GotoEvent(event) == kFALSE)
{
- if ( ! fRawReader->NextEvent())
+ // Use fallback method - iteration with NextEvent().
+ Int_t rawEv = fEventId;
+ if (event < rawEv)
{
fRawReader->RewindEvents();
- fEventId = -1;
- throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
+ rawEv = -1;
}
- ++rawEv;
- }
- printf ("Loaded raw-event %d.\n", rawEv);
+ while (rawEv < event)
+ {
+ if ( ! fRawReader->NextEvent())
+ {
+ fRawReader->RewindEvents();
+ fEventId = -1;
+ throw (kEH + Form("Error going to next raw-event from event %d.", rawEv));
+ }
+ ++rawEv;
+ }
+ Warning(kEH, "Loaded raw-event %d with fallback method.\n", rawEv);
+ }
}
- fEventId = event;
+ fHasEvent = kTRUE;
+ fEventId = event;
SetName(Form("Event %d", fEventId));
ElementChanged();
AfterNewEventLoaded();
}
+void AliEveEventManager::NextEvent()
+{
+ // Loads next event.
+ // Does magick needed for online display when under external event control.
+
+ static const TEveException kEH("AliEveEventManager::NextEvent ");
+
+ if (fAutoLoadTimerRunning)
+ {
+ throw (kEH + "Event auto-load timer is running.");
+ }
+
+ if (fExternalCtrl)
+ {
+ // !!! This should really go somewhere else. It is done in GotoEvent(),
+ // so here we should do it in SetEvent().
+ DestroyElements();
+
+ gSystem->ExitLoop();
+ }
+ else
+ {
+ if (fEventId < GetMaxEventId(kTRUE))
+ GotoEvent(fEventId + 1);
+ else
+ GotoEvent(0);
+ }
+}
+
+void AliEveEventManager::PrevEvent()
+{
+ // Loads previous event.
+
+ static const TEveException kEH("AliEveEventManager::PrevEvent ");
+
+ if (fAutoLoadTimerRunning)
+ {
+ throw (kEH + "Event auto-load timer is running.");
+ }
+ if (fExternalCtrl)
+ {
+ throw (kEH + "Event-loop is under external control.");
+ }
+
+ GotoEvent(fEventId - 1);
+}
+
void AliEveEventManager::Close()
{
- // Close the event files.
- // For the moment only ESD is closed. Needs to be investigated for
- // AliRunLoader and Raw.
+ // Close the event data-files and delete ESD, ESDfriend, run-loader
+ // and raw-reader.
+
+ static const TEveException kEH("AliEveEventManager::Close ");
+
+ if (!fIsOpen)
+ {
+ throw (kEH + "Event-files not opened.");
+ }
+
+ if (fAutoLoadTimerRunning)
+ StopAutoLoadTimer();
if (fESDTree) {
delete fESD; fESD = 0;
delete fESDfriend; fESDfriend = 0;
+ fESDfriendExists = kFALSE;
- delete fESDTree; fESDTree = 0;
- delete fESDFile; fESDFile = 0;
+ delete fESDTree; fESDTree = 0;
+ delete fESDFile; fESDFile = 0;
}
+
+ if (fRunLoader) {
+ delete fRunLoader; fRunLoader = 0;
+ }
+
+ if (fRawReader) {
+ delete fRawReader; fRawReader = 0;
+ }
+
+ fEventId = -1;
+ fIsOpen = kFALSE;
+ fHasEvent = kFALSE;
}
-/******************************************************************************/
+//------------------------------------------------------------------------------
// Static convenience functions, mainly used from macros.
-/******************************************************************************/
+//------------------------------------------------------------------------------
+
+Bool_t AliEveEventManager::HasRunLoader()
+{
+ // Check if AliRunLoader is initialized.
+
+ return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRunLoader;
+}
+
+Bool_t AliEveEventManager::HasESD()
+{
+ // Check if AliESDEvent is initialized.
+
+ return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESD;
+}
+
+Bool_t AliEveEventManager::HasESDfriend()
+{
+ // Check if AliESDfriend is initialized.
+
+ return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fESDfriend;
+}
+
+Bool_t AliEveEventManager::HasRawReader()
+{
+ // Check if raw-reader is initialized.
+
+ return gAliEveEvent && gAliEveEvent->fHasEvent && gAliEveEvent->fRawReader;
+}
AliRunLoader* AliEveEventManager::AssertRunLoader()
{
static const TEveException kEH("AliEveEventManager::AssertRunLoader ");
- if (gAliEveEvent == 0)
+ if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
throw (kEH + "ALICE event not ready.");
if (gAliEveEvent->fRunLoader == 0)
throw (kEH + "AliRunLoader not initialised.");
static const TEveException kEH("AliEveEventManager::AssertESD ");
- if (gAliEveEvent == 0)
+ if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
throw (kEH + "ALICE event not ready.");
if (gAliEveEvent->fESD == 0)
throw (kEH + "AliESD not initialised.");
static const TEveException kEH("AliEveEventManager::AssertESDfriend ");
- if (gAliEveEvent == 0)
+ if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
throw (kEH + "ALICE event not ready.");
if (gAliEveEvent->fESDfriend == 0)
throw (kEH + "AliESDfriend not initialised.");
static const TEveException kEH("AliEveEventManager::AssertRawReader ");
- if (gAliEveEvent == 0)
+ if (gAliEveEvent == 0 || gAliEveEvent->fHasEvent == kFALSE)
throw (kEH + "ALICE event not ready.");
if (gAliEveEvent->fRawReader == 0)
throw (kEH + "RawReader not ready.");
AliMagF* AliEveEventManager::AssertMagField()
{
- // Make sure AliMagF is initialized and return it.
+ // Make sure AliMagF is initialized and returns it.
+ // Run-loader must be initialized to get the correct magnetic field!
// Throws exception in case magnetic field is not available.
// Static utility for macros.
+ // !!!! This should be fixed ... get field also in some other way,
+ // not only via run-loader.
+
if (fgMagField == 0)
{
if (gAliEveEvent && gAliEveEvent->fRunLoader && gAliEveEvent->fRunLoader->GetAliRun())
::Warning(kEH, "mismatch of alignable volumes. Proceeding.");
// throw (kEH + "could not apply align objs.");
}
-
- // @@NEWROOT@@ Temporary fix.
- // In AliEve several simplified geometries can be loaded at a later stage.
- // Locking/unlocking is now handled properly in
- // TEveManager::GetGeometry() but we're waiting for next root
- // version due on 14.5.2008.
- TGeoManager::UnlockGeometry();
+ AliGeomManager::GetGeometry()->DefaultColors();
}
gGeoManager = AliGeomManager::GetGeometry();
return gGeoManager;
}
+
+//------------------------------------------------------------------------------
+// Autoloading of events
+//------------------------------------------------------------------------------
+
+void AliEveEventManager::SetAutoLoadTime(Float_t time)
+{
+ // Set the auto-load time in seconds
+
+ fAutoLoadTime = time;
+}
+
void AliEveEventManager::SetAutoLoad(Bool_t autoLoad)
{
// Set the automatic event loading mode
+
+ static const TEveException kEH("AliEveEventManager::SetAutoLoad ");
+
+ if (fAutoLoad == autoLoad)
+ {
+ Warning(kEH, "Setting autoload to the same value as before - %s. Ignoring.", fAutoLoad ? "true" : "false");
+ return;
+ }
+
fAutoLoad = autoLoad;
- StartStopAutoLoadTimer();
+ if (fAutoLoad)
+ {
+ StartAutoLoadTimer();
+ }
+ else
+ {
+ StopAutoLoadTimer();
+ }
}
-void AliEveEventManager::SetAutoLoadTime(Double_t time)
+void AliEveEventManager::StartAutoLoadTimer()
{
- // Set the auto-load time in seconds
- fAutoLoadTime = time;
- StartStopAutoLoadTimer();
+ // Start the auto-load timer.
+
+ fAutoLoadTimer->SetTime((Long_t)(1000*fAutoLoadTime));
+ fAutoLoadTimer->Reset();
+ fAutoLoadTimer->TurnOn();
+ fAutoLoadTimerRunning = kTRUE;
}
-void AliEveEventManager::StartStopAutoLoadTimer()
+void AliEveEventManager::StopAutoLoadTimer()
{
- // Create if needed and start
- // the automatic event loading timer
- if (fAutoLoad) {
- if (!fAutoLoadTimer) {
- fAutoLoadTimer = new TTimer;
- fAutoLoadTimer->Connect("Timeout()","AliEveEventManager",this,"NextEvent()");
- }
- fAutoLoadTimer->Start((Long_t)fAutoLoadTime*1000,kTRUE);
- }
- else {
- if (fAutoLoadTimer) fAutoLoadTimer->Stop();
- }
+ // Stop the auto-load timer.
+
+ fAutoLoadTimerRunning = kFALSE;
+ fAutoLoadTimer->TurnOff();
}
-void AliEveEventManager::PrevEvent()
+void AliEveEventManager::AutoLoadNextEvent()
{
- // Loads previous event
- // only in case of manual mode
- if (!fIsOnline) {
- GotoEvent(fEventId - 1);
- StartStopAutoLoadTimer();
+ // Called from auto-load timer, so it has to be public.
+ // Do NOT call it directly.
+
+ static const TEveException kEH("AliEveEventManager::AutoLoadNextEvent ");
+
+ if ( ! fAutoLoadTimerRunning || ! fAutoLoadTimer->HasTimedOut())
+ {
+ Warning(kEH, "Called unexpectedly - ignoring the call. Should ONLY be called from an internal timer.");
+ return;
}
+
+ StopAutoLoadTimer();
+ NextEvent();
+ if (fAutoLoad && !fExternalCtrl)
+ StartAutoLoadTimer();
}
-void AliEveEventManager::NextEvent()
+
+//------------------------------------------------------------------------------
+// Post event-loading functions
+//------------------------------------------------------------------------------
+
+void AliEveEventManager::AfterNewEventLoaded()
{
- // Loads next event
- // either in automatic (online) or
- // manual mode
-
- if (fIsOnline) {
- if (fAutoLoadTimer) fAutoLoadTimer->Stop();
+ // Execute registered macros and commands.
+ // At the end emit NewEventLoaded signal.
+ //
+ // Virtual from TEveEventManager.
- DestroyElements();
+ if (fExecutor)
+ fExecutor->ExecMacros();
- gSystem->ExitLoop();
+ TEveEventManager::AfterNewEventLoaded();
+
+ NewEventLoaded();
+}
+
+void AliEveEventManager::NewEventLoaded()
+{
+ // Emit NewEventLoaded signal.
+
+ Emit("NewEventLoaded()");
+}
+
+
+//------------------------------------------------------------------------------
+// Event info dumpers
+//------------------------------------------------------------------------------
+
+TString AliEveEventManager::GetEventInfoHorizontal() const
+{
+ // Dumps the event-header contents in vertical formatting.
+
+ TString rawInfo, esdInfo;
+
+ if (!fRawReader)
+ {
+ rawInfo = "No raw-data event info is available!\n";
+ }
+ else
+ {
+ const UInt_t* attr = fRawReader->GetAttributes();
+ TTimeStamp ts(fRawReader->GetTimestamp());
+ rawInfo.Form("RAW event info: Run#: %d Event type: %d (%s) Period: %x Orbit: %x BC: %x\n"
+ "Trigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x Timestamp: %s\n",
+ fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
+ fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
+ fRawReader->GetClassMask(),
+ *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
+ attr[0],attr[1],attr[2], ts.AsString("s"));
}
- else {
- GotoEvent(fEventId + 1);
- StartStopAutoLoadTimer();
+
+ if (!fESD)
+ {
+ esdInfo = "No ESD event info is available!";
+ }
+ else
+ {
+ TString acttrclasses = fESD->GetESDRun()->GetActiveTriggerClasses();
+ TString firedtrclasses = fESD->GetFiredTriggerClasses();
+ TTimeStamp ts(fESD->GetTimeStamp());
+ esdInfo.Form("ESD event info: Run#: %d Event type: %d (%s) Period: %x Orbit: %x BC: %x\n"
+ "Active trigger classes: %s\nTrigger: %llx (%s)\nEvent# in file: %d Timestamp: %s",
+ fESD->GetRunNumber(),
+ fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
+ fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
+ acttrclasses.Data(),
+ fESD->GetTriggerMask(),firedtrclasses.Data(),
+ fESD->GetEventNumberInFile(), ts.AsString("s"));
}
+
+ return rawInfo + esdInfo;
}
-const char* AliEveEventManager::GetEventInfo() const
+TString AliEveEventManager::GetEventInfoVertical() const
{
- // Dumps the event-header contents
+ // Dumps the event-header contents in vertical formatting.
- static TString eventInfo;
+ TString rawInfo, esdInfo;
- if (!fRawReader) return "No event information is available";
+ if (!fRawReader)
+ {
+ rawInfo = "No raw-data event info is available!\n";
+ }
+ else
+ {
+ const UInt_t* attr = fRawReader->GetAttributes();
+ rawInfo.Form("Raw-data event info:\nRun#: %d\nEvent type: %d (%s)\nPeriod: %x\nOrbit: %x BC: %x\nTrigger: %llx\nDetectors: %x (%s)\nAttributes:%x-%x-%x\nTimestamp: %x\n",
+ fRawReader->GetRunNumber(),fRawReader->GetType(),AliRawEventHeaderBase::GetTypeName(fRawReader->GetType()),
+ fRawReader->GetPeriod(),fRawReader->GetOrbitID(),fRawReader->GetBCID(),
+ fRawReader->GetClassMask(),
+ *fRawReader->GetDetectorPattern(),AliDAQ::ListOfTriggeredDetectors(*fRawReader->GetDetectorPattern()),
+ attr[0],attr[1],attr[2],
+ fRawReader->GetTimestamp());
+ }
- const UInt_t* id = fRawReader->GetEventId();
- const UInt_t* pattern = fRawReader->GetTriggerPattern();
- const UInt_t* attr = fRawReader->GetAttributes();
- eventInfo.Form("Run#: %d\nEvent type: %d\nPeriod: %x\nOrbit: %x\nBC: %x\nTrigger: %x-%x\nDetectors: %x\nAttributes:%x-%x-%x",
- fRawReader->GetRunNumber(),fRawReader->GetType(),
- (((id)[0]>>4)&0x0fffffff),((((id)[0]<<20)&0xf00000)|(((id)[1]>>12)&0xfffff)),((id)[1]&0x00000fff),
- pattern[0],pattern[1],
- *fRawReader->GetDetectorPattern(),
- attr[0],attr[1],attr[2]);
+ if (!fESD)
+ {
+ esdInfo = "No ESD event info is available!\n";
+ }
+ else
+ {
+ TString acttrclasses = fESD->GetESDRun()->GetActiveTriggerClasses();
+ TString firedtrclasses = fESD->GetFiredTriggerClasses();
+ esdInfo.Form("ESD event info:\nRun#: %d\nActive trigger classes: %s\nEvent type: %d (%s)\nPeriod: %x\nOrbit: %x BC: %x\nTrigger: %llx (%s)\nEvent# in file:%d\nTimestamp: %x\n",
+ fESD->GetRunNumber(),
+ acttrclasses.Data(),
+ fESD->GetEventType(),AliRawEventHeaderBase::GetTypeName(fESD->GetEventType()),
+ fESD->GetPeriodNumber(),fESD->GetOrbitNumber(),fESD->GetBunchCrossNumber(),
+ fESD->GetTriggerMask(),firedtrclasses.Data(),
+ fESD->GetEventNumberInFile(),
+ fESD->GetTimeStamp());
+ }
- return eventInfo.Data();
+ return rawInfo + "\n" + esdInfo;
}