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