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(Float_t p1,Float_t /* dummy */) {
  19         // Diffusion coefficient
  20       fDiffCoeff=p1; }
  21     virtual void    DiffCoeff(Float_t &diffc,Float_t & /* dummy */) const {
  22         // Get diffusion coefficient
  23         diffc= fDiffCoeff;
  24     }
  25
  26     virtual  void   SetNoiseParam(Float_t np, Float_t nn) {
  27         // set noise par
  28         fNoiseP=np; fNoiseN=nn;
  29     }
  30     virtual void    GetNoiseParam(Float_t &np, Float_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(Float_t *par);
  52
  53     // Parameters options
  54     virtual Int_t   NDetParam() const {
  55         // number of param
  56         return fNPar;
  57     }
  58     virtual void    GetDetParam(Float_t *dpar) const;
  59
  60     virtual void    SetSigmaSpread(Float_t p1, Float_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(Float_t &sP, Float_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(Float_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(Float_t /* p1 */)
  86       {NotImplemented("SetDriftSpeed");}
  87     virtual Float_t DriftSpeed() const
  88       {NotImplemented("DrifSpeed"); return 0.;}
  89     virtual void   SetElectronics(Int_t /* i */)
  90                     {NotImplemented("SetElectronics");}
  91     virtual Int_t Electronics() const {NotImplemented("Electronics"); return 0;}
  92     virtual void    GiveCompressParam(Int_t *) const
  93       {NotImplemented("GiveCompressParam");}
  94     virtual void SetMaxAdc(Float_t /* adc */) {NotImplemented("SetMaxAdc");}
  95     virtual Float_t MaxAdc() const {NotImplemented("MaxAdc"); return 0.;}
  96     virtual void    SetDynamicRange(Float_t /*dr */)
  97       {NotImplemented("SetDynamicRange");}
  98     virtual Float_t DynamicRange() const
  99       {NotImplemented("DynamicRange"); return 0.;}
 100     virtual void    SetChargeLoss(Float_t /* cl */)
 101       {NotImplemented("SetChargeLoss"); }
 102     virtual Float_t ChargeLoss() const
 103       {NotImplemented("ChargeLoss"); return 0.;}
 104     virtual void   SetThresholds(Float_t /* a */, Float_t /* b */)
 105       {NotImplemented("SetThresholds");}
 106     virtual void   Thresholds(Float_t & /* a */, Float_t & /* b */) const
 107       {NotImplemented("Thresholds");}
 108     virtual void   SetZeroSupp(const char*)
 109       {NotImplemented("SetZeroSupp");}
 110     virtual const char *ZeroSuppOption() const
 111       {NotImplemented("ZeroSuppression"); return "";}
 112     virtual void    SetNSigmaIntegration(Float_t)
 113       {NotImplemented("SetNSigmaIntegration");}
 114     virtual Float_t NSigmaIntegration() const
 115       {NotImplemented("NSigmaIntegration"); return 0.;}
 116     virtual void    SetNLookUp(Int_t)
 117       {NotImplemented("SetNLookUp");}
 118
 119  protected:
 120     static const Float_t fgkDiffCoeffDefault; //default for fDiffCoeff
 121     static const TString fgkOption1Default; // default for fOption1
 122     static const TString fgkOption2Default; // default for fOption2
 123     static const Float_t fgkNoiseNDefault; // default for fNoiseN
 124     static const Float_t fgkNoisePDefault; // default for fNoiseP
 125     static const Int_t fgkNParDefault; // default for fNPar
 126     static const Float_t fgkSigmaPDefault; //default for fSigmaP
 127     static const Float_t fgkSigmaNDefault; //default for fSigmaP
 128     Int_t   fNPar;            // Number of detector param
 129     Float_t *fDetPar;         //[fNPar] Array of parameters
 130
 131     Float_t fNoiseP;          // Noise on Pside
 132     Float_t fNoiseN;          // Noise on Nside
 133
 134     Float_t fSigmaP;          // Sigma charge spread on Pside
 135     Float_t fSigmaN;          // Sigma charge spread on Nside
 136     Float_t fDiffCoeff;       // Diffusion Coefficient
 137
 138     Float_t fADCpereV;        // Constant to convert eV to ADC.
 139
 140     TString fOption1;         // Simulate invalid strips option
 141     TString fOption2;         // Not used for the moment
 142
 143  private:
 144     AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
 145     AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
 146
 147     ClassDef(AliITSresponseSSD,1) //Response class for SSD
 148 };
 149 #endif