ITS/AliITSresponseSSD.h

   1 #ifndef ALIITSRESPONSESSD_H
   2 #define ALIITSRESPONSESSD_H
   3
   4 #include "AliITSresponse.h"
   5
   6
   7 // response for SSD
   8
   9 //-----------------------------
  10 class AliITSresponseSSD : public AliITSresponse {
  11
  12  public:
  13     AliITSresponseSSD();
  14     AliITSresponseSSD(const char *dataType);
  15     virtual ~AliITSresponseSSD();
  16
  17 // Implementation of virtual member functions declared in AliITSresponse
  18     virtual void    SetDiffCoeff(Double_t p1,Double_t /* dummy */) {
  19         // Diffusion coefficient
  20       fDiffCoeff=p1; }
  21     virtual void    DiffCoeff(Double_t &diffc,Double_t & /* dummy */) const {
  22         // Get diffusion coefficient
  23         diffc= fDiffCoeff;
  24     }
  25
  26     virtual  void   SetNoiseParam(Double_t np, Double_t nn) {
  27         // set noise par
  28         fNoiseP=np; fNoiseN=nn;
  29     }
  30     virtual void    GetNoiseParam(Double_t &np, Double_t &nn) const {
  31         // get noise par
  32         np=fNoiseP; nn=fNoiseN;
  33     }
  34
  35     virtual void    SetParamOptions(const char *opt1, const char *opt2) {
  36         // parameters: "SetInvalid" to simulate the invalid strips
  37         fOption1=opt1; fOption2=opt2;
  38     }
  39     virtual void    ParamOptions(char *opt1,char *opt2) const {
  40         // options
  41         strcpy(opt1,fOption1.Data());  strcpy(opt2,fOption2.Data());
  42     }
  43
  44     // Number of parameters to be set
  45     // 4 couplings, mean number of invalid strips, RMS of invalid strips
  46     virtual  void   SetNDetParam(Int_t npar) {
  47         // set number of param
  48         fNPar=npar;
  49     }
  50
  51     virtual  void   SetDetParam(Double_t *par);
  52
  53     // Parameters options
  54     virtual Int_t   NDetParam() const {
  55         // number of param
  56         return fNPar;
  57     }
  58     virtual void    GetDetParam(Double_t *dpar) const;
  59
  60     virtual void    SetSigmaSpread(Double_t p1, Double_t p2) {
  61         // Set sigmas of the charge spread function: Pside-Nside
  62         // square of (microns)
  63         fSigmaP=p1; fSigmaN=p2;
  64     }
  65     virtual void    SigmaSpread(Double_t &sP, Double_t &sN) const {
  66         // Get sigmas for the charge spread
  67         sP=fSigmaP; sN=fSigmaN;
  68     }
  69
  70 //Declaration of member functions peculiar to this class
  71
  72 // Sets electron-hole pairs to ADC value conversion factor
  73 // are rather arbitrary (need tuning)
  74 // minimum ionizing particle--> ~30000 pairs--> ADC channel 50
  75     void SetADCpereV(Double_t a=50./30000.0){fADCpereV = a;}
  76 // Converts electron-hole pairs to
  77 // ADC value conversion factor are rather arbitrary (need tuning)
  78 // minimum ionizing particle--> ~30000 pairs--> ADC channel 50
  79     Double_t DEvToADC(Double_t eV){return eV*fADCpereV;}
  80     Int_t IEvToADC(Double_t eV){ // Converts electron-hole pairs to
  81         // ADC value
  82         return ((Int_t) DEvToADC(eV)); }
  83
  84  //abstract methods in AliITSresponse not implemented in this class
  85     virtual void    SetDriftSpeed(Double_t /* p1 */)
  86       {NotImplemented("SetDriftSpeed");}
  87     virtual Double_t DriftSpeed() const
  88       {NotImplemented("DrifSpeed"); return 0.;}
  89     virtual void    GiveCompressParam(Int_t *) const
  90       {NotImplemented("GiveCompressParam");}
  91     virtual Double_t ChargeLoss() const
  92       {NotImplemented("ChargeLoss"); return 0.;}
  93     virtual void   SetThresholds(Double_t /* a */, Double_t /* b */)
  94       {NotImplemented("SetThresholds");}
  95     virtual void   Thresholds(Double_t & /* a */, Double_t & /* b */) const
  96       {NotImplemented("Thresholds");}
  97     virtual void   SetZeroSupp(const char*)
  98       {NotImplemented("SetZeroSupp");}
  99     virtual const char *ZeroSuppOption() const
 100       {NotImplemented("ZeroSuppression"); return "";}
 101     virtual void    SetNSigmaIntegration(Double_t)
 102       {NotImplemented("SetNSigmaIntegration");}
 103     virtual Double_t NSigmaIntegration() const
 104       {NotImplemented("NSigmaIntegration"); return 0.;}
 105     virtual void    SetNLookUp(Int_t)
 106       {NotImplemented("SetNLookUp");}
 107
 108  protected:
 109     static const Double_t fgkDiffCoeffDefault; //default for fDiffCoeff
 110     static const TString fgkOption1Default; // default for fOption1
 111     static const TString fgkOption2Default; // default for fOption2
 112     static const Double_t fgkNoiseNDefault; // default for fNoiseN
 113     static const Double_t fgkNoisePDefault; // default for fNoiseP
 114     static const Int_t fgkNParDefault; // default for fNPar
 115     static const Double_t fgkSigmaPDefault; //default for fSigmaP
 116     static const Double_t fgkSigmaNDefault; //default for fSigmaP
 117     Int_t   fNPar;            // Number of detector param
 118     Double_t *fDetPar;         //[fNPar] Array of parameters
 119
 120     Double_t fNoiseP;          // Noise on Pside
 121     Double_t fNoiseN;          // Noise on Nside
 122
 123     Double_t fSigmaP;          // Sigma charge spread on Pside
 124     Double_t fSigmaN;          // Sigma charge spread on Nside
 125     Double_t fDiffCoeff;       // Diffusion Coefficient
 126
 127     Double_t fADCpereV;        // Constant to convert eV to ADC.
 128
 129     TString fOption1;         // Simulate invalid strips option
 130     TString fOption2;         // Not used for the moment
 131
 132  private:
 133     AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
 134     AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
 135
 136     ClassDef(AliITSresponseSSD,2) //Response class for SSD
 137 };
 138 #endif