[u/mrichter/AliRoot.git] / ITS / AliITSRawStreamSPD.h

#ifndef ALIITSRAWSTREAMSPD_H
#define ALIITSRAWSTREAMSPD_H
/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
///
/// This class provides access to ITS SPD digits in raw data.
///
///////////////////////////////////////////////////////////////////////////////

#include "AliRawReader.h"
#include "AliITSRawStream.h"
#include "AliITSRawStreamSPDErrorLog.h"

class AliITSRawStreamSPD: public AliITSRawStream {
  public :
    AliITSRawStreamSPD(AliRawReader* rawReader);
    AliITSRawStreamSPD(const AliITSRawStreamSPD& rstream);
    AliITSRawStreamSPD& operator=(const AliITSRawStreamSPD& rstream);
    virtual ~AliITSRawStreamSPD() {};

    virtual Bool_t  Next();
    virtual Int_t   ReadCalibHeader();

    // the 2 methods below are equivalent to AliITSRawStream::GetCoord1 and GetCoord2
    // together with the AliITSRawStream::GetModuleID these are the "offline" coordinates
    Int_t    GetColumn() const {return fCoord1;};
    Int_t    GetRow() const {return fCoord2;};

    // together with the AliRawReader::GetDDLID() these are the "online" coordinates
    UShort_t GetHalfStaveNr() const {return fHalfStaveNr;}
    UShort_t GetChipAddr() const {return fChipAddr;}
    Int_t    GetChipCol() const {return fCol;};
    Int_t    GetChipRow() const {return fRow;};

    // module mapping
    static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iModule);
    static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iHS, UInt_t iChip) 
      {return GetOfflineModuleFromOnline(iDDL,iHS,iChip);}

    // coordinate conversions:
    static Bool_t OfflineToOnline(UInt_t module, UInt_t colM, UInt_t RowM, UInt_t& eq, UInt_t& hs, UInt_t& chip, UInt_t& col, UInt_t& row);
    static Bool_t OnlineToOffline(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row, UInt_t& module, UInt_t& colM, UInt_t& rowM);
    // coordinate conversions - offline->online
    static UInt_t GetOnlineEqIdFromOffline(UInt_t module);
    static UInt_t GetOnlineHSFromOffline(UInt_t module);
    static UInt_t GetOnlineChipFromOffline(UInt_t module, UInt_t colM);
    static UInt_t GetOnlineColFromOffline(UInt_t module, UInt_t colM);
    static UInt_t GetOnlineRowFromOffline(UInt_t module, UInt_t rowM);
    // coordinate conversions - online->offline
    static UInt_t GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip);
    static UInt_t GetOfflineChipKeyFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip);
    static UInt_t GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col);
    static UInt_t GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row);

    Bool_t  GetFastOrSignal(UInt_t eq, UInt_t hs, UInt_t chip);

    Int_t   GetEventCounter() const {return fEventCounter;}    // get last read event counter value
    Short_t GetEventCounterFullEq(UInt_t eq) const;
    Short_t GetEventCounterFullHS(UInt_t eq, UInt_t hs) const;
    Short_t GetEventCounterFullChip(UInt_t eq, UInt_t hs, UInt_t chip) const;
    Bool_t  IsEventCounterFullConsistent() const;

    Bool_t IsActiveEq(UInt_t eq) const;
    Bool_t IsActiveHS(UInt_t eq, UInt_t hs) const;
    Bool_t IsActiveChip(UInt_t eq, UInt_t hs, UInt_t chip) const;

    Bool_t GetHalfStavePresent(UInt_t hs);

    Int_t  GetHword(UInt_t index);
    // use the methods below to extract the information from the scan calibration header:
    UInt_t GetHrouterNr() const {return (fCalHeadWord[0] & 0x0000003f);}
    Bool_t GetHhalfStaveScanned(UInt_t hs) const;
    UInt_t GetHtype() const {return (Int_t)((fCalHeadWord[1]) & 0x000000ff);}
    Bool_t GetHdataFormat() const {return (Bool_t)(((fCalHeadWord[1]) & 0x00000100)>>8);}
    UInt_t GetHtriggers() const {return fCalHeadWord[2];}
    Bool_t GetHchipPresent(UInt_t hs, UInt_t chip) const;
    UInt_t GetHdacStart() const {return ((fCalHeadWord[5]>>24) & 0x000000ff);}
    UInt_t GetHdacEnd() const {return ((fCalHeadWord[5]>>16) & 0x000000ff);}
    UInt_t GetHdacStep() const {return ((fCalHeadWord[5]>>8) & 0x000000ff);}
    UInt_t GetHdacId() const {return ((fCalHeadWord[5]) & 0x000000ff);}
    UInt_t GetHrowStart() const {return (UInt_t) ((fCalHeadWord[6]>>24) & 0x000000ff);}
    UInt_t GetHrowEnd() const {return (UInt_t) ((fCalHeadWord[6]>>16) & 0x000000ff);}
    UInt_t GetHrowValue() const {return (UInt_t) ((fCalHeadWord[6]>> 8) & 0x000000ff);}
    UInt_t GetHrowSpan() const {return (UInt_t) ((fCalHeadWord[6]) & 0x000000ff);}    
    UInt_t GetHdacValue() const {return (Int_t) ((fCalHeadWord[6]) & 0x000000ff);}
    UInt_t GetHdacHigh(UInt_t hs) const;
    UInt_t GetHdacLow(UInt_t hs) const;
    UInt_t GetHTPAmp(UInt_t hs) const;
    Bool_t GetHminTHchipPresent(UInt_t chip) const;
    UInt_t GetHglobalDBversion() const {return fCalHeadWord[16];}
    // use the methods below to extract the information from the fo calibration header:
    UInt_t GetFOHrouterNr() const {return GetHrouterNr();}
    UInt_t GetFOHtype() const {return GetHtype();}
    UInt_t GetFOHtriggers() const {return GetHtriggers();}
    Bool_t GetFOHchipPresent(UInt_t hs, UInt_t chip) const {return GetHchipPresent(hs,chip);}
    UInt_t GetFOHglobalDBversion() const {return fCalHeadWord[5];}
    UInt_t GetFOHMatrixID() const {return fCalHeadWord[6] & 0x0000000f;}
    UInt_t GetFOHpixelCol() const {return (fCalHeadWord[6] >> 20) & 0x0000001f;}
    UInt_t GetFOHpixelRow() const {return (fCalHeadWord[6] >> 10) & 0x000000ff;}
    UInt_t GetFOHnumDacs() const;
    UInt_t GetFOHdacIndex(UInt_t index) const;
    UInt_t GetFOHdacValue(UInt_t index) const;
    UInt_t GetFOHchipCount(UInt_t hs, UInt_t chip) const;

    void   ActivateAdvancedErrorLog(Bool_t activate, AliITSRawStreamSPDErrorLog* advLogger = NULL);
    AliITSRawStreamSPDErrorLog* GetAdvancedErrorLog() {return fAdvLogger;}

    static const Char_t* GetErrorName(UInt_t errorCode);

    enum {kDDLsNumber = 20};      // number of DDLs in SPD
    enum {kModulesPerDDL = 12};   // number of modules in each DDL
    enum {kCalHeadLenMax = 64};   // maximum number of calib header words
    enum ESPDRawStreamError {
      kTotal,
      kHeaderMissingErr,
      kTrailerMissingErr,
      kTrailerWithoutHeaderErr,
      kHeaderCountErr,
      kTrailerCountErr,
      kFillUnexpectErr,
      kFillMissingErr,
      kWrongFillWordErr,
      kNumberHitsErr,
      kEventCounterErr,
      kDDLNumberErr,
      kHSNumberErr,
      kChipAddrErr,
      kCalHeaderLengthErr,
      kAdvEventCounterErr,     // used by SPDmood
      kAdvEventCounterOrderErr,// used by SPDmood
      kTrailerErrorBitErr,
      kLinkRxDetectorFatalErr,
      kTSMtriggerErr,
      kHighMultiplicityFlag
    };

  private :
    static const Int_t fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL];  // mapping DDL/module -> module number

    Bool_t      ReadNextShort();
    Bool_t      ReadNextInt();
    void        NewEvent();
    void	CheckHeaderAndTrailerCount(Int_t ddlID);

    Int_t       fEventCounter;                // chip event counter
    Short_t     fEventCounterFull[20][6][10]; // chip event counter

    UShort_t    fChipAddr;                    // chip nr
    UShort_t    fHalfStaveNr;                 // half stave nr
    UInt_t      fCol;                         // chip column nr
    UInt_t      fRow;                         // chip row nr
    UInt_t      fCalHeadWord[kCalHeadLenMax]; // calibration header words
    UInt_t      fCalHeadLen;                  // calibration header length

    UShort_t    fData;            // 16 bit data word read
    UInt_t      fOffset;          // offset for cell column
    UInt_t      fHitCount;        // counter of hits
    UChar_t     fDataChar1, fDataChar2, fDataChar3, fDataChar4; // temps part of a 32bit word
    Bool_t      fFirstWord;       // keeps track of which of the two 16bit words out of the 32bit word to read when ReadNextShort is called
    Bool_t      fCalHeadRead[20];            // calibration header read flags (reset at new event)
    UInt_t      fPrevEventId;                // previous event id (needed to know if there is a new event)

    UInt_t      fEqPLBytesRead;              // bytes read for current equipment payload
    UInt_t      fEqPLChipHeadersRead;        // number of chip headers found in current equipment payload
    UInt_t      fEqPLChipTrailersRead;       // number of chip trailers found in current equipment payload
    Bool_t      fHeaderOrTrailerReadLast;    // in previous words, was a header (true) or a trailer (false) read last
    UInt_t      fExpectedHeaderTrailerCount; // expected number of headers and trailers for the current equipment payload
    Bool_t      fFillOutOfSynch;             // has a fill word been put in the wrong place?
    Int_t       fDDLID;                      // ddl id 
    Int_t       fLastDDLID;                  // ddl id for equipment read in previous words

    Bool_t      fAdvancedErrorLog;           // is the advanced error logging activated?
    AliITSRawStreamSPDErrorLog *fAdvLogger;  // pointer to special error logger object

    Bool_t      fFastOrSignal[20][6][10];    // fastor signal bit (one per chip)

    Bool_t      fActiveEq[20];               // which equipments are active (found in data)
    Bool_t      fActiveHS[20][6];            // which half-staves are active (blockattribute bits)
    Bool_t      fActiveChip[20][6][10];      // which chips are active (found in data)

    ClassDef(AliITSRawStreamSPD, 0) // class for reading ITS SPD raw digits
};

#endif
Commit	Line	Data
2906f4c2	1	#ifndef ALIITSRAWSTREAMSPD_H
	2	#define ALIITSRAWSTREAMSPD_H
	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
	8	///////////////////////////////////////////////////////////////////////////////
	9	///
	10	/// This class provides access to ITS SPD digits in raw data.
	11	///
	12	///////////////////////////////////////////////////////////////////////////////
	13
ad7f2bfa	14	#include "AliRawReader.h"
2906f4c2	15	#include "AliITSRawStream.h"
d9c68335	16	#include "AliITSRawStreamSPDErrorLog.h"
2906f4c2	17
	18	class AliITSRawStreamSPD: public AliITSRawStream {
	19	public :
	20	AliITSRawStreamSPD(AliRawReader* rawReader);
d9c68335	21	AliITSRawStreamSPD(const AliITSRawStreamSPD& rstream);
d9c68335	22	AliITSRawStreamSPD& operator=(const AliITSRawStreamSPD& rstream);
2906f4c2	23	virtual ~AliITSRawStreamSPD() {};
2906f4c2	24
b696414b	25	virtual Bool_t Next();
3f917533	26	virtual Int_t ReadCalibHeader();
2906f4c2	27
c42b9ed0	28	// the 2 methods below are equivalent to AliITSRawStream::GetCoord1 and GetCoord2
	29	// together with the AliITSRawStream::GetModuleID these are the "offline" coordinates
	30	Int_t GetColumn() const {return fCoord1;};
	31	Int_t GetRow() const {return fCoord2;};
	32
	33	// together with the AliRawReader::GetDDLID() these are the "online" coordinates
	34	UShort_t GetHalfStaveNr() const {return fHalfStaveNr;}
	35	UShort_t GetChipAddr() const {return fChipAddr;}
	36	Int_t GetChipCol() const {return fCol;};
	37	Int_t GetChipRow() const {return fRow;};
	38
53ae21ce	39	// module mapping
6727e2db	40	static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iModule);
	41	static Int_t GetModuleNumber(UInt_t iDDL, UInt_t iHS, UInt_t iChip)
	42	{return GetOfflineModuleFromOnline(iDDL,iHS,iChip);}
	43
	44	// coordinate conversions:
	45	static Bool_t OfflineToOnline(UInt_t module, UInt_t colM, UInt_t RowM, UInt_t& eq, UInt_t& hs, UInt_t& chip, UInt_t& col, UInt_t& row);
	46	static Bool_t OnlineToOffline(UInt_t eq, UInt_t hs, UInt_t chip, UInt_t col, UInt_t row, UInt_t& module, UInt_t& colM, UInt_t& rowM);
	47	// coordinate conversions - offline->online
	48	static UInt_t GetOnlineEqIdFromOffline(UInt_t module);
	49	static UInt_t GetOnlineHSFromOffline(UInt_t module);
	50	static UInt_t GetOnlineChipFromOffline(UInt_t module, UInt_t colM);
	51	static UInt_t GetOnlineColFromOffline(UInt_t module, UInt_t colM);
	52	static UInt_t GetOnlineRowFromOffline(UInt_t module, UInt_t rowM);
	53	// coordinate conversions - online->offline
	54	static UInt_t GetOfflineModuleFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip);
b457135f	55	static UInt_t GetOfflineChipKeyFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip);
6727e2db	56	static UInt_t GetOfflineColFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t col);
	57	static UInt_t GetOfflineRowFromOnline(UInt_t eqId, UInt_t hs, UInt_t chip, UInt_t row);
	58
4f98b62b	59	Bool_t GetFastOrSignal(UInt_t eq, UInt_t hs, UInt_t chip);
4f98b62b	60
478d804c	61	Int_t GetEventCounter() const {return fEventCounter;} // get last read event counter value
	62	Short_t GetEventCounterFullEq(UInt_t eq) const;
	63	Short_t GetEventCounterFullHS(UInt_t eq, UInt_t hs) const;
	64	Short_t GetEventCounterFullChip(UInt_t eq, UInt_t hs, UInt_t chip) const;
	65	Bool_t IsEventCounterFullConsistent() const;
b696414b	66
478d804c	67	Bool_t IsActiveEq(UInt_t eq) const;
	68	Bool_t IsActiveHS(UInt_t eq, UInt_t hs) const;
	69	Bool_t IsActiveChip(UInt_t eq, UInt_t hs, UInt_t chip) const;
53ae21ce	70
c42b9ed0	71	Bool_t GetHalfStavePresent(UInt_t hs);
c42b9ed0	72
de12e454	73	Int_t GetHword(UInt_t index);
de12e454	74	// use the methods below to extract the information from the scan calibration header:
c42b9ed0	75	UInt_t GetHrouterNr() const {return (fCalHeadWord[0] & 0x0000003f);}
	76	Bool_t GetHhalfStaveScanned(UInt_t hs) const;
	77	UInt_t GetHtype() const {return (Int_t)((fCalHeadWord[1]) & 0x000000ff);}
	78	Bool_t GetHdataFormat() const {return (Bool_t)(((fCalHeadWord[1]) & 0x00000100)>>8);}
	79	UInt_t GetHtriggers() const {return fCalHeadWord[2];}
	80	Bool_t GetHchipPresent(UInt_t hs, UInt_t chip) const;
	81	UInt_t GetHdacStart() const {return ((fCalHeadWord[5]>>24) & 0x000000ff);}
	82	UInt_t GetHdacEnd() const {return ((fCalHeadWord[5]>>16) & 0x000000ff);}
	83	UInt_t GetHdacStep() const {return ((fCalHeadWord[5]>>8) & 0x000000ff);}
	84	UInt_t GetHdacId() const {return ((fCalHeadWord[5]) & 0x000000ff);}
	85	UInt_t GetHrowStart() const {return (UInt_t) ((fCalHeadWord[6]>>24) & 0x000000ff);}
	86	UInt_t GetHrowEnd() const {return (UInt_t) ((fCalHeadWord[6]>>16) & 0x000000ff);}
	87	UInt_t GetHrowValue() const {return (UInt_t) ((fCalHeadWord[6]>> 8) & 0x000000ff);}
ad7f2bfa	88	UInt_t GetHrowSpan() const {return (UInt_t) ((fCalHeadWord[6]) & 0x000000ff);}
c42b9ed0	89	UInt_t GetHdacValue() const {return (Int_t) ((fCalHeadWord[6]) & 0x000000ff);}
	90	UInt_t GetHdacHigh(UInt_t hs) const;
	91	UInt_t GetHdacLow(UInt_t hs) const;
	92	UInt_t GetHTPAmp(UInt_t hs) const;
1fd93b67	93	Bool_t GetHminTHchipPresent(UInt_t chip) const;
ad7f2bfa	94	UInt_t GetHglobalDBversion() const {return fCalHeadWord[16];}
de12e454	95	// use the methods below to extract the information from the fo calibration header:
	96	UInt_t GetFOHrouterNr() const {return GetHrouterNr();}
	97	UInt_t GetFOHtype() const {return GetHtype();}
	98	UInt_t GetFOHtriggers() const {return GetHtriggers();}
	99	Bool_t GetFOHchipPresent(UInt_t hs, UInt_t chip) const {return GetHchipPresent(hs,chip);}
	100	UInt_t GetFOHglobalDBversion() const {return fCalHeadWord[5];}
fe24ac86	101	UInt_t GetFOHMatrixID() const {return fCalHeadWord[6] & 0x0000000f;}
	102	UInt_t GetFOHpixelCol() const {return (fCalHeadWord[6] >> 20) & 0x0000001f;}
	103	UInt_t GetFOHpixelRow() const {return (fCalHeadWord[6] >> 10) & 0x000000ff;}
de12e454	104	UInt_t GetFOHnumDacs() const;
	105	UInt_t GetFOHdacIndex(UInt_t index) const;
	106	UInt_t GetFOHdacValue(UInt_t index) const;
	107	UInt_t GetFOHchipCount(UInt_t hs, UInt_t chip) const;
	108
d9c68335	109	void ActivateAdvancedErrorLog(Bool_t activate, AliITSRawStreamSPDErrorLog* advLogger = NULL);
b457135f	110	AliITSRawStreamSPDErrorLog* GetAdvancedErrorLog() {return fAdvLogger;}
b457135f	111
d9c68335	112	static const Char_t* GetErrorName(UInt_t errorCode);
d9c68335	113
2906f4c2	114	enum {kDDLsNumber = 20}; // number of DDLs in SPD
2906f4c2	115	enum {kModulesPerDDL = 12}; // number of modules in each DDL
de12e454	116	enum {kCalHeadLenMax = 64}; // maximum number of calib header words
d9edae7b	117	enum ESPDRawStreamError {
d9c68335	118	kTotal,
	119	kHeaderMissingErr,
	120	kTrailerMissingErr,
	121	kTrailerWithoutHeaderErr,
	122	kHeaderCountErr,
	123	kTrailerCountErr,
	124	kFillUnexpectErr,
	125	kFillMissingErr,
	126	kWrongFillWordErr,
	127	kNumberHitsErr,
	128	kEventCounterErr,
	129	kDDLNumberErr,
	130	kHSNumberErr,
	131	kChipAddrErr,
b696414b	132	kCalHeaderLengthErr,
b696414b	133	kAdvEventCounterErr, // used by SPDmood
4f98b62b	134	kAdvEventCounterOrderErr,// used by SPDmood
de12e454	135	kTrailerErrorBitErr,
	136	kLinkRxDetectorFatalErr,
	137	kTSMtriggerErr,
86cb46a6	138	kHighMultiplicityFlag
d9edae7b	139	};
2906f4c2	140
	141	private :
	142	static const Int_t fgkDDLModuleMap[kDDLsNumber][kModulesPerDDL]; // mapping DDL/module -> module number
	143
d9c68335	144	Bool_t ReadNextShort();
	145	Bool_t ReadNextInt();
	146	void NewEvent();
	147	void CheckHeaderAndTrailerCount(Int_t ddlID);
	148
	149	Int_t fEventCounter; // chip event counter
478d804c	150	Short_t fEventCounterFull[20][6][10]; // chip event counter
478d804c	151
d9c68335	152	UShort_t fChipAddr; // chip nr
	153	UShort_t fHalfStaveNr; // half stave nr
	154	UInt_t fCol; // chip column nr
	155	UInt_t fRow; // chip row nr
	156	UInt_t fCalHeadWord[kCalHeadLenMax]; // calibration header words
de12e454	157	UInt_t fCalHeadLen; // calibration header length
de12e454	158
d9c68335	159	UShort_t fData; // 16 bit data word read
	160	UInt_t fOffset; // offset for cell column
	161	UInt_t fHitCount; // counter of hits
	162	UChar_t fDataChar1, fDataChar2, fDataChar3, fDataChar4; // temps part of a 32bit word
	163	Bool_t fFirstWord; // keeps track of which of the two 16bit words out of the 32bit word to read when ReadNextShort is called
	164	Bool_t fCalHeadRead[20]; // calibration header read flags (reset at new event)
	165	UInt_t fPrevEventId; // previous event id (needed to know if there is a new event)
	166
	167	UInt_t fEqPLBytesRead; // bytes read for current equipment payload
	168	UInt_t fEqPLChipHeadersRead; // number of chip headers found in current equipment payload
	169	UInt_t fEqPLChipTrailersRead; // number of chip trailers found in current equipment payload
	170	Bool_t fHeaderOrTrailerReadLast; // in previous words, was a header (true) or a trailer (false) read last
	171	UInt_t fExpectedHeaderTrailerCount; // expected number of headers and trailers for the current equipment payload
	172	Bool_t fFillOutOfSynch; // has a fill word been put in the wrong place?
	173	Int_t fDDLID; // ddl id
	174	Int_t fLastDDLID; // ddl id for equipment read in previous words
	175
	176	Bool_t fAdvancedErrorLog; // is the advanced error logging activated?
	177	AliITSRawStreamSPDErrorLog *fAdvLogger; // pointer to special error logger object
72600597	178
4f98b62b	179	Bool_t fFastOrSignal[20][6][10]; // fastor signal bit (one per chip)
4f98b62b	180
b696414b	181	Bool_t fActiveEq[20]; // which equipments are active (found in data)
b696414b	182	Bool_t fActiveHS[20][6]; // which half-staves are active (blockattribute bits)
478d804c	183	Bool_t fActiveChip[20][6][10]; // which chips are active (found in data)
b696414b	184
2906f4c2	185	ClassDef(AliITSRawStreamSPD, 0) // class for reading ITS SPD raw digits
	186	};
	187
	188	#endif