[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, 
    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);
  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 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;

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

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

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

  // Trigger header
  UInt_t *fCurrTrgHeaderIndexWord;              // current tracking header index word
  UInt_t *fCurrTrgHeaderSize;                   // current tracking header index word

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

  // 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
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();
9cb9c409	56	Int_t NextChamber(AliTRDdigitsManager *digMgr);
	57	Int_t NextChamber(AliTRDdigitsManager *digMgr,
	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
	68	enum ErrorCode_t {
	69	kUnknown = 0,
	70	kLinkMonitor,
	71	kPtrgCntMismatch,
	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,
	87	kLastErrorCode
	88	};
	89
cc26f39c	90	enum ErrorBehav_t {
92223bf6	91	kTolerate = 0,
	92	kAbort = 1,
	93	kDiscardMCM = 2,
	94	kDiscardHC = 4
cc26f39c	95	};
cc26f39c	96
5fdfc9e4	97	enum MarkerCode_t {
8df9496c	98	kHCactive = 1,
8df9496c	99	kSecactive = 2
5fdfc9e4	100	};
5fdfc9e4	101
0508ca31	102	TTree* GetErrorTree() const { return fErrors; }
d60fe037	103	static const char* GetErrorMessage(ErrorCode_t errCode);
9cb9c409	104	static void SetErrorDebugLevel(ErrorCode_t error, Int_t level) { fgErrorDebugLevel[error] = level; }
9cb9c409	105	static void SetErrorBehaviour(ErrorCode_t error, ErrorBehav_t behav) { fgErrorBehav[error] = behav; }
d60fe037	106
8df9496c	107	class AliTRDrawStreamError : public TObject {
	108	public:
	109	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);
	110	virtual ~AliTRDrawStreamError() {}
	111	Int_t fError; // error code
	112	Int_t fSector; // sector
	113	Int_t fStack; // stack
	114	Int_t fLink; // link
	115	Int_t fRob; // ROB no
	116	Int_t fMcm; // MCM no
	117	ClassDef(AliTRDrawStreamError, 1);
	118	};
	119
cc26f39c	120	// event statistics
	121	class AliTRDrawStats : public TObject {
	122	public:
	123	AliTRDrawStats() : TObject(), fBytesRead(0) {}
	124	void ClearStats();
	125
	126	class AliTRDrawStatsSector : public TObject {
	127	public:
	128	AliTRDrawStatsSector() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
	129	void ClearStats();
	130
	131	class AliTRDrawStatsHC : public TObject {
	132	public:
	133	AliTRDrawStatsHC() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
	134	void ClearStats();
	135
	136	Int_t fBytes; // number of bytes (not necessarily read)
	137	Int_t fBytesRead; // number of bytes read
	138	Int_t fNTracklets; // number of tracklets
	139	Int_t fNMCMs; // number of MCMs (from MCM headers)
	140	Int_t fNChannels; // number of channels
	141	ClassDef(AliTRDrawStatsHC, 1);
	142	};
	143
	144	Int_t fBytes; // number of bytes (not necessarily read)
	145	Int_t fBytesRead; // number of bytes read
	146	Int_t fNTracklets; // number of tracklets
	147	Int_t fNMCMs; // number of MCMs (from MCM headers)
	148	Int_t fNChannels; // number of channels
	149	AliTRDrawStatsHC fStatsHC[60]; //[60] HC-wise statistics
	150	ClassDef(AliTRDrawStatsSector, 1);
	151	};
	152
cc26f39c	153	AliTRDrawStatsSector fStatsSector[18]; //[18] sector-wise statistics
	154	Int_t fBytesRead; // number of bytes read
	155	ClassDef(AliTRDrawStats, 1);
	156	};
	157
	158	AliTRDrawStats fStats; // event statistics, clearing must be done by the user
	159
	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
	166	// raw data dumping
	167	void SetDumpMCM(Int_t det, Int_t rob, Int_t mcm, Bool_t dump = kTRUE);
	168
92305359	169	Bool_t IsDumping() const { return (fNDumpMCMs > 0); }
92305359	170	Bool_t DumpingMCM(Int_t det, Int_t rob, Int_t mcm) const;
cc26f39c	171
9cb9c409	172	TString DumpRaw(TString title, UInt_t *start, Int_t length, UInt_t endmarker = 0xffffffff);
	173	TString DumpMcmHeader(TString title, UInt_t word);
	174	TString DumpAdcMask(TString title, UInt_t word);
	175
	176	// temporary: allow to change expected readout order
	177	static void SetMCMReadoutPos(Int_t mcm, Int_t pos) { if (mcm > -1 && mcm < 16) fgMcmOrder[mcm] = pos; }
	178	static void SetROBReadoutPos(Int_t robpair, Int_t pos) { if (robpair > -1 && robpair < 4) fgMcmOrder[robpair] = pos; }
cc26f39c	179
d60fe037	180	protected:
9cb9c409	181	Int_t ReadGTUHeaders(UInt_t *buffer);
d60fe037	182	Int_t ReadSmHeader();
9cb9c409	183	Int_t ReadTrackingHeader(Int_t stack);
	184	Int_t ReadTriggerHeaders();
	185	Int_t ReadStackHeader(Int_t stack);
	186	Int_t DecodeGTUtracks();
	187	Int_t ReadGTUTrailer();
d60fe037	188
	189	Int_t ReadLinkData();
	190	Int_t ReadTracklets();
	191	Int_t ReadHcHeader();
	192	Int_t ReadTPData(Int_t mode = 1);
	193	Int_t ReadZSData();
	194	Int_t ReadNonZSData();
	195
92223bf6	196	Int_t SeekNextLink();
92223bf6	197
d60fe037	198	// MCM header decoding
0508ca31	199	Int_t ROB(UInt_t mcmhdr) const { return 0x7 & mcmhdr >> 28; }
	200	Int_t MCM(UInt_t mcmhdr) const { return 0xf & mcmhdr >> 24; }
	201	Int_t Row(UInt_t mcmhdr) const { return (ROB(mcmhdr) / 2) * 4 + MCM(mcmhdr) / 4; }
	202	Int_t AdcColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 21 + (ROB(mcmhdr) % 2) * 84 - 1; }
	203	Int_t PadColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 18 + (ROB(mcmhdr) % 2) * 72 + 1; }
	204	Int_t EvNo(UInt_t mcmhdr) const { return 0xfffff & mcmhdr >> 4; }
	205	Int_t Check(UInt_t mcmhdr) const { return 0xf & mcmhdr; }
	206	Int_t CouldBeMCMhdr(UInt_t mcmhdr) const { return ((0xf & mcmhdr) == 0xc); }
	207
9cb9c409	208	Int_t GetMCMReadoutPos(Int_t mcm) const { return (mcm > -1 && mcm < 16) ? fgMcmOrder[mcm] : -1; }
9cb9c409	209	Int_t GetROBReadoutPos(Int_t rob) const { return (rob > -1 && rob < 4) ? fgRobOrder[rob] : -1; }
d60fe037	210
d60fe037	211	// ADC mask decoding
0508ca31	212	Int_t GetActiveChannels(UInt_t adcmask) const { return 0x1fffff & adcmask >> 4; }
82029d44	213	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	214	Int_t GetNActiveChannels(UInt_t adcmask) const { return (0x1f & ~(adcmask >> 25)); }
0508ca31	215	Int_t CouldBeADCmask(UInt_t adcmask) const { return ((0xf & adcmask) == 0xc && (0x3 & adcmask >> 30) == 0x1); }
d60fe037	216
d60fe037	217	// error message generation
1d62be37	218	void EquipmentError(ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	219	void StackError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	220	void LinkError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	221	void ROBError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
	222	void MCMError (ErrorCode_t err = kUnknown, const char *const msg = "", ...);
f4b3235e	223	void StoreErrorTree() { fErrors->Fill(); }
5fdfc9e4	224	void StoreErrorArray() { new ((*fMarkers)[fMarkers->GetEntriesFast()]) AliTRDrawStreamError(fLastError); }
f4b3235e	225	void ForgetError() { return; }
f4b3235e	226	void (AliTRDrawStream::*fStoreError)(); //! function pointer to method used for storing the error
d60fe037	227
92305359	228	static const char* fgkErrorMessages[kLastErrorCode]; // error messages corresponding to the error codes
92305359	229	static Int_t fgErrorDebugLevel[kLastErrorCode]; // error debug level
92223bf6	230	static ErrorBehav_t fgErrorBehav[kLastErrorCode]; // bevhaviour in case of error of given type
d60fe037	231
d60fe037	232	// I/O
0508ca31	233	AliRawReader *fRawReader; // pointer to the raw reader to take the data from
	234	AliTRDdigitsManager *fDigitsManager; // pointer to the digitsManager to fill the data
	235	AliTRDdigitsParam *fDigitsParam; // pointer to the parameters belonging to the digits
d60fe037	236
0508ca31	237	TTree *fErrors; // tree containing the occured error codes
8df9496c	238	AliTRDrawStreamError fLastError; // last error which occured
92223bf6	239	UInt_t fErrorFlags; // error flags used to steer subsequent reading
92223bf6	240	char fErrorBuffer[100]; // buffer for error message
d60fe037	241
0508ca31	242	UInt_t *fPayloadStart; // pointer to start of data payload
0508ca31	243	UInt_t *fPayloadCurr; // pointer to current reading position in the payload
cc26f39c	244	Int_t fPayloadSize; // size of the payload (in UInt_t words)
d60fe037	245
0508ca31	246	static const Int_t fgkNlinks; // number of links to read
9cb9c409	247	static const Int_t fgkNsectors; // number of sectors
0508ca31	248	static const Int_t fgkNstacks; // number of stacks to read
9cb9c409	249	static const Int_t fgkNtriggers; // number of triggers in data stream
0508ca31	250	static const UInt_t fgkDataEndmarker; // data endmarker
0508ca31	251	static const UInt_t fgkTrackletEndmarker; // tracklet endmarker
9cb9c409	252	static Int_t fgMcmOrder []; // expected readout order of the MCMs
9cb9c409	253	static Int_t fgRobOrder []; // expected readout order of the ROBs
d60fe037	254
d60fe037	255	// persistent information
0508ca31	256	Int_t fNtimebins; // number of timebins
0508ca31	257	Int_t fLastEvId; // Event ID of last event
d60fe037	258
d60fe037	259	// information valid at current reader position
0508ca31	260	// all the variables fCurr... refer to the value at the current
	261	// reading position
	262	Int_t fCurrSlot; // current slot
	263	Int_t fCurrLink; // current link
	264	Int_t fCurrRobPos; // current ROB number
	265	Int_t fCurrMcmPos; // current MCM number
d60fe037	266
d60fe037	267	// DDL header
0508ca31	268	UInt_t fCurrEquipmentId; // current Equipment ID
d60fe037	269
9cb9c409	270	// SM header
	271	UInt_t fCurrSmHeaderSize; // current size of the SM header
	272	UInt_t fCurrSmHeaderVersion; // current version of the SM header
	273	UInt_t fCurrTrailerReadout; // current presence of trailer (after the payload)
	274	UInt_t fCurrTrgHeaderAvail; // current trigger information availability
	275	UInt_t fCurrTrgHeaderReadout; // current readout mode for the trigger headers
	276	UInt_t fCurrTrkHeaderAvail; // current tracking information availability
	277	UInt_t fCurrEvType; // current event type
	278	UInt_t fCurrTriggerEnable; // current trigger enable
	279	UInt_t fCurrTriggerFired; // current trigger fired
0508ca31	280	UInt_t fCurrTrackEnable; // current value of track enable
	281	UInt_t fCurrTrackletEnable; // current value of tracklet enable
	282	UInt_t fCurrStackMask; // current mask of active stacks
d60fe037	283
9cb9c409	284	// Tracking header
	285	UInt_t *fCurrTrkHeaderIndexWord; // current tracking header index word
	286	UInt_t *fCurrTrkHeaderSize; // current tracking header index word
	287
	288	// Trigger header
	289	UInt_t *fCurrTrgHeaderIndexWord; // current tracking header index word
	290	UInt_t *fCurrTrgHeaderSize; // current tracking header index word
	291
	292	// Stack header
0508ca31	293	UInt_t *fCurrStackIndexWord; // current stack index words
	294	UInt_t *fCurrStackHeaderSize; // current stack index sizes
	295	UInt_t *fCurrStackHeaderVersion; // current stack header versions
	296	UInt_t *fCurrLinkMask; // current link masks
	297	UInt_t *fCurrCleanCheckout; // current clean checkout flags
	298	UInt_t *fCurrBoardId; // current board IDs
9cb9c409	299	UInt_t fCurrHwRev; // current hardware revision
9cb9c409	300	UInt_t *fCurrHwRevTMU; // current hardware revision
0508ca31	301	UInt_t *fCurrLinkMonitorFlags; // current link monitor flags
	302	UInt_t *fCurrLinkDataTypeFlags; // current link data flags
	303	UInt_t *fCurrLinkDebugFlags; // current link debug flags
d60fe037	304
d60fe037	305	// HC information
0508ca31	306	Int_t fCurrSpecial; // current value of the special flag
	307	Int_t fCurrMajor; // current major version
	308	Int_t fCurrMinor; // current minor version
	309	Int_t fCurrAddHcWords; // current number of additional HC-header words
	310	Int_t fCurrSm; // current sector
	311	Int_t fCurrStack; // current stack
	312	Int_t fCurrLayer; // current layer
	313	Int_t fCurrSide; // current side
	314	Int_t fCurrHC; // current HC
	315	Int_t fCurrCheck; // current check bits
	316	Int_t fCurrNtimebins; // current number of timebins
	317	Int_t fCurrBC; // current BC
	318	Int_t fCurrPtrgCnt; // current pretrigger count
	319	Int_t fCurrPtrgPhase; // current pretrigger phase
d60fe037	320
cc26f39c	321	// settings for dumping
	322	Int_t fDumpMCM[100]; // MCMs to dump
	323	Int_t fNDumpMCMs; // number of MCMs to dump
	324
d60fe037	325	// tracklet information
0508ca31	326	TClonesArray *fTrackletArray; // pointer to array for tracklet storage
d60fe037	327
d60fe037	328	// output data
0508ca31	329	AliTRDarrayADC *fAdcArray; // pointer to ADC array
	330	AliTRDSignalIndex *fSignalIndex; // pointer to the signal index
	331	TTree *fTrackletTree; // pointer to the tree for tracklet storage
5fdfc9e4	332	TClonesArray *fTracklets; // pointer to array of tracklets
	333	TClonesArray *fTracks; // pointer to array of GTU tracks
	334	TClonesArray *fMarkers; // pointer to array of markers (data present, errors, ...)
d60fe037	335
d60fe037	336	AliTRDrawStream(const AliTRDrawStream&); // not implemented
0508ca31	337	AliTRDrawStream& operator=(const AliTRDrawStream&); // not implemented
d60fe037	338
	339	ClassDef(AliTRDrawStream, 0);
	340	};
	341
82029d44	342	Int_t AliTRDrawStream::GetNActiveChannelsFromMask(UInt_t adcmask) const
	343	{
	344	// return number of active bits in the ADC mask
	345
	346	adcmask = GetActiveChannels(adcmask);
	347	adcmask = adcmask - ((adcmask >> 1) & 0x55555555);
	348	adcmask = (adcmask & 0x33333333) + ((adcmask >> 2) & 0x33333333);
	349	return (((adcmask + (adcmask >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
	350	}
	351
d60fe037	352	#endif