Fix coding convention violations
authorprino <prino@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Mar 2011 11:58:15 +0000 (11:58 +0000)
committerprino <prino@f7af4fe6-9843-0410-8265-dc069ae4e863>
Tue, 8 Mar 2011 11:58:15 +0000 (11:58 +0000)
ITS/AliITSDCSDataSDD.cxx
ITS/AliITSOnlineSDDBase.cxx
ITS/AliITSOnlineSDDBase.h
ITS/AliITSOnlineSDDCMN.cxx
ITS/AliITSOnlineSDDTP.cxx
ITS/AliITSOnlineSDDTP.h
ITS/AliITSresponseSDD.h
ITS/AliITSsegmentationSDD.cxx

index 14b9162..30d34b5 100644 (file)
@@ -61,7 +61,9 @@ fStatusSetPoints(0)
 
 void AliITSDCSDataSDD::SetNPointsTempLeft( Int_t npts )
 {
+  // dimension arrays with left side temperatures
   //
+
   if( npts < fTempLeftSetPoints)
   {                     // Cannot resize arrays - some elements would be lost
     AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_L)"); 
@@ -80,7 +82,9 @@ void AliITSDCSDataSDD::SetNPointsTempLeft( Int_t npts )
 
 void AliITSDCSDataSDD::SetNPointsTempRight( Int_t npts )
 {
+  // dimension arrays with right side temperatures
   //
+
   if( npts < fTempRightSetPoints)
   {                     // Cannot resize arrays - some elements would be lost
     AliWarning("Attemp to reduce size of full array (SDD DCS _TEMP_R)");
@@ -99,7 +103,9 @@ void AliITSDCSDataSDD::SetNPointsTempRight( Int_t npts )
 
 void AliITSDCSDataSDD::SetNPointsHV( Int_t npts )
 {
+  // dimension arrays with HV values
   //
+
   if( npts < fHVSetPoints)
   {                     // Cannot resize arrays - some elements would be lost
     AliWarning("Attemp to reduce size of full array (SDD DCS _HV)");
@@ -118,7 +124,9 @@ void AliITSDCSDataSDD::SetNPointsHV( Int_t npts )
 
 void AliITSDCSDataSDD::SetNPointsMV( Int_t npts )
 {
+  // dimension arrays with   MV values
   //
+
   if( npts < fMVSetPoints)
   {                     // Cannot resize arrays - some elements would be lost
     AliWarning("Attemp to reduce size of full array (SDD DCS _MV)");
@@ -137,7 +145,9 @@ void AliITSDCSDataSDD::SetNPointsMV( Int_t npts )
 
 void AliITSDCSDataSDD::SetNPointsStatus( Int_t npts )
 {
+  // dimension arrays withn DCS channel status
   //
+
   if( npts < fStatusSetPoints)
   {                     // Cannot resize arrays - some elements would be lost
     AliWarning("Attemp to reduce size of full array (SDD DCS Status)");
@@ -156,7 +166,9 @@ void AliITSDCSDataSDD::SetNPointsStatus( Int_t npts )
 //---------------------------------------------------------------------------
 void AliITSDCSDataSDD::SetValueTempLeft(Int_t time, Float_t temperature )
 {
+  // insert a value for left temperature data point
   //
+
    if( fTempLeftMaxPoints == fTempLeftSetPoints )
     SetNPointsTempLeft( fTempLeftMaxPoints + AUTORESIZE );
                         // Enlarges arrays if necessary
@@ -199,7 +211,9 @@ void AliITSDCSDataSDD::SetValueTempLeft(Int_t time, Float_t temperature )
 
 void AliITSDCSDataSDD::SetValueTempRight(Int_t time, Float_t temperature )
 {
+  // insert a value for right temperature data point
   //
+
    if( fTempRightMaxPoints == fTempRightSetPoints )
     SetNPointsTempRight( fTempRightMaxPoints + AUTORESIZE );
                         // Enlarges arrays if necessary
@@ -242,7 +256,9 @@ void AliITSDCSDataSDD::SetValueTempRight(Int_t time, Float_t temperature )
 
 void AliITSDCSDataSDD::SetValueHV(Int_t time, Float_t voltage )
 {
+  // insert a value for HV data point
   //
+
    if( fHVMaxPoints == fHVSetPoints )
     SetNPointsHV( fHVMaxPoints + AUTORESIZE );
                         // Enlarges arrays if necessary
@@ -282,7 +298,9 @@ void AliITSDCSDataSDD::SetValueHV(Int_t time, Float_t voltage )
 
 void AliITSDCSDataSDD::SetValueMV(Int_t time, Float_t voltage )
 {
+  // insert a value for MV data point
   //
+
    if( fMVMaxPoints == fMVSetPoints )
     SetNPointsMV( fMVMaxPoints + AUTORESIZE );
                         // Enlarges arrays if necessary
@@ -325,7 +343,9 @@ void AliITSDCSDataSDD::SetValueMV(Int_t time, Float_t voltage )
 
 void AliITSDCSDataSDD::SetValueStatus(Int_t time, Char_t status )
 {
+  // insert a value for channel status
   //
+
    if( fStatusMaxPoints == fStatusSetPoints )
     SetNPointsStatus( fStatusMaxPoints + AUTORESIZE );
                         // Enlarges arrays if necessary
index 25865ba..4dfdf52 100644 (file)
@@ -62,7 +62,7 @@ AliITSOnlineSDDBase::~AliITSOnlineSDDBase(){
 }
 //______________________________________________________________________
 void AliITSOnlineSDDBase::Reset(){
-  //
+  // reset all counters
   fNEvents=0;
   for(Int_t i=0;i<fgkNAnodes;i++){
     fGoodAnode[i]=1;
@@ -73,7 +73,7 @@ void AliITSOnlineSDDBase::Reset(){
 }
 //______________________________________________________________________
 void  AliITSOnlineSDDBase::ValidateAnodes(){
-  //
+  // tag good/bad channels
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     fGoodAnode[ian]=1;
     Float_t basel=GetAnodeBaseline(ian);
@@ -89,7 +89,8 @@ void  AliITSOnlineSDDBase::ValidateAnodes(){
 
 //______________________________________________________________________
 void AliITSOnlineSDDBase::AddEvent(TH2F* hrawd){
-  // 
+  // analyzes one event and adds its ontribution to the various counters
+
   fNEvents++;
   const Int_t kTimeBins=fLastGoodTB+1;
   Float_t sum[fgkNAnodes];
@@ -168,7 +169,7 @@ Float_t AliITSOnlineSDDBase::GetMinimumBaseline() const {
 }
 //______________________________________________________________________
 Float_t AliITSOnlineSDDBase::CalcMeanRawNoise() const{
-  //
+  // compute mean value of raw noise
   Float_t meanns=0.;
   Int_t cnt=0;
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
@@ -181,7 +182,10 @@ Float_t AliITSOnlineSDDBase::CalcMeanRawNoise() const{
 }
 //______________________________________________________________________
 void AliITSOnlineSDDBase::WriteToASCII(){
-  //
+  // writes parameters of each channel into an ASCII file 
+  // to be then read in the successive step for common mode noise
+  // correction (AliITSOnlineSDDCMN)
+
   TString outfilnam;
   Float_t basMin,basMax;
   GetMinAndMaxBaseline(basMin,basMax);
index a66c8b4..a315829 100644 (file)
@@ -40,12 +40,7 @@ class AliITSOnlineSDDBase : public AliITSOnlineSDD {
   }
   void GetMinAndMaxBaseline(Float_t &basMin, Float_t &basMax) const;
   Float_t GetMinimumBaseline() const;
-  Float_t GetAnodeRawNoise(Int_t iAnode) const{
-    Float_t noise2=0.;
-    if(fNEvents>0) noise2=fSumRawNoise[iAnode]/fNEvents-fSumBaseline[iAnode]*fSumBaseline[iAnode]/fNEvents/fNEvents;
-    if(noise2>0.) return TMath::Sqrt(noise2);
-    else return 0;
-  }
+  Float_t GetAnodeRawNoise(Int_t iAnode) const;
 
   Int_t CountGoodAnodes() const{
     Int_t nGdAn=0;
@@ -81,4 +76,13 @@ class AliITSOnlineSDDBase : public AliITSOnlineSDD {
 
   ClassDef(AliITSOnlineSDDBase,2);
 };
+
+inline Float_t AliITSOnlineSDDBase::GetAnodeRawNoise(Int_t iAnode) const{
+  // compute raw noise for given anode
+  Float_t noise2=0.;
+  if(fNEvents>0) noise2=fSumRawNoise[iAnode]/fNEvents-fSumBaseline[iAnode]*fSumBaseline[iAnode]/fNEvents/fNEvents;
+  if(noise2>0.) return TMath::Sqrt(noise2);
+  else return 0;
+}
+
 #endif
index f31cce3..982843d 100644 (file)
@@ -53,7 +53,7 @@ AliITSOnlineSDDCMN::~AliITSOnlineSDDCMN(){
 }
 //______________________________________________________________________
 void AliITSOnlineSDDCMN::Reset(){
-  //
+  // Reset counters
   fNEvents=0;
   for(Int_t i=0;i<fgkNAnodes;i++){
     fGoodAnode[i]=1;
@@ -97,7 +97,7 @@ void AliITSOnlineSDDCMN::ReadBaselines(){
 }
 //______________________________________________________________________
 void  AliITSOnlineSDDCMN::ValidateAnodes(){
-  //
+  // Tag good/bad anodes
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     if(!fGoodAnode[ian]) continue;
     if(GetAnodeCorrNoise(ian)>fMaxCorrNoise || GetAnodeCorrNoise(ian)<fMinCorrNoise) fGoodAnode[ian]=0;
@@ -107,7 +107,8 @@ void  AliITSOnlineSDDCMN::ValidateAnodes(){
 
 //______________________________________________________________________
 TH2F* AliITSOnlineSDDCMN::GetCleanEvent(TH2F* hrawd) const {
-  // 
+  // Fills an histogram with counts corrected for common mode noise
+
   TH2F* hcorrd=new TH2F("hcorrd","",hrawd->GetNbinsX(),hrawd->GetXaxis()->GetXmin(),hrawd->GetXaxis()->GetXmax(),hrawd->GetNbinsY(),hrawd->GetYaxis()->GetXmin(),hrawd->GetYaxis()->GetXmax());
   for(Int_t itb=fFirstGoodTB;itb<=fLastGoodTB;itb++){
     Float_t sumEven=0., sumOdd=0.;
@@ -135,7 +136,8 @@ TH2F* AliITSOnlineSDDCMN::GetCleanEvent(TH2F* hrawd) const {
 }
 //______________________________________________________________________
 void AliITSOnlineSDDCMN::AddEvent(TH2F* hrawd){
-  // 
+  // analyzes one event and adds its ontribution to the various counters
+
   fNEvents++;
   TH2F* hcorrd=GetCleanEvent(hrawd);
 
@@ -154,7 +156,8 @@ void AliITSOnlineSDDCMN::AddEvent(TH2F* hrawd){
 }
 //______________________________________________________________________
 Float_t AliITSOnlineSDDCMN::CalcMeanNoise() const{
-  //
+  // compute average noise
+
   Float_t meanns=0.;
   Int_t cnt=0;
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
@@ -167,7 +170,9 @@ Float_t AliITSOnlineSDDCMN::CalcMeanNoise() const{
 }
 //______________________________________________________________________
 void AliITSOnlineSDDCMN::WriteToASCII(){
-  //
+  // writes parameters of each channel into an ASCII file 
+  // to be then read by the PULSER DA (AliITSOnlineSDDTP)
+
   TString outfilnam;
   outfilnam.Form("SDDbase_step2_ddl%02dc%02d_sid%d.data",fDDL,fCarlos,fSide);
   FILE* outf=fopen(outfilnam.Data(),"w");
@@ -181,7 +186,7 @@ void AliITSOnlineSDDCMN::WriteToASCII(){
 
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetBaselineAnodeHisto() const {
-  //
+  // produce histogram with baseline vs. anode number
   TString hisnam;  
   hisnam.Form("hbase%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -192,7 +197,7 @@ TH1F* AliITSOnlineSDDCMN::GetBaselineAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetRawNoiseAnodeHisto() const {
-  //
+  // produce histogram with raw noise vs. anode number
   TString hisnam;  
   hisnam.Form("hnois%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -203,7 +208,7 @@ TH1F* AliITSOnlineSDDCMN::GetRawNoiseAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetCorrNoiseAnodeHisto() const {
-  //
+  // produce histogram with corrected noise vs. anode number
   TString hisnam;  
   hisnam.Form("hcorn%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -214,7 +219,7 @@ TH1F* AliITSOnlineSDDCMN::GetCorrNoiseAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetCMNCoefAnodeHisto() const {
-//
+  // produce histogram with coefficients for common mode noise subtraction
   TString hisnam;  
   hisnam.Form("hcmn%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -225,7 +230,7 @@ TH1F* AliITSOnlineSDDCMN::GetCMNCoefAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetStatusAnodeHisto() const {
-//
+  // produce histogram with status bit of each anode
   TString hisnam;  
   hisnam.Form("hgood%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -236,7 +241,7 @@ TH1F* AliITSOnlineSDDCMN::GetStatusAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetBaselineHisto() const {
-  //
+  // produce histogram with baseline distribution
   TString hisnam;  
   hisnam.Form("hdbd%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",100,0.,150.);
@@ -247,7 +252,7 @@ TH1F* AliITSOnlineSDDCMN::GetBaselineHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetRawNoiseHisto() const {
-  //
+  // produce histogram with raw noise distribution
   TString hisnam;  
   hisnam.Form("hdnd%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",100,0.,8.);
@@ -258,7 +263,7 @@ TH1F* AliITSOnlineSDDCMN::GetRawNoiseHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDCMN::GetCorrNoiseHisto() const {
-  //
+  // produce histogram with corrected noise distribution
   TString hisnam;  
   hisnam.Form("hdcd%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",100,0.,8.);
@@ -269,7 +274,7 @@ TH1F* AliITSOnlineSDDCMN::GetCorrNoiseHisto() const {
 }
 //______________________________________________________________________
 Bool_t AliITSOnlineSDDCMN::WriteToROOT(TFile *fil){
-  //
+  // writes output into a root file
   if(fil==0){ 
     AliWarning("Invalid pointer to ROOT file");
     return kFALSE;    
index ea8461d..63c8fd5 100644 (file)
@@ -51,7 +51,7 @@ AliITSOnlineSDDTP::~AliITSOnlineSDDTP(){
 }
 //______________________________________________________________________
 void AliITSOnlineSDDTP::Reset(){
-  //
+  // reset all counters
   for(Int_t i=0;i<fgkNAnodes;i++){
     fNEvents[i]=0;
     fGoodAnode[i]=1;
@@ -67,7 +67,7 @@ void AliITSOnlineSDDTP::Reset(){
 
 //______________________________________________________________________
 void AliITSOnlineSDDTP::AddEvent(TH2F* hrawd){
-  // 
+  // analyzes current event and sum its contribution to the various counters
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
     Float_t auxmax=0.;
     Int_t auxtb=0;
@@ -131,7 +131,7 @@ Bool_t AliITSOnlineSDDTP::IsModuleGood() const{
 }
 //______________________________________________________________________
 void AliITSOnlineSDDTP::ValidateAnodes(){
-  //
+  // tag good/bad channels
   Float_t meang,rmsg;
   StatGain(meang,rmsg);
   Float_t lowlim=meang-fNSigmaGain*rmsg;
@@ -145,8 +145,8 @@ void AliITSOnlineSDDTP::ValidateAnodes(){
 
 
 //______________________________________________________________________
-void AliITSOnlineSDDTP::StatGain(Float_t &mean, Float_t  &rms){
-  //
+void AliITSOnlineSDDTP::StatGain(Float_t &mean, Float_t  &rms) const {
+  // compute average gain and rms
   Float_t sum=0.,sumq=0.;
   Int_t cnt=0;
   for(Int_t ian=0;ian<fgkNAnodes;ian++){
@@ -171,7 +171,9 @@ void AliITSOnlineSDDTP::StatGain(Float_t &mean, Float_t  &rms){
 
 //______________________________________________________________________
 void AliITSOnlineSDDTP::WriteToASCII(){
-  //
+  // writes parameters of each channel into an ASCII file 
+  // to be sent to FXS by the DA and processed by the SHUTTLE
+
   TString outfilnam;
   outfilnam.Form("SDDbase_ddl%02dc%02d_sid%d.data",fDDL,fCarlos,fSide);
   FILE* outf=fopen(outfilnam.Data(),"w");
@@ -185,7 +187,7 @@ void AliITSOnlineSDDTP::WriteToASCII(){
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDTP::GetBaselineAnodeHisto() const {
-  //
+  // produce histogram with baseline vs. anode number
   TString hisnam;  
   hisnam.Form("hbase%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -196,7 +198,7 @@ TH1F* AliITSOnlineSDDTP::GetBaselineAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDTP::GetRawNoiseAnodeHisto() const {
-  //
+  // produce histogram with raw noise vs. anode number
   TString hisnam;  
   hisnam.Form("hnois%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -207,7 +209,7 @@ TH1F* AliITSOnlineSDDTP::GetRawNoiseAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDTP::GetCorrNoiseAnodeHisto() const {
-  //
+  // produce histogram with corrected noise vs. anode number
   TString hisnam;  
   hisnam.Form("hcorn%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -218,7 +220,7 @@ TH1F* AliITSOnlineSDDTP::GetCorrNoiseAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDTP::GetCMNCoefAnodeHisto() const {
-//
+  // produce histogram with coefficients for common mode noise subtraction
   TString hisnam;  
   hisnam.Form("hcmn%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -229,7 +231,7 @@ TH1F* AliITSOnlineSDDTP::GetCMNCoefAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDTP::GetStatusAnodeHisto() const {
-//
+  // produce histogram with status bit of each anode
   TString hisnam;  
   hisnam.Form("hgood%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -240,7 +242,7 @@ TH1F* AliITSOnlineSDDTP::GetStatusAnodeHisto() const {
 }
 //______________________________________________________________________
 TH1F* AliITSOnlineSDDTP::GetGainAnodeHisto() const {
-//
+  // produce histogram with gain vs. anode number
   TString hisnam;  
   hisnam.Form("hgain%02dc%02ds%d",fDDL,fCarlos,fSide);
   TH1F* h=new TH1F(hisnam.Data(),"",256,-0.5,255.5);
@@ -251,7 +253,7 @@ TH1F* AliITSOnlineSDDTP::GetGainAnodeHisto() const {
 }
 //______________________________________________________________________
 Bool_t AliITSOnlineSDDTP::WriteToROOT(TFile *fil){
-  //
+  // writes output into a root file
   if(fil==0){ 
     AliWarning("Invalid pointer to ROOT file");
     return kFALSE;    
index 2f42992..0fef276 100644 (file)
@@ -43,7 +43,7 @@ class AliITSOnlineSDDTP : public AliITSOnlineSDD {
     if(fNEvents[iAnode]>0) return fSumTPPeak[iAnode]/fNEvents[iAnode]/fDAC;
     else return 0;
   }
-  void StatGain(Float_t &mean, Float_t  &rms);
+  void StatGain(Float_t &mean, Float_t  &rms) const;
   void WriteToASCII();
   Bool_t WriteToROOT(TFile *fil);
 
index 40f5f82..187a159 100644 (file)
@@ -46,11 +46,7 @@ class AliITSresponseSDD : public TObject {
   virtual void SetHalfLadderATimeZero(Int_t lay, Int_t lad, Float_t tzero);
   virtual void SetHalfLadderCTimeZero(Int_t lay, Int_t lad, Float_t tzero);
   virtual void SetModuleTimeZero(Int_t modIndex, Float_t tzero){
-    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
-      AliError(Form("SDD module number %d out of range",modIndex));
-      return;
-    }
-    fTimeZero[modIndex-kNSPDmods]=tzero;
+    if(CheckModuleIndex(modIndex)) fTimeZero[modIndex-kNSPDmods]=tzero;
   }
 
   virtual void SetDeltaVDrift(Int_t modIndex, Float_t dv, Bool_t rightSide=kFALSE) {
@@ -72,46 +68,29 @@ class AliITSresponseSDD : public TObject {
   virtual void SetTimeOffset(Float_t to){fTimeOffset = to;}
   virtual Float_t GetTimeOffset()const {return fTimeOffset;}
   virtual Float_t GetTimeZero(Int_t modIndex) const {
-    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
-      AliError(Form("SDD module number %d out of range",modIndex));
-      return 0.;
-    }
-    return fTimeZero[modIndex-kNSPDmods];
+    if(CheckModuleIndex(modIndex)) return fTimeZero[modIndex-kNSPDmods];
+    else return 0.;
   }
 
   virtual void SetADC2keV(Float_t conv){fADC2keV=conv;}
   virtual Float_t GetADC2keV()const {return fADC2keV;}
   virtual void SetADCtokeV(Int_t modIndex, Float_t conv){
-    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
-      AliError(Form("SDD module number %d out of range",modIndex));
-      return;
-    }
-    fADCtokeV[modIndex-kNSPDmods]=conv;
+    if(CheckModuleIndex(modIndex)) fADCtokeV[modIndex-kNSPDmods]=conv;
   }
   virtual Float_t GetADCtokeV(Int_t modIndex) const {
-    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
-      AliError(Form("SDD module number %d out of range",modIndex));
-      return 0.;
-    }
-    return fADCtokeV[modIndex-kNSPDmods];
+    if(CheckModuleIndex(modIndex)) return fADCtokeV[modIndex-kNSPDmods];
+    else return 0.;
   }
 
   virtual void SetChargevsTime(Float_t slope){fChargevsTime=slope;}
   virtual Float_t GetChargevsTime()const {return fChargevsTime;}
 
   virtual void SetADCvsDriftTime(Int_t modIndex, Float_t slope){
-    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
-      AliError(Form("SDD module number %d out of range",modIndex));
-      return;
-    }
-    fADCvsDriftTime[modIndex-kNSPDmods]=slope;
+    if(CheckModuleIndex(modIndex)) fADCvsDriftTime[modIndex-kNSPDmods]=slope;
   }
   virtual Float_t GetADCvsDriftTime(Int_t modIndex) const {
-    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){
-      AliError(Form("SDD module number %d out of range",modIndex));
-      return 0.;
-    }
-    return fADCvsDriftTime[modIndex-kNSPDmods];
+    if(CheckModuleIndex(modIndex)) return fADCvsDriftTime[modIndex-kNSPDmods];
+    else return 0.;
   }
 
   static Float_t DefaultADC2keV() {return fgkADC2keVDefault;}
@@ -132,6 +111,10 @@ class AliITSresponseSDD : public TObject {
     return (rightSide && IsVDCorr2Side()) ? ind + kNSDDmods : ind;
   }
 
+  virtual Bool_t CheckModuleIndex(Int_t modIndex) const {
+    if(modIndex<kNSPDmods || modIndex>=kNSPDmods+kNSDDmods){ AliError(Form("SDD module number %d out of range",modIndex)); return kFALSE;}
+    return kTRUE;
+  }
 
  protected:
 
index b870e79..f50fa6f 100644 (file)
@@ -213,6 +213,9 @@ Int_t AliITSsegmentationSDD::GetChipFromLocal(Float_t xloc, Float_t zloc) const
 }
 //----------------------------------------------------------------------
 Int_t AliITSsegmentationSDD::GetChipsInLocalWindow(Int_t* array, Float_t zmin, Float_t zmax, Float_t xmin, Float_t xmax) const {
+  // returns the numbers of the chips that read channels in a given region
+  // of the module defined in local coordinates by zmin-zmax, xmin-max
+
   Int_t nChipInW = 0;
   Float_t zminDet=-fDz*fgkMicron2Cm/2.;
   Float_t zmaxDet=fDz*fgkMicron2Cm/2.;