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 "AliITSCalibrationSSD.h"
  33 #include "AliITSsegmentationSPD.h"
  34 #include "AliITSsegmentationSDD.h"
  35 #include "AliITSsegmentationSSD.h"
  36 #include "AliCDBEntry.h"
  37 #include "TMath.h"
  38 #include "AliLog.h"
  39
  40 ClassImp(AliITSChannelStatus)
  41
  42
  43 //______________________________________________________________________
  44 AliITSChannelStatus::AliITSChannelStatus():
  45 TObject(),
  46 fSPDChannelStatus(0),
  47 fSDDChannelStatus(0),
  48 fSSDChannelStatus(0)
  49 {
  50   // default constructor
  51   UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  52   fSPDChannelStatus=new TBits(nSPDchan);
  53   UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  54   fSDDChannelStatus=new TBits(nSDDchan);
  55   UInt_t nSSDchan=kSSDModules*kSSDStripsPerModule;
  56   fSSDChannelStatus=new TBits(nSSDchan);
  57   InitDefaults();
  58 }
  59 //______________________________________________________________________
  60 AliITSChannelStatus::AliITSChannelStatus(AliCDBManager *cdb):
  61 TObject(),
  62 fSPDChannelStatus(0),
  63 fSDDChannelStatus(0),
  64 fSSDChannelStatus(0)
  65 {
  66   // contruct starting from CDB
  67   AliCDBEntry* spdEntryD = cdb->Get("ITS/Calib/SPDDead");
  68   if (!spdEntryD) AliFatal("Cannot get CDB entry for SPDDead");
  69   TObjArray* deadArrSPD = (TObjArray*)spdEntryD->GetObject();
  70   if (!deadArrSPD) AliFatal("No object found in SPDDead file");
  71
  72   AliCDBEntry* spdEntrySparseD = cdb->Get("ITS/Calib/SPDSparseDead");
  73   if (!spdEntrySparseD) AliFatal("Cannot get CDB entry for SPDSparseDead");
  74   TObjArray* deadSparseArrSPD = (TObjArray*)spdEntrySparseD->GetObject();
  75   if (!deadSparseArrSPD) AliFatal("No object found in SPDSparseDead file");
  76
  77   AliCDBEntry* spdEntryN = cdb->Get("ITS/Calib/SPDNoisy");
  78   if (!spdEntryN) AliFatal("Cannot get CDB entry for SPDNoisy");
  79   TObjArray* noisArrSPD = (TObjArray*)spdEntryN->GetObject();
  80   if (!noisArrSPD) AliFatal("No object found in SPDNoisy file");
  81
  82   AliCDBEntry* sddEntry = cdb->Get("ITS/Calib/CalibSDD");
  83   if (!sddEntry) AliFatal("Cannot get CDB entry for CalibSDD");
  84   TObjArray* calArrSDD = (TObjArray*)sddEntry->GetObject();
  85   if (!calArrSDD) AliFatal("No object found in CalibSDD file");
  86
  87   AliCDBEntry* ssdEntry = cdb->Get("ITS/Calib/CalibSSD");
  88   if (!ssdEntry) AliFatal("Cannot get CDB entry for CalibSSD");
  89   TObjArray* calArrSSD = (TObjArray*)ssdEntry->GetObject();
  90   if (!calArrSSD) AliFatal("No object found in CalibSSD file");
  91
  92   UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
  93   fSPDChannelStatus=new TBits(nSPDchan);
  94   UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
  95   fSDDChannelStatus=new TBits(nSDDchan);
  96   UInt_t nSSDchan=kSSDModules*kSSDStripsPerModule;
  97   fSSDChannelStatus=new TBits(nSSDchan);
  98   InitFromOCDB(deadArrSPD,deadSparseArrSPD,noisArrSPD,calArrSDD,calArrSSD);
  99 }
 100 //______________________________________________________________________
 101 AliITSChannelStatus::AliITSChannelStatus(const AliITSDetTypeRec *dtrec):
 102 TObject(),
 103 fSPDChannelStatus(0),
 104 fSDDChannelStatus(0),
 105 fSSDChannelStatus(0)
 106 {
 107   // contruct starting from det type rec
 108   UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
 109   fSPDChannelStatus=new TBits(nSPDchan);
 110
 111   UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
 112   fSDDChannelStatus=new TBits(nSDDchan);
 113
 114   UInt_t nSSDchan=kSSDModules*kSSDStripsPerModule;
 115   fSSDChannelStatus=new TBits(nSSDchan);
 116
 117   // SPD modules
 118   for(Int_t imod=0; imod<kSPDModules; imod++){
 119     for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
 120       for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
 121         Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 122         fSPDChannelStatus->SetBitNumber(index,kTRUE);
 123       }
 124     }
 125     Int_t ix,iz;
 126
 127     // Mask SPD dead pixels
 128     AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)dtrec->GetSPDDeadModel(imod);
 129     for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
 130       deadspd->GetBadPixel(ipix,ix,iz);
 131       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 132       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 133     }
 134
 135        // Mask SPD sparse dead pixels
 136     AliITSCalibrationSPD* deadSparseSpd=(AliITSCalibrationSPD*)dtrec->GetSPDSparseDeadModel(imod);
 137     for(Int_t ipix=0; ipix<deadSparseSpd->GetNrBad();ipix++){
 138       deadSparseSpd->GetBadPixel(ipix,ix,iz);
 139       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 140       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 141     }
 142
 143     // Mask SPD noisy pixels
 144     AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)dtrec->GetCalibrationModel(imod);
 145     for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
 146       noisspd->GetBadPixel(ipix,ix,iz);
 147       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 148       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 149     }
 150   }
 151
 152   // SDD modules
 153   for(Int_t imod=0; imod<kSDDModules; imod++){
 154     AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)dtrec->GetCalibrationModel(imod+kSPDModules);
 155     for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
 156       Bool_t cstatus=kTRUE;
 157       if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
 158       Int_t index=imod*kSDDAnodesPerModule+ian;
 159       fSDDChannelStatus->SetBitNumber(index,cstatus);
 160     }
 161   }
 162
 163   // SSD modules
 164   for (Int_t imod = 0; imod < kSSDModules; imod++) {
 165     AliITSCalibrationSSD* calssd=(AliITSCalibrationSSD*)dtrec->GetCalibrationModel(kSSDFirstModule+imod);
 166     for(Int_t ip=0; ip<kSSDStripsPerModule; ip++) {
 167       Int_t index=imod*kSSDStripsPerModule+ip;
 168       Bool_t cstatus = kTRUE;
 169       if (ip < 768 && calssd->IsPChannelBad(ip))
 170         cstatus = kFALSE;
 171       if (ip >= 768 && calssd->IsNChannelBad(ip-768))
 172         cstatus = kFALSE;
 173
 174       fSSDChannelStatus->SetBitNumber(index,cstatus);
 175     }
 176   }
 177 }
 178 //______________________________________________________________________
 179 void  AliITSChannelStatus::InitDefaults(){
 180   // fill bitmaps setting all channels as good
 181   for(Int_t imod=0; imod<kSPDModules; imod++){
 182     for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
 183       for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
 184         Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 185         fSPDChannelStatus->SetBitNumber(index,kTRUE);
 186       }
 187     }
 188   }
 189   for(Int_t imod=0; imod<kSDDModules; imod++){
 190     for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
 191       Int_t index=imod*kSDDAnodesPerModule+ian;
 192       fSDDChannelStatus->SetBitNumber(index,kTRUE);
 193     }
 194   }
 195   for(Int_t imod=0; imod<kSSDModules; imod++){
 196     for(Int_t is=0; is<kSSDStripsPerModule; is++){
 197       Int_t index=imod*kSSDStripsPerModule+is;
 198       fSSDChannelStatus->SetBitNumber(index,kTRUE);
 199     }
 200   }
 201 }
 202 //______________________________________________________________________
 203 void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* /* deadSparseArrSPD */, TObjArray* noisArrSPD, TObjArray* calArrSDD, TObjArray *calArrSSD){
 204 // fills bitmaps from arrays of AliITSCalibrationSXD objects
 205
 206   // SPD modules
 207   for(Int_t imod=0; imod<kSPDModules; imod++){
 208     for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
 209       for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
 210         Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 211         fSPDChannelStatus->SetBitNumber(index,kTRUE);
 212       }
 213     }
 214     Int_t ix,iz;
 215
 216     // Mask SPD dead pixels
 217     AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)deadArrSPD->At(imod);
 218     for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
 219       deadspd->GetBadPixel(ipix,ix,iz);
 220       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 221       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 222     }
 223
 224     // Mask SPD sparse dead pixels
 225     AliITSCalibrationSPD* deadSparseSpd=(AliITSCalibrationSPD*)deadArrSPD->At(imod);
 226     for(Int_t ipix=0; ipix<deadSparseSpd->GetNrBad();ipix++){
 227       deadSparseSpd->GetBadPixel(ipix,ix,iz);
 228       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 229       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 230     }
 231
 232     // Mask SPD noisy pixels
 233     AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)noisArrSPD->At(imod);
 234     for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
 235       noisspd->GetBadPixel(ipix,ix,iz);
 236       Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 237       fSPDChannelStatus->SetBitNumber(index,kFALSE);
 238     }
 239   }
 240
 241   // SDD modules
 242   for(Int_t imod=0; imod<kSDDModules; imod++){
 243     AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)calArrSDD->At(imod);
 244     for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
 245       Bool_t cstatus=kTRUE;
 246       if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
 247       Int_t index=imod*kSDDAnodesPerModule+ian;
 248       fSDDChannelStatus->SetBitNumber(index,cstatus);
 249     }
 250   }
 251
 252   // SSD modules
 253   for (Int_t imod = 0; imod < kSSDModules; imod++) {
 254     AliITSCalibrationSSD* calssd=(AliITSCalibrationSSD*)calArrSSD->At(imod);
 255     for(Int_t ip=0; ip<kSSDStripsPerModule; ip++) {
 256       Int_t index=imod*kSSDStripsPerModule+ip;
 257       Bool_t cstatus = kTRUE;
 258       if (ip < 768 && calssd->IsPChannelBad(ip))
 259         cstatus = kFALSE;
 260       if (ip >= 768 && calssd->IsNChannelBad(ip-768))
 261         cstatus = kFALSE;
 262
 263       fSSDChannelStatus->SetBitNumber(index,cstatus);
 264     }
 265   }
 266 }
 267 //______________________________________________________________________
 268 AliITSChannelStatus::AliITSChannelStatus(const AliITSChannelStatus& cstatus):
 269 TObject(),
 270 fSPDChannelStatus(cstatus.fSPDChannelStatus),
 271 fSDDChannelStatus(cstatus.fSDDChannelStatus),
 272 fSSDChannelStatus(cstatus.fSSDChannelStatus)
 273 {
 274   // copy constructor
 275 }
 276 //______________________________________________________________________
 277 AliITSChannelStatus& AliITSChannelStatus::operator=(const AliITSChannelStatus& cstatus)
 278 {
 279   // assignment operator
 280   this->~AliITSChannelStatus();
 281   new(this) AliITSChannelStatus(cstatus);
 282   return *this;
 283 }
 284
 285 //______________________________________________________________________
 286 AliITSChannelStatus::~AliITSChannelStatus(){
 287   // destructor
 288   if(fSPDChannelStatus) delete fSPDChannelStatus;
 289   if(fSDDChannelStatus) delete fSDDChannelStatus;
 290   if(fSSDChannelStatus) delete fSSDChannelStatus;
 291 }
 292
 293 //______________________________________________________________________
 294 Bool_t AliITSChannelStatus::CheckBounds(Int_t imod, Int_t iz, Int_t ix) const {
 295   // check for out of bounds
 296   if(imod<0 || imod>=kSPDModules+kSDDModules+kSSDModules){
 297     AliError(Form("Module number out of range 0-%d",kSPDModules+kSDDModules));
 298     return kFALSE;
 299   }
 300   if(imod<kSPDModules){
 301     if(ix<0 || ix>=kSPDNpxPerModule || iz<0 || iz>=kSPDNpzPerModule){
 302       AliError("SPD: Pixel number out of range");
 303       return kFALSE;
 304     }
 305   }else if (imod<kSSDFirstModule){
 306     if(iz<0 || iz>=kSDDAnodesPerModule){
 307       AliError("SDD: anode number out of range");
 308       return kFALSE;
 309     }
 310   }
 311   else {
 312     if(iz<0 || iz>=kSSDStripsPerModule){
 313       AliError("SSD: strip number out of range");
 314       return kFALSE;
 315     }
 316   }
 317   return kTRUE;
 318 }
 319 //______________________________________________________________________
 320 Bool_t AliITSChannelStatus::GetChannelStatus(Int_t imod, Int_t iz, Int_t ix) const {
 321   // return status of inquired channel
 322   if(CheckBounds(imod,iz,ix)==kFALSE) return kFALSE;
 323   if(imod<kSPDModules){
 324     Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 325     return fSPDChannelStatus->TestBitNumber(index);
 326   } else if (imod < kSSDFirstModule) {
 327     imod-=kSPDModules;
 328     Int_t index=imod*kSDDAnodesPerModule+iz;
 329     return fSDDChannelStatus->TestBitNumber(index);
 330   }
 331   else { // SSD: iz is strip number 0-767 P-side, 768 - 1535 N-side
 332     imod-=kSSDFirstModule;
 333     Int_t index=imod*kSSDStripsPerModule+iz;
 334     return fSSDChannelStatus->TestBitNumber(index);
 335   }
 336 }
 337 //______________________________________________________________________
 338 void AliITSChannelStatus::SetChannelStatus(Bool_t cstatus, Int_t imod, Int_t iz, Int_t ix){
 339   // set status for given channel
 340   if(CheckBounds(imod,iz,ix)==kFALSE) return;
 341   if(imod<kSPDModules){
 342     Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
 343     fSPDChannelStatus->SetBitNumber(index,cstatus);
 344   }else if (imod < kSSDFirstModule) {
 345     imod-=kSPDModules;
 346     Int_t index=imod*kSDDAnodesPerModule+iz;
 347     fSDDChannelStatus->SetBitNumber(index,cstatus);
 348   }
 349   else { // SSD: iz is strip number 0-767 P-side, 768 - 1535 N-side
 350     imod-=kSSDFirstModule;
 351     Int_t index=imod*kSSDStripsPerModule+iz;
 352     return fSSDChannelStatus->SetBitNumber(index,cstatus);
 353   }
 354 }
 355 //______________________________________________________________________
 356 Bool_t AliITSChannelStatus::GetSDDLimits(Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax, Int_t& izmin, Int_t& izmax, Int_t& izmin2, Int_t& izmax2) const {
 357   // Returns min. and max. anode numbers from local coordindate
 358   AliITSsegmentationSDD *seg=new AliITSsegmentationSDD();
 359   Float_t dummySpeed=6.5; // to avoid warnings in SDD segmentation
 360   Float_t tolerance=0.9999;
 361   seg->SetDriftSpeed(dummySpeed);
 362   Float_t zHalfSize=0.5*seg->Dz()/10000.;
 363   zHalfSize*=tolerance;
 364   if(zlocmin<-zHalfSize) zlocmin=-zHalfSize;
 365   if(zlocmax>zHalfSize) zlocmax=zHalfSize;
 366   if(zlocmax<-zHalfSize || zlocmin>zHalfSize){
 367     AliWarning("Search region completely outside module");
 368     return kFALSE;
 369   }
 370   Float_t xHalfSize=seg->Dx()/10000.;
 371   xHalfSize*=tolerance;
 372   if(xlocmin<-xHalfSize) xlocmin=-xHalfSize;
 373   if(xlocmax>xHalfSize) xlocmax=xHalfSize;
 374   if(xlocmax<-xHalfSize || xlocmin>xHalfSize){
 375     AliWarning("Search region completely outside module");
 376     return kFALSE;
 377   }
 378
 379   Int_t iSid1=seg->GetSideFromLocalX(xlocmin);
 380   Int_t iSid2=seg->GetSideFromLocalX(xlocmax);
 381   Int_t iz1,iz2,ixdummy;
 382   seg->LocalToDet(xlocmin,zlocmin,ixdummy,iz1);
 383   seg->LocalToDet(xlocmin,zlocmax,ixdummy,iz2);
 384   izmin=TMath::Min(iz1,iz2);
 385   izmax=TMath::Max(iz1,iz2);
 386   if(iSid1==iSid2){
 387     izmax2=izmin2=-1;
 388   }else{
 389     seg->LocalToDet(xlocmax,zlocmin,ixdummy,iz1);
 390     seg->LocalToDet(xlocmax,zlocmax,ixdummy,iz2);
 391     izmin2=TMath::Min(iz1,iz2);
 392     izmax2=TMath::Max(iz1,iz2);
 393   }
 394   delete seg;
 395   return kTRUE;
 396 }
 397 //______________________________________________________________________
 398 Bool_t AliITSChannelStatus::GetSPDLimits(Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax, Int_t& izmin, Int_t& izmax, Int_t& ixmin, Int_t& ixmax) const {
 399   // Returns min. and max. pixel numbers from local coordindate
 400   Float_t tolerance=0.9999;
 401   AliITSsegmentationSPD *seg=new AliITSsegmentationSPD();
 402   Float_t zHalfSize=0.5*seg->Dz()/10000.;
 403   zHalfSize*=tolerance;
 404   if(zlocmin<-zHalfSize) zlocmin=-zHalfSize;
 405   if(zlocmax>zHalfSize) zlocmax=zHalfSize;
 406   if(zlocmax<-zHalfSize || zlocmin>zHalfSize){
 407     AliWarning("Search region completely outside module");
 408     return kFALSE;
 409   }
 410   Float_t xHalfSize=0.5*seg->Dx()/10000.;
 411   xHalfSize*=tolerance;
 412   if(xlocmin<-xHalfSize) xlocmin=-xHalfSize;
 413   if(xlocmax>xHalfSize) xlocmax=xHalfSize;
 414   if(xlocmax<-xHalfSize || xlocmin>xHalfSize){
 415     AliWarning("Search region completely outside module");
 416     return kFALSE;
 417   }
 418
 419   Int_t iz1,ix1,iz2,ix2;
 420   seg->LocalToDet(xlocmin,zlocmin,ix1,iz1);
 421   seg->LocalToDet(xlocmax,zlocmax,ix2,iz2);
 422   izmin=TMath::Min(iz1,iz2);
 423   izmax=TMath::Max(iz1,iz2);
 424   ixmin=TMath::Min(ix1,ix2);
 425   ixmax=TMath::Max(ix1,ix2);
 426   delete seg;
 427   return kTRUE;
 428 }
 429 //______________________________________________________________________
 430 Bool_t AliITSChannelStatus::GetSSDLimits(Int_t layer, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax, Int_t& iPmin, Int_t& iPmax, Int_t& iNmin, Int_t& iNmax) const {
 431   // Returns min, max strip for SSD, given a search window
 432   static AliITSsegmentationSSD seg;
 433
 434   AliDebug(2,Form("xmin %f zmin %f xmax %f zmax %f\n",xlocmin,zlocmin,xlocmax,zlocmax));
 435
 436   Int_t p,n;
 437   seg.SetLayer(layer);
 438   seg.GetPadIxz(xlocmin,zlocmin,p,n);
 439   iPmin = iPmax = p;
 440   iNmin = iNmax = n;
 441   AliDebug(5,Form("lay %d xmin, zmin p %d n %d\n",layer,p,n));
 442   seg.GetPadIxz(xlocmax,zlocmin,p,n);
 443   iPmin = TMath::Min(iPmin,p);
 444   iPmax = TMath::Max(iPmax,p);
 445   iNmin = TMath::Min(iNmin,n);
 446   iNmax = TMath::Max(iNmax,n);
 447   AliDebug(5,Form("lay %d xmax, zmin p %d n %d\n",layer,p,n));
 448   seg.GetPadIxz(xlocmax,zlocmax,p,n);
 449   iPmin = TMath::Min(iPmin,p);
 450   iPmax = TMath::Max(iPmax,p);
 451   iNmin = TMath::Min(iNmin,n);
 452   iNmax = TMath::Max(iNmax,n);
 453   AliDebug(5,Form("lay %d xmax, zmax p %d n %d\n",layer,p,n));
 454   seg.GetPadIxz(xlocmin,zlocmax,p,n);
 455   iPmin = TMath::Min(iPmin,p);
 456   iPmax = TMath::Max(iPmax,p);
 457   iNmin = TMath::Min(iNmin,n);
 458   iNmax = TMath::Max(iNmax,n);
 459   AliDebug(5,Form("lay %d xmin, zmax p %d n %d\n",layer,p,n));
 460
 461   if (iPmin < 0)
 462     iPmin = 0;
 463   if (iNmin < 0)
 464     iNmin = 0;
 465   if (iPmax >= kSSDStripsPerSide)
 466     iPmax = kSSDStripsPerSide-1;
 467   if (iNmax >= kSSDStripsPerSide)
 468     iNmax = kSSDStripsPerSide-1;
 469   AliDebug(2,Form("lay %d p %d %d n %d %d\n",layer,iPmin,iPmax,iNmin,iNmax));
 470   return kTRUE;
 471 }
 472 //______________________________________________________________________
 473 Bool_t AliITSChannelStatus::AnyBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const{
 474   // Checks if there is at least one bad channel in the search road
 475   // For SSD: return kTRUE if there is at least one bad strip on both sides
 476   //          if only bad strips on one side 1D clusters can be used
 477   AliDebug(2,Form("checking for module %d",imod));
 478   if(imod<kSPDModules){
 479     Int_t izmin,izmax,ixmin,ixmax;
 480     Bool_t retcode=GetSPDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,ixmin,ixmax);
 481     if(!retcode) return kFALSE;
 482     for(Int_t iz=izmin; iz<=izmax;iz++){
 483       for(Int_t ix=ixmin; ix<=ixmax;ix++){
 484         if(GetChannelStatus(imod,iz,ix)==kFALSE) return kTRUE;
 485       }
 486     }
 487   }else if (imod < kSSDFirstModule) {
 488     Int_t izmin,izmax,izmin2,izmax2;
 489     Bool_t retcode=GetSDDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,izmin2,izmax2);
 490     if(!retcode) return kFALSE;
 491     for(Int_t iz=izmin; iz<=izmax;iz++){
 492       if(GetChannelStatus(imod,iz,0)==kFALSE) { return kTRUE;}
 493     }
 494     if(izmin2!=-1 && izmax2!=-1){
 495       for(Int_t iz=izmin2; iz<=izmax2;iz++){
 496         if(GetChannelStatus(imod,iz,0)==kFALSE) { return kTRUE;}
 497       }
 498     }
 499   }
 500   else {
 501     Int_t layer = 5;
 502     if (imod > kSSDMaxModLay5)
 503       layer = 6;
 504     Int_t iPmin,iPmax,iNmin,iNmax;
 505     Bool_t retcode=GetSSDLimits(layer,zlocmin,zlocmax,xlocmin,xlocmax,iPmin,iPmax,iNmin,iNmax);
 506     if(!retcode) return kFALSE;
 507     Int_t nPbad = 0;
 508     for(Int_t iP=iPmin; iP<=iPmax;iP++){
 509       if(GetChannelStatus(imod,iP,0)==kFALSE) nPbad++;
 510     }
 511     if (nPbad == 0)
 512       return kFALSE;
 513     for(Int_t iN=iNmin; iN<=iNmax;iN++){
 514       if(GetChannelStatus(imod,iN+768,0)==kFALSE) { return kTRUE; }
 515     }
 516   }
 517   return kFALSE;
 518 }
 519 //______________________________________________________________________
 520 Float_t AliITSChannelStatus::FractionOfBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const{
 521   // Calculate the fraction of bad channels in the road
 522   // Note: SSD returns fraction of dead strips on 'best' side. This
 523   //       is not proportional to dead surface area.
 524   Float_t totChan=0.;
 525   Float_t badChan=0.;
 526   if(imod<kSPDModules){
 527     Int_t izmin,izmax,ixmin,ixmax;
 528     Bool_t retcode=GetSPDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,ixmin,ixmax);
 529     if(!retcode) return 0.;
 530     for(Int_t iz=izmin; iz<=izmax;iz++){
 531       for(Int_t ix=ixmin; ix<=ixmax;ix++){
 532         totChan+=1;
 533         if(GetChannelStatus(imod,iz,ix)==kFALSE) badChan+=1.;
 534       }
 535     }
 536   }else if (imod < kSSDFirstModule) {
 537     Int_t izmin,izmax,izmin2,izmax2;
 538     Bool_t retcode=GetSDDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,izmin2,izmax2);
 539     if(!retcode) return 0.;
 540     for(Int_t iz=izmin; iz<=izmax;iz++){
 541       totChan+=1;
 542       if(GetChannelStatus(imod,iz,0)==kFALSE) badChan+=1.;
 543     }
 544     if(izmin2!=-1 && izmax2!=-1){
 545       for(Int_t iz=izmin2; iz<=izmax2;iz++){
 546         totChan+=1;
 547         if(GetChannelStatus(imod,iz,0)==kFALSE) badChan+=1.;
 548       }
 549     }
 550   }
 551   else {
 552     Int_t layer = 5;
 553     if (imod > kSSDMaxModLay5)
 554       layer = 6;
 555     Int_t iPmin,iPmax,iNmin,iNmax;
 556     Bool_t retcode=GetSSDLimits(layer,zlocmin,zlocmax,xlocmin,xlocmax,iPmin,iPmax,iNmin,iNmax);
 557     if(!retcode) return kFALSE;
 558     Int_t nPbad = 0;
 559     for(Int_t iP=iPmin; iP<=iPmax;iP++){
 560       if(GetChannelStatus(imod,iP,0)==kFALSE) nPbad++;
 561     }
 562     Float_t fracP = (Float_t) nPbad / (iPmax-iPmin+1);
 563     if (nPbad == 0)
 564       return 0;
 565     Int_t nNbad = 0;
 566     for(Int_t iN=iNmin; iN<=iNmax;iN++){
 567       if(GetChannelStatus(imod,iN+768,0)==kFALSE) nNbad++;
 568     }
 569     Float_t fracN = (Float_t) nNbad / (iPmax-iPmin+1);
 570     return TMath::Min(fracP,fracN);
 571   }
 572   if(totChan==0.) return 0.;
 573   else return badChan/totChan;
 574 }
 575