Added support to display the HLT ESD Tree. See the comment in visscan_local.C for How
authorquark <quark@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Jul 2013 17:16:35 +0000 (17:16 +0000)
committerquark <quark@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 9 Jul 2013 17:16:35 +0000 (17:16 +0000)
EVE/EveBase/AliEveEventManager.cxx
EVE/EveBase/AliEveEventManager.h
EVE/EveBase/AliEveEventSelector.cxx
EVE/EveBase/AliEveEventSelector.h
EVE/macros/alieve_init.C
EVE/macros/alieve_loadlibs.C
EVE/macros/alieve_online.C
EVE/macros/visscan_init.C
EVE/macros/visscan_local.C

index 68f9e75..941aaa1 100644 (file)
@@ -96,6 +96,7 @@ Bool_t AliEveEventManager::fgAssertAOD       = kFALSE;
 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");
@@ -156,7 +157,7 @@ AliEveEventManager::AliEveEventManager(const TString& name, Int_t ev) :
 
     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(),
@@ -203,14 +204,15 @@ AliEveEventManager::~AliEveEventManager()
 
 /******************************************************************************/
 
-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)
@@ -271,25 +273,25 @@ void AliEveEventManager::SetGAliceFileName(const TString& galice)
     // 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())) );
@@ -348,60 +350,32 @@ void AliEveEventManager::Open()
     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)
         {
@@ -702,14 +676,27 @@ Int_t AliEveEventManager::GetMaxEventId(Bool_t refreshESD) const
         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)
     {
@@ -764,13 +751,24 @@ void AliEveEventManager::GotoEvent(Int_t event)
     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)
     {
@@ -841,6 +839,14 @@ void AliEveEventManager::GotoEvent(Int_t event)
             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.");
@@ -918,7 +924,7 @@ void AliEveEventManager::NextEvent()
         gSystem->ExitLoop();
 
     }
-    else if (fESDTree)
+    else if ((fESDTree!=0) || (fHLTESDTree!=0))
     {
         Int_t nextevent=0;
         if (fPEventSelector->FindNext(nextevent))
@@ -947,7 +953,7 @@ void AliEveEventManager::PrevEvent()
         throw (kEH + "Event-loop is under external control.");
     }
 
-    if (fESDTree)
+    if ((fESDTree!=0) || (fHLTESDTree!=0))
     {
         Int_t nextevent=0;
         if (fPEventSelector->FindPrev(nextevent))
@@ -976,13 +982,14 @@ void AliEveEventManager::Close()
     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;
     }
 
@@ -1222,7 +1229,7 @@ Bool_t AliEveEventManager::InitRecoParam()
     fgRecoParam = new AliRecoParam;
     const Int_t  kNDetectors = 14;
 
-    static const TEveException kEH("AliEveEventManager::InitRecoParam ");
+    static const TEveException kEH("AliEveEventManager::InitRecoParam");
 
     Bool_t isOK = kTRUE;
 
@@ -1309,6 +1316,58 @@ Bool_t AliEveEventManager::InitRecoParam()
     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;
+}
+
 
 //------------------------------------------------------------------------------
 
index df5b2f5..3afae67 100644 (file)
@@ -46,179 +46,186 @@ class TMap;
 
 
 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
index 8d0f157..c72387a 100644 (file)
@@ -29,289 +29,330 @@ ClassImp(AliEveEventSelector)
 
 //_____________________________________________________________________________
 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;
 }
 
index b787465..c7880d7 100644 (file)
@@ -71,6 +71,9 @@ public:
 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&);
index 3a1ef7d..fac6c54 100644 (file)
@@ -11,7 +11,7 @@
 /// \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,
@@ -37,7 +37,14 @@ void alieve_init(const TString& cdburi = "",
 
   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,
@@ -55,13 +62,13 @@ void alieve_init(const TString& cdburi = "",
       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);
       }
     }
   }
index 7502725..f867a78 100644 (file)
@@ -88,6 +88,7 @@ void alieve_loadlibs ()
   gSystem->Load("libTPCbase");
   gSystem->Load("libTPCrec");
   gSystem->Load("libTPCsim");
+  gSystem->Load("libTPCfast");
   gSystem->Load("libITSbase");
   gSystem->Load("libITSsim");
   gSystem->Load("libITSrec");
index ad32f78..5f48260 100644 (file)
@@ -388,11 +388,11 @@ void alieve_online_on_new_event()
 
     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()));
index b7c1177..20e79d3 100644 (file)
@@ -27,6 +27,7 @@ Bool_t gCenterProjectionsAtPrimaryVertex = kFALSE;
 
 void visscan_init(const TString& cdburi = "",
                  const TString& path   = ".",
+                 Bool_t showHLTESDTree=kFALSE,
                  Bool_t showMuon = kTRUE,
                  Bool_t showTrd = kFALSE)
 {
@@ -53,7 +54,7 @@ void visscan_init(const TString& cdburi = "",
   AliEveEventManager::AddAODfriend("AliAOD.VertexingHF.root");
 
   TEveUtil::LoadMacro("alieve_init.C");
-  alieve_init(cdburi, path, -1);
+  alieve_init(cdburi, path, -1, showHLTESDTree);
 
   // TEveLine::SetDefaultSmooth(1);
 
index 7e2119e..44011c6 100644 (file)
@@ -1,9 +1,12 @@
 #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));
 }