Implemented the calculation of the fraction of bad SPD and SDD channels in a given...

diff --git a/ITS/AliITSChannelStatus.cxx b/ITS/AliITSChannelStatus.cxx
index 981553d4126a2fbb6ee284a70d6b42b0f92f1382..4e637de8bf839f63c48ff4cbd517c9c12b8fc539 100644 (file)
--- a/ITS/AliITSChannelStatus.cxx
+++ b/ITS/AliITSChannelStatus.cxx
@@ -29,7 +29,10 @@
 #include "AliITSChannelStatus.h"
 #include "AliITSCalibrationSPD.h"
 #include "AliITSCalibrationSDD.h"
+#include "AliITSsegmentationSPD.h"
+#include "AliITSsegmentationSDD.h"
 #include "AliCDBEntry.h"
+#include "TMath.h"
 #include "AliLog.h"
 
 ClassImp(AliITSChannelStatus)
@@ -254,3 +257,137 @@ void AliITSChannelStatus::SetChannelStatus(Bool_t cstatus, Int_t imod, Int_t iz,
     fSDDChannelStatus->SetBitNumber(index,cstatus);
   }
 }
+//______________________________________________________________________
+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 {
+  // Returns min. and max. anode numbers from local coordindate
+  AliITSsegmentationSDD *seg=new AliITSsegmentationSDD();
+  Float_t dummySpeed=6.5; // to avoid warnings in SDD segmentation
+  Float_t tolerance=0.9999;
+  seg->SetDriftSpeed(dummySpeed);
+  Float_t zHalfSize=0.5*seg->Dz()/10000.;
+  zHalfSize*=tolerance;
+  if(zlocmin<-zHalfSize) zlocmin=-zHalfSize;
+  if(zlocmax>zHalfSize) zlocmax=zHalfSize;
+  if(zlocmax<-zHalfSize || zlocmin>zHalfSize){
+    AliWarning("Search region completely outside module");
+    return kFALSE;
+  }
+  Float_t xHalfSize=seg->Dx()/10000.;
+  xHalfSize*=tolerance;
+  if(xlocmin<-xHalfSize) xlocmin=-xHalfSize;
+  if(xlocmax>xHalfSize) xlocmax=xHalfSize;
+  if(xlocmax<-xHalfSize || xlocmin>xHalfSize){
+    AliWarning("Search region completely outside module");
+    return kFALSE;
+  }
+  
+  Int_t iSid1=seg->GetSideFromLocalX(xlocmin);
+  Int_t iSid2=seg->GetSideFromLocalX(xlocmax);
+  Int_t iz1,iz2,ixdummy;
+  seg->LocalToDet(xlocmin,zlocmin,ixdummy,iz1);
+  seg->LocalToDet(xlocmin,zlocmax,ixdummy,iz2);
+  izmin=TMath::Min(iz1,iz2);
+  izmax=TMath::Max(iz1,iz2);    
+  if(iSid1==iSid2){
+    izmax2=izmin2=-1;
+  }else{
+    seg->LocalToDet(xlocmax,zlocmin,ixdummy,iz1);
+    seg->LocalToDet(xlocmax,zlocmax,ixdummy,iz2);
+    izmin2=TMath::Min(iz1,iz2);
+    izmax2=TMath::Max(iz1,iz2);    
+  }
+  delete seg;
+  return kTRUE;
+}
+//______________________________________________________________________
+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 {
+  // Returns min. and max. pixel numbers from local coordindate
+  Float_t tolerance=0.9999;
+  AliITSsegmentationSPD *seg=new AliITSsegmentationSPD();
+  Float_t zHalfSize=0.5*seg->Dz()/10000.;
+  zHalfSize*=tolerance;
+  if(zlocmin<-zHalfSize) zlocmin=-zHalfSize;
+  if(zlocmax>zHalfSize) zlocmax=zHalfSize;
+  if(zlocmax<-zHalfSize || zlocmin>zHalfSize){
+    AliWarning("Search region completely outside module");
+    return kFALSE;
+  }
+  Float_t xHalfSize=0.5*seg->Dx()/10000.;
+  xHalfSize*=tolerance;
+  if(xlocmin<-xHalfSize) xlocmin=-xHalfSize;
+  if(xlocmax>xHalfSize) xlocmax=xHalfSize;
+  if(xlocmax<-xHalfSize || xlocmin>xHalfSize){
+    AliWarning("Search region completely outside module");
+    return kFALSE;
+  }
+
+  Int_t iz1,ix1,iz2,ix2;
+  seg->LocalToDet(xlocmin,zlocmin,ix1,iz1);
+  seg->LocalToDet(xlocmax,zlocmax,ix2,iz2);
+  izmin=TMath::Min(iz1,iz2);
+  izmax=TMath::Max(iz1,iz2);
+  ixmin=TMath::Min(ix1,ix2);
+  ixmax=TMath::Max(ix1,ix2);
+  delete seg;
+  return kTRUE;
+}
+//______________________________________________________________________
+Bool_t AliITSChannelStatus::AnyBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const{
+  // Checks if there is at least one bad channel in the search road
+  if(imod<kSPDModules){
+    Int_t izmin,izmax,ixmin,ixmax;
+    Bool_t retcode=GetSPDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,ixmin,ixmax);
+    if(!retcode) return kFALSE;
+    for(Int_t iz=izmin; iz<=izmax;iz++){
+      for(Int_t ix=ixmin; ix<=ixmax;ix++){
+       if(GetChannelStatus(imod,iz,ix)==kFALSE) return kTRUE;
+      }
+    }
+  }else{
+    Int_t izmin,izmax,izmin2,izmax2;
+    Bool_t retcode=GetSDDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,izmin2,izmax2);
+    if(!retcode) return kFALSE;
+    for(Int_t iz=izmin; iz<=izmax;iz++){
+      if(GetChannelStatus(imod,iz,0)==kFALSE) return kTRUE;
+    }
+    if(izmin2!=-1 && izmax2!=-1){
+      for(Int_t iz=izmin2; iz<=izmax2;iz++){
+       if(GetChannelStatus(imod,iz,0)==kFALSE) return kTRUE;
+      }
+    }
+  }
+  return kFALSE;
+}
+//______________________________________________________________________
+Float_t AliITSChannelStatus::FractionOfBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const{
+  // Calculate the fraction of bad channels in the road  
+  Float_t totChan=0.;
+  Float_t badChan=0.;
+  if(imod<kSPDModules){
+    Int_t izmin,izmax,ixmin,ixmax;
+    Bool_t retcode=GetSPDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,ixmin,ixmax);
+    if(!retcode) return 0.;
+    for(Int_t iz=izmin; iz<=izmax;iz++){
+      for(Int_t ix=ixmin; ix<=ixmax;ix++){
+       totChan+=1;
+       if(GetChannelStatus(imod,iz,ix)==kFALSE) badChan+=1.;
+      }
+    }
+  }else{
+    Int_t izmin,izmax,izmin2,izmax2;
+    Bool_t retcode=GetSDDLimits(zlocmin,zlocmax,xlocmin,xlocmax,izmin,izmax,izmin2,izmax2);
+    if(!retcode) return 0.;
+    for(Int_t iz=izmin; iz<=izmax;iz++){
+      totChan+=1;
+      if(GetChannelStatus(imod,iz,0)==kFALSE) badChan+=1.;
+    }
+    if(izmin2!=-1 && izmax2!=-1){
+      for(Int_t iz=izmin2; iz<=izmax2;iz++){
+       totChan+=1;
+       if(GetChannelStatus(imod,iz,0)==kFALSE) badChan+=1.;
+      }
+    }
+  }
+  if(totChan==0.) return 0.;
+  else return badChan/totChan;
+}

diff --git a/ITS/AliITSChannelStatus.h b/ITS/AliITSChannelStatus.h
index d987a3eb0ecc4c1997fdc0d02b3e6c1e961d0e6d..1d278a98755ba5272f6d51f8ad11adceb85aaf49 100644 (file)
--- a/ITS/AliITSChannelStatus.h
+++ b/ITS/AliITSChannelStatus.h
@@ -35,12 +35,8 @@ class AliITSChannelStatus : public TObject {
 
   Bool_t GetChannelStatus(Int_t imod, Int_t iz, Int_t ix=0) const;
 
-  Bool_t AnyBadInRoad(Int_t /*imod*/, Float_t /*zlocmin*/, Float_t /*zlocmax*/, Float_t /*xlocmin*/, Float_t /*xlocmax*/) const{
-    return kFALSE;
-  }
-  Float_t FractionOfBadInRoad(Int_t /*imod*/, Float_t /*zlocmin*/, Float_t /*zlocmax*/, Float_t /*xlocmin*/, Float_t /*xlocmax*/) const{
-    return 0.;
-  }
+  Bool_t AnyBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const;
+  Float_t FractionOfBadInRoad(Int_t imod, Float_t zlocmin, Float_t zlocmax, Float_t xlocmin, Float_t xlocmax) const;
 
   Int_t GetNSPDChannels()const {return fSPDChannelStatus->GetNbits();}
   Int_t GetNSDDChannels()const {return fSDDChannelStatus->GetNbits();}
@@ -49,6 +45,8 @@ class AliITSChannelStatus : public TObject {
   void InitDefaults();
   void InitFromOCDB(TObjArray* deadArrSPD, TObjArray* noisArrSPD, TObjArray* calArrSDD);
   Bool_t CheckBounds(Int_t imod, Int_t iz, Int_t ix=0) const;
+  Bool_t 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;
+  Bool_t 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;
   enum {kSPDModules=240};
   enum {kSPDNpzPerModule=160};
   enum {kSPDNpxPerModule=256};