]>
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;} | |
ce189d7c | 60 | void GetSPDCouplingOption(char *opt) const {strncpy(opt,fSPDCouplOpt.Data(),fSPDCouplOpt.Sizeof());} |
cd2a0045 | 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 | ||
a0a6914c | 70 | void SetSPDLorentzDrift(Bool_t ison) {fSPDLorentzDrift=ison;} |
71 | Bool_t GetSPDLorentzDrift() const {return fSPDLorentzDrift;} | |
72 | void SetSPDLorentzHoleWeight(Float_t weight) {fSPDLorentzHoleWeight=weight;} | |
73 | Float_t GetSPDLorentzHoleWeight() const {return fSPDLorentzHoleWeight;} | |
ad7f2bfa | 74 | |
75 | void SetSPDAddNoisyFlag(Bool_t value) {fSPDAddNoisyFlag = value;} | |
374200ee | 76 | Bool_t GetSPDAddNoisyFlag() const {return fSPDAddNoisyFlag;} |
ad7f2bfa | 77 | void SetSPDRemoveDeadFlag(Bool_t value) {fSPDRemoveDeadFlag = value;} |
374200ee | 78 | Bool_t GetSPDRemoveDeadFlag() const {return fSPDRemoveDeadFlag;} |
ad7f2bfa | 79 | |
cd2a0045 | 80 | void SetSDDElectronics(Int_t p1=1) {fSDDElectronics=p1; } |
81 | Int_t GetSDDElectronics() const {return fSDDElectronics;} | |
82 | ||
83 | void SetSDDDiffCoeff(Float_t p1, Float_t p2) { | |
84 | fSDDDiffCoeff=p1; fSDDDiffCoeff1=p2;} | |
85 | void GetSDDDiffCoeff(Float_t &diff,Float_t &diff1) const { | |
86 | diff=fSDDDiffCoeff; diff1=fSDDDiffCoeff1;} | |
87 | ||
88 | void SetSDDJitterError(Float_t jitter) {fSDDJitterError=jitter;} | |
89 | Float_t GetSDDJitterError() const {return fSDDJitterError;} | |
90 | ||
91 | void SetSDDDynamicRange(Double_t p1) {fSDDDynamicRange = p1;} | |
92 | Float_t GetSDDDynamicRange() const {return fSDDDynamicRange;} | |
93 | ||
94 | void SetSDDMaxAdc(Double_t p1) {fSDDMaxAdc=p1;} | |
95 | Float_t GetSDDMaxAdc() const {return fSDDMaxAdc;} | |
96 | ||
97 | void SetSDDChargeLoss(Double_t p1) {fSDDChargeLoss=p1;} | |
98 | Float_t GetSDDChargeLoss() const {return fSDDChargeLoss;} | |
99 | ||
417ff3f4 | 100 | void SetSDDTrigDelay(Double_t p1) {fSDDTrigDelay=p1;} |
101 | Float_t GetSDDTrigDelay() const {return fSDDTrigDelay;} | |
102 | ||
374200ee | 103 | void SetSDDCorrMapPrecision(Double_t p1) {fSDDMapPrec=p1;} |
104 | Float_t GetSDDCorrMapPrecision() const {return fSDDMapPrec;} | |
105 | ||
106 | void SetSDDkeVtoADC(Double_t p1) {fSDDkeVtoADC=p1;} | |
107 | Float_t GetSDDkeVtoADC() const {return fSDDkeVtoADC;} | |
108 | ||
d9ed1779 | 109 | void SetSDDRawDataFormatCarlos() {fSDDRawFormat=7;} |
110 | void SetSDDRawDataFormatFixLen8bitEncoded() {fSDDRawFormat=0;} | |
111 | Char_t GetSDDRawDataFormat() const {return fSDDRawFormat;} | |
66b89079 | 112 | |
113 | // Use Lorentz's angle | |
114 | void SetSSDLorentzDrift(Bool_t ison) {fSSDLorentzDrift=ison;} | |
115 | Bool_t GetSSDLorentzDrift() const {return fSSDLorentzDrift;} | |
116 | ||
8be4e1b1 | 117 | Int_t GetSSDZSThreshold() const { // ZS threshold |
118 | return fSSDZSThreshold; } | |
119 | virtual void SetSSDZSThreshold(Int_t zsth) { fSSDZSThreshold = zsth; } | |
120 | ||
cd2a0045 | 121 | void SetSSDCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) { |
122 | fSSDCouplingPR=pr; fSSDCouplingPL=pl; fSSDCouplingNR=nr; fSSDCouplingNL=nl; } | |
123 | Double_t GetSSDCouplingPR() const {return fSSDCouplingPR;} | |
124 | Double_t GetSSDCouplingPL() const {return fSSDCouplingPL;} | |
125 | Double_t GetSSDCouplingNR() const {return fSSDCouplingNR;} | |
126 | Double_t GetSSDCouplingNL() const {return fSSDCouplingNL;} | |
127 | ||
128 | void SetNSigmaIntegration(Double_t p1) {fNsigmas=p1;} | |
129 | Float_t GetNSigmaIntegration() const {return fNsigmas;} | |
130 | void SetNLookUp(Int_t p1); | |
131 | Int_t GetGausNLookUp() const {return fNcomps;} | |
132 | Float_t GetGausLookUp(Int_t i) { | |
133 | if (!fGaus) SetNLookUp(fgkNcompsDefault); | |
134 | if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i); | |
135 | } | |
136 | ||
2ae37d58 | 137 | // Set the impurity concentrations in [#/cm^3] |
138 | void SetImpurity(Double_t n=0.0){fN = n;} | |
139 | // Returns the impurity consentration in [#/cm^3] | |
140 | Double_t Impurity() const {return fN;} | |
141 | ||
142 | // Electron mobility in Si. [cm^2/(Volt Sec)]. T in degree K, N in #/cm^3 | |
143 | Double_t MobilityElectronSiEmp() const ; | |
144 | // Hole mobility in Si. [cm^2/(Volt Sec)] T in degree K, N in #/cm^3 | |
145 | Double_t MobilityHoleSiEmp() const ; | |
146 | // Einstein relation for Diffusion Coefficient of Electrons. [cm^2/sec] | |
147 | // T in degree K, N in #/cm^3 | |
148 | Double_t DiffusionCoefficientElectron() const ; | |
149 | // Einstein relation for Diffusion Coefficient of Holes. [cm^2/sec] | |
150 | // T in [degree K], N in [#/cm^3] | |
151 | Double_t DiffusionCoefficientHole() const ; | |
152 | // Electron <speed> under an applied electric field E=Volts/cm. [cm/sec] | |
153 | // d distance-thickness in [cm], v in [volts], T in [degree K], | |
154 | // N in [#/cm^3] | |
155 | Double_t SpeedElectron() const ; | |
156 | // Holes <speed> under an applied electric field E=Volts/cm. [cm/sec] | |
157 | // d distance-thickness in [cm], v in [volts], T in [degree K], | |
158 | // N in [#/cm^3] | |
159 | Double_t SpeedHole() const ; | |
160 | // Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of | |
161 | // electrons or holes through a distance l [cm] caused by an applied | |
162 | // voltage v [volt] through a distance d [cm] in any material at a | |
163 | // temperature T [degree K]. | |
164 | Double_t SigmaDiffusion3D(Double_t l) const; | |
165 | // Returns the Gaussian sigma == <x^2 +y^2+z^2> [cm^2] due to the | |
166 | // defusion of electrons or holes through a distance l [cm] caused by an | |
167 | // applied voltage v [volt] through a distance d [cm] in any material at a | |
168 | // temperature T [degree K]. | |
169 | Double_t SigmaDiffusion2D(Double_t l) const; | |
170 | // Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of | |
171 | // electrons or holes through a distance l [cm] caused by an applied | |
172 | // voltage v [volt] through a distance d [cm] in any material at a | |
173 | // temperature T [degree K]. | |
174 | Double_t SigmaDiffusion1D(Double_t l) const; | |
175 | // Computes the Lorentz angle for Electron and Hole, under the Magnetic field bz (in kGauss) | |
176 | Double_t LorentzAngleElectron(Double_t bz) const; | |
177 | Double_t LorentzAngleHole(Double_t bz) const; | |
178 | // Compute the thickness of the depleted region in a Si detector, version A | |
179 | Double_t DepletedRegionThicknessA(Double_t dopCons, | |
180 | Double_t voltage, | |
181 | Double_t elecCharge, | |
182 | Double_t voltBuiltIn=0.5)const; | |
183 | // Compute the thickness of the depleted region in a Si detector, version B | |
184 | Double_t DepletedRegionThicknessB(Double_t resist,Double_t voltage, | |
185 | Double_t mobility, | |
186 | Double_t voltBuiltIn=0.5, | |
187 | Double_t dielConst=1.E-12)const; | |
188 | // Computes the temperature dependance of the reverse bias current | |
189 | Double_t ReverseBiasCurrent(Double_t temp,Double_t revBiasCurT1, | |
190 | Double_t tempT1,Double_t energy=1.2)const; | |
191 | ||
192 | ||
cd2a0045 | 193 | void PrintParameters() const; |
194 | ||
195 | protected: | |
196 | ||
197 | static const Float_t fgkSPDBiasVoltageDefault;//default for fSPDBiasVoltage | |
198 | static const Double_t fgkSPDThreshDefault; //default for fThresh | |
199 | static const Double_t fgkSPDSigmaDefault; //default for fSigma | |
200 | static const TString fgkSPDCouplingOptDefault; // type of pixel Coupling (old or new) | |
201 | static const Double_t fgkSPDCouplColDefault; //default for fSPDCouplCol | |
202 | static const Double_t fgkSPDCouplRowDefault; //default for fSPDCouplRow | |
203 | static const Float_t fgkSPDEccDiffDefault;//default for fSPDEccDiff | |
a0a6914c | 204 | static const Float_t fgkSPDLorentzHoleWeightDefault;//default for fSPDLorentzHoleWeight |
cd2a0045 | 205 | static const Float_t fgkSDDDiffCoeffDefault; // default for fSDDDiffCoeff |
206 | static const Float_t fgkSDDDiffCoeff1Default; // default for fSDDDiffCoeff1 | |
207 | static const Float_t fgkSDDJitterErrorDefault; // default for fSDDJitterError | |
208 | static const Float_t fgkSDDDynamicRangeDefault; // default for fSDDDynamicRange | |
209 | static const Int_t fgkSDDMaxAdcDefault; // default for fSDDMaxAdc | |
210 | static const Float_t fgkSDDChargeLossDefault; // default for fSDDChargeLoss | |
417ff3f4 | 211 | static const Float_t fgkSDDTrigDelayDefault; // default for fSDDTrigDelay |
374200ee | 212 | static const Float_t fgkSDDMapPrecDefault; // default for fSDDTrigDelay |
213 | static const Float_t fgkSDDkeVtoADCDefault; // default for keV->ADC conv. | |
cd2a0045 | 214 | |
215 | static const Double_t fgkSSDCouplingPRDefault; // default values | |
216 | static const Double_t fgkSSDCouplingPLDefault; // for the | |
217 | static const Double_t fgkSSDCouplingNRDefault; // various SSD | |
218 | static const Double_t fgkSSDCouplingNLDefault; // couplings | |
219 | static const Int_t fgkSSDZSThresholdDefault; // default for fSSDZSThreshold | |
220 | ||
221 | static const Float_t fgkNsigmasDefault; //default for fNsigmas | |
222 | static const Int_t fgkNcompsDefault; //default for fNcomps | |
223 | ||
224 | private: | |
225 | Double_t fGeVcharge; // Energy to ionize (free an electron) in GeV | |
226 | Double_t fDOverV; // The parameter d/v where d is the disance over which the | |
2ae37d58 | 227 | // the potential v is applied d/v [cm/volts] |
cd2a0045 | 228 | |
229 | ||
2ae37d58 | 230 | Double_t fSPDBiasVoltage[240]; // Bias Voltage for the SPD |
231 | Double_t fSPDThresh[240]; // SPD Threshold value | |
232 | Double_t fSPDSigma[240]; // SPD threshold fluctuations spread | |
233 | Double_t fSPDNoise[240]; // SPD electronic noise: sigma | |
234 | Double_t fSPDBaseline[240]; // SPD electronic noise: baseline | |
cd2a0045 | 235 | TString fSPDCouplOpt; // SPD Coupling Option |
236 | Double_t fSPDCouplCol; // SPD Coupling parameter along the cols | |
237 | Double_t fSPDCouplRow; // SPD Coupling parameter along the rows | |
238 | Float_t fSPDEccDiff; // Eccentricity (i.e. asymmetry parameter) in the | |
ad7f2bfa | 239 | // Gaussian diffusion for SPD |
a0a6914c | 240 | Bool_t fSPDLorentzDrift; // Flag to decide whether to simulate the Lorentz Drift or not in SPD |
241 | Float_t fSPDLorentzHoleWeight;// Lorentz Angle is computed for SPD as average of Hole and Electron | |
242 | // this parameter gives the relative weights between the two | |
ad7f2bfa | 243 | Bool_t fSPDAddNoisyFlag; // Flag saying whether noisy pixels should be added to digits |
244 | Bool_t fSPDRemoveDeadFlag; // Flag saying whether dead pixels should be removed from digits | |
cd2a0045 | 245 | |
246 | Int_t fSDDElectronics; // SDD Electronics Pascal (1) or OLA (2) | |
247 | Float_t fSDDDiffCoeff; // SDD Diffusion Coefficient (scaling the time) | |
248 | Float_t fSDDDiffCoeff1; // SDD Diffusion Coefficient (constant term) | |
249 | Float_t fSDDJitterError; // SDD jitter error | |
250 | Float_t fSDDDynamicRange; // SDD Dynamic Range | |
251 | Float_t fSDDMaxAdc; // SDD ADC saturation value | |
252 | Float_t fSDDChargeLoss; // Set Linear Coefficient for Charge Loss | |
417ff3f4 | 253 | Float_t fSDDTrigDelay; // SDD time-zero |
374200ee | 254 | Float_t fSDDMapPrec; // SDD maps precision |
255 | Float_t fSDDkeVtoADC; // SDD keV->ADC conv. factor | |
d9ed1779 | 256 | Char_t fSDDRawFormat; // Index for SDD RawFormat |
cd2a0045 | 257 | |
66b89079 | 258 | Bool_t fSSDLorentzDrift; // Flag to decide whether to simulate the Lorentz Drift or not in SSD |
259 | ||
cd2a0045 | 260 | Double_t fSSDCouplingPR; // SSD couplings |
261 | Double_t fSSDCouplingPL; // SSD couplings | |
262 | Double_t fSSDCouplingNR; // SSD couplings | |
263 | Double_t fSSDCouplingNL; // SSD couplings | |
264 | Int_t fSSDZSThreshold; // SSD threshold for the zero suppresion | |
265 | ||
266 | Float_t fNsigmas; // Number of sigmas over which charge disintegration | |
267 | // is performed | |
268 | Int_t fNcomps; // Number of samplings along the gaussian | |
269 | TArrayF *fGaus; // Gaussian lookup table for signal generation | |
270 | ||
2ae37d58 | 271 | Double_t fN; // the impurity concentration of the material in #/cm^3 (NOT USED!) |
272 | Float_t fT; // The temperature of the Si in Degree K. | |
273 | ||
374200ee | 274 | ClassDef(AliITSSimuParam,6); |
cd2a0045 | 275 | }; |
276 | #endif |