Added classes for geometry - reconstruction interface, minor fixes in other classes
[u/mrichter/AliRoot.git] / ITS / UPGRADE / AliITSUSimuParam.cxx
1 /**************************************************************************
2  * Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id: AliITSUSimuParam.cxx 48165 2011-03-07 17:48:57Z masera $ */
17
18 ///////////////////////////////////////////////////////////////////
19 //                                                               //
20 // Implementation of the class to store the parameters used in   //
21 // the simulation of SPD, SDD and SSD detectors                  //
22 // Origin: F.Prino, Torino, prino@to.infn.it                     //
23 //                                                               //
24 ///////////////////////////////////////////////////////////////////
25 #include "AliITSUSimuParam.h"
26 #include "AliLog.h"
27 using namespace TMath;
28
29
30 const Double_t  AliITSUSimuParam::fgkPixBiasVoltageDefault = 18.182;
31 const Double_t  AliITSUSimuParam::fgkPixThreshDefault = 2000.;
32 const Double_t  AliITSUSimuParam::fgkPixThrSigmaDefault = 200.;
33 const Double_t  AliITSUSimuParam::fgkPixMinElToAddDefault = 2.;
34 const UInt_t    AliITSUSimuParam::fgkPixCouplingOptDefault = AliITSUSimuParam::kOldCouplingPix;
35 const Double_t  AliITSUSimuParam::fgkPixCouplColDefault = 0.;
36 const Double_t  AliITSUSimuParam::fgkPixCouplRowDefault = 0.055;
37 const Double_t  AliITSUSimuParam::fgkPixEccDiffDefault = 0.85;
38 const Double_t  AliITSUSimuParam::fgkPixLorentzHoleWeightDefault = 1.0;
39 const Double_t  AliITSUSimuParam::fgkGeVtoChargeDefault = 3.6e-9;
40 const Double_t  AliITSUSimuParam::fgkDOverVDefault = 0.000375;
41 const Double_t  AliITSUSimuParam::fgkTDefault = 300;
42
43 const Double_t  AliITSUSimuParam::fgkNsigmasDefault = 3.;
44 const Int_t    AliITSUSimuParam::fgkNcompsDefault = 121;
45
46 ClassImp(AliITSUSimuParam)
47
48 //______________________________________________________________________
49 AliITSUSimuParam::AliITSUSimuParam()
50 :  fGeVcharge(fgkGeVtoChargeDefault)
51   ,fDOverV(fgkDOverVDefault)
52   ,fT(fgkTDefault)
53   //
54   ,fNPix(0)
55   ,fPixCouplOpt(kOldCouplingPix)
56   ,fPixCouplCol(fgkPixCouplColDefault)
57   ,fPixCouplRow(fgkPixCouplRowDefault)
58   ,fPixEccDiff(fgkPixEccDiffDefault)
59   ,fPixLorentzDrift(kTRUE)
60   ,fPixLorentzHoleWeight(fgkPixLorentzHoleWeightDefault)
61   ,fPixAddNoisyFlag(kFALSE)
62   ,fPixRemoveDeadFlag(kFALSE)
63   //
64   ,fPixThreshDef(fgkPixThreshDefault)
65   ,fPixThrSigmaDef(fgkPixThrSigmaDefault)
66   ,fPixBiasVoltageDef(fgkPixBiasVoltageDefault)
67   ,fPixNoiseDef(0)
68   ,fPixBaselineDef(0)
69   ,fPixMinElToAddDef(fgkPixMinElToAddDefault)
70   //
71   ,fPixThresh(0)
72   ,fPixThrSigma(0)
73   ,fPixBiasVoltage(0)
74   ,fPixSigma(0)
75   ,fPixNoise(0)
76   ,fPixBaseline(0)
77 {  
78   // default constructor
79 }
80
81 //______________________________________________________________________
82 AliITSUSimuParam::AliITSUSimuParam(UInt_t nPix)
83   :fGeVcharge(fgkGeVtoChargeDefault)
84   ,fDOverV(fgkDOverVDefault)
85   ,fT(fgkTDefault)
86     //
87   ,fNPix(nPix)
88   ,fPixCouplOpt(kOldCouplingPix)
89   ,fPixCouplCol(fgkPixCouplColDefault)
90   ,fPixCouplRow(fgkPixCouplRowDefault)
91   ,fPixEccDiff(fgkPixEccDiffDefault)
92   ,fPixLorentzDrift(kTRUE)
93   ,fPixLorentzHoleWeight(fgkPixLorentzHoleWeightDefault)
94   ,fPixAddNoisyFlag(kFALSE)
95   ,fPixRemoveDeadFlag(kFALSE)
96   //
97   ,fPixThreshDef(fgkPixThreshDefault)
98   ,fPixThrSigmaDef(fgkPixThrSigmaDefault)
99   ,fPixBiasVoltageDef(fgkPixBiasVoltageDefault)
100   ,fPixNoiseDef(0)
101   ,fPixBaselineDef(0)
102   ,fPixMinElToAddDef(fgkPixMinElToAddDefault)
103   //
104   ,fPixThresh(0)
105   ,fPixThrSigma(0)
106   ,fPixBiasVoltage(0)
107   ,fPixSigma(0)
108   ,fPixNoise(0)
109   ,fPixBaseline(0)
110 {  
111   // regular constructor
112   if (fNPix>0) {
113     fPixBiasVoltage = new Double_t[fNPix];
114     fPixThresh      = new Double_t[fNPix];
115     fPixThrSigma    = new Double_t[fNPix];
116     fPixNoise       = new Double_t[fNPix];
117     fPixBaseline    = new Double_t[fNPix];
118   }
119   SetPixThreshold(fgkPixThreshDefault,fgkPixThrSigmaDefault);
120   SetPixNoise(0.,0.);
121   SetPixBiasVoltage(fgkPixBiasVoltageDefault);
122   //
123 }
124
125 //______________________________________________________________________
126 AliITSUSimuParam::AliITSUSimuParam(const AliITSUSimuParam &simpar)
127   :TObject(simpar)
128   ,fGeVcharge(simpar.fGeVcharge)
129   ,fDOverV(simpar.fDOverV)
130   ,fT(simpar.fT)
131    //
132   ,fNPix(simpar.fNPix)
133   ,fPixCouplOpt(simpar.fPixCouplOpt)
134   ,fPixCouplCol(simpar.fPixCouplCol)
135   ,fPixCouplRow(simpar.fPixCouplRow)
136   ,fPixEccDiff(simpar.fPixEccDiff)
137   ,fPixLorentzDrift(simpar.fPixLorentzDrift)
138   ,fPixLorentzHoleWeight(simpar.fPixLorentzHoleWeight)
139   ,fPixAddNoisyFlag(simpar.fPixAddNoisyFlag)
140   ,fPixRemoveDeadFlag(simpar.fPixRemoveDeadFlag)
141    //
142   ,fPixThreshDef(simpar.fPixThreshDef)
143   ,fPixThrSigmaDef(simpar.fPixThrSigmaDef)
144   ,fPixBiasVoltageDef(simpar.fPixBiasVoltageDef)
145   ,fPixNoiseDef(simpar.fPixNoiseDef)
146   ,fPixBaselineDef(simpar.fPixBaselineDef)
147   ,fPixMinElToAddDef(simpar.fPixMinElToAddDef)
148   //
149   ,fPixThresh(0)
150   ,fPixThrSigma(0)
151   ,fPixBiasVoltage(0)
152   ,fPixSigma(0)
153   ,fPixNoise(0)
154   ,fPixBaseline(0)   
155    //
156 {
157   // copy constructor
158   if (fNPix) {
159     fPixBiasVoltage = new Double_t[fNPix];
160     fPixThresh      = new Double_t[fNPix];
161     fPixThrSigma    = new Double_t[fNPix];
162     fPixNoise       = new Double_t[fNPix];
163     fPixBaseline    = new Double_t[fNPix];
164   }
165   for (Int_t i=fNPix;i--;) {
166     fPixBiasVoltage[i] = simpar.fPixBiasVoltage[i];
167     fPixThresh[i]      = simpar.fPixThresh[i];
168     fPixThrSigma[i]    = simpar.fPixThrSigma[i];
169     fPixNoise[i]       = simpar.fPixNoise[i];
170     fPixBaseline[i]    = simpar.fPixBaseline[i];
171   }
172   //
173 }
174
175 //______________________________________________________________________
176 AliITSUSimuParam& AliITSUSimuParam::operator=(const AliITSUSimuParam& source)
177 {
178   // Assignment operator. 
179   if (this==&source) return *this;
180   this->~AliITSUSimuParam();
181   new(this) AliITSUSimuParam(source);
182   return *this;
183   //
184 }
185
186 //______________________________________________________________________
187 AliITSUSimuParam::~AliITSUSimuParam() 
188 {
189   // destructor
190   delete[] fPixBiasVoltage;
191   delete[] fPixThresh;
192   delete[] fPixThrSigma;
193   delete[] fPixNoise;
194   delete[] fPixBaseline;
195 }
196
197 //________________________________________________________________________
198 void AliITSUSimuParam::Print(Option_t *) const
199 {
200   // Dump all parameters
201   Dump();
202 }
203
204 //_______________________________________________________________________
205 Double_t AliITSUSimuParam::ApplyPixBaselineAndNoise(UInt_t mod) const 
206 {
207   // generate random noise 
208   double base,noise;
209   if (mod>=fNPix) {
210     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
211     base = fPixBaselineDef;
212     noise = fPixNoiseDef;
213   }
214   else {
215     base  = fPixBaseline[mod];
216     noise = fPixNoise[mod];    
217   }
218   return base+noise*gRandom->Gaus();
219 }
220
221 //_______________________________________________________________________
222 Double_t AliITSUSimuParam::CalcProbNoiseOverThreshold(UInt_t mod) const 
223 {
224   // calculate probability of noise exceeding the threshold
225   double base,noise,thresh;
226   if (mod>=fNPix) {
227     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
228     base   = fPixBaselineDef;
229     noise  = fPixNoiseDef;
230     thresh = fPixThreshDef;
231   }
232   else {
233     base   = fPixBaseline[mod];
234     noise  = fPixNoise[mod];
235     thresh = fPixThresh[mod];
236   }
237   if (noise<1e-12) {
238     if (base>thresh) return 1;
239     else             return 0;
240   }
241   return CalcProbNoiseOverThreshold(base, noise, thresh);
242 }
243
244 //_______________________________________________________________________
245 void AliITSUSimuParam::SetPixThreshold(Double_t thresh, Double_t sigma, int mod)
246 {
247   // set threshold params
248   if (mod<0) {
249     fPixThreshDef = thresh;
250     fPixThrSigmaDef  = sigma;
251     for (int i=fNPix;i--;) {
252       fPixThresh[i] = thresh;
253       fPixThrSigma[i]  = sigma;
254     }
255   }
256   else if (mod>=(int)fNPix) {
257     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
258     fPixThreshDef = thresh;
259     fPixThrSigmaDef  = sigma;
260   }
261   else {
262     fPixThresh[mod] = thresh;
263     fPixThrSigma[mod]  = sigma;
264   }
265   //
266 }
267
268 //_______________________________________________________________________
269 Double_t AliITSUSimuParam::GetPixThreshold(UInt_t mod) const
270 {
271   // obtain threshold
272   if (mod>=fNPix) {
273     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
274     return fPixThreshDef;
275   }
276   else return fPixThresh[mod];
277 }
278
279 //_______________________________________________________________________
280 void AliITSUSimuParam::GetPixThreshold(UInt_t mod, Double_t &thresh, Double_t &sigma) const
281 {
282   // obtain thresholds
283   if (mod>=fNPix) {
284     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
285     thresh = fPixThreshDef;
286     sigma  = fPixThrSigmaDef;
287   }
288   else {
289     thresh = fPixThresh[mod];
290     sigma  = fPixThrSigma[mod];
291   }
292 }
293
294 //_______________________________________________________________________
295 void AliITSUSimuParam::SetPixBiasVoltage(Double_t val, int mod)
296 {
297   // set threshold params
298   if (mod<0) {
299     fPixBiasVoltageDef = val;
300     for (int i=fNPix;i--;) fPixBiasVoltage[i] = val;
301   }
302   else if (mod>=(int)fNPix) {
303     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
304     fPixBiasVoltageDef = val;
305   }
306   else fPixBiasVoltage[mod] = val;
307   //
308 }
309
310 //_______________________________________________________________________
311 Double_t AliITSUSimuParam::GetPixBiasVoltage(UInt_t mod) const
312 {
313   // obtain threshold
314   if (mod>=fNPix) {
315     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
316     return fPixBiasVoltageDef;
317   }
318   else return fPixBiasVoltage[mod];
319 }
320
321 //_______________________________________________________________________
322 void AliITSUSimuParam::SetPixNoise(Double_t noise, Double_t baseline, int mod)
323 {
324   // set noise params
325   if (mod<0) {
326     fPixNoiseDef = noise;
327     fPixBaselineDef  = baseline;
328     for (int i=fNPix;i--;) {
329       fPixNoise[i] = noise;
330       fPixBaseline[i]  = baseline;
331     }
332   }
333   else if (mod>=(int)fNPix) {
334     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
335     fPixNoiseDef = noise;
336     fPixBaselineDef  = baseline;
337   }
338   else {
339     fPixNoise[mod] = noise;
340     fPixBaseline[mod]  = baseline;
341   }
342   //
343 }
344
345 //_______________________________________________________________________
346 void AliITSUSimuParam::GetPixNoise(UInt_t mod, Double_t &noise, Double_t &baseline) const
347 {
348   // obtain noise
349   if (mod>=fNPix) {
350     if (fNPix>0) {AliFatal(Form("Wrong module %d, NPidUpg=%d",mod,fNPix));}
351     noise     = fPixNoiseDef;
352     baseline  = fPixBaselineDef;
353   }
354   else {
355     noise     = fPixNoise[mod];
356     baseline  = fPixBaseline[mod];
357   }
358 }
359
360 //_______________________________________________________________________
361 void AliITSUSimuParam::SetPixCouplingOption(UInt_t opt)
362 {
363   // set coupling option
364   if (opt>=kMaxCouplingOptPix) AliFatal(Form("Coupling option %d should be less than %d",opt,kMaxCouplingOptPix));
365   fPixCouplOpt = opt;
366 }
367
368
369 //______________________________________________________________________
370 Double_t AliITSUSimuParam::LorentzAngleHole(Double_t B) const 
371 {
372   // Computes the Lorentz angle for electrons in Si
373   // Input: magnetic Field in KGauss
374   // Output: Lorentz angle in radians (positive if Bz is positive)
375   // Main Reference: NIM A 497 (2003) 389–396.
376   // "An algorithm for calculating the Lorentz angle in silicon detectors", V. Bartsch et al.
377   //
378   const Double_t krH=0.70; // Hall scattering factor for Hole
379   const Double_t kT0  = 300.;       // reference Temperature (degree K).
380   const Double_t kmulow0 = 470.5;   // cm^2/Volt-sec
381   const Double_t keT0 = -2.5;       // Power of Temp.
382   const Double_t beta0 = 1.213;     // beta coeff. at T0=300K
383   const Double_t keT1 = 0.17;       // Power of Temp. for beta
384   const Double_t kvsat0 = 8.37E+06; // saturated velocity at T0=300K (cm/sec)
385   const Double_t keT2 = 0.52;       // Power of Temp. for vsat
386   Double_t tT = fT;
387   Double_t eE= 1./fDOverV;
388   Double_t muLow=kmulow0*Power(tT/kT0,keT0);
389   Double_t beta=beta0*Power(tT/kT0,keT1);
390   Double_t vsat=kvsat0*Power(tT/kT0,keT2);
391   Double_t mu=muLow/Power(1+Power(muLow*eE/vsat,beta),1/beta);
392   Double_t angle=ATan(krH*mu*B*1.E-05); // Conversion Factor
393   return angle;
394 }
395
396 //______________________________________________________________________
397 Double_t AliITSUSimuParam::LorentzAngleElectron(Double_t B) const 
398 {
399   // Computes the Lorentz angle for electrons in Si
400   // Input: magnetic Field in KGauss
401   // Output: Lorentz angle in radians (positive if Bz is positive)
402   // Main Reference: NIM A 497 (2003) 389–396.
403   // "An algorithm for calculating the Lorentz angle in silicon detectors", V. Bartsch et al.
404   //
405   const Double_t krH=1.15; // Hall scattering factor for Electron
406   const Double_t kT0  = 300.;       // reference Temperature (degree K).
407   const Double_t kmulow0 = 1417.0;  // cm^2/Volt-sec
408   const Double_t keT0 = -2.2;       // Power of Temp.
409   const Double_t beta0 = 1.109;     // beta coeff. at T0=300K
410   const Double_t keT1 = 0.66;       // Power of Temp. for beta
411   const Double_t kvsat0 = 1.07E+07; // saturated velocity at T0=300K (cm/sec)
412   const Double_t keT2 = 0.87;       // Power of Temp. for vsat
413   Double_t tT = fT;
414   Double_t eE= 1./fDOverV;
415   Double_t muLow=kmulow0*Power(tT/kT0,keT0);
416   Double_t beta=beta0*Power(tT/kT0,keT1);
417   Double_t vsat=kvsat0*Power(tT/kT0,keT2);
418   Double_t mu=muLow/Power(1+Power(muLow*eE/vsat,beta),1/beta);
419   Double_t angle=ATan(krH*mu*B*1.E-05);
420   return angle;
421 }
422
423 //______________________________________________________________________
424 Double_t AliITSUSimuParam::SigmaDiffusion3D(Double_t l) const 
425 {
426   // Returns the Gaussian sigma^2 == <x^2+y^2+z^2> [cm^2] due to the
427   // defusion of electrons or holes through a distance l [cm] caused
428   // by an applied voltage v [volt] through a distance d [cm] in any
429   //  material at a temperature T [degree K]. The sigma diffusion when
430   //  expressed in terms of the distance over which the diffusion
431   // occures, l=time/speed, is independent of the mobility and therefore
432   //  the properties of the material. The charge distributions is given by
433   // n = exp(-r^2/4Dt)/(4piDt)^1.5. From this <r^2> = 6Dt where D=mkT/e
434   // (m==mobility, k==Boltzman's constant, T==temparature, e==electric
435   // charge. and vel=m*v/d. consiquently sigma^2=6kTdl/ev.
436   // Inputs:
437   //    Double_t l   Distance the charge has to travel.
438   // Output:
439   //    none.
440   // Return:
441   //    The Sigma due to the diffution of electrons. [cm]
442   const Double_t kcon = 5.17040258E-04; // == 6k/e [J/col or volts]  
443   return Sqrt(kcon*fT*fDOverV*l);  // [cm]
444 }
445
446 //______________________________________________________________________
447 Double_t AliITSUSimuParam::SigmaDiffusion2D(Double_t l) const 
448 {
449   // Returns the Gaussian sigma^2 == <x^2+z^2> [cm^2] due to the defusion
450   // of electrons or holes through a distance l [cm] caused by an applied
451   // voltage v [volt] through a distance d [cm] in any material at a
452   // temperature T [degree K]. The sigma diffusion when expressed in terms
453   // of the distance over which the diffusion occures, l=time/speed, is
454   // independent of the mobility and therefore the properties of the
455   // material. The charge distributions is given by
456   // n = exp(-r^2/4Dt)/(4piDt)^1.5. From this <x^2+z^2> = 4Dt where D=mkT/e
457   // (m==mobility, k==Boltzman's constant, T==temparature, e==electric
458   // charge. and vel=m*v/d. consiquently sigma^2=4kTdl/ev.
459   // Inputs:
460   //    Double_t l   Distance the charge has to travel.
461   // Output:
462   //    none.
463   // Return:
464   //    The Sigma due to the diffution of electrons. [cm]
465   const Double_t kcon = 3.446935053E-04; // == 4k/e [J/col or volts]
466   return Sqrt(kcon*fT*fDOverV*l);  // [cm]
467 }
468
469 //______________________________________________________________________
470 Double_t AliITSUSimuParam::SigmaDiffusion1D(Double_t l) const 
471 {
472   // Returns the Gaussian sigma^2 == <x^2> [cm^2] due to the defusion
473   // of electrons or holes through a distance l [cm] caused by an applied
474   // voltage v [volt] through a distance d [cm] in any material at a
475   // temperature T [degree K]. The sigma diffusion when expressed in terms
476   // of the distance over which the diffusion occures, l=time/speed, is
477   // independent of the mobility and therefore the properties of the
478   // material. The charge distributions is given by
479   // n = exp(-r^2/4Dt)/(4piDt)^1.5. From this <r^2> = 2Dt where D=mkT/e
480   // (m==mobility, k==Boltzman's constant, T==temparature, e==electric
481   // charge. and vel=m*v/d. consiquently sigma^2=2kTdl/ev.
482   // Inputs:
483   //    Double_t l   Distance the charge has to travel.
484   // Output:
485   //    none.
486   // Return:
487   //    The Sigma due to the diffution of electrons. [cm]
488   const Double_t kcon = 1.723467527E-04; // == 2k/e [J/col or volts]
489   return Sqrt(kcon*fT*fDOverV*l);  // [cm]
490 }