[u/mrichter/AliRoot.git] / TRD / AliTRDrawStream.h

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

//-----------------------------------
//
// decoding of TRD raw data stream 
// and translation into digits
//
//----------------------------------

#ifndef ALITRDRAWSTREAM_H
#define ALITRDRAWSTREAM_H

#include "TObject.h"
#include "TClonesArray.h"
#include "TTree.h"

class TObjArray;
class TString;
class TBranch;

class AliRawReader;
class AliTRDdigitsManager;
class AliTRDdigitsParam;
class AliTRDarrayADC;
class AliTRDSignalIndex;
class AliTRDtrackletContainer;

#define TRDMAXTBINS 63
#define TRDMAXADC   21
#define TRDMAXMCM   4 * 16
#define MAXTRACKLETSPERHC 256

class AliTRDrawStream : public TObject
{
 public:
  AliTRDrawStream(AliRawReader *rawReader = 0x0);
  ~AliTRDrawStream();

  enum { kDDLOffset = 0x400 };                                // Offset for DDL numbers

  Bool_t SetReader(AliRawReader *rawReader) { fRawReader = rawReader; return kTRUE; }
  void SetDigitsManager(AliTRDdigitsManager *digMgr) { fDigitsManager = digMgr; }
  void SetTrackletArray(TClonesArray *ar) { fTracklets = ar; }
  void SetTrackArray(TClonesArray *ar) { fTracks = ar; }
  void SetMarkerArray(TClonesArray *ar) { fMarkers = ar; }

  TClonesArray* GetTrackletArray() const { return fTracklets; }
  TClonesArray* GetTrackArray() const { return fTracks; }
  TClonesArray* GetMarkerArray() const { return fMarkers; }

  AliTRDdigitsManager* GetDigitsManager() const { return fDigitsManager; }
  TTree *GetTrackletTree() const { return fTrackletTree; }

  Bool_t ReadEvent(TTree *trackletTree = 0x0);

  Bool_t NextDDL();
  Int_t NextChamber(AliTRDdigitsManager *digMgr, 
		    UInt_t ** /* trackletContainer */=NULL, UShort_t ** /* errorContainer */=NULL);

  Bool_t ConnectTracklets(TTree *trklTree);

  void StoreErrorsInTree()   { fStoreError = &AliTRDrawStream::StoreErrorTree; }
  void StoreErrorsInArray()  { fStoreError = &AliTRDrawStream::StoreErrorArray; }
  void EnableErrorStorage()  { fStoreError = &AliTRDrawStream::StoreErrorTree; }
  void DisableErrorStorage() { fStoreError = &AliTRDrawStream::ForgetError; }

  // error handling
  enum ErrorCode_t { 
    kUnknown = 0, 
    kLinkMonitor, 
    kPtrgCntMismatch, 
    kNonTrdEq,
    kStackHeaderInvalid,
    kInvalidDetector,
    kNoDigits,
    kHCmismatch,
    kHCcheckFailed,
    kPosUnexp,
    kTPmodeInvalid,
    kTPmismatch,
    kNtimebinsChanged,
    kAdcMaskInconsistent,
    kAdcCheckInvalid,
    kAdcDataAbort,
    kAdcChannelsMiss,
    kMissMcmHeaders,
    kLastErrorCode
  }; 

  enum ErrorBehav_t {
    kTolerate = 0,
    kAbort = 1, 
    kDiscardMCM = 2,
    kDiscardHC = 4
  };

  enum MarkerCode_t {
    kHCactive = 1,
    kSecactive = 2
  };

  TTree* GetErrorTree() const { return fErrors; }
  static const char* GetErrorMessage(ErrorCode_t errCode);

  class AliTRDrawStreamError : public TObject {
  public:
    AliTRDrawStreamError(Int_t error = 0, Int_t sector = -1, Int_t stack = -1, Int_t link = -1, Int_t rob = -1, Int_t mcm = -1); 
    virtual ~AliTRDrawStreamError() {}
    Int_t fError;                               // error code
    Int_t fSector;				// sector
    Int_t fStack;				// stack
    Int_t fLink;				// link
    Int_t fRob;					// ROB no
    Int_t fMcm;					// MCM no
    ClassDef(AliTRDrawStreamError, 1);
  };

  // event statistics
  class AliTRDrawStats : public TObject {
  public:
    AliTRDrawStats() : TObject(), fBytesRead(0) {}
    void ClearStats();

    class AliTRDrawStatsSector : public TObject {
    public:
      AliTRDrawStatsSector() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
      void ClearStats();

      class AliTRDrawStatsHC : public TObject {
      public:
        AliTRDrawStatsHC() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
	void ClearStats();

	Int_t fBytes;             // number of bytes (not necessarily read)
 	Int_t fBytesRead;	  // number of bytes read
	Int_t fNTracklets;	  // number of tracklets
	Int_t fNMCMs;		  // number of MCMs (from MCM headers)
	Int_t fNChannels;	  // number of channels
	ClassDef(AliTRDrawStatsHC, 1);
      };

      Int_t fBytes;		     // number of bytes (not necessarily read)
      Int_t fBytesRead;		     // number of bytes read
      Int_t fNTracklets;	     // number of tracklets
      Int_t fNMCMs;		     // number of MCMs (from MCM headers)
      Int_t fNChannels;		     // number of channels
      AliTRDrawStatsHC fStatsHC[60]; //[60] HC-wise statistics
      ClassDef(AliTRDrawStatsSector, 1);
    };

    AliTRDrawStatsSector fStatsSector[18]; //[18] sector-wise statistics
    Int_t fBytesRead;			   // number of bytes read
    ClassDef(AliTRDrawStats, 1);
  };

  AliTRDrawStats fStats; 	     // event statistics, clearing must be done by the user

  AliTRDrawStats* GetStats() { return &fStats; }
  Int_t GetEventSize(Int_t sector)  const { return fStats.fStatsSector[sector].fBytes; }
  Int_t GetNTracklets(Int_t sector) const { return fStats.fStatsSector[sector].fNTracklets; }
  Int_t GetNMCMs(Int_t sector)      const { return fStats.fStatsSector[sector].fNMCMs; }
  Int_t GetNChannels(Int_t sector)  const { return fStats.fStatsSector[sector].fNChannels; }

  // raw data dumping
  void SetDumpMCM(Int_t det, Int_t rob, Int_t mcm, Bool_t dump = kTRUE);

  Bool_t IsDumping() const { return (fNDumpMCMs > 0); }
  Bool_t DumpingMCM(Int_t det, Int_t rob, Int_t mcm) const;

  void DumpRaw(TString title, UInt_t *start, Int_t length); 

 protected:
  Int_t ReadSmHeader();
  Int_t ReadStackIndexHeader(Int_t stack);

  Int_t ReadLinkData();
  Int_t ReadTracklets();
  Int_t ReadHcHeader();
  Int_t ReadTPData(Int_t mode = 1);
  Int_t ReadZSData();
  Int_t ReadNonZSData();

  Int_t SeekNextLink();

  // MCM header decoding
  Int_t ROB(UInt_t mcmhdr) const { return 0x7 & mcmhdr >> 28; }
  Int_t MCM(UInt_t mcmhdr) const { return 0xf & mcmhdr >> 24; }
  Int_t Row(UInt_t mcmhdr) const { return (ROB(mcmhdr) / 2) * 4 + MCM(mcmhdr) / 4; }
  Int_t AdcColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 21 + (ROB(mcmhdr) % 2) * 84 - 1; }
  Int_t PadColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 18 + (ROB(mcmhdr) % 2) * 72 + 1; }
  Int_t EvNo(UInt_t mcmhdr) const { return 0xfffff & mcmhdr >> 4; }
  Int_t Check(UInt_t mcmhdr) const { return 0xf & mcmhdr; }
  Int_t CouldBeMCMhdr(UInt_t mcmhdr) const { return ((0xf & mcmhdr) == 0xc); }

  Int_t GetMCMReadoutPos(Int_t mcm) const { return (mcm > -1 && mcm < 16) ? fgkMcmOrder[mcm] : -1; }
  Int_t GetROBReadoutPos(Int_t rob) const { return (rob > -1 && rob < 4) ? fgkRobOrder[rob] : -1; }

  // ADC mask decoding
  Int_t GetActiveChannels(UInt_t adcmask) const { return 0x1fffff & adcmask >> 4; }
  inline Int_t GetNActiveChannelsFromMask(UInt_t adcmask) const; // { Int_t nch = 0; for (Int_t i = 0; i < 21; i++) if ((GetActiveChannels(adcmask) & 1 << i)) nch++; return nch; }
  Int_t GetNActiveChannels(UInt_t adcmask) const { return (0x1f & ~(adcmask >> 25)); }
  Int_t CouldBeADCmask(UInt_t adcmask) const { return ((0xf & adcmask) == 0xc && (0x3 & adcmask >> 30) == 0x1); }
      
  // error message generation
  void EquipmentError(ErrorCode_t err = kUnknown, const char *const msg = "", ...); 
  void StackError    (ErrorCode_t err = kUnknown, const char *const msg = "", ...);     
  void LinkError     (ErrorCode_t err = kUnknown, const char *const msg = "", ...); 
  void ROBError      (ErrorCode_t err = kUnknown, const char *const msg = "", ...); 
  void MCMError      (ErrorCode_t err = kUnknown, const char *const msg = "", ...); 
  void StoreErrorTree() { fErrors->Fill(); }
  void StoreErrorArray() { new ((*fMarkers)[fMarkers->GetEntriesFast()]) AliTRDrawStreamError(fLastError); }
  void ForgetError() { return; }
  void (AliTRDrawStream::*fStoreError)();       //! function pointer to method used for storing the error

  static const char* fgkErrorMessages[kLastErrorCode];     // error messages corresponding to the error codes
  static       Int_t fgErrorDebugLevel[kLastErrorCode];   // error debug level
  static       ErrorBehav_t fgErrorBehav[kLastErrorCode]; // bevhaviour in case of error of given type

  // I/O
  AliRawReader *fRawReader;                     // pointer to the raw reader to take the data from 
  AliTRDdigitsManager *fDigitsManager;          // pointer to the digitsManager to fill the data
  AliTRDdigitsParam   *fDigitsParam;            // pointer to the parameters belonging to the digits

  TTree *fErrors;                               // tree containing the occured error codes
  AliTRDrawStreamError fLastError;              // last error which occured
  UInt_t fErrorFlags;                           // error flags used to steer subsequent reading
  char   fErrorBuffer[100];                     // buffer for error message

  UInt_t *fPayloadStart;                        // pointer to start of data payload
  UInt_t *fPayloadCurr;                         // pointer to current reading position in the payload
  Int_t   fPayloadSize;                         // size of the payload (in UInt_t words)

  static const Int_t fgkNlinks;                 // number of links to read
  static const Int_t fgkNstacks;                // number of stacks to read
  static const UInt_t fgkDataEndmarker;         // data endmarker 
  static const UInt_t fgkTrackletEndmarker;     // tracklet endmarker
  static const Int_t fgkMcmOrder [];            // expected readout order of the MCMs
  static const Int_t fgkRobOrder [];            // expected readout order of the ROBs

  // persistent information
  Int_t  fNtimebins;                            // number of timebins
  Int_t  fLastEvId;                             // Event ID of last event 

  // information valid at current reader position
  // all the variables fCurr... refer to the value at the current
  // reading position
  Int_t fCurrSlot;                              // current slot 
  Int_t fCurrLink;				// current link
  Int_t fCurrRobPos; 				// current ROB number
  Int_t fCurrMcmPos;				// current MCM number

  // DDL header
  UInt_t fCurrEquipmentId;			// current Equipment ID

  // SMU index header
  UInt_t fCurrSmuIndexHeaderSize;		// current size of the SMU index header
  UInt_t fCurrSmuIndexHeaderVersion;		// current version of the SMU index header
  UInt_t fCurrTrackEnable;			// current value of track enable
  UInt_t fCurrTrackletEnable; 			// current value of tracklet enable
  UInt_t fCurrStackMask;			// current mask of active stacks

  // Stack index header
  UInt_t *fCurrStackIndexWord;			// current stack index words
  UInt_t *fCurrStackHeaderSize;			// current stack index sizes
  UInt_t *fCurrStackHeaderVersion;		// current stack header versions
  UInt_t *fCurrLinkMask;			// current link masks
  UInt_t *fCurrCleanCheckout;			// current clean checkout flags
  UInt_t *fCurrBoardId;				// current board IDs
  UInt_t *fCurrHwRev;				// current hardware revision
  UInt_t *fCurrLinkMonitorFlags;		// current link monitor flags
  UInt_t *fCurrLinkDataTypeFlags;		// current link data flags
  UInt_t *fCurrLinkDebugFlags;			// current link debug flags

  // HC information
  Int_t fCurrSpecial;				// current value of the special flag
  Int_t fCurrMajor;				// current major version
  Int_t fCurrMinor;				// current minor version
  Int_t fCurrAddHcWords;			// current number of additional HC-header words
  Int_t fCurrSm;				// current sector
  Int_t fCurrStack;				// current stack
  Int_t fCurrLayer;				// current layer
  Int_t fCurrSide;				// current side
  Int_t fCurrHC;				// current HC
  Int_t fCurrCheck;				// current check bits
  Int_t fCurrNtimebins;				// current number of timebins
  Int_t fCurrBC;				// current BC
  Int_t fCurrPtrgCnt;				// current pretrigger count
  Int_t fCurrPtrgPhase;				// current pretrigger phase

  // settings for dumping
  Int_t fDumpMCM[100];		                // MCMs to dump
  Int_t fNDumpMCMs;                             // number of MCMs to dump

  // tracklet information
  TClonesArray *fTrackletArray;			// pointer to array for tracklet storage

  // output data
  AliTRDarrayADC *fAdcArray;			// pointer to ADC array
  AliTRDSignalIndex *fSignalIndex;		// pointer to the signal index
  TTree *fTrackletTree; 			// pointer to the tree for tracklet storage
  TClonesArray *fTracklets;			// pointer to array of tracklets
  TClonesArray *fTracks;			// pointer to array of GTU tracks
  TClonesArray *fMarkers;			// pointer to array of markers (data present, errors, ...)

  AliTRDrawStream(const AliTRDrawStream&);           // not implemented
  AliTRDrawStream& operator=(const AliTRDrawStream&); // not implemented

  ClassDef(AliTRDrawStream, 0);
};

Int_t AliTRDrawStream::GetNActiveChannelsFromMask(UInt_t adcmask) const
{
  // return number of active bits in the ADC mask

  adcmask = GetActiveChannels(adcmask);
  adcmask = adcmask - ((adcmask >> 1) & 0x55555555);
  adcmask = (adcmask & 0x33333333) + ((adcmask >> 2) & 0x33333333);
  return (((adcmask + (adcmask >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
}

#endif
Commit	Line	Data
0508ca31	1	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	2	* See cxx source for full Copyright notice */
	3
	4	//-----------------------------------
	5	//
	6	// decoding of TRD raw data stream
	7	// and translation into digits
	8	//
	9	//----------------------------------
	10
d60fe037	11	#ifndef ALITRDRAWSTREAM_H
	12	#define ALITRDRAWSTREAM_H
	13
8df1f8f5	14	#include "TObject.h"
f4b3235e	15	#include "TClonesArray.h"
f4b3235e	16	#include "TTree.h"
d60fe037	17
d60fe037	18	class TObjArray;
d60fe037	19	class TString;
cc26f39c	20	class TBranch;
d60fe037	21
	22	class AliRawReader;
	23	class AliTRDdigitsManager;
	24	class AliTRDdigitsParam;
	25	class AliTRDarrayADC;
	26	class AliTRDSignalIndex;
cc26f39c	27	class AliTRDtrackletContainer;
d60fe037	28
84f471a7	29	#define TRDMAXTBINS 63
	30	#define TRDMAXADC 21
	31	#define TRDMAXMCM 4 * 16
	32	#define MAXTRACKLETSPERHC 256
	33
8df1f8f5	34	class AliTRDrawStream : public TObject
d60fe037	35	{
	36	public:
	37	AliTRDrawStream(AliRawReader *rawReader = 0x0);
	38	~AliTRDrawStream();
	39
84f471a7	40	enum { kDDLOffset = 0x400 }; // Offset for DDL numbers
84f471a7	41
d60fe037	42	Bool_t SetReader(AliRawReader *rawReader) { fRawReader = rawReader; return kTRUE; }
d60fe037	43	void SetDigitsManager(AliTRDdigitsManager *digMgr) { fDigitsManager = digMgr; }
5fdfc9e4	44	void SetTrackletArray(TClonesArray *ar) { fTracklets = ar; }
	45	void SetTrackArray(TClonesArray *ar) { fTracks = ar; }
	46	void SetMarkerArray(TClonesArray *ar) { fMarkers = ar; }
	47
	48	TClonesArray* GetTrackletArray() const { return fTracklets; }
	49	TClonesArray* GetTrackArray() const { return fTracks; }
	50	TClonesArray* GetMarkerArray() const { return fMarkers; }
d60fe037	51
f4b3235e	52	AliTRDdigitsManager* GetDigitsManager() const { return fDigitsManager; }
	53	TTree *GetTrackletTree() const { return fTrackletTree; }
	54
d60fe037	55	Bool_t ReadEvent(TTree *trackletTree = 0x0);
	56
	57	Bool_t NextDDL();
	58	Int_t NextChamber(AliTRDdigitsManager *digMgr,
84f471a7	59	UInt_t ** /* trackletContainer /=NULL, UShort_t * /* errorContainer */=NULL);
d60fe037	60
67271412	61	Bool_t ConnectTracklets(TTree *trklTree);
67271412	62
5fdfc9e4	63	void StoreErrorsInTree() { fStoreError = &AliTRDrawStream::StoreErrorTree; }
5fdfc9e4	64	void StoreErrorsInArray() { fStoreError = &AliTRDrawStream::StoreErrorArray; }
f4b3235e	65	void EnableErrorStorage() { fStoreError = &AliTRDrawStream::StoreErrorTree; }
	66	void DisableErrorStorage() { fStoreError = &AliTRDrawStream::ForgetError; }
	67
d60fe037	68	// error handling
	69	enum ErrorCode_t {
	70	kUnknown = 0,
	71	kLinkMonitor,
	72	kPtrgCntMismatch,
	73	kNonTrdEq,
	74	kStackHeaderInvalid,
	75	kInvalidDetector,
	76	kNoDigits,
	77	kHCmismatch,
	78	kHCcheckFailed,
	79	kPosUnexp,
	80	kTPmodeInvalid,
	81	kTPmismatch,
	82	kNtimebinsChanged,
	83	kAdcMaskInconsistent,
	84	kAdcCheckInvalid,
	85	kAdcDataAbort,
	86	kAdcChannelsMiss,
	87	kMissMcmHeaders,
	88	kLastErrorCode
	89	};
	90
cc26f39c	91	enum ErrorBehav_t {
92223bf6	92	kTolerate = 0,
	93	kAbort = 1,
	94	kDiscardMCM = 2,
	95	kDiscardHC = 4
cc26f39c	96	};
cc26f39c	97
5fdfc9e4	98	enum MarkerCode_t {
8df9496c	99	kHCactive = 1,
8df9496c	100	kSecactive = 2
5fdfc9e4	101	};
5fdfc9e4	102
0508ca31	103	TTree* GetErrorTree() const { return fErrors; }
d60fe037	104	static const char* GetErrorMessage(ErrorCode_t errCode);
d60fe037	105
8df9496c	106	class AliTRDrawStreamError : public TObject {
	107	public:
	108	AliTRDrawStreamError(Int_t error = 0, Int_t sector = -1, Int_t stack = -1, Int_t link = -1, Int_t rob = -1, Int_t mcm = -1);
	109	virtual ~AliTRDrawStreamError() {}
	110	Int_t fError; // error code
	111	Int_t fSector; // sector
	112	Int_t fStack; // stack
	113	Int_t fLink; // link
	114	Int_t fRob; // ROB no
	115	Int_t fMcm; // MCM no
	116	ClassDef(AliTRDrawStreamError, 1);
	117	};
	118
cc26f39c	119	// event statistics
	120	class AliTRDrawStats : public TObject {
	121	public:
	122	AliTRDrawStats() : TObject(), fBytesRead(0) {}
	123	void ClearStats();
	124
	125	class AliTRDrawStatsSector : public TObject {
	126	public:
	127	AliTRDrawStatsSector() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
	128	void ClearStats();
	129
	130	class AliTRDrawStatsHC : public TObject {
	131	public:
	132	AliTRDrawStatsHC() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
	133	void ClearStats();
	134
	135	Int_t fBytes; // number of bytes (not necessarily read)
	136	Int_t fBytesRead; // number of bytes read
	137	Int_t fNTracklets; // number of tracklets
	138	Int_t fNMCMs; // number of MCMs (from MCM headers)
	139	Int_t fNChannels; // number of channels
	140	ClassDef(AliTRDrawStatsHC, 1);
	141	};
	142
	143	Int_t fBytes; // number of bytes (not necessarily read)
	144	Int_t fBytesRead; // number of bytes read
	145	Int_t fNTracklets; // number of tracklets
	146	Int_t fNMCMs; // number of MCMs (from MCM headers)
	147	Int_t fNChannels; // number of channels
	148	AliTRDrawStatsHC fStatsHC[60]; //[60] HC-wise statistics
	149	ClassDef(AliTRDrawStatsSector, 1);
	150	};
	151
cc26f39c	152	AliTRDrawStatsSector fStatsSector[18]; //[18] sector-wise statistics
	153	Int_t fBytesRead; // number of bytes read
	154	ClassDef(AliTRDrawStats, 1);
	155	};
	156
	157	AliTRDrawStats fStats; // event statistics, clearing must be done by the user
	158
	159	AliTRDrawStats* GetStats() { return &fStats; }
92305359	160	Int_t GetEventSize(Int_t sector) const { return fStats.fStatsSector[sector].fBytes; }
	161	Int_t GetNTracklets(Int_t sector) const { return fStats.fStatsSector[sector].fNTracklets; }
	162	Int_t GetNMCMs(Int_t sector) const { return fStats.fStatsSector[sector].fNMCMs; }
	163	Int_t GetNChannels(Int_t sector) const { return fStats.fStatsSector[sector].fNChannels; }
cc26f39c	164
	165	// raw data dumping
	166	void SetDumpMCM(Int_t det, Int_t rob, Int_t mcm, Bool_t dump = kTRUE);
	167
92305359	168	Bool_t IsDumping() const { return (fNDumpMCMs > 0); }
92305359	169	Bool_t DumpingMCM(Int_t det, Int_t rob, Int_t mcm) const;
cc26f39c	170
	171	void DumpRaw(TString title, UInt_t *start, Int_t length);
	172
d60fe037	173	protected:
	174	Int_t ReadSmHeader();
	175	Int_t ReadStackIndexHeader(Int_t stack);
	176
	177	Int_t ReadLinkData();
	178	Int_t ReadTracklets();
	179	Int_t ReadHcHeader();
	180	Int_t ReadTPData(Int_t mode = 1);
	181	Int_t ReadZSData();
	182	Int_t ReadNonZSData();
	183
92223bf6	184	Int_t SeekNextLink();
92223bf6	185
d60fe037	186	// MCM header decoding
0508ca31	187	Int_t ROB(UInt_t mcmhdr) const { return 0x7 & mcmhdr >> 28; }
	188	Int_t MCM(UInt_t mcmhdr) const { return 0xf & mcmhdr >> 24; }
	189	Int_t Row(UInt_t mcmhdr) const { return (ROB(mcmhdr) / 2) * 4 + MCM(mcmhdr) / 4; }
	190	Int_t AdcColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 21 + (ROB(mcmhdr) % 2) * 84 - 1; }
	191	Int_t PadColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 18 + (ROB(mcmhdr) % 2) * 72 + 1; }
	192	Int_t EvNo(UInt_t mcmhdr) const { return 0xfffff & mcmhdr >> 4; }
	193	Int_t Check(UInt_t mcmhdr) const { return 0xf & mcmhdr; }
	194	Int_t CouldBeMCMhdr(UInt_t mcmhdr) const { return ((0xf & mcmhdr) == 0xc); }
	195
	196	Int_t GetMCMReadoutPos(Int_t mcm) const { return (mcm > -1 && mcm < 16) ? fgkMcmOrder[mcm] : -1; }
	197	Int_t GetROBReadoutPos(Int_t rob) const { return (rob > -1 && rob < 4) ? fgkRobOrder[rob] : -1; }
d60fe037	198
d60fe037	199	// ADC mask decoding
0508ca31	200	Int_t GetActiveChannels(UInt_t adcmask) const { return 0x1fffff & adcmask >> 4; }
82029d44	201	inline Int_t GetNActiveChannelsFromMask(UInt_t adcmask) const; // { Int_t nch = 0; for (Int_t i = 0; i < 21; i++) if ((GetActiveChannels(adcmask) & 1 << i)) nch++; return nch; }
0508ca31	202	Int_t GetNActiveChannels(UInt_t adcmask) const { return (0x1f & ~(adcmask >> 25)); }
0508ca31	203	Int_t CouldBeADCmask(UInt_t adcmask) const { return ((0xf & adcmask) == 0xc && (0x3 & adcmask >> 30) == 0x1); }
d60fe037	204
d60fe037	205	// error message generation
1d62be37	206	void EquipmentError(ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	207	void StackError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	208	void LinkError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	209	void ROBError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	210	void MCMError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
f4b3235e	211	void StoreErrorTree() { fErrors->Fill(); }
5fdfc9e4	212	void StoreErrorArray() { new ((*fMarkers)[fMarkers->GetEntriesFast()]) AliTRDrawStreamError(fLastError); }
f4b3235e	213	void ForgetError() { return; }
f4b3235e	214	void (AliTRDrawStream::*fStoreError)(); //! function pointer to method used for storing the error
d60fe037	215
92305359	216	static const char* fgkErrorMessages[kLastErrorCode]; // error messages corresponding to the error codes
92305359	217	static Int_t fgErrorDebugLevel[kLastErrorCode]; // error debug level
92223bf6	218	static ErrorBehav_t fgErrorBehav[kLastErrorCode]; // bevhaviour in case of error of given type
d60fe037	219
d60fe037	220	// I/O
0508ca31	221	AliRawReader *fRawReader; // pointer to the raw reader to take the data from
	222	AliTRDdigitsManager *fDigitsManager; // pointer to the digitsManager to fill the data
	223	AliTRDdigitsParam *fDigitsParam; // pointer to the parameters belonging to the digits
d60fe037	224
0508ca31	225	TTree *fErrors; // tree containing the occured error codes
8df9496c	226	AliTRDrawStreamError fLastError; // last error which occured
92223bf6	227	UInt_t fErrorFlags; // error flags used to steer subsequent reading
92223bf6	228	char fErrorBuffer[100]; // buffer for error message
d60fe037	229
0508ca31	230	UInt_t *fPayloadStart; // pointer to start of data payload
0508ca31	231	UInt_t *fPayloadCurr; // pointer to current reading position in the payload
cc26f39c	232	Int_t fPayloadSize; // size of the payload (in UInt_t words)
d60fe037	233
0508ca31	234	static const Int_t fgkNlinks; // number of links to read
	235	static const Int_t fgkNstacks; // number of stacks to read
	236	static const UInt_t fgkDataEndmarker; // data endmarker
	237	static const UInt_t fgkTrackletEndmarker; // tracklet endmarker
	238	static const Int_t fgkMcmOrder []; // expected readout order of the MCMs
	239	static const Int_t fgkRobOrder []; // expected readout order of the ROBs
d60fe037	240
d60fe037	241	// persistent information
0508ca31	242	Int_t fNtimebins; // number of timebins
0508ca31	243	Int_t fLastEvId; // Event ID of last event
d60fe037	244
d60fe037	245	// information valid at current reader position
0508ca31	246	// all the variables fCurr... refer to the value at the current
	247	// reading position
	248	Int_t fCurrSlot; // current slot
	249	Int_t fCurrLink; // current link
	250	Int_t fCurrRobPos; // current ROB number
	251	Int_t fCurrMcmPos; // current MCM number
d60fe037	252
d60fe037	253	// DDL header
0508ca31	254	UInt_t fCurrEquipmentId; // current Equipment ID
d60fe037	255
d60fe037	256	// SMU index header
0508ca31	257	UInt_t fCurrSmuIndexHeaderSize; // current size of the SMU index header
	258	UInt_t fCurrSmuIndexHeaderVersion; // current version of the SMU index header
	259	UInt_t fCurrTrackEnable; // current value of track enable
	260	UInt_t fCurrTrackletEnable; // current value of tracklet enable
	261	UInt_t fCurrStackMask; // current mask of active stacks
d60fe037	262
d60fe037	263	// Stack index header
0508ca31	264	UInt_t *fCurrStackIndexWord; // current stack index words
	265	UInt_t *fCurrStackHeaderSize; // current stack index sizes
	266	UInt_t *fCurrStackHeaderVersion; // current stack header versions
	267	UInt_t *fCurrLinkMask; // current link masks
	268	UInt_t *fCurrCleanCheckout; // current clean checkout flags
	269	UInt_t *fCurrBoardId; // current board IDs
	270	UInt_t *fCurrHwRev; // current hardware revision
	271	UInt_t *fCurrLinkMonitorFlags; // current link monitor flags
	272	UInt_t *fCurrLinkDataTypeFlags; // current link data flags
	273	UInt_t *fCurrLinkDebugFlags; // current link debug flags
d60fe037	274
d60fe037	275	// HC information
0508ca31	276	Int_t fCurrSpecial; // current value of the special flag
	277	Int_t fCurrMajor; // current major version
	278	Int_t fCurrMinor; // current minor version
	279	Int_t fCurrAddHcWords; // current number of additional HC-header words
	280	Int_t fCurrSm; // current sector
	281	Int_t fCurrStack; // current stack
	282	Int_t fCurrLayer; // current layer
	283	Int_t fCurrSide; // current side
	284	Int_t fCurrHC; // current HC
	285	Int_t fCurrCheck; // current check bits
	286	Int_t fCurrNtimebins; // current number of timebins
	287	Int_t fCurrBC; // current BC
	288	Int_t fCurrPtrgCnt; // current pretrigger count
	289	Int_t fCurrPtrgPhase; // current pretrigger phase
d60fe037	290
cc26f39c	291	// settings for dumping
	292	Int_t fDumpMCM[100]; // MCMs to dump
	293	Int_t fNDumpMCMs; // number of MCMs to dump
	294
d60fe037	295	// tracklet information
0508ca31	296	TClonesArray *fTrackletArray; // pointer to array for tracklet storage
d60fe037	297
d60fe037	298	// output data
0508ca31	299	AliTRDarrayADC *fAdcArray; // pointer to ADC array
	300	AliTRDSignalIndex *fSignalIndex; // pointer to the signal index
	301	TTree *fTrackletTree; // pointer to the tree for tracklet storage
5fdfc9e4	302	TClonesArray *fTracklets; // pointer to array of tracklets
	303	TClonesArray *fTracks; // pointer to array of GTU tracks
	304	TClonesArray *fMarkers; // pointer to array of markers (data present, errors, ...)
d60fe037	305
d60fe037	306	AliTRDrawStream(const AliTRDrawStream&); // not implemented
0508ca31	307	AliTRDrawStream& operator=(const AliTRDrawStream&); // not implemented
d60fe037	308
	309	ClassDef(AliTRDrawStream, 0);
	310	};
	311
82029d44	312	Int_t AliTRDrawStream::GetNActiveChannelsFromMask(UInt_t adcmask) const
	313	{
	314	// return number of active bits in the ADC mask
	315
	316	adcmask = GetActiveChannels(adcmask);
	317	adcmask = adcmask - ((adcmask >> 1) & 0x55555555);
	318	adcmask = (adcmask & 0x33333333) + ((adcmask >> 2) & 0x33333333);
	319	return (((adcmask + (adcmask >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
	320	}
	321
d60fe037	322	#endif