ITS/UPGRADE/AliITSUCalibrationPix.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 #include "TArrayI.h"
  16 #include "AliITSUCalibrationPix.h"
  17
  18 ///////////////////////////////////////////////////////////////////////////
  19 //
  20 //  Calibration class for set:ITS
  21 //  Specific subdetector implementation for
  22 //  Silicon pixels
  23 //
  24 //  Modified by D. Elia, G.E. Bruno, H. Tydesjo
  25 //  Adapted for upgrade ruben.shahoyan@cern.ch
  26 //
  27 ///////////////////////////////////////////////////////////////////////////
  28
  29 ClassImp(AliITSUCalibrationPix)
  30
  31 //______________________________________________________________________
  32 AliITSUCalibrationPix::AliITSUCalibrationPix()
  33 : fNChips(0)
  34   ,fNColPerChip(0)
  35   ,fNCol(0)
  36   ,fNRow(0)
  37   ,fNrBadSingle(0)
  38   ,fBadChips(0)
  39   ,fBadChannels(0)
  40 {
  41   // constructor
  42    SetDataType("simulated");
  43    ClearBad();
  44 }
  45
  46 //______________________________________________________________________
  47 AliITSUCalibrationPix::AliITSUCalibrationPix(Short_t nChips,Short_t nColPerChip,Short_t nRow)
  48 : fNChips(0)
  49   ,fNColPerChip(0)
  50   ,fNCol(0)
  51   ,fNRow(0)
  52   ,fNrBadSingle(0)
  53   ,fBadChips(0)
  54   ,fBadChannels(0)
  55 {
  56   // constructor
  57    SetDataType("simulated");
  58    SetColRowData(nChips,nColPerChip,nRow);
  59    ClearBad();
  60 }
  61
  62 //______________________________________________________________________
  63 AliITSUCalibrationPix::AliITSUCalibrationPix(const AliITSUCalibrationPix &src) :
  64   AliITSCalibration(src)
  65   ,fNChips(src.fNChips)
  66   ,fNColPerChip(src.fNColPerChip)
  67   ,fNCol(src.fNCol)
  68   ,fNRow(src.fNRow)
  69   ,fNrBadSingle(src.fNrBadSingle)
  70   ,fBadChips(src.fBadChips)
  71   ,fBadChannels(src.fBadChannels)
  72 {
  73 }
  74
  75 //____________________________________________________________________________
  76 void AliITSUCalibrationPix::ClearBad()
  77 {
  78   // clear all bad pixels (single+chips)
  79   fBadChannels.Reset();
  80   fNrBadSingle=0;
  81   fBadChips = 0;
  82   //
  83 }
  84
  85 //____________________________________________________________________________
  86 void AliITSUCalibrationPix::AddBad(Int_t col, Int_t row)
  87 {
  88   // add single bad pixel
  89   fBadChannels.Set(fNrBadSingle*2+2);
  90   fBadChannels.AddAt(col,fNrBadSingle*2);
  91   fBadChannels.AddAt(row,fNrBadSingle*2+1);
  92   fNrBadSingle++;
  93 }
  94
  95 //____________________________________________________________________________
  96 void AliITSUCalibrationPix::SetChipBad(Int_t chip)
  97 {
  98   // set full chip bad
  99   if ((int)chip>=fNChips) {AliError(Form("chip number %d exceeds allowed limit %d",chip,fNChips)); return;}
 100   fBadChips |= 0x1<<chip;
 101   //
 102 }
 103
 104 //____________________________________________________________________________
 105 void AliITSUCalibrationPix::UnSetChipBad(Int_t chip)
 106 {
 107   // unset full chip bad
 108   if (chip>=fNChips) {AliError(Form("chip number %d exceeds allowed limit %d",chip,fNChips)); return;}
 109   fBadChips &= ~(0x1<<chip);
 110   //
 111 }
 112
 113 //____________________________________________________________________________
 114 Int_t AliITSUCalibrationPix::GetBadColAt(Int_t index) const
 115 {
 116   // Get column of index-th bad pixel
 117   int nrc = fNColPerChip*fNRow;
 118   if (nrc<1) AliFatal("Number of colums and rows is not set");
 119   //
 120   if ((Int_t)index<GetNrBadSingle()) return fBadChannels.At(index*2);
 121   else {
 122     Int_t badChipIndex=(index-GetNrBadSingle())/nrc;
 123     Int_t badChipsFound =0;
 124     for (int chip=fNChips; chip--;) {
 125       if (IsChipMarkedBad(chip)) badChipsFound++;
 126       if (badChipIndex==badChipsFound-1) {
 127         Int_t badPixelIndex=(index-GetNrBadSingle())%(nrc);
 128         return chip*fNColPerChip + badPixelIndex/fNRow;
 129       }
 130     }
 131   }
 132   AliError(Form("Index %d is out of bounds - returning -1",index));
 133   return -1;
 134 }
 135
 136 //____________________________________________________________________________
 137 Int_t AliITSUCalibrationPix::GetBadRowAt(Int_t index) const
 138 {
 139   // Get row of index-th bad pixel
 140   int nrc = fNColPerChip*fNRow;
 141   if (nrc<1) AliFatal("Number of colums and rows is not set");
 142   //
 143   if ((Int_t)index<GetNrBadSingle()) return fBadChannels.At(index*2+1);
 144   else {
 145     Int_t badChipIndex=(index-GetNrBadSingle())/nrc;
 146     Int_t badChipsFound =0;
 147     for (int chip=fNChips; chip--;) {
 148       if (IsChipMarkedBad(chip)) badChipsFound++;
 149       if (badChipIndex==badChipsFound-1) {
 150         Int_t badPixelIndex=(index-GetNrBadSingle())%nrc;
 151         return badPixelIndex%fNRow;
 152       }
 153     }
 154   }
 155   AliError(Form("Index %d is out of bounds - returning -1",index));
 156   return -1;
 157 }
 158
 159 //____________________________________________________________________________
 160 void AliITSUCalibrationPix::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const
 161 {
 162   // i: is the i-th bad pixel in single bad pixel list
 163   // row: is the corresponding row (-1 if i is out of range)
 164   // col: is the corresponding column (-1 if i is out of range)
 165   row = -1;
 166   col = -1;
 167   if(index>=0 && index<GetNrBadSingle()){
 168     col = GetBadColAt(index);
 169     row = GetBadRowAt(index);
 170     return;
 171   }
 172   else {
 173     if (index>=0) {
 174       int nrc = fNColPerChip*fNRow;
 175       if (nrc<1) AliFatal("Number of colums and rows is not set");
 176       Int_t badChipIndex=(index-GetNrBadSingle())/nrc;
 177       Int_t badChipsFound =0;
 178       for (int chip=fNChips; chip--;) {
 179         if (IsChipMarkedBad(chip)) badChipsFound++;
 180         if (badChipIndex==badChipsFound-1) {
 181           Int_t badPixelIndex=(index-GetNrBadSingle())%nrc;
 182           col = chip*fNColPerChip + badPixelIndex/fNRow;
 183           row = badPixelIndex%fNRow;
 184           return;
 185         }
 186       }
 187     }
 188   }
 189   AliError(Form("Index %d is out of bounds - nothing done",index));
 190 }
 191
 192 //____________________________________________________________________________
 193 void AliITSUCalibrationPix::GetBadPixelSingle(Int_t index, UInt_t &row, UInt_t &col) const
 194 {
 195   // i: is the i-th bad pixel in single bad pixel list
 196   // row: is the corresponding row (-1 if i is out of range)
 197   // col: is the corresponding column (-1 if i is out of range)
 198   if(index<0 && index>=GetNrBadSingle())  AliFatal(Form("Index %d >= NrBadSingle=%d",index,fNrBadSingle));
 199   col = fBadChannels.At(index*2);
 200   row = fBadChannels.At(index*2+1);
 201 }
 202
 203 //___________________________________________________________________________
 204 Int_t  AliITSUCalibrationPix::GetNrBad() const
 205 {
 206   // Total number of bad pixels (including bad chips) in a given module
 207   Int_t bad=0;
 208   // single pixels:
 209   bad += fNrBadSingle;
 210   // whole chips:
 211   for (int chip=fNChips; chip--;) if (IsChipMarkedBad(chip)) bad += fNColPerChip*fNRow;
 212   return bad;
 213 }
 214
 215 //___________________________________________________________________________
 216 Int_t  AliITSUCalibrationPix::GetNrBadInChip(Int_t chip) const
 217 {
 218   // Total number of bad pixels (including bad chips) in a given chip
 219   if(chip<0 || chip>=fNChips) {AliError("Wrong chip number"); return -1;}
 220   if (IsChipMarkedBad(chip)) return fNColPerChip*fNRow;
 221   else {
 222     Int_t bad=0;
 223     for (int i=fNrBadSingle; i--;) {
 224       Int_t col = GetBadColAt(i);
 225       if (col!=-1) if (GetChipIndexFromCol(col)==chip) bad++;
 226     }
 227     return bad;
 228   }
 229 }
 230
 231 //___________________________________________________________________________
 232 Int_t  AliITSUCalibrationPix::GetNrBadInColumn(Int_t col) const
 233 {
 234   // Total number of bad pixels (including bad chips) in a given column: col. range
 235   if(col<0 || col>=fNCol) {AliError("Wrong column number"); return -1;}
 236   if (IsChipMarkedBad(GetChipIndexFromCol(col))) return fNRow;
 237   else {
 238     Int_t bad=0;
 239     for (int i=fNrBadSingle; i--;) if (GetBadColAt(i)==col) bad++;
 240     return bad;
 241   }
 242 }
 243
 244 //______________________________________________________________________
 245 Bool_t AliITSUCalibrationPix::IsBad() const
 246 {
 247   // Are all chips of this module bad?
 248   for (Int_t chip=fNChips; chip--;) if (!IsChipMarkedBad(chip)) return kFALSE;
 249   return kTRUE;
 250 }
 251
 252 //______________________________________________________________________
 253 Bool_t AliITSUCalibrationPix::IsChipBad(Int_t chip) const
 254 {
 255   // Is the full chip bad?
 256   return (GetNrBadInChip(chip)==fNColPerChip*fNRow);
 257 }
 258
 259 //______________________________________________________________________
 260 Bool_t AliITSUCalibrationPix::IsColumnBad(Int_t col) const
 261 {
 262   // Is the full column bad?
 263   return (GetNrBadInColumn(col)==fNRow);
 264 }
 265
 266 //____________________________________________________________________________
 267 Bool_t AliITSUCalibrationPix::IsPixelBad(Int_t col, Int_t row) const
 268 {
 269   // Is this pixel bad?
 270   if(col<0 || col>=fNCol) {AliError("Wrong column number"); return kFALSE;}
 271   Int_t chip = GetChipIndexFromCol(col);
 272   if (IsChipMarkedBad(chip)) return kTRUE;
 273   for (Int_t i=fNrBadSingle; i--;) if (GetBadColAt(i)==col && GetBadRowAt(i)==row) return kTRUE;
 274   return kFALSE;
 275 }
 276
 277 //______________________________________________________________________
 278 Int_t AliITSUCalibrationPix::GetChipIndexFromCol(Int_t col) const
 279 {
 280   // returns chip index for specific column
 281   if(col>=fNCol) {AliWarning("Wrong column number"); return -1;}
 282   return col/fNColPerChip;
 283 }
 284
 285 //______________________________________________________________________
 286 void AliITSUCalibrationPix::SetNrBad(Int_t /*nr*/)
 287 {
 288   // should not be used anymore !!!
 289   AliError("This method should not be used anymore. Use SetNrBadSingle instead!!!");
 290 }
 291
 292 //____________________________________________________________________________
 293 void  AliITSUCalibrationPix::SetColRowData(Short_t nchip, Short_t ncolperchip, Short_t nrow)
 294 {
 295   // set segmentation data
 296   fNChips = nchip;
 297   fNCol   = nchip*ncolperchip;
 298   fNRow   = nrow;
 299   fNColPerChip = ncolperchip;
 300 }