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