[u/mrichter/AliRoot.git] / EVE / EveBase / AliEveEventManager.h

// $Id$
// Main authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007

/**************************************************************************
 * Copyright(c) 1998-2008, ALICE Experiment at CERN, all rights reserved. *
 * See http://aliceinfo.cern.ch/Offline/AliRoot/License.html for          *
 * full copyright notice.                                                 *
 **************************************************************************/

#ifndef AliEveEventManaget_H
#define AliEveEventManager_H

#include <TEveEventManager.h>

class AliRunLoader;
class AliESDEvent;
class AliESDfriend;
class AliRawReader;

class AliMagF;

class TFile;
class TTree;
class TGeoManager;

//==============================================================================
//
// AliEveEventManager
//
// Interface to ALICE event-data (RunLoader, ESD), magnetic field and
// geometry.
//


class AliEveEventManager : public TEveEventManager
{
public:
  static void SetESDFileName(const Text_t* esd);
  static void SetRawFileName(const Text_t* raw);
  static void SetCdbUri(const Text_t* cdb);
  static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd, Bool_t assertRaw);

  AliEveEventManager();
  AliEveEventManager(TString path, Int_t ev=0);
  virtual ~AliEveEventManager();


  virtual void Open();
  void         SetEvent(AliRunLoader *runLoader, AliRawReader *rawReader, AliESDEvent *esd);
	    
  virtual void GotoEvent(Int_t event);
  virtual void NextEvent();
  virtual void PrevEvent();
  virtual void Close();

  Int_t         GetEventId()   const { return fEventId; }
  AliRunLoader* GetRunLoader() const { return fRunLoader; }
  TTree*        GetESDTree()   const { return fESDTree; }
  AliESDEvent*  GetESD()       const { return fESD; }
  AliESDfriend* GetESDfriend()       const { return fESDfriend; }
  Bool_t        GetESDfriendExists() const { return fESDfriendExists; }
  virtual const Text_t* GetTitle()   const { return fPath.Data(); }
  const char*   GetEventInfo() const;

  static AliRunLoader* AssertRunLoader();
  static AliESDEvent*  AssertESD();
  static AliESDfriend* AssertESDfriend();
  static AliRawReader* AssertRawReader();

  static AliMagF*      AssertMagField();

  static TGeoManager*  AssertGeometry();

  Bool_t        GetAutoLoad() const {return fAutoLoad;}
  Double_t      GetAutoLoadTime() const {return fAutoLoadTime;}
  void          SetAutoLoad(Bool_t autoLoad);
  void          SetAutoLoadTime(Double_t time);
  Bool_t        GetIsOnline() const {return fIsOnline;}

  void          StartStopAutoLoadTimer();

protected:
  TString       fPath;			// URL to event-data.
  Int_t         fEventId;		// Id of current event.

  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.

  AliRawReader* fRawReader;             // Raw-adata reader.

  Bool_t        fAutoLoad;              // Automatic loading of events (online)
  Double_t      fAutoLoadTime;          // Auto-load time in seconds
  TTimer       *fAutoLoadTimer;         // Timer for automatic event loading
  Bool_t        fIsOnline;              // Are we running online?

  static TString  fgESDFileName;        // Name by which to open ESD.
  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   fgAssertRaw;		// Global flag specifying if raw-data presence must be asserted during opening of the event-data.

  static AliMagF* fgMagField;		// Global pointer to magneti field.

private:
  AliEveEventManager(const AliEveEventManager&);            // Not implemented
  AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented

  ClassDef(AliEveEventManager, 0); // Interface for getting all event components in a uniform way.
};

extern AliEveEventManager* gAliEveEvent;

#endif
Commit	Line	Data
	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 AliEveEventManaget_H
	11	#define AliEveEventManager_H
	12
	13	#include <TEveEventManager.h>
	14
	15	class AliRunLoader;
	16	class AliESDEvent;
	17	class AliESDfriend;
	18	class AliRawReader;
	19
	20	class AliMagF;
	21
	22	class TFile;
	23	class TTree;
	24	class TGeoManager;
	25
	26	//==============================================================================
	27	//
	28	// AliEveEventManager
	29	//
	30	// Interface to ALICE event-data (RunLoader, ESD), magnetic field and
	31	// geometry.
	32	//
	33
	34
	35	class AliEveEventManager : public TEveEventManager
	36	{
	37	public:
	38	static void SetESDFileName(const Text_t* esd);
	39	static void SetRawFileName(const Text_t* raw);
	40	static void SetCdbUri(const Text_t* cdb);
	41	static void SetAssertElements(Bool_t assertRunloader, Bool_t assertEsd, Bool_t assertRaw);
	42
	43	AliEveEventManager();
	44	AliEveEventManager(TString path, Int_t ev=0);
	45	virtual ~AliEveEventManager();
	46
	47
	48	virtual void Open();
	49	void SetEvent(AliRunLoader runLoader, AliRawReader rawReader, AliESDEvent *esd);
	50
	51	virtual void GotoEvent(Int_t event);
	52	virtual void NextEvent();
	53	virtual void PrevEvent();
	54	virtual void Close();
	55
	56	Int_t GetEventId() const { return fEventId; }
	57	AliRunLoader* GetRunLoader() const { return fRunLoader; }
	58	TTree* GetESDTree() const { return fESDTree; }
	59	AliESDEvent* GetESD() const { return fESD; }
	60	AliESDfriend* GetESDfriend() const { return fESDfriend; }
	61	Bool_t GetESDfriendExists() const { return fESDfriendExists; }
	62	virtual const Text_t* GetTitle() const { return fPath.Data(); }
	63	const char* GetEventInfo() const;
	64
	65	static AliRunLoader* AssertRunLoader();
	66	static AliESDEvent* AssertESD();
	67	static AliESDfriend* AssertESDfriend();
	68	static AliRawReader* AssertRawReader();
	69
	70	static AliMagF* AssertMagField();
	71
	72	static TGeoManager* AssertGeometry();
	73
	74	Bool_t GetAutoLoad() const {return fAutoLoad;}
	75	Double_t GetAutoLoadTime() const {return fAutoLoadTime;}
	76	void SetAutoLoad(Bool_t autoLoad);
	77	void SetAutoLoadTime(Double_t time);
	78	Bool_t GetIsOnline() const {return fIsOnline;}
	79
	80	void StartStopAutoLoadTimer();
	81
	82	protected:
	83	TString fPath; // URL to event-data.
	84	Int_t fEventId; // Id of current event.
	85
	86	AliRunLoader* fRunLoader; // Run loader.
	87
	88	TFile* fESDFile; // ESD file.
	89	TTree* fESDTree; // ESD tree.
	90	AliESDEvent* fESD; // ESDEvent object.
	91	AliESDfriend* fESDfriend; // ESDfriend object.
	92	Bool_t fESDfriendExists; // Flag specifying if ESDfriend was found during opening of the event-data.
	93
	94	AliRawReader* fRawReader; // Raw-adata reader.
	95
	96	Bool_t fAutoLoad; // Automatic loading of events (online)
	97	Double_t fAutoLoadTime; // Auto-load time in seconds
	98	TTimer *fAutoLoadTimer; // Timer for automatic event loading
	99	Bool_t fIsOnline; // Are we running online?
	100
	101	static TString fgESDFileName; // Name by which to open ESD.
	102	static TString fgRawFileName; // Name by which to open raw-data file.
	103	static TString fgCdbUri; // Global URI to CDB.
	104	static Bool_t fgAssertRunLoader; // Global flag specifying if AliRunLoader must be asserted during opening of the event-data.
	105	static Bool_t fgAssertESD; // Global flag specifying if ESDEvent must be asserted during opening of the event-data.
	106	static Bool_t fgAssertRaw; // Global flag specifying if raw-data presence must be asserted during opening of the event-data.
	107
	108	static AliMagF* fgMagField; // Global pointer to magneti field.
	109
	110	private:
	111	AliEveEventManager(const AliEveEventManager&); // Not implemented
	112	AliEveEventManager& operator=(const AliEveEventManager&); // Not implemented
	113
	114	ClassDef(AliEveEventManager, 0); // Interface for getting all event components in a uniform way.
	115	};
	116
	117	extern AliEveEventManager* gAliEveEvent;
	118
	119	#endif