#include <AliRunLoader.h>
#include <AliRun.h>
+#include <AliESDRun.h>
#include <AliESDEvent.h>
#include <AliESDfriend.h>
+#include <AliAODEvent.h>
+
#include <AliDAQ.h>
#include <AliRawEventHeaderBase.h>
#include <AliRawReaderRoot.h>
//______________________________________________________________________________
//
// Provides interface for loading and navigating standard AliRoot data
-// (AliRunLoader), ESDs and RAW.
+// (AliRunLoader), ESD, AOD and RAW.
+//
+// ESDfriend is attached automatically, if the file is found.
+//
+// AODfriends are not attached automatically as there are several
+// possible files involved. To have a specific AODfriend attached, call
+// static method
+// AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
+// before initializing the event-manager.
//
// Also provides interface to magnetic-field and geometry. Mostly
// intended as wrappers over standard AliRoot functionality for
Bool_t AliEveEventManager::fgAssertRunLoader = kFALSE;
Bool_t AliEveEventManager::fgAssertESD = kFALSE;
+Bool_t AliEveEventManager::fgAssertAOD = kFALSE;
Bool_t AliEveEventManager::fgAssertRaw = kFALSE;
TString AliEveEventManager::fgESDFileName("AliESDs.root");
+TString AliEveEventManager::fgAODFileName("AliAOD.root");
TString AliEveEventManager::fgRawFileName("raw.root");
TString AliEveEventManager::fgCdbUri("local://$ALICE_ROOT");
AliMagF* AliEveEventManager::fgMagField = 0;
+TList* AliEveEventManager::fgAODfriends = 0;
+
AliEveEventManager* AliEveEventManager::fgMaster = 0;
AliEveEventManager* AliEveEventManager::fgCurrent = 0;
fRunLoader (0),
fESDFile (0), fESDTree (0), fESD (0),
fESDfriend (0), fESDfriendExists(kFALSE),
+ fAODFile (0), fAODTree (0), fAOD (0),
fRawReader (0),
fAutoLoad (kFALSE), fAutoLoadTime (5.), fAutoLoadTimer(0),
fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
fRunLoader (0),
fESDFile (0), fESDTree (0), fESD (0),
fESDfriend (0), fESDfriendExists(kFALSE),
+ fAODFile (0), fAODTree (0), fAOD (0),
fRawReader (0),
fAutoLoad (kFALSE), fAutoLoadTime (5), fAutoLoadTimer(0),
fIsOpen (kFALSE), fHasEvent (kFALSE), fExternalCtrl (kFALSE),
if ( ! esd.IsNull()) fgESDFileName = esd;
}
+void AliEveEventManager::SetAODFileName(const TString& aod)
+{
+ // Set file-name for opening AOD, default "AliAOD.root".
+
+ if ( ! aod.IsNull()) fgAODFileName = aod;
+}
+
+void AliEveEventManager::AddAODfriend(const TString& friendFileName)
+{
+ // Add new AOD friend file-name to be attached when opening AOD.
+ // This should include '.root', as in 'AliAOD.VertexingHF.root'.
+
+ if (fgAODfriends == 0)
+ {
+ fgAODfriends = new TList;
+ fgAODfriends->SetOwner(kTRUE);
+ }
+ fgAODfriends->Add(new TObjString(friendFileName));
+}
+
void AliEveEventManager::SetRawFileName(const TString& raw)
{
// Set file-name for opening of raw-data, default "raw.root"
if ( ! cdb.IsNull()) fgCdbUri = cdb;
}
-void AliEveEventManager::SetAssertElements(Bool_t assertRunloader,
- Bool_t assertEsd,
- Bool_t assertRaw)
+void AliEveEventManager::SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
+ Bool_t assertAod, Bool_t assertRaw)
{
// Set global flags that detrmine which parts of the event-data must
// be present when the event is opened.
fgAssertRunLoader = assertRunloader;
fgAssertESD = assertEsd;
+ fgAssertAOD = assertAod;
fgAssertRaw = assertRaw;
}
}
}
+ // Open AOD and registered friends
+
+ TString aodPath(Form("%s/%s", fPath.Data(), fgAODFileName.Data()));
+ if ((fAODFile = TFile::Open(aodPath)))
+ {
+ fAOD = new AliAODEvent();
+ fAODTree = (TTree*) fAODFile->Get("aodTree");
+ if (fAODTree != 0)
+ {
+ // Check if AODfriends exist and attach them.
+ TIter friends(fgAODfriends);
+ TObjString *name;
+ while ((name = (TObjString*) friends()) != 0)
+ {
+ TString p(Form("%s/%s", fPath.Data(), name->GetName()));
+ if (gSystem->AccessPathName(p, kReadPermission) == kFALSE)
+ {
+ fAODTree->AddFriend("aodTree", name->GetName());
+ }
+ }
+
+ fAOD->ReadFromTree(fAODTree);
+
+ if (fAODTree->GetEntry(0) <= 0)
+ {
+ delete fAODFile; fAODFile = 0;
+ delete fAOD; fAOD = 0;
+ Warning(kEH, "failed getting the first entry from addTree.");
+ }
+ else
+ {
+ if (runNo < 0)
+ runNo = fAOD->GetRunNumber();
+ }
+ }
+ else // aodtree == 0
+ {
+ delete fAODFile; fAODFile = 0;
+ delete fAOD; fAOD = 0;
+ Warning(kEH, "failed getting the aodTree.");
+ }
+ }
+ else // aod not readable
+ {
+ Warning(kEH, "can not read AOD file '%s'.", aodPath.Data());
+ }
+ if (fAODTree == 0)
+ {
+ if (fgAssertAOD)
+ {
+ throw (kEH + "AOD not initialized. Its precence was requested.");
+ } else {
+ Warning(kEH, "AOD not initialized.");
+ }
+ }
+
// Open RunLoader from galice.root
TString gaPath(Form("%s/galice.root", fPath.Data()));
}
}
+ // Initialize OCDB ... only in master event-manager
+
if (this == fgMaster)
{
AliCDBManager* cdb = AliCDBManager::Instance();
void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd)
{
- // Set an event from an external source
- // The method is used in the online visualisation
+ // Set an event from an external source.
+ // The method is used in the online visualisation.
+ // AOD is not supported.
static const TEveException kEH("AliEveEventManager::SetEvent ");
fRunLoader = runLoader;
fRawReader = rawReader;
fESD = esd;
+ fAOD = 0;
fEventId++;
fHasEvent = kTRUE;
// fESDTree->Refresh();
return fESDTree->GetEntries() - 1;
}
+ else if (fAODTree)
+ {
+ return fAODTree->GetEntries() - 1;
+ }
else if (fRunLoader)
{
return fRunLoader->GetNumberOfEvents() - 1;
}
else
{
- throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
+ throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
}
}
if (event < 0)
event = fESDTree->GetEntries() + event;
}
+ else if (fAODTree)
+ {
+ maxEvent = fAODTree->GetEntries() - 1;
+ if (event < 0)
+ event = fAODTree->GetEntries() + event;
+ }
else if (fRunLoader)
{
maxEvent = fRunLoader->GetNumberOfEvents() - 1;
fESD->SetESDfriend(fESDfriend);
}
+ if (fAODTree) {
+ if (fAODTree->GetEntry(event) <= 0)
+ throw (kEH + "failed getting required event from AOD.");
+ }
+
if (fRunLoader) {
if (fRunLoader->GetEvent(event) != 0)
throw (kEH + "failed getting required event.");
delete fESDFile; fESDFile = 0;
}
+ if (fAODTree) {
+ delete fAOD; fAOD = 0;
+
+ delete fAODTree; fAODTree = 0;
+ delete fAODFile; fAODFile = 0;
+ }
+
if (fRunLoader) {
delete fRunLoader; fRunLoader = 0;
}
return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fESDfriend;
}
+Bool_t AliEveEventManager::HasAOD()
+{
+ // Check if AliESDEvent is initialized.
+
+ return fgCurrent && fgCurrent->fHasEvent && fgCurrent->fAOD;
+}
+
Bool_t AliEveEventManager::HasRawReader()
{
// Check if raw-reader is initialized.
return fgCurrent->fESDfriend;
}
+AliAODEvent* AliEveEventManager::AssertAOD()
+{
+ // Make sure AliAODEvent is initialized and return it.
+ // Throws exception in case AOD is not available.
+ // Static utility for macros.
+
+ static const TEveException kEH("AliEveEventManager::AssertAOD ");
+
+ if (fgCurrent == 0 || fgCurrent->fHasEvent == kFALSE)
+ throw (kEH + "ALICE event not ready.");
+ if (fgCurrent->fAOD == 0)
+ throw (kEH + "AliAOD not initialised.");
+ return fgCurrent->fAOD;
+}
+
AliRawReader* AliEveEventManager::AssertRawReader()
{
// Make sure raw-reader is initialized and return it.
#include <TEveEventManager.h>
#include <TQObject.h>
#include <TObjArray.h>
-#include <AliESDEvent.h>
class AliEveMacroExecutor;
class AliRunLoader;
class AliESDEvent;
class AliESDfriend;
+class AliAODEvent;
class AliRawReader;
class AliMagF;
{
public:
static void SetESDFileName(const TString& esd);
+ 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 SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd, Bool_t assertRaw);
+ static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
+ Bool_t assertAod, Bool_t assertRaw);
AliEveEventManager(const TString& name="Event");
AliEveEventManager(const TString& name, const TString& path, Int_t ev=0);
Bool_t FindPrevByTrigger(Int_t& i);
- 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; }
+ 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; }
virtual const Text_t* GetTitle() const { return fPath.Data(); }
TString GetEventInfoHorizontal() const;
TString GetEventInfoVertical() const;
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();
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.
TList *fSubManagers; // Dependent event-managers, used for event embedding.
static TString fgESDFileName; // Name by which to open ESD.
+ 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 AliMagF* fgMagField; // Global pointer to magnetic field.
+ static AliMagF *fgMagField; // Global pointer to magnetic field.
+
+ static TList *fgAODfriends; // Global list of AOD friend names to be attached during opening of the event-data (empty by default).
private:
AliEveEventManager(const AliEveEventManager&); // Not implemented
#include "AliEveEventManagerEditor.h"
#include "AliEveEventManager.h"
-#include "TVirtualPad.h"
+#include <AliESDEvent.h>
+
+#include <TVirtualPad.h>
#include "TColor.h"
#include <TEveGValuators.h>
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *pv = esd->GetPrimaryVertex();
+ if ( ! pv->GetStatus()) {
+ Info("primary_vertex", "Primary vertex not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_cross(pv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *spdv = esd->GetPrimaryVertexSPD();
+ if ( ! spdv->GetStatus()) {
+ Info("primary_vertex_spd", "Primary vertex SPD not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_cross(spdv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX SPD");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *tpcv = esd->GetPrimaryVertexTPC();
+ if ( ! pv->GetStatus()) {
+ Info("primary_vertex_tpc", "Primary vertex TPC not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_cross(tpcv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX TPC");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *pv = esd->GetPrimaryVertex();
+ if ( ! pv->GetStatus()) {
+ Info("primary_vertex_ellipse", "Primary vertex not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_ellipse(pv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX Ellipse");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *spdv = esd->GetPrimaryVertexSPD();
+ if ( ! spdv->GetStatus()) {
+ Info("primary_vertex_ellipse_spd", "Primary vertex SPD not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_ellipse(spdv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX Ellipse SPD");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *tpcv = esd->GetPrimaryVertexTPC();
+ if ( ! pv->GetStatus()) {
+ Info("primary_vertex_ellipse_tpc", "Primary vertex TPC not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_ellipse(tpcv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX Ellipse TPC");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *pv = esd->GetPrimaryVertex();
+ if ( ! pv->GetStatus()) {
+ Info("primary_vertex_box", "Primary vertex not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_box(pv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX Box");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *spdv = esd->GetPrimaryVertexSPD();
+ if ( ! spdv->GetStatus()) {
+ Info("primary_vertex_box_spd", "Primary vertex SPD not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_box(spdv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX Box SPD");
{
AliESDEvent *esd = AliEveEventManager::AssertESD();
AliESDVertex *tpcv = esd->GetPrimaryVertexTPC();
+ if ( ! pv->GetStatus()) {
+ Info("primary_vertex_box_tpc", "Primary vertex TPC not available.");
+ return 0;
+ }
TEveStraightLineSet* ls = make_vertex_box(tpcv, use_sigma, fx, fy, fz);
ls->ApplyVizTag("PVTX Box TPC");
void alieve_init(const Text_t* path = ".", Int_t event=0,
const Text_t* esdfile = 0,
+ const Text_t* aodfile = 0,
const Text_t* rawfile = 0,
const Text_t* cdburi = 0,
Bool_t assert_runloader = kFALSE,
Bool_t assert_esd = kFALSE,
+ Bool_t assert_aod = kFALSE,
Bool_t assert_raw = kFALSE)
{
Info("alieve_init", "Adding standard macros.");
AliEveEventManager::SetESDFileName(esdfile);
AliEveEventManager::SetRawFileName(rawfile);
AliEveEventManager::SetCdbUri(cdburi);
- AliEveEventManager::SetAssertElements(assert_runloader, assert_esd, assert_raw);
+ AliEveEventManager::SetAssertElements(assert_runloader, assert_esd,
+ assert_aod, assert_raw);
// Open event
if (path != 0)
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff