[u/mrichter/AliRoot.git] / ITS / AliITSSimuParam.h

#ifndef ALIITSSIMUPARAM_H
#define ALIITSSIMUPARAM_H
/* Copyright(c) 2007-2009, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */

///////////////////////////////////////////////////////////////////
//                                                               //
// Class to store the parameters used in the simulation of       //
// SPD, SDD and SSD detectors                                    //
// Origin: F.Prino, Torino, prino@to.infn.it                     //
//                                                               //
///////////////////////////////////////////////////////////////////
#include <TRandom.h>
#include<TObject.h>
#include <TString.h>
#include <TArrayF.h>

class AliITSSimuParam : public TObject {

 public:
  AliITSSimuParam();
  AliITSSimuParam(const AliITSSimuParam& simpar);
  // assignment operator 
  AliITSSimuParam& operator=(const AliITSSimuParam& source);
  ~AliITSSimuParam();

 
  void SetGeVToCharge(Double_t gc=3.6e-9){fGeVcharge = gc;}
  Double_t GetGeVToCharge() const {return fGeVcharge;}
  Double_t GeVToCharge(Double_t gev) const {return gev/fGeVcharge;}
  
  void SetDistanceOverVoltage(Double_t d,Double_t v){fDOverV = d/v;}
  void SetDistanceOverVoltage(Double_t dv=0.000375){fDOverV = dv;}
  Double_t GetDistanceOverVoltage() const {return fDOverV;}


  void    SetSPDBiasVoltageAll(Double_t bias=18.182) {for(Int_t i=0;i<240;i++) fSPDBiasVoltage[i]=bias;}
  void    SetSPDBiasVoltage(Int_t mod, Double_t bias=18.182) {if(mod<0 || mod>239) return; fSPDBiasVoltage[mod]=bias;}
  Double_t  GetSPDBiasVoltage(Int_t mod=0) const {if(mod<0 || mod>239) return 0;  return fSPDBiasVoltage[mod];}

  void   SetSPDThresholdsAll(Double_t thresh, Double_t sigma)
        {for(Int_t i=0;i<240;i++) {fSPDThresh[i]=thresh; fSPDSigma[i]=sigma;}}
  void   SetSPDThresholds(Int_t mod,Double_t thresh, Double_t sigma)
        {if(mod<0 || mod>239) return; fSPDThresh[mod]=thresh; fSPDSigma[mod]=sigma; }
  void   SPDThresholds(const Int_t mod, Double_t& thresh, Double_t& sigma) const;
  void   SetSPDNoiseAll(Double_t noise, Double_t baseline)
        {for(Int_t i=0;i<240;i++) {fSPDNoise[i]=noise; fSPDBaseline[i]=baseline;}}
  void   SetSPDNoise(Int_t mod,Double_t noise, Double_t baseline)
        {if(mod<0 || mod>239) return; fSPDNoise[mod]=noise; fSPDBaseline[mod]=baseline; }
  void   SPDNoise(const Int_t mod,Double_t &noise, Double_t &baseline) const;
  // Applies a random noise and addes the baseline
  Double_t ApplySPDBaselineAndNoise(Int_t mod=0) const 
    {if (mod<0 || mod>239) mod=0; return fSPDBaseline[mod]+fSPDNoise[mod]*gRandom->Gaus();}


  void SetSPDCouplingOption(const char *opt) {fSPDCouplOpt=opt;}
  void GetSPDCouplingOption(char *opt) const {strncpy(opt,fSPDCouplOpt.Data(),fSPDCouplOpt.Sizeof());}

  void SetSPDCouplingParam(Double_t col, Double_t row)
        {fSPDCouplCol = col; fSPDCouplRow = row;}
  void GetSPDCouplingParam(Double_t &col, Double_t &row) const
        {col = fSPDCouplCol; row = fSPDCouplRow;}

  void   SetSPDSigmaDiffusionAsymmetry(Double_t ecc) {fSPDEccDiff=ecc;}   
  void   GetSPDSigmaDiffusionAsymmetry(Double_t &ecc) const {ecc=fSPDEccDiff;}

  void    SetSPDLorentzDrift(Bool_t ison) {fSPDLorentzDrift=ison;}
  Bool_t  GetSPDLorentzDrift() const {return fSPDLorentzDrift;}
  void    SetSPDLorentzHoleWeight(Float_t weight) {fSPDLorentzHoleWeight=weight;}
  Float_t GetSPDLorentzHoleWeight() const {return fSPDLorentzHoleWeight;}
  
  void   SetSPDAddNoisyFlag(Bool_t value) {fSPDAddNoisyFlag = value;}
  Bool_t GetSPDAddNoisyFlag() const {return fSPDAddNoisyFlag;}
  void   SetSPDRemoveDeadFlag(Bool_t value) {fSPDRemoveDeadFlag = value;}
  Bool_t GetSPDRemoveDeadFlag() const {return fSPDRemoveDeadFlag;}
  
  void SetSDDElectronics(Int_t p1=1) {fSDDElectronics=p1;   }
  Int_t GetSDDElectronics()  const {return fSDDElectronics;}

  void  SetSDDDiffCoeff(Float_t p1, Float_t p2) {
      fSDDDiffCoeff=p1; fSDDDiffCoeff1=p2;}
  void  GetSDDDiffCoeff(Float_t &diff,Float_t &diff1) const {
      diff=fSDDDiffCoeff; diff1=fSDDDiffCoeff1;}

  void  SetSDDJitterError(Float_t jitter) {fSDDJitterError=jitter;}
  Float_t  GetSDDJitterError() const {return fSDDJitterError;}

  void    SetSDDDynamicRange(Double_t p1) {fSDDDynamicRange = p1;}
  Float_t GetSDDDynamicRange() const {return fSDDDynamicRange;}

  void    SetSDDMaxAdc(Double_t p1) {fSDDMaxAdc=p1;}
  Float_t GetSDDMaxAdc() const  {return fSDDMaxAdc;}

  void    SetSDDChargeLoss(Double_t p1) {fSDDChargeLoss=p1;}
  Float_t GetSDDChargeLoss() const {return fSDDChargeLoss;}

  void    SetSDDTrigDelay(Double_t p1) {fSDDTrigDelay=p1;}
  Float_t GetSDDTrigDelay() const {return fSDDTrigDelay;}

  void    SetSDDCorrMapPrecision(Double_t p1) {fSDDMapPrec=p1;}
  Float_t GetSDDCorrMapPrecision() const {return fSDDMapPrec;}

  void    SetSDDkeVtoADC(Double_t p1) {fSDDkeVtoADC=p1;}
  Float_t GetSDDkeVtoADC() const {return fSDDkeVtoADC;}

  void    SetSDDRawDataFormatCarlos() {fSDDRawFormat=7;}
  void    SetSDDRawDataFormatFixLen8bitEncoded() {fSDDRawFormat=0;}
  Char_t  GetSDDRawDataFormat() const {return fSDDRawFormat;}

  // Use Lorentz's angle
  void    SetSSDLorentzDrift(Bool_t ison) {fSSDLorentzDrift=ison;}
  Bool_t  GetSSDLorentzDrift() const {return fSSDLorentzDrift;}

  Int_t GetSSDZSThreshold() const { // ZS threshold
    return fSSDZSThreshold; }
  virtual void SetSSDZSThreshold(Int_t zsth) { fSSDZSThreshold = zsth; }
  
  void SetSSDCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) {
      fSSDCouplingPR=pr; fSSDCouplingPL=pl; fSSDCouplingNR=nr; fSSDCouplingNL=nl; }
  Double_t  GetSSDCouplingPR() const {return fSSDCouplingPR;}
  Double_t  GetSSDCouplingPL() const {return fSSDCouplingPL;}
  Double_t  GetSSDCouplingNR() const {return fSSDCouplingNR;}
  Double_t  GetSSDCouplingNL() const {return fSSDCouplingNL;}

  void    SetNSigmaIntegration(Double_t p1) {fNsigmas=p1;}
  Float_t GetNSigmaIntegration() const {return fNsigmas;}
  void    SetNLookUp(Int_t p1);
  Int_t   GetGausNLookUp() const {return fNcomps;}
  Float_t GetGausLookUp(Int_t i)  {
    if (!fGaus) SetNLookUp(fgkNcompsDefault);
    if(i<0 || i>=fNcomps) return 0.;return fGaus->At(i);
  }

  // Set the impurity concentrations in [#/cm^3]
  void SetImpurity(Double_t n=0.0){fN = n;}
  // Returns the impurity consentration in [#/cm^3]
  Double_t Impurity() const {return fN;}

  // Electron mobility in Si. [cm^2/(Volt Sec)]. T in degree K, N in #/cm^3
  Double_t MobilityElectronSiEmp() const ;
  // Hole mobility in Si. [cm^2/(Volt Sec)]  T in degree K, N in #/cm^3
  Double_t MobilityHoleSiEmp() const ;
  // Einstein relation for Diffusion Coefficient of Electrons. [cm^2/sec]
  //  T in degree K, N in #/cm^3
  Double_t DiffusionCoefficientElectron() const ;
  // Einstein relation for Diffusion Coefficient of Holes. [cm^2/sec]
  //  T in [degree K], N in [#/cm^3]
  Double_t DiffusionCoefficientHole() const ;
  // Electron <speed> under an applied electric field E=Volts/cm. [cm/sec]
  // d distance-thickness in [cm], v in [volts], T in [degree K],
  // N in [#/cm^3]
  Double_t SpeedElectron() const ;
  // Holes <speed> under an applied electric field E=Volts/cm. [cm/sec]
  // d distance-thickness in [cm], v in [volts], T in [degree K],
  // N in [#/cm^3]
  Double_t SpeedHole() const ;
  // Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of
  // electrons or holes through a distance l [cm] caused by an applied
  // voltage v [volt] through a distance d [cm] in any material at a
  // temperature T [degree K].
  Double_t SigmaDiffusion3D(Double_t  l) const;
  // Returns the Gaussian sigma == <x^2 +y^2+z^2> [cm^2] due to the
  // defusion of electrons or holes through a distance l [cm] caused by an
  // applied voltage v [volt] through a distance d [cm] in any material at a
  // temperature T [degree K].
  Double_t SigmaDiffusion2D(Double_t l) const;
  // Returns the Gaussian sigma == <x^2+z^2> [cm^2] due to the defusion of
  // electrons or holes through a distance l [cm] caused by an applied
  // voltage v [volt] through a distance d [cm] in any material at a
  // temperature T [degree K].
  Double_t SigmaDiffusion1D(Double_t l) const;
  // Computes the Lorentz angle for Electron and Hole, under the Magnetic field bz (in kGauss)
  Double_t LorentzAngleElectron(Double_t bz) const;
  Double_t LorentzAngleHole(Double_t bz) const;
  // Compute the thickness of the depleted region in a Si detector, version A
  Double_t DepletedRegionThicknessA(Double_t dopCons,
                                    Double_t voltage,
                                    Double_t elecCharge,
                                    Double_t voltBuiltIn=0.5)const;
  // Compute the thickness of the depleted region in a Si detector, version B
  Double_t DepletedRegionThicknessB(Double_t resist,Double_t voltage,
                                    Double_t mobility,
                                    Double_t voltBuiltIn=0.5,
                                    Double_t dielConst=1.E-12)const;
  // Computes the temperature dependance of the reverse bias current
  Double_t ReverseBiasCurrent(Double_t temp,Double_t revBiasCurT1,
  	                      Double_t tempT1,Double_t energy=1.2)const;


  void PrintParameters() const; 

 protected:

  static const Float_t fgkSPDBiasVoltageDefault;//default for fSPDBiasVoltage
  static const Double_t fgkSPDThreshDefault; //default for fThresh
  static const Double_t fgkSPDSigmaDefault; //default for fSigma
  static const TString fgkSPDCouplingOptDefault;  // type of pixel Coupling (old or new)
  static const Double_t fgkSPDCouplColDefault; //default for fSPDCouplCol
  static const Double_t fgkSPDCouplRowDefault; //default for fSPDCouplRow
  static const Float_t fgkSPDEccDiffDefault;//default for fSPDEccDiff
  static const Float_t fgkSPDLorentzHoleWeightDefault;//default for fSPDLorentzHoleWeight
  static const Float_t fgkSDDDiffCoeffDefault; // default for fSDDDiffCoeff
  static const Float_t fgkSDDDiffCoeff1Default; // default for fSDDDiffCoeff1 
  static const Float_t fgkSDDJitterErrorDefault; // default for fSDDJitterError
  static const Float_t fgkSDDDynamicRangeDefault; // default for fSDDDynamicRange
  static const Int_t fgkSDDMaxAdcDefault; // default for fSDDMaxAdc
  static const Float_t fgkSDDChargeLossDefault; // default for fSDDChargeLoss
  static const Float_t fgkSDDTrigDelayDefault; // default for fSDDTrigDelay
  static const Float_t fgkSDDMapPrecDefault; // default for fSDDTrigDelay
  static const Float_t fgkSDDkeVtoADCDefault; // default for keV->ADC conv.

  static const Double_t fgkSSDCouplingPRDefault;  // default values
  static const Double_t fgkSSDCouplingPLDefault;  // for the
  static const Double_t fgkSSDCouplingNRDefault;  // various SSD
  static const Double_t fgkSSDCouplingNLDefault;  // couplings
  static const Int_t fgkSSDZSThresholdDefault;  // default for fSSDZSThreshold

  static const Float_t fgkNsigmasDefault; //default for fNsigmas
  static const Int_t fgkNcompsDefault; //default for fNcomps

 private:
  Double_t fGeVcharge;      // Energy to ionize (free an electron) in GeV
  Double_t fDOverV;  // The parameter d/v where d is the disance over which the
                     // the potential v is applied d/v [cm/volts]

  
  Double_t fSPDBiasVoltage[240]; // Bias Voltage for the SPD
  Double_t fSPDThresh[240];      // SPD Threshold value
  Double_t fSPDSigma[240];       // SPD threshold fluctuations spread
  Double_t fSPDNoise[240];       // SPD electronic noise: sigma
  Double_t fSPDBaseline[240];    // SPD electronic noise: baseline
  TString  fSPDCouplOpt;    // SPD Coupling Option
  Double_t fSPDCouplCol;    // SPD Coupling parameter along the cols
  Double_t fSPDCouplRow;    // SPD Coupling parameter along the rows
  Float_t  fSPDEccDiff;     // Eccentricity (i.e. asymmetry parameter) in the 
                            // Gaussian diffusion for SPD  
  Bool_t   fSPDLorentzDrift;     // Flag to decide whether to simulate the Lorentz Drift or not in SPD
  Float_t  fSPDLorentzHoleWeight;// Lorentz Angle is computed for SPD as average of Hole and Electron
                                 // this parameter gives the relative weights between the two
  Bool_t   fSPDAddNoisyFlag;     // Flag saying whether noisy pixels should be added to digits
  Bool_t   fSPDRemoveDeadFlag;   // Flag saying whether dead pixels should be removed from digits

  Int_t    fSDDElectronics;  // SDD Electronics Pascal (1) or OLA (2)
  Float_t  fSDDDiffCoeff;    // SDD Diffusion Coefficient (scaling the time)
  Float_t  fSDDDiffCoeff1;   // SDD Diffusion Coefficient (constant term)
  Float_t  fSDDJitterError;  // SDD jitter error
  Float_t  fSDDDynamicRange; // SDD Dynamic Range 
  Float_t  fSDDMaxAdc;       // SDD ADC saturation value
  Float_t  fSDDChargeLoss;   // Set Linear Coefficient for Charge Loss 
  Float_t  fSDDTrigDelay;    // SDD time-zero
  Float_t  fSDDMapPrec;      // SDD maps precision
  Float_t  fSDDkeVtoADC;     // SDD keV->ADC conv. factor
  Char_t   fSDDRawFormat;    // Index for SDD RawFormat
  
  Bool_t   fSSDLorentzDrift;     // Flag to decide whether to simulate the Lorentz Drift or not in SSD

  Double_t fSSDCouplingPR;  // SSD couplings
  Double_t fSSDCouplingPL;  // SSD couplings
  Double_t fSSDCouplingNR;  // SSD couplings
  Double_t fSSDCouplingNL;  // SSD couplings   
  Int_t    fSSDZSThreshold; // SSD threshold for the zero suppresion

  Float_t  fNsigmas;   // Number of sigmas over which charge disintegration
                       // is performed
  Int_t      fNcomps;  // Number of samplings along the gaussian
  TArrayF   *fGaus;    // Gaussian lookup table for signal generation

  Double_t fN;  // the impurity concentration of the material in #/cm^3  (NOT USED!)
  Float_t fT;   // The temperature of the Si in Degree K.

  ClassDef(AliITSSimuParam,6);
};
#endif
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
cd2a0045	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
ad7f2bfa	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
374200ee	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
cd2a0045	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
ad7f2bfa	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
374200ee	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
66b89079	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	};
cd2a0045	276	#endif