Some clean-up in AliITSresponse classes + coding conventions
authormasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Dec 2003 10:43:26 +0000 (10:43 +0000)
committermasera <masera@f7af4fe6-9843-0410-8265-dc069ae4e863>
Thu, 4 Dec 2003 10:43:26 +0000 (10:43 +0000)
13 files changed:
ITS/AliITSresponse.cxx
ITS/AliITSresponse.h
ITS/AliITSresponseSDD.cxx
ITS/AliITSresponseSDD.h
ITS/AliITSresponseSPD.cxx
ITS/AliITSresponseSPD.h
ITS/AliITSresponseSPDdubna.cxx
ITS/AliITSresponseSPDdubna.h
ITS/AliITSresponseSSD.cxx
ITS/AliITSresponseSSD.h
ITS/AliITSsimulationSDD.cxx
ITS/AliITStrackV2Pid.h
ITS/AliITSvSPD02.cxx

index ec6bac8..19f2470 100644 (file)
 
 /* $Id$ */
 
-////////////////////////////////////////////////
-//  Response class for set:ITS                //
-////////////////////////////////////////////////
+//////////////////////////////////////////////////////
+//  Response class for set:ITS                      //
+//  Specific subdetector implementation is done in  //
+//  AliITSresponseSPD                               //
+//  AliITSresponseSDD                               //
+//  AliITSresponseSSD                               //
+//////////////////////////////////////////////////////
 #include <Riostream.h>
 #include <TMath.h>
-#include <TF1.h>
-#include <TString.h>
 #include "AliITSresponse.h"
 
 ClassImp(AliITSresponse)
@@ -34,6 +36,7 @@ AliITSresponse::AliITSresponse(){
     fN  = 0.0;
     fT  = 300.0;
     SetGeVToCharge();
+    SetFilenames();
 }
 //______________________________________________________________________
 AliITSresponse::AliITSresponse(Double_t thickness){
@@ -43,6 +46,7 @@ AliITSresponse::AliITSresponse(Double_t thickness){
     fN  = 0.0;
     fT  = 300.0;
     SetGeVToCharge();
+    SetFilenames();
 }
 //______________________________________________________________________
 Double_t AliITSresponse::MobilityElectronSiEmp() const {
@@ -57,24 +61,24 @@ Double_t AliITSresponse::MobilityElectronSiEmp() const {
     // Return:
     //    The Mobility of electrons in Si at a give temprature and impurity
     //    concentration. [cm^2/Volt-sec]
-    const Double_t m0  = 55.24; // cm^2/Volt-sec
-    const Double_t m1  = 7.12E+08; // cm^2 (degree K)^2.3 / Volt-sec
-    const Double_t N0  = 1.072E17; // #/cm^3
-    const Double_t T0  = 300.; // degree K.
-    const Double_t eT0 = -2.3; // Power of Temp.
-    const Double_t eT1 = -3.8; // Power of Temp.
-    const Double_t eN  = 0.73; // Power of Dopent Consentrations
+    const Double_t km0  = 55.24; // cm^2/Volt-sec
+    const Double_t km1  = 7.12E+08; // cm^2 (degree K)^2.3 / Volt-sec
+    const Double_t kN0  = 1.072E17; // #/cm^3
+    const Double_t kT0  = 300.; // degree K.
+    const Double_t keT0 = -2.3; // Power of Temp.
+    const Double_t keT1 = -3.8; // Power of Temp.
+    const Double_t keN  = 0.73; // Power of Dopent Consentrations
     Double_t m;
-    Double_t T = fT,N = fN;
+    Double_t tT = fT,nN = fN;
 
-    if(N<=0.0){ // Simple case.
-       if(T==300.) return 1350.0; // From Table 5-1 at consentration 1.0E14.
-       m = m1*TMath::Power(T,eT0);
+    if(nN<=0.0){ // Simple case.
+       if(tT==300.) return 1350.0; // From Table 5-1 at consentration 1.0E14.
+       m = km1*TMath::Power(tT,keT0);
        return m;
-    } // if N<=0.0
-    m = m1*TMath::Power(T,eT0) - m0;
-    m /= 1.0 + TMath::Power(T/T0,eT1)*TMath::Power(N/N0,eN);
-    m += m0;
+    } // if nN<=0.0
+    m = km1*TMath::Power(tT,keT0) - km0;
+    m /= 1.0 + TMath::Power(tT/kT0,keT1)*TMath::Power(nN/kN0,keN);
+    m += km0;
     return m;
 }
 //______________________________________________________________________
@@ -90,25 +94,25 @@ Double_t AliITSresponse::MobilityHoleSiEmp() const {
     // Return:
     //    The Mobility of Hole in Si at a give temprature and impurity
     //    concentration. [cm^2/Volt-sec]
-    const Double_t m0a = 49.74; // cm^2/Volt-sec
-    const Double_t m0b = 49.70; // cm^2/Volt-sec
-    const Double_t m1  = 1.35E+08; // cm^2 (degree K)^2.3 / Volt-sec
-    const Double_t N0  = 1.606E17; // #/cm^3
-    const Double_t T0  = 300.; // degree K.
-    const Double_t eT0 = -2.2; // Power of Temp.
-    const Double_t eT1 = -3.7; // Power of Temp.
-    const Double_t eN  = 0.70; // Power of Dopent Consentrations
+    const Double_t km0a = 49.74; // cm^2/Volt-sec
+    const Double_t km0b = 49.70; // cm^2/Volt-sec
+    const Double_t km1  = 1.35E+08; // cm^2 (degree K)^2.3 / Volt-sec
+    const Double_t kN0  = 1.606E17; // #/cm^3
+    const Double_t kT0  = 300.; // degree K.
+    const Double_t keT0 = -2.2; // Power of Temp.
+    const Double_t keT1 = -3.7; // Power of Temp.
+    const Double_t keN  = 0.70; // Power of Dopent Consentrations
     Double_t m;
-    Double_t T = fT,N = fN;
+    Double_t tT = fT,nN = fN;
 
-    if(N<=0.0){ // Simple case.
-       if(T==300.) return 495.0; // From Table 5-1 at consentration 1.0E14.
-       m = m1*TMath::Power(T,eT0) + m0a-m0b;
+    if(nN<=0.0){ // Simple case.
+       if(tT==300.) return 495.0; // From Table 5-1 at consentration 1.0E14.
+       m = km1*TMath::Power(tT,keT0) + km0a-km0b;
        return m;
-    } // if N<=0.0
-    m = m1*TMath::Power(T,eT0) - m0b;
-    m /= 1.0 + TMath::Power(T/T0,eT1)*TMath::Power(N/N0,eN);
-    m += m0a;
+    } // if nN<=0.0
+    m = km1*TMath::Power(tT,keT0) - km0b;
+    m /= 1.0 + TMath::Power(tT/kT0,keT1)*TMath::Power(nN/kN0,keN);
+    m += km0a;
     return m;
 }
 //______________________________________________________________________
@@ -128,9 +132,9 @@ Double_t AliITSresponse::DiffusionCoefficientElectron() const {
     // const Double_t qe = 1.60217646E-19; // Coulumbs.
     const Double_t kbqe = 8.617342312E-5; // Volt/degree K
     Double_t m = MobilityElectronSiEmp();
-    Double_t T = fT;
+    Double_t tT = fT;
 
-    return m*kbqe*T;  // [cm^2/sec]
+    return m*kbqe*tT;  // [cm^2/sec]
 }
 //______________________________________________________________________
 Double_t AliITSresponse::DiffusionCoefficientHole() const {
@@ -150,9 +154,9 @@ Double_t AliITSresponse::DiffusionCoefficientHole() const {
     // const Double_t qe = 1.60217646E-19; // Coulumbs.
     const Double_t kbqe = 8.617342312E-5; // Volt/degree K
     Double_t m = MobilityHoleSiEmp();
-    Double_t T = fT;
+    Double_t tT = fT;
 
-    return m*kbqe*T;  // [cm^2/sec]
+    return m*kbqe*tT;  // [cm^2/sec]
 }
 //______________________________________________________________________
 Double_t AliITSresponse::SpeedElectron() const {
@@ -202,9 +206,9 @@ Double_t AliITSresponse::SigmaDiffusion3D(Double_t l) const {
     //    none.
     // Return:
     //    The Sigma due to the diffution of electrons. [cm]
-    const Double_t con = 5.17040258E-04; // == 6k/e [J/col or volts]
+    const Double_t kcon = 5.17040258E-04; // == 6k/e [J/col or volts]
 
-    return TMath::Sqrt(con*fT*fdv*l);  // [cm]
+    return TMath::Sqrt(kcon*fT*fdv*l);  // [cm]
 }
 //______________________________________________________________________
 Double_t AliITSresponse::SigmaDiffusion2D(Double_t l) const {
@@ -224,9 +228,9 @@ Double_t AliITSresponse::SigmaDiffusion2D(Double_t l) const {
     //    none.
     // Return:
     //    The Sigma due to the diffution of electrons. [cm]
-    const Double_t con = 3.446935053E-04; // == 4k/e [J/col or volts]
+    const Double_t kcon = 3.446935053E-04; // == 4k/e [J/col or volts]
 
-    return TMath::Sqrt(con*fT*fdv*l);  // [cm]
+    return TMath::Sqrt(kcon*fT*fdv*l);  // [cm]
 }
 //______________________________________________________________________
 Double_t AliITSresponse::SigmaDiffusion1D(Double_t l) const {
@@ -246,45 +250,24 @@ Double_t AliITSresponse::SigmaDiffusion1D(Double_t l) const {
     //    none.
     // Return:
     //    The Sigma due to the diffution of electrons. [cm]
-    const Double_t con = 1.723467527E-04; // == 2k/e [J/col or volts]
+    const Double_t kcon = 1.723467527E-04; // == 2k/e [J/col or volts]
 
-    return TMath::Sqrt(con*fT*fdv*l);  // [cm]
+    return TMath::Sqrt(kcon*fT*fdv*l);  // [cm]
 }
 //----------------------------------------------------------------------
-void AliITSresponse::Print(ostream *os){
+void AliITSresponse::Print(ostream *os) const {
   // Standard output format for this class.
   // Inputs:
-  //    ostream *os  Pointer to the output stream
-  // Outputs:
-  //    none:
-  // Return:
-  //    none.
-#if defined __GNUC__
-#if __GNUC__ > 2
-    ios::fmtflags fmt;
-#else
-    Int_t fmt;
-#endif
-#else
-#if defined __ICC || defined __ECC
-    ios::fmtflags fmt;
-#else
-    Int_t fmt;
-#endif
-#endif
-
-    fmt = os->setf(ios::scientific);  // set scientific floating point output
     *os << fdv << " " << fN << " " << fT << " ";
-    *os << fGeVcharge;
-//    *os << " " << endl;
-    os->flags(fmt); // reset back to old formating.
+    *os << fGeVcharge;    
+  //    printf("%-10.6e  %-10.6e %-10.6e %-10.6e \n",fdv,fN,fT,fGeVcharge);
     return;
 }
 //----------------------------------------------------------------------
-void AliITSresponse::Read(istream *is){
+void AliITSresponse::Read(istream *is) {
   // Standard input format for this class.
   // Inputs:
-  //    ostream *os  Pointer to the output stream
+  //    ostream *is  Pointer to the output stream
   // Outputs:
   //    none:
   // Return:
@@ -294,6 +277,7 @@ void AliITSresponse::Read(istream *is){
     return;
 }
 //----------------------------------------------------------------------
+
 ostream &operator<<(ostream &os,AliITSresponse &p){
   // Standard output streaming function.
   // Inputs:
@@ -306,6 +290,7 @@ ostream &operator<<(ostream &os,AliITSresponse &p){
     p.Print(&os);
     return os;
 }
+
 //----------------------------------------------------------------------
 istream &operator>>(istream &is,AliITSresponse &r){
   // Standard input streaming function.
index da77e1e..ca61ec9 100644 (file)
@@ -6,11 +6,10 @@
 /* $Id$ */
 
 #include <TObject.h>
+#include <TString.h>
 
-#include "AliITSsegmentation.h"
-
+class AliITSsegmentation;
 class TF1;
-class TString;
 class AliITSgeom;
 
 //----------------------------------------------
@@ -30,24 +29,24 @@ class AliITSresponse : public TObject {
     //
 
     // Set Electronics
-    virtual void    SetElectronics(Int_t) {}
+    virtual void    SetElectronics(Int_t) = 0;
     // Get Electronics
-    virtual Int_t Electronics() const {return 0;}
+    virtual Int_t Electronics() const = 0;
 
     // Set maximum Adc-count value
-    virtual void    SetMaxAdc(Float_t) {}
+    virtual void    SetMaxAdc(Float_t) = 0;
     // Get maximum Adc-count value
-    virtual Float_t MaxAdc() const {return 0.;}
+    virtual Float_t MaxAdc() const = 0;
 
     // Set maximum Adc-top value
-    virtual void    SetDynamicRange(Float_t) {}
+    virtual void    SetDynamicRange(Float_t) = 0;
     // Get maximum Adc-top value
-    virtual Float_t DynamicRange() const {return 0.0;}
+    virtual Float_t DynamicRange() const = 0;
 
     // Set Charge Loss Linear Coefficient
-    virtual void    SetChargeLoss(Float_t) {}
+    virtual void    SetChargeLoss(Float_t) = 0;
     // Get Charge Loss Linear Coefficient
-    virtual Float_t ChargeLoss() const {return 0.0;}
+    virtual Float_t ChargeLoss() const = 0;
 
     // Set GeVcharge value
     virtual void SetGeVToCharge(Float_t gc=2.778E+8){fGeVcharge = gc;}
@@ -57,16 +56,16 @@ class AliITSresponse : public TObject {
     virtual Float_t GeVToCharge(Float_t gev) const {return gev*fGeVcharge;}
 
     // Diffusion coefficient
-    virtual void    SetDiffCoeff(Float_t, Float_t) {}
+    virtual void    SetDiffCoeff(Float_t, Float_t) = 0;
     // Get diffusion coefficients
-    virtual void    DiffCoeff(Float_t &,Float_t &) {}
+    virtual void    DiffCoeff(Float_t &,Float_t &) const = 0;
 
     // Temperature in [degree K]
     virtual void    SetTemperature(Float_t t=300.0) {fT = t;}
     // Get temperature [degree K]
     virtual Float_t Temperature() const {return fT;}
     // Type of data - real or simulated
-    virtual void    SetDataType(const char *) {}
+    virtual void    SetDataType(const char *data="simulated") {fDataType=data;}
     // Set the impurity concentrations in [#/cm^3]
     virtual void SetImpurity(Double_t n=0.0){fN = n;}
     // Returns the impurity consentration in [#/cm^3]
@@ -79,61 +78,63 @@ class AliITSresponse : public TObject {
     // Returns the ration distance/voltage
     virtual Double_t DistanceOverVoltage() const {return fdv;}
     // Get data type
-    virtual const char  *DataType() const {return "";}
+    virtual const char  *DataType() const {return fDataType.Data();}
  
     // Set parameters options: "same" or read from "file" or "SetInvalid" or...
-    virtual void   SetParamOptions(const char*,const char*) {}
+    virtual void   SetParamOptions(const char*,const char*) = 0;
     // Set noise parameters 
-    virtual void   SetNoiseParam(Float_t, Float_t) {}
+    virtual void   SetNoiseParam(Float_t, Float_t) = 0;
     // Number of parameters to be set
-    virtual  void   SetNDetParam(Int_t) {}
+    virtual  void   SetNDetParam(Int_t) = 0;
     // Set detector parameters: gain, coupling ...
-    virtual  void   SetDetParam(Float_t *) {}
+    virtual  void   SetDetParam(Float_t *) = 0;
 
     // Parameters options
-    virtual void   ParamOptions(char *,char*) {}
-    virtual Int_t  NDetParam() const {return 0;}
-    virtual void   GetDetParam(Float_t *) {}
-    virtual void   GetNoiseParam(Float_t&, Float_t&) {}
+    virtual void   ParamOptions(char *,char*) const = 0;
+    virtual Int_t  NDetParam() const = 0;
+    virtual void   GetDetParam(Float_t *) const = 0;
+    virtual void   GetNoiseParam(Float_t&, Float_t&) const = 0;
 
     // Zero-suppression option - could be 1D, 2D or non-ZeroSuppressed
-    virtual void   SetZeroSupp(const char*) {}
+    virtual void   SetZeroSupp(const char*) = 0;
     // Get zero-suppression option
-    virtual const char *ZeroSuppOption() const {return "";}
+    virtual const char *ZeroSuppOption() const = 0;
      // Set thresholds
-    virtual void   SetThresholds(Float_t, Float_t) {}
-    virtual void   Thresholds(Float_t &, Float_t &) {}
-    // Set min val
-    virtual void   SetMinVal(Int_t) {};
-    virtual Int_t  MinVal() const {return 0;};
+    virtual void   SetThresholds(Float_t, Float_t) = 0;
+    virtual void   Thresholds(Float_t &, Float_t &) const = 0;
 
     // Set filenames
-    virtual void SetFilenames(const char *,const char *,const char *) {}
+    virtual void SetFilenames(const char *f1="",const char *f2="",const char *f3=""){
+       // Set filenames - input, output, parameters ....
+       fFileName1=f1; fFileName2=f2; fFileName3=f3;}
     // Filenames
-    virtual void   Filenames(char*,char*,char*) {}
-
-    virtual Float_t DriftSpeed() const {return 0.;}
-    virtual Bool_t  OutputOption() const {return kFALSE;}
+    virtual void   Filenames(char* input,char* baseline,char* param) {
+       strcpy(input,fFileName1.Data());  strcpy(baseline,fFileName2.Data());  
+       strcpy(param,fFileName3.Data());}
+
+    virtual void    SetDriftSpeed(Float_t p1) = 0;
+    virtual Float_t DriftSpeed() const = 0;
+    virtual void    SetOutputOption(Bool_t write=kFALSE) {// set output option
+       fWrite = write;}
+    virtual Bool_t  OutputOption() const {return fWrite;}
     virtual Bool_t  Do10to8() const {return kTRUE;}
-    virtual void    GiveCompressParam(Int_t *) {}
-
+    virtual void    GiveCompressParam(Int_t *) const =0;
     //
     // Detector type response methods
     // Set number of sigmas over which cluster disintegration is performed
-    virtual void    SetNSigmaIntegration(Float_t) {}
+    virtual void    SetNSigmaIntegration(Float_t) = 0;
     // Get number of sigmas over which cluster disintegration is performed
-    virtual Float_t NSigmaIntegration() const {return 0.;}
+    virtual Float_t NSigmaIntegration() const = 0;
     // Set number of bins for the gaussian lookup table
-    virtual void    SetNLookUp(Int_t) {}
+    virtual void    SetNLookUp(Int_t) = 0;
     // Get number of bins for the gaussian lookup table
     virtual Int_t GausNLookUp() const {return 0;}
     // Get scaling factor for bin i-th from the gaussian lookup table
     virtual Float_t GausLookUp(Int_t) const {return 0.;}
     // Set sigmas of the charge spread function
-    virtual void    SetSigmaSpread(Float_t, Float_t) {}
+    virtual void    SetSigmaSpread(Float_t, Float_t) = 0;
     // Get sigmas for the charge spread
-    virtual void    SigmaSpread(Float_t &,Float_t &) {}
-
+    virtual void    SigmaSpread(Float_t &,Float_t &) const = 0;
     // Pulse height from scored quantity (eloss)
     virtual Float_t IntPH(Float_t) const {return 0.;}
     // Charge disintegration
@@ -160,27 +161,37 @@ class AliITSresponse : public TObject {
     // electrons or holes through a distance l [cm] caused by an applied
     // voltage v [volt] through a distance d [cm] in any material at a
     // temperature T [degree K].
-    virtual Double_t SigmaDiffusion3D(Double_t) const ;
+    virtual Double_t SigmaDiffusion3D(Double_t  l) const ;
     // Returns the Gaussian sigma == <x^2 +y^2+z^2> [cm^2] due to the
     // defusion of electrons or holes through a distance l [cm] caused by an
     // applied voltage v [volt] through a distance d [cm] in any material at a
     // temperature T [degree K].
-    virtual Double_t SigmaDiffusion2D(Double_t) const ;
+    virtual Double_t SigmaDiffusion2D(Double_t l) const ;
     // Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of
     // electrons or holes through a distance l [cm] caused by an applied
     // voltage v [volt] through a distance d [cm] in any material at a
     // temperature T [degree K].
-    virtual Double_t SigmaDiffusion1D(Double_t) const ;
+    virtual Double_t SigmaDiffusion1D(Double_t l) const ;
     // Prints out the content of this class in ASCII format.
-    virtual void Print(ostream *os);
+    virtual void Print(ostream *os) const;
     // Reads in the content of this class in the format of Print
     virtual void Read(istream *is);
+ protected:
+    void NotImplemented(const char *method) const {if(gDebug>0)
+         Warning(method,"This method is not implemented for this sub-class");}
+
+    TString  fDataType;   // data type - real or simulated
  private:
     Double_t fdv;  // The parameter d/v where d is the disance over which the
                    // the potential v is applied d/v [cm/volts]
     Double_t fN;   // the impurity consentration of the material in #/cm^3
     Double_t fT;   // The temperature of the Si in Degree K.
     Double_t fGeVcharge; // Energy to ionize (free an electron).
+    TString  fFileName1;        // input keys : run, module #
+    TString  fFileName2;        // baseline & noise val or output code
+                                // signal or monitored bgr.
+    TString  fFileName3;        // param values or output coded signal
+    Bool_t     fWrite;          // Write option for the compression algorithms
 
     ClassDef(AliITSresponse,2) // Detector type response virtual base class 
 };
index 3313077..7578ac7 100644 (file)
 
 /* $Id$ */
 
-#include <TString.h>
+#include <Riostream.h>
 #include <TRandom.h>
 
 #include "AliITSresponseSDD.h"
 
+//////////////////////////////////////////////////
+//  Response class for set:ITS                      //
+//  Specific subdetector implementation             //
+//  for silicon drift detectors                     //
+//                                                  //
+//                                                  //
+//////////////////////////////////////////////////////
 
+const Int_t AliITSresponseSDD::fgkModules;   
+const Int_t AliITSresponseSDD::fgkChips;  
+const Int_t AliITSresponseSDD::fgkChannels; 
+const Int_t AliITSresponseSDD::fgkMaxAdcDefault = 1024;
+const Float_t AliITSresponseSDD::fgkDynamicRangeDefault = 132.;
+const Float_t AliITSresponseSDD::fgkfChargeLossDefault = 0;
+const Float_t AliITSresponseSDD::fgkDiffCoeffDefault = 3.23;
+const Float_t AliITSresponseSDD::fgkDiffCoeff1Default = 30.;
+const Float_t AliITSresponseSDD::fgkTemperatureDefault = 296.;
+const TString AliITSresponseSDD::fgkParam1Default = "same";
+const TString AliITSresponseSDD::fgkParam2Default = "same";
+const Float_t AliITSresponseSDD::fgkNoiseDefault = 10.;
+const Float_t AliITSresponseSDD::fgkBaselineDefault = 20.;
+const TString AliITSresponseSDD::fgkOptionDefault = "1D";
+const Float_t AliITSresponseSDD::fgkMinValDefault  = 4;
+const Float_t AliITSresponseSDD::fgkDriftSpeedDefault = 7.3;
+const Float_t AliITSresponseSDD::fgkNsigmasDefault = 3.;
+const Int_t AliITSresponseSDD::fgkNcompsDefault = 121;
 //______________________________________________________________________
 ClassImp(AliITSresponseSDD)
 
@@ -28,22 +53,22 @@ AliITSresponseSDD::AliITSresponseSDD(){
   // default constructor
    fGaus = 0;
    SetDeadChannels();
-   SetMaxAdc();
-   SetDiffCoeff();
-   SetDriftSpeed();
-   SetNSigmaIntegration();
-   SetNLookUp();
+   SetMaxAdc(fgkMaxAdcDefault);
+   SetDiffCoeff(fgkDiffCoeffDefault,fgkDiffCoeff1Default);
+   SetDriftSpeed(fgkDriftSpeedDefault);
+   SetNSigmaIntegration(fgkNsigmasDefault);
+   SetNLookUp(fgkNcompsDefault);
    // SetClock();
-   SetNoiseParam();
+   SetNoiseParam(fgkNoiseDefault,fgkBaselineDefault);
    SetNoiseAfterElectronics();
    SetJitterError();
    SetElectronics();
-   SetDynamicRange();
-   SetChargeLoss();
-   SetMinVal();
-   SetParamOptions();
-   SetTemperature();
-   SetZeroSupp();
+   SetDynamicRange(fgkDynamicRangeDefault);
+   SetChargeLoss(fgkfChargeLossDefault);
+   SetThresholds(fgkMinValDefault,0.);
+   SetParamOptions(fgkParam1Default.Data(),fgkParam2Default.Data());
+   SetTemperature(fgkTemperatureDefault);
+   SetZeroSupp(fgkOptionDefault);
    SetDataType();
    SetFilenames();
    SetOutputOption();
@@ -63,22 +88,22 @@ AliITSresponseSDD::AliITSresponseSDD(const char *dataType){
   // constructor
    fGaus = 0;
    SetDeadChannels();
-   SetMaxAdc();
-   SetDiffCoeff();
-   SetDriftSpeed();
-   SetNSigmaIntegration();
-   SetNLookUp();
+   SetMaxAdc(fgkMaxAdcDefault);
+   SetDiffCoeff(fgkDiffCoeffDefault,fgkDiffCoeff1Default);
+   SetDriftSpeed(fgkDriftSpeedDefault);
+   SetNSigmaIntegration(fgkNsigmasDefault);
+   SetNLookUp(fgkNcompsDefault);
    // SetClock();
-   SetNoiseParam();
+   SetNoiseParam(fgkNoiseDefault,fgkBaselineDefault);
    SetNoiseAfterElectronics();
    SetJitterError();
    SetElectronics();
-   SetDynamicRange();
-   SetChargeLoss();
-   SetMinVal();
-   SetParamOptions();
-   SetTemperature();
-   SetZeroSupp();
+   SetDynamicRange(fgkDynamicRangeDefault);
+   SetChargeLoss(fgkfChargeLossDefault);
+   SetThresholds(fgkMinValDefault,0.);
+   SetParamOptions(fgkParam1Default.Data(),fgkParam2Default.Data());
+   SetTemperature(fgkTemperatureDefault);
+   SetZeroSupp(fgkOptionDefault);
    SetDataType(dataType);
    SetFilenames();
    SetOutputOption();
@@ -94,6 +119,21 @@ AliITSresponseSDD::AliITSresponseSDD(const char *dataType){
    fCPar[7]=0;
 }
 //______________________________________________________________________
+AliITSresponseSDD::AliITSresponseSDD(const AliITSresponseSDD &ob) : AliITSresponse(ob) {
+  // Copy constructor
+  // Copies are not allowed. The method is protected to avoid misuse.
+  Error("AliITSresponseSDD","Copy constructor not allowed\n");
+}
+
+//______________________________________________________________________
+AliITSresponseSDD& AliITSresponseSDD::operator=(const AliITSresponseSDD& /* ob */){
+  // Assignment operator
+  // Assignment is not allowed. The method is protected to avoid misuse.
+  Error("= operator","Assignment operator not allowed\n");
+  return *this;
+}
+
+//______________________________________________________________________
 AliITSresponseSDD::~AliITSresponseSDD() { 
 
   if(fGaus) delete fGaus;
@@ -109,7 +149,7 @@ void AliITSresponseSDD::SetCompressParam(Int_t  cp[8]){
     } // end for i
 }
 //______________________________________________________________________
-void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8]){
+void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8]) const {
   // give compression param
 
     Int_t i;
@@ -118,13 +158,24 @@ void AliITSresponseSDD::GiveCompressParam(Int_t  cp[8]){
     } // end for i
 }
 //______________________________________________________________________
+void AliITSresponseSDD::SetNLookUp(Int_t p1){
+  // Set number of sigmas over which cluster disintegration is performed
+  fNcomps=p1;
+  fGaus = new TArrayF(fNcomps+1);
+  for(Int_t i=0; i<=fNcomps; i++) {
+    Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
+    (*fGaus)[i] = exp(-((x*x)/2));
+    //     cout << "fGaus[" << i << "]: " << fGaus->At(i) << endl;
+  }
+}
+//______________________________________________________________________
 void AliITSresponseSDD::SetDeadChannels(Int_t nmod, 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<fModules; m++ ) 
-        for( Int_t n=0; n<fChips; n++ ) 
-            for( Int_t p=0; p<fChannels; p++ ) 
+    for( Int_t m=0; m<fgkModules; m++ ) 
+        for( Int_t n=0; n<fgkChips; n++ ) 
+            for( Int_t p=0; p<fgkChannels; p++ ) 
                  fGain[m][n][p] = 1.;
                  
     fDeadModules  = nmod;  
@@ -134,18 +185,18 @@ void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan){
     // nothing to do
     if( nmod == 0 && nchip == 0 && nchan == 0 ) return;
 
-    if( nmod < 0 || nmod > fModules ) 
+    if( nmod < 0 || nmod > fgkModules ) 
     { 
         cout << "Wrong number of dead modules: " << nmod << endl; 
         return; 
     }
-    Int_t nmax = (fModules-nmod)*fChips; 
+    Int_t nmax = (fgkModules-nmod)*fgkChips; 
     if( nchip < 0 || nchip > nmax ) 
     { 
         cout << "Wrong number of dead chips: " << nchip << endl; 
         return; 
     }
-    nmax = ((fModules - nmod)*fChips - nchip)*fChannels; 
+    nmax = ((fgkModules - nmod)*fgkChips - nchip)*fgkChannels; 
     if( nchan < 0 || nchan > nmax ) 
     { 
         cout << "Wrong number of dead channels: " << nchan << endl; 
@@ -159,78 +210,78 @@ void AliITSresponseSDD::SetDeadChannels(Int_t nmod, Int_t nchip, Int_t nchan){
     Int_t i; //loop variable
     for( i=0; i<nmod; i++ ) 
     {
-        mod[i] = (Int_t) (1.+fModules*gran->Uniform());
+        mod[i] = (Int_t) (1.+fgkModules*gran->Uniform());
         cout << i+1 << ": Dead module nr: " << mod[i] << endl;
-        for(Int_t n=0; n<fChips; n++)
-            for(Int_t p=0; p<fChannels; p++)
+        for(Int_t n=0; n<fgkChips; n++)
+            for(Int_t p=0; p<fgkChannels; p++)
                 fGain[mod[i]-1][n][p] = 0.;
     }
 
     //  cout << "chips" << endl;
     Int_t * chip     = new Int_t[nchip];
-    Int_t * chip_mod = new Int_t[nchip];
+    Int_t * chipMod = new Int_t[nchip];
     i = 0;
     while( i < nchip ) 
     {
-        Int_t module = (Int_t) (fModules*gran->Uniform() + 1.);
-        if( module <=0 || module > fModules ) 
+        Int_t module = (Int_t) (fgkModules*gran->Uniform() + 1.);
+        if( module <=0 || module > fgkModules ) 
             cout << "Wrong module: " << module << endl;
-        Int_t flag_mod = 0;
+        Int_t flagMod = 0;
         for( Int_t k=0; k<nmod; k++ ) 
-            if( module == mod[k] ) { flag_mod = 1; break; }
-        if( flag_mod == 1 ) continue;
+            if( module == mod[k] ) { flagMod = 1; break; }
+        if( flagMod == 1 ) continue;
         
-        Int_t chi = (Int_t) (fChips*gran->Uniform() + 1.);
-        if( chi <=0 || chi > fChips ) cout << "Wrong chip: " << chi << endl;
+        Int_t chi = (Int_t) (fgkChips*gran->Uniform() + 1.);
+        if( chi <=0 || chi > fgkChips ) cout << "Wrong chip: " << chi << endl;
         i++;
         chip[i-1] = chi; 
-        chip_mod[i-1] = module;
-        for( Int_t m=0; m<fChannels; m++ ) 
+        chipMod[i-1] = module;
+        for( Int_t m=0; m<fgkChannels; m++ ) 
             fGain[module-1][chi-1][m] = 0.;
         cout << i << ": Dead chip nr. " << chip[i-1] << " in module nr: " 
-            << chip_mod[i-1] << endl;
+            << chipMod[i-1] << endl;
     }
 
     //  cout << "channels" << endl;
     Int_t * channel      = new Int_t[nchan];
-    Int_t * channel_chip = new Int_t[nchan];
-    Int_t * channel_mod  = new Int_t[nchan];
+    Int_t * channelChip = new Int_t[nchan];
+    Int_t * channelMod  = new Int_t[nchan];
     i = 0;
     while( i < nchan ) 
     {
         Int_t k; //loop variable
-        Int_t module = (Int_t) (fModules*gran->Uniform() + 1.);
-        if( module <=0 || module > fModules ) 
+        Int_t module = (Int_t) (fgkModules*gran->Uniform() + 1.);
+        if( module <=0 || module > fgkModules ) 
             cout << "Wrong module: " << module << endl;
-        Int_t flag_mod = 0;
+        Int_t flagMod = 0;
         for( k=0; k<nmod; k++ ) 
-            if( module == mod[k] ) { flag_mod = 1; break; }
-        if( flag_mod == 1 ) continue;
-        Int_t chipp = (Int_t) (fChips*gran->Uniform() + 1.);
-        if( chipp <=0 || chipp > fChips ) cout << "Wrong chip: "<< chipp<<endl;
-        Int_t flag_chip = 0;
+            if( module == mod[k] ) { flagMod = 1; break; }
+        if( flagMod == 1 ) continue;
+        Int_t chipp = (Int_t) (fgkChips*gran->Uniform() + 1.);
+        if( chipp <=0 || chipp > fgkChips ) cout << "Wrong chip: "<< chipp<<endl;
+        Int_t flagChip = 0;
         for( k=0; k<nchip; k++) 
-            if( chipp == chip[k] && module == chip_mod[k] ) { 
-               flag_chip = 1; break; }
-        if( flag_chip == 1 ) continue;
+            if( chipp == chip[k] && module == chipMod[k] ) { 
+               flagChip = 1; break; }
+        if( flagChip == 1 ) continue;
         i++;
-        channel[i-1] = (Int_t) (fChannels*gran->Uniform() + 1.); 
-        if( channel[i-1] <=0 || channel[i-1] > fChannels ) 
+        channel[i-1] = (Int_t) (fgkChannels*gran->Uniform() + 1.); 
+        if( channel[i-1] <=0 || channel[i-1] > fgkChannels ) 
             cout << "Wrong channel: " << channel[i-1] << endl;
-        channel_chip[i-1] = chipp;
-        channel_mod[i-1] = module;
+        channelChip[i-1] = chipp;
+        channelMod[i-1] = module;
         fGain[module-1][chipp-1][channel[i-1]-1] = 0.;
         cout << i << ": Dead channel nr. " << channel[i-1] << " in chip nr. " 
-            << channel_chip[i-1] << " in module nr: " << channel_mod[i-1] 
+            << channelChip[i-1] << " in module nr: " << channelMod[i-1] 
             << endl;
     }
     
     delete [] mod;
     delete [] chip;
-    delete [] chip_mod;
+    delete [] chipMod;
     delete [] channel;
-    delete [] channel_mod;
-    delete [] channel_chip;
+    delete [] channelMod;
+    delete [] channelChip;
 }
 //______________________________________________________________________
 void AliITSresponseSDD::PrintGains(){
@@ -247,9 +298,9 @@ void AliITSresponseSDD::PrintGains(){
   cout << "**************************************************" << endl;
 
   // Print SDD electronic gains
-  for(Int_t t=0; t<fModules;t++)
-    for(Int_t u=0; u<fChips;u++)
-      for(Int_t v=0; v<fChannels;v++)
+  for(Int_t t=0; t<fgkModules;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 Module: " << t+1 << ", Chip " << u+1 << 
@@ -273,7 +324,7 @@ void AliITSresponseSDD::Print(){
 
    cout << "Dynamic Range: " << fDynamicRange << endl;
    cout << "Charge Loss: " << fChargeLoss << endl;
-   cout << "Temperature: " << fTemperature << endl;
+   cout << "Temperature: " << Temperature() << " K " << endl;
    cout << "Drift Speed: " << fDriftSpeed << endl;
    cout << "Electronics (1=PASCAL, 2=OLA): " << fElectronics << endl;
 
index c305b11..7ec6aa0 100644 (file)
@@ -9,8 +9,6 @@
 */
 
 #include "TArrayF.h"
-#include <TString.h>
-#include <Riostream.h>
 #include "AliITSresponse.h"
 
 // response for SDD
@@ -25,145 +23,142 @@ class AliITSresponseSDD : public AliITSresponse {
     AliITSresponseSDD(const char *dataType);
     virtual ~AliITSresponseSDD();
 
-    void SetElectronics(Int_t p1=1) {// Electronics: Pascal (1) or OLA (2)
-       fElectronics=p1;}
-    Int_t Electronics() const {// Electronics: 1 = Pascal; 2 = OLA
+// Implementation of virtual member functions declared in AliITSresponse 
+    virtual void SetElectronics(Int_t p1=1) 
+      {fElectronics=p1;  /* Electronics: Pascal (1) or OLA (2) */ }
+    virtual Int_t Electronics() const {// Electronics: 1 = Pascal; 2 = OLA
        return fElectronics;}
-    void    SetMaxAdc(Float_t p1=1024.) {// Adc-count saturation value
+    virtual void    SetMaxAdc(Float_t p1) {// Adc-count saturation value
        fMaxAdc=p1;}
-    Float_t MaxAdc() const {// Get maximum Adc-count value
+    virtual Float_t MaxAdc() const {// Get maximum Adc-count value
        return fMaxAdc;}
-    void    SetChargeLoss(Float_t p1=0.0) {
+    virtual void    SetChargeLoss(Float_t p1) {
        // Set Linear Charge Loss Steepness  // 0.01 for 20%
        fChargeLoss=p1;}
     Float_t ChargeLoss() const {// Get Charge Loss Coefficient
        return fChargeLoss;}
-    void    SetDynamicRange(Float_t p1=132.) {// Set Dynamic Range
-       fDynamicRange=p1;}
-    Float_t DynamicRange() const {// Get Dynamic Range
+    virtual void    SetDynamicRange(Float_t p1) {// Set Dynamic Range
+       fDynamicRange = p1;}
+    virtual Float_t DynamicRange() const {// Get Dynamic Range
        return fDynamicRange;}
-    void    SetDiffCoeff(Float_t p1=3.23,Float_t p2=30.) {
-       // Diffusion coefficients
-       fDiffCoeff=p1;fDiffCoeff1=p2;}
-    void DiffCoeff(Float_t&diff,Float_t&diff1) {// Get diffusion coefficients
-       diff = fDiffCoeff;diff1 = fDiffCoeff1;}
-    void    SetDriftSpeed(Float_t p1=7.3) {// Drift velocity
+    // Diffusion coefficients
+    virtual void    SetDiffCoeff(Float_t p1, Float_t p2) 
+       {fDiffCoeff=p1;fDiffCoeff1=p2;}
+    // Get diffusion coefficients
+    virtual void DiffCoeff(Float_t&diff,Float_t&diff1) const 
+       {diff = fDiffCoeff;diff1 = fDiffCoeff1;}
+    virtual void    SetDriftSpeed(Float_t p1) {// Drift velocity
        fDriftSpeed=p1;}
-    Float_t DriftSpeed() const {// drift speed
+    virtual Float_t DriftSpeed() const {// drift speed
        return fDriftSpeed;}
-    void    SetTemperature(Float_t p1=23.) {// Temperature
-       fTemperature=p1;}
-    Float_t Temperature() const {// Get temperature
-       return fTemperature;}
-    void    SetDataType(const char *data="simulated") {
-       // Type of data - real or simulated
-       fDataType=data;}
-    const char  *DataType() const {// Get data type
-       return fDataType.Data();}
-    void SetParamOptions(const char *opt1="same",const char *opt2="same"){
+    virtual void SetParamOptions(const char *opt1,const char *opt2){
        // Parameters: "same" or read from "file" 
        fParam1=opt1; fParam2=opt2;}
-    void   ParamOptions(char *opt1,char *opt2) {// options
+    virtual void   ParamOptions(char *opt1,char *opt2) const {// options
        strcpy(opt1,fParam1.Data()); strcpy(opt2,fParam2.Data());}
-    void  SetNoiseParam(Float_t n=10., Float_t b=20.){
+    virtual void  SetNoiseParam(Float_t n, Float_t b){
        // Noise and baseline  // 10 for ALICE with beam test measurements 2001
        fNoise=n; fBaseline=b;}
+    virtual void  GetNoiseParam(Float_t &n, Float_t &b) const {// get noise param
+       n=fNoise; b=fBaseline;}
+    virtual Bool_t Do10to8() const {// get 10 to 8 compression option
+       return fBitComp;}
+    void    SetZeroSupp (const char *opt) {
+       // Zero-suppression option - could be 1D, 2D or non-ZS 
+       fOption=opt;}
+    const char *ZeroSuppOption() const {// Get zero-suppression option
+       return fOption.Data();}
+    virtual void   SetThresholds(Float_t  mv, Float_t /* b */){
+       // Min value used in 2D - could be used as a threshold setting
+       fMinVal = mv;}
+    virtual void   Thresholds(Float_t &  mv, Float_t & /* b */) const 
+      {mv = fMinVal;}
+    virtual void  GiveCompressParam(Int_t *x) const;
+    // Detector type response methods
+    virtual void    SetNSigmaIntegration(Float_t p1) {
+       // Set number of sigmas over which cluster disintegration is performed
+       fNsigmas=p1;}
+    virtual Float_t NSigmaIntegration() const {
+       // Get number of sigmas over which cluster disintegration is performed
+       return fNsigmas;}
+    virtual void SetNLookUp(Int_t p1);
+    // Get number of intervals in which the gaussian lookup table is divided
+    virtual Int_t GausNLookUp() const {return fNcomps;}
+    virtual Float_t GausLookUp(Int_t i) const  {
+       if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);}
+   
+//Declaration of member functions peculiar to this class
     void  SetNoiseAfterElectronics(Float_t n=2.38){
        // Noise after electronics (ADC units)
        // 2.36 for ALICE from beam test measurements 2001
        fNoiseAfterEl=n;}
-    void  GetNoiseParam(Float_t &n, Float_t &b) {// get noise param
-       n=fNoise; b=fBaseline;}
-    Float_t  GetNoiseAfterElectronics(){
+    Float_t  GetNoiseAfterElectronics() const {
        // Noise after electronics (ADC units)
        return fNoiseAfterEl;}
     void  SetJitterError(Float_t jitter=20) {
        // set Jitter error (20 um for ALICE from beam test measurements 2001)
        fJitterError=jitter;}
-    Float_t  JitterError() {// set Jitter error
+    Float_t  JitterError() const {// set Jitter error
        return fJitterError;}
     void  SetDo10to8(Bool_t bitcomp=kTRUE) {
        // set the option for 10 to 8 bit compression
        fBitComp = bitcomp;}
-    Bool_t Do10to8() const {// get 10 to 8 compression option
-       return fBitComp;}
-    void    SetZeroSupp (const char *opt="1D") {
-       // Zero-suppression option - could be 1D, 2D or non-ZS 
-       fOption=opt;}
-    const char *ZeroSuppOption() const {// Get zero-suppression option
-       return fOption.Data();}
-    void  SetMinVal(Int_t mv=4) {
-       // Min value used in 2D - could be used as a threshold setting
-       fMinVal = mv;}
-    Int_t  MinVal() const {// min val
-       return fMinVal;}
-    void   SetFilenames(const char *f1="",const char *f2="",const char *f3=""){
-       // Set filenames - input, output, parameters ....
-       fFileName1=f1; fFileName2=f2; fFileName3=f3;}
-    void   Filenames(char *input,char *baseline,char *param) {// Filenames
-       strcpy(input,fFileName1.Data());  strcpy(baseline,fFileName2.Data());  
-       strcpy(param,fFileName3.Data());}
-    void  SetOutputOption(Bool_t write=kFALSE) {// set output option
-       fWrite = write;}
-    Bool_t OutputOption() const {// output option
-       return fWrite;}
-    // 
     // Compression parameters
     void  SetCompressParam(Int_t cp[8]); 
-    void  GiveCompressParam(Int_t *x);
-    //
-    // Detector type response methods
-    void    SetNSigmaIntegration(Float_t p1=3.) {
-       // Set number of sigmas over which cluster disintegration is performed
-       fNsigmas=p1;}
-    Float_t NSigmaIntegration() const {
-       // Get number of sigmas over which cluster disintegration is performed
-       return fNsigmas;}
-    void SetNLookUp(Int_t p1=121) {
-       // Set number of sigmas over which cluster disintegration is performed
-       fNcomps=p1;
-       fGaus = new TArrayF(fNcomps+1);
-       for(Int_t i=0; i<=fNcomps; i++) {
-           Float_t x = -fNsigmas + (2.*i*fNsigmas)/(fNcomps-1);
-           (*fGaus)[i] = exp(-((x*x)/2));
-           //     cout << "fGaus[" << i << "]: " << fGaus->At(i) << endl;
-       }
-    }
-    // Get number of intervals in which the gaussian lookup table is divided
-    Int_t GausNLookUp() const {return fNcomps;}
-    Float_t IntPH(Float_t) const {// Pulse height from scored quantity (eloss)
-       return 0.;}
-    Float_t IntXZ(AliITSsegmentation *) const {// Charge disintegration 
-       return 0.;}
-    Float_t GausLookUp(Int_t i) const  {
-       if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);}
     void SetDeadChannels(Int_t nmodules=0, Int_t nchips=0, Int_t nchannels=0);
-    Int_t GetDeadModules() { return fDeadModules; }
-    Int_t GetDeadChips() { return fDeadChips; }
-    Int_t GetDeadChannels() { return fDeadChannels; }
-    Float_t Gain(Int_t mod,Int_t chip,Int_t ch){return fGain[mod][chip][ch]; }
+    Int_t GetDeadModules() const { return fDeadModules; }
+    Int_t GetDeadChips() const { return fDeadChips; }
+    Int_t GetDeadChannels() const { return fDeadChannels; }
+    Float_t Gain(Int_t mod,Int_t chip,Int_t ch)const {return fGain[mod][chip][ch]; }
     // these functions should be move to AliITSsegmentationSDD
-    const Int_t Modules() const{return fModules;}// Total number of SDD modules
-    const Int_t Chips() const{return fChips;} // Number of chips/module
-    const Int_t Channels() const { return fChannels;}// Number of channels/chip
+    const Int_t Modules() const{return fgkModules;}// Total number of SDD modules
+    const Int_t Chips() const{return fgkChips;} // Number of chips/module
+    const Int_t Channels() const { return fgkChannels;}// Number of channels/chip
     //********
     void    PrintGains();
     void    Print();
 
- private:
-    AliITSresponseSDD(const AliITSresponseSDD &source); // copy constructor
-    AliITSresponseSDD& operator=(const AliITSresponseSDD &source); // ass. op.
+    // not implemented virtual methods (devlared in the mother class
+    virtual  void   SetDetParam(Float_t *)
+      {NotImplemented("SetDetParam");}
+    virtual void   GetDetParam(Float_t *) const 
+      {NotImplemented("GetDetParam");}
+    virtual  void   SetNDetParam(Int_t /* n */)
+      {NotImplemented("SetNDetParam");}
+    virtual Int_t  NDetParam() const
+      {NotImplemented("NDetParam"); return 0;}
+    virtual void    SetSigmaSpread(Float_t, Float_t) 
+      {NotImplemented("SetSigmaSpread");}
+    virtual void    SigmaSpread(Float_t & /* p1 */,Float_t & /* p2 */) const 
+      {NotImplemented("SigmaSpread");}
 
  protected:
     // these statis const should be move to AliITSsegmentationSDD
-    static const Int_t fModules = 520;     // Total number of SDD modules
-    static const Int_t fChips = 4;        // Number of chips/module
-    static const Int_t fChannels = 64;    // Number of channels/chip
+    static const Int_t fgkModules = 520;     // Total number of SDD modules
+    static const Int_t fgkChips = 4;        // Number of chips/module
+    static const Int_t fgkChannels = 64;    // Number of channels/chip
     //*******
+    static const Int_t fgkMaxAdcDefault; // default for fMaxAdc
+    static const Float_t fgkDynamicRangeDefault; // default for fDynamicRange
+    static const Float_t fgkfChargeLossDefault; // default for fChargeLoss
+    static const Float_t fgkDiffCoeffDefault; // default for fDiffCoeff
+    static const Float_t fgkDiffCoeff1Default; // default for fDiffCoeff1 
+    static const Float_t fgkTemperatureDefault; // default for fT (Kelvin)
+    static const TString fgkParam1Default; // default for fParam1
+    static const TString fgkParam2Default; // default for fParam2
+    static const Float_t fgkNoiseDefault; // default for fNoise
+    static const Float_t fgkBaselineDefault; // default for fBaseline
+    static const TString fgkOptionDefault; // default for fOption
+    static const Float_t fgkMinValDefault; // default for fMinVal
+    static const Float_t fgkDriftSpeedDefault; // default for fDriftSpeed
+    static const Float_t fgkNsigmasDefault; //default for fNsigmas
+    static const Int_t fgkNcompsDefault; //default for fNcomps
+    //
+
     Int_t fDeadModules;                   // Total number of dead SDD modules
     Int_t fDeadChips;                     // Number of dead chips
     Int_t fDeadChannels;                  // Number of dead channels
-    Float_t   fGain[fModules][fChips][fChannels];   // Array for channel gains
+    Float_t   fGain[fgkModules][fgkChips][fgkChannels];   // Array for channel gains
     Int_t     fCPar[8];        // Hardware compression parameters
     Float_t   fNoise;          // Noise
     Float_t   fBaseline;       // Baseline
@@ -171,27 +166,25 @@ class AliITSresponseSDD : public AliITSresponse {
     Float_t   fJitterError;    // jitter error
     Float_t   fDynamicRange;   // Set Dynamic Range 
     Float_t   fChargeLoss;     // Set Linear Coefficient for Charge Loss 
-    Float_t   fTemperature;    // Temperature 
     Float_t   fDriftSpeed;     // Drift velocity
     Int_t     fElectronics;    // Electronics
-    Float_t    fMaxAdc;        // Adc saturation value
-    Float_t    fDiffCoeff;     // Diffusion Coefficient (scaling the time)
-    Float_t    fDiffCoeff1;    // Diffusion Coefficient (constant term)
-    Float_t    fNsigmas;   // Number of sigmas over which charge disintegration
+    Float_t   fMaxAdc;         // Adc saturation value
+    Float_t   fDiffCoeff;      // Diffusion Coefficient (scaling the time)
+    Float_t   fDiffCoeff1;     // Diffusion Coefficient (constant term)
+    Float_t   fNsigmas;    // Number of sigmas over which charge disintegration
                                // is performed
     TArrayF   *fGaus;          // Gaussian lookup table for signal generation
     Int_t      fNcomps;        // Number of samplings along the gaussian
-    Int_t      fMinVal;        // Min value used in 2D zero-suppression algo
-    Bool_t     fWrite;         // Write option for the compression algorithms
+    Float_t      fMinVal;        // Min value used in 2D zero-suppression algo
     Bool_t     fBitComp;       // 10 to 8 bit compression option
     TString    fOption;        // Zero-suppresion option (1D, 2D or none)
     TString    fParam1;        // Read baselines from file option
     TString    fParam2;        // Read compression algo thresholds from file
-    TString         fDataType;         // data type - real or simulated
-    TString         fFileName1;        // input keys : run, module #
-    TString         fFileName2;        // baseline & noise val or output code
-                                       // signal or monitored bgr.
-    TString         fFileName3;        // param values or output coded signal
+
+ private:
+    AliITSresponseSDD(const AliITSresponseSDD &ob); // copy constructor
+    AliITSresponseSDD& operator=(const AliITSresponseSDD & /* source */); // ass. op.
+
 
     ClassDef(AliITSresponseSDD,3) // SDD response 
     
index 483b984..3ef7697 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-
-#include <TMath.h>
+//////////////////////////////////////////////////////
+//  Response class for set:ITS                      //
+//  Specific subdetector implementation for         //
+//  Silicon pixels                                  //
+//  An alternative version "SPDdubna"               //
+//  is also available                               //
+//////////////////////////////////////////////////////
 
 #include "AliITSresponseSPD.h"
 
+const Float_t AliITSresponseSPD::fgkDiffCoeffDefault = 0.;
+const Float_t AliITSresponseSPD::fgkThreshDefault = 2000.;
+const Float_t AliITSresponseSPD::fgkSigmaDefault = 280.;
+
 ClassImp(AliITSresponseSPD)    
 //______________________________________________________________________
 AliITSresponseSPD::AliITSresponseSPD(){
   // constructor
 
-   SetThresholds();
-   SetNoiseParam();
+   SetThresholds(fgkThreshDefault,fgkSigmaDefault);
+   SetDiffCoeff(fgkDiffCoeffDefault,0.);
+   SetNoiseParam(0.,0.);
    SetDataType();
    SetFractionDead();
 }
index b7d8bf1..971ed87 100644 (file)
@@ -8,7 +8,6 @@ $Id$
 */
 
 #include "AliITSresponse.h"
-#include <TString.h>
 
 //----------------------------------------------
 //
@@ -18,33 +17,83 @@ class AliITSresponseSPD :  public AliITSresponse {
  public:
     AliITSresponseSPD(); // default constructor
     virtual ~AliITSresponseSPD() {} // destructror
-    // Configuration methods
-    // sets the diffusion coeffeciant.
-    virtual  void   SetDiffCoeff(Float_t p1=0) {fDiffCoeff=p1;}
+
+    // Implementation of virtual member functions declared in AliITSresponse 
+    // sets the diffusion coeffecient.
+    virtual  void   SetDiffCoeff(Float_t p1, Float_t /*dummy */) {fDiffCoeff=p1;}
     // returns the diffusion coeffeciant
-    virtual  Float_t   DiffCoeff() {return fDiffCoeff;}
+    virtual  void   DiffCoeff(Float_t &p1, Float_t & /*p2 */) const 
+                             {p1 = fDiffCoeff;}
     // Set Threshold and noise + threshold fluctuations parameter values
-    virtual  void   SetThresholds(Float_t thresh=2000, Float_t sigma=280)
+    virtual  void   SetThresholds(Float_t thresh, Float_t sigma)
        {fThresh=thresh; fSigma=sigma;}
     // Get Threshold and noise + threshold fluctuations parameter values
-    virtual  void   Thresholds(Float_t &thresh, Float_t &sigma)
+    virtual  void   Thresholds(Float_t &thresh, Float_t &sigma) const
        {thresh=fThresh; sigma=fSigma;}
     // set coupling parameters
-    virtual  void   SetNoiseParam(Float_t col=0., Float_t row=0.)
+    virtual  void   SetNoiseParam(Float_t col, Float_t row)
        {fCouplCol=col; fCouplRow=row;}   
     // get coupling parameters
-    virtual  void   GetNoiseParam(Float_t &col, Float_t &row)
+    virtual  void   GetNoiseParam(Float_t &col, Float_t &row) const 
        {col=fCouplCol; row=fCouplRow;}
+
+//Declaration of member functions peculiar to this class
     // Sets the fraction of Dead SPD Pixels
-    virtual void SetFractionDead(Float_t d=0.01){ fDeadPixels = d;}
+    void SetFractionDead(Float_t d=0.01){ fDeadPixels = d;}
     // Retruns the fraction of Dead SPD Pixels
-    virtual Float_t GetFractionDead(){return fDeadPixels;}
-    // Type of data - real or simulated
-    virtual void    SetDataType(char *data="simulated") {fDataType=data;}
-    // Get data typer
-    virtual const char  *DataType() const {return fDataType.Data();}
+    Float_t GetFractionDead() const {return fDeadPixels;}
+
+    //abstract methods in AliITSresponse not implemented in this class
+    virtual void    SetDriftSpeed(Float_t /* p1 */)
+      {NotImplemented("SetDriftSpeed");}
+    virtual Float_t DriftSpeed() const 
+      {NotImplemented("DrifSpeed"); return 0.;}
+    virtual void    GiveCompressParam(Int_t *) const
+      {NotImplemented("GiveCompressParam");}
+    virtual void   SetElectronics(Int_t /* i */) 
+                    {NotImplemented("SetElectronics");}
+    virtual Int_t Electronics() const {NotImplemented("Electronics"); return 0;}
+    virtual void SetMaxAdc(Float_t /* adc */) {NotImplemented("SetMaxAdc");}
+    virtual Float_t MaxAdc() const {NotImplemented("MaxAdc"); return 0.;}
+    virtual void    SetDynamicRange(Float_t /*dr */) 
+      {NotImplemented("SetDynamicRange");}
+    virtual Float_t DynamicRange() const 
+      {NotImplemented("DynamicRange"); return 0.;}
+    virtual void    SetChargeLoss(Float_t /* cl */)
+      {NotImplemented("SetChargeLoss"); }
+    virtual Float_t ChargeLoss() const 
+      {NotImplemented("ChargeLoss"); return 0.;}
+    virtual  void   SetDetParam(Float_t *)
+      {NotImplemented("SetDetParam");}
+    virtual void   GetDetParam(Float_t *) const 
+      {NotImplemented("GetDetParam");}
+    virtual  void   SetNDetParam(Int_t /* n */)
+      {NotImplemented("SetNDetParam");}
+    virtual Int_t  NDetParam() const
+      {NotImplemented("NDetParam"); return 0;}
+    virtual void   SetParamOptions(const char* /* a */,const char* /* b */)
+      {NotImplemented("SetParamOptions");}
+    virtual void   ParamOptions(char *,char*) const
+      {NotImplemented("ParamOptions");} 
+    virtual void   SetZeroSupp(const char*)
+      {NotImplemented("SetZeroSupp");}
+    virtual const char *ZeroSuppOption() const 
+      {NotImplemented("ZeroSuppression"); return "";}
+    virtual void    SetNSigmaIntegration(Float_t)
+      {NotImplemented("SetNSigmaIntegration");}
+    virtual Float_t NSigmaIntegration() const
+      {NotImplemented("NSigmaIntegration"); return 0.;}
+    virtual void    SetNLookUp(Int_t) 
+      {NotImplemented("SetNLookUp");}
+    virtual void    SetSigmaSpread(Float_t, Float_t) 
+      {NotImplemented("SetSigmaSpread");}
+    virtual void    SigmaSpread(Float_t & /* p1 */,Float_t & /* p2 */) const 
+      {NotImplemented("SigmaSpread");}
 
  protected:
+    static const Float_t fgkDiffCoeffDefault; //default for fDiffCoeff
+    static const Float_t fgkThreshDefault; //default for fThresh
+    static const Float_t fgkSigmaDefault; //default for fSigma
     Float_t fDiffCoeff;       // Sigma diffusion coefficient (not used) 
     Float_t fThresh;          // Threshold value
     Float_t fSigma;           // Noise + threshold fluctuations value
@@ -52,9 +101,8 @@ class AliITSresponseSPD :  public AliITSresponse {
     Float_t fCouplRow;        // Coupling probability along a row
     Float_t fDeadPixels;      // the fraction of dead pixels
 
-    TString fDataType;        // Type of data - real or simulated
 
-    ClassDef(AliITSresponseSPD,1) // SPD response
+    ClassDef(AliITSresponseSPD,2) // SPD response
 };
 
 #endif
index f7ae06b..a3f5cbd 100644 (file)
  * about the suitability of this software for any purpose. It is          *
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
-#include <Riostream.h>
-#include <TMath.h>
-#include <TRandom.h>
 
+#include<Riostream.h>
 #include "AliITSresponseSPDdubna.h"
+//////////////////////////////////////////////////////
+//  Response class for set:ITS                      //
+//  Specific subdetector implementation for         //
+//  Silicon pixels                                  //
+//  This is and alternative version                 //
+//  to the default version                          //
+////////////////////////////////////////////////////// 
+const Float_t AliITSresponseSPDdubna::fgkNoiseDefault = 200.;
+const Float_t AliITSresponseSPDdubna::fgkThresholdDefault = 2000.;
+
 //___________________________________________
 ClassImp(AliITSresponseSPDdubna)       
 
@@ -30,8 +37,8 @@ AliITSresponseSPDdubna::AliITSresponseSPDdubna() : AliITSresponse(){
    // Return:
    //    A default constructed AliITSresponseSPD class
 
-   SetNoiseParam();  // fNoise, fBaseline
-   SetThreshold();   // fThreshold
+   SetNoiseParam(fgkNoiseDefault,0.);  // fNoise, fBaseline
+   SetThresholds(fgkThresholdDefault,0.);   // fThreshold
    SetCouplings();   // fCouplCol, fCouplRow
    SetFractionDeadPixels(); // fDeadPixels
    SetDataType();    // fDataType
@@ -57,8 +64,9 @@ Bool_t AliITSresponseSPDdubna::IsPixelDead(Int_t mod,Int_t ix,Int_t iz) const {
   if(ran.Rndm(0)<fDeadPixels) dead = kTRUE;
   return dead;
 }
+
 //----------------------------------------------------------------------
-void AliITSresponseSPDdubna::Print(ostream *os){
+void AliITSresponseSPDdubna::Print(ostream *os) const{
     // Standard output format for this class.
     // Inputs:
     //    ostream *os  Pointer to the output stream
@@ -66,31 +74,17 @@ void AliITSresponseSPDdubna::Print(ostream *os){
     //    none:
     // Return:
     //    none.
-#if defined __GNUC__
-#if __GNUC__ > 2
-    ios::fmtflags fmt;
-#else
-    Int_t fmt;
-#endif
-#else
-#if defined __ICC || defined __ECC
-    ios::fmtflags fmt;
-#else
-    Int_t fmt;
-#endif
-#endif
 
     AliITSresponse::Print(os);
-    fmt = os->setf(ios::scientific);  // set scientific floating point output
     *os << fNoise << " " << fBaseline << " " << fCouplCol << " ";
     *os << fCouplRow << " "<< fThreshold << " " << fDeadPixels << " ";
     *os << fDataType;
 //    *os << " " << endl;
-    os->flags(fmt); // reset back to old formating.
     return;
 }
+
 //----------------------------------------------------------------------
-void AliITSresponseSPDdubna::Read(istream *is){
+void AliITSresponseSPDdubna::Read(istream *is) {
     // Standard input format for this class.
     // Inputs:
     //    ostream *os  Pointer to the output stream
@@ -99,12 +93,13 @@ void AliITSresponseSPDdubna::Read(istream *is){
     // Return:
     //    none.
 
-    AliITSresponseSPDdubna::Read(is);
+    AliITSresponse::Read(is);
     *is >> fNoise >> fBaseline >> fCouplCol >> fCouplRow;
     *is >> fThreshold >> fDeadPixels >> fDataType;
     return;
 }
 //----------------------------------------------------------------------
+
 ostream &operator<<(ostream &os,AliITSresponseSPDdubna &p){
     // Standard output streaming function.
     // Inputs:
@@ -117,6 +112,7 @@ ostream &operator<<(ostream &os,AliITSresponseSPDdubna &p){
     p.Print(&os);
     return os;
 }
+
 //----------------------------------------------------------------------
 istream &operator>>(istream &is,AliITSresponseSPDdubna &r){
     // Standard input streaming function.
index 383d95d..5d99e0c 100644 (file)
@@ -5,8 +5,9 @@
 
 /* $Id$ */
 
-#include <TString.h>
 #include <TRandom.h>
+class TString;
+
 
 #include "AliITSresponse.h"
 
@@ -16,54 +17,109 @@ class AliITSresponseSPDdubna : public AliITSresponse {
  public:
   AliITSresponseSPDdubna();
   virtual ~AliITSresponseSPDdubna(){}// destructror
-  //
+//abstract methods in AliITSresponse not implemented in this class
+    virtual void    GiveCompressParam(Int_t *) const
+      {NotImplemented("GiveCompressParam");}
+    virtual void    SetDriftSpeed(Float_t /* p1 */)
+      {NotImplemented("SetDriftSpeed");}
+    virtual Float_t DriftSpeed() const 
+      {NotImplemented("DrifSpeed"); return 0.;}
+    virtual void   SetElectronics(Int_t /* i */) 
+                    {NotImplemented("SetElectronics");}
+    virtual Int_t Electronics() const {NotImplemented("Electronics"); return 0;}
+    virtual void SetMaxAdc(Float_t /* adc */) {NotImplemented("SetMaxAdc");}
+    virtual Float_t MaxAdc() const {NotImplemented("MaxAdc"); return 0.;}
+    virtual void    SetDynamicRange(Float_t /*dr */) 
+      {NotImplemented("SetDynamicRange");}
+    virtual Float_t DynamicRange() const 
+      {NotImplemented("DynamicRange"); return 0.;}
+    virtual void    SetChargeLoss(Float_t /* cl */)
+      {NotImplemented("SetChargeLoss"); }
+    virtual Float_t ChargeLoss() const 
+      {NotImplemented("ChargeLoss"); return 0.;}
+    virtual void    SetDiffCoeff(Float_t /* a */, Float_t /* b */)
+      {NotImplemented("SetDiffCoeff");}
+    virtual void    DiffCoeff(Float_t & /* a */,Float_t & /* b */) const
+      {NotImplemented("DiffCoeff");}
+    virtual  void   SetDetParam(Float_t *)
+      {NotImplemented("SetDetParam");}
+    virtual void   GetDetParam(Float_t *) const 
+      {NotImplemented("GetDetParam");}
+    virtual  void   SetNDetParam(Int_t /* n */)
+      {NotImplemented("SetNDetParam");}
+    virtual Int_t  NDetParam() const
+      {NotImplemented("NDetParam"); return 0;}
+    virtual void   SetParamOptions(const char* /* a */,const char* /* b */)
+      {NotImplemented("SetParamOptions");}
+    virtual void   ParamOptions(char *,char*) const
+      {NotImplemented("ParamOptions");} 
+    virtual void   SetZeroSupp(const char*)
+      {NotImplemented("SetZeroSupp");}
+    virtual const char *ZeroSuppOption() const 
+      {NotImplemented("ZeroSuppression"); return "";}
+    virtual void    SetNSigmaIntegration(Float_t)
+      {NotImplemented("SetNSigmaIntegration");}
+    virtual Float_t NSigmaIntegration() const
+      {NotImplemented("NSigmaIntegration"); return 0.;}
+    virtual void    SetNLookUp(Int_t) 
+      {NotImplemented("SetNLookUp");}
+    virtual void    SetSigmaSpread(Float_t, Float_t) 
+      {NotImplemented("SetSigmaSpread");}
+    virtual void    SigmaSpread(Float_t & /* p1 */,Float_t & /* p2 */) const 
+      {NotImplemented("SigmaSpread");}
+
+// Implementation of virtual member functions declared in AliITSresponse 
   // set noise and baseline
-  virtual void SetNoiseParam(Float_t n=200., Float_t b=0.) {
+  virtual void SetNoiseParam(Float_t n, Float_t b) {
     fNoise=n; fBaseline=b;}
-  // Returns just noise value
-  virtual Float_t GetNoise() const {return fNoise;} 
-  //Returns just baseline value
-  virtual Float_t GetBaseline() const {return fBaseline;}
-  virtual void GetNoiseParam(Float_t &n, Float_t &b) {
+  virtual void GetNoiseParam(Float_t &n, Float_t &b) const {
     n=fNoise; b=fBaseline;} // get noise and baseline
-  // Applies a randome noise and addes the baseline
-  virtual Float_t ApplyBaselineAndNoise() const {return fBaseline+
-                                                 fNoise*gRandom->Gaus();}
   // Zero-suppression option threshold
-  virtual void SetThreshold(Int_t th=2000) {fThreshold=th;}
+  virtual void SetThresholds(Float_t th, Float_t /* dum */) {fThreshold=th;}
+  virtual void Thresholds(Float_t & thr, Float_t & /*dum */) const
+    {thr = fThreshold;}
+
+  // Prints out the content of this class in ASCII format.
+  virtual void Print(ostream *os) const;
+
+  // Reads in the content of this class in the format of Print
+  virtual void Read(istream *is);
+
+//Declaration of member functions peculiar to this class
+  // Applies a random noise and addes the baseline
+  Float_t ApplyBaselineAndNoise() const {return fBaseline+
+                                                 fNoise*gRandom->Gaus();}
+  //Returns just baseline value
+  Float_t GetBaseline() const {return fBaseline;}
+  // Returns just noise value
+  Float_t GetNoise() const {return fNoise;} 
   // Get zero-suppression threshold
-  virtual Float_t GetThreshold() const {return fThreshold;}
+  Float_t GetThreshold() const {return fThreshold;}
   // Sets the coupling probabilities for columns and rows
-  virtual void SetCouplings(Float_t ccol=0.,Float_t crow=0.){fCouplCol=ccol;
+  void SetCouplings(Float_t ccol=0.,Float_t crow=0.){fCouplCol=ccol;
                                                        fCouplRow=crow;}
   // Gets the coupling probabilities for columns and rows
-  virtual void GetCouplings(Float_t &ccol,Float_t &crow){ccol=fCouplCol;
-                                                         crow=fCouplRow;}
-  // Retruns the fraction of dead pixels
-  virtual Float_t GetFractionDeadPixels() const {return fDeadPixels;}
+  void GetCouplings(Float_t &ccol,Float_t &crow) const 
+              {ccol=fCouplCol; crow=fCouplRow;}
+  // Returns the fraction of dead pixels
+  Float_t GetFractionDeadPixels() const {return fDeadPixels;}
   // Sets the fraction of dead pixels
-  virtual void SetFractionDeadPixels(Float_t f=0.01){fDeadPixels = f;}
+  void SetFractionDeadPixels(Float_t f=0.01){fDeadPixels = f;}
   // Returns a logical if a pixels is dead or not
-  virtual Bool_t IsPixelDead(Int_t mod,Int_t ix,Int_t iz) const ;
-  // Sets the Type of data -real or simulated
-  virtual void SetDataType(const char *data="simulated") {fDataType=data;}
-  // Get data type, real or simulated.
-  virtual const char* DataType() const {return fDataType.Data();}
-  // Prints out the content of this class in ASCII format.
-  virtual void Print(ostream *os);
-  // Reads in the content of this class in the format of Print
-  virtual void Read(istream *is);
+  Bool_t IsPixelDead(Int_t mod,Int_t ix,Int_t iz) const ;
 
-  ClassDef(AliITSresponseSPDdubna,2) // SPD response
-    ;
+  ClassDef(AliITSresponseSPDdubna,3) // SPD response
+    
  protected:
+  static const Float_t fgkNoiseDefault; // default for fNoise
+  static const Float_t fgkThresholdDefault; //default for fThreshold
   Float_t fNoise;           // Noise value
   Float_t fBaseline;        // Baseline value
   Float_t fCouplCol;        // Coupling Probability along columns
   Float_t fCouplRow;        // Coupling Probability along rows
   Float_t fThreshold;       // Zero-Suppression threshold
   Float_t fDeadPixels;      // Fraction of dead pixels.
-  TString fDataType;        // Type of data - real or simulated
 };
 // Input and output function for standard C++ input/output.
 ostream& operator<<(ostream &os,AliITSresponseSPDdubna &source);
index da4e804..b0a0a70 100644 (file)
  * provided "as is" without express or implied warranty.                  *
  **************************************************************************/
 
-#include <TMath.h>
-#include <TString.h>
 
 #include "AliITSresponseSSD.h"
-#include "AliITSgeom.h"
+//////////////////////////////////////////////////
+//  Response class for set:ITS                      //
+//  Specific subdetector implementation             //
+//  for silicon strips detectors                    //
+//                                                  //
+//                                                  //
+//////////////////////////////////////////////////////
+
+const Float_t AliITSresponseSSD::fgkDiffCoeffDefault = 0.;
+const TString AliITSresponseSSD::fgkOption1Default = "";
+const TString AliITSresponseSSD::fgkOption2Default = "";
+const Float_t AliITSresponseSSD::fgkNoiseNDefault = 625.;
+const Float_t AliITSresponseSSD::fgkNoisePDefault = 420.;
+const Int_t AliITSresponseSSD::fgkNParDefault = 6;
+const Float_t AliITSresponseSSD::fgkSigmaPDefault = 3.;
+const Float_t AliITSresponseSSD::fgkSigmaNDefault = 2.;
 
 ClassImp(AliITSresponseSSD)
 
@@ -33,17 +46,19 @@ AliITSresponseSSD::AliITSresponseSSD(){
     fSigmaN = 0;
     fDiffCoeff = 0;
     fADCpereV  = 0;
+    SetParamOptions(fgkOption1Default.Data(),fgkOption2Default.Data());
+    SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
 }
 //______________________________________________________________________
 AliITSresponseSSD::AliITSresponseSSD(const char *dataType){
     // constructor
 
-    SetDiffCoeff();
-    SetNoiseParam();
+    SetDiffCoeff(fgkDiffCoeffDefault,0.);
+    SetNoiseParam(fgkNoisePDefault,fgkNoiseNDefault);
     SetDataType(dataType);
-    SetSigmaSpread();
-    SetParamOptions();
-    SetNDetParam();   // Sets fNPar=6 by default.
+    SetSigmaSpread(fgkSigmaPDefault,fgkSigmaNDefault);
+    SetParamOptions(fgkOption1Default.Data(),fgkOption2Default.Data());
+    SetNDetParam(fgkNParDefault);   // Sets fNPar=6 by default.
     SetADCpereV();
     fDetPar = new Float_t[fNPar];
     if (fNPar==6) {
@@ -99,7 +114,7 @@ void AliITSresponseSSD::SetDetParam(Float_t  *par){
     } // end for i
 }
 //______________________________________________________________________
-void AliITSresponseSSD::GetDetParam(Float_t  *par){
+void AliITSresponseSSD::GetDetParam(Float_t  *par) const {
     // get det param
     Int_t i;
 
index 2e6a232..770152b 100644 (file)
@@ -3,7 +3,6 @@
  
 #include "AliITSresponse.h"
 
-class TString;
 
 // response for SSD
 
@@ -14,39 +13,37 @@ class AliITSresponseSSD : public AliITSresponse {
     AliITSresponseSSD();
     AliITSresponseSSD(const char *dataType);
     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.) {
+// Implementation of virtual member functions declared in AliITSresponse 
+    virtual void    SetDiffCoeff(Float_t p1,Float_t /* dummy */) {
        // Diffusion coefficient
-       fDiffCoeff=p1;dummy = 0.0;
-    }
-    virtual void    DiffCoeff(Float_t &diffc,Float_t &dummy) {
+      fDiffCoeff=p1; }
+    virtual void    DiffCoeff(Float_t &diffc,Float_t & /* dummy */) const {
        // Get diffusion coefficient
-       diffc= fDiffCoeff;dummy = 0.0;
+       diffc= fDiffCoeff;
     }
 
-    virtual  void   SetNoiseParam(Float_t np=420., Float_t nn=625.) {
+    virtual  void   SetNoiseParam(Float_t np, Float_t nn) {
        // set noise par
        fNoiseP=np; fNoiseN=nn;
     }
-    virtual void    GetNoiseParam(Float_t &np, Float_t &nn) {
+    virtual void    GetNoiseParam(Float_t &np, Float_t &nn) const {
        // get noise par
        np=fNoiseP; nn=fNoiseN;
     }
 
-    virtual void    SetParamOptions(const char *opt1="", const char *opt2="") {
+    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) {
+    virtual void    ParamOptions(char *opt1,char *opt2) const {
        // 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) {
+    virtual  void   SetNDetParam(Int_t npar) {
        // set number of param
        fNPar=npar;
     }
@@ -58,43 +55,76 @@ class AliITSresponseSSD : public AliITSresponse {
        // number of param
        return fNPar;
     }
-    virtual void    GetDetParam(Float_t *dpar); 
+    virtual void    GetDetParam(Float_t *dpar) const; 
 
-    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.) {
+    virtual void    SetSigmaSpread(Float_t p1, Float_t p2) {
        // 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) {
+    virtual void    SigmaSpread(Float_t &sP, Float_t &sN) const {
        // Get sigmas for the charge spread 
        sP=fSigmaP; sN=fSigmaN;
     }
-    virtual void SetADCpereV(Float_t a=50./30000.0){ // Sets electron-hole
-       // pairs to ADC value conversion factor are rather arbitrary
-       // (need tuning) minimum ionizing particle--> ~30000 pairs--> ADC
-       // channel 50
-       fADCpereV = a;
-    }
-    virtual Double_t DEvToADC(Double_t eV){ // Converts electron-hole pairs 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 electron-hole pairs to
+
+//Declaration of member functions peculiar to this class
+
+// Sets electron-hole pairs to ADC value conversion factor
+// are rather arbitrary (need tuning)
+// minimum ionizing particle--> ~30000 pairs--> ADC channel 50
+    void SetADCpereV(Float_t a=50./30000.0){fADCpereV = a;}
+// Converts electron-hole pairs to
+// ADC value conversion factor are rather arbitrary (need tuning)
+// minimum ionizing particle--> ~30000 pairs--> ADC channel 50
+    Double_t DEvToADC(Double_t eV){return eV*fADCpereV;}
+    Int_t IEvToADC(Double_t eV){ // Converts electron-hole pairs to
        // ADC value
-       return ((Int_t) DEvToADC(eV));
-    }
+       return ((Int_t) DEvToADC(eV)); }
+
+ //abstract methods in AliITSresponse not implemented in this class
+    virtual void    SetDriftSpeed(Float_t /* p1 */)
+      {NotImplemented("SetDriftSpeed");}
+    virtual Float_t DriftSpeed() const 
+      {NotImplemented("DrifSpeed"); return 0.;}
+    virtual void   SetElectronics(Int_t /* i */) 
+                    {NotImplemented("SetElectronics");}
+    virtual Int_t Electronics() const {NotImplemented("Electronics"); return 0;}
+    virtual void    GiveCompressParam(Int_t *) const
+      {NotImplemented("GiveCompressParam");}
+    virtual void SetMaxAdc(Float_t /* adc */) {NotImplemented("SetMaxAdc");}
+    virtual Float_t MaxAdc() const {NotImplemented("MaxAdc"); return 0.;}
+    virtual void    SetDynamicRange(Float_t /*dr */) 
+      {NotImplemented("SetDynamicRange");}
+    virtual Float_t DynamicRange() const 
+      {NotImplemented("DynamicRange"); return 0.;}
+    virtual void    SetChargeLoss(Float_t /* cl */)
+      {NotImplemented("SetChargeLoss"); }
+    virtual Float_t ChargeLoss() const 
+      {NotImplemented("ChargeLoss"); return 0.;}
+    virtual void   SetThresholds(Float_t /* a */, Float_t /* b */)
+      {NotImplemented("SetThresholds");}
+    virtual void   Thresholds(Float_t & /* a */, Float_t & /* b */) const 
+      {NotImplemented("Thresholds");}
+    virtual void   SetZeroSupp(const char*)
+      {NotImplemented("SetZeroSupp");}
+    virtual const char *ZeroSuppOption() const 
+      {NotImplemented("ZeroSuppression"); return "";}
+    virtual void    SetNSigmaIntegration(Float_t)
+      {NotImplemented("SetNSigmaIntegration");}
+    virtual Float_t NSigmaIntegration() const
+      {NotImplemented("NSigmaIntegration"); return 0.;}
+    virtual void    SetNLookUp(Int_t) 
+      {NotImplemented("SetNLookUp");}
   
  protected:
+    static const Float_t fgkDiffCoeffDefault; //default for fDiffCoeff
+    static const TString fgkOption1Default; // default for fOption1
+    static const TString fgkOption2Default; // default for fOption2
+    static const Float_t fgkNoiseNDefault; // default for fNoiseN
+    static const Float_t fgkNoisePDefault; // default for fNoiseP
+    static const Int_t fgkNParDefault; // default for fNPar
+    static const Float_t fgkSigmaPDefault; //default for fSigmaP
+    static const Float_t fgkSigmaNDefault; //default for fSigmaP
     Int_t   fNPar;            // Number of detector param 
     Float_t *fDetPar;         //[fNPar] Array of parameters
 
@@ -109,7 +139,10 @@ class AliITSresponseSSD : public AliITSresponse {
 
     TString fOption1;         // Simulate invalid strips option
     TString fOption2;         // Not used for the moment
-    TString fDataType;       // Type of data - real or simulated
+
+ private:
+    AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
+    AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
 
     ClassDef(AliITSresponseSSD,1) //Response class for SSD
 };
index 9034886..852aba3 100644 (file)
@@ -1213,7 +1213,9 @@ void AliITSsimulationSDD::Init2D(){
     Float_t *savesigma = new Float_t [fNofMaps];
     char input[100],basel[100],par[100];
     char *filtmp;
-    Int_t minval = fResponse->MinVal();
+    Float_t tmp1,tmp2;
+    fResponse->Thresholds(tmp1,tmp2);
+    Int_t minval = static_cast<Int_t>(tmp1);
 
     fResponse->Filenames(input,basel,par);
     fFileName = par;
@@ -1256,8 +1258,10 @@ void AliITSsimulationSDD::Init2D(){
 void AliITSsimulationSDD::Compress2D(){
     // simple ITS cluster finder -- online zero-suppression conditions
 
-    Int_t db,tl,th;  
-    Int_t minval   = fResponse->MinVal();
+    Int_t db,tl,th; 
+    Float_t tmp1,tmp2;
+    fResponse->Thresholds(tmp1,tmp2); 
+    Int_t minval   = static_cast<Int_t>(tmp1);
     Bool_t write   = fResponse->OutputOption();   
     Bool_t do10to8 = fResponse->Do10to8();
     Int_t nz, nl, nh, low, i, j; 
@@ -1351,7 +1355,9 @@ void AliITSsimulationSDD::Init1D(){
     Float_t *savesigma = new Float_t [fNofMaps];
     char input[100],basel[100],par[100];
     char *filtmp;
-    Int_t minval = fResponse->MinVal();
+    Float_t tmp1,tmp2;
+    fResponse->Thresholds(tmp1,tmp2);
+    Int_t minval = static_cast<Int_t>(tmp1);
 
     fResponse->Filenames(input,basel,par);
     fFileName=par;
index b7a2d44..4127636 100644 (file)
@@ -10,7 +10,7 @@ class AliITStrackV2Pid : public TObject {
 public:
     AliITStrackV2Pid();
     virtual ~AliITStrackV2Pid(){}
-public:
+protected:
     Float_t fWpi,fWk,fWp,fSignal,fMom;
     Float_t fPhi,fLam;
     Int_t   fPcode;
index 583207e..9fb83df 100644 (file)
@@ -584,7 +584,6 @@ void AliITSvSPD02::SetDefaults(){
     // Get shape info. Do it this way for now.
     s0 = (AliITSgeomSPD*) fITSgeom->GetShape(kSPD);
     AliITSresponse *resp0=new AliITSresponseSPDdubna();
-    ((AliITSresponseSPDdubna*)resp0)->SetNoiseParam();
     resp0->SetTemperature();
     resp0->SetDistanceOverVoltage();
     SetResponseModel(kSPD,resp0);