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