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

#ifndef ALIMDC_H
#define ALIMDC_H
// @(#)alimdc:$Name$:$Id$
// Author: Fons Rademakers  26/11/99

/* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// AliMDC                                                               //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

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

#ifndef ROOT_TObjArray
#include <TObjArray.h>
#endif

#ifndef ROOT_TSysEvtHandler
#include <TSysEvtHandler.h>
#endif

// Forward class declarations
class AliRawEvent;
class AliRawEventHeaderBase;
class AliRawEquipmentHeader;
class AliRawData;
class AliRawDB;
class AliTagDB;
class AliRawEventTag;
class AliStats;
class AliESD;

class AliMDC : public TObject {

public:
   enum EWriteMode { kLOCAL, kRFIO, kROOTD, kCASTOR, kDEVNULL };
   enum EFilterMode { kFilterOff, kFilterTransparent, kFilterOn };
   enum EErrorCode { kErrStartEndRun = -1, 
		     kErrHeader = -2, 
		     kErrHeaderSize = -3, 
		     kErrSubHeader = -4, 
		     kErrDataSize = -5, 
		     kErrEquipmentHeader = -6, 
		     kErrEquipment = -7,
                     kErrFileSize = -8,
		     kFilterReject = -9,
                     kErrWriting = -10 };

   AliMDC(Int_t compress, Bool_t deleteFiles, 
	  EFilterMode filterMode = kFilterTransparent, 
	  Double_t maxSizeTagDB = -1, const char* fileNameTagDB = NULL,
	  const char* guidFileFolder = NULL);
   virtual ~AliMDC();

   Int_t      Open(EWriteMode mode, const char* fileName,
		   Double_t maxFileSize = 0,
		   const char* fs1 = NULL, const char* fs2 = NULL);
   Int_t      ProcessEvent(void* event, Bool_t isIovecArray = kFALSE);
   Int_t      GetTotalSize();
   Int_t      Close();

   Int_t      Run(const char* inputFile, Bool_t loop,
	          EWriteMode mode, Double_t maxFileSize, 
		  const char* fs1 = NULL, const char* fs2 = NULL);
   void       Stop();

private:
   class AliMDCInterruptHandler : public TSignalHandler {
   public:
     AliMDCInterruptHandler(AliMDC *mdc) : TSignalHandler(kSigUser1, kFALSE), fMDC(mdc) { }
     Bool_t Notify() {
       Info("Notify", "received a SIGUSR1 signal");
       fMDC->Stop();
       return kTRUE;
     }
   private:
     AliMDC *fMDC;   // alimdc to signal

     AliMDCInterruptHandler(const AliMDCInterruptHandler& handler); // Not implemented
     AliMDCInterruptHandler& operator=(const AliMDCInterruptHandler& handler); // Not implemented
   };

   AliRawEvent *fEvent;       // produced AliRawEvent
   AliESD      *fESD;         // pointer to HLT ESD object
   AliStats    *fStats;       // statistics
   AliRawDB    *fRawDB;       // raw data DB
   AliTagDB    *fTagDB;       // tag DB
   AliRawEventTag *fEventTag; // raw-data event tag object
   Int_t        fCompress;    // compression factor used for raw output DB
   Bool_t       fDeleteFiles; // flag for deletion of files
   EFilterMode  fFilterMode;  // high level filter mode
   TObjArray    fFilters;     // filter algorithms
   Bool_t       fStop;        // stop execution (triggered by SIGUSR1)
   Bool_t       fIsTagDBCreated; // is tag db already created
   Double_t     fMaxSizeTagDB;// max size of the tag DB
   const char*  fFileNameTagDB;// tag DB file name
   const char*  fGuidFileFolder; // guid files folder

   // Filter names
   enum {kNFilters = 1};
   static const char* const fgkFilterName[kNFilters];

   AliMDC(const AliMDC& mdc);
   AliMDC& operator = (const AliMDC& mdc);

   Int_t     Read(const char *name) { return TObject::Read(name); }
   Int_t     Read(Int_t fd, void *buffer, Int_t length);
   Int_t     ReadEquipmentHeader(AliRawEquipmentHeader &header,
                                 Bool_t isSwapped, char*& data);
   Int_t     ReadRawData(AliRawData &raw, Int_t size, char*& data);

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

#endif
Commit	Line	Data
a197a4ce	1	#ifndef ALIMDC_H
	2	#define ALIMDC_H
	3	// @(#)alimdc:$Name$:$Id$
	4	// Author: Fons Rademakers 26/11/99
	5
	6	/* Copyright(c) 1998-2003, ALICE Experiment at CERN, All rights reserved. *
	7	* See cxx source for full Copyright notice */
	8
	9	//////////////////////////////////////////////////////////////////////////
	10	// //
	11	// AliMDC //
	12	// //
	13	//////////////////////////////////////////////////////////////////////////
	14
	15	#ifndef ROOT_TObject
	16	#include <TObject.h>
	17	#endif
	18
e10815f1	19	#ifndef ROOT_TObjArray
	20	#include <TObjArray.h>
	21	#endif
	22
a197a4ce	23	#ifndef ROOT_TSysEvtHandler
	24	#include <TSysEvtHandler.h>
	25	#endif
	26
	27	// Forward class declarations
a109e73e	28	class AliRawEvent;
f2dc6b20	29	class AliRawEventHeaderBase;
a197a4ce	30	class AliRawEquipmentHeader;
a197a4ce	31	class AliRawData;
e10815f1	32	class AliRawDB;
e10815f1	33	class AliTagDB;
54dd2271	34	class AliRawEventTag;
e10815f1	35	class AliStats;
a109e73e	36	class AliESD;
a197a4ce	37
	38	class AliMDC : public TObject {
	39
	40	public:
	41	enum EWriteMode { kLOCAL, kRFIO, kROOTD, kCASTOR, kDEVNULL };
e10815f1	42	enum EFilterMode { kFilterOff, kFilterTransparent, kFilterOn };
f07ec911	43	enum EErrorCode { kErrStartEndRun = -1,
e10815f1	44	kErrHeader = -2,
	45	kErrHeaderSize = -3,
	46	kErrSubHeader = -4,
	47	kErrDataSize = -5,
	48	kErrEquipmentHeader = -6,
d21e9888	49	kErrEquipment = -7,
f07ec911	50	kErrFileSize = -8,
	51	kFilterReject = -9,
	52	kErrWriting = -10 };
e10815f1	53
	54	AliMDC(Int_t compress, Bool_t deleteFiles,
	55	EFilterMode filterMode = kFilterTransparent,
5d315e4d	56	Double_t maxSizeTagDB = -1, const char* fileNameTagDB = NULL,
5d315e4d	57	const char* guidFileFolder = NULL);
e10815f1	58	virtual ~AliMDC();
e10815f1	59
4fbf7315	60	Int_t Open(EWriteMode mode, const char* fileName,
	61	Double_t maxFileSize = 0,
	62	const char* fs1 = NULL, const char* fs2 = NULL);
e10815f1	63	Int_t ProcessEvent(void* event, Bool_t isIovecArray = kFALSE);
d21e9888	64	Int_t GetTotalSize();
e10815f1	65	Int_t Close();
	66
	67	Int_t Run(const char* inputFile, Bool_t loop,
	68	EWriteMode mode, Double_t maxFileSize,
	69	const char* fs1 = NULL, const char* fs2 = NULL);
	70	void Stop();
a197a4ce	71
	72	private:
	73	class AliMDCInterruptHandler : public TSignalHandler {
	74	public:
	75	AliMDCInterruptHandler(AliMDC *mdc) : TSignalHandler(kSigUser1, kFALSE), fMDC(mdc) { }
	76	Bool_t Notify() {
	77	Info("Notify", "received a SIGUSR1 signal");
e10815f1	78	fMDC->Stop();
a197a4ce	79	return kTRUE;
	80	}
	81	private:
	82	AliMDC *fMDC; // alimdc to signal
	83
d557984f	84	AliMDCInterruptHandler(const AliMDCInterruptHandler& handler); // Not implemented
d557984f	85	AliMDCInterruptHandler& operator=(const AliMDCInterruptHandler& handler); // Not implemented
a197a4ce	86	};
a197a4ce	87
e10815f1	88	AliRawEvent *fEvent; // produced AliRawEvent
	89	AliESD *fESD; // pointer to HLT ESD object
	90	AliStats *fStats; // statistics
	91	AliRawDB *fRawDB; // raw data DB
e10815f1	92	AliTagDB *fTagDB; // tag DB
54dd2271	93	AliRawEventTag *fEventTag; // raw-data event tag object
e10815f1	94	Int_t fCompress; // compression factor used for raw output DB
	95	Bool_t fDeleteFiles; // flag for deletion of files
	96	EFilterMode fFilterMode; // high level filter mode
	97	TObjArray fFilters; // filter algorithms
	98	Bool_t fStop; // stop execution (triggered by SIGUSR1)
f2dc6b20	99	Bool_t fIsTagDBCreated; // is tag db already created
	100	Double_t fMaxSizeTagDB;// max size of the tag DB
	101	const char* fFileNameTagDB;// tag DB file name
5d315e4d	102	const char* fGuidFileFolder; // guid files folder
e10815f1	103
	104	// Filter names
	105	enum {kNFilters = 1};
	106	static const char* const fgkFilterName[kNFilters];
a197a4ce	107
	108	AliMDC(const AliMDC& mdc);
	109	AliMDC& operator = (const AliMDC& mdc);
	110
	111	Int_t Read(const char *name) { return TObject::Read(name); }
e10815f1	112	Int_t Read(Int_t fd, void *buffer, Int_t length);
a197a4ce	113	Int_t ReadEquipmentHeader(AliRawEquipmentHeader &header,
e10815f1	114	Bool_t isSwapped, char*& data);
e10815f1	115	Int_t ReadRawData(AliRawData &raw, Int_t size, char*& data);
a197a4ce	116
	117	ClassDef(AliMDC,0) // MDC processor
	118	};
	119
	120	#endif