]> git.uio.no Git - u/mrichter/AliRoot.git/blame - TRD/AliTRDrawFastStream.h
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Move function SetNoErrorWarning() so that it can be called by HLT via base class
[u/mrichter/AliRoot.git] / TRD / AliTRDrawFastStream.h
CommitLineData
b48576ab 1#ifndef ALITRDRAWFASTSTREAM_H\r
2#define ALITRDRAWFASTSTREAM_H\r
3\r
4/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *\r
5 * See cxx source for full Copyright notice */\r
6\r
7/* $Id: AliTRDrawFastStream.h 27696 2008-07-31 09:18:53Z cblume $ */\r
8\r
9/////////////////////////////////////////////////////////////////////////////////\r
10// //\r
11// This class provides access to TRD digits in raw data in a way of streaming. //\r
12// //\r
13/////////////////////////////////////////////////////////////////////////////////\r
14\r
15#include "AliTRDrawStreamBase.h"\r
16#include "AliTRDarrayADC.h"\r
17#include "AliTRDarrayDictionary.h"\r
18#include "AliTRDSignalIndex.h"\r
19\r
20class AliTRDgeometry;\r
21class AliRawReader;\r
22class AliTRDdigitsManager;\r
23class TTreeSRedirector;\r
24class AliTRDfeeParam;\r
25\r
26\r
27class AliTRDrawFastStream : public AliTRDrawStreamBase\r
28{ // class def begin\r
29\r
30 public:\r
31 \r
32 //--------------------------------------------------------\r
33 // THE STRUCTURES\r
34 //--------------------------------------------------------\r
35\r
36 struct AliTRDrawMCM\r
37 { // mcm struct\r
38 Int_t fROB; // ROB number\r
39 Int_t fMCM; // MCM number\r
40 Int_t fROW; // row number filed during decoding\r
41 \r
42 UInt_t fEvCounter; // MCM event counter\r
43 UInt_t fADCMask; // ADC mask\r
44 UInt_t fADCMaskWord; // word with ADC mask in\r
45 UInt_t fADCchannel[TRDMAXADC]; // channels to be decoded accrording to ADC mask\r
46 \r
47 Int_t fADCmax; // number of ADCs fired\r
48 Int_t fADCcount; // number of ADCs fired from double checking bit\r
49 Int_t fMCMADCWords; // mcm words to expect\r
50 Int_t fSingleADCwords; // n of words per ADC\r
51 \r
52 Int_t fMCMhdCorrupted; // is mcm header corrupted\r
53 Int_t fADCmaskCorrupted; // is mcm adc mask corrupted\r
54 Bool_t fDataCorrupted; // true if the corruption is in ADC data level \r
55 \r
56 UInt_t *fPos; //! position of mcm header in the buffer\r
57 UInt_t *fAdcDataPos; //! start of ADC data for this mcm\r
58\r
59 Int_t fADCcounter; // count the adcs decoded\r
60 \r
61\r
62 AliTRDrawMCM()\r
63 : fROB(-1)\r
64 , fMCM(-1)\r
65 , fROW(-1)\r
66 , fEvCounter(0)\r
67 , fADCMask(0)\r
68 , fADCMaskWord(0)\r
69 , fADCchannel() \r
70 , fADCmax(0)\r
71 , fADCcount(0)\r
72 , fMCMADCWords(0) \r
73 , fSingleADCwords(0)\r
74 , fMCMhdCorrupted(0) \r
75 , fADCmaskCorrupted(0) \r
76 , fDataCorrupted(0) \r
77 , fPos(0)\r
78 , fAdcDataPos(0)\r
79 , fADCcounter(0)\r
80 {\r
81 // default constructor\r
82 };\r
83\r
84 AliTRDrawMCM(const AliTRDrawMCM & p):\r
85 fROB(p.fROB)\r
86 , fMCM(p.fMCM)\r
87 , fROW(p.fROW)\r
88 , fEvCounter(p.fEvCounter)\r
89 , fADCMask(p.fADCMask)\r
90 , fADCMaskWord(p.fADCMaskWord)\r
91 , fADCchannel() \r
92 , fADCmax(p.fADCmax)\r
93 , fADCcount(p.fADCcount)\r
94 , fMCMADCWords(p.fMCMADCWords) \r
95 , fSingleADCwords(p.fSingleADCwords)\r
96 , fMCMhdCorrupted(p.fMCMhdCorrupted) \r
97 , fADCmaskCorrupted(p.fADCmaskCorrupted) \r
98 , fDataCorrupted(p.fDataCorrupted) \r
99 , fPos(p.fPos)\r
100 , fAdcDataPos(p.fAdcDataPos)\r
101 , fADCcounter(p.fADCcounter)\r
102 {\r
103 // copy constructor\r
104 };\r
105\r
106 AliTRDrawMCM &operator=(const AliTRDrawMCM &)\r
107 {\r
108 // assignment operator\r
109 // not implemented\r
110 return *this;\r
111 };\r
112\r
113 };\r
114\r
115 //--------------------------------------------------------\r
116\r
117 struct AliTRDrawHC\r
118 { // hc struct\r
119 \r
120 //tacklet words of given HC\r
121 UInt_t fTrackletWords[MAXTRACKLETSPERHC]; // array to keep tracklet words \r
122 Short_t fNTracklets; // number of tracklet \r
123\r
124 // header word 0\r
125 Int_t fSpecialRawV; // Raw data version\r
126 Int_t fRawVMajor; // Raw data version\r
127 Int_t fRawVMajorOpt; // Raw data version\r
128 Int_t fRawVMinor; // Raw data version\r
129 Int_t fNExtraWords; // N extra HC header words\r
130 Int_t fDCSboard; // DCS board number\r
131 Int_t fSM; // Super Module number\r
132 Int_t fSMHCheader; // Super Module number from HC header\r
133 Int_t fStack; // Stack number (some people might call it a chamber)\r
134 Int_t fStackHCheader; // Stack number from HC header(some people might call it a chamber)\r
135 Int_t fLayer; // Layer number (some people might call it a plane)\r
136 Int_t fLayerHCheader; // Layer number from HC header(some people might call it a plane)\r
137 Int_t fSide; // Side of HC\r
138 Int_t fSideHCheader; // Side of HC from HC header\r
139 \r
140 // header word 1\r
141 Int_t fTimeBins; // N of t bins\r
142 UInt_t fBunchCrossCounter; // Bunch crossing counter\r
143 UInt_t fPreTriggerCounter; // Pre Trigger counter\r
144 UInt_t fPreTriggerPhase; // Pre Trigger phase\r
145 \r
146 // error \r
147 UShort_t fErrorCodes[1411]; // array to keep encoded errors\r
148 UInt_t fNErrors; // number of total errors of given hc \r
149\r
150 Short_t fH0Corrupted; // is hc header 0 corrupted \r
151 Short_t fH1Corrupted; // is hc header 1 corrupted\r
152 Short_t fCorrupted; // is hc data corrupted \r
153 Bool_t fEOTECorrupted; // if the corruption is due to meet END_OF_TRACKLET_MARKERNEW\r
154 Bool_t fBufferCorrupted; // if the corruption is due to buffer end\r
155 Bool_t fDataCorrupted; // if the corruption is on the MCM data\r
156\r
157 Short_t fMCMCorrupted[TRDMAXMCM]; // is hc data corrupted \r
158\r
159 UInt_t *fPos[2]; //! position of the header words in buffer\r
160 \r
161 Int_t fDET; // filled while decoding\r
162 Int_t fROC; // filled while decoding\r
163 Int_t fRowMax; // filled while decoding\r
164 Int_t fColMax; // filled while decoding\r
165\r
166 // hc data\r
167 Int_t fMCMmax; // number of mcm found\r
168\r
169 AliTRDrawHC()\r
170 : fTrackletWords() \r
171 , fNTracklets(0)\r
172 , fSpecialRawV(0)\r
173 , fRawVMajor(0)\r
174 , fRawVMajorOpt(0)\r
175 , fRawVMinor(0)\r
176 , fNExtraWords(0)\r
177 , fDCSboard(-1)\r
178 , fSM(-1)\r
179 , fSMHCheader(-1)\r
180 , fStack(-1)\r
181 , fStackHCheader(-1)\r
182 , fLayer(-1)\r
183 , fLayerHCheader(-1)\r
184 , fSide(-1)\r
185 , fSideHCheader(-1)\r
186 , fTimeBins(0)\r
187 , fBunchCrossCounter(0)\r
188 , fPreTriggerCounter(0)\r
189 , fPreTriggerPhase(0)\r
190 , fNErrors(0)\r
191 , fH0Corrupted(0)\r
192 , fH1Corrupted(0)\r
193 , fCorrupted(0)\r
194 , fEOTECorrupted(0)\r
195 , fBufferCorrupted(0)\r
196 , fDataCorrupted(0)\r
197 , fPos()\r
198 , fDET(-1)\r
199 , fROC(-1)\r
200 , fRowMax(-1)\r
201 , fColMax(-1)\r
202 , fMCMmax(0)\r
203 {\r
204 // default constructor hc info \r
205 };\r
206\r
207 AliTRDrawHC(const AliTRDrawHC & p):\r
208 fTrackletWords() \r
209 , fNTracklets(p.fNTracklets)\r
210 , fSpecialRawV(p.fSpecialRawV)\r
211 , fRawVMajor(p.fRawVMajor)\r
212 , fRawVMajorOpt(p.fRawVMajorOpt)\r
213 , fRawVMinor(p.fRawVMinor)\r
214 , fNExtraWords(p.fNExtraWords)\r
215 , fDCSboard(p.fDCSboard)\r
216 , fSM(p.fSM)\r
217 , fSMHCheader(p.fSMHCheader)\r
218 , fStack(p.fStack)\r
219 , fStackHCheader(p.fStackHCheader)\r
220 , fLayer(p.fLayer)\r
221 , fLayerHCheader(p.fLayerHCheader)\r
222 , fSide(p.fSide)\r
223 , fSideHCheader(p.fSideHCheader)\r
224 , fTimeBins(p.fTimeBins)\r
225 , fBunchCrossCounter(p.fBunchCrossCounter)\r
226 , fPreTriggerCounter(p.fPreTriggerCounter)\r
227 , fPreTriggerPhase(p.fPreTriggerPhase)\r
228 , fNErrors(p.fNErrors)\r
229 , fH0Corrupted(p.fH0Corrupted)\r
230 , fH1Corrupted(p.fH1Corrupted)\r
231 , fCorrupted(p.fCorrupted)\r
232 , fEOTECorrupted(p.fEOTECorrupted)\r
233 , fBufferCorrupted(p.fBufferCorrupted)\r
234 , fDataCorrupted(p.fDataCorrupted)\r
235 , fPos()\r
236 , fDET(p.fDET)\r
237 , fROC(p.fROC)\r
238 , fRowMax(p.fRowMax)\r
239 , fColMax(p.fColMax)\r
240 , fMCMmax(p.fMCMmax)\r
241 {\r
242 // copy constructor\r
243 };\r
244\r
245 AliTRDrawHC &operator=(const AliTRDrawHC &)\r
246 {\r
247 // assignment operator\r
248 // not implemented\r
249 return *this;\r
250 };\r
251\r
252 };\r
253\r
254 //--------------------------------------------------------\r
255 \r
256 struct AliTRDrawStack\r
257 {\r
258 UInt_t fHeaderSize; // header size of the stack info\r
259 Bool_t fLinksActive[12]; // data links active - 1 per half chamber\r
260 Short_t fLinksDataType[12]; // 0 indicating real data for the front-end electronics \r
261 Short_t fLinksMonitor[12]; // 0 indicating properly operating link \r
262 Short_t fLinkMonitorError[12]; // record link monitor error\r
263 Int_t fActiveLinks; // number of active links\r
264 UInt_t *fPos; //! position in the buffer\r
265 \r
266 AliTRDrawHC fHalfChambers[12]; // 12 half chambers in a stack\r
267 \r
268 AliTRDrawStack()\r
269 : fHeaderSize(0)\r
270 , fLinksActive()\r
271 , fLinksDataType()\r
272 , fLinksMonitor()\r
273 , fLinkMonitorError()\r
274 , fActiveLinks(0)\r
275 , fPos(0)\r
276 , fHalfChambers()\r
277 {\r
278 // default constructor\r
279 }; \r
280\r
281 AliTRDrawStack(const AliTRDrawStack & p):\r
282 fHeaderSize(p.fHeaderSize)\r
283 , fLinksActive()\r
284 , fLinksDataType()\r
285 , fLinksMonitor()\r
286 , fLinkMonitorError()\r
287 , fActiveLinks(p.fActiveLinks)\r
288 , fPos(p.fPos)\r
289 , fHalfChambers()\r
290 {\r
291 // copy constructor\r
292 };\r
293\r
294 AliTRDrawStack &operator=(const AliTRDrawStack &)\r
295 {\r
296 // assignment operator\r
297 // not implemented\r
298 return *this;\r
299 };\r
300\r
301 };\r
302\r
303 //--------------------------------------------------------\r
304\r
305 struct AliTRDrawSM\r
306 {\r
307 UInt_t fHeaderSize; // size of the header in words\r
308 Bool_t fTrackletEnable; // tracklet enable bit\r
309 Bool_t fStackActive[5]; // map of active/expected stacks\r
310 Int_t fActiveStacks; // number of active stacks\r
311 Int_t fCorrupted; // is sm info corrupted\r
312 Int_t fNexpectedHalfChambers; // number of half chambers to be read out in this sm\r
313 UInt_t *fPos; // location of the sm info - should be the first word (after CDH if not DDL buffer)\r
314\r
315 AliTRDrawStack fStacks[5]; // 5 stacks\r
316\r
317 AliTRDrawSM()\r
318 : fHeaderSize(0)\r
319 , fTrackletEnable(0)\r
320 , fStackActive()\r
321 , fActiveStacks(0)\r
322 , fCorrupted(0)\r
323 , fNexpectedHalfChambers(0)\r
324 , fPos(0)\r
325 , fStacks()\r
326 {\r
327 // Default constructor\r
328 }; \r
329\r
330 AliTRDrawSM(const AliTRDrawSM & p):\r
331 fHeaderSize(p.fHeaderSize)\r
332 , fTrackletEnable(p.fTrackletEnable)\r
333 , fStackActive()\r
334 , fActiveStacks(p.fActiveStacks)\r
335 , fCorrupted(p.fCorrupted)\r
336 , fNexpectedHalfChambers(p.fNexpectedHalfChambers)\r
337 , fPos(p.fPos)\r
338 , fStacks()\r
339 {\r
340 // copy constructor\r
341 };\r
342\r
343 AliTRDrawSM &operator=(const AliTRDrawSM &)\r
344 {\r
345 // assignment operator\r
346 // not implemented\r
347 return *this;\r
348 };\r
349\r
350 };\r
351 \r
352 //--------------------------------------------------------\r
353 \r
354 AliTRDrawFastStream();\r
355 AliTRDrawFastStream(AliRawReader *rawReader);\r
356 virtual ~AliTRDrawFastStream();\r
357\r
358 //--------------------------------------------------------\r
359\r
360 virtual Bool_t Next(); // read the next data in the memory\r
361 virtual Int_t NextChamber(AliTRDdigitsManager *man, UInt_t **trackletContainer, UShort_t **errorCodeContainer); // read next chamber data in the memory\r
362 virtual Bool_t Init(); // initialize some internal variables\r
363\r
364 Int_t NextBuffer(); // go and init next buffer if available - check the implementation file for return values\r
365\r
366 Bool_t SetRawVersion(Int_t fraw); // set the raw version - used for backward compat.\r
367 \r
368 void SetSharedPadReadout(Bool_t fv) {fSharedPadsOn = fv;} // set the flag on if the reader should return the shared pads\r
369 \r
370 Bool_t DecodeSMHeader(void *buffer, UInt_t length); // decode a buffer\r
371 Bool_t SetReader(AliRawReader *reader); // set the raw reader to use\r
faad97e3 372 void SetNoErrorWarning() {fWarnError = kFALSE;} // disable warning and error info\r
b48576ab 373 \r
374 // from MCM Header Word\r
375 // rob and mcm ordering\r
376 // side 0(even link) - ROB: 0 2 4 6 MCM: 12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 \r
377 // side 1( odd link) - ROB: 1 3 5 7 MCM: 12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 \r
378\r
379\r
380 UShort_t *GetErrorCodes() const { return fHC->fErrorCodes;} // return error codes pointer per hc \r
381 UInt_t GetNErrors() const {return fHC ? fHC->fNErrors: 0;} // [mj temp]\r
382\r
383 // info from ADC data words\r
384 // from here, only works with returning ADC channel pointer using Next() \r
385\r
386 UInt_t *GetTrackletWords() const { return fHC->fTrackletWords;} // return tracklet words pointer per hc \r
387 Int_t GetNTracklets() const {return fHC ? fHC->fNTracklets : -1;} // get number of tracklets \r
388\r
389 Int_t GetSpecialRawVersion() const {return fHC ? fHC->fSpecialRawV : -1;} // return special raw version\r
390 Int_t GetMajorRawVersion() const {return fHC ? fHC->fRawVMajor : -1;} // major raw version getter\r
391 Int_t GetRawVersion() const {return fHC ? fHC->fRawVMajor : -1;} // compatibility see funtion above\r
392 Int_t GetMinorRawVersion() const {return fHC ? fHC->fRawVMinor : -1;} // minor raw version\r
393\r
394 Int_t GetSM() const {return fHC ? fHC->fSM : -1;} // SM Position of CURRENT half chamber in full TRD\r
395 Int_t GetLayer() const {return fHC ? fHC->fLayer : -1;} // Layer Position of CURRENT half chamber in full TRD\r
396 Int_t GetStack() const {return fHC ? fHC->fStack : -1;} // Stack Position of CURRENT half chamber in full TRD\r
397 Int_t GetSide() const {return fHC ? fHC->fSide : -1;} // get side\r
398 Int_t GetDCS() const { return fHC ? fHC->fDCSboard : -1;} // DCS board number read from data (HC header)\r
399 Int_t GetROC() const { return fHC ? fHC->fROC : -1;} // ROB Position of CURRENT half chamber in full TRD\r
400 Int_t GetNumberOfTimeBins() const { return fHC ? fHC->fTimeBins : 0;} // Get Ntime bins\r
401 UInt_t GetBunchCrossCounter() const {return fHC ? fHC->fBunchCrossCounter : 0;} // get bunch cross counter\r
402 UInt_t GetPreTriggerCounter() const {return fHC ? fHC->fPreTriggerCounter : 0;} // get pre trigger info\r
403 UInt_t GetPreTriggerPhase() const {return fHC ? fHC->fPreTriggerPhase : 0;} // get trigger phase\r
404\r
405 Int_t GetRow() const {return fMCM.fROW;} // get current row number\r
406 Int_t GetCol() const {return fCOL;} \r
407 Int_t GetExtendedCol() const {return fExtendedCOL;} \r
408 Int_t GetRowMax() const { return fHC ? fHC->fRowMax : -1;} // Get maximum rows in the current HC\r
409 Int_t GetColMax() const { return fHC ? fHC->fColMax : -1;} // Get maximum cols in the current HC\r
410 // compatibility\r
411 Int_t GetMaxRow() const { return fHC ? fHC->fRowMax : -1;} // Get maximum rows in the current HC\r
412 Int_t GetMaxCol() const { return fHC ? fHC->fColMax : -1;} // Get maximum cols in the current HC\r
413\r
414 UInt_t GetHCword0() const {return fHC ? *fHC->fPos[0] : 0;} // get the HC word 0\r
415 UInt_t GetHCword1() const {return fHC ? *fHC->fPos[1] : 0;} // get the HC word 1\r
416 \r
417 Int_t GetDET() const {return fHC ? fHC->fDET : -1;} // get current det number\r
418 Int_t GetDet() const {return fHC ? fHC->fDET : -1;} // get current det number\r
419 \r
420 Int_t GetROB() const {return fMCM.fROB;} // get current ROB number\r
421 Int_t GetMCM() const {return fMCM.fMCM;} // get current MCM number\r
422 Int_t GetEventNumber() const { return fMCM.fEvCounter;} // MCM Event number and position of current MCM on TRD chamber\r
423\r
424 Int_t GetTimeBin() const { return 0;} // MCM ADC channel and Time Bin of word 1\r
425\r
426 UInt_t *GetSMstreamPosition() const {return fSM.fPos;} // get position of the SM index word in the buffer\r
427\r
428\r
429 //----------------------------------------------------------\r
430 \r
431 static void SetNoDebug() {fgDebugFlag = kFALSE;} // allow debug info\r
432 static void EnableMemoryReset() {fgEnableMemoryReset = kTRUE;} // allow memory reset\r
b48576ab 433 static void SetForceCleanDataOnly() {fgCleanDataOnly = kTRUE;} // clean data only\r
434 static void AllowCorruptedData() {fgCleanDataOnly = kFALSE;} // accept corrupted data\r
435\r
436 static void SetExtraWordsFix() {fgExtraSkip = kTRUE;} // extra skip of 24 32-bit words \r
437 static void SetSkipCDH() {fgSkipCDH = kTRUE;} // skip of 8 32-bit words \r
438 static void SetDumpHead(Int_t iv) {fgDumpHead = iv;}\r
439 static void DisableStackNumberChecker() {fgStackNumberChecker = kFALSE;} // set false to cleanroom data \r
440 static void DisableStackLinkNumberChecker() {fgStackLinkNumberChecker = kFALSE;} \r
441 static void DisableSkipData() {fgSkipData = kFALSE;} // keep reading next words even previous words were corrupted - debugging purpose \r
442\r
443 static void EnableDecodeConfigData() {fgEnableDecodeConfigData = kTRUE;} // allow configuration data decoding\r
444 static Bool_t fgEnableDecodeConfigData; // flag to decode configuration data\r
445\r
446 Int_t GetGlobalNTimeBins() const {return fGlobalNTimeBins;} // get number of time information for the digit container\r
447\r
448 //--------------------------------------------------------\r
449 // Decoding functions\r
450 //--------------------------------------------------------\r
451\r
452 void DecodeSMInfo(const UInt_t *word, struct AliTRDrawSM *sm) const ;\r
453 const char *DumpSMInfo(const struct AliTRDrawSM *sm);\r
454 void DecodeStackInfo(const UInt_t *word, struct AliTRDrawStack *st) const;\r
455 void DecodeStackHeader(const UInt_t *word, struct AliTRDrawStack *st, Int_t iword) const;\r
456 const char *DumpStackInfo(const struct AliTRDrawStack *st);\r
457 Bool_t DecodeHCwordH0(const UInt_t *word, struct AliTRDrawHC *hc) const;\r
458 Bool_t DecodeHCwordH1(const UInt_t *word, struct AliTRDrawHC *hc) const;\r
459 const char *DumpHCinfoH0(const struct AliTRDrawHC *hc);\r
460 const char *DumpHCinfoH1(const struct AliTRDrawHC *hc);\r
461 void DecodeMCMheader(const UInt_t *word, struct AliTRDrawMCM *mcm) const;\r
462 UInt_t GetMCMadcMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const;\r
463 void DecodeMask(const UInt_t *word, struct AliTRDrawMCM *mcm) const;\r
464 void MCMADCwordsWithTbins(UInt_t fTbins, struct AliTRDrawMCM *mcm) const;\r
465 const char *DumpMCMinfo(const struct AliTRDrawMCM *mcm);\r
466 const char *DumpMCMadcMask(const struct AliTRDrawMCM *mcm);\r
467\r
468\r
469 protected:\r
470\r
471 Bool_t InitBuffer(void *buffer, UInt_t length); // init the buffer - called by DecodeSM(void*, UInt_t)\r
472 Bool_t DumpWords(UInt_t *px, UInt_t iw, UInt_t marker = 0); // dump some words onto the screen\r
473\r
474 void SwapOnEndian(); // swap if endian is BIG\r
475 Bool_t SkipWords(UInt_t iw); // skip number of words\r
476 Bool_t DecodeGTUheader(); // decode data in GTU header\r
477 Bool_t DecodeTracklets(); // decode tracklets\r
478 Bool_t DecodeHC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, AliTRDSignalIndex *indexes); // decode data in HC\r
479\r
480 Bool_t DecodeADC(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, AliTRDSignalIndex *indexes); // decode 10 ADC words\r
481 Bool_t DecodeADCExtended(AliTRDdigitsManager *digitsManager, AliTRDarrayADC *digits, AliTRDarrayDictionary *track0, AliTRDarrayDictionary *track1, AliTRDarrayDictionary *track2, AliTRDSignalIndex *indexes); // decode 10 ADC words\r
482\r
483 Bool_t DecodeHCheader(); // decode HC header\r
484 Bool_t SeekEndOfData(); // go to next end of raw data marker (actually 1 word after)\r
485 Bool_t SkipMCMdata(UInt_t iw); // skip this mcm data due to mcm header corruption\r
486 Bool_t SeekNextMCMheader(); // go to next mcm header\r
487 Bool_t DecodeMCMheader(); // decode mcm header\r
488\r
489 Bool_t IsRowValid(); // check if row within the range\r
490 Bool_t IsHCheaderOK(); // check if current hc header data make sense\r
491 Bool_t IsMCMheaderOK(); // check if current mcm header data make sense\r
492 \r
493 Bool_t SetGlobalNTimebins(); // set number of timebin based on the value read from HC header, this value will be used in the digit container\r
494 Bool_t SetNTimebins(); // set number of timebin based on the value read from HC header\r
495\r
496 void ResetCounters(); // reset some counters\r
497 void ResetIterators(); // needed for Next()\r
498 void ResetPerSM(); // reset every SM \r
499 void ResetPerStack(); // reset every Stack \r
500 void ResetPerHC(); // reset every HC \r
501 void ResetPerMCM(); // reset every MCM \r
502 void ResetMemory(); // reset all data members\r
503\r
504 AliTRDrawFastStream(const AliTRDrawFastStream& st);\r
505 AliTRDrawFastStream &operator=(const AliTRDrawFastStream &);\r
506\r
507 // ----------------- DATA MEMBERS START\r
508\r
509 struct AliTRDrawSM fSM; // one SM per buffer\r
510 struct AliTRDrawStack *fStack; //! pointer to the current stack\r
511 struct AliTRDrawHC *fHC; //! current HC\r
512 struct AliTRDrawHC *fLastHC; //! last HC\r
513 struct AliTRDrawMCM fMCM; //! current MCM\r
514 \r
515 UInt_t *fpPos; // current position in the buffer\r
516 UInt_t *fpBegin; // begin - pointer to the buffer word 0\r
517 UInt_t *fpEnd; // end of the buffer\r
518\r
519 UInt_t fWordLength; // length of the buffer in 32bit words\r
520\r
521 UInt_t *fpPosTemp; // specific position in the buffer \r
522 Int_t fGlobalNTimeBins; // number of time bin to be used in the digit container\r
523 Bool_t fIsTimeBinSet; // set true if the global time bin is set to avoid multiple search\r
524 Bool_t fIsGlobalDigitsParamSet; // set true if the global digit parameters are already set\r
525\r
526 Int_t fStackNumber; // current stack number\r
527 Int_t fStackLinkNumber; // current link in the stack\r
528\r
529 Int_t fLinkTrackletCounter; // count the tracklets in the current HC\r
530 Int_t fEndOfTrackletCount; // count link by link (hc by hc) used for debug\r
531 Int_t fNWordsCounter; // counts words of given hc having link monitor error\r
532\r
533 UInt_t fMaskADCword; // temp mask when decoding adcs\r
534 UInt_t fTbinADC; // temp adc \r
535\r
536 UInt_t fEventCounter; // stores the valid/current MCM event counter\r
537 UInt_t fLastEventCounter; // last known event counter of MCM\r
538\r
539 Bool_t fSharedPadsOn; // do we want to output shared pads - default is off\r
540 Int_t fMaxADCgeom; // maximum ADC channels per mcm\r
541\r
542 Short_t fADCnumber; // number of the ADC 0 .. 20\r
543 Short_t fCOL; // column - row from MCM\r
544 Short_t fExtendedCOL; // virtual column for extended digit container\r
545 Bool_t fIsShared; // true if the pad is shared pad\r
faad97e3 546 Bool_t fWarnError; // no errors no warnings\r
b48576ab 547\r
548 Bool_t fBufferRead; // set true if the buffer for one ddl is read\r
549\r
550 AliTRDgeometry *fGeometry; //! TRD geometry\r
551 AliRawReader *fRawReader; //! raw reader \r
552\r
553 AliTRDfeeParam *fTRDfeeParam; // pointer to the fee params\r
554 Int_t fCommonAdditive; // baseline value \r
555\r
556 // STATIC \r
557\r
558 static Bool_t fgExtraSkip; // whether we should skip the leading 24 words\r
559 static Bool_t fgSkipCDH; // whether we should skip CDH (8 words)\r
b48576ab 560 static Bool_t fgCleanDataOnly; // release only clean events = no errors\r
561 static Bool_t fgDebugFlag; // allow debugging info\r
562 static Bool_t fgEnableMemoryReset; // allow memory reset\r
563 static Bool_t fgStackNumberChecker; // decide if we check stack number insanity - set false to cleanroom data\r
564 static Bool_t fgStackLinkNumberChecker; // decide if we check stack link number insanity - debuging purpose\r
565 static Bool_t fgSkipData; // decide if we skip corrupted data of given HC\r
566 static Int_t fgDumpHead; // number of words to dump (from the start of the buffer) on each Init\r
567 static Short_t fgMCMordering[16]; // mcm number odering for mcm header corruption check\r
568 static Short_t fgROBordering[16]; // mcm number odering for mcm header corruption check\r
569 static Int_t fgLastHC; // HC number indicator to check HC numbering\r
570 static Int_t fgLastROB; // ROB number indicator to check ROB numbering \r
571 static Int_t fgLastIndex; // variable to check mcm number odering\r
572\r
573 // ----------------- DATA MEMBERS STOP\r
574\r
575 enum ETRDzRawStreamError \r
576 {\r
577 kDecodeStackInfo = 1 //\r
578 , kMissingData = 2 //\r
579 , kLinkDataMissing = 3 //\r
580 , kHCdataMissing = 4 //\r
581 , kTrackletOverflow = 5 //\r
582 , kEOTrackeltsMissing = 6 //\r
583 , kWrongPadrow = 7 //\r
584 , kMCMheaderCorrupted = 8 //\r
585 , kWrongMCMorROB = 9 //\r
586 , kMCMeventMissmatch = 10 //\r
587 , kMCMADCMaskMissing = 11 //\r
588 , kHCHeaderCorrupt = 12 //\r
589 , kHCHeaderWrongStack = 13 //\r
590 , kHCHeaderWrongLayer = 14 //\r
591 , kHCHeaderWrongSide = 15 //\r
592 , kHCHeaderWrongSM = 16 //\r
593 , kHCHeaderWrongDet = 17 //\r
594 , kHCHeaderWrongROC = 18 //\r
595 , kHCWordMissing = 19 //\r
596 , kMCMdataMissing = 20 //\r
597 , kMCMoverflow = 21 //\r
598 , kADCdataMissing = 22 //\r
599 , kADCmaskMissmatch = 23 //\r
600 , kWrongPadcolumn = 24 //\r
601 }; \r
602\r
603 ClassDef(AliTRDrawFastStream, 0)\r
604}; //clas def end\r
605\r
606#endif\r