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();
  50   AliEveEventManager(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 void AddDependentManager(const TString& path);
  90
  91   static AliEveEventManager* GetMaster();
  92   static AliEveEventManager* GetCurrent();
  93
  94   Double_t      GetAutoLoadTime()        const { return fAutoLoadTime; }
  95   Bool_t        GetAutoLoad()            const { return fAutoLoad;     }
  96   void          SetAutoLoadTime(Float_t time);
  97   void          SetAutoLoad(Bool_t autoLoad);
  98   void          AutoLoadNextEvent();
  99
 100   Bool_t        GetSelectOnTriggerType()     const { return fSelectOnTriggerType; }
 101   TString       GetTriggerType()             const { return fTriggerType; }
 102   void          SetTriggerType(const TString& triggertype) { fTriggerType = triggertype; }
 103   void          SetSelectOnTriggerType(Bool_t sel)         { fSelectOnTriggerType = sel; }
 104
 105   Bool_t        AreEventFilesOpened()    const { return fIsOpen;       }
 106   Bool_t        IsEventAvailable()       const { return fHasEvent;     }
 107   Bool_t        IsUnderExternalControl() const { return fExternalCtrl; }
 108
 109   virtual void  AfterNewEventLoaded();
 110   void          NewEventLoaded();      // *SIGNAL*
 111
 112   AliEveMacroExecutor* GetExecutor() const { return fExecutor; }
 113
 114 protected:
 115   TString       fPath;                  // URL to event-data.
 116   Int_t         fEventId;               // Id of current event.
 117
 118   AliRunLoader* fRunLoader;             // Run loader.
 119
 120   TFile        *fESDFile;               // ESD file.
 121   TTree        *fESDTree;               // ESD tree.
 122   AliESDEvent  *fESD;                   // ESDEvent object.
 123   AliESDfriend *fESDfriend;             // ESDfriend object.
 124   Bool_t        fESDfriendExists;       // Flag specifying if ESDfriend was found during opening of the event-data.
 125
 126   AliRawReader *fRawReader;             // Raw-data reader.
 127
 128   Bool_t        fAutoLoad;              // Automatic loading of events (online)
 129   Float_t       fAutoLoadTime;          // Auto-load time in seconds
 130   TTimer       *fAutoLoadTimer;         // Timer for automatic event loading
 131
 132   Bool_t        fIsOpen;                // Are event-files opened.
 133   Bool_t        fHasEvent;              // Is an event available.
 134   Bool_t        fExternalCtrl;          // Are we under external event-loop.
 135
 136   Bool_t        fSelectOnTriggerType;   // Whether to select on trigger-type.
 137   TString       fTriggerType;           // Trigger-type to select on.
 138
 139   AliEveMacroExecutor *fExecutor;       // Executor for std macros
 140
 141   TList        *fSubManagers;           // Dependent event-managers, used for event embedding.
 142
 143   static TString  fgESDFileName;        // Name by which to open ESD.
 144   static TString  fgRawFileName;        // Name by which to open raw-data file.
 145   static TString  fgCdbUri;             // Global URI to CDB.
 146   static Bool_t   fgAssertRunLoader;    // Global flag specifying if AliRunLoader must be asserted during opening of the event-data.
 147   static Bool_t   fgAssertESD;          // Global flag specifying if ESDEvent must be asserted during opening of the event-data.
 148   static Bool_t   fgAssertRaw;          // Global flag specifying if raw-data presence must be asserted during opening of the event-data.
 149
 150   static AliMagF* fgMagField;           // Global pointer to magnetic field.
 151
 152 private:
 153   AliEveEventManager(const AliEveEventManager&);            // Not implemented
 154   AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented
 155
 156   void InitInternals();
 157   void StartAutoLoadTimer();
 158   void StopAutoLoadTimer();
 159
 160   Bool_t fAutoLoadTimerRunning; // State of auto-load timer.
 161
 162   static AliEveEventManager* fgMaster;
 163   static AliEveEventManager* fgCurrent;
 164
 165   ClassDef(AliEveEventManager, 0); // Interface for getting all event components in a uniform way.
 166 };
 167
 168 #endif