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