Some clean-up in AliITSresponse classes + coding conventions
[u/mrichter/AliRoot.git] / 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