Added functions SetADCpereV, DEvToADC, and IEvToADC, Plus cleanded up things

a bit.

diff --git a/ITS/AliITSresponseSSD.cxx b/ITS/AliITSresponseSSD.cxx
index fee377ab6f2e6fe2b0c5a933ab0e76eac915b600..a35d01a9643b1f80ab7336d7a079c06131da452f 100644 (file)
--- a/ITS/AliITSresponseSSD.cxx
+++ b/ITS/AliITSresponseSSD.cxx
@@ -19,89 +19,77 @@
 #include "AliITSresponseSSD.h"
 #include "AliITSgeom.h"
 
-ClassImp(AliITSresponseSSD)    
-//----------------------------------------------------------
-AliITSresponseSSD::AliITSresponseSSD()
-{
-  // constructor
-  SetDiffCoeff();
-  SetNoiseParam();
-  SetDataType();
-  SetSigmaSpread();
-  SetParamOptions();
-  SetNDetParam();
-  fDetPar = new Float_t[fNPar];
-  if (fNPar==6) {
-    fDetPar[0]=10.;
-    fDetPar[1]=5.;
-    fDetPar[2]=0.02;
-    fDetPar[3]=0.02;
-    fDetPar[4]=0.02;
-    fDetPar[5]=0.03;
-  }
-  
-  
-}
+ClassImp(AliITSresponseSSD)
+
+//______________________________________________________________________
+AliITSresponseSSD::AliITSresponseSSD(){
+    // constructor
 
-//----------------------------------------------------------
-AliITSresponseSSD::~AliITSresponseSSD()
-{
-  // destructor
-  delete [] fDetPar;
-  
+    SetDiffCoeff();
+    SetNoiseParam();
+    SetDataType();
+    SetSigmaSpread();
+    SetParamOptions();
+    SetNDetParam();
+    SetADCpereV();
+    fDetPar = new Float_t[fNPar];
+    if (fNPar==6) {
+       fDetPar[0]=10.;
+       fDetPar[1]=5.;
+       fDetPar[2]=0.02;
+       fDetPar[3]=0.02;
+       fDetPar[4]=0.02;
+       fDetPar[5]=0.03;
+    } // end if
 }
+//______________________________________________________________________
+AliITSresponseSSD::~AliITSresponseSSD(){
+    // destructor
 
-//__________________________________________________________________________
-AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &source){
-  //     Copy Constructor 
-  if(&source == this) return;
-  this->fNPar = source.fNPar;
-  this->fDetPar = source.fDetPar;
-  this->fNoiseP = source.fNoiseP;
-  this->fNoiseN = source.fNoiseN;
-  this->fSigmaP = source.fSigmaP;
-  this->fSigmaN = source.fSigmaN;
-  this->fDiffCoeff = source.fDiffCoeff;
-  this->fOption1 = source.fOption1;
-  this->fOption2 = source.fOption2;
-  this->fDataType = source.fDataType;
-  return;
+    delete [] fDetPar;
 }
+//______________________________________________________________________
+AliITSresponseSSD& AliITSresponseSSD::operator=(const AliITSresponseSSD &src) {
+    // = operator.
+
+    if(&src == this) return *this;
+
+    this->fNPar      = src.fNPar;
+    for(Int_t i=0;i<this->fNPar;i++) this->fDetPar[i] = src.fDetPar[i];
+    this->fNoiseP    = src.fNoiseP;
+    this->fNoiseN    = src.fNoiseN;
+    this->fSigmaP    = src.fSigmaP;
+    this->fSigmaN    = src.fSigmaN;
+    this->fDiffCoeff = src.fDiffCoeff;
+    this->fADCpereV  = src.fADCpereV;
+    this->fOption1   = src.fOption1;
+    this->fOption2   = src.fOption2;
+    this->fDataType  = src.fDataType;
 
+    return *this;
+}
 //_________________________________________________________________________
-AliITSresponseSSD& 
-  AliITSresponseSSD::operator=(const AliITSresponseSSD &source) {
-  //    Assignment operator
-  if(&source == this) return *this;
-  this->fNPar = source.fNPar;
-  this->fDetPar = source.fDetPar;
-  this->fNoiseP = source.fNoiseP;
-  this->fNoiseN = source.fNoiseN;
-  this->fSigmaP = source.fSigmaP;
-  this->fSigmaN = source.fSigmaN;
-  this->fDiffCoeff = source.fDiffCoeff;
-  this->fOption1 = source.fOption1;
-  this->fOption2 = source.fOption2;
-  this->fDataType = source.fDataType;
-  return *this;
+AliITSresponseSSD::AliITSresponseSSD(const AliITSresponseSSD &src) {
+    // copy constructor
+
+    *this = src;
 }
+//______________________________________________________________________
+void AliITSresponseSSD::SetDetParam(Float_t  *par){
+    // set det param
+    Int_t i;
 
-//----------------------------------------------------------
-void AliITSresponseSSD::SetDetParam(Float_t  *par)
-{
-  // set det param
-  Int_t i;
-  for (i=0; i<fNPar; i++) {
-    fDetPar[i]=par[i];
-    //printf("\n CompressPar %d %d \n",i,fCPar[i]);
-    
-  } 
+    for (i=0; i<fNPar; i++) {
+       fDetPar[i]=par[i];
+       //printf("\n CompressPar %d %d \n",i,fCPar[i]);    
+    } // end for i
 }
-void AliITSresponseSSD::GetDetParam(Float_t  *par)
-{
-  // get det param  
-  Int_t i;  
-  for (i=0; i<fNPar; i++) {
-    par[i]=fDetPar[i];
-  }
+//______________________________________________________________________
+void AliITSresponseSSD::GetDetParam(Float_t  *par){
+    // get det param
+    Int_t i;
+
+    for (i=0; i<fNPar; i++) {
+       par[i]=fDetPar[i];
+    } // end for i
 }

diff --git a/ITS/AliITSresponseSSD.h b/ITS/AliITSresponseSSD.h
index 3a427265628d6fa921a5f7a3dade0b28d60ae0a6..350d43427d41304acb2c658eb32748f816c4e4d3 100644 (file)
--- a/ITS/AliITSresponseSSD.h
+++ b/ITS/AliITSresponseSSD.h
@@ -8,100 +8,106 @@ class TString;
 // response for SSD
 
 //-----------------------------
-class AliITSresponseSSD :
-public AliITSresponse {
-
-public:
-  
-  AliITSresponseSSD();
-  virtual ~AliITSresponseSSD();
-  AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
-  AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
-  
-  virtual void    SetDiffCoeff(Float_t p1=0.,Float_t dummy=0.) {
-    // Diffusion coefficient
-    fDiffCoeff=p1;
-  }
-  virtual void    DiffCoeff(Float_t &diffc,Float_t &dummy) {
-    // Get diffusion coefficient
-    diffc= fDiffCoeff;
-  }
-  
-  virtual  void   SetNoiseParam(Float_t np=420., Float_t nn=625.) {
-    // set noise par
-    fNoiseP=np; fNoiseN=nn;
-  }
-  virtual void    GetNoiseParam(Float_t &np, Float_t &nn) {
-    // get noise par
-    np=fNoiseP; nn=fNoiseN;
-  }
-  
-  virtual void    SetParamOptions(const char *opt1="", const char *opt2="") {
-    // parameters: "SetInvalid" to simulate the invalid strips
-    fOption1=opt1; fOption2=opt2;
-  }
-  virtual void    ParamOptions(char *opt1,char *opt2) {
-    // options
-     strcpy(opt1,fOption1.Data());  strcpy(opt2,fOption2.Data());
-  }
-  
-  // Number of parameters to be set
-  // 4 couplings, mean number of invalid strips, RMS of invalid strips
-  virtual  void   SetNDetParam(Int_t npar=6) {
-    // set number of param
-    fNPar=npar;
-  }
-
-  virtual  void   SetDetParam(Float_t *par);
-  
-  // Parameters options
-  virtual Int_t   NDetParam() {
-    // number of param
-    return fNPar;
-  }
-  virtual void    GetDetParam(Float_t *dpar); 
-
-  virtual void    SetDataType(const char *data="simulated") {
-  // Type of data - real or simulated
-    fDataType=data;
-  }
-  virtual const char  *DataType() const {
-    // Get data type
-    return fDataType.Data();
-  } 
+class AliITSresponseSSD : public AliITSresponse {
+
+ public:
+    AliITSresponseSSD();
+    virtual ~AliITSresponseSSD();
+    AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
+    AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
+
+    virtual void    SetDiffCoeff(Float_t p1=0.,Float_t dummy=0.) {
+       // Diffusion coefficient
+       fDiffCoeff=p1;
+    }
+    virtual void    DiffCoeff(Float_t &diffc,Float_t &dummy) {
+       // Get diffusion coefficient
+       diffc= fDiffCoeff;
+    }
+
+    virtual  void   SetNoiseParam(Float_t np=420., Float_t nn=625.) {
+       // set noise par
+       fNoiseP=np; fNoiseN=nn;
+    }
+    virtual void    GetNoiseParam(Float_t &np, Float_t &nn) {
+       // get noise par
+       np=fNoiseP; nn=fNoiseN;
+    }
+
+    virtual void    SetParamOptions(const char *opt1="", const char *opt2="") {
+       // parameters: "SetInvalid" to simulate the invalid strips
+       fOption1=opt1; fOption2=opt2;
+    }
+    virtual void    ParamOptions(char *opt1,char *opt2) {
+       // options
+       strcpy(opt1,fOption1.Data());  strcpy(opt2,fOption2.Data());
+    }
+
+    // Number of parameters to be set
+    // 4 couplings, mean number of invalid strips, RMS of invalid strips
+    virtual  void   SetNDetParam(Int_t npar=6) {
+       // set number of param
+       fNPar=npar;
+    }
+
+    virtual  void   SetDetParam(Float_t *par);
+
+    // Parameters options
+    virtual Int_t   NDetParam() {
+       // number of param
+       return fNPar;
+    }
+    virtual void    GetDetParam(Float_t *dpar); 
+
+    virtual void    SetDataType(const char *data="simulated") {
+       // Type of data - real or simulated
+       fDataType=data;
+    }
+    virtual const char  *DataType() const {
+       // Get data type
+       return fDataType.Data();
+    }
+
+    virtual void    SetSigmaSpread(Float_t p1=3., Float_t p2=2.) {
+       // Set sigmas of the charge spread function: Pside-Nside
+       // square of (microns)
+       fSigmaP=p1; fSigmaN=p2;
+    }
+    virtual void    SigmaSpread(Float_t &sP, Float_t &sN) {
+       // Get sigmas for the charge spread 
+       sP=fSigmaP; sN=fSigmaN;
+    }
+    virtual void SetADCpereV(Float_t a=50./30000.0){ // Sets eV to ADC value
+       fADCpereV = a;
+    }
+    virtual Double_t DEvToADC(Double_t eV){ // Converts eV to ADC value
+       // conversion factor are rather arbitrary (need tuning)
+       // minimum ionizing particle--> ~30000 pairs--> ADC channel 50
+       return eV*fADCpereV;
+    }
+    virtual Int_t IEvToADC(Double_t eV){ // Converts eV to ADC value
+       return ((Int_t) DEvToADC(eV));
+    }
   
-  virtual void    SetSigmaSpread(Float_t p1=3., Float_t p2=2.) {
-    // Set sigmas of the charge spread function: Pside-Nside
-    // square of (microns)
-    fSigmaP=p1; fSigmaN=p2;
-  }
-  virtual void    SigmaSpread(Float_t &sP, Float_t &sN) {
-    // Get sigmas for the charge spread 
-    sP=fSigmaP; sN=fSigmaN;
-  }
-  
-protected:
-  Int_t   fNPar;            // Number of detector param 
-  Float_t *fDetPar;         //[fNPar] Array of parameters 
-  
-  Float_t fNoiseP;          // Noise on Pside
-  Float_t fNoiseN;          // Noise on Nside
-  
-  Float_t fSigmaP;          // Sigma charge spread on Pside
-  Float_t fSigmaN;          // Sigma charge spread on Nside
-  Float_t fDiffCoeff;       // Diffusion Coefficient
-  
-  TString fOption1;         // Simulate invalid strips option
-  TString fOption2;         // Not used for the moment
-  
-  TString  fDataType;       // Type of data - real or simulated
-  
-  ClassDef(AliITSresponseSSD,1) //Response class for SSD 
+ protected:
+    Int_t   fNPar;            // Number of detector param 
+    Float_t *fDetPar;         //[fNPar] Array of parameters
+
+    Float_t fNoiseP;          // Noise on Pside
+    Float_t fNoiseN;          // Noise on Nside
 
-    };
+    Float_t fSigmaP;          // Sigma charge spread on Pside
+    Float_t fSigmaN;          // Sigma charge spread on Nside
+    Float_t fDiffCoeff;       // Diffusion Coefficient
 
+    Float_t fADCpereV;        // Constant to convert eV to ADC.
 
+    TString fOption1;         // Simulate invalid strips option
+    TString fOption2;         // Not used for the moment
+    TString fDataType;       // Type of data - real or simulated
 
+    ClassDef(AliITSresponseSSD,1) //Response class for SSD
+};
 #endif