[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"

#include "AliLog.h"

class TObjArray;
class TString;
class TBranch;

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

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

  enum { kDDLOffset = 0x400,                                  // Offset for DDL numbers
         kDDLMax    = 0x411 };                                // Max DDL number for TRD SM

  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);
  Int_t NextChamber(AliTRDdigitsManager *digMgr,
  		      UInt_t ** /* trackletContainer */, UShort_t ** /* errorContainer */) { AliError("Deprecated, use NextChamber(AliTRDdigitsManger*) instead!"); return NextChamber(digMgr); }

  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,
    kEvCntMismatch,
    kNonTrdEq,
    kStackHeaderInvalid,
    kInvalidDetector,
    kNoDigits,
    kHCmismatch,
    kHCcheckFailed,
    kPosUnexp,
    kTPmodeInvalid,
    kTPmismatch,
    kNtimebinsChanged,
    kAdcMaskInconsistent,
    kAdcCheckInvalid,
    kAdcDataAbort,
    kAdcChannelsMiss,
    kMissMcmHeaders,
    kMissTpData,
    kCRCmismatch,
    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);
  static void SetErrorDebugLevel(ErrorCode_t error, Int_t level) { fgErrorDebugLevel[error] = level; }
  static void SetErrorBehaviour(ErrorCode_t error, ErrorBehav_t behav) { fgErrorBehav[error] = behav; }

  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* 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; }

  ULong64_t GetTrkFlags(Int_t sector, Int_t stack) const { return fCurrTrkFlags[sector*fgkNstacks + stack]; }
  UInt_t GetTriggerFlags(Int_t sector) const { return fCurrTrgFlags[sector]; }

  // 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;

  TString DumpRaw(TString title, UInt_t *start, Int_t length, UInt_t endmarker = 0xffffffff);
  TString DumpMcmHeader(TString title, UInt_t word);
  TString DumpAdcMask(TString title, UInt_t word);

  static void SortTracklets(TClonesArray *trklArray, TList &sortedTracklets, Int_t *indices);

  // temporary: allow to change expected readout order
  static void SetMCMReadoutPos(Int_t mcm, Int_t pos) { if (mcm > -1 && mcm < 16) fgMcmOrder[mcm] = pos; }
  static void SetROBReadoutPos(Int_t robpair, Int_t pos) { if (robpair > -1 && robpair < 4) fgMcmOrder[robpair] = pos; }

 protected:
  Int_t ReadGTUHeaders(UInt_t *buffer);
  Int_t ReadSmHeader();
  Int_t ReadTrackingHeader(Int_t stack);
  Int_t ReadTriggerHeaders();
  Int_t ReadStackHeader(Int_t stack);
  Int_t DecodeGTUtracks();
  Int_t ReadGTUTrailer();

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

  Int_t SeekNextStack();
  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) ? fgMcmOrder[mcm] : -1; }
  Int_t GetROBReadoutPos(Int_t rob) const { return (rob > -1 && rob < 4) ? fgRobOrder[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

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

  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 fgkNsectors;               // number of sectors
  static const Int_t fgkNstacks;                // number of stacks to read
  static const Int_t fgkNtriggers;              // number of triggers in data stream
  static const UInt_t fgkDataEndmarker;         // data endmarker
  static const UInt_t fgkTrackletEndmarker;     // tracklet endmarker
  static const UInt_t fgkStackEndmarker[];      // stack endmarker (used from version 0xd on)
  static       Int_t fgMcmOrder [];             // expected readout order of the MCMs
  static       Int_t fgRobOrder [];             // 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

  // SM header
  UInt_t fCurrSmHeaderSize;                     // current size of the SM header
  UInt_t fCurrSmHeaderVersion;                  // current version of the SM header
  UInt_t fCurrTrailerReadout;			// current presence of trailer (after the payload)
  UInt_t fCurrTrgHeaderAvail;	        	// current trigger information availability
  UInt_t fCurrTrgHeaderReadout;                 // current readout mode for the trigger headers
  UInt_t fCurrTrkHeaderAvail;	        	// current tracking information availability
  UInt_t fCurrStackEndmarkerAvail;              // current stack endmarker availability
  UInt_t fCurrEvType;            		// current event type
  UInt_t fCurrTriggerEnable;                    // current trigger enable
  UInt_t fCurrTriggerFired;                     // current trigger fired
  UInt_t fCurrTrackEnable;			// current value of track enable
  UInt_t fCurrTrackletEnable; 			// current value of tracklet enable
  UInt_t fCurrStackMask;			// current mask of active stacks

  // Tracking header
  UInt_t *fCurrTrkHeaderIndexWord;              // current tracking header index word
  UInt_t *fCurrTrkHeaderSize;                   // current tracking header index word
  ULong64_t *fCurrTrkFlags;                     // current tracking done flags

  // Trigger header
  UInt_t *fCurrTrgHeaderIndexWord;              // current tracking header index word
  UInt_t *fCurrTrgHeaderSize;                   // current tracking header index word
  UInt_t *fCurrTrgFlags;			// current trigger flags of all sectors

  // Stack 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 *fCurrHwRevTMU;			// current hardware revision
  UInt_t *fCurrLinkMonitorFlags;		// current link monitor flags
  UInt_t *fCurrLinkDataTypeFlags;		// current link data flags
  UInt_t *fCurrLinkDebugFlags;			// current link debug flags

  // CRC checks from trailer
  Char_t fCurrMatchFlagsSRAM;
  Char_t fCurrMatchFlagsPostBP;
  UInt_t fCurrChecksumStack[5];
  UInt_t fCurrChecksumSIU;

  // 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	//
5f006bd7	6	// decoding of TRD raw data stream
0508ca31	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
9cb9c409	18	#include "AliLog.h"
9cb9c409	19
d60fe037	20	class TObjArray;
d60fe037	21	class TString;
cc26f39c	22	class TBranch;
d60fe037	23
	24	class AliRawReader;
	25	class AliTRDdigitsManager;
	26	class AliTRDdigitsParam;
	27	class AliTRDarrayADC;
	28	class AliTRDSignalIndex;
cc26f39c	29	class AliTRDtrackletContainer;
d60fe037	30
8df1f8f5	31	class AliTRDrawStream : public TObject
d60fe037	32	{
	33	public:
	34	AliTRDrawStream(AliRawReader *rawReader = 0x0);
	35	~AliTRDrawStream();
	36
9cb9c409	37	enum { kDDLOffset = 0x400, // Offset for DDL numbers
9cb9c409	38	kDDLMax = 0x411 }; // Max DDL number for TRD SM
84f471a7	39
d60fe037	40	Bool_t SetReader(AliRawReader *rawReader) { fRawReader = rawReader; return kTRUE; }
d60fe037	41	void SetDigitsManager(AliTRDdigitsManager *digMgr) { fDigitsManager = digMgr; }
5fdfc9e4	42	void SetTrackletArray(TClonesArray *ar) { fTracklets = ar; }
	43	void SetTrackArray(TClonesArray *ar) { fTracks = ar; }
	44	void SetMarkerArray(TClonesArray *ar) { fMarkers = ar; }
	45
	46	TClonesArray* GetTrackletArray() const { return fTracklets; }
	47	TClonesArray* GetTrackArray() const { return fTracks; }
	48	TClonesArray* GetMarkerArray() const { return fMarkers; }
d60fe037	49
f4b3235e	50	AliTRDdigitsManager* GetDigitsManager() const { return fDigitsManager; }
	51	TTree *GetTrackletTree() const { return fTrackletTree; }
	52
d60fe037	53	Bool_t ReadEvent(TTree *trackletTree = 0x0);
	54
	55	Bool_t NextDDL();
5f006bd7	56	Int_t NextChamber(AliTRDdigitsManager *digMgr);
9cb9c409	57	Int_t NextChamber(AliTRDdigitsManager *digMgr,
2519cca4	58	UInt_t ** /* trackletContainer /, UShort_t * /* errorContainer /) { AliError("Deprecated, use NextChamber(AliTRDdigitsManger) instead!"); return NextChamber(digMgr); }
d60fe037	59
67271412	60	Bool_t ConnectTracklets(TTree *trklTree);
67271412	61
5fdfc9e4	62	void StoreErrorsInTree() { fStoreError = &AliTRDrawStream::StoreErrorTree; }
5fdfc9e4	63	void StoreErrorsInArray() { fStoreError = &AliTRDrawStream::StoreErrorArray; }
f4b3235e	64	void EnableErrorStorage() { fStoreError = &AliTRDrawStream::StoreErrorTree; }
	65	void DisableErrorStorage() { fStoreError = &AliTRDrawStream::ForgetError; }
	66
d60fe037	67	// error handling
5f006bd7	68	enum ErrorCode_t {
	69	kUnknown = 0,
	70	kLinkMonitor,
52a2b6c0	71	kEvCntMismatch,
d60fe037	72	kNonTrdEq,
	73	kStackHeaderInvalid,
	74	kInvalidDetector,
	75	kNoDigits,
	76	kHCmismatch,
	77	kHCcheckFailed,
	78	kPosUnexp,
	79	kTPmodeInvalid,
	80	kTPmismatch,
	81	kNtimebinsChanged,
	82	kAdcMaskInconsistent,
	83	kAdcCheckInvalid,
	84	kAdcDataAbort,
	85	kAdcChannelsMiss,
	86	kMissMcmHeaders,
2519cca4	87	kMissTpData,
52a2b6c0	88	kCRCmismatch,
d60fe037	89	kLastErrorCode
5f006bd7	90	};
d60fe037	91
cc26f39c	92	enum ErrorBehav_t {
92223bf6	93	kTolerate = 0,
5f006bd7	94	kAbort = 1,
92223bf6	95	kDiscardMCM = 2,
92223bf6	96	kDiscardHC = 4
cc26f39c	97	};
cc26f39c	98
5fdfc9e4	99	enum MarkerCode_t {
8df9496c	100	kHCactive = 1,
8df9496c	101	kSecactive = 2
5fdfc9e4	102	};
5fdfc9e4	103
0508ca31	104	TTree* GetErrorTree() const { return fErrors; }
d60fe037	105	static const char* GetErrorMessage(ErrorCode_t errCode);
9cb9c409	106	static void SetErrorDebugLevel(ErrorCode_t error, Int_t level) { fgErrorDebugLevel[error] = level; }
9cb9c409	107	static void SetErrorBehaviour(ErrorCode_t error, ErrorBehav_t behav) { fgErrorBehav[error] = behav; }
d60fe037	108
8df9496c	109	class AliTRDrawStreamError : public TObject {
8df9496c	110	public:
5f006bd7	111	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);
8df9496c	112	virtual ~AliTRDrawStreamError() {}
	113	Int_t fError; // error code
	114	Int_t fSector; // sector
	115	Int_t fStack; // stack
	116	Int_t fLink; // link
	117	Int_t fRob; // ROB no
	118	Int_t fMcm; // MCM no
	119	ClassDef(AliTRDrawStreamError, 1);
	120	};
	121
cc26f39c	122	// event statistics
	123	class AliTRDrawStats : public TObject {
	124	public:
	125	AliTRDrawStats() : TObject(), fBytesRead(0) {}
	126	void ClearStats();
	127
	128	class AliTRDrawStatsSector : public TObject {
	129	public:
	130	AliTRDrawStatsSector() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
	131	void ClearStats();
	132
	133	class AliTRDrawStatsHC : public TObject {
	134	public:
	135	AliTRDrawStatsHC() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
	136	void ClearStats();
	137
	138	Int_t fBytes; // number of bytes (not necessarily read)
	139	Int_t fBytesRead; // number of bytes read
	140	Int_t fNTracklets; // number of tracklets
	141	Int_t fNMCMs; // number of MCMs (from MCM headers)
	142	Int_t fNChannels; // number of channels
	143	ClassDef(AliTRDrawStatsHC, 1);
	144	};
	145
	146	Int_t fBytes; // number of bytes (not necessarily read)
	147	Int_t fBytesRead; // number of bytes read
	148	Int_t fNTracklets; // number of tracklets
	149	Int_t fNMCMs; // number of MCMs (from MCM headers)
	150	Int_t fNChannels; // number of channels
	151	AliTRDrawStatsHC fStatsHC[60]; //[60] HC-wise statistics
	152	ClassDef(AliTRDrawStatsSector, 1);
	153	};
	154
cc26f39c	155	AliTRDrawStatsSector fStatsSector[18]; //[18] sector-wise statistics
	156	Int_t fBytesRead; // number of bytes read
	157	ClassDef(AliTRDrawStats, 1);
	158	};
	159
cc26f39c	160	AliTRDrawStats* GetStats() { return &fStats; }
92305359	161	Int_t GetEventSize(Int_t sector) const { return fStats.fStatsSector[sector].fBytes; }
	162	Int_t GetNTracklets(Int_t sector) const { return fStats.fStatsSector[sector].fNTracklets; }
	163	Int_t GetNMCMs(Int_t sector) const { return fStats.fStatsSector[sector].fNMCMs; }
	164	Int_t GetNChannels(Int_t sector) const { return fStats.fStatsSector[sector].fNChannels; }
cc26f39c	165
2519cca4	166	ULong64_t GetTrkFlags(Int_t sector, Int_t stack) const { return fCurrTrkFlags[sector*fgkNstacks + stack]; }
	167	UInt_t GetTriggerFlags(Int_t sector) const { return fCurrTrgFlags[sector]; }
	168
cc26f39c	169	// raw data dumping
	170	void SetDumpMCM(Int_t det, Int_t rob, Int_t mcm, Bool_t dump = kTRUE);
	171
92305359	172	Bool_t IsDumping() const { return (fNDumpMCMs > 0); }
92305359	173	Bool_t DumpingMCM(Int_t det, Int_t rob, Int_t mcm) const;
cc26f39c	174
5f006bd7	175	TString DumpRaw(TString title, UInt_t *start, Int_t length, UInt_t endmarker = 0xffffffff);
9cb9c409	176	TString DumpMcmHeader(TString title, UInt_t word);
	177	TString DumpAdcMask(TString title, UInt_t word);
	178
52a2b6c0	179	static void SortTracklets(TClonesArray trklArray, TList &sortedTracklets, Int_t indices);
52a2b6c0	180
9cb9c409	181	// temporary: allow to change expected readout order
	182	static void SetMCMReadoutPos(Int_t mcm, Int_t pos) { if (mcm > -1 && mcm < 16) fgMcmOrder[mcm] = pos; }
	183	static void SetROBReadoutPos(Int_t robpair, Int_t pos) { if (robpair > -1 && robpair < 4) fgMcmOrder[robpair] = pos; }
cc26f39c	184
d60fe037	185	protected:
9cb9c409	186	Int_t ReadGTUHeaders(UInt_t *buffer);
d60fe037	187	Int_t ReadSmHeader();
9cb9c409	188	Int_t ReadTrackingHeader(Int_t stack);
	189	Int_t ReadTriggerHeaders();
	190	Int_t ReadStackHeader(Int_t stack);
	191	Int_t DecodeGTUtracks();
	192	Int_t ReadGTUTrailer();
d60fe037	193
	194	Int_t ReadLinkData();
	195	Int_t ReadTracklets();
	196	Int_t ReadHcHeader();
	197	Int_t ReadTPData(Int_t mode = 1);
	198	Int_t ReadZSData();
	199	Int_t ReadNonZSData();
	200
52a2b6c0	201	Int_t SeekNextStack();
92223bf6	202	Int_t SeekNextLink();
92223bf6	203
d60fe037	204	// MCM header decoding
0508ca31	205	Int_t ROB(UInt_t mcmhdr) const { return 0x7 & mcmhdr >> 28; }
	206	Int_t MCM(UInt_t mcmhdr) const { return 0xf & mcmhdr >> 24; }
	207	Int_t Row(UInt_t mcmhdr) const { return (ROB(mcmhdr) / 2) * 4 + MCM(mcmhdr) / 4; }
	208	Int_t AdcColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 21 + (ROB(mcmhdr) % 2) * 84 - 1; }
	209	Int_t PadColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 18 + (ROB(mcmhdr) % 2) * 72 + 1; }
	210	Int_t EvNo(UInt_t mcmhdr) const { return 0xfffff & mcmhdr >> 4; }
	211	Int_t Check(UInt_t mcmhdr) const { return 0xf & mcmhdr; }
	212	Int_t CouldBeMCMhdr(UInt_t mcmhdr) const { return ((0xf & mcmhdr) == 0xc); }
	213
9cb9c409	214	Int_t GetMCMReadoutPos(Int_t mcm) const { return (mcm > -1 && mcm < 16) ? fgMcmOrder[mcm] : -1; }
9cb9c409	215	Int_t GetROBReadoutPos(Int_t rob) const { return (rob > -1 && rob < 4) ? fgRobOrder[rob] : -1; }
d60fe037	216
d60fe037	217	// ADC mask decoding
0508ca31	218	Int_t GetActiveChannels(UInt_t adcmask) const { return 0x1fffff & adcmask >> 4; }
82029d44	219	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	220	Int_t GetNActiveChannels(UInt_t adcmask) const { return (0x1f & ~(adcmask >> 25)); }
0508ca31	221	Int_t CouldBeADCmask(UInt_t adcmask) const { return ((0xf & adcmask) == 0xc && (0x3 & adcmask >> 30) == 0x1); }
5f006bd7	222
d60fe037	223	// error message generation
1dd71b58	224	void EquipmentError(ErrorCode_t err = kUnknown, const char *const msg = " ", ...);
	225	void StackError (ErrorCode_t err = kUnknown, const char *const msg = " ", ...);
	226	void LinkError (ErrorCode_t err = kUnknown, const char *const msg = " ", ...);
	227	void ROBError (ErrorCode_t err = kUnknown, const char *const msg = " ", ...);
	228	void MCMError (ErrorCode_t err = kUnknown, const char *const msg = " ", ...);
f4b3235e	229	void StoreErrorTree() { fErrors->Fill(); }
5fdfc9e4	230	void StoreErrorArray() { new ((*fMarkers)[fMarkers->GetEntriesFast()]) AliTRDrawStreamError(fLastError); }
f4b3235e	231	void ForgetError() { return; }
f4b3235e	232	void (AliTRDrawStream::*fStoreError)(); //! function pointer to method used for storing the error
d60fe037	233
92305359	234	static const char* fgkErrorMessages[kLastErrorCode]; // error messages corresponding to the error codes
92305359	235	static Int_t fgErrorDebugLevel[kLastErrorCode]; // error debug level
92223bf6	236	static ErrorBehav_t fgErrorBehav[kLastErrorCode]; // bevhaviour in case of error of given type
d60fe037	237
d60fe037	238	// I/O
5f006bd7	239	AliRawReader *fRawReader; // pointer to the raw reader to take the data from
0508ca31	240	AliTRDdigitsManager *fDigitsManager; // pointer to the digitsManager to fill the data
0508ca31	241	AliTRDdigitsParam *fDigitsParam; // pointer to the parameters belonging to the digits
d60fe037	242
0508ca31	243	TTree *fErrors; // tree containing the occured error codes
8df9496c	244	AliTRDrawStreamError fLastError; // last error which occured
92223bf6	245	UInt_t fErrorFlags; // error flags used to steer subsequent reading
92223bf6	246	char fErrorBuffer[100]; // buffer for error message
d60fe037	247
2519cca4	248	AliTRDrawStats fStats; // event statistics, clearing must be done by the user
2519cca4	249
0508ca31	250	UInt_t *fPayloadStart; // pointer to start of data payload
0508ca31	251	UInt_t *fPayloadCurr; // pointer to current reading position in the payload
cc26f39c	252	Int_t fPayloadSize; // size of the payload (in UInt_t words)
d60fe037	253
0508ca31	254	static const Int_t fgkNlinks; // number of links to read
9cb9c409	255	static const Int_t fgkNsectors; // number of sectors
0508ca31	256	static const Int_t fgkNstacks; // number of stacks to read
9cb9c409	257	static const Int_t fgkNtriggers; // number of triggers in data stream
5f006bd7	258	static const UInt_t fgkDataEndmarker; // data endmarker
0508ca31	259	static const UInt_t fgkTrackletEndmarker; // tracklet endmarker
52a2b6c0	260	static const UInt_t fgkStackEndmarker[]; // stack endmarker (used from version 0xd on)
9cb9c409	261	static Int_t fgMcmOrder []; // expected readout order of the MCMs
9cb9c409	262	static Int_t fgRobOrder []; // expected readout order of the ROBs
d60fe037	263
d60fe037	264	// persistent information
0508ca31	265	Int_t fNtimebins; // number of timebins
5f006bd7	266	Int_t fLastEvId; // Event ID of last event
d60fe037	267
d60fe037	268	// information valid at current reader position
0508ca31	269	// all the variables fCurr... refer to the value at the current
0508ca31	270	// reading position
5f006bd7	271	Int_t fCurrSlot; // current slot
0508ca31	272	Int_t fCurrLink; // current link
	273	Int_t fCurrRobPos; // current ROB number
	274	Int_t fCurrMcmPos; // current MCM number
d60fe037	275
d60fe037	276	// DDL header
0508ca31	277	UInt_t fCurrEquipmentId; // current Equipment ID
d60fe037	278
9cb9c409	279	// SM header
	280	UInt_t fCurrSmHeaderSize; // current size of the SM header
	281	UInt_t fCurrSmHeaderVersion; // current version of the SM header
	282	UInt_t fCurrTrailerReadout; // current presence of trailer (after the payload)
	283	UInt_t fCurrTrgHeaderAvail; // current trigger information availability
	284	UInt_t fCurrTrgHeaderReadout; // current readout mode for the trigger headers
	285	UInt_t fCurrTrkHeaderAvail; // current tracking information availability
52a2b6c0	286	UInt_t fCurrStackEndmarkerAvail; // current stack endmarker availability
9cb9c409	287	UInt_t fCurrEvType; // current event type
	288	UInt_t fCurrTriggerEnable; // current trigger enable
	289	UInt_t fCurrTriggerFired; // current trigger fired
0508ca31	290	UInt_t fCurrTrackEnable; // current value of track enable
	291	UInt_t fCurrTrackletEnable; // current value of tracklet enable
	292	UInt_t fCurrStackMask; // current mask of active stacks
d60fe037	293
9cb9c409	294	// Tracking header
	295	UInt_t *fCurrTrkHeaderIndexWord; // current tracking header index word
	296	UInt_t *fCurrTrkHeaderSize; // current tracking header index word
2519cca4	297	ULong64_t *fCurrTrkFlags; // current tracking done flags
9cb9c409	298
	299	// Trigger header
	300	UInt_t *fCurrTrgHeaderIndexWord; // current tracking header index word
	301	UInt_t *fCurrTrgHeaderSize; // current tracking header index word
2519cca4	302	UInt_t *fCurrTrgFlags; // current trigger flags of all sectors
9cb9c409	303
9cb9c409	304	// Stack header
0508ca31	305	UInt_t *fCurrStackIndexWord; // current stack index words
	306	UInt_t *fCurrStackHeaderSize; // current stack index sizes
	307	UInt_t *fCurrStackHeaderVersion; // current stack header versions
	308	UInt_t *fCurrLinkMask; // current link masks
	309	UInt_t *fCurrCleanCheckout; // current clean checkout flags
	310	UInt_t *fCurrBoardId; // current board IDs
9cb9c409	311	UInt_t fCurrHwRev; // current hardware revision
9cb9c409	312	UInt_t *fCurrHwRevTMU; // current hardware revision
0508ca31	313	UInt_t *fCurrLinkMonitorFlags; // current link monitor flags
	314	UInt_t *fCurrLinkDataTypeFlags; // current link data flags
	315	UInt_t *fCurrLinkDebugFlags; // current link debug flags
d60fe037	316
52a2b6c0	317	// CRC checks from trailer
	318	Char_t fCurrMatchFlagsSRAM;
	319	Char_t fCurrMatchFlagsPostBP;
	320	UInt_t fCurrChecksumStack[5];
	321	UInt_t fCurrChecksumSIU;
	322
d60fe037	323	// HC information
0508ca31	324	Int_t fCurrSpecial; // current value of the special flag
	325	Int_t fCurrMajor; // current major version
	326	Int_t fCurrMinor; // current minor version
	327	Int_t fCurrAddHcWords; // current number of additional HC-header words
	328	Int_t fCurrSm; // current sector
	329	Int_t fCurrStack; // current stack
	330	Int_t fCurrLayer; // current layer
	331	Int_t fCurrSide; // current side
	332	Int_t fCurrHC; // current HC
	333	Int_t fCurrCheck; // current check bits
	334	Int_t fCurrNtimebins; // current number of timebins
	335	Int_t fCurrBC; // current BC
	336	Int_t fCurrPtrgCnt; // current pretrigger count
	337	Int_t fCurrPtrgPhase; // current pretrigger phase
d60fe037	338
cc26f39c	339	// settings for dumping
	340	Int_t fDumpMCM[100]; // MCMs to dump
	341	Int_t fNDumpMCMs; // number of MCMs to dump
	342
d60fe037	343	// tracklet information
0508ca31	344	TClonesArray *fTrackletArray; // pointer to array for tracklet storage
d60fe037	345
d60fe037	346	// output data
0508ca31	347	AliTRDarrayADC *fAdcArray; // pointer to ADC array
	348	AliTRDSignalIndex *fSignalIndex; // pointer to the signal index
	349	TTree *fTrackletTree; // pointer to the tree for tracklet storage
5fdfc9e4	350	TClonesArray *fTracklets; // pointer to array of tracklets
	351	TClonesArray *fTracks; // pointer to array of GTU tracks
	352	TClonesArray *fMarkers; // pointer to array of markers (data present, errors, ...)
d60fe037	353
d60fe037	354	AliTRDrawStream(const AliTRDrawStream&); // not implemented
0508ca31	355	AliTRDrawStream& operator=(const AliTRDrawStream&); // not implemented
d60fe037	356
	357	ClassDef(AliTRDrawStream, 0);
	358	};
	359
82029d44	360	Int_t AliTRDrawStream::GetNActiveChannelsFromMask(UInt_t adcmask) const
	361	{
	362	// return number of active bits in the ADC mask
	363
	364	adcmask = GetActiveChannels(adcmask);
	365	adcmask = adcmask - ((adcmask >> 1) & 0x55555555);
	366	adcmask = (adcmask & 0x33333333) + ((adcmask >> 2) & 0x33333333);
	367	return (((adcmask + (adcmask >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
	368	}
	369
d60fe037	370	#endif