ITS/AliITSCalibrationSPD.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 #include "AliITSCalibrationSPD.h"
  17 ///////////////////////////////////////////////////////////////////////////
  18 //  Calibration class for set:ITS
  19 //  Specific subdetector implementation for
  20 //  Silicon pixels
  21 //
  22 //  Modified by D. Elia, G.E. Bruno, H. Tydesjo
  23 ///////////////////////////////////////////////////////////////////////////
  24
  25 ClassImp(AliITSCalibrationSPD)
  26
  27 //______________________________________________________________________
  28 AliITSCalibrationSPD::AliITSCalibrationSPD():
  29 AliITSCalibration(),
  30 fNrBad(0),
  31 fBadChannels(0){
  32   // constructor
  33
  34    SetDataType("simulated");
  35    ClearBad();
  36 }
  37 //____________________________________________________________________________
  38 void AliITSCalibrationSPD::ClearBad() {
  39   // clear all bad pixels (single+chips)
  40   fBadChannels.Reset();
  41   fNrBad=0;
  42   for (UInt_t chip=0; chip<5; chip++) {
  43     fBadChip[chip]=kFALSE;
  44   }
  45 }
  46 //____________________________________________________________________________
  47 void AliITSCalibrationSPD::AddBad(UInt_t col, UInt_t row) {
  48   // add single bad pixel
  49   fBadChannels.Set(fNrBad*2+2);
  50   fBadChannels.AddAt(col,fNrBad*2);
  51   fBadChannels.AddAt(row,fNrBad*2+1);
  52   fNrBad++;
  53 }
  54 //____________________________________________________________________________
  55 void AliITSCalibrationSPD::SetChipBad(UInt_t chip) {
  56   // set full chip bad
  57   if (chip>=5) {AliError("Wrong chip number");}
  58   fBadChip[chip]=kTRUE;
  59 }
  60 //____________________________________________________________________________
  61 void AliITSCalibrationSPD::UnSetChipBad(UInt_t chip) {
  62   // unset full chip bad
  63   if (chip>=5) {AliError("Wrong chip number");}
  64   fBadChip[chip]=kFALSE;
  65 }
  66 //____________________________________________________________________________
  67 Int_t AliITSCalibrationSPD::GetBadColAt(UInt_t index) const {
  68   // Get column of index-th bad pixel
  69   if ((Int_t)index<GetNrBadSingle()) {
  70     return fBadChannels.At(index*2);
  71   }
  72   else {
  73     Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
  74     Int_t badChipsFound =0;
  75     for (UInt_t chip=0; chip<5; chip++) {
  76       if (fBadChip[chip]) badChipsFound++;
  77       if (badChipIndex==badChipsFound-1) {
  78         Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
  79         return chip*32 + badPixelIndex/256;
  80       }
  81     }
  82   }
  83   AliError(Form("Index %d is out of bounds - returning -1",index));
  84   return -1;
  85 }
  86 //____________________________________________________________________________
  87 Int_t AliITSCalibrationSPD::GetBadRowAt(UInt_t index) const {
  88   // Get row of index-th bad pixel
  89   if ((Int_t)index<GetNrBadSingle()) {
  90     return fBadChannels.At(index*2+1);
  91   }
  92   else {
  93     Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
  94     Int_t badChipsFound =0;
  95     for (UInt_t chip=0; chip<5; chip++) {
  96       if (fBadChip[chip]) badChipsFound++;
  97       if (badChipIndex==badChipsFound-1) {
  98         Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
  99         return badPixelIndex%256;
 100       }
 101     }
 102   }
 103   AliError(Form("Index %d is out of bounds - returning -1",index));
 104   return -1;
 105 }
 106 //____________________________________________________________________________
 107 void AliITSCalibrationSPD::GetBadPixel(Int_t index, Int_t &row, Int_t &col) const {
 108   // i: is the i-th bad pixel in single bad pixel list
 109   // row: is the corresponding row (-1 if i is out of range)
 110   // col: is the corresponding column (-1 if i is out of range)
 111   row = -1;
 112   col = -1;
 113   if(index>=0 && index<GetNrBadSingle()){
 114     col = GetBadColAt(index);
 115     row = GetBadRowAt(index);
 116     return;
 117   }
 118   else {
 119     if (index>=0) {
 120       Int_t badChipIndex=(index-GetNrBadSingle())/(32*256);
 121       Int_t badChipsFound =0;
 122       for (UInt_t chip=0; chip<5; chip++) {
 123         if (fBadChip[chip]) badChipsFound++;
 124         if (badChipIndex==badChipsFound-1) {
 125           Int_t badPixelIndex=(index-GetNrBadSingle())%(32*256);
 126           col = chip*32 + badPixelIndex/256;
 127           row = badPixelIndex%256;
 128           return;
 129         }
 130       }
 131     }
 132   }
 133   AliError(Form("Index %d is out of bounds - nothing done",index));
 134 }
 135 //___________________________________________________________________________
 136 Int_t  AliITSCalibrationSPD::GetNrBad() const {
 137   // Total number of bad pixels (including bad chips) in a given module
 138   Int_t bad=0;
 139   // single pixels:
 140   bad+=fNrBad;
 141   // whole chips:
 142   for (UInt_t chip=0; chip<5; chip++) {
 143     bad+=fBadChip[chip]*32*256;
 144   }
 145   return bad;
 146 }
 147 //___________________________________________________________________________
 148 Int_t  AliITSCalibrationSPD::GetNrBadInChip(Int_t chip) const {
 149   // Total number of bad pixels (including bad chips) in a given chip: chip range [0,4]
 150   if(chip<0 || chip>4) {AliError("Wrong chip number"); return -1;}
 151   if (fBadChip[chip]) return 32*256;
 152   else {
 153     Int_t bad=0;
 154     for (UInt_t i=0; i<fNrBad; i++) {
 155       Int_t col = GetBadColAt(i);
 156       if (col!=-1) {
 157         if (GetChipIndexFromCol(col)==chip) bad++;
 158       }
 159     }
 160     return bad;
 161   }
 162 }
 163 //___________________________________________________________________________
 164 Int_t  AliITSCalibrationSPD::GetNrBadInColumn(Int_t col) const {
 165   // Total number of bad pixels (including bad chips) in a given column: col. range [0,159]
 166   if(col<0 || col>159) {AliError("Wrong column number"); return -1;}
 167   if (fBadChip[GetChipIndexFromCol(col)]) return 256;
 168   else {
 169     Int_t bad=0;
 170     for (UInt_t i=0; i<fNrBad; i++) {
 171       if (GetBadColAt(i)==col) bad++;
 172     }
 173     return bad;
 174   }
 175 }
 176 //______________________________________________________________________
 177 Bool_t AliITSCalibrationSPD::IsBad() const {
 178   // Are all chips of this module bad?
 179   for (UInt_t chip=0; chip<5; chip++) {
 180     if (!fBadChip[chip]) return kFALSE;
 181   }
 182   return kTRUE;
 183 }
 184 //______________________________________________________________________
 185 Bool_t AliITSCalibrationSPD::IsChipBad(Int_t chip) const {
 186   // Is the full chip bad?
 187   return (GetNrBadInChip(chip)==32*256);
 188 }
 189 //______________________________________________________________________
 190 Bool_t AliITSCalibrationSPD::IsColumnBad(Int_t col) const {
 191   // Is the full column bad?
 192   return (GetNrBadInColumn(col)==256);
 193 }
 194 //____________________________________________________________________________
 195 Bool_t AliITSCalibrationSPD::IsPixelBad(Int_t col, Int_t row) const {
 196   // Is this pixel bad?
 197   if(col<0 || col>159) {AliError("Wrong column number"); return kFALSE;}
 198   Int_t chip = GetChipIndexFromCol(col);
 199   if (fBadChip[chip]) return kTRUE;
 200   for (UInt_t i=0; i<fNrBad; i++) {
 201     if (GetBadColAt(i)==col && GetBadRowAt(i)==row) {
 202       return kTRUE;
 203     }
 204   }
 205   return kFALSE;
 206 }
 207 //______________________________________________________________________
 208 Int_t AliITSCalibrationSPD::GetChipIndexFromCol(UInt_t col) const {
 209   // returns chip index for specific column
 210   if(col>=160) {AliWarning("Wrong column number"); return -1;}
 211   return col/32;
 212 }
 213 //______________________________________________________________________
 214 void AliITSCalibrationSPD::SetNrBad(UInt_t /*nr*/) {
 215   // should not be used anymore !!!
 216   AliError("This method should not be used anymore. Use SetNrBadSingle instead!!!");
 217 }
 218 //______________________________________________________________________
 219 void AliITSCalibrationSPD::Streamer(TBuffer &R__b) {
 220   // Stream an object of class AliITSCalibrationSPD.
 221   UInt_t R__s, R__c;
 222   if (R__b.IsReading()) {
 223     Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
 224     AliITSCalibration::Streamer(R__b);
 225     if (R__v >= 8) {
 226       R__b >> fNrBad;
 227       fBadChannels.Streamer(R__b);
 228       R__b.ReadStaticArray((bool*)fBadChip);
 229     }
 230     else {
 231       Double_t dummy;
 232       R__b >> dummy;
 233       R__b >> dummy;
 234       R__b >> dummy;
 235       R__b >> dummy;
 236       R__b >> dummy;
 237       R__b >> dummy;
 238       R__b >> dummy;
 239       R__b >> fNrBad;
 240       if (R__v == 7) {
 241         fBadChannels.Streamer(R__b);
 242         R__b.ReadStaticArray((bool*)fBadChip);
 243       }
 244       else {
 245         if (R__v == 6) {
 246           fBadChannels.Streamer(R__b);
 247         }
 248         else {
 249           TArrayI fBadChannelsV1;
 250           fBadChannelsV1.Streamer(R__b);
 251           fBadChannels.Set(fNrBad*2);
 252           for (UInt_t i=0; i<fNrBad*2; i++) {
 253             fBadChannels[i] = fBadChannelsV1[i];
 254           }
 255         }
 256         for (UInt_t i=0; i<5; i++) {
 257           fBadChip[i]=kFALSE;
 258         }
 259       }
 260     }
 261     R__b.CheckByteCount(R__s, R__c, AliITSCalibrationSPD::IsA());
 262   }
 263   else {
 264     R__c = R__b.WriteVersion(AliITSCalibrationSPD::IsA(), kTRUE);
 265     AliITSCalibration::Streamer(R__b);
 266     R__b << fNrBad;
 267     fBadChannels.Streamer(R__b);
 268     R__b.WriteArray(fBadChip, 5);
 269     R__b.SetByteCount(R__c, kTRUE);
 270   }
 271 }