Coverity warnings
[u/mrichter/AliRoot.git] / ITS / AliITSCalibrationSDD.cxx
index a8bc37b..8704e18 100644 (file)
@@ -1,5 +1,5 @@
 /**************************************************************************
- * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
+ * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
  *                                                                        *
  * Author: The ALICE Off-line Project.                                    *
  * Contributors are mentioned in the code where appropriate.              *
@@ -13,6 +13,7 @@
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
+/* $Id$ */
 
 #include <Riostream.h>
 #include <TRandom.h>
 //                                                  //
 //////////////////////////////////////////////////////
 
-const Double_t AliITSCalibrationSDD::fgkTemperatureDefault = 296.;
-const Double_t AliITSCalibrationSDD::fgkNoiseDefault = 10.;
-const Double_t AliITSCalibrationSDD::fgkGainDefault = 1.;
-const Double_t AliITSCalibrationSDD::fgkBaselineDefault = 20.;
-const Double_t AliITSCalibrationSDD::fgkMinValDefault  = 4;
+const Float_t AliITSCalibrationSDD::fgkTemperatureDefault = 296.;
+const Float_t AliITSCalibrationSDD::fgkNoiseDefault = 2.38;
+const Float_t AliITSCalibrationSDD::fgkGainDefault = 1.;
+const Float_t AliITSCalibrationSDD::fgkBaselineDefault = 20.;
 //______________________________________________________________________
 ClassImp(AliITSCalibrationSDD)
 
-AliITSCalibrationSDD::AliITSCalibrationSDD(){
+AliITSCalibrationSDD::AliITSCalibrationSDD():
+AliITSCalibration(),
+fZeroSupp(kTRUE),
+fAMAt20MHz(kFALSE),
+fDeadChips(0),
+fDeadChannels(0),
+fIsBad(kFALSE),
+fBadChannels(),
+fMapAW0(0),
+fMapAW1(0),
+fMapTW0(0),
+fMapTW1(0),
+fDrSpeed0(0),
+fDrSpeed1(0)
+{
   // default constructor
 
   SetDeadChannels();
-  fBadChannels.Set(fDeadChannels);
   for(Int_t ian=0;ian<fgkWings*fgkChannels*fgkChips;ian++){
     fBaseline[ian]=fgkBaselineDefault;
     fNoise[ian]=fgkNoiseDefault;
+    fGain[ian]=1.;
     SetNoiseAfterElectronics(ian);
   }
   for(Int_t iw=0;iw<fgkWings;iw++){
+    SetZSLowThreshold(iw);
+    SetZSHighThreshold(iw);
     for(Int_t icp=0;icp<fgkChips;icp++){
-      for(Int_t ich=0;ich<fgkChannels;ich++)
-       fGain[iw][icp][ich]=1.;
+      Int_t chipindex=iw*fgkChips+icp;
+      fIsChipBad[chipindex]=kFALSE;
     }
   }
-  SetThresholds(fgkMinValDefault,0.);
   SetTemperature(fgkTemperatureDefault);
   SetDataType();
-  for(Int_t i=0;i<fgkChips*fgkChannels;i++){
-    for(Int_t j=0;j<fgkMapTimeNBin;j++){
-      fMapA[i][j]=0;
-      fMapT[i][j]=0;
-    }
-  }
  }
 //______________________________________________________________________
-AliITSCalibrationSDD::AliITSCalibrationSDD(const char *dataType){
+AliITSCalibrationSDD::AliITSCalibrationSDD(const char *dataType):
+AliITSCalibration(),
+fZeroSupp(kTRUE),
+fAMAt20MHz(kFALSE),
+fDeadChips(0),
+fDeadChannels(0),
+fIsBad(kFALSE),
+fBadChannels(),
+fMapAW0(0),
+fMapAW1(0),
+fMapTW0(0),
+fMapTW1(0),
+fDrSpeed0(0),
+fDrSpeed1(0)
+{
   // constructor
 
   SetDeadChannels();
-  fBadChannels.Set(fDeadChannels);
   for(Int_t ian=0;ian<fgkWings*fgkChannels*fgkChips;ian++){
     fBaseline[ian]=fgkBaselineDefault;
-      fNoise[ian]=fgkNoiseDefault;
-      SetNoiseAfterElectronics(ian);
+    fNoise[ian]=fgkNoiseDefault;
+    fGain[ian]=1.;
+    SetNoiseAfterElectronics(ian);
   }  
   for(Int_t iw=0;iw<fgkWings;iw++){
+    SetZSLowThreshold(iw);
+    SetZSHighThreshold(iw);
     for(Int_t icp=0;icp<fgkChips;icp++){
-      for(Int_t ich=0;ich<fgkChannels;ich++)
-       fGain[iw][icp][ich]=1.;
+      Int_t chipindex=iw*fgkChips+icp;
+      fIsChipBad[chipindex]=kFALSE;
     }
   }
 
-  SetThresholds(fgkMinValDefault,0.);
   SetTemperature(fgkTemperatureDefault);
   SetDataType(dataType);
-  for(Int_t i=0;i<fgkChips*fgkChannels;i++){
-    for(Int_t j=0;j<fgkMapTimeNBin;j++){
-      fMapA[i][j]=0;
-      fMapT[i][j]=0;
-    }
-  }
-
  }
-//______________________________________________________________________
-AliITSCalibrationSDD::AliITSCalibrationSDD(const AliITSCalibrationSDD &ob) : AliITSCalibration(ob) {
-  // Copy constructor
-  // Copies are not allowed. The method is protected to avoid misuse.
-  Error("AliITSCalibrationSDD","Copy constructor not allowed\n");
-}
-
-//______________________________________________________________________
-AliITSCalibrationSDD& AliITSCalibrationSDD::operator=(const AliITSCalibrationSDD& /* ob */){
-  // Assignment operator
-  // Assignment is not allowed. The method is protected to avoid misuse.
-  Error("= operator","Assignment operator not allowed\n");
-  return *this;
+//_____________________________________________________________________
+AliITSCalibrationSDD::~AliITSCalibrationSDD(){
+
+  //destructor
+  if(fMapAW0) delete fMapAW0;
+  if(fMapAW1) delete fMapAW1;
+  if(fMapTW0) delete fMapTW0;
+  if(fMapTW1) delete fMapTW1;
+  if(fDrSpeed0) delete fDrSpeed0;
+  if(fDrSpeed1) delete fDrSpeed1;
 }
 
 //______________________________________________________________________
-void AliITSCalibrationSDD::GiveCompressParam(Int_t  cp[8],Int_t ian) const {
+void AliITSCalibrationSDD::GiveCompressParam(Int_t  cp[4]) const {
   // give compression param
-
-  cp[0]=(Int_t) fBaseline[ian];
-  cp[1]=(Int_t) fBaseline[ian];
-  cp[2]=(Int_t)(2.*fNoiseAfterEl[ian] + 0.5);
-  cp[3]=(Int_t)(2.*fNoiseAfterEl[ian] + 0.5);
-  cp[4]=0;
-  cp[5]=0;
-  cp[6]=0;
-  cp[7]=0;
+  cp[0]=fZSTH[0];
+  cp[1]=fZSTL[0];
+  cp[2]=fZSTH[1];
+  cp[3]=fZSTL[1];
 }
 //_____________________________________________________________________
 void AliITSCalibrationSDD::SetBadChannel(Int_t i,Int_t anode){
   //Set bad anode (set gain=0 for these channels);
 
-  if(anode<0 || anode >fgkChannels*fgkChips*fgkWings-1)AliError("Wrong anode number");
-  Int_t wing=0;
-  Int_t chip,channel;
-  chip=anode/fgkChannels;
-  channel=anode-(chip*fgkChannels);
-  if(anode>=fgkChips*fgkChannels) wing=1;
-  if(wing==1)chip-=fgkChips;
+  if(anode<0 || anode >fgkChannels*fgkChips*fgkWings-1){
+    AliError("Wrong anode number");
+    return;
+  }
   fBadChannels[i]=anode;
-  fGain[wing][chip][channel]=0;
+  fGain[anode]=0;
 }
-//_____________________________________________________________________
-Bool_t AliITSCalibrationSDD::IsBadChannel(Int_t anode){
-  //returns kTRUE if the anode i (0-512) has fGain=0
-  if(anode<0 || anode >fgkChannels*fgkChips*fgkWings-1)AliError("Wrong anode number");
-  Int_t wing=0;
-  Int_t chip,channel;
-  chip=anode/fgkChannels;
-  channel=anode-(chip*fgkChannels);
-  if(anode>=fgkChips*fgkChannels) wing=1;
-  if(wing==1)chip-=fgkChips;
-  if(fGain[wing][chip][channel]==0) return kTRUE;
-  else return kFALSE;
-} 
-/*
 //______________________________________________________________________
-void AliITSCalibrationSDD::SetDeadChannels(Int_t nchip, Int_t nchan){
-  // Set fGain to zero to simulate a random distribution of 
-  // dead modules, dead chips and single dead channels
-
-  for( Int_t m=0; m<fgkWings; m++ ) 
-    for( Int_t n=0; n<fgkChips; n++ ) 
-      for( Int_t p=0; p<fgkChannels; p++ ) 
-       fGain[m][n][p] = 1.;
-                 
-  //fDeadModules  = nmod;  
-  fDeadChips    = nchip;  
-  fDeadChannels = nchan; 
-  fBadChannels.Set(fDeadChannels);  
-  // nothing to do
-  //if( nmod == 0 && nchip == 0 && nchan == 0 ) return;
-
-  if( nchip == 0 && nchan == 0 ) return;
-  // if( nmod < 0 || nmod > fgkModules ) 
-  //  { 
-  //    cout << "Wrong number of dead modules: " << nmod << endl; 
-  //    return; 
-  //  }
-  
-  Int_t nmax = fgkWings*fgkChips; 
-  if( nchip < 0 || nchip > nmax ) 
-    { 
-      cout << "Wrong number of dead chips: " << nchip << endl; 
-      return; 
-    }
-  nmax = (fgkWings*fgkChips - nchip)*fgkChannels; 
-  if( nchan < 0 || nchan > nmax ) 
-    { 
-      cout << "Wrong number of dead channels: " << nchan << endl; 
-      return; 
-    }
-  
-  TRandom *gran = new TRandom();
-  //  cout << "chips" << endl;
-  Int_t * chip     = new Int_t[nchip];
-  Int_t i = 0;
-  while( i < nchip ) 
-    {
-      Int_t wing = (Int_t) (fgkWings*gran->Uniform() + 1.);
-      if( wing <=0 || wing > fgkWings ) Error("SetDeadChannels","Wrong wing");
-        
-      Int_t chi = (Int_t) (fgkChips*gran->Uniform() + 1.);
-      if( chi <=0 || chi > fgkChips ) Error("SetDeadChannels","Wrong chip:%d\n",chi);
-      i++;
-      chip[i-1] = chi; 
-      for( Int_t m=0; m<fgkChannels; m++ ) 
-       fGain[wing-1][chi-1][m] = 0.;
-    }
-
-  Int_t * channel      = new Int_t[nchan];
-  Int_t * channelChip = new Int_t[nchan];
-  i = 0;
-  while( i < nchan ) 
-    {
-      Int_t k; //loop variable
-      Int_t wing = (Int_t) (fgkWings*gran->Uniform() + 1.);
-      if( wing <=0 || wing > fgkWings ) Error("SetDeadChannels","Wrong wing:%d\n",wing);
-      Int_t chipp = (Int_t) (fgkChips*gran->Uniform() + 1.);
-      if( chipp <=0 || chipp > fgkChips ) Error("SetDeadChannels","Wrong chip:%d",chipp);
-      Int_t flagChip = 0;
-      for( k=0; k<nchip; k++) 
-       if( chipp == chip[k] ) { 
-         flagChip = 1; break; }
-      if( flagChip == 1 ) continue;
-      i++;
-      channel[i-1] = (Int_t) (fgkChannels*gran->Uniform() + 1.); 
-      if( channel[i-1] <=0 || channel[i-1] > fgkChannels ) 
-       Error("SetDeadChannels","Wrong channel:%d\n",channel[i-1]);
-      channelChip[i-1] = chipp;
-      fGain[wing-1][chipp-1][channel[i-1]-1] = 0.;
-    }
-    
-  delete [] chip;
-  delete [] channel;
-  delete [] channelChip;
+void AliITSCalibrationSDD::GetCorrections(Float_t z, Float_t x, Float_t &devz, Float_t &devx, AliITSsegmentationSDD* seg){
+  //correction of coordinates using the maps stored in the DB
+  Int_t nSide=seg->GetSideFromLocalX(x);
+  devz=0;
+//     if(nSide==0) devz=fMapAW0->GetCorrection(z,x,seg);
+//     else devz=fMapAW1->GetCorrection(z,x,seg);
+  devx=0;
+  if(nSide==0) devx=fMapTW0->GetCorrection(z,x,seg);
+  else devx=fMapTW1->GetCorrection(z,x,seg);
+  return;
 }
-*/
 //______________________________________________________________________
 void AliITSCalibrationSDD::PrintGains() const{
   //
@@ -242,15 +164,11 @@ void AliITSCalibrationSDD::PrintGains() const{
   cout << "**************************************************" << endl;
 
   // Print SDD electronic gains
-  for(Int_t t=0; t<fgkWings;t++)
-    for(Int_t u=0; u<fgkChips;u++)
-      for(Int_t v=0; v<fgkChannels;v++)
-       {
-         if( fGain[t][u][v] != 1.0 )
-           cout << "Gain for wing: " << t+1 << ", Chip " << u+1 << 
-             ", Channel " << v+1 << " = " << fGain[t][u][v] << endl;
-       }
+  for(Int_t ian=0; ian<fgkWings*fgkChips*fgkChannels;ian++){
+    printf("Gain for channel %d = %f\n",ian,fGain[ian]);
+  }
 }
+
 //______________________________________________________________________
 void AliITSCalibrationSDD::Print(){
   // Print SDD response Parameters
@@ -263,7 +181,6 @@ void AliITSCalibrationSDD::Print(){
   cout << "Baseline (ADC units): " << fBaseline[0] << endl;
   cout << "Noise after electronics (ADC units): " << fNoiseAfterEl[0] << endl;
   cout << "Temperature: " << Temperature() << " K " << endl;
-  cout << "Min. Value: " << fMinVal << endl;
   PrintGains();
 
 }