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