ITS/AliITSChannelStatus.cxx

   1 /**************************************************************************
   2  * Copyright(c) 2007-2009, 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 /* $Id:$ */
  17
  18 //////////////////////////////////////////////////////////////////////////
  19 //                                                                      //
  20 // Implementation of the class for bad channel treatment in the tracker //
  21 // Stores 1 status bit for each SPD pixel and SDD anode:                //
  22 //  0 = bad channel                                                     //
  23 //  1 = good channel                                                    //
  24 // Dead and noisy channels are read from AliITSCalibration objects      //
  25 // Origin: F.Prino, Torino, prino@to.infn.it                            //
  26 //                                                                      //
  27 //////////////////////////////////////////////////////////////////////////
  28
  29 #include "AliITSChannelStatus.h"
  30 #include "AliITSCalibrationSPD.h"
  31 #include "AliITSCalibrationSDD.h"
  32 #include "AliCDBEntry.h"
  33 #include "AliLog.h"
  34
  35 ClassImp(AliITSChannelStatus)
  36
  37
  38 //______________________________________________________________________
  39 AliITSChannelStatus::AliITSChannelStatus():
  40 TObject(),
  41 fSPDChannelStatus(0),
  42 fSDDChannelStatus(0)
  43 {
  44   // default constructor
  45   UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  46   fSPDChannelStatus=new TBits(nSPDchan);
  47   UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  48   fSDDChannelStatus=new TBits(nSDDchan);
  49   InitDefaults();
  50 }
  51 //______________________________________________________________________
  52 AliITSChannelStatus::AliITSChannelStatus(AliCDBManager *cdb):
  53 TObject(),
  54 fSPDChannelStatus(0),
  55 fSDDChannelStatus(0)
  56 {
  57   AliCDBEntry* spdEntryD = cdb->Get("ITS/Calib/SPDDead");
  58   if (!spdEntryD) AliFatal("Cannot get CDB entry for SPDDead");
  59   TObjArray* deadArrSPD = (TObjArray*)spdEntryD->GetObject();
  60   if (!deadArrSPD) AliFatal("No object found in SPDDead file");
  61
  62   AliCDBEntry* spdEntryN = cdb->Get("ITS/Calib/SPDNoisy");
  63   if (!spdEntryN) AliFatal("Cannot get CDB entry for SPDNoisy");
  64   TObjArray* noisArrSPD = (TObjArray*)spdEntryN->GetObject();
  65   if (!noisArrSPD) AliFatal("No object found in SPDNoisy file");
  66
  67   AliCDBEntry* sddEntry = cdb->Get("ITS/Calib/CalibSDD");
  68   if (!sddEntry) AliFatal("Cannot get CDB entry for CalibSDD");
  69   TObjArray* calArrSDD = (TObjArray*)sddEntry->GetObject();
  70   if (!calArrSDD) AliFatal("No object found in CalibSDD file");
  71
  72   UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  73   fSPDChannelStatus=new TBits(nSPDchan);
  74   UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  75   fSDDChannelStatus=new TBits(nSDDchan);
  76   InitFromOCDB(deadArrSPD,noisArrSPD,calArrSDD);
  77 }
  78 //______________________________________________________________________
  79 AliITSChannelStatus::AliITSChannelStatus(AliITSDetTypeRec *dtrec):
  80 TObject(),
  81 fSPDChannelStatus(0),
  82 fSDDChannelStatus(0)
  83 {
  84   UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  85   fSPDChannelStatus=new TBits(nSPDchan);
  86
  87   UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  88   fSDDChannelStatus=new TBits(nSDDchan);
  89
  90   // SPD modules
  91   for(Int_t imod=0; imod<kSPDModules; imod++){
  92     for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
  93       for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
  94         Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
  95         fSPDChannelStatus->SetBitNumber(index,kTRUE);
  96       }
  97     }
  98     Int_t ix,iz;
  99
 100     // Mask SPD dead pixels
 101     AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)dtrec->GetSPDDeadModel(imod);
 102     for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
 103       deadspd->GetBadPixel(ipix,ix,iz);
 104       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 105       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 106     }
 107     // Mask SPD noisy pixels
 108     AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)dtrec->GetCalibrationModel(imod);
 109     for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
 110       noisspd->GetBadPixel(ipix,ix,iz);
 111       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 112       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 113     }
 114   }
 115
 116   // SDD modules
 117   for(Int_t imod=0; imod<kSDDModules; imod++){
 118     AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)dtrec->GetCalibrationModel(imod+kSPDModules);
 119     for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
 120       Bool_t cstatus=kTRUE;
 121       if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
 122       Int_t index=imod*kSDDAnodesPerModule+ian;
 123       fSDDChannelStatus->SetBitNumber(index,cstatus);
 124     }
 125   }
 126 }
 127 //______________________________________________________________________
 128 void  AliITSChannelStatus::InitDefaults(){
 129   // fill bitmaps setting all channels as good
 130   for(Int_t imod=0; imod<kSPDModules; imod++){
 131     for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
 132       for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
 133         Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 134         fSPDChannelStatus->SetBitNumber(index,kTRUE);
 135       }
 136     }
 137   }
 138   for(Int_t imod=0; imod<kSDDModules; imod++){
 139     for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
 140       Int_t index=imod*kSDDAnodesPerModule+ian;
 141       fSDDChannelStatus->SetBitNumber(index,kTRUE);
 142     }
 143   }
 144 }
 145 //______________________________________________________________________
 146 void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD){
 147 // fills bitmaps from arrays of AliITSCalibrationSXD objects
 148
 149   // SPD modules
 150   for(Int_t imod=0; imod<kSPDModules; imod++){
 151     for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
 152       for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
 153         Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 154         fSPDChannelStatus->SetBitNumber(index,kTRUE);
 155       }
 156     }
 157     Int_t ix,iz;
 158
 159     // Mask SPD dead pixels
 160     AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)deadArrSPD->At(imod);
 161     for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
 162       deadspd->GetBadPixel(ipix,ix,iz);
 163       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 164       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 165     }
 166
 167     // Mask SPD noisy pixels
 168     AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)noisArrSPD->At(imod);
 169     for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
 170       noisspd->GetBadPixel(ipix,ix,iz);
 171       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 172       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 173     }
 174   }
 175
 176   // SDD modules
 177   for(Int_t imod=0; imod<kSDDModules; imod++){
 178     AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)calArrSDD->At(imod);
 179     for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
 180       Bool_t cstatus=kTRUE;
 181       if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
 182       Int_t index=imod*kSDDAnodesPerModule+ian;
 183       fSDDChannelStatus->SetBitNumber(index,cstatus);
 184     }
 185   }
 186 }
 187 //______________________________________________________________________
 188 AliITSChannelStatus::AliITSChannelStatus(const AliITSChannelStatus& cstatus):
 189 TObject(),
 190 fSPDChannelStatus(cstatus.fSPDChannelStatus),
 191 fSDDChannelStatus(cstatus.fSDDChannelStatus)
 192 {
 193   // copy constructor
 194 }
 195 //______________________________________________________________________
 196 AliITSChannelStatus& AliITSChannelStatus::operator=(const AliITSChannelStatus& cstatus)
 197 {
 198   // assignment operator
 199   this->~AliITSChannelStatus();
 200   new(this) AliITSChannelStatus(cstatus);
 201   return *this;
 202 }
 203
 204 //______________________________________________________________________
 205 AliITSChannelStatus::~AliITSChannelStatus(){
 206   // destructor
 207   if(fSPDChannelStatus) delete fSPDChannelStatus;
 208   if(fSDDChannelStatus) delete fSDDChannelStatus;
 209 }
 210
 211 //______________________________________________________________________
 212 Bool_t AliITSChannelStatus::CheckBounds(Int_t imod, Int_t iz, Int_t ix) const {
 213   // check for out of bounds
 214   if(imod<0 || imod>=kSPDModules+kSDDModules){
 215     AliError(Form("Module number out of range 0-%d",kSPDModules+kSDDModules));
 216     return kFALSE;
 217   }
 218   if(imod<kSPDModules){
 219     if(ix<0 || ix>=kSPDNpxPerModule || iz<0 || iz>=kSPDNpzPerModule){
 220       AliError("SPD: Pixel number out of range");
 221       return kFALSE;
 222     }
 223   }else{
 224     if(iz<0 || iz>=kSDDAnodesPerModule){
 225       AliError("SDD: anode number out of range");
 226       return kFALSE;
 227     }
 228   }
 229   return kTRUE;
 230 }
 231 //______________________________________________________________________
 232 Bool_t AliITSChannelStatus::GetChannelStatus(Int_t imod, Int_t iz, Int_t ix) const {
 233   // return status of inquired channel
 234   if(CheckBounds(imod,iz,ix)==kFALSE) return kFALSE;
 235   if(imod<kSPDModules){
 236     Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 237     return fSPDChannelStatus->TestBitNumber(index);
 238   }else{
 239     imod-=kSPDModules;
 240     Int_t index=imod*kSDDAnodesPerModule+iz;
 241     return fSDDChannelStatus->TestBitNumber(index);
 242   }
 243 }
 244 //______________________________________________________________________
 245 void AliITSChannelStatus::SetChannelStatus(Bool_t cstatus, Int_t imod, Int_t iz, Int_t ix){
 246   // set status for given channel
 247   if(CheckBounds(imod,iz,ix)==kFALSE) return;
 248   if(imod<kSPDModules){
 249     Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 250     fSPDChannelStatus->SetBitNumber(index,cstatus);
 251   }else{
 252     imod-=kSPDModules;
 253     Int_t index=imod*kSDDAnodesPerModule+iz;
 254     fSDDChannelStatus->SetBitNumber(index,cstatus);
 255   }
 256 }