1 /**************************************************************************
2 * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
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 **************************************************************************/
18 //////////////////////////////////////////////////////////////////////////
20 // Implementation of the class for bad channel treatment in the tracker //
21 // Stores 1 status bit for each SPD pixel and SDD anode: //
23 // 1 = good channel //
24 // Dead and noisy channels are read from AliITSCalibration objects //
25 // Origin: F.Prino, Torino, prino@to.infn.it //
27 //////////////////////////////////////////////////////////////////////////
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"
40 ClassImp(AliITSChannelStatus)
43 //______________________________________________________________________
44 AliITSChannelStatus::AliITSChannelStatus():
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);
59 //______________________________________________________________________
60 AliITSChannelStatus::AliITSChannelStatus(AliCDBManager *cdb):
66 AliCDBEntry* spdEntryD = cdb->Get("ITS/Calib/SPDDead");
67 if (!spdEntryD) AliFatal("Cannot get CDB entry for SPDDead");
68 TObjArray* deadArrSPD = (TObjArray*)spdEntryD->GetObject();
69 if (!deadArrSPD) AliFatal("No object found in SPDDead file");
71 AliCDBEntry* spdEntryN = cdb->Get("ITS/Calib/SPDNoisy");
72 if (!spdEntryN) AliFatal("Cannot get CDB entry for SPDNoisy");
73 TObjArray* noisArrSPD = (TObjArray*)spdEntryN->GetObject();
74 if (!noisArrSPD) AliFatal("No object found in SPDNoisy file");
76 AliCDBEntry* sddEntry = cdb->Get("ITS/Calib/CalibSDD");
77 if (!sddEntry) AliFatal("Cannot get CDB entry for CalibSDD");
78 TObjArray* calArrSDD = (TObjArray*)sddEntry->GetObject();
79 if (!calArrSDD) AliFatal("No object found in CalibSDD file");
81 AliCDBEntry* ssdEntry = cdb->Get("ITS/Calib/CalibSSD");
82 if (!ssdEntry) AliFatal("Cannot get CDB entry for CalibSSD");
83 TObjArray* calArrSSD = (TObjArray*)ssdEntry->GetObject();
84 if (!calArrSSD) AliFatal("No object found in CalibSSD file");
86 UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
87 fSPDChannelStatus=new TBits(nSPDchan);
88 UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
89 fSDDChannelStatus=new TBits(nSDDchan);
90 UInt_t nSSDchan=kSSDModules*kSSDStripsPerModule;
91 fSSDChannelStatus=new TBits(nSSDchan);
92 InitFromOCDB(deadArrSPD,noisArrSPD,calArrSDD,calArrSSD);
94 //______________________________________________________________________
95 AliITSChannelStatus::AliITSChannelStatus(const AliITSDetTypeRec *dtrec):
101 UInt_t nSPDchan=kSPDModules*kSPDNpxPerModule*kSPDNpzPerModule;
102 fSPDChannelStatus=new TBits(nSPDchan);
104 UInt_t nSDDchan=kSDDModules*kSDDAnodesPerModule;
105 fSDDChannelStatus=new TBits(nSDDchan);
107 UInt_t nSSDchan=kSSDModules*kSSDStripsPerModule;
108 fSSDChannelStatus=new TBits(nSSDchan);
111 for(Int_t imod=0; imod<kSPDModules; imod++){
112 for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
113 for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
114 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
115 fSPDChannelStatus->SetBitNumber(index,kTRUE);
120 // Mask SPD dead pixels
121 AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)dtrec->GetSPDDeadModel(imod);
122 for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
123 deadspd->GetBadPixel(ipix,ix,iz);
124 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
125 fSPDChannelStatus->SetBitNumber(index,kFALSE);
127 // Mask SPD noisy pixels
128 AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)dtrec->GetCalibrationModel(imod);
129 for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
130 noisspd->GetBadPixel(ipix,ix,iz);
131 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
132 fSPDChannelStatus->SetBitNumber(index,kFALSE);
137 for(Int_t imod=0; imod<kSDDModules; imod++){
138 AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)dtrec->GetCalibrationModel(imod+kSPDModules);
139 for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
140 Bool_t cstatus=kTRUE;
141 if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
142 Int_t index=imod*kSDDAnodesPerModule+ian;
143 fSDDChannelStatus->SetBitNumber(index,cstatus);
148 for (Int_t imod = 0; imod < kSSDModules; imod++) {
149 AliITSCalibrationSSD* calssd=(AliITSCalibrationSSD*)dtrec->GetCalibrationModel(kSSDFirstModule+imod);
150 for(Int_t ip=0; ip<kSSDStripsPerModule; ip++) {
151 Int_t index=imod*kSSDStripsPerModule+ip;
152 Bool_t cstatus = kTRUE;
153 if (ip < 768 && calssd->IsPChannelBad(ip))
155 if (ip >= 768 && calssd->IsNChannelBad(ip-768))
158 fSSDChannelStatus->SetBitNumber(index,cstatus);
162 //______________________________________________________________________
163 void AliITSChannelStatus::InitDefaults(){
164 // fill bitmaps setting all channels as good
165 for(Int_t imod=0; imod<kSPDModules; imod++){
166 for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
167 for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
168 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
169 fSPDChannelStatus->SetBitNumber(index,kTRUE);
173 for(Int_t imod=0; imod<kSDDModules; imod++){
174 for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
175 Int_t index=imod*kSDDAnodesPerModule+ian;
176 fSDDChannelStatus->SetBitNumber(index,kTRUE);
179 for(Int_t imod=0; imod<kSSDModules; imod++){
180 for(Int_t is=0; is<kSSDStripsPerModule; is++){
181 Int_t index=imod*kSSDStripsPerModule+is;
182 fSSDChannelStatus->SetBitNumber(index,kTRUE);
186 //______________________________________________________________________
187 void AliITSChannelStatus::InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD, TObjArray *calArrSSD){
188 // fills bitmaps from arrays of AliITSCalibrationSXD objects
191 for(Int_t imod=0; imod<kSPDModules; imod++){
192 for(Int_t ix=0; ix<kSPDNpxPerModule; ix++){
193 for(Int_t iz=0; iz<kSPDNpzPerModule; iz++){
194 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
195 fSPDChannelStatus->SetBitNumber(index,kTRUE);
200 // Mask SPD dead pixels
201 AliITSCalibrationSPD* deadspd=(AliITSCalibrationSPD*)deadArrSPD->At(imod);
202 for(Int_t ipix=0; ipix<deadspd->GetNrBad();ipix++){
203 deadspd->GetBadPixel(ipix,ix,iz);
204 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
205 fSPDChannelStatus->SetBitNumber(index,kFALSE);
208 // Mask SPD noisy pixels
209 AliITSCalibrationSPD* noisspd=(AliITSCalibrationSPD*)noisArrSPD->At(imod);
210 for(Int_t ipix=0; ipix<noisspd->GetNrBad();ipix++){
211 noisspd->GetBadPixel(ipix,ix,iz);
212 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
213 fSPDChannelStatus->SetBitNumber(index,kFALSE);
218 for(Int_t imod=0; imod<kSDDModules; imod++){
219 AliITSCalibrationSDD* calsdd=(AliITSCalibrationSDD*)calArrSDD->At(imod);
220 for(Int_t ian=0; ian<kSDDAnodesPerModule; ian++){
221 Bool_t cstatus=kTRUE;
222 if(calsdd->IsBadChannel(ian)) cstatus=kFALSE;
223 Int_t index=imod*kSDDAnodesPerModule+ian;
224 fSDDChannelStatus->SetBitNumber(index,cstatus);
229 for (Int_t imod = 0; imod < kSSDModules; imod++) {
230 AliITSCalibrationSSD* calssd=(AliITSCalibrationSSD*)calArrSSD->At(imod);
231 for(Int_t ip=0; ip<kSSDStripsPerModule; ip++) {
232 Int_t index=imod*kSSDStripsPerModule+ip;
233 Bool_t cstatus = kTRUE;
234 if (ip < 768 && calssd->IsPChannelBad(ip))
236 if (ip >= 768 && calssd->IsNChannelBad(ip-768))
239 fSSDChannelStatus->SetBitNumber(index,cstatus);
243 //______________________________________________________________________
244 AliITSChannelStatus::AliITSChannelStatus(const AliITSChannelStatus& cstatus):
246 fSPDChannelStatus(cstatus.fSPDChannelStatus),
247 fSDDChannelStatus(cstatus.fSDDChannelStatus),
248 fSSDChannelStatus(cstatus.fSSDChannelStatus)
252 //______________________________________________________________________
253 AliITSChannelStatus& AliITSChannelStatus::operator=(const AliITSChannelStatus& cstatus)
255 // assignment operator
256 this->~AliITSChannelStatus();
257 new(this) AliITSChannelStatus(cstatus);
261 //______________________________________________________________________
262 AliITSChannelStatus::~AliITSChannelStatus(){
264 if(fSPDChannelStatus) delete fSPDChannelStatus;
265 if(fSDDChannelStatus) delete fSDDChannelStatus;
266 if(fSSDChannelStatus) delete fSSDChannelStatus;
269 //______________________________________________________________________
270 Bool_t AliITSChannelStatus::CheckBounds(Int_t imod, Int_t iz, Int_t ix) const {
271 // check for out of bounds
272 if(imod<0 || imod>=kSPDModules+kSDDModules+kSSDModules){
273 AliError(Form("Module number out of range 0-%d",kSPDModules+kSDDModules));
276 if(imod<kSPDModules){
277 if(ix<0 || ix>=kSPDNpxPerModule || iz<0 || iz>=kSPDNpzPerModule){
278 AliError("SPD: Pixel number out of range");
281 }else if (imod<kSSDFirstModule){
282 if(iz<0 || iz>=kSDDAnodesPerModule){
283 AliError("SDD: anode number out of range");
288 if(iz<0 || iz>=kSSDStripsPerModule){
289 AliError("SSD: strip number out of range");
295 //______________________________________________________________________
296 Bool_t AliITSChannelStatus::GetChannelStatus(Int_t imod, Int_t iz, Int_t ix) const {
297 // return status of inquired channel
298 if(CheckBounds(imod,iz,ix)==kFALSE) return kFALSE;
299 if(imod<kSPDModules){
300 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
301 return fSPDChannelStatus->TestBitNumber(index);
302 } else if (imod < kSSDFirstModule) {
304 Int_t index=imod*kSDDAnodesPerModule+iz;
305 return fSDDChannelStatus->TestBitNumber(index);
307 else { // SSD: iz is strip number 0-767 P-side, 768 - 1535 N-side
308 imod-=kSSDFirstModule;
309 Int_t index=imod*kSSDStripsPerModule+iz;
310 return fSSDChannelStatus->TestBitNumber(index);
313 //______________________________________________________________________
314 void AliITSChannelStatus::SetChannelStatus(Bool_t cstatus, Int_t imod, Int_t iz, Int_t ix){
315 // set status for given channel
316 if(CheckBounds(imod,iz,ix)==kFALSE) return;
317 if(imod<kSPDModules){
318 Int_t index=imod*kSPDNpxPerModule*kSPDNpzPerModule+ix*kSPDNpzPerModule+iz;
319 fSPDChannelStatus->SetBitNumber(index,cstatus);
320 }else if (imod < kSSDFirstModule) {
322 Int_t index=imod*kSDDAnodesPerModule+iz;
323 fSDDChannelStatus->SetBitNumber(index,cstatus);
325 else { // SSD: iz is strip number 0-767 P-side, 768 - 1535 N-side
326 imod-=kSSDFirstModule;
327 Int_t index=imod*kSSDStripsPerModule+iz;
328 return fSSDChannelStatus->SetBitNumber(index,cstatus);
331 //______________________________________________________________________
332 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 {
333 // Returns min. and max. anode numbers from local coordindate
334 AliITSsegmentationSDD *seg=new AliITSsegmentationSDD();
335 Float_t dummySpeed=6.5; // to avoid warnings in SDD segmentation
336 Float_t tolerance=0.9999;
337 seg->SetDriftSpeed(dummySpeed);
338 Float_t zHalfSize=0.5*seg->Dz()/10000.;
339 zHalfSize*=tolerance;
340 if(zlocmin<-zHalfSize) zlocmin=-zHalfSize;
341 if(zlocmax>zHalfSize) zlocmax=zHalfSize;
342 if(zlocmax<-zHalfSize || zlocmin>zHalfSize){
343 AliWarning("Search region completely outside module");
346 Float_t xHalfSize=seg->Dx()/10000.;
347 xHalfSize*=tolerance;
348 if(xlocmin<-xHalfSize) xlocmin=-xHalfSize;
349 if(xlocmax>xHalfSize) xlocmax=xHalfSize;
350 if(xlocmax<-xHalfSize || xlocmin>xHalfSize){
351 AliWarning("Search region completely outside module");
355 Int_t iSid1=seg->GetSideFromLocalX(xlocmin);
356 Int_t iSid2=seg->GetSideFromLocalX(xlocmax);
357 Int_t iz1,iz2,ixdummy;
358 seg->LocalToDet(xlocmin,zlocmin,ixdummy,iz1);
359 seg->LocalToDet(xlocmin,zlocmax,ixdummy,iz2);
360 izmin=TMath::Min(iz1,iz2);
361 izmax=TMath::Max(iz1,iz2);
365 seg->LocalToDet(xlocmax,zlocmin,ixdummy,iz1);
366 seg->LocalToDet(xlocmax,zlocmax,ixdummy,iz2);
367 izmin2=TMath::Min(iz1,iz2);
368 izmax2=TMath::Max(iz1,iz2);
373 //______________________________________________________________________
374 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 {
375 // Returns min. and max. pixel numbers from local coordindate
376 Float_t tolerance=0.9999;
377 AliITSsegmentationSPD *seg=new AliITSsegmentationSPD();
378 Float_t zHalfSize=0.5*seg->Dz()/10000.;
379 zHalfSize*=tolerance;
380 if(zlocmin<-zHalfSize) zlocmin=-zHalfSize;
381 if(zlocmax>zHalfSize) zlocmax=zHalfSize;
382 if(zlocmax<-zHalfSize || zlocmin>zHalfSize){
383 AliWarning("Search region completely outside module");
386 Float_t xHalfSize=0.5*seg->Dx()/10000.;
387 xHalfSize*=tolerance;
388 if(xlocmin<-xHalfSize) xlocmin=-xHalfSize;
389 if(xlocmax>xHalfSize) xlocmax=xHalfSize;
390 if(xlocmax<-xHalfSize || xlocmin>xHalfSize){
391 AliWarning("Search region completely outside module");
395 Int_t iz1,ix1,iz2,ix2;
396 seg->LocalToDet(xlocmin,zlocmin,ix1,iz1);
397 seg->LocalToDet(xlocmax,zlocmax,ix2,iz2);
398 izmin=TMath::Min(iz1,iz2);
399 izmax=TMath::Max(iz1,iz2);
400 ixmin=TMath::Min(ix1,ix2);
401 ixmax=TMath::Max(ix1,ix2);
405 //______________________________________________________________________
406 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 {
407 // Returns min, max strip for SSD, given a search window
408 static AliITSsegmentationSSD seg;
410 AliDebug(2,Form("xmin %f zmin %f xmax %f zmax %f\n",xlocmin,zlocmin,xlocmax,zlocmax));
414 seg.GetPadIxz(xlocmin,zlocmin,p,n);
417 AliDebug(5,Form("lay %d xmin, zmin p %d n %d\n",layer,p,n));
418 seg.GetPadIxz(xlocmax,zlocmin,p,n);
419 iPmin = TMath::Min(iPmin,p);
420 iPmax = TMath::Min(iPmax,p);
421 iNmin = TMath::Min(iNmin,n);
422 iNmax = TMath::Min(iNmax,n);
423 AliDebug(5,Form("lay %d xmax, zmin p %d n %d\n",layer,p,n));
424 seg.GetPadIxz(xlocmax,zlocmax,p,n);
425 iPmin = TMath::Min(iPmin,p);
426 iPmax = TMath::Min(iPmax,p);
427 iNmin = TMath::Min(iNmin,n);
428 iNmax = TMath::Min(iNmax,n);
429 AliDebug(5,Form("lay %d xmax, zmax p %d n %d\n",layer,p,n));
430 seg.GetPadIxz(xlocmin,zlocmax,p,n);
431 iPmin = TMath::Min(iPmin,p);
432 iPmax = TMath::Min(iPmax,p);
433 iNmin = TMath::Min(iNmin,n);
434 iNmax = TMath::Min(iNmax,n);
435 AliDebug(5,Form("lay %d xmin, zmax p %d n %d\n",layer,p,n));
441 if (iPmax >= kSSDStripsPerSide)
442 iPmax = kSSDStripsPerSide-1;
443 if (iNmax >= kSSDStripsPerSide)
444 iNmax = kSSDStripsPerSide-1;
445 AliDebug(2,Form("lay %d p %d %d n %d %d\n",layer,iPmin,iPmax,iNmin,iNmax));
448 //______________________________________________________________________
449 Bool_t AliITSChannelStatus::AnyBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const{
450 // Checks if there is at least one bad channel in the search road
451 // For SSD: return kTRUE if there is at least one bad strip on both sides
452 // if only bad strips on one side 1D clusters can be used
453 AliDebug(2,Form("checking for module %d",imod));
454 if(imod<kSPDModules){
455 Int_t izmin,izmax,ixmin,ixmax;
456 Bool_t retcode=GetSPDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,ixmin,ixmax);
457 if(!retcode) return kFALSE;
458 for(Int_t iz=izmin; iz<=izmax;iz++){
459 for(Int_t ix=ixmin; ix<=ixmax;ix++){
460 if(GetChannelStatus(imod,iz,ix)==kFALSE) return kTRUE;
463 }else if (imod < kSSDFirstModule) {
464 Int_t izmin,izmax,izmin2,izmax2;
465 Bool_t retcode=GetSDDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,izmin2,izmax2);
466 if(!retcode) return kFALSE;
467 for(Int_t iz=izmin; iz<=izmax;iz++){
468 if(GetChannelStatus(imod,iz,0)==kFALSE) { return kTRUE;}
470 if(izmin2!=-1 && izmax2!=-1){
471 for(Int_t iz=izmin2; iz<=izmax2;iz++){
472 if(GetChannelStatus(imod,iz,0)==kFALSE) { return kTRUE;}
478 if (imod > kSSDMaxModLay5)
480 Int_t iPmin,iPmax,iNmin,iNmax;
481 Bool_t retcode=GetSSDLimits(layer,zlocmin,zlocmax,xlocmin,xlocmax,iPmin,iPmax,iNmin,iNmax);
482 if(!retcode) return kFALSE;
484 for(Int_t iP=iPmin; iP<=iPmax;iP++){
485 if(GetChannelStatus(imod,iP,0)==kFALSE) nPbad++;
489 for(Int_t iN=iNmin; iN<=iNmax;iN++){
490 if(GetChannelStatus(imod,iN+768,0)==kFALSE) { return kTRUE; }
495 //______________________________________________________________________
496 Float_t AliITSChannelStatus::FractionOfBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const{
497 // Calculate the fraction of bad channels in the road
498 // Note: SSD returns fraction of dead strips on 'best' side. This
499 // is not proportional to dead surface area.
502 if(imod<kSPDModules){
503 Int_t izmin,izmax,ixmin,ixmax;
504 Bool_t retcode=GetSPDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,ixmin,ixmax);
505 if(!retcode) return 0.;
506 for(Int_t iz=izmin; iz<=izmax;iz++){
507 for(Int_t ix=ixmin; ix<=ixmax;ix++){
509 if(GetChannelStatus(imod,iz,ix)==kFALSE) badChan+=1.;
512 }else if (imod < kSSDFirstModule) {
513 Int_t izmin,izmax,izmin2,izmax2;
514 Bool_t retcode=GetSDDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,izmin2,izmax2);
515 if(!retcode) return 0.;
516 for(Int_t iz=izmin; iz<=izmax;iz++){
518 if(GetChannelStatus(imod,iz,0)==kFALSE) badChan+=1.;
520 if(izmin2!=-1 && izmax2!=-1){
521 for(Int_t iz=izmin2; iz<=izmax2;iz++){
523 if(GetChannelStatus(imod,iz,0)==kFALSE) badChan+=1.;
529 if (imod > kSSDMaxModLay5)
531 Int_t iPmin,iPmax,iNmin,iNmax;
532 Bool_t retcode=GetSSDLimits(layer,zlocmin,zlocmax,xlocmin,xlocmax,iPmin,iPmax,iNmin,iNmax);
533 if(!retcode) return kFALSE;
535 for(Int_t iP=iPmin; iP<=iPmax;iP++){
536 if(GetChannelStatus(imod,iP,0)==kFALSE) nPbad++;
538 Float_t fracP = (Float_t) nPbad / (iPmax-iPmin+1);
542 for(Int_t iN=iNmin; iN<=iNmax;iN++){
543 if(GetChannelStatus(imod,iN+768,0)==kFALSE) nNbad++;
545 Float_t fracN = (Float_t) nNbad / (iPmax-iPmin+1);
546 return TMath::Min(fracP,fracN);
548 if(totChan==0.) return 0.;
549 else return badChan/totChan;