ITS/AliITSSimuParam.h

   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
   6 /* $Id$ */
   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 ///////////////////////////////////////////////////////////////////
  15 #include <TRandom.h>
  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
  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();}
  57
  58
  59   void SetSPDCouplingOption(const char *opt) {fSPDCouplOpt=opt;}
  60   void GetSPDCouplingOption(char *opt) const {strncpy(opt,fSPDCouplOpt.Data(),fSPDCouplOpt.Sizeof());}
  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    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;}
  74
  75   void   SetSPDAddNoisyFlag(Bool_t value) {fSPDAddNoisyFlag = value;}
  76   Bool_t GetSPDAddNoisyFlag() const {return fSPDAddNoisyFlag;}
  77   void   SetSPDRemoveDeadFlag(Bool_t value) {fSPDRemoveDeadFlag = value;}
  78   Bool_t GetSPDRemoveDeadFlag() const {return fSPDRemoveDeadFlag;}
  79
  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
 100   void    SetSDDTrigDelay(Double_t p1) {fSDDTrigDelay=p1;}
 101   Float_t GetSDDTrigDelay() const {return fSDDTrigDelay;}
 102
 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
 109   void    SetSDDRawDataFormatCarlos() {fSDDRawFormat=7;}
 110   void    SetSDDRawDataFormatFixLen8bitEncoded() {fSDDRawFormat=0;}
 111   Char_t  GetSDDRawDataFormat() const {return fSDDRawFormat;}
 112
 113   // Use Lorentz's angle
 114   void    SetSSDLorentzDrift(Bool_t ison) {fSSDLorentzDrift=ison;}
 115   Bool_t  GetSSDLorentzDrift() const {return fSSDLorentzDrift;}
 116
 117   Int_t GetSSDZSThreshold() const { // ZS threshold
 118     return fSSDZSThreshold; }
 119   virtual void SetSSDZSThreshold(Int_t zsth) { fSSDZSThreshold = zsth; }
 120
 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
 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
 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
 204   static const Float_t fgkSPDLorentzHoleWeightDefault;//default for fSPDLorentzHoleWeight
 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
 211   static const Float_t fgkSDDTrigDelayDefault; // default for fSDDTrigDelay
 212   static const Float_t fgkSDDMapPrecDefault; // default for fSDDTrigDelay
 213   static const Float_t fgkSDDkeVtoADCDefault; // default for keV->ADC conv.
 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
 227                      // the potential v is applied d/v [cm/volts]
 228
 229
 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
 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
 239                             // Gaussian diffusion for SPD
 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
 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
 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
 253   Float_t  fSDDTrigDelay;    // SDD time-zero
 254   Float_t  fSDDMapPrec;      // SDD maps precision
 255   Float_t  fSDDkeVtoADC;     // SDD keV->ADC conv. factor
 256   Char_t   fSDDRawFormat;    // Index for SDD RawFormat
 257
 258   Bool_t   fSSDLorentzDrift;     // Flag to decide whether to simulate the Lorentz Drift or not in SSD
 259
 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
 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
 274   ClassDef(AliITSSimuParam,6);
 275 };
 276 #endif