AliEveEventManager
[u/mrichter/AliRoot.git] / EVE / EveBase / AliEveEventManager.h
1 // $Id$
2 // Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007
3
4 /**************************************************************************
5  * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
6  * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
7  * full copyright notice.                                                 *
8  **************************************************************************/
9
10 #ifndef AliEveEventManager_H
11 #define AliEveEventManager_H
12
13 #include <TEveEventManager.h>
14 #include <TQObject.h>
15 #include <TObjArray.h>
16 #include <AliESDEvent.h>
17
18 class AliEveMacroExecutor;
19
20 class AliRunLoader;
21 class AliESDEvent;
22 class AliESDfriend;
23 class AliRawReader;
24
25 class AliMagF;
26
27 class TFile;
28 class TTree;
29 class TGeoManager;
30
31 //==============================================================================
32 //
33 // AliEveEventManager
34 //
35 // Interface to ALICE event-data (RunLoader, ESD), magnetic field and
36 // geometry.
37 //
38
39
40 class AliEveEventManager : public TEveEventManager,
41                            public TQObject
42 {
43 public:
44   static void SetESDFileName(const TString& esd);
45   static void SetRawFileName(const TString& raw);
46   static void SetCdbUri     (const TString& cdb);
47   static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd, Bool_t assertRaw);
48
49   AliEveEventManager(const TString& name="Event");
50   AliEveEventManager(const TString& name, const TString& path, Int_t ev=0);
51   virtual ~AliEveEventManager();
52
53   virtual void  Open();
54   void          SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd);
55   virtual Int_t GetMaxEventId(Bool_t refreshESD=kFALSE) const;
56   virtual void  GotoEvent(Int_t event);
57   virtual void  NextEvent();
58   virtual void  PrevEvent();
59   virtual void  Close();
60   Bool_t        FindNextByTrigger(Int_t& i);
61   Bool_t        FindPrevByTrigger(Int_t& i);
62
63
64   Int_t         GetEventId()   const { return fEventId; }
65   AliRunLoader* GetRunLoader() const { return fRunLoader; }
66   TFile*        GetESDFile()   const { return fESDFile; }
67   TTree*        GetESDTree()   const { return fESDTree; }
68   AliESDEvent*  GetESD()       const { return fESD; }
69   AliESDfriend* GetESDfriend()       const { return fESDfriend; }
70   Bool_t        GetESDfriendExists() const { return fESDfriendExists; }
71   virtual const Text_t* GetTitle()   const { return fPath.Data(); }
72   TString       GetEventInfoHorizontal() const;
73   TString       GetEventInfoVertical()   const;
74
75   static Bool_t HasRunLoader();
76   static Bool_t HasESD();
77   static Bool_t HasESDfriend();
78   static Bool_t HasRawReader();
79
80   static AliRunLoader* AssertRunLoader();
81   static AliESDEvent*  AssertESD();
82   static AliESDfriend* AssertESDfriend();
83   static AliRawReader* AssertRawReader();
84
85   static AliMagF*      AssertMagField();
86
87   static TGeoManager*  AssertGeometry();
88
89   static AliEveEventManager* AddDependentManager(const TString& name, const TString& path);
90   static AliEveEventManager* GetDependentManager(const TString& name);
91
92   static AliEveEventManager* GetMaster();
93   static AliEveEventManager* GetCurrent();
94
95   Double_t      GetAutoLoadTime()        const { return fAutoLoadTime; }
96   Bool_t        GetAutoLoad()            const { return fAutoLoad;     }
97   void          SetAutoLoadTime(Float_t time);
98   void          SetAutoLoad(Bool_t autoLoad);
99   void          AutoLoadNextEvent();
100
101   Bool_t        GetSelectOnTriggerType()     const { return fSelectOnTriggerType; }
102   TString       GetTriggerType()             const { return fTriggerType; }
103   void          SetTriggerType(const TString& triggertype) { fTriggerType = triggertype; }
104   void          SetSelectOnTriggerType(Bool_t sel)         { fSelectOnTriggerType = sel; }
105
106   Bool_t        AreEventFilesOpened()    const { return fIsOpen;       }
107   Bool_t        IsEventAvailable()       const { return fHasEvent;     }
108   Bool_t        IsUnderExternalControl() const { return fExternalCtrl; }
109
110   virtual void  AfterNewEventLoaded();
111   void          NewEventLoaded();      // *SIGNAL*
112
113   AliEveMacroExecutor* GetExecutor() const { return fExecutor; }
114
115 protected:
116   TString       fPath;                  // URL to event-data.
117   Int_t         fEventId;               // Id of current event.
118
119   AliRunLoader* fRunLoader;             // Run loader.
120
121   TFile        *fESDFile;               // ESD file.
122   TTree        *fESDTree;               // ESD tree.
123   AliESDEvent  *fESD;                   // ESDEvent object.
124   AliESDfriend *fESDfriend;             // ESDfriend object.
125   Bool_t        fESDfriendExists;       // Flag specifying if ESDfriend was found during opening of the event-data.
126
127   AliRawReader *fRawReader;             // Raw-data reader.
128
129   Bool_t        fAutoLoad;              // Automatic loading of events (online)
130   Float_t       fAutoLoadTime;          // Auto-load time in seconds
131   TTimer       *fAutoLoadTimer;         // Timer for automatic event loading
132
133   Bool_t        fIsOpen;                // Are event-files opened.
134   Bool_t        fHasEvent;              // Is an event available.
135   Bool_t        fExternalCtrl;          // Are we under external event-loop.
136
137   Bool_t        fSelectOnTriggerType;   // Whether to select on trigger-type.
138   TString       fTriggerType;           // Trigger-type to select on.
139
140   AliEveMacroExecutor *fExecutor;       // Executor for std macros
141
142   TList        *fSubManagers;           // Dependent event-managers, used for event embedding.
143
144   static TString  fgESDFileName;        // Name by which to open ESD.
145   static TString  fgRawFileName;        // Name by which to open raw-data file.
146   static TString  fgCdbUri;             // Global URI to CDB.
147   static Bool_t   fgAssertRunLoader;    // Global flag specifying if AliRunLoader must be asserted during opening of the event-data.
148   static Bool_t   fgAssertESD;          // Global flag specifying if ESDEvent must be asserted during opening of the event-data.
149   static Bool_t   fgAssertRaw;          // Global flag specifying if raw-data presence must be asserted during opening of the event-data.
150
151   static AliMagF* fgMagField;           // Global pointer to magnetic field.
152
153 private:
154   AliEveEventManager(const AliEveEventManager&);            // Not implemented
155   AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented
156
157   void InitInternals();
158   void StartAutoLoadTimer();
159   void StopAutoLoadTimer();
160
161   Bool_t fAutoLoadTimerRunning; // State of auto-load timer.
162
163   static AliEveEventManager* fgMaster;
164   static AliEveEventManager* fgCurrent;
165
166   ClassDef(AliEveEventManager, 0); // Interface for getting all event components in a uniform way.
167 };
168
169 #endif