[u/mrichter/AliRoot.git] / RAW / AliRawEvent.h

#ifndef ALIRAWEVENT_H
#define ALIRAWEVENT_H
// @(#)alimdc:$Name$:$Id$
// Author: Fons Rademakers  26/11/99
// Updated: Dario Favretto  15/04/2003


#ifndef ROOT_TObject
#include <TObject.h>
#endif

#ifndef ROOT_TDatime
#include <TDatime.h>
#endif

#ifndef ROOT_TString
#include <TString.h>
#endif

#ifndef ROOT_TFile
#include <TFile.h>
#endif

#ifndef ROOT_TTree
#include <TTree.h>
#endif

#ifndef ROOT_TH1
#include <TH1.h>
#endif


// Forward class declarations
class AliRawDB;


// The following enumeration can be used once the kEventTypeMask has been
// applied to the raw event type
enum EAliRawEventType {
   kStartOfRun =       1,    // START_OF_RUN
   kEndOfRun =         2,    // END_OF_RUN
   kStartOfRunFiles =  3,    // START_OF_RUN_FILES
   kEndOfRunFiles =    4,    // END_OF_RUN_FILES
   kStartOfBurst =     5,    // START_OF_BURST
   kEndOfBurst =       6,    // END_OF_BURST
   kPhysicsEvent =     7,    // PHYSICS_EVENT
   kCalibrationEvent = 8,    // CALIBRATION_EVENT
   kFormatError =      9     // EVENT_FORMAT_ERROR
};

const Int_t kEventTypeMin = kStartOfRun;
const Int_t kEventTypeMax = kFormatError;

const UInt_t kEventMagicNumber        = 0xDA1E5AFE;
const UInt_t kEventMagicNumberSwapped = 0xFE5A1EDA;

// Type sizes
const Int_t kIdWords        = 2;
const Int_t kTriggerWords   = 2;
const Int_t kDetectorWords  = 1;
const Int_t kAttributeWords = 3;


class AliRawEventHeader : public TObject {

public:
   AliRawEventHeader() { fSize = 0; }
   virtual ~AliRawEventHeader() { }

   void         *HeaderBegin() { return (void *) &fSize; }
   Int_t         HeaderSize() const { return (Long_t) &fGDCId - (Long_t) &fSize + sizeof(fGDCId); }
   Bool_t        DataIsSwapped() const;
   Bool_t        IsSwapped() const { return (fMagic == kEventMagicNumberSwapped) ? kTRUE : kFALSE; }
   Bool_t        IsValid() const { return IsSwapped() ? kTRUE : ((fMagic == kEventMagicNumber) ? kTRUE : kFALSE); }
   void          Swap();

   UInt_t        GetEventSize() const { return fSize; }
   UInt_t        GetMagic() const { return fMagic; }
   UInt_t        GetHeaderLength() const { return fHeadLen; }
   UInt_t        GetVersion() const { return fVersion; }
   UInt_t        GetType() const { return fType; }
   const char   *GetTypeName() const;
   UInt_t        GetRunNumber() const { return fRunNb; }
   UInt_t        GetEventInRun() const;
   const UInt_t *GetId() const { return fId; }
   const UInt_t *GetTriggerPattern() const { return fTriggerPattern; }
   const UInt_t *GetDetectorPattern() const { return fDetectorPattern; }
   const UInt_t *GetTypeAttribute() const { return fTypeAttribute; }
   UInt_t        GetLDCId() const { return fLDCId; }
   UInt_t        GetGDCId() const { return fGDCId; }

private:
   UInt_t fSize;          // size of event in bytes
   UInt_t fMagic;         // magic number used for consistency check
   UInt_t fHeadLen;       // size of header in bytes
   UInt_t fVersion;       // unique version identifier
   UInt_t fType;          // event type
   UInt_t fRunNb;         // run number
   UInt_t fId[kIdWords];  // id field
   UInt_t fTriggerPattern[kTriggerWords];   // trigger pattern
   UInt_t fDetectorPattern[kDetectorWords]; // detector pattern
   UInt_t fTypeAttribute[kAttributeWords];  // system (0,1) and user (2) attributes
   UInt_t fLDCId;         // LDC id
   UInt_t fGDCId;         // GDC id

   ClassDef(AliRawEventHeader,1)  // Alice raw event header
};


class AliRawEquipmentHeader : public TObject {

public:
   AliRawEquipmentHeader() { fSize = 0; }
   ~AliRawEquipmentHeader() { }

   void         *HeaderBegin() { return (void *) &fSize; }
   Int_t         HeaderSize() const { return (Long_t) &fBasicElementSizeType - (Long_t) &fSize + sizeof(fBasicElementSizeType); }
   void          Swap();

   UInt_t        GetEquipmentSize() const { return fSize; }
   UInt_t        GetEquipmentType() const { return fEquipmentType; }
   UInt_t        GetId() const { return fEquipmentID; }
   const UInt_t *GetTypeAttribute() const { return fTypeAttribute; }
   UInt_t        GetBasicSizeType() const { return fBasicElementSizeType; }

private:
   UInt_t fSize;                            // number of raw data bytes
   UInt_t fEquipmentType;                   // equipment type
   UInt_t fEquipmentID;                     // equipment ID
   UInt_t fTypeAttribute[kAttributeWords];  // system (0,1) and user (2) attributes
   UInt_t fBasicElementSizeType;            // basic element size type

   ClassDef(AliRawEquipmentHeader,1) //Alice equipment header
};


class AliRawData : public TObject {

public:
   AliRawData() { fSize = fBufSize = 0; fRawData = 0; fOwner = kTRUE; }
   AliRawData(const AliRawData& rawData): TObject(rawData) 
     {Fatal("AliRawData", "copy constructor not implemented");};
   AliRawData& operator = (const AliRawData& /*rawData*/) {
     Fatal("operator =", "assignment operator not implemented"); 
     return *this;
   };
   virtual ~AliRawData() { if (fOwner) delete [] fRawData; }

   inline void SetSize(Int_t size);
   inline void  SetBuffer(void *buf, Int_t size);
   Int_t    GetSize() const { return fSize; }
   void    *GetBuffer() { return fRawData; }

private:
   Int_t   fSize;         // number of raw data bytes
   Int_t   fBufSize;      //!actual size of fRawData
   char   *fRawData;      //[fSize] raw event data
   Bool_t  fOwner;        //!if true object owns fRawData buffer

   ClassDef(AliRawData,1)  // Alice raw event buffer
};

void AliRawData::SetSize(Int_t size) 
{
  if (size > fBufSize) {
    if (fOwner) delete [] fRawData;
    fRawData = new char [size];
    fBufSize = size;
    fOwner   = kTRUE;
  }
  fSize = size;
}

void AliRawData::SetBuffer(void *buf, Int_t size) 
{
  if (fOwner) delete [] fRawData;
  fRawData = (char *) buf;
  fBufSize = size;
  fSize    = size;
  fOwner   = kFALSE;
}


class AliRawEvent : public TObject {

public:
   AliRawEvent();
   AliRawEvent(const AliRawEvent& rawEvent): TObject(rawEvent) 
     {Fatal("AliRawEvent", "copy constructor not implemented");};
   AliRawEvent& operator = (const AliRawEvent& /*rawEvent*/) {
     Fatal("operator =", "assignment operator not implemented"); 
     return *this;
   };
   virtual ~AliRawEvent();

   AliRawEventHeader     *GetHeader();
   AliRawEquipmentHeader *GetEquipmentHeader();
   AliRawData            *GetRawData();
   Int_t                  GetNSubEvents() const { return fNSubEvents; }
   AliRawEvent           *NextSubEvent();
   AliRawEvent           *GetSubEvent(Int_t index) const;
   void                   Reset();

private:
   Int_t                  fNSubEvents;  // number of valid sub-events
   AliRawEventHeader     *fEvtHdr;      // event header object
   AliRawEquipmentHeader *fEqpHdr;      // equipment header
   AliRawData            *fRawData;     // raw data container
   TObjArray             *fSubEvents;   // sub AliRawEvent's

   ClassDef(AliRawEvent,1)  // ALICE raw event object
};


class AliStats : public TObject {

public:
   AliStats(const char *filename = "", Int_t compmode = 0, Bool_t filter = kFALSE);
   AliStats(const AliStats& stats): TObject(stats) 
     {Fatal("AliStats", "copy constructor not implemented");};
   virtual ~AliStats();
   AliStats &operator=(const AliStats &rhs);

   void SetEvents(Int_t events) { fEvents = events; }
   void SetFirstId(Int_t run, Int_t event) { fFirstRun = run; fFirstEvent = event; }
   void SetLastId(Int_t run, Int_t event) { fLastRun = run; fLastEvent = event; }
   void SetBeginTime() { fBegin.Set(); }
   void SetEndTime() { fEnd.Set(); }
   void SetFileSize(Double_t size) { fFileSize = size; }
   void SetCompressionFactor(Float_t comp) { fCompFactor = comp; }
   void Fill(Float_t time);
   void WriteToDB(AliRawDB *rawdb);

   Int_t       GetEvents() const { return fEvents; }
   Int_t       GetFirstRun() const { return fFirstRun; }
   Int_t       GetFirstEvent() const { return fFirstEvent; }
   Int_t       GetLastRun() const { return fLastRun; }
   Int_t       GetLastEvent() const { return fLastEvent; }
   TDatime    &GetBeginTime() { return fBegin; }
   TDatime    &GetEndTime() { return fEnd; }
   Double_t    GetFileSize() const { return fFileSize; }
   Int_t       GetCompressionMode() const { return fCompMode; }
   Float_t     GetCompressionFactor() const { return fCompFactor; }
   Bool_t      GetFilterState() const { return fFilter; }
   const char *GetFileName() const { return fFileName; }
   TH1F       *GetRTHist() const { return fRTHist; }

private:
   Int_t    fEvents;     // number of events in this file
   Int_t    fFirstRun;   // run number of first event in file
   Int_t    fFirstEvent; // event number of first event in file
   Int_t    fLastRun;    // run number of last event in file
   Int_t    fLastEvent;  // event number of last event in file
   TDatime  fBegin;      // begin of filling time
   TDatime  fEnd;        // end of filling time
   TString  fFileName;   // name of file containing this data
   Double_t fFileSize;   // size of file
   Float_t  fCompFactor; // tree compression factor
   Int_t    fCompMode;   // compression mode
   Bool_t   fFilter;     // 3rd level filter on/off
   TH1F    *fRTHist;     // histogram of real-time to process chunck of data
   Float_t  fChunk;      //!chunk to be histogrammed

   ClassDef(AliStats,1)  // Statistics object
};


class AliRawDB : public TObject {

public:
   AliRawDB(AliRawEvent *event, Double_t maxsize, Int_t compress,
            Bool_t create = kTRUE);
   AliRawDB(const AliRawDB& rawDB): TObject(rawDB) 
     {Fatal("AliRawDB", "copy constructor not implemented");};
   AliRawDB& operator = (const AliRawDB& /*rawDB*/) {
     Fatal("operator =", "assignment operator not implemented"); 
     return *this;
   };
   virtual ~AliRawDB() { Close(); }

   virtual const char *GetOpenOption() const { return "RECREATE"; }
   virtual Bool_t      Create();
   virtual void        Close();
   void                Fill() { fTree->Fill(); }
   Bool_t              FileFull() { return (fRawDB->GetBytesWritten() > fMaxSize) ?
                                    kTRUE : kFALSE; }

   Bool_t       NextFile();

   Double_t     GetBytesWritten() const { return fRawDB->GetBytesWritten(); }
   TFile       *GetDB() const { return fRawDB; }
   const char  *GetDBName() const { return fRawDB->GetName(); }
   Int_t        GetEvents() const { return (Int_t) fTree->GetEntries(); }
   AliRawEvent *GetEvent() const { return fEvent; }
   Float_t      GetCompressionFactor() const;
   Int_t        GetCompressionMode() const { return fRawDB->GetCompressionLevel(); }

protected:
   TFile         *fRawDB;         // DB to store raw data
   TTree         *fTree;          // tree used to store raw data
   AliRawEvent   *fEvent;         // AliRawEvent via which data is stored
   Int_t          fCompress;      // compression mode (1 default)
   Double_t       fMaxSize;       // maximum size in bytes of the raw DB

   virtual const char *GetFileName() const;
   virtual Bool_t      FSHasSpace(const char *fs) const;
   virtual void        MakeTree();

   ClassDef(AliRawDB,0)  // Raw DB
};


class AliRawRFIODB : public AliRawDB {

public:
   AliRawRFIODB(AliRawEvent *event, Double_t maxsize, Int_t compress);
   ~AliRawRFIODB() { Close(); }

   void Close();

private:
   const char *GetFileName() const;

   ClassDef(AliRawRFIODB,0)  // Raw DB via RFIO
};


class AliRawCastorDB : public AliRawDB {

public:
   AliRawCastorDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
   ~AliRawCastorDB() { Close(); }

   const char *GetOpenOption() const { return "-RECREATE"; }
   void        Close();

private:
   const char *GetFileName() const;

   ClassDef(AliRawCastorDB,0)  // Raw DB via CASTOR and rootd
};


class AliRawRootdDB : public AliRawDB {

public:
   AliRawRootdDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
   ~AliRawRootdDB() { Close(); }

   void Close();

private:
   const char *GetFileName() const;

   ClassDef(AliRawRootdDB,0)  // Raw DB via rootd
};


class AliRawNullDB : public AliRawDB {

public:
   AliRawNullDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
   ~AliRawNullDB() { Close(); }

   void Close();

private:
   const char *GetFileName() const;

   ClassDef(AliRawNullDB,0)  // Raw DB to /dev/null
};


class AliTagDB : public TObject {

public:
   AliTagDB(AliRawEventHeader *header, Double_t maxsize, Bool_t create = kTRUE);
   AliTagDB(const AliTagDB& tagDB): TObject(tagDB) 
     {Fatal("AliTagDB", "copy constructor not implemented");};
   AliTagDB& operator = (const AliTagDB& /*tagDB*/) {
     Fatal("operator =", "assignment operator not implemented"); 
     return *this;
   };
   virtual ~AliTagDB() { Close(); }

   Bool_t          Create();
   virtual void    Close();
   void            Fill() { fTree->Fill(); }
   Bool_t          FileFull()
            { return (fTagDB->GetBytesWritten() > fMaxSize) ? kTRUE : kFALSE; }

   Bool_t          NextFile();

   Double_t           GetBytesWritten() const { return fTagDB->GetBytesWritten(); }
   TFile             *GetDB() const { return fTagDB; }
   const char        *GetDBName() const { return fTagDB->GetName(); }
   AliRawEventHeader *GetHeader() const { return fHeader; }
   Int_t              GetEvents() const { return (Int_t) fTree->GetEntries(); }
   Float_t            GetCompressionFactor() const;

protected:
   TFile             *fTagDB;     // DB to store header information only (tag)
   TTree             *fTree;      // tree use to store header
   AliRawEventHeader *fHeader;    // header via which data is stored
   Double_t           fMaxSize;   // maximum size in bytes of tag DB

   virtual const char *GetFileName() const;

   ClassDef(AliTagDB,0)  // Tag DB
};


class AliTagNullDB : public AliTagDB {

public:
   AliTagNullDB(AliRawEventHeader *header, Double_t maxsize);
   ~AliTagNullDB() { Close(); }

   void Close();

private:
   const char *GetFileName() const;

   ClassDef(AliTagNullDB,0)   // Tag DB to /dev/null
};


class AliRunDB : public TObject {

public:
   AliRunDB(Bool_t noLocalDB = kFALSE);
   AliRunDB(const AliRunDB& runDB): TObject(runDB) 
     {Fatal("AliRunDB", "copy constructor not implemented");};
   AliRunDB& operator = (const AliRunDB& /*runDB*/) {
     Fatal("operator =", "assignment operator not implemented"); 
     return *this;
   };
   ~AliRunDB() { Close(); }

   void Update(AliStats *stats);
   void UpdateRDBMS(AliStats *stats);
   void UpdateAliEn(AliStats *stats);
   void Close();

private:
   TFile  *fRunDB;     // run database

   ClassDef(AliRunDB,0)  // Run (bookkeeping) DB
};


class AliMDC : public TObject {

public:
   enum EWriteMode { kLOCAL, kRFIO, kROOTD, kCASTOR, kDEVNULL };

   AliMDC(Int_t fd, Int_t compress, Double_t maxFileSize, Bool_t useFilter,
          EWriteMode mode, Bool_t useLoop, Bool_t delFiles);
   ~AliMDC() { }

   Int_t  Run();
   void   SetStopLoop() { fStopLoop = kTRUE; }
   Bool_t StopLoop() const { return fStopLoop; }

   void   SetDebugLevel(Int_t level) { fDebugLevel = level; }
   Int_t  GetDebugLevel() const { return fDebugLevel; }

   static Bool_t DeleteFiles() { return fgDeleteFiles; }

private:
   Int_t      fFd;          // DATE input stream
   Int_t      fCompress;    // compression factor used for raw output DB
   Int_t      fNumEvents;   // number of events processed
   Int_t      fDebugLevel;  // controls debug print-out
   Double_t   fMaxFileSize; // maximum size of raw output DB
   EWriteMode fWriteMode;   // write mode (local, rfio, rootd, castor, /dev/null)
   Bool_t     fUseFifo;     // read from fifo, file otherwise
   Bool_t     fUseEb;       // use event builder API instead of fifo
   Bool_t     fUseFilter;   // use 3rd level trigger filter
   Bool_t     fUseLoop;     // loop on input source (must be file)
   Bool_t     fStopLoop;    // break from endless loop (triggered by SIGUSR1)

   static Bool_t fgDeleteFiles;  // flag for deletion of files

   Int_t     Read(const char *name) { return TObject::Read(name); }
   Int_t     Read(void *buffer, Int_t length);
   Int_t     ReadHeader(AliRawEventHeader &header, void *eb = 0);
   Int_t     ReadEquipmentHeader(AliRawEquipmentHeader &header,
                                 Bool_t isSwapped, void *eb = 0);
   Int_t     ReadRawData(AliRawData &raw, Int_t size, void *eb = 0);
   Int_t     DumpEvent(Int_t toRead);
   Int_t     Filter(AliRawData &raw);

   ClassDef(AliMDC,0)  // MDC processor
};

R__EXTERN AliMDC *gAliMDC;

#define ALIDEBUG(level) \
   if (gAliMDC && (gAliMDC->GetDebugLevel() >= (level)))

#endif
Commit	Line	Data
c689d2f6	1	#ifndef ALIRAWEVENT_H
c689d2f6	2	#define ALIRAWEVENT_H
5ea08be4	3	// @(#)alimdc:$Name$:$Id$
	4	// Author: Fons Rademakers 26/11/99
	5	// Updated: Dario Favretto 15/04/2003
	6
5ea08be4	7
	8	#ifndef ROOT_TObject
	9	#include <TObject.h>
	10	#endif
	11
5ea08be4	12	#ifndef ROOT_TDatime
	13	#include <TDatime.h>
	14	#endif
	15
	16	#ifndef ROOT_TString
	17	#include <TString.h>
	18	#endif
	19
	20	#ifndef ROOT_TFile
	21	#include <TFile.h>
	22	#endif
	23
	24	#ifndef ROOT_TTree
	25	#include <TTree.h>
	26	#endif
	27
04fa961a	28	#ifndef ROOT_TH1
	29	#include <TH1.h>
	30	#endif
	31
5ea08be4	32
5ea08be4	33	// Forward class declarations
5ea08be4	34	class AliRawDB;
	35
	36
	37	// The following enumeration can be used once the kEventTypeMask has been
	38	// applied to the raw event type
	39	enum EAliRawEventType {
	40	kStartOfRun = 1, // START_OF_RUN
	41	kEndOfRun = 2, // END_OF_RUN
	42	kStartOfRunFiles = 3, // START_OF_RUN_FILES
	43	kEndOfRunFiles = 4, // END_OF_RUN_FILES
	44	kStartOfBurst = 5, // START_OF_BURST
	45	kEndOfBurst = 6, // END_OF_BURST
	46	kPhysicsEvent = 7, // PHYSICS_EVENT
	47	kCalibrationEvent = 8, // CALIBRATION_EVENT
	48	kFormatError = 9 // EVENT_FORMAT_ERROR
	49	};
	50
	51	const Int_t kEventTypeMin = kStartOfRun;
	52	const Int_t kEventTypeMax = kFormatError;
	53
	54	const UInt_t kEventMagicNumber = 0xDA1E5AFE;
	55	const UInt_t kEventMagicNumberSwapped = 0xFE5A1EDA;
	56
	57	// Type sizes
	58	const Int_t kIdWords = 2;
	59	const Int_t kTriggerWords = 2;
	60	const Int_t kDetectorWords = 1;
	61	const Int_t kAttributeWords = 3;
	62
	63
	64	class AliRawEventHeader : public TObject {
	65
5ea08be4	66	public:
	67	AliRawEventHeader() { fSize = 0; }
	68	virtual ~AliRawEventHeader() { }
	69
	70	void HeaderBegin() { return (void ) &fSize; }
	71	Int_t HeaderSize() const { return (Long_t) &fGDCId - (Long_t) &fSize + sizeof(fGDCId); }
	72	Bool_t DataIsSwapped() const;
	73	Bool_t IsSwapped() const { return (fMagic == kEventMagicNumberSwapped) ? kTRUE : kFALSE; }
	74	Bool_t IsValid() const { return IsSwapped() ? kTRUE : ((fMagic == kEventMagicNumber) ? kTRUE : kFALSE); }
	75	void Swap();
	76
	77	UInt_t GetEventSize() const { return fSize; }
	78	UInt_t GetMagic() const { return fMagic; }
	79	UInt_t GetHeaderLength() const { return fHeadLen; }
	80	UInt_t GetVersion() const { return fVersion; }
	81	UInt_t GetType() const { return fType; }
	82	const char *GetTypeName() const;
	83	UInt_t GetRunNumber() const { return fRunNb; }
	84	UInt_t GetEventInRun() const;
	85	const UInt_t *GetId() const { return fId; }
	86	const UInt_t *GetTriggerPattern() const { return fTriggerPattern; }
	87	const UInt_t *GetDetectorPattern() const { return fDetectorPattern; }
	88	const UInt_t *GetTypeAttribute() const { return fTypeAttribute; }
	89	UInt_t GetLDCId() const { return fLDCId; }
	90	UInt_t GetGDCId() const { return fGDCId; }
	91
c689d2f6	92	private:
	93	UInt_t fSize; // size of event in bytes
	94	UInt_t fMagic; // magic number used for consistency check
	95	UInt_t fHeadLen; // size of header in bytes
	96	UInt_t fVersion; // unique version identifier
	97	UInt_t fType; // event type
	98	UInt_t fRunNb; // run number
	99	UInt_t fId[kIdWords]; // id field
	100	UInt_t fTriggerPattern[kTriggerWords]; // trigger pattern
	101	UInt_t fDetectorPattern[kDetectorWords]; // detector pattern
	102	UInt_t fTypeAttribute[kAttributeWords]; // system (0,1) and user (2) attributes
	103	UInt_t fLDCId; // LDC id
	104	UInt_t fGDCId; // GDC id
	105
5ea08be4	106	ClassDef(AliRawEventHeader,1) // Alice raw event header
	107	};
	108
	109
	110	class AliRawEquipmentHeader : public TObject {
	111
5ea08be4	112	public:
	113	AliRawEquipmentHeader() { fSize = 0; }
	114	~AliRawEquipmentHeader() { }
	115
	116	void HeaderBegin() { return (void ) &fSize; }
	117	Int_t HeaderSize() const { return (Long_t) &fBasicElementSizeType - (Long_t) &fSize + sizeof(fBasicElementSizeType); }
	118	void Swap();
	119
	120	UInt_t GetEquipmentSize() const { return fSize; }
	121	UInt_t GetEquipmentType() const { return fEquipmentType; }
	122	UInt_t GetId() const { return fEquipmentID; }
	123	const UInt_t *GetTypeAttribute() const { return fTypeAttribute; }
	124	UInt_t GetBasicSizeType() const { return fBasicElementSizeType; }
	125
c689d2f6	126	private:
	127	UInt_t fSize; // number of raw data bytes
	128	UInt_t fEquipmentType; // equipment type
	129	UInt_t fEquipmentID; // equipment ID
	130	UInt_t fTypeAttribute[kAttributeWords]; // system (0,1) and user (2) attributes
	131	UInt_t fBasicElementSizeType; // basic element size type
	132
5ea08be4	133	ClassDef(AliRawEquipmentHeader,1) //Alice equipment header
	134	};
	135
	136
	137	class AliRawData : public TObject {
	138
5ea08be4	139	public:
8f66d77e	140	AliRawData() { fSize = fBufSize = 0; fRawData = 0; fOwner = kTRUE; }
c689d2f6	141	AliRawData(const AliRawData& rawData): TObject(rawData)
	142	{Fatal("AliRawData", "copy constructor not implemented");};
	143	AliRawData& operator = (const AliRawData& /rawData/) {
	144	Fatal("operator =", "assignment operator not implemented");
	145	return *this;
	146	};
5ea08be4	147	virtual ~AliRawData() { if (fOwner) delete [] fRawData; }
5ea08be4	148
c689d2f6	149	inline void SetSize(Int_t size);
c689d2f6	150	inline void SetBuffer(void *buf, Int_t size);
5ea08be4	151	Int_t GetSize() const { return fSize; }
	152	void *GetBuffer() { return fRawData; }
	153
c689d2f6	154	private:
	155	Int_t fSize; // number of raw data bytes
	156	Int_t fBufSize; //!actual size of fRawData
	157	char *fRawData; //[fSize] raw event data
	158	Bool_t fOwner; //!if true object owns fRawData buffer
	159
5ea08be4	160	ClassDef(AliRawData,1) // Alice raw event buffer
	161	};
	162
c689d2f6	163	void AliRawData::SetSize(Int_t size)
	164	{
	165	if (size > fBufSize) {
	166	if (fOwner) delete [] fRawData;
	167	fRawData = new char [size];
	168	fBufSize = size;
	169	fOwner = kTRUE;
	170	}
	171	fSize = size;
	172	}
	173
	174	void AliRawData::SetBuffer(void *buf, Int_t size)
	175	{
	176	if (fOwner) delete [] fRawData;
	177	fRawData = (char *) buf;
	178	fBufSize = size;
	179	fSize = size;
	180	fOwner = kFALSE;
	181	}
5ea08be4	182
5ea08be4	183
c689d2f6	184	class AliRawEvent : public TObject {
5ea08be4	185
	186	public:
	187	AliRawEvent();
c689d2f6	188	AliRawEvent(const AliRawEvent& rawEvent): TObject(rawEvent)
	189	{Fatal("AliRawEvent", "copy constructor not implemented");};
	190	AliRawEvent& operator = (const AliRawEvent& /rawEvent/) {
	191	Fatal("operator =", "assignment operator not implemented");
	192	return *this;
	193	};
5ea08be4	194	virtual ~AliRawEvent();
5ea08be4	195
c51de60d	196	AliRawEventHeader *GetHeader();
5ea08be4	197	AliRawEquipmentHeader *GetEquipmentHeader();
	198	AliRawData *GetRawData();
	199	Int_t GetNSubEvents() const { return fNSubEvents; }
	200	AliRawEvent *NextSubEvent();
5459c838	201	AliRawEvent *GetSubEvent(Int_t index) const;
5ea08be4	202	void Reset();
5ea08be4	203
c689d2f6	204	private:
	205	Int_t fNSubEvents; // number of valid sub-events
	206	AliRawEventHeader *fEvtHdr; // event header object
	207	AliRawEquipmentHeader *fEqpHdr; // equipment header
	208	AliRawData *fRawData; // raw data container
	209	TObjArray *fSubEvents; // sub AliRawEvent's
	210
5ea08be4	211	ClassDef(AliRawEvent,1) // ALICE raw event object
	212	};
	213
	214
	215	class AliStats : public TObject {
	216
5ea08be4	217	public:
5ea08be4	218	AliStats(const char *filename = "", Int_t compmode = 0, Bool_t filter = kFALSE);
c689d2f6	219	AliStats(const AliStats& stats): TObject(stats)
c689d2f6	220	{Fatal("AliStats", "copy constructor not implemented");};
5ea08be4	221	virtual ~AliStats();
	222	AliStats &operator=(const AliStats &rhs);
	223
	224	void SetEvents(Int_t events) { fEvents = events; }
	225	void SetFirstId(Int_t run, Int_t event) { fFirstRun = run; fFirstEvent = event; }
	226	void SetLastId(Int_t run, Int_t event) { fLastRun = run; fLastEvent = event; }
	227	void SetBeginTime() { fBegin.Set(); }
	228	void SetEndTime() { fEnd.Set(); }
	229	void SetFileSize(Double_t size) { fFileSize = size; }
	230	void SetCompressionFactor(Float_t comp) { fCompFactor = comp; }
	231	void Fill(Float_t time);
	232	void WriteToDB(AliRawDB *rawdb);
	233
	234	Int_t GetEvents() const { return fEvents; }
	235	Int_t GetFirstRun() const { return fFirstRun; }
	236	Int_t GetFirstEvent() const { return fFirstEvent; }
	237	Int_t GetLastRun() const { return fLastRun; }
	238	Int_t GetLastEvent() const { return fLastEvent; }
	239	TDatime &GetBeginTime() { return fBegin; }
	240	TDatime &GetEndTime() { return fEnd; }
	241	Double_t GetFileSize() const { return fFileSize; }
	242	Int_t GetCompressionMode() const { return fCompMode; }
	243	Float_t GetCompressionFactor() const { return fCompFactor; }
	244	Bool_t GetFilterState() const { return fFilter; }
	245	const char *GetFileName() const { return fFileName; }
	246	TH1F *GetRTHist() const { return fRTHist; }
	247
c689d2f6	248	private:
	249	Int_t fEvents; // number of events in this file
	250	Int_t fFirstRun; // run number of first event in file
	251	Int_t fFirstEvent; // event number of first event in file
	252	Int_t fLastRun; // run number of last event in file
	253	Int_t fLastEvent; // event number of last event in file
	254	TDatime fBegin; // begin of filling time
	255	TDatime fEnd; // end of filling time
	256	TString fFileName; // name of file containing this data
	257	Double_t fFileSize; // size of file
	258	Float_t fCompFactor; // tree compression factor
	259	Int_t fCompMode; // compression mode
	260	Bool_t fFilter; // 3rd level filter on/off
	261	TH1F *fRTHist; // histogram of real-time to process chunck of data
	262	Float_t fChunk; //!chunk to be histogrammed
	263
5ea08be4	264	ClassDef(AliStats,1) // Statistics object
	265	};
	266
	267
	268	class AliRawDB : public TObject {
	269
5ea08be4	270	public:
	271	AliRawDB(AliRawEvent *event, Double_t maxsize, Int_t compress,
	272	Bool_t create = kTRUE);
c689d2f6	273	AliRawDB(const AliRawDB& rawDB): TObject(rawDB)
	274	{Fatal("AliRawDB", "copy constructor not implemented");};
	275	AliRawDB& operator = (const AliRawDB& /rawDB/) {
	276	Fatal("operator =", "assignment operator not implemented");
	277	return *this;
	278	};
	279	virtual ~AliRawDB() { Close(); }
5ea08be4	280
06c6fef1	281	virtual const char *GetOpenOption() const { return "RECREATE"; }
	282	virtual Bool_t Create();
	283	virtual void Close();
	284	void Fill() { fTree->Fill(); }
	285	Bool_t FileFull() { return (fRawDB->GetBytesWritten() > fMaxSize) ?
	286	kTRUE : kFALSE; }
5ea08be4	287
06c6fef1	288	Bool_t NextFile();
5ea08be4	289
	290	Double_t GetBytesWritten() const { return fRawDB->GetBytesWritten(); }
	291	TFile *GetDB() const { return fRawDB; }
	292	const char *GetDBName() const { return fRawDB->GetName(); }
	293	Int_t GetEvents() const { return (Int_t) fTree->GetEntries(); }
	294	AliRawEvent *GetEvent() const { return fEvent; }
	295	Float_t GetCompressionFactor() const;
	296	Int_t GetCompressionMode() const { return fRawDB->GetCompressionLevel(); }
	297
c689d2f6	298	protected:
	299	TFile *fRawDB; // DB to store raw data
	300	TTree *fTree; // tree used to store raw data
	301	AliRawEvent *fEvent; // AliRawEvent via which data is stored
	302	Int_t fCompress; // compression mode (1 default)
	303	Double_t fMaxSize; // maximum size in bytes of the raw DB
	304
	305	virtual const char *GetFileName() const;
	306	virtual Bool_t FSHasSpace(const char *fs) const;
	307	virtual void MakeTree();
	308
5ea08be4	309	ClassDef(AliRawDB,0) // Raw DB
	310	};
	311
	312
	313	class AliRawRFIODB : public AliRawDB {
	314
5ea08be4	315	public:
	316	AliRawRFIODB(AliRawEvent *event, Double_t maxsize, Int_t compress);
	317	~AliRawRFIODB() { Close(); }
	318
	319	void Close();
	320
c689d2f6	321	private:
	322	const char *GetFileName() const;
	323
5ea08be4	324	ClassDef(AliRawRFIODB,0) // Raw DB via RFIO
	325	};
	326
	327
9174317d	328	class AliRawCastorDB : public AliRawDB {
9174317d	329
9174317d	330	public:
	331	AliRawCastorDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
	332	~AliRawCastorDB() { Close(); }
	333
06c6fef1	334	const char *GetOpenOption() const { return "-RECREATE"; }
06c6fef1	335	void Close();
9174317d	336
c689d2f6	337	private:
	338	const char *GetFileName() const;
	339
9174317d	340	ClassDef(AliRawCastorDB,0) // Raw DB via CASTOR and rootd
	341	};
	342
	343
5ea08be4	344	class AliRawRootdDB : public AliRawDB {
5ea08be4	345
5ea08be4	346	public:
	347	AliRawRootdDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
	348	~AliRawRootdDB() { Close(); }
	349
	350	void Close();
	351
c689d2f6	352	private:
	353	const char *GetFileName() const;
	354
5ea08be4	355	ClassDef(AliRawRootdDB,0) // Raw DB via rootd
	356	};
	357
	358
	359	class AliRawNullDB : public AliRawDB {
	360
5ea08be4	361	public:
	362	AliRawNullDB(AliRawEvent *event, Double_t maxsize, Int_t compress);
	363	~AliRawNullDB() { Close(); }
	364
	365	void Close();
	366
c689d2f6	367	private:
	368	const char *GetFileName() const;
	369
5ea08be4	370	ClassDef(AliRawNullDB,0) // Raw DB to /dev/null
	371	};
	372
	373
	374	class AliTagDB : public TObject {
	375
5ea08be4	376	public:
5ea08be4	377	AliTagDB(AliRawEventHeader *header, Double_t maxsize, Bool_t create = kTRUE);
c689d2f6	378	AliTagDB(const AliTagDB& tagDB): TObject(tagDB)
	379	{Fatal("AliTagDB", "copy constructor not implemented");};
	380	AliTagDB& operator = (const AliTagDB& /tagDB/) {
	381	Fatal("operator =", "assignment operator not implemented");
	382	return *this;
	383	};
	384	virtual ~AliTagDB() { Close(); }
5ea08be4	385
	386	Bool_t Create();
	387	virtual void Close();
	388	void Fill() { fTree->Fill(); }
	389	Bool_t FileFull()
	390	{ return (fTagDB->GetBytesWritten() > fMaxSize) ? kTRUE : kFALSE; }
	391
	392	Bool_t NextFile();
	393
	394	Double_t GetBytesWritten() const { return fTagDB->GetBytesWritten(); }
	395	TFile *GetDB() const { return fTagDB; }
	396	const char *GetDBName() const { return fTagDB->GetName(); }
	397	AliRawEventHeader *GetHeader() const { return fHeader; }
	398	Int_t GetEvents() const { return (Int_t) fTree->GetEntries(); }
	399	Float_t GetCompressionFactor() const;
	400
c689d2f6	401	protected:
	402	TFile *fTagDB; // DB to store header information only (tag)
	403	TTree *fTree; // tree use to store header
	404	AliRawEventHeader *fHeader; // header via which data is stored
	405	Double_t fMaxSize; // maximum size in bytes of tag DB
	406
	407	virtual const char *GetFileName() const;
	408
5ea08be4	409	ClassDef(AliTagDB,0) // Tag DB
	410	};
	411
	412
	413	class AliTagNullDB : public AliTagDB {
	414
5ea08be4	415	public:
	416	AliTagNullDB(AliRawEventHeader *header, Double_t maxsize);
	417	~AliTagNullDB() { Close(); }
	418
	419	void Close();
	420
c689d2f6	421	private:
	422	const char *GetFileName() const;
	423
5ea08be4	424	ClassDef(AliTagNullDB,0) // Tag DB to /dev/null
	425	};
	426
	427
	428	class AliRunDB : public TObject {
	429
5ea08be4	430	public:
8ee17d63	431	AliRunDB(Bool_t noLocalDB = kFALSE);
c689d2f6	432	AliRunDB(const AliRunDB& runDB): TObject(runDB)
	433	{Fatal("AliRunDB", "copy constructor not implemented");};
	434	AliRunDB& operator = (const AliRunDB& /runDB/) {
	435	Fatal("operator =", "assignment operator not implemented");
	436	return *this;
	437	};
5ea08be4	438	~AliRunDB() { Close(); }
	439
	440	void Update(AliStats *stats);
	441	void UpdateRDBMS(AliStats *stats);
9174317d	442	void UpdateAliEn(AliStats *stats);
5ea08be4	443	void Close();
5ea08be4	444
c689d2f6	445	private:
	446	TFile *fRunDB; // run database
	447
5ea08be4	448	ClassDef(AliRunDB,0) // Run (bookkeeping) DB
	449	};
	450
	451
	452	class AliMDC : public TObject {
	453
9174317d	454	public:
	455	enum EWriteMode { kLOCAL, kRFIO, kROOTD, kCASTOR, kDEVNULL };
	456
c689d2f6	457	AliMDC(Int_t fd, Int_t compress, Double_t maxFileSize, Bool_t useFilter,
	458	EWriteMode mode, Bool_t useLoop, Bool_t delFiles);
	459	~AliMDC() { }
	460
	461	Int_t Run();
	462	void SetStopLoop() { fStopLoop = kTRUE; }
	463	Bool_t StopLoop() const { return fStopLoop; }
	464
	465	void SetDebugLevel(Int_t level) { fDebugLevel = level; }
	466	Int_t GetDebugLevel() const { return fDebugLevel; }
	467
	468	static Bool_t DeleteFiles() { return fgDeleteFiles; }
	469
5ea08be4	470	private:
9174317d	471	Int_t fFd; // DATE input stream
	472	Int_t fCompress; // compression factor used for raw output DB
	473	Int_t fNumEvents; // number of events processed
	474	Int_t fDebugLevel; // controls debug print-out
	475	Double_t fMaxFileSize; // maximum size of raw output DB
	476	EWriteMode fWriteMode; // write mode (local, rfio, rootd, castor, /dev/null)
	477	Bool_t fUseFifo; // read from fifo, file otherwise
	478	Bool_t fUseEb; // use event builder API instead of fifo
	479	Bool_t fUseFilter; // use 3rd level trigger filter
	480	Bool_t fUseLoop; // loop on input source (must be file)
	481	Bool_t fStopLoop; // break from endless loop (triggered by SIGUSR1)
5ea08be4	482
c689d2f6	483	static Bool_t fgDeleteFiles; // flag for deletion of files
5ea08be4	484
	485	Int_t Read(const char *name) { return TObject::Read(name); }
	486	Int_t Read(void *buffer, Int_t length);
	487	Int_t ReadHeader(AliRawEventHeader &header, void *eb = 0);
	488	Int_t ReadEquipmentHeader(AliRawEquipmentHeader &header,
	489	Bool_t isSwapped, void *eb = 0);
	490	Int_t ReadRawData(AliRawData &raw, Int_t size, void *eb = 0);
	491	Int_t DumpEvent(Int_t toRead);
	492	Int_t Filter(AliRawData &raw);
	493
5ea08be4	494	ClassDef(AliMDC,0) // MDC processor
	495	};
	496
	497	R__EXTERN AliMDC *gAliMDC;
	498
	499	#define ALIDEBUG(level) \
86f15b50	500	if (gAliMDC && (gAliMDC->GetDebugLevel() >= (level)))
5ea08be4	501
5ea08be4	502	#endif