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