EMCAL/AliEMCALTriggerTRU.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
  21 Author: R. GUERNANE LPSC Grenoble CNRS/IN2P3
  22 */
  23
  24
  25 #include "AliEMCALTriggerTRU.h"
  26 #include "AliEMCALTriggerPatch.h"
  27 #include "AliEMCALTriggerTRUDCSConfig.h"
  28 #include "AliLog.h"
  29
  30 #include <TClonesArray.h>
  31 #include <TSystem.h>
  32 #include <Riostream.h>
  33
  34 namespace
  35 {
  36         const Int_t kTimeBins       = 16; // number of sampling bins of the FastOR signal
  37         const Int_t kTimeWindowSize =  4; //
  38         const Int_t kNup            =  2; //
  39         const Int_t kNdown          =  1; //
  40 }
  41
  42 ClassImp(AliEMCALTriggerTRU)
  43
  44 //________________
  45 AliEMCALTriggerTRU::AliEMCALTriggerTRU() : AliEMCALTriggerBoard()
  46 ,fDCSConfig(0x0)
  47 {
  48         //
  49         for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
  50 }
  51
  52 //________________
  53 AliEMCALTriggerTRU::AliEMCALTriggerTRU(AliEMCALTriggerTRUDCSConfig* dcsConf, const TVector2& rSize, Int_t mapType) :
  54 AliEMCALTriggerBoard(rSize)
  55 ,fDCSConfig(dcsConf)
  56 {
  57         //
  58         for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
  59
  60         // FIXME: use of class AliEMCALTriggerParam to get size
  61         TVector2 size;
  62
  63         size.Set( 1. , 1. );
  64         SetSubRegionSize( size ); // 1 by 1 FOR
  65
  66         size.Set( 2. , 2. );
  67         SetPatchSize( size );     // 2 by 2 subregions
  68
  69         for (Int_t ietam=0;ietam<24;ietam++)
  70         {
  71                 for (Int_t iphim=0;iphim<4;iphim++)
  72                 {
  73                         // idx: 0..95 since iphim: 0..11 ietam: 0..23
  74                         Int_t idx = ( !mapType ) ? ( 3 - iphim ) + ietam * 4 : iphim + (23 - ietam) * 4;
  75
  76                         // Build a matrix used to get TRU digit id (ADC channel) from (eta,phi)|SM
  77                         fMap[ietam][iphim] = idx; // [0..11][0..3] namely [eta][phi] in SM
  78                 }
  79         }
  80 }
  81
  82 //________________
  83 AliEMCALTriggerTRU::~AliEMCALTriggerTRU()
  84 {
  85    // delete TRU digits only used as transient containers
  86    // to compute FastOR from energy deposit
  87 }
  88
  89 //________________
  90 void AliEMCALTriggerTRU::ShowFastOR(Int_t iTimeWindow, Int_t iChannel)
  91 {
  92         //
  93         Int_t iChanF, iChanL;
  94
  95         if (iChannel != -1) iChanF = iChanL = iChannel;
  96         else
  97         {
  98                 iChanF =  0;
  99                 iChanL = 96;
 100         }
 101
 102         for (Int_t i=iChanF;i<iChanL+1;i++)
 103         {
 104                 printf("\tChannel: %2d - ",i);
 105                 for (Int_t j=0;j<60;j++)
 106                 {
 107                         if (j == iTimeWindow)
 108                                 printf(" | %4d",fADC[i][j]);
 109                         else if (j == iTimeWindow+kTimeWindowSize-1)
 110                                 printf(" %4d |",fADC[i][j]);
 111                         else
 112                                 printf(" %4d",fADC[i][j]);
 113                 }
 114
 115                 printf("\n");
 116         }
 117 }
 118
 119 //________________
 120 Int_t AliEMCALTriggerTRU::L0()
 121 {
 122         // Mimick the TRU L0 'virtual' since not yet released algo
 123
 124         // L0 issuing condition is: (2 up & 1 down) AND (time sum > thres)
 125         // fill a matrix to support sliding window
 126         // compute the time sum for all the FastOR of a given TRU
 127         // and then move the space window
 128
 129         AliDebug(1,"=== Running TRU L0 algorithm ===");
 130         const Int_t xsize    = Int_t(fRegionSize->X());
 131         const Int_t ysize    = Int_t(fRegionSize->Y());
 132         const Int_t zsize    = kNup+kNdown;
 133
 134         Int_t buffer[xsize][ysize][zsize];
 135
 136         for (Int_t i=0; i<fRegionSize->X(); i++) for (Int_t j=0; j<fRegionSize->Y(); j++)
 137                 for (Int_t k=0; k<kNup+kNdown; k++)     buffer[i][j][k] = 0;
 138
 139         // Time sliding window algorithm
 140         for (Int_t i=0; i<=(kTimeBins-kTimeWindowSize); i++)
 141         {
 142                 AliDebug(1,Form("----------- Time window: %d\n",i));
 143
 144                 for (Int_t j=0; j<fRegionSize->X(); j++)
 145                 {
 146                         for (Int_t k=0; k<fRegionSize->Y(); k++)
 147                         {
 148                                 for (Int_t l=i; l<i+kTimeWindowSize; l++)
 149                                 {
 150 //                                      printf("fRegion[%2d][%2d]: %d += fADC[%2d][%2d]: %d\n",j,k,fRegion[j][k],fMap[j][k],l,fADC[fMap[j][k]][l]);
 151                                         // [eta][phi][time]
 152                                         fRegion[j][k] += fADC[fMap[j][k]][l];
 153                                 }
 154
 155                                 buffer[j][k][i%(kNup + kNdown)] = fRegion[j][k];
 156
 157                                 if ( i > kNup + kNdown - 1 )
 158                                 {
 159                                         for (Int_t v = 0; v < kNup + kNdown - 1; v++) buffer[j][k][v] =  buffer[j][k][v+1];
 160
 161                                         buffer[j][k][kNup + kNdown - 1] = fRegion[j][k];
 162                                 }
 163                                 else
 164                                 {
 165                                         buffer[j][k][i] = fRegion[j][k];
 166                                 }
 167
 168 /*
 169                                 for (Int_t v = 0; v<kNup + kNdown; v++)
 170                                         printf("buffer[%2d][%2d][%2d]: %d\n",j,k,v,buffer[j][k][v]);
 171 */
 172
 173 //                              if (kTimeWindowSize > 4) fRegion[j][k] = fRegion[j][k] >> 1; // truncate time sum to fit 14b
 174                         }
 175                 }
 176
 177                 // Don't start to evaluate space sum if a peak can't be findable
 178                 if (i < kNup + kNdown - 1)
 179                 {
 180                         ZeroRegion();
 181                         continue;
 182                 }
 183
 184                 Int_t peaks[xsize][ysize];
 185
 186                 for (Int_t j=0; j<fRegionSize->X(); j++) for (Int_t k=0; k<fRegionSize->Y(); k++) peaks[j][k] = 0;
 187
 188                 Int_t nPeaks = 0;
 189
 190                 for (Int_t j=0; j<fRegionSize->X(); j++)
 191                 {
 192                         for (Int_t k=0; k<fRegionSize->Y(); k++)
 193                         {
 194                                 Int_t foundU = 0;
 195
 196                                 Int_t foundD = 0;
 197
 198                                 for (Int_t l=   1;l<kNup       ;l++) foundU = ( buffer[j][k][l]> buffer[j][k][l-1] && buffer[j][k][l-1] ) ? 1 : 0;
 199
 200                                 for (Int_t l=kNup;l<kNup+kNdown;l++) foundD = ( buffer[j][k][l]<=buffer[j][k][l-1] && buffer[j][k][l  ] ) ? 1 : 0;
 201
 202                                 if ( foundU && foundD )
 203                                 {
 204                                         peaks[j][k] = 1;
 205                                         nPeaks++;
 206                                 }
 207                         }
 208                 }
 209
 210 /*
 211                 for (Int_t j=0; j<fRegionSize->X(); j++)
 212                 {
 213                         for (Int_t k=0; k<fRegionSize->Y(); k++)
 214                         {
 215                                 printf("peaks[%2d][%2d]: %d\n",j,k,peaks[j][k]);
 216                         }
 217                 }
 218 */
 219                 if ( !nPeaks )
 220                 {
 221                         ZeroRegion();
 222                         continue;
 223                 }
 224
 225                 // Threshold
 226                 // FIXME: for now consider just one threshold for all patches, should consider one per patch?
 227                 // ANSWE: both solutions will be implemented in the TRU
 228                 // return the list of patches above threshold
 229                 // Theshold checked out from OCDB
 230
 231                 SlidingWindow( kGamma, fDCSConfig->GetGTHRL0() );
 232
 233 //              for(Int_t j=0; j<fRegionSize->X(); j++)
 234 //                      for (Int_t k=0; k<fRegionSize->Y(); k++) fRegion[j][k] = fRegion[j][k]>>2; // go to 12b before shipping to STU
 235
 236                 Int_t nP = 0;
 237
 238                 for (Int_t j=0; j<fPatches->GetEntriesFast(); j++)
 239                 {
 240                         AliEMCALTriggerPatch* p = (AliEMCALTriggerPatch*)fPatches->At( j );
 241
 242                         if ( AliDebugLevel() ) p->Print("");
 243
 244                         TVector2 v; p->Position(v);
 245
 246                         Int_t sizeX = (Int_t)(fPatchSize->X() * fSubRegionSize->X());
 247
 248                         Int_t sizeY = (Int_t)(fPatchSize->Y() * fSubRegionSize->Y());
 249
 250                         const Int_t psize =  sizeX * sizeY; // Number of FastOR in the patch
 251
 252                         Int_t* idx = new Int_t[psize];
 253
 254                         for (Int_t xx=0;xx<sizeX;xx++)
 255                         {
 256                                 for (Int_t yy=0;yy<sizeY;yy++)
 257                                 {
 258                                         Int_t index = xx*sizeY+yy;
 259
 260                                         idx[index] = fMap[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]; // Get current patch FastOR ADC channels
 261
 262                                         if (peaks[int(v.X()*fSubRegionSize->X())+xx][int(v.Y()*fSubRegionSize->Y())+yy]) nP++;
 263
 264                                         if ( AliDebugLevel() ) ShowFastOR(i,idx[index]);
 265                                 }
 266                         }
 267
 268                         if ( nP )
 269                         {
 270 //                              cout << "break patch loop" << endl;
 271                                 break;
 272                         }
 273                 }
 274
 275                 if ( !nP )
 276                         fPatches->Delete();
 277                 else
 278                 {
 279 //                      cout << "break time loop" << endl;
 280                         break;     // Stop the algo when at least one patch is found ( thres & max )
 281                 }
 282
 283                 ZeroRegion();  // Clear fRegion for this time window before computing the next one
 284         }
 285
 286 //      cout << "Nof patches: " << fPatches->GetEntriesFast() << endl;
 287
 288         return fPatches->GetEntriesFast();
 289 }
 290
 291 //________________
 292 void AliEMCALTriggerTRU::SetADC( Int_t channel, Int_t bin, Int_t sig )
 293 {
 294         //
 295         if (channel>95) AliError("TRU has 96 ADC channels only!");
 296         fADC[channel][bin] = sig;
 297 }
 298
 299 //________________
 300 void AliEMCALTriggerTRU::SaveRegionADC(Int_t iTRU, Int_t iEvent)
 301 {
 302         // O for STU Hw
 303         //
 304         gSystem->Exec(Form("mkdir -p Event%d",iEvent));
 305
 306         ofstream outfile(Form("Event%d/data_TRU%d.txt",iEvent,iTRU),ios_base::trunc);
 307
 308         for (Int_t i=0;i<96;i++)
 309         {
 310                 Int_t ietam = 23 - i/4;
 311
 312                 Int_t iphim =  3 - i%4;
 313
 314                 outfile << fRegion[ietam][iphim] << endl;
 315         }
 316
 317         outfile.close();
 318 }
 319
 320 //________________
 321 void AliEMCALTriggerTRU::Reset()
 322 {
 323         //
 324         fPatches->Delete();
 325
 326         ZeroRegion();
 327
 328         for (Int_t i=0;i<96;i++) for (Int_t j=0;j<256;j++) fADC[i][j] = 0;
 329 }
 330