]>
Commit | Line | Data |
---|---|---|
cd2a0045 | 1 | #ifndef ALIITSSIMUPARAM_H |
2 | #define ALIITSSIMUPARAM_H | |
3 | /* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. * | |
4 | * See cxx source for full Copyright notice */ | |
5 | ||
2ae37d58 | 6 | /* $Id$ */ |
cd2a0045 | 7 | |
8 | /////////////////////////////////////////////////////////////////// | |
9 | // // | |
10 | // Class to store the parameters used in the simulation of // | |
11 | // SPD, SDD and SSD detectors // | |
12 | // Origin: F.Prino, Torino, prino@to.infn.it // | |
13 | // // | |
14 | /////////////////////////////////////////////////////////////////// | |
2ae37d58 | 15 | #include <TRandom.h> |
cd2a0045 | 16 | #include<TObject.h> |
17 | #include <TString.h> | |
18 | #include <TArrayF.h> | |
19 | ||
20 | class AliITSSimuParam : public TObject { | |
21 | ||
22 | public: | |
23 | AliITSSimuParam(); | |
24 | AliITSSimuParam(const AliITSSimuParam& simpar); | |
25 | // assignment operator | |
26 | AliITSSimuParam& operator=(const AliITSSimuParam& source); | |
27 | ~AliITSSimuParam(); | |
28 | ||
29 | ||
30 | void SetGeVToCharge(Double_t gc=3.6e-9){fGeVcharge = gc;} | |
31 | Double_t GetGeVToCharge() const {return fGeVcharge;} | |
32 | Double_t GeVToCharge(Double_t gev) const {return gev/fGeVcharge;} | |
33 | ||
34 | void SetDistanceOverVoltage(Double_t d,Double_t v){fDOverV = d/v;} | |
35 | void SetDistanceOverVoltage(Double_t dv=0.000375){fDOverV = dv;} | |
36 | Double_t GetDistanceOverVoltage() const {return fDOverV;} | |
37 | ||
38 | ||
39 | ||
2ae37d58 | 40 | void SetSPDBiasVoltageAll(Double_t bias=18.182) {for(Int_t i=0;i<240;i++) fSPDBiasVoltage[i]=bias;} |
41 | void SetSPDBiasVoltage(Int_t mod, Double_t bias=18.182) {if(mod<0 || mod>239) return; fSPDBiasVoltage[mod]=bias;} | |
42 | Double_t GetSPDBiasVoltage(Int_t mod=0) const {if(mod<0 || mod>239) return 0; return fSPDBiasVoltage[mod];} | |
43 | ||
44 | void SetSPDThresholdsAll(Double_t thresh, Double_t sigma) | |
45 | {for(Int_t i=0;i<240;i++) {fSPDThresh[i]=thresh; fSPDSigma[i]=sigma;}} | |
46 | void SetSPDThresholds(Int_t mod,Double_t thresh, Double_t sigma) | |
47 | {if(mod<0 || mod>239) return; fSPDThresh[mod]=thresh; fSPDSigma[mod]=sigma; } | |
48 | void SPDThresholds(const Int_t mod, Double_t& thresh, Double_t& sigma) const; | |
49 | void SetSPDNoiseAll(Double_t noise, Double_t baseline) | |
50 | {for(Int_t i=0;i<240;i++) {fSPDNoise[i]=noise; fSPDBaseline[i]=baseline;}} | |
51 | void SetSPDNoise(Int_t mod,Double_t noise, Double_t baseline) | |
52 | {if(mod<0 || mod>239) return; fSPDNoise[mod]=noise; fSPDBaseline[mod]=baseline; } | |
53 | void SPDNoise(const Int_t mod,Double_t &noise, Double_t &baseline) const; | |
54 | // Applies a random noise and addes the baseline | |
55 | Double_t ApplySPDBaselineAndNoise(Int_t mod=0) const | |
56 | {if (mod<0 || mod>239) mod=0; return fSPDBaseline[mod]+fSPDNoise[mod]*gRandom->Gaus();} | |
cd2a0045 | 57 | |
cd2a0045 | 58 | |
59 | void SetSPDCouplingOption(const char *opt) {fSPDCouplOpt=opt;} | |
60 | void GetSPDCouplingOption(char *opt) const {strcpy(opt,fSPDCouplOpt.Data());} | |
61 | ||
62 | void SetSPDCouplingParam(Double_t col, Double_t row) | |
63 | {fSPDCouplCol = col; fSPDCouplRow = row;} | |
64 | void GetSPDCouplingParam(Double_t &col, Double_t &row) const | |
65 | {col = fSPDCouplCol; row = fSPDCouplRow;} | |
66 | ||
67 | void SetSPDSigmaDiffusionAsymmetry(Double_t ecc) {fSPDEccDiff=ecc;} | |
68 | void GetSPDSigmaDiffusionAsymmetry(Double_t &ecc) const {ecc=fSPDEccDiff;} | |
69 | ||
70 | void SetSDDElectronics(Int_t p1=1) {fSDDElectronics=p1; } | |
71 | Int_t GetSDDElectronics() const {return fSDDElectronics;} | |
72 | ||
73 | void SetSDDDiffCoeff(Float_t p1, Float_t p2) { | |
74 | fSDDDiffCoeff=p1; fSDDDiffCoeff1=p2;} | |
75 | void GetSDDDiffCoeff(Float_t &diff,Float_t &diff1) const { | |
76 | diff=fSDDDiffCoeff; diff1=fSDDDiffCoeff1;} | |
77 | ||
78 | void SetSDDJitterError(Float_t jitter) {fSDDJitterError=jitter;} | |
79 | Float_t GetSDDJitterError() const {return fSDDJitterError;} | |
80 | ||
81 | void SetSDDDynamicRange(Double_t p1) {fSDDDynamicRange = p1;} | |
82 | Float_t GetSDDDynamicRange() const {return fSDDDynamicRange;} | |
83 | ||
84 | void SetSDDMaxAdc(Double_t p1) {fSDDMaxAdc=p1;} | |
85 | Float_t GetSDDMaxAdc() const {return fSDDMaxAdc;} | |
86 | ||
87 | void SetSDDChargeLoss(Double_t p1) {fSDDChargeLoss=p1;} | |
88 | Float_t GetSDDChargeLoss() const {return fSDDChargeLoss;} | |
89 | ||
8be4e1b1 | 90 | Int_t GetSSDZSThreshold() const { // ZS threshold |
91 | return fSSDZSThreshold; } | |
92 | virtual void SetSSDZSThreshold(Int_t zsth) { fSSDZSThreshold = zsth; } | |
93 | ||
cd2a0045 | 94 | void SetSSDCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) { |
95 | fSSDCouplingPR=pr; fSSDCouplingPL=pl; fSSDCouplingNR=nr; fSSDCouplingNL=nl; } | |
96 | Double_t GetSSDCouplingPR() const {return fSSDCouplingPR;} | |
97 | Double_t GetSSDCouplingPL() const {return fSSDCouplingPL;} | |
98 | Double_t GetSSDCouplingNR() const {return fSSDCouplingNR;} | |
99 | Double_t GetSSDCouplingNL() const {return fSSDCouplingNL;} | |
100 | ||
101 | void SetNSigmaIntegration(Double_t p1) {fNsigmas=p1;} | |
102 | Float_t GetNSigmaIntegration() const {return fNsigmas;} | |
103 | void SetNLookUp(Int_t p1); | |
104 | Int_t GetGausNLookUp() const {return fNcomps;} | |
105 | Float_t GetGausLookUp(Int_t i) { | |
106 | if (!fGaus) SetNLookUp(fgkNcompsDefault); | |
107 | if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i); | |
108 | } | |
109 | ||
2ae37d58 | 110 | // Set the impurity concentrations in [#/cm^3] |
111 | void SetImpurity(Double_t n=0.0){fN = n;} | |
112 | // Returns the impurity consentration in [#/cm^3] | |
113 | Double_t Impurity() const {return fN;} | |
114 | ||
115 | // Electron mobility in Si. [cm^2/(Volt Sec)]. T in degree K, N in #/cm^3 | |
116 | Double_t MobilityElectronSiEmp() const ; | |
117 | // Hole mobility in Si. [cm^2/(Volt Sec)] T in degree K, N in #/cm^3 | |
118 | Double_t MobilityHoleSiEmp() const ; | |
119 | // Einstein relation for Diffusion Coefficient of Electrons. [cm^2/sec] | |
120 | // T in degree K, N in #/cm^3 | |
121 | Double_t DiffusionCoefficientElectron() const ; | |
122 | // Einstein relation for Diffusion Coefficient of Holes. [cm^2/sec] | |
123 | // T in [degree K], N in [#/cm^3] | |
124 | Double_t DiffusionCoefficientHole() const ; | |
125 | // Electron <speed> under an applied electric field E=Volts/cm. [cm/sec] | |
126 | // d distance-thickness in [cm], v in [volts], T in [degree K], | |
127 | // N in [#/cm^3] | |
128 | Double_t SpeedElectron() const ; | |
129 | // Holes <speed> under an applied electric field E=Volts/cm. [cm/sec] | |
130 | // d distance-thickness in [cm], v in [volts], T in [degree K], | |
131 | // N in [#/cm^3] | |
132 | Double_t SpeedHole() const ; | |
133 | // Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of | |
134 | // electrons or holes through a distance l [cm] caused by an applied | |
135 | // voltage v [volt] through a distance d [cm] in any material at a | |
136 | // temperature T [degree K]. | |
137 | Double_t SigmaDiffusion3D(Double_t l) const; | |
138 | // Returns the Gaussian sigma == <x^2 +y^2+z^2> [cm^2] due to the | |
139 | // defusion of electrons or holes through a distance l [cm] caused by an | |
140 | // applied voltage v [volt] through a distance d [cm] in any material at a | |
141 | // temperature T [degree K]. | |
142 | Double_t SigmaDiffusion2D(Double_t l) const; | |
143 | // Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of | |
144 | // electrons or holes through a distance l [cm] caused by an applied | |
145 | // voltage v [volt] through a distance d [cm] in any material at a | |
146 | // temperature T [degree K]. | |
147 | Double_t SigmaDiffusion1D(Double_t l) const; | |
148 | // Computes the Lorentz angle for Electron and Hole, under the Magnetic field bz (in kGauss) | |
149 | Double_t LorentzAngleElectron(Double_t bz) const; | |
150 | Double_t LorentzAngleHole(Double_t bz) const; | |
151 | // Compute the thickness of the depleted region in a Si detector, version A | |
152 | Double_t DepletedRegionThicknessA(Double_t dopCons, | |
153 | Double_t voltage, | |
154 | Double_t elecCharge, | |
155 | Double_t voltBuiltIn=0.5)const; | |
156 | // Compute the thickness of the depleted region in a Si detector, version B | |
157 | Double_t DepletedRegionThicknessB(Double_t resist,Double_t voltage, | |
158 | Double_t mobility, | |
159 | Double_t voltBuiltIn=0.5, | |
160 | Double_t dielConst=1.E-12)const; | |
161 | // Computes the temperature dependance of the reverse bias current | |
162 | Double_t ReverseBiasCurrent(Double_t temp,Double_t revBiasCurT1, | |
163 | Double_t tempT1,Double_t energy=1.2)const; | |
164 | ||
165 | ||
cd2a0045 | 166 | void PrintParameters() const; |
167 | ||
168 | protected: | |
169 | ||
170 | static const Float_t fgkSPDBiasVoltageDefault;//default for fSPDBiasVoltage | |
171 | static const Double_t fgkSPDThreshDefault; //default for fThresh | |
172 | static const Double_t fgkSPDSigmaDefault; //default for fSigma | |
173 | static const TString fgkSPDCouplingOptDefault; // type of pixel Coupling (old or new) | |
174 | static const Double_t fgkSPDCouplColDefault; //default for fSPDCouplCol | |
175 | static const Double_t fgkSPDCouplRowDefault; //default for fSPDCouplRow | |
176 | static const Float_t fgkSPDEccDiffDefault;//default for fSPDEccDiff | |
177 | static const Float_t fgkSDDDiffCoeffDefault; // default for fSDDDiffCoeff | |
178 | static const Float_t fgkSDDDiffCoeff1Default; // default for fSDDDiffCoeff1 | |
179 | static const Float_t fgkSDDJitterErrorDefault; // default for fSDDJitterError | |
180 | static const Float_t fgkSDDDynamicRangeDefault; // default for fSDDDynamicRange | |
181 | static const Int_t fgkSDDMaxAdcDefault; // default for fSDDMaxAdc | |
182 | static const Float_t fgkSDDChargeLossDefault; // default for fSDDChargeLoss | |
183 | ||
184 | static const Double_t fgkSSDCouplingPRDefault; // default values | |
185 | static const Double_t fgkSSDCouplingPLDefault; // for the | |
186 | static const Double_t fgkSSDCouplingNRDefault; // various SSD | |
187 | static const Double_t fgkSSDCouplingNLDefault; // couplings | |
188 | static const Int_t fgkSSDZSThresholdDefault; // default for fSSDZSThreshold | |
189 | ||
190 | static const Float_t fgkNsigmasDefault; //default for fNsigmas | |
191 | static const Int_t fgkNcompsDefault; //default for fNcomps | |
192 | ||
193 | private: | |
194 | Double_t fGeVcharge; // Energy to ionize (free an electron) in GeV | |
195 | Double_t fDOverV; // The parameter d/v where d is the disance over which the | |
2ae37d58 | 196 | // the potential v is applied d/v [cm/volts] |
cd2a0045 | 197 | |
198 | ||
2ae37d58 | 199 | Double_t fSPDBiasVoltage[240]; // Bias Voltage for the SPD |
200 | Double_t fSPDThresh[240]; // SPD Threshold value | |
201 | Double_t fSPDSigma[240]; // SPD threshold fluctuations spread | |
202 | Double_t fSPDNoise[240]; // SPD electronic noise: sigma | |
203 | Double_t fSPDBaseline[240]; // SPD electronic noise: baseline | |
cd2a0045 | 204 | TString fSPDCouplOpt; // SPD Coupling Option |
205 | Double_t fSPDCouplCol; // SPD Coupling parameter along the cols | |
206 | Double_t fSPDCouplRow; // SPD Coupling parameter along the rows | |
207 | Float_t fSPDEccDiff; // Eccentricity (i.e. asymmetry parameter) in the | |
208 | // Gaussian diffusion for SPD | |
209 | ||
210 | Int_t fSDDElectronics; // SDD Electronics Pascal (1) or OLA (2) | |
211 | Float_t fSDDDiffCoeff; // SDD Diffusion Coefficient (scaling the time) | |
212 | Float_t fSDDDiffCoeff1; // SDD Diffusion Coefficient (constant term) | |
213 | Float_t fSDDJitterError; // SDD jitter error | |
214 | Float_t fSDDDynamicRange; // SDD Dynamic Range | |
215 | Float_t fSDDMaxAdc; // SDD ADC saturation value | |
216 | Float_t fSDDChargeLoss; // Set Linear Coefficient for Charge Loss | |
217 | ||
cd2a0045 | 218 | Double_t fSSDCouplingPR; // SSD couplings |
219 | Double_t fSSDCouplingPL; // SSD couplings | |
220 | Double_t fSSDCouplingNR; // SSD couplings | |
221 | Double_t fSSDCouplingNL; // SSD couplings | |
222 | Int_t fSSDZSThreshold; // SSD threshold for the zero suppresion | |
223 | ||
224 | Float_t fNsigmas; // Number of sigmas over which charge disintegration | |
225 | // is performed | |
226 | Int_t fNcomps; // Number of samplings along the gaussian | |
227 | TArrayF *fGaus; // Gaussian lookup table for signal generation | |
228 | ||
2ae37d58 | 229 | Double_t fN; // the impurity concentration of the material in #/cm^3 (NOT USED!) |
230 | Float_t fT; // The temperature of the Si in Degree K. | |
231 | ||
232 | ClassDef(AliITSSimuParam,2); | |
cd2a0045 | 233 | }; |
234 | #endif |