EMCAL/AliEMCALTriggerSTURawStream.cxx

   1 /**************************************************************************
   2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   3  *                                                                        *
   4  * Author: The ALICE Off-line Project.                                    *
   5  * Contributors are mentioned in the code where appropriate.              *
   6  *                                                                        *
   7  * Permission to use, copy, modify and distribute this software and its   *
   8  * documentation strictly for non-commercial purposes is hereby granted   *
   9  * without fee, provided that the above copyright notice appears in all   *
  10  * copies and that both the copyright notice and this permission notice   *
  11  * appear in the supporting documentation. The authors make no claims     *
  12  * about the suitability of this software for any purpose. It is          *
  13  * provided "as is" without express or implied warranty.                  *
  14  **************************************************************************/
  15
  16 /*
  17
  18
  19
  20 This class provides access to STU DDL raw data.
  21 Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
  22 */
  23
  24 #include "AliEMCALTriggerSTURawStream.h"
  25 #include "AliRawReader.h"
  26 #include "AliLog.h"
  27
  28 #include "Riostream.h"
  29 #include "TBits.h"
  30
  31 namespace
  32 {
  33         const Int_t kPayLoadSize = 944;
  34 }
  35
  36 ClassImp(AliEMCALTriggerSTURawStream)
  37
  38 //_____________________________________________________________________________
  39 AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream() : TObject(),
  40 fRawReader(0x0),
  41 fL1JetThreshold(0),
  42 fL1GammaThreshold(0),
  43 fL0GammaPatchIndex(0x0),
  44 fL1GammaPatchIndex(0x0),
  45 fL1JetPatchIndex(0x0),
  46 fNL0GammaPatch(0),
  47 fNL1JetPatch(0),
  48 fNL1GammaPatch(0),
  49 fL0(0)
  50 {
  51         //
  52 }
  53
  54 //_____________________________________________________________________________
  55 AliEMCALTriggerSTURawStream::AliEMCALTriggerSTURawStream(AliRawReader* rawReader) : TObject(),
  56 fRawReader(rawReader),
  57 fL1JetThreshold(0),
  58 fL1GammaThreshold(0),
  59 fL0GammaPatchIndex(0x0),
  60 fL1GammaPatchIndex(0x0),
  61 fL1JetPatchIndex(0x0),
  62 fNL0GammaPatch(0),
  63 fNL1JetPatch(0),
  64 fNL1GammaPatch(0),
  65 fL0(0)
  66 {
  67         //
  68         fRawReader->Reset();
  69         fRawReader->Select("EMCAL",44);
  70 }
  71
  72 //_____________________________________________________________________________
  73 AliEMCALTriggerSTURawStream::~AliEMCALTriggerSTURawStream()
  74 {
  75         // destructor
  76 }
  77
  78 //_____________________________________________________________________________
  79 void AliEMCALTriggerSTURawStream::Reset()
  80 {
  81         //
  82         if (fRawReader) fRawReader->Reset();
  83 }
  84
  85 //_____________________________________________________________________________
  86 Bool_t AliEMCALTriggerSTURawStream::ReadPayLoad()
  87 {
  88         // STU data decoder from Olivier Bourrion LPSC CNRS-IN2P3
  89         // bourrion@lpsc.in2p3.fr
  90
  91         UInt_t word32[1772]; // 32b words
  92
  93         Int_t iword = 0;
  94
  95         UInt_t w32;
  96         while (fRawReader->ReadNextInt(w32)) word32[iword++] = w32;
  97
  98         if (iword < kPayLoadSize)
  99         {
 100                 AliError(Form("STU raw data size is too small: %d word32 only!", iword));
 101                 return kFALSE;
 102         }
 103         else if (iword > kPayLoadSize )
 104         {
 105                 AliLog::Message(AliLog::kInfo, "TRU raw data in the STU payload enabled","EMCAL","AliEMCALTriggerSTURawStream","ReadPayLoad()","AliEMCALTriggerSTURawStream.cxx",104);
 106         }
 107
 108         fL0 = 0;
 109
 110           fL1JetThreshold = ((word32[0]>>16) & 0xFFF);
 111         fL1GammaThreshold =  (word32[0]      & 0xFFF);
 112
 113         for (Int_t jet_row=0; jet_row<11; jet_row++)
 114         {
 115                 UInt_t currentrow = word32[1+jet_row];
 116
 117                 for (Int_t jet_col=0; jet_col<15; jet_col++)
 118                 {
 119                         if (currentrow & (1 << jet_col))
 120                         {
 121                                 fNL1JetPatch++;
 122                                 fL1JetPatchIndex = (UShort_t*)realloc(fL1JetPatchIndex, fNL1JetPatch * sizeof(UShort_t));
 123                                 if (fL1JetPatchIndex == NULL) {AliError("Error (re)allocating L1 jet patch memory");}
 124
 125                                 fL1JetPatchIndex[fNL1JetPatch-1] = ((jet_row << 8) & 0xFF00) | (jet_col & 0xFF);
 126                         }
 127                 }
 128         }
 129
 130         //////////////////////////////////////////////////////////
 131         // index des L0                                         //
 132         //////////////////////////////////////////////////////////
 133         // FIXME: still not interpreted to be done with Jiri
 134
 135         unsigned short TRU_L0_indexes[32][6];
 136
 137         // extraction from stream
 138         for (Int_t index=0;index<6;index++)
 139         {
 140                 for (Int_t tru_num=0;tru_num<16;tru_num++)
 141                 {
 142                         TRU_L0_indexes[2*tru_num  ][index] = ( word32[12+index*16+tru_num]      & 0xFFFF);
 143                         TRU_L0_indexes[2*tru_num+1][index] = ((word32[12+index*16+tru_num]>>16) & 0xFFFF);
 144                 }
 145         }
 146
 147         for (Int_t tru_num=0;tru_num<32;tru_num++)
 148         {
 149                 for (Int_t index=0;index<6;index++)
 150                 {
 151                         for (Int_t bit_num=0;bit_num<12;bit_num++)
 152                         {
 153                                 if ((TRU_L0_indexes[tru_num][index] & (1 << bit_num)))
 154                                 {
 155                                         fL0 = 1;
 156
 157                                         Int_t idx = 12 * index + bit_num;
 158
 159                                         Int_t col = idx / 3;
 160                                         Int_t row = idx % 3;
 161
 162                                         fNL0GammaPatch++;
 163                                         fL0GammaPatchIndex = (UShort_t*)realloc(fL0GammaPatchIndex, fNL0GammaPatch * sizeof(UShort_t));
 164
 165                                         if (fL0GammaPatchIndex == NULL) {AliError("Error (re)allocating L0 gamma patch memory");}
 166
 167                                         fL0GammaPatchIndex[fNL0GammaPatch-1] = (((row << 10) & 0xC00) | ((col << 5) & 0x3E0) | (tru_num & 0x1F));
 168                                 }
 169                         }
 170                 }
 171         }
 172
 173         //////////////////////////////////////////////////////////
 174         // index des L1 gamma                                   //
 175         //////////////////////////////////////////////////////////
 176
 177         unsigned short TRU_L1_indexes[32][8];
 178
 179         // extraction from stream
 180         for (Int_t index=0;index<8;index++)
 181         {
 182                 for (Int_t tru_num=0;tru_num<16;tru_num++)
 183                 {
 184                         TRU_L1_indexes[2*tru_num  ][index] = ( word32[108+index*16+tru_num]      & 0xFFFF);
 185                         TRU_L1_indexes[2*tru_num+1][index] = ((word32[108+index*16+tru_num]>>16) & 0xFFFF);
 186                 }
 187         }
 188
 189         // interpretation
 190         int gammacolnum;
 191         short indexcopy;
 192
 193         for (Int_t tru_num=0;tru_num<32;tru_num++)
 194         {
 195                 for (Int_t index=0;index<8;index++)
 196                 {
 197                         for (Int_t bit_num=0; bit_num<12; bit_num++)
 198                         {
 199                                 if ((TRU_L1_indexes[tru_num][index] & (1<<bit_num)) != 0)
 200                                 {
 201                                         if (index<4) // Even
 202                                         {
 203                                                 gammacolnum = (2*bit_num  );
 204                                                 indexcopy   = index;
 205                                         }
 206                                         else         // Odd
 207                                         {
 208                                                 gammacolnum = (2*bit_num+1);
 209                                                 indexcopy   = index-4;
 210                                         }
 211
 212                                         fNL1GammaPatch++;
 213                                         fL1GammaPatchIndex = (UShort_t*)realloc(fL1GammaPatchIndex, fNL1GammaPatch * sizeof(UShort_t));
 214
 215                                         if (fL1GammaPatchIndex == NULL) {AliError("Error (re)allocating L1 gamma patch memory");}
 216
 217                                         fL1GammaPatchIndex[fNL1GammaPatch-1] = (((indexcopy << 10) & 0xC00) | ((gammacolnum << 5) & 0x3E0) | (tru_num & 0x1F));
 218                                 }
 219                         }
 220                 }
 221         }
 222
 223         //////////////////////////////////////////////////////////
 224         // raw output                                           //
 225         //////////////////////////////////////////////////////////
 226
 227         if ( iword <= kPayLoadSize ) return kFALSE;
 228
 229         // extraction from stream
 230         for (Int_t index=0;index<96;index++)
 231         {
 232                 for (Int_t tru_num=0;tru_num<16;tru_num++)
 233                 {
 234                         fADC[2*tru_num  ][index] = ( word32[236+index*16+tru_num]      & 0xFFFF);
 235                         fADC[2*tru_num+1][index] = ((word32[236+index*16+tru_num]>>16) & 0xFFFF);
 236                 }
 237         }
 238
 239         for (Int_t tru_num=16;tru_num<32;tru_num++) // A side
 240         {
 241                 for (Int_t index=0;index<96;index++)
 242                 {
 243                         fADC[tru_num][index] = fADC[tru_num][95-index];
 244                 }
 245         }
 246
 247         return kFALSE;
 248 }
 249
 250 //_____________________________________________________________________________
 251 Bool_t AliEMCALTriggerSTURawStream::GetL0GammaPatch(const Int_t i, Int_t& tru, Int_t& col, Int_t& row) const
 252 {
 253         //
 254         if (i > fNL0GammaPatch) return kFALSE;
 255
 256         tru =  fL0GammaPatchIndex[i] & 0x1F;
 257         col = (fL0GammaPatchIndex[i] & 0x3E0) >> 5;
 258         row = (fL0GammaPatchIndex[i] & 0xC00) >> 10;
 259
 260         return kTRUE;
 261 }
 262
 263 //_____________________________________________________________________________
 264 Bool_t AliEMCALTriggerSTURawStream::GetL1GammaPatch(const Int_t i, Int_t& tru, Int_t& col, Int_t& row) const
 265 {
 266         //
 267         if (i > fNL1GammaPatch) return kFALSE;
 268
 269         tru =  fL1GammaPatchIndex[i] & 0x1F;
 270         col = (fL1GammaPatchIndex[i] & 0x3E0) >> 5;
 271         row = (fL1GammaPatchIndex[i] & 0xC00) >> 10;
 272
 273         return kTRUE;
 274 }
 275
 276 //_____________________________________________________________________________
 277 Bool_t AliEMCALTriggerSTURawStream::GetL1JetPatch(const Int_t i, Int_t& col, Int_t& row) const
 278 {
 279         //
 280         if (i > fNL1JetPatch) return kFALSE;
 281
 282         col =  fL1JetPatchIndex[i] & 0xFF;
 283         row = (fL1JetPatchIndex[i] & 0xFF00) >> 8;
 284
 285         return kTRUE;
 286 }
 287
 288 //_____________________________________________________________________________
 289 void AliEMCALTriggerSTURawStream::GetADC(Int_t iTRU, UInt_t ADC[])
 290 {
 291         //
 292         for (Int_t i=0; i<96; i++) ADC[i] = fADC[iTRU][i];
 293 }
 294
 295 //_____________________________________________________________________________
 296 void AliEMCALTriggerSTURawStream::Dump(const Option_t *option) const
 297 {
 298         //
 299         TString op = option;
 300
 301         cout << "Jet Threshold: " << fL1JetThreshold << " Gamma threshold: " << fL1GammaThreshold << endl;
 302
 303         Int_t itru, col, row;
 304
 305         Bool_t isOK;
 306
 307         if (op.Contains("L0") || op.Contains("ALL"))
 308         {
 309                 for (Int_t i=0;i<fNL0GammaPatch;i++)
 310                 {
 311                         isOK = GetL0GammaPatch(i,itru,col,row);
 312                         if (isOK) cout << "> Found L0 gamma in TRU #" << setw(2) << itru
 313                                                 <<  " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
 314                 }
 315         }
 316
 317         if (op.Contains("L1") || op.Contains("ALL"))
 318         {
 319                 for (Int_t i=0;i<fNL1GammaPatch;i++)
 320                 {
 321                         isOK = GetL1GammaPatch(i,itru,col,row);
 322                         if (isOK) cout << "> Found L1 gamma in TRU #" << setw(2) << itru
 323                                                 <<  " at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
 324                 }
 325
 326                 for (Int_t i=0;i<fNL1JetPatch;i++)
 327                 {
 328                         isOK = GetL1JetPatch(i,col,row);
 329                         if (isOK) cout << "> Found L1 jet at: ( col: " << setw(2) << col << " , row: " << setw(2) << row << " )" << endl;
 330                 }
 331         }
 332
 333         if (op.Contains("ADC") || op.Contains("ALL"))
 334         {
 335                 for (Int_t i=0;i<32;i++)
 336                 {
 337                         cout << "--------\n";
 338                         cout << "TRU #" << setw(2) << i << ":";
 339                         for (Int_t j=0;j<96;j++)
 340                         {
 341                                 TBits xadc(12); xadc.Set(12,&fADC[i][j]);
 342                                 if ((j%4)==0) cout << endl;
 343                                 //cout << setw(2) << j << ": " << xadc << " ";
 344                                 printf("%2d: %3x / ",j,fADC[i][j]);
 345                         }
 346                         cout << "\n";
 347                 }
 348         }
 349 }