AliEveEventManager
authormtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Oct 2008 12:41:30 +0000 (12:41 +0000)
committermtadel <mtadel@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 17 Oct 2008 12:41:30 +0000 (12:41 +0000)
------------------
Add support for reading AODs and arbitrary AODfriends.

alieve_init.C
-------------
Add arguments for AOD file-name and assert AOD.

primary_vertex.C
----------------
Only import vertexen if their status is OK.
Print info message otherwise.

AliEveEventManagerEditor
------------------------
Add missing include (removed from AliEveEventManager.h).

EVE/EveBase/AliEveEventManager.cxx
EVE/EveBase/AliEveEventManager.h
EVE/EveBase/AliEveEventManagerEditor.cxx
EVE/alice-macros/primary_vertex.C
EVE/macros/alieve_init.C

index 4c533f1..c028471 100644 (file)
 
 #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
@@ -58,14 +69,18 @@ ClassImp(AliEveEventManager)
 
 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;
 
@@ -100,6 +115,7 @@ AliEveEventManager::AliEveEventManager(const TString& name) :
   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),
@@ -120,6 +136,7 @@ AliEveEventManager::AliEveEventManager(const TString& name, const TString& path,
   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),
@@ -160,6 +177,26 @@ void AliEveEventManager::SetESDFileName(const TString& esd)
   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"
@@ -173,15 +210,15 @@ void AliEveEventManager::SetCdbUri(const TString& cdb)
   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;
 }
 
@@ -296,6 +333,62 @@ void AliEveEventManager::Open()
     }
   }
 
+  // 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()));
@@ -388,6 +481,8 @@ void AliEveEventManager::Open()
     }
   }
 
+  // Initialize OCDB ... only in master event-manager
+
   if (this == fgMaster)
   {
     AliCDBManager* cdb = AliCDBManager::Instance();
@@ -410,8 +505,9 @@ void AliEveEventManager::Open()
 
 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 ");
 
@@ -424,6 +520,7 @@ void AliEveEventManager::SetEvent(AliRunLoader *runLoader, AliRawReader *rawRead
   fRunLoader = runLoader;
   fRawReader = rawReader;
   fESD       = esd;
+  fAOD       = 0;
 
   fEventId++;
   fHasEvent     = kTRUE;
@@ -464,6 +561,10 @@ Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
     //   fESDTree->Refresh();
     return fESDTree->GetEntries() - 1;
   }
+  else if (fAODTree)
+  {
+    return fAODTree->GetEntries() - 1;
+  }
   else if (fRunLoader)
   {
     return fRunLoader->GetNumberOfEvents() - 1;
@@ -475,7 +576,7 @@ Int_t AliEveEventManager::GetMaxEventId(Bool_t /*refreshESD*/) const
   }
   else
   {
-    throw (kEH + "neither RunLoader, ESD nor Raw loaded.");
+    throw (kEH + "neither ESD, AOD, RunLoader nor Raw loaded.");
   }
 }
 
@@ -521,6 +622,12 @@ void AliEveEventManager::GotoEvent(Int_t event)
     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;
@@ -571,6 +678,11 @@ void AliEveEventManager::GotoEvent(Int_t event)
       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.");
@@ -697,6 +809,13 @@ void AliEveEventManager::Close()
     delete fESDFile;   fESDFile = 0;
   }
 
+  if (fAODTree) {
+    delete fAOD;       fAOD       = 0;
+
+    delete fAODTree;   fAODTree = 0;
+    delete fAODFile;   fAODFile = 0;
+  }
+
   if (fRunLoader) {
     delete fRunLoader; fRunLoader = 0;
   }
@@ -736,6 +855,13 @@ Bool_t AliEveEventManager::HasESDfriend()
   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.
@@ -788,6 +914,21 @@ AliESDfriend* AliEveEventManager::AssertESDfriend()
   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.
index 160fdef..3c90e83 100644 (file)
 #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;
@@ -42,9 +42,12 @@ class AliEveEventManager : public TEveEventManager,
 {
 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);
@@ -61,13 +64,16 @@ public:
   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;
@@ -75,11 +81,13 @@ public:
   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();
@@ -123,6 +131,9 @@ protected:
   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.
 
@@ -142,13 +153,17 @@ protected:
   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
index 92f1aef..5823489 100644 (file)
@@ -10,7 +10,9 @@
 #include "AliEveEventManagerEditor.h"
 #include "AliEveEventManager.h"
 
-#include "TVirtualPad.h"
+#include <AliESDEvent.h>
+
+#include <TVirtualPad.h>
 #include "TColor.h"
 
 #include <TEveGValuators.h>
index 99fe06a..13ce5ae 100644 (file)
@@ -146,6 +146,10 @@ primary_vertex(Bool_t use_sigma=kTRUE, Float_t fx=1, Float_t fy=1, Float_t fz=1)
 {
   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");
@@ -159,6 +163,10 @@ primary_vertex_spd(Bool_t use_sigma=kTRUE, Float_t fx=1, Float_t fy=1, Float_t f
 {
   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");
@@ -172,6 +180,10 @@ primary_vertex_tpc(Bool_t use_sigma=kTRUE, Float_t fx=1, Float_t fy=1, Float_t f
 {
   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");
@@ -189,6 +201,10 @@ primary_vertex_ellipse(Bool_t use_sigma=kTRUE, Float_t fx=30, Float_t fy=30, Flo
 {
   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");
@@ -202,6 +218,10 @@ primary_vertex_ellipse_spd(Bool_t use_sigma=kTRUE, Float_t fx=30, Float_t fy=30,
 {
   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");
@@ -215,6 +235,10 @@ primary_vertex_ellipse_tpc(Bool_t use_sigma=kTRUE, Float_t fx=30, Float_t fy=30,
 {
   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");
@@ -232,6 +256,10 @@ primary_vertex_box(Bool_t use_sigma=kTRUE, Float_t fx=30, Float_t fy=30, Float_t
 {
   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");
@@ -245,6 +273,10 @@ primary_vertex_box_spd(Bool_t use_sigma=kTRUE, Float_t fx=30, Float_t fy=30, Flo
 {
   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");
@@ -258,6 +290,10 @@ primary_vertex_box_tpc(Bool_t use_sigma=kTRUE, Float_t fx=30, Float_t fy=30, Flo
 {
   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");
index 93584fa..cb4206d 100644 (file)
 
 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.");
@@ -33,7 +35,8 @@ void alieve_init(const Text_t* path   = ".", Int_t event=0,
   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)