TOF/AliTOFDigitMap.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 $Log$
  18 Revision 1.12  2007/02/20 15:57:00  decaro
  19 Raw data update: to read the TOF raw data defined in UNPACKED mode
  20
  21 */
  22
  23 ////////////////////////////////////////////////////////////////////////
  24 //
  25 // AliTOFDigitMap class
  26 //
  27 // digitmap enables fast check if the pad was already digit.
  28
  29 // The index of a AliTOFdigit is saved in the each digitmap "cell"
  30 // (there is an offset +1, because the index can be zero and zero
  31 // means empty cell).
  32 // In TOF, number of strips varies according plate type, the highest
  33 // number is in plate C. For all plates is used this number, so the
  34 // size of the digitmap is a little bit greater than necessary, but it
  35 // simplifies the access algorithm.
  36 //
  37 //
  38 // Author: F. Pierella based on AliTOFHitMap
  39 //
  40 // Modified by A. De Caro
  41 //
  42 ///////////////////////////////////////////////////////////////////////
  43
  44 #include "AliLog.h"
  45
  46 #include "AliTOFDigitMap.h"
  47 #include "AliTOFGeometry.h"
  48
  49 ClassImp(AliTOFDigitMap)
  50
  51 AliTOFDigitMap::AliTOFDigitMap():
  52   fNSector(AliTOFGeometry::NSectors()),
  53   fNplate(AliTOFGeometry::NPlates()),
  54   fNstrip(AliTOFGeometry::NStripC()),
  55   fNpx(AliTOFGeometry::NpadX()),
  56   fNpz(AliTOFGeometry::NpadZ()),
  57   fMaxIndex(-1),
  58   fDigitMap(0x0)
  59 {
  60 //
  61 // Default ctor
  62 //
  63
  64   fMaxIndex=fNSector*fNplate*fNstrip*fNpx*fNpz;
  65   fDigitMap = new Int_t*[fMaxIndex];
  66
  67   for (Int_t i=0; i<fMaxIndex; i++) fDigitMap[i] = new Int_t[kMaxDigitsPerPad];
  68   Clear();
  69 }
  70
  71 ////////////////////////////////////////////////////////////////////////
  72 AliTOFDigitMap::AliTOFDigitMap(const AliTOFDigitMap & digitMap):
  73   TObject(digitMap),
  74   fNSector(digitMap.fNSector),
  75   fNplate(digitMap.fNplate),
  76   fNstrip(digitMap.fNstrip),
  77   fNpx(digitMap.fNpx),
  78   fNpz(digitMap.fNpz),
  79   fMaxIndex(-1),
  80   fDigitMap(0x0)
  81 {
  82 //
  83 // dummy copy constructor
  84 //
  85
  86   fMaxIndex=fNSector*fNplate*fNstrip*fNpx*fNpz;
  87   fDigitMap = new Int_t*[fMaxIndex];
  88   for (Int_t i=0; i<fMaxIndex; i++) fDigitMap[i] = new Int_t[kMaxDigitsPerPad];
  89   for (Int_t i=0; i<fMaxIndex; i++)
  90     for (Int_t j=0; j<kMaxDigitsPerPad; j++)
  91       fDigitMap[i][j]=digitMap.fDigitMap[i][j];
  92
  93 }
  94
  95 ////////////////////////////////////////////////////////////////////////
  96 AliTOFDigitMap & AliTOFDigitMap::operator=(const AliTOFDigitMap & digitMap)
  97 {
  98 //
  99 // dummy copy const
 100 //
 101
 102   if (this == &digitMap) return *this;
 103   fNSector=digitMap.fNSector;
 104   fNplate=digitMap.fNplate;
 105   fNstrip=digitMap.fNstrip;
 106   fNpx=digitMap.fNpx;
 107   fNpz=digitMap.fNpz;
 108   fMaxIndex=fNSector*fNplate*fNstrip*fNpx*fNpz;
 109   fDigitMap = new Int_t*[fMaxIndex];
 110   for (Int_t i=0; i<fMaxIndex; i++) fDigitMap[i] = new Int_t[kMaxDigitsPerPad];
 111   for (Int_t i=0; i<fMaxIndex; i++)
 112     for (Int_t j=0; j<kMaxDigitsPerPad; j++)
 113       fDigitMap[i][j]=digitMap.fDigitMap[i][j];
 114
 115 }
 116
 117
 118 ////////////////////////////////////////////////////////////////////////
 119 AliTOFDigitMap::~AliTOFDigitMap()
 120 {
 121 //
 122 // Destructor
 123 //
 124   if (fDigitMap) {
 125     for (Int_t i=0; i<fMaxIndex; i++)  delete[] fDigitMap[i];
 126     delete [] fDigitMap;
 127   }
 128
 129
 130 }
 131
 132 ////////////////////////////////////////////////////////////////////////
 133 void AliTOFDigitMap::Clear(const Option_t*)
 134 {
 135   //
 136   // Clear digitmap
 137   //
 138
 139   for(Int_t ii=0; ii<fMaxIndex; ii++) {
 140     for (Int_t jj=0; jj<kMaxDigitsPerPad; jj++) {
 141       fDigitMap[ii][jj] = 0;
 142     }
 143   }
 144
 145 }
 146
 147 ////////////////////////////////////////////////////////////////////////
 148 Int_t AliTOFDigitMap::CheckedIndex(Int_t * const vol) const
 149 {
 150   //
 151   // Return checked index for vol
 152   //
 153
 154   Int_t index =
 155     vol[0]*fNplate*fNstrip*fNpx*fNpz+             // sector
 156     vol[1]*fNstrip*fNpx*fNpz+                     // plate
 157     vol[2]*fNpx*fNpz+                             // strip
 158     vol[3]*fNpz+                                  // padx
 159     vol[4];                                       // padz
 160
 161     if (index >= fMaxIndex || index < 0) {
 162       AliError("CheckedIndex - input outside bounds");
 163       return -1;
 164     } else {
 165       return index;
 166     }
 167 }
 168
 169 ////////////////////////////////////////////////////////////////////////
 170 void AliTOFDigitMap::AddDigit(Int_t *vol, Int_t idigit)
 171 {
 172   //
 173   // Assign digit to pad vol
 174   //
 175   // 0 means empty pad, we need to shift indeces by 1
 176
 177   if (fDigitMap[CheckedIndex(vol)][kMaxDigitsPerPad-1]!=0) {
 178     AliDebug(1,Form("In the volume (Se%i, Pl%i, St%i, PadR%i, Pad%i) there is not more possibility to add other digits.", vol[0], vol[1], vol[2], vol[4], vol[3]));
 179     AliDebug(1,Form("Then, the digit number %i will be not inserted in the digit map, i.e. it will be lost.", idigit));
 180     AliDebug(1,Form("Please, check the possibility to increase the digit map size (succently set to %i)", kMaxDigitsPerPad));
 181     return;
 182   }
 183
 184   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++) {
 185
 186     if (fDigitMap[CheckedIndex(vol)][slot]==0) {
 187       fDigitMap[CheckedIndex(vol)][slot]=idigit+1;
 188       break;
 189     }
 190     //else continue;
 191
 192   }
 193
 194 }
 195
 196 ////////////////////////////////////////////////////////////////////////
 197 void AliTOFDigitMap::GetDigitIndex(Int_t *vol, Int_t *digitLabels) const
 198 {
 199   //
 200   // Get all contents (digitLabels) of pad volume (vol)
 201   //
 202
 203   // 0 means empty pad, we need to shift indeces by 1
 204
 205   Int_t dummy;
 206     for (Int_t j=0; j<kMaxDigitsPerPad; j++) {
 207       dummy = GetDigitIndex(vol,j);
 208       if (dummy>=0) digitLabels[j] = dummy;
 209       else break;
 210     }
 211 }
 212
 213 ////////////////////////////////////////////////////////////////////////
 214 Int_t AliTOFDigitMap::GetDigitIndex(Int_t *vol, Int_t label) const
 215 {
 216   //
 217   // Get one of the contents (label) of pad volume (vol)
 218   //
 219
 220   // 0 means empty pad, we need to shift indeces by 1
 221
 222   if (!(label<kMaxDigitsPerPad)) {
 223     AliWarning(Form("label (=%i) >= kMaxDigitsPerPad (=%i)", label, kMaxDigitsPerPad));
 224     return -1;
 225   }
 226
 227   Int_t ci = CheckedIndex(vol);
 228   if (ci==-1) return -1;
 229
 230   Int_t dummy = fDigitMap[ci][label];
 231
 232   if (dummy>0) return dummy-1;
 233   else return -1;
 234
 235 }
 236
 237 ////////////////////////////////////////////////////////////////////////
 238 FlagType AliTOFDigitMap::TestDigit(Int_t *vol) const
 239 {
 240 //
 241 // Check if hit cell is empty, used or unused
 242 //
 243   Int_t inf=fDigitMap[CheckedIndex(vol)][0]; // to be modified
 244     if (inf > 0) {
 245         return kUsed;
 246     } else if (inf == 0) {
 247         return kEmpty;
 248     } else {
 249         return kUnused;
 250     }
 251 }
 252
 253 ////////////////////////////////////////////////////////////////////////
 254 Int_t AliTOFDigitMap::GetFilledCellNumber() const
 255 {
 256   //
 257   // Returns the number of filled cells of the TOF digit map
 258   //
 259
 260   Int_t counter = 0;
 261
 262   for (Int_t index = 0; index < fMaxIndex; ++index)
 263   {
 264     for (Int_t label = 0; label < kMaxDigitsPerPad; ++label)
 265     {
 266       if (fDigitMap[index][label] > 0)
 267       {
 268         ++counter;
 269         break;
 270       }
 271     }
 272   }
 273
 274   return counter;
 275 }
 276
 277 ////////////////////////////////////////////////////////////////////////
 278 Bool_t AliTOFDigitMap::StripDigitCheck(Int_t iSector, Int_t iPlate, Int_t iStrip) const
 279 {
 280   //
 281   // Returns:
 282   //           kFALSE if the strip doesn't contain digits
 283   //           kTRUE  if the strip contains at least one digit
 284   //
 285
 286   Int_t volume[5] = {iSector, iPlate, iStrip, -1, -1};
 287   Bool_t counter = kFALSE;
 288
 289   for (Int_t iPadX=0; iPadX<fNpx; iPadX++)
 290     for (Int_t iPadZ=0; iPadZ<fNpz; iPadZ++)
 291       {
 292         volume[3] = iPadX;
 293         volume[4] = iPadZ;
 294         for (Int_t label=0; label<kMaxDigitsPerPad; label++) {
 295           if (GetDigitIndex(volume, label)>=0) {
 296             counter = kTRUE;
 297             break;
 298           }
 299         }
 300       }
 301
 302   return counter;
 303
 304 }
 305
 306 ////////////////////////////////////////////////////////////////////////
 307 Int_t AliTOFDigitMap::DigitInStrip(Int_t iSector, Int_t iPlate, Int_t iStrip) const
 308 {
 309   //
 310   // Returns number of digits in the strip iStrip,
 311   //         in the plate iPlate of the sector iSector
 312   //
 313
 314   Int_t volume[5] = {iSector, iPlate, iStrip, -1, -1};
 315   Int_t counter = 0;
 316
 317   for (Int_t iPadX=0; iPadX<fNpx; iPadX++)
 318     for (Int_t iPadZ=0; iPadZ<fNpz; iPadZ++)
 319       for (Int_t label=0; label<kMaxDigitsPerPad; label++) {
 320         volume[3] = iPadX;
 321         volume[4] = iPadZ;
 322         if (GetDigitIndex(volume, label)>=0)
 323           counter++;
 324       }
 325
 326   return counter;
 327
 328 }
 329
 330 ////////////////////////////////////////////////////////////////////////
 331 Int_t AliTOFDigitMap::FilledCellsInStrip(Int_t iSector, Int_t iPlate, Int_t iStrip) const
 332 {
 333   //
 334   // Returns number of digits in the strip iStrip,
 335   //         in the plate iPlate of the sector iSector
 336   //
 337
 338   Int_t volume[5] = {iSector, iPlate, iStrip, -1, -1};
 339   Int_t counter = 0;
 340
 341   for (Int_t iPadX=0; iPadX<fNpx; iPadX++)
 342     for (Int_t iPadZ=0; iPadZ<fNpz; iPadZ++) {
 343       volume[3] = iPadX;
 344       volume[4] = iPadZ;
 345       if (GetDigitIndex(volume, 0)>=0)
 346         counter++;
 347     }
 348
 349   return counter;
 350
 351 }
 352
 353 ////////////////////////////////////////////////////////////////////////
 354 void AliTOFDigitMap::ResetDigitNumber(Int_t *vol, Int_t dig)
 355 {
 356   //
 357   // Reset digit into pad vol
 358   //
 359
 360   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++) {
 361     if (fDigitMap[CheckedIndex(vol)][slot]-1==dig) {
 362       fDigitMap[CheckedIndex(vol)][slot] = 0;
 363     }
 364   }
 365
 366 }
 367
 368 ////////////////////////////////////////////////////////////////////////
 369 void AliTOFDigitMap::ResetDigit(Int_t *vol, Int_t dig)
 370 {
 371   //
 372   // Reset digit into pad vol
 373   //
 374   // 0 means empty pad, we need to shift indeces by 1
 375
 376   fDigitMap[CheckedIndex(vol)][dig] = 0;
 377
 378 }
 379
 380 ////////////////////////////////////////////////////////////////////////
 381 void AliTOFDigitMap::ResetDigit(Int_t *vol)
 382 {
 383   //
 384   // Reset digit into pad vol
 385   //
 386   // 0 means empty pad, we need to shift indices by 1
 387
 388   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++)
 389     fDigitMap[CheckedIndex(vol)][slot] = 0;
 390
 391 }
 392
 393 ////////////////////////////////////////////////////////////////////////
 394 Int_t AliTOFDigitMap::GetNumberOfDigits(Int_t *vol)
 395 {
 396   //
 397   // Returns the number of digit
 398   //   into pad volume vol
 399   //
 400   // 0 means empty pad
 401   //
 402
 403   Int_t counter = 0;
 404
 405   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++)
 406     if (GetDigitIndex(vol, slot)>=0) counter++;
 407
 408   return counter;
 409
 410 }