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(digitMap.fMaxIndex),
  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
  89   for (Int_t i=0; i<fMaxIndex; i++) fDigitMap[i] = new Int_t[kMaxDigitsPerPad];
  90 }
  91
  92 ////////////////////////////////////////////////////////////////////////
  93 AliTOFDigitMap &
  94 AliTOFDigitMap::operator=(const AliTOFDigitMap & /*digitMap*/)
  95 {
  96 //
  97 // dummy copy const
  98 //
  99     return *this;
 100 }
 101
 102
 103 ////////////////////////////////////////////////////////////////////////
 104 AliTOFDigitMap::~AliTOFDigitMap()
 105 {
 106 //
 107 // Destructor
 108 //
 109   if (fDigitMap) {
 110     for (Int_t i=0; i<fMaxIndex; i++)  delete[] fDigitMap[i];
 111   }
 112
 113
 114 }
 115
 116 ////////////////////////////////////////////////////////////////////////
 117 void AliTOFDigitMap::Clear(const Option_t*)
 118 {
 119   //
 120   // Clear digitmap
 121   //
 122
 123   for(Int_t ii=0; ii<fMaxIndex; ii++) {
 124     for (Int_t jj=0; jj<kMaxDigitsPerPad; jj++) {
 125       fDigitMap[ii][jj] = 0;
 126     }
 127   }
 128
 129 }
 130
 131 ////////////////////////////////////////////////////////////////////////
 132 Int_t AliTOFDigitMap::CheckedIndex(Int_t *vol) const
 133 {
 134   //
 135   // Return checked index for vol
 136   //
 137
 138   Int_t index =
 139     vol[0]*fNplate*fNstrip*fNpx*fNpz+             // sector
 140     vol[1]*fNstrip*fNpx*fNpz+                     // plate
 141     vol[2]*fNpx*fNpz+                             // strip
 142     vol[3]*fNpz+                                  // padx
 143     vol[4];                                       // padz
 144
 145     if (index >= fMaxIndex || index < 0) {
 146       AliError("CheckedIndex - input outside bounds");
 147       return -1;
 148     } else {
 149       return index;
 150     }
 151 }
 152
 153 ////////////////////////////////////////////////////////////////////////
 154 void AliTOFDigitMap::AddDigit(Int_t *vol, Int_t idigit)
 155 {
 156   //
 157   // Assign digit to pad vol
 158   //
 159   // 0 means empty pad, we need to shift indeces by 1
 160
 161   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++) {
 162
 163     if (fDigitMap[CheckedIndex(vol)][slot]==0) {
 164       fDigitMap[CheckedIndex(vol)][slot]=idigit+1;
 165       break;
 166     }
 167     //else continue;
 168
 169   }
 170 }
 171
 172 ////////////////////////////////////////////////////////////////////////
 173 void AliTOFDigitMap::GetDigitIndex(Int_t *vol, Int_t *digitLabels) const
 174 {
 175   //
 176   // Get all contents (digitLabels) of pad volume (vol)
 177   //
 178
 179   // 0 means empty pad, we need to shift indeces by 1
 180
 181   Int_t dummy;
 182     for (Int_t j=0; j<kMaxDigitsPerPad; j++) {
 183       dummy = GetDigitIndex(vol,j);
 184       if (dummy>=0) digitLabels[j] = dummy;
 185       else break;
 186     }
 187 }
 188
 189 ////////////////////////////////////////////////////////////////////////
 190 Int_t AliTOFDigitMap::GetDigitIndex(Int_t *vol, Int_t label) const
 191 {
 192   //
 193   // Get one of the contents (label) of pad volume (vol)
 194   //
 195
 196   // 0 means empty pad, we need to shift indeces by 1
 197
 198   if (!(label<kMaxDigitsPerPad)) {
 199     AliWarning(Form("label (=%i) >= kMaxDigitsPerPad (=%i)", label, kMaxDigitsPerPad));
 200     return -1;
 201   }
 202
 203   if (CheckedIndex(vol)==-1) return -1;
 204
 205   Int_t dummy = fDigitMap[CheckedIndex(vol)][label];
 206
 207   if (dummy>0) return dummy-1;
 208   else return -1;
 209
 210 }
 211
 212 ////////////////////////////////////////////////////////////////////////
 213 FlagType AliTOFDigitMap::TestDigit(Int_t *vol) const
 214 {
 215 //
 216 // Check if hit cell is empty, used or unused
 217 //
 218   Int_t inf=fDigitMap[CheckedIndex(vol)][0]; // to be modified
 219     if (inf > 0) {
 220         return kUsed;
 221     } else if (inf == 0) {
 222         return kEmpty;
 223     } else {
 224         return kUnused;
 225     }
 226 }
 227
 228 ////////////////////////////////////////////////////////////////////////
 229 Int_t AliTOFDigitMap::GetFilledCellNumber() const
 230 {
 231   //
 232   // Returns the number of filled cells of the TOF digit map
 233   //
 234
 235   Int_t volume[5] = {-1, -1, -1, -1, -1};
 236   Int_t counter = 0;
 237
 238   for (Int_t iSector=0; iSector<fNSector; iSector++)
 239     for (Int_t iPlate=0; iPlate<fNplate; iPlate++)
 240       for (Int_t iStrip=0; iStrip<fNstrip; iStrip++)
 241         for (Int_t iPadX=0; iPadX<fNpx; iPadX++)
 242           for (Int_t iPadZ=0; iPadZ<fNpz; iPadZ++)
 243             {
 244
 245               volume[0] = iSector;
 246               volume[1] = iPlate;
 247               volume[2] = iStrip;
 248               volume[3] = iPadX;
 249               volume[4] = iPadZ;
 250
 251               //if (CheckedIndex(volume)!=-1) counter++;
 252               if (GetDigitIndex(volume, 0)>0) counter++;
 253             }
 254
 255   return counter;
 256
 257 }
 258
 259 ////////////////////////////////////////////////////////////////////////
 260 Bool_t AliTOFDigitMap::StripDigitCheck(Int_t iSector, Int_t iPlate, Int_t iStrip) const
 261 {
 262   //
 263   // Returns:
 264   //           kFALSE if the strip doesn't contain digits
 265   //           kTRUE  if the strip contains at least one digit
 266   //
 267
 268   Int_t volume[5] = {iSector, iPlate, iStrip, -1, -1};
 269   Bool_t counter = kFALSE;
 270
 271   for (Int_t iPadX=0; iPadX<fNpx; iPadX++)
 272     for (Int_t iPadZ=0; iPadZ<fNpz; iPadZ++)
 273       {
 274         volume[3] = iPadX;
 275         volume[4] = iPadZ;
 276         if (GetDigitIndex(volume, 0)>=0) {
 277           counter = kTRUE;
 278           break;
 279         }
 280       }
 281
 282   return counter;
 283
 284 }
 285
 286 ////////////////////////////////////////////////////////////////////////
 287 Int_t AliTOFDigitMap::DigitInStrip(Int_t iSector, Int_t iPlate, Int_t iStrip) const
 288 {
 289   //
 290   // Returns:
 291   //
 292
 293   Int_t volume[5] = {iSector, iPlate, iStrip, -1, -1};
 294   Int_t counter = 0;
 295
 296   for (Int_t iPadX=0; iPadX<fNpx; iPadX++)
 297     for (Int_t iPadZ=0; iPadZ<fNpz; iPadZ++)
 298       for (Int_t label=0; label<kMaxDigitsPerPad; label++) {
 299         volume[3] = iPadX;
 300         volume[4] = iPadZ;
 301         if (GetDigitIndex(volume, label)<0) continue;
 302         counter++;
 303       }
 304
 305   return counter;
 306
 307 }
 308
 309 ////////////////////////////////////////////////////////////////////////
 310 void AliTOFDigitMap::ResetDigitNumber(Int_t *vol, Int_t dig)
 311 {
 312   //
 313   // Reset digit into pad vol
 314   //
 315
 316   Int_t dummy = -1;
 317
 318   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++) {
 319     if (fDigitMap[CheckedIndex(vol)][slot]-1==dig) {
 320       fDigitMap[CheckedIndex(vol)][slot] = 0;
 321       dummy = slot;
 322     }
 323   }
 324   /*
 325   if (dummy<kMaxDigitsPerPad-1) {
 326     for (Int_t ii=dummy; ii<kMaxDigitsPerPad-1; ii++) {
 327       fDigitMap[CheckedIndex(vol)][ii] =
 328         fDigitMap[CheckedIndex(vol)][ii+1];
 329     }
 330   }
 331   */
 332 }
 333
 334 ////////////////////////////////////////////////////////////////////////
 335 void AliTOFDigitMap::ResetDigit(Int_t *vol, Int_t dig)
 336 {
 337   //
 338   // Reset digit into pad vol
 339   //
 340   // 0 means empty pad, we need to shift indeces by 1
 341
 342   //for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++) {
 343   //if (fDigitMap[CheckedIndex(vol)][slot]==dig)
 344   //fDigitMap[CheckedIndex(vol)][slot] = 0;
 345   //}
 346
 347
 348   fDigitMap[CheckedIndex(vol)][dig] = 0;
 349   /*
 350   if (dig<kMaxDigitsPerPad-1) {
 351     for (Int_t ii=dig; ii<kMaxDigitsPerPad-1; ii++) {
 352       fDigitMap[CheckedIndex(vol)][ii] =
 353         fDigitMap[CheckedIndex(vol)][ii+1];
 354     }
 355   }
 356   */
 357 }
 358
 359 void AliTOFDigitMap::ResetDigit(Int_t *vol)
 360 {
 361   //
 362   // Reset digit into pad vol
 363   //
 364   // 0 means empty pad, we need to shift indices by 1
 365
 366   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++)
 367     fDigitMap[CheckedIndex(vol)][slot] = 0;
 368
 369 }
 370
 371 Int_t AliTOFDigitMap::GetNumberOfDigits(Int_t *vol)
 372 {
 373   //
 374   // Returns the number of digit
 375   //   into pad volume vol
 376   //
 377   // 0 means empty pad
 378   //
 379
 380   Int_t counter = 0;
 381
 382   for (Int_t slot=0; slot<kMaxDigitsPerPad; slot++)
 383     if (GetDigitIndex(vol, slot)!=-1) counter++;
 384
 385   return counter;
 386
 387 }