a3390ea0713d52098c04928bb67987aae453a1f0
[u/mrichter/AliRoot.git] / EMCAL / AliEMCALTriggerSTURawStream.cxx
1
2 /**************************************************************************
3  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
4  *                                                                        *
5  * Author: The ALICE Off-line Project.                                    *
6  * Contributors are mentioned in the code where appropriate.              *
7  *                                                                        *
8  * Permission to use, copy, modify and distribute this software and its   *
9  * documentation strictly for non-commercial purposes is hereby granted   *
10  * without fee, provided that the above copyright notice appears in all   *
11  * copies and that both the copyright notice and this permission notice   *
12  * appear in the supporting documentation. The authors make no claims     *
13  * about the suitability of this software for any purpose. It is          *
14  * provided "as is" without express or implied warranty.                  *
15  **************************************************************************/
16
17 /*
18
19
20
21 This class provides access to STU DDL raw data.
22 Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
23 */
24
25 #include "AliEMCALTriggerSTURawStream.h"
26 #include "AliRawReader.h"
27 #include "AliLog.h"
28
29 #include "Riostream.h"
30 #include "TBits.h"
31
32 #include <cstdlib>
33
34 namespace
35 {
36         const Int_t kPayLoadSizeOld     = 236;
37         const Int_t kPayLoadSizeNew     = 245;
38 }
39
40 ClassImp(AliEMCALTriggerSTURawStream)
41
42 //_____________________________________________________________________________
43 AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream() : TObject(),
44 fRawReader(0x0),
45 fL1JetThreshold(0),
46 fL1GammaThreshold(0),
47 fL0GammaPatchIndex(),
48 fL1GammaPatchIndex(),
49 fL1JetPatchIndex(),
50 fNL0GammaPatch(0),
51 fNL1JetPatch(0),
52 fNL1GammaPatch(0),
53 fGetRawData(0),
54 fV0A(0),
55 fV0C(0),
56 fGA(0),
57 fGB(0),
58 fGC(0),
59 fJA(0),
60 fJB(0),
61 fJC(0),
62 fRegionEnable(0),
63 fFrameReceived(0),
64 fFwVersion(0)
65 {
66         //
67 }
68
69 //_____________________________________________________________________________
70 AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream(AliRawReader* rawReader) : TObject(),
71 fRawReader(rawReader),
72 fL1JetThreshold(0),
73 fL1GammaThreshold(0),
74 fL0GammaPatchIndex(),
75 fL1GammaPatchIndex(),
76 fL1JetPatchIndex(),
77 fNL0GammaPatch(0),
78 fNL1JetPatch(0),
79 fNL1GammaPatch(0),
80 fGetRawData(0),
81 fV0A(0),
82 fV0C(0),
83 fGA(0),
84 fGB(0),
85 fGC(0),
86 fJA(0),
87 fJB(0),
88 fJC(0),
89 fRegionEnable(0),
90 fFrameReceived(0),
91 fFwVersion(0)
92 {
93         //
94         fRawReader->Reset();
95         fRawReader->Select("EMCAL",44);
96 }
97
98 //_____________________________________________________________________________
99 AliEMCALTriggerSTURawStream::~AliEMCALTriggerSTURawStream()
100 {
101         // destructor
102 }
103
104 //_____________________________________________________________________________
105 void AliEMCALTriggerSTURawStream::Reset()
106 {
107         // Reset
108         
109         if (fRawReader) fRawReader->Reset();
110         
111         fNL0GammaPatch = 0;
112         fNL1GammaPatch = 0;
113         fNL1JetPatch   = 0;     
114 }
115
116 //_____________________________________________________________________________
117 Bool_t AliEMCALTriggerSTURawStream::ReadPayLoad()
118 {
119         // STU data decoder from Olivier Bourrion LPSC CNRS-IN2P3
120         // bourrion_at_lpsc_dot_in2p3_dot_fr
121         
122         UInt_t word32[kPayLoadSizeNew + 1536]; // 32b words
123         for (Int_t i = 0;i < kPayLoadSizeNew + 1536; i++) word32[i] = 0;
124         
125         Int_t iword = 0;
126         
127         fNL0GammaPatch = 0;
128         fNL1GammaPatch = 0;
129         fNL1JetPatch   = 0;
130         
131         Int_t eqId = -1, eqSize = 0;
132         
133         UInt_t w32;
134         
135         while (fRawReader->ReadNextInt(w32)) 
136         {
137                 if (!iword)
138                 {
139                         eqId   = fRawReader->GetEquipmentId();
140                         eqSize = fRawReader->GetEquipmentSize();
141                 }
142                 
143                 word32[iword++] = w32;
144         }
145         
146         if (iword != kPayLoadSizeOld && iword != kPayLoadSizeNew && iword != (kPayLoadSizeOld + 1536) && iword != (kPayLoadSizeNew + 1536))
147         {
148                 AliError(Form("STU payload (eqId: %d, eqSize: %d) doesn't match expected size! %d word32",
149                                           eqId, eqSize, iword));
150                 return kFALSE;
151         }
152         
153         if (AliDebugLevel())
154         {
155                 AliInfo(Form("STU (eqId: %d, eqSize: %d) payload size: %d word32",
156                                          eqId, eqSize, iword));
157         }
158         
159         int offset = 0, jetSize = 2;
160         
161         switch (iword) 
162         {
163                 case kPayLoadSizeOld:
164                 case kPayLoadSizeOld + 1536:
165                 {
166                         fL1JetThreshold   = ((word32[0]>>16) & 0xFFFF);
167                         fL1GammaThreshold =  (word32[0]      & 0xFFFF);
168                         
169                         break;
170                 }
171                 case kPayLoadSizeNew:
172                 case kPayLoadSizeNew + 1536:
173                 {
174                         fV0A = ((word32[0]>>16) & 0xFFFF);
175                         fV0C =  (word32[0]      & 0xFFFF);
176                         
177                         UInt_t sV0 = fV0A + fV0C;
178                         
179                         fGA            = word32[1];
180                         fGB            = word32[2];
181                         fGC            = word32[3];
182                         fJA            = word32[4];
183                         fJB            = word32[5];
184                         fJC            = word32[6];             
185                         fRegionEnable  = word32[7];
186                         fFrameReceived = word32[8];
187                         fFwVersion     = word32[9];
188                         
189                         jetSize += (fFwVersion >> 16);
190                         
191                         fL1JetThreshold   = fJA * sV0 * sV0 + fJB * sV0 + fJC;
192                         fL1GammaThreshold = fGA * sV0 * sV0 + fGB * sV0 + fGC;          
193                         
194                         offset = 9;
195                         
196                         break;
197                 }
198         }
199         
200         ///////////
201         // START DECODING
202         //////////
203
204         for (Int_t jet_row = 0; jet_row < 12 - (jetSize - 1); jet_row++)
205         {
206                 UInt_t currentrow = word32[offset + 1 + jet_row];
207                 
208                 for (Int_t jet_col = 0; jet_col < 15; jet_col++)
209                 {
210                         if (currentrow & (1 << jet_col))
211                         {
212                                 fNL1JetPatch++;
213                                 
214                                 fL1JetPatchIndex[fNL1JetPatch-1] = ((jet_row << 8) & 0xFF00) | (jet_col & 0xFF);
215                         }
216                 }
217         }
218                 
219         
220         //////////////////////////////////////////////////////////
221         // index des L0                                         //
222         //////////////////////////////////////////////////////////
223         // FIXME: sounds like not valid data
224         
225         unsigned short truL0indexes[32][6];
226         
227         // extraction from stream
228         for (Int_t index=0;index<6;index++)
229         {
230                 for (Int_t tru_num=0;tru_num<16;tru_num++)
231                 {
232                         truL0indexes[2*tru_num  ][index] = ( word32[offset + 12 + index * 16 + tru_num]        & 0xFFFF);
233                         truL0indexes[2*tru_num+1][index] = ((word32[offset + 12 + index * 16 + tru_num] >> 16) & 0xFFFF);
234                 }
235         }
236
237         for (Int_t tru_num=0;tru_num<32;tru_num++) 
238         {
239                 for (Int_t index=0;index<6;index++) 
240                 {
241                         for (Int_t bit_num=0;bit_num<12;bit_num++)
242                         {
243                                 if ((truL0indexes[tru_num][index] & (1 << bit_num)))
244                                 {
245                                         Int_t idx = 12 * index + bit_num;
246                                                                                 
247                                         fNL0GammaPatch++;
248                                         
249                                         fL0GammaPatchIndex[fNL0GammaPatch-1] = (((idx << 5) & 0x7E0) | (tru_num & 0x1F));
250                                 }
251                         }
252                 }
253         }
254
255         //////////////////////////////////////////////////////////
256         // index des L1 gamma                                   //
257         //////////////////////////////////////////////////////////
258         
259         unsigned short truL1indexes[32][8];
260         
261         // extraction from stream
262         for (Int_t index=0;index<8;index++)
263         {
264                 for (Int_t tru_num=0;tru_num<16;tru_num++)
265                 {
266                         truL1indexes[2*tru_num  ][index] = ( word32[offset + 108 + index * 16 + tru_num]        & 0xFFFF);
267                         truL1indexes[2*tru_num+1][index] = ((word32[offset + 108 + index * 16 + tru_num] >> 16) & 0xFFFF);
268                 }
269         }       
270
271         // interpretation
272         int gammacolnum;
273         short indexcopy;
274         
275         for (Int_t tru_num=0;tru_num<32;tru_num++)
276         {
277                 for (Int_t index=0;index<8;index++)
278                 {
279                         for (Int_t bit_num=0; bit_num<12; bit_num++)
280                         {
281                                 if ((truL1indexes[tru_num][index] & (1<<bit_num)) != 0)
282                                 {
283                                         if (index<4) // Even
284                                         {
285                                                 gammacolnum = (2*bit_num  );
286                                                 indexcopy   = index;
287                                         }
288                                         else         // Odd
289                                         {
290                                                 gammacolnum = (2*bit_num+1);
291                                                 indexcopy   = index-4;
292                                         }                                               
293                                         
294                                         fNL1GammaPatch++;
295                                         
296                                         fL1GammaPatchIndex[fNL1GammaPatch-1] = (((indexcopy << 10) & 0xC00) | ((gammacolnum << 5) & 0x3E0) | (tru_num & 0x1F));
297                                 }
298                         }
299                 }
300         }       
301
302         //////////////////////////////////////////////////////////
303         // raw output                                           //
304         //////////////////////////////////////////////////////////
305         
306         if (iword == kPayLoadSizeOld || iword == kPayLoadSizeNew) 
307         {
308                 fGetRawData = 0;
309                 return kTRUE;
310         }
311         
312         fGetRawData = 1;
313         
314         // extraction from stream
315         for (Int_t index=0;index<96;index++)
316         {
317                 for (Int_t tru_num=0;tru_num<16;tru_num++)
318                 {
319                         fADC[2*tru_num  ][index] = ( word32[offset + 236 + index * 16 + tru_num]        & 0xFFFF);
320                         fADC[2*tru_num+1][index] = ((word32[offset + 236 + index * 16 + tru_num] >> 16) & 0xFFFF);
321                 }
322         }       
323
324         for (Int_t tru_num=16;tru_num<32;tru_num++) // A side
325         {
326                 Int_t v[96];
327                 for (Int_t index=0;index<96;index++) v[index] = fADC[tru_num][95-index];
328                 
329                 for (Int_t index=0;index<96;index++) fADC[tru_num][index] = v[index];
330         }
331         
332         return kTRUE;
333 }
334
335 //_____________________________________________________________________________
336 Bool_t AliEMCALTriggerSTURawStream::GetL0GammaPatch(const Int_t i, Int_t& tru, Int_t& idx) const
337 {
338         // L0 gamma patches sent to STU (original access to L0 patch indexes)
339         
340         if (i > fNL0GammaPatch) return kFALSE;
341         
342         tru =  fL0GammaPatchIndex[i] & 0x1F;
343         idx = (fL0GammaPatchIndex[i] & 0x7E0) >> 5;
344         
345         return kTRUE;
346 }
347
348 //_____________________________________________________________________________
349 Bool_t AliEMCALTriggerSTURawStream::GetL1GammaPatch(const Int_t i, Int_t& tru, Int_t& col, Int_t& row) const
350 {
351         // L1 gamma patch indexes
352         
353         if (i > fNL1GammaPatch) return kFALSE;
354         
355         tru =  fL1GammaPatchIndex[i] & 0x1F;
356         col = (fL1GammaPatchIndex[i] & 0x3E0) >> 5;
357         row = (fL1GammaPatchIndex[i] & 0xC00) >> 10;
358         
359         return kTRUE;
360 }
361
362 //_____________________________________________________________________________
363 Bool_t AliEMCALTriggerSTURawStream::GetL1JetPatch(const Int_t i, Int_t& col, Int_t& row) const
364 {
365         // L1 jet patch indexes
366         
367         if (i > fNL1JetPatch) return kFALSE;
368         
369         col =  fL1JetPatchIndex[i] & 0xFF;
370         row = (fL1JetPatchIndex[i] & 0xFF00) >> 8;
371         
372         return kTRUE;
373 }
374
375 //_____________________________________________________________________________
376 void AliEMCALTriggerSTURawStream::GetADC(Int_t iTRU, UInt_t ADC[])
377 {
378         // Time sums
379         
380         for (Int_t i=0; i<96; i++) ADC[i] = fADC[iTRU][i];
381 }
382
383 //_____________________________________________________________________________
384 void AliEMCALTriggerSTURawStream::DumpPayLoad(const Option_t *option) const
385 {
386         // Dump STU payload
387         
388         TString op = option;
389         
390         printf("V0A:             %d\n", fV0A);
391         printf("V0C:             %d\n", fV0C);
392         printf("G_A:             %d\n", fGA);
393         printf("G_B:             %d\n", fGB);
394         printf("G_C:             %d\n", fGC);
395         printf("Gamma threshold: %d\n", fL1GammaThreshold);
396         printf("J_A:             %d\n", fJA);
397         printf("J_B:             %d\n", fJB);
398         printf("J_C:             %d\n", fJC);
399         printf("Jet Threshold:   %d\n", fL1JetThreshold);
400         printf("RawData:         %d\n", fGetRawData);
401         printf("RegionEnable:    %8x\n", fRegionEnable); 
402         printf("FrameReceived:   %8x\n", fFrameReceived);
403         printf("FwVersion:       %x\n", fFwVersion);
404         printf("Number of L0:    %d\n", fNL0GammaPatch);
405         printf("Number of L1-g:  %d\n", fNL1GammaPatch);
406         printf("Number of L1-j:  %d\n", fNL1JetPatch);
407         
408         Int_t itru, col, row;
409         
410         if (op.Contains("L0") || op.Contains("ALL"))
411         {
412                 for (Int_t i=0;i<fNL0GammaPatch;i++)
413                 {
414                         
415                         if (GetL0GammaPatch(i,itru,col)) 
416                                 cout << "> Found L0 gamma in TRU #" << setw(2) << itru <<  " at idx: " << setw(2) << col << endl;
417                 }
418         }
419         
420         if (op.Contains("L1") || op.Contains("ALL"))
421         {
422                 for (Int_t i=0;i<fNL1GammaPatch;i++)
423                 {
424                         if (GetL1GammaPatch(i,itru,col,row)) 
425                                 cout << "> Found L1 gamma in TRU #" << setw(2) << itru <<  " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
426                 }
427
428                 for (Int_t i=0;i<fNL1JetPatch;i++)
429                 {
430                         if (GetL1JetPatch(i,col,row)) cout << "> Found L1 jet at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
431                 }
432         }
433         
434         
435         
436         if ( (op.Contains("ADC") || op.Contains("ALL")) && fGetRawData )
437         {
438                 for (Int_t i=0;i<32;i++)
439                 {
440                         cout << "--------\n";
441                         cout << "TRU #" << setw(2) << i << ":";
442                         for (Int_t j=0;j<96;j++) 
443                         { 
444                                 TBits xadc(12); xadc.Set(12,&fADC[i][j]); 
445                                 if ((j%4)==0) cout << endl;
446                                 //cout << setw(2) << j << ": " << xadc << " ";
447                                 printf("%2d: %3x / ",j,fADC[i][j]); 
448                         }
449                         cout << "\n";
450                 }
451         }
452 }