Added ESDfriend Entry in Filedialog. Fix paths to filenames
[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
17 #include <AliEventInfo.h>
18
19 class AliEveMacroExecutor;
20 class AliEveEventSelector; 
21
22 class AliRunLoader;
23 class AliESDEvent;
24 class AliESDfriend;
25 class AliAODEvent;
26 class AliRawReader;
27
28 class AliGRPObject;
29 class AliRecoParam;
30 class AliMagF;
31
32 class TEveElement;
33 class TFile;
34 class TTree;
35 class TGeoManager;
36 class TString;
37 class TMap;
38
39 //==============================================================================
40 //
41 // AliEveEventManager
42 //
43 // Interface to ALICE event-data (RunLoader, ESD), magnetic field and
44 // geometry.
45 //
46
47
48 class AliEveEventManager : public TEveEventManager,
49                            public TQObject
50 {
51 public:
52   static void SetESDFileName(const TString& esd);
53   static void SetESDfriendFileName(const TString& esdf);
54   static void SetAODFileName(const TString& aod);
55   static void AddAODfriend  (const TString& friendFileName);
56   static void SetRawFileName(const TString& raw);
57   static void SetCdbUri     (const TString& cdb);
58   static void SetGAliceFileName(const TString& galice);
59   
60   // set Local Directory or URL where the files are located
61   // it can also be a path to root_archive.zip
62   // assumes the filenames of ESD, AOD, etc are standard ALICE names 
63   // (AliESDs.root, AliESDfriends.root, AliAOD.root, AliAODfriend.root, galice.root,raw.root) 
64   static void SetFilesPath(const TString& path); 
65   
66   static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd,
67                                 Bool_t assertAod, Bool_t assertRaw);
68   static void SearchRawForCentralReconstruction();
69
70   AliEveEventManager(const TString& name="Event", Int_t ev=0);
71   virtual ~AliEveEventManager();
72
73   virtual void  Open();
74   void          SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd, AliESDfriend *esdf);
75   virtual Int_t GetMaxEventId(Bool_t refreshESD=kFALSE) const;
76   virtual void  GotoEvent(Int_t event);
77   virtual void  NextEvent();
78   virtual void  PrevEvent(); 
79   virtual void  Close();
80   void Timeout(); // * SIGNAL*
81
82   Int_t         GetEventId()         const { return fEventId; }
83   AliRunLoader* GetRunLoader()       const { return fRunLoader; }
84   TFile*        GetESDFile()         const { return fESDFile; }
85   TTree*        GetESDTree()         const { return fESDTree; }
86   AliESDEvent*  GetESD()             const { return fESD;     }
87   AliESDfriend* GetESDfriend()       const { return fESDfriend; }
88   Bool_t        GetESDfriendExists() const { return fESDfriendExists; }
89   TFile*        GetAODFile()         const { return fAODFile; }
90   TTree*        GetAODTree()         const { return fAODTree; }
91   AliAODEvent*  GetAOD()             const { return fAOD;     }
92   AliEveEventSelector* GetEventSelector() const { return fPEventSelector; }
93   TString       GetEventInfoHorizontal() const;
94   TString       GetEventInfoVertical()   const;
95   const AliEventInfo*   GetEventInfo();
96
97   static Int_t  CurrentEventId();
98
99   static Bool_t HasRunLoader();
100   static Bool_t HasESD();
101   static Bool_t HasESDfriend();
102   static Bool_t HasAOD();
103   static Bool_t HasRawReader();
104
105   static AliRunLoader* AssertRunLoader();
106   static AliESDEvent*  AssertESD();
107   static AliESDfriend* AssertESDfriend();
108   static AliAODEvent*  AssertAOD();
109   static AliRawReader* AssertRawReader();
110
111   static AliMagF*      AssertMagField();
112   static TGeoManager*  AssertGeometry();
113   static AliRecoParam* AssertRecoParams();
114
115   static AliEveEventManager* AddDependentManager(const TString& name, const TString& path);
116   static AliEveEventManager* GetDependentManager(const TString& name);
117
118   static AliEveEventManager* GetMaster();
119   static AliEveEventManager* GetCurrent();
120
121   static void                RegisterTransient    (TEveElement* element);
122   static void                RegisterTransientList(TEveElement* element);
123
124
125   Double_t      GetAutoLoadTime()        const { return fAutoLoadTime; }
126   Bool_t        GetAutoLoad()            const { return fAutoLoad;     }
127   void          SetAutoLoadTime(Float_t time);
128   void          SetAutoLoad(Bool_t autoLoad);
129   void          SetTrigSel(Int_t trig);
130   void          AutoLoadNextEvent();
131
132   Bool_t        AreEventFilesOpened()    const { return fIsOpen;       }
133   Bool_t        IsEventAvailable()       const { return fHasEvent;     }
134   Bool_t        IsUnderExternalControl() const { return fExternalCtrl; }
135   
136   Bool_t        InsertGlobal(const TString& tag, TEveElement* model);
137   Bool_t        InsertGlobal(const TString& tag, TEveElement* model,
138                              Bool_t replace, Bool_t update);
139   TEveElement*  FindGlobal(const TString& tag);
140
141   virtual void  AfterNewEventLoaded();
142   void          NewEventDataLoaded();  // *SIGNAL*
143   void          NewEventLoaded();      // *SIGNAL*
144
145   AliEveMacroExecutor* GetExecutor() const { return fExecutor; }
146
147 protected:
148   Int_t         fEventId;               // Id of current event.
149
150   AliRunLoader* fRunLoader;             // Run loader.
151
152   TFile        *fESDFile;               // ESD file.
153   TTree        *fESDTree;               // ESD tree.
154   AliESDEvent  *fESD;                   // ESDEvent object.
155   AliESDfriend *fESDfriend;             // ESDfriend object.
156   Bool_t        fESDfriendExists;       // Flag specifying if ESDfriend was found during opening of the event-data.
157   TFile        *fAODFile;               // AOD file.
158   TTree        *fAODTree;               // AOD tree.
159   AliAODEvent  *fAOD;                   // AODEvent object.
160
161   AliRawReader *fRawReader;             // Raw-data reader.
162   AliEventInfo  fEventInfo;             // Current Event Info
163   
164   Bool_t        fAutoLoad;              // Automatic loading of events (online)
165   Float_t       fAutoLoadTime;          // Auto-load time in seconds
166   TTimer       *fAutoLoadTimer;         // Timer for automatic event loading
167
168   Bool_t        fIsOpen;                // Are event-files opened.
169   Bool_t        fHasEvent;              // Is an event available.
170   Bool_t        fExternalCtrl;          // Are we under external event-loop.
171
172   TMap*         fGlobal;
173   Bool_t        fGlobalReplace;         // Are global replace
174   Bool_t        fGlobalUpdate;          // Are global updates
175
176   AliEveMacroExecutor *fExecutor;       // Executor for std macros
177
178   TEveElementList     *fTransients;     // Container for additional transient (per event) elements.
179   TEveElementList     *fTransientLists; // Container for lists of transient (per event) elements.
180
181   AliEveEventSelector* fPEventSelector; // Event filter
182
183   TList        *fSubManagers;           // Dependent event-managers, used for event embedding.
184
185   static TString  fgGAliceFileName;        // galice.root file
186   static TString  fgESDFileName;        // Name by which to open ESD.
187   static TString  fgESDfriendsFileName;
188   static TString  fgAODFileName;        // Name by which to open AOD.
189   static TString  fgRawFileName;        // Name by which to open raw-data file.
190   static TString  fgCdbUri;             // Global URI to CDB.
191   static Bool_t   fgAssertRunLoader;    // Global flag specifying if AliRunLoader must be asserted during opening of the event-data.
192   static Bool_t   fgAssertESD;          // Global flag specifying if ESDEvent must be asserted during opening of the event-data.
193   static Bool_t   fgAssertAOD;          // Global flag specifying if AODEvent must be asserted during opening of the event-data.
194   static Bool_t   fgAssertRaw;          // Global flag specifying if raw-data presence must be asserted during opening of the event-data.
195
196   static TList   *fgAODfriends;         // Global list of AOD friend names to be attached during opening of the event-data (empty by default).
197
198   static Bool_t   fgRawFromStandardLoc; // Global flag to enable looking for raw data in ../../../raw/, as it is stored for central reco.
199
200   static Bool_t        fgGRPLoaded;     // Global run parameters loaded?
201   static AliMagF      *fgMagField;      // Global pointer to magnetic field.
202   static AliRecoParam* fgRecoParam;
203   static Bool_t        fgUniformField;  // Track with uniform field.
204
205 private:
206   AliEveEventManager(const AliEveEventManager&);            // Not implemented
207   AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented
208
209   void InitInternals();
210   void StartAutoLoadTimer();
211   void StopAutoLoadTimer();
212
213   static Bool_t InitGRP();
214   static Bool_t InitRecoParam();
215
216   Bool_t fAutoLoadTimerRunning; // State of auto-load timer.
217
218   static AliEveEventManager* fgMaster;
219   static AliEveEventManager* fgCurrent;
220
221   ClassDef(AliEveEventManager, 0); // Interface for getting all event components in a uniform way.
222 };
223
224 #endif