TRD/AliTRDrawStream.h

   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
  11 #ifndef ALITRDRAWSTREAM_H
  12 #define ALITRDRAWSTREAM_H
  13
  14 #include "TObject.h"
  15
  16 #include "AliTRDrawStreamBase.h"
  17 //#include "AliRawReader.h"
  18
  19 class TObjArray;
  20 class TString;
  21 class TTree;
  22 class TBranch;
  23
  24 class AliRawReader;
  25 class AliTRDdigitsManager;
  26 class AliTRDdigitsParam;
  27 class AliTRDarrayADC;
  28 class AliTRDSignalIndex;
  29 class AliTRDtrackletContainer;
  30
  31 class AliTRDrawStream : public AliTRDrawStreamBase
  32 {
  33  public:
  34   AliTRDrawStream(AliRawReader *rawReader = 0x0);
  35   ~AliTRDrawStream();
  36
  37   Bool_t SetReader(AliRawReader *rawReader) { fRawReader = rawReader; return kTRUE; }
  38   void SetDigitsManager(AliTRDdigitsManager *digMgr) { fDigitsManager = digMgr; }
  39
  40   Bool_t ReadEvent(TTree *trackletTree = 0x0);
  41
  42   Bool_t NextDDL();
  43   Int_t NextChamber(AliTRDdigitsManager *digMgr,
  44                     UInt_t ** /* trackletContainer */, UShort_t ** /* errorContainer */);
  45
  46   Bool_t ConnectTracklets(TTree *trklTree);
  47
  48   // legacy code, to be removed
  49   Bool_t SetRawVersion(Int_t) { return kTRUE; }
  50   void SetSharedPadReadout(Bool_t) {}
  51   void SetNoErrorWarning() {}
  52
  53   // error handling
  54   enum ErrorCode_t {
  55     kUnknown = 0,
  56     kLinkMonitor,
  57     kPtrgCntMismatch,
  58     kNonTrdEq,
  59     kStackHeaderInvalid,
  60     kInvalidDetector,
  61     kNoDigits,
  62     kHCmismatch,
  63     kHCcheckFailed,
  64     kPosUnexp,
  65     kTPmodeInvalid,
  66     kTPmismatch,
  67     kNtimebinsChanged,
  68     kAdcMaskInconsistent,
  69     kAdcCheckInvalid,
  70     kAdcDataAbort,
  71     kAdcChannelsMiss,
  72     kMissMcmHeaders,
  73     kLastErrorCode
  74   };
  75
  76   enum ErrorBehav_t {
  77     kTolerate,
  78     kDiscardMCM,
  79     kDiscardHC
  80   };
  81
  82   TTree* GetErrorTree() const { return fErrors; }
  83   static const char* GetErrorMessage(ErrorCode_t errCode);
  84
  85   // event statistics
  86   class AliTRDrawStats : public TObject {
  87   public:
  88     AliTRDrawStats() : TObject(), fBytesRead(0) {}
  89     void ClearStats();
  90
  91     class AliTRDrawStatsSector : public TObject {
  92     public:
  93       AliTRDrawStatsSector() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
  94       void ClearStats();
  95
  96       class AliTRDrawStatsHC : public TObject {
  97       public:
  98         AliTRDrawStatsHC() : TObject(), fBytes(0), fBytesRead(0), fNTracklets(0), fNMCMs(0), fNChannels(0) {}
  99         void ClearStats();
 100
 101         Int_t fBytes;             // number of bytes (not necessarily read)
 102         Int_t fBytesRead;         // number of bytes read
 103         Int_t fNTracklets;        // number of tracklets
 104         Int_t fNMCMs;             // number of MCMs (from MCM headers)
 105         Int_t fNChannels;         // number of channels
 106         ClassDef(AliTRDrawStatsHC, 1);
 107       };
 108
 109       Int_t fBytes;                  // number of bytes (not necessarily read)
 110       Int_t fBytesRead;              // number of bytes read
 111       Int_t fNTracklets;             // number of tracklets
 112       Int_t fNMCMs;                  // number of MCMs (from MCM headers)
 113       Int_t fNChannels;              // number of channels
 114       AliTRDrawStatsHC fStatsHC[60]; //[60] HC-wise statistics
 115       ClassDef(AliTRDrawStatsSector, 1);
 116     };
 117
 118
 119     AliTRDrawStatsSector fStatsSector[18]; //[18] sector-wise statistics
 120     Int_t fBytesRead;                      // number of bytes read
 121     ClassDef(AliTRDrawStats, 1);
 122   };
 123
 124   AliTRDrawStats fStats;             // event statistics, clearing must be done by the user
 125
 126   AliTRDrawStats* GetStats() { return &fStats; }
 127   Int_t GetEventSize(Int_t sector) { return fStats.fStatsSector[sector].fBytes; }
 128   Int_t GetNTracklets(Int_t sector) { return fStats.fStatsSector[sector].fNTracklets; }
 129   Int_t GetNMCMs(Int_t sector) { return fStats.fStatsSector[sector].fNMCMs; }
 130   Int_t GetNChannels(Int_t sector) { return fStats.fStatsSector[sector].fNChannels; }
 131
 132   // raw data dumping
 133   void SetDumpMCM(Int_t det, Int_t rob, Int_t mcm, Bool_t dump = kTRUE);
 134
 135   Bool_t IsDumping() { return (fNDumpMCMs > 0); }
 136   Bool_t DumpingMCM(Int_t det, Int_t rob, Int_t mcm);
 137
 138   void DumpRaw(TString title, UInt_t *start, Int_t length);
 139
 140  protected:
 141   Int_t ReadSmHeader();
 142   Int_t ReadStackIndexHeader(Int_t stack);
 143
 144   Int_t ReadLinkData();
 145   Int_t ReadTracklets();
 146   Int_t ReadHcHeader();
 147   Int_t ReadTPData(Int_t mode = 1);
 148   Int_t ReadZSData();
 149   Int_t ReadNonZSData();
 150
 151   // MCM header decoding
 152   Int_t ROB(UInt_t mcmhdr) const { return 0x7 & mcmhdr >> 28; }
 153   Int_t MCM(UInt_t mcmhdr) const { return 0xf & mcmhdr >> 24; }
 154   Int_t Row(UInt_t mcmhdr) const { return (ROB(mcmhdr) / 2) * 4 + MCM(mcmhdr) / 4; }
 155   Int_t AdcColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 21 + (ROB(mcmhdr) % 2) * 84 - 1; }
 156   Int_t PadColOffset(UInt_t mcmhdr) const { return (MCM(mcmhdr) % 4 + 1) * 18 + (ROB(mcmhdr) % 2) * 72 + 1; }
 157   Int_t EvNo(UInt_t mcmhdr) const { return 0xfffff & mcmhdr >> 4; }
 158   Int_t Check(UInt_t mcmhdr) const { return 0xf & mcmhdr; }
 159   Int_t CouldBeMCMhdr(UInt_t mcmhdr) const { return ((0xf & mcmhdr) == 0xc); }
 160
 161   Int_t GetMCMReadoutPos(Int_t mcm) const { return (mcm > -1 && mcm < 16) ? fgkMcmOrder[mcm] : -1; }
 162   Int_t GetROBReadoutPos(Int_t rob) const { return (rob > -1 && rob < 4) ? fgkRobOrder[rob] : -1; }
 163
 164   // ADC mask decoding
 165   Int_t GetActiveChannels(UInt_t adcmask) const { return 0x1fffff & adcmask >> 4; }
 166   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; }
 167   Int_t GetNActiveChannels(UInt_t adcmask) const { return (0x1f & ~(adcmask >> 25)); }
 168   Int_t CouldBeADCmask(UInt_t adcmask) const { return ((0xf & adcmask) == 0xc && (0x3 & adcmask >> 30) == 0x1); }
 169
 170   // error message generation
 171   TString EquipmentError(ErrorCode_t err = kUnknown, TString msg = "");
 172   TString StackError    (ErrorCode_t err = kUnknown, TString msg = "");
 173   TString LinkError     (ErrorCode_t err = kUnknown, TString msg = "");
 174   TString ROBError      (ErrorCode_t err = kUnknown, TString msg = "");
 175   TString MCMError      (ErrorCode_t err = kUnknown, TString msg = "");
 176
 177   static const char* fgErrorMessages[kLastErrorCode]; // error messages corresponding to the error codes
 178   ErrorBehav_t fgErrorBehav[kLastErrorCode];          // bevhaviour in case of error of given type
 179
 180   // I/O
 181   AliRawReader *fRawReader;                     // pointer to the raw reader to take the data from
 182   AliTRDdigitsManager *fDigitsManager;          // pointer to the digitsManager to fill the data
 183   AliTRDdigitsParam   *fDigitsParam;            // pointer to the parameters belonging to the digits
 184
 185   TTree *fErrors;                               // tree containing the occured error codes
 186   struct { Int_t fSector; Int_t fStack; Int_t fLink; Int_t fError; Int_t fRob; Int_t fMcm; }
 187   fLastError;                                   // last error which occured
 188
 189   UInt_t *fPayloadStart;                        // pointer to start of data payload
 190   UInt_t *fPayloadCurr;                         // pointer to current reading position in the payload
 191   Int_t   fPayloadSize;                         // size of the payload (in UInt_t words)
 192
 193   static const Int_t fgkNlinks;                 // number of links to read
 194   static const Int_t fgkNstacks;                // number of stacks to read
 195   static const UInt_t fgkDataEndmarker;         // data endmarker
 196   static const UInt_t fgkTrackletEndmarker;     // tracklet endmarker
 197   static const Int_t fgkMcmOrder [];            // expected readout order of the MCMs
 198   static const Int_t fgkRobOrder [];            // expected readout order of the ROBs
 199
 200   // persistent information
 201   Int_t  fNtimebins;                            // number of timebins
 202   Int_t  fLastEvId;                             // Event ID of last event
 203
 204   // information valid at current reader position
 205   // all the variables fCurr... refer to the value at the current
 206   // reading position
 207   Int_t fCurrSlot;                              // current slot
 208   Int_t fCurrLink;                              // current link
 209   Int_t fCurrRobPos;                            // current ROB number
 210   Int_t fCurrMcmPos;                            // current MCM number
 211
 212   // DDL header
 213   UInt_t fCurrEquipmentId;                      // current Equipment ID
 214
 215   // SMU index header
 216   UInt_t fCurrSmuIndexHeaderSize;               // current size of the SMU index header
 217   UInt_t fCurrSmuIndexHeaderVersion;            // current version of the SMU index header
 218   UInt_t fCurrTrackEnable;                      // current value of track enable
 219   UInt_t fCurrTrackletEnable;                   // current value of tracklet enable
 220   UInt_t fCurrStackMask;                        // current mask of active stacks
 221
 222   // Stack index header
 223   UInt_t *fCurrStackIndexWord;                  // current stack index words
 224   UInt_t *fCurrStackHeaderSize;                 // current stack index sizes
 225   UInt_t *fCurrStackHeaderVersion;              // current stack header versions
 226   UInt_t *fCurrLinkMask;                        // current link masks
 227   UInt_t *fCurrCleanCheckout;                   // current clean checkout flags
 228   UInt_t *fCurrBoardId;                         // current board IDs
 229   UInt_t *fCurrHwRev;                           // current hardware revision
 230   UInt_t *fCurrLinkMonitorFlags;                // current link monitor flags
 231   UInt_t *fCurrLinkDataTypeFlags;               // current link data flags
 232   UInt_t *fCurrLinkDebugFlags;                  // current link debug flags
 233
 234   // HC information
 235   Int_t fCurrSpecial;                           // current value of the special flag
 236   Int_t fCurrMajor;                             // current major version
 237   Int_t fCurrMinor;                             // current minor version
 238   Int_t fCurrAddHcWords;                        // current number of additional HC-header words
 239   Int_t fCurrSm;                                // current sector
 240   Int_t fCurrStack;                             // current stack
 241   Int_t fCurrLayer;                             // current layer
 242   Int_t fCurrSide;                              // current side
 243   Int_t fCurrHC;                                // current HC
 244   Int_t fCurrCheck;                             // current check bits
 245   Int_t fCurrNtimebins;                         // current number of timebins
 246   Int_t fCurrBC;                                // current BC
 247   Int_t fCurrPtrgCnt;                           // current pretrigger count
 248   Int_t fCurrPtrgPhase;                         // current pretrigger phase
 249
 250   // settings for dumping
 251   Int_t fDumpMCM[100];                          // MCMs to dump
 252   Int_t fNDumpMCMs;                             // number of MCMs to dump
 253
 254   // tracklet information
 255   TClonesArray *fTrackletArray;                 // pointer to array for tracklet storage
 256
 257   // output data
 258   AliTRDarrayADC *fAdcArray;                    // pointer to ADC array
 259   AliTRDSignalIndex *fSignalIndex;              // pointer to the signal index
 260   TTree *fTrackletTree;                         // pointer to the tree for tracklet storage
 261
 262   AliTRDrawStream(const AliTRDrawStream&);           // not implemented
 263   AliTRDrawStream& operator=(const AliTRDrawStream&); // not implemented
 264
 265   ClassDef(AliTRDrawStream, 0);
 266 };
 267
 268 Int_t AliTRDrawStream::GetNActiveChannelsFromMask(UInt_t adcmask) const
 269 {
 270   // return number of active bits in the ADC mask
 271
 272   adcmask = GetActiveChannels(adcmask);
 273   adcmask = adcmask - ((adcmask >> 1) & 0x55555555);
 274   adcmask = (adcmask & 0x33333333) + ((adcmask >> 2) & 0x33333333);
 275   return (((adcmask + (adcmask >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
 276 }
 277
 278 #endif