[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<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    SetSPDBiasVoltage(Double_t bias=18.182) {fSPDBiasVoltage=bias;}
  Double_t  GetSPDBiasVoltage() const {return fSPDBiasVoltage;}

  void   SetSPDThresholds(Double_t thresh, Double_t sigma)
	{fSPDThresh=thresh; fSPDSigma=sigma;}
  void   Thresholds(Double_t &thresh, Double_t &sigma) const
	{thresh=fSPDThresh; sigma=fSPDSigma;}

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

  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 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 SetSSDADCpereV(Double_t a=120./24888.9){fSSDADCpereV = a;}
  Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;}
  Int_t GetSSDIEvToADC(Double_t eV) const { 
      return ((Int_t) GetSSDDEvToADC(eV)); }

  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);
  }

  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 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 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; // Bias Voltage for the SPD
  Double_t fSPDThresh;      // SPD Threshold value
  Double_t fSPDSigma;       // SPD Noise + threshold fluctuations value  
  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

  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 
  
  Double_t fSSDADCpereV;    // Constant to convert eV to ADC for 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

  ClassDef(AliITSSimuParam,1);
};
#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
	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
	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 SetSPDBiasVoltage(Double_t bias=18.182) {fSPDBiasVoltage=bias;}
	41	Double_t GetSPDBiasVoltage() const {return fSPDBiasVoltage;}
	42
	43	void SetSPDThresholds(Double_t thresh, Double_t sigma)
	44	{fSPDThresh=thresh; fSPDSigma=sigma;}
	45	void Thresholds(Double_t &thresh, Double_t &sigma) const
	46	{thresh=fSPDThresh; sigma=fSPDSigma;}
	47
	48	void SetSPDCouplingOption(const char *opt) {fSPDCouplOpt=opt;}
	49	void GetSPDCouplingOption(char *opt) const {strcpy(opt,fSPDCouplOpt.Data());}
	50
	51	void SetSPDCouplingParam(Double_t col, Double_t row)
	52	{fSPDCouplCol = col; fSPDCouplRow = row;}
	53	void GetSPDCouplingParam(Double_t &col, Double_t &row) const
	54	{col = fSPDCouplCol; row = fSPDCouplRow;}
	55
	56	void SetSPDSigmaDiffusionAsymmetry(Double_t ecc) {fSPDEccDiff=ecc;}
	57	void GetSPDSigmaDiffusionAsymmetry(Double_t &ecc) const {ecc=fSPDEccDiff;}
	58
	59	void SetSDDElectronics(Int_t p1=1) {fSDDElectronics=p1; }
	60	Int_t GetSDDElectronics() const {return fSDDElectronics;}
	61
	62	void SetSDDDiffCoeff(Float_t p1, Float_t p2) {
	63	fSDDDiffCoeff=p1; fSDDDiffCoeff1=p2;}
	64	void GetSDDDiffCoeff(Float_t &diff,Float_t &diff1) const {
65	diff=fSDDDiffCoeff; diff1=fSDDDiffCoeff1;}
66
67	void SetSDDJitterError(Float_t jitter) {fSDDJitterError=jitter;}
68	Float_t GetSDDJitterError() const {return fSDDJitterError;}
69
70	void SetSDDDynamicRange(Double_t p1) {fSDDDynamicRange = p1;}
71	Float_t GetSDDDynamicRange() const {return fSDDDynamicRange;}
72
73	void SetSDDMaxAdc(Double_t p1) {fSDDMaxAdc=p1;}
74	Float_t GetSDDMaxAdc() const {return fSDDMaxAdc;}
75
76	void SetSDDChargeLoss(Double_t p1) {fSDDChargeLoss=p1;}
77	Float_t GetSDDChargeLoss() const {return fSDDChargeLoss;}
78
79
80	void SetSSDADCpereV(Double_t a=120./24888.9){fSSDADCpereV = a;}
81	Double_t GetSSDDEvToADC(Double_t eV) const {return eV*fSSDADCpereV;}
82	Int_t GetSSDIEvToADC(Double_t eV) const {
83	return ((Int_t) GetSSDDEvToADC(eV)); }
84
85	void SetSSDCouplings(Double_t pr, Double_t pl, Double_t nr, Double_t nl) {
86	fSSDCouplingPR=pr; fSSDCouplingPL=pl; fSSDCouplingNR=nr; fSSDCouplingNL=nl; }
87	Double_t GetSSDCouplingPR() const {return fSSDCouplingPR;}
88	Double_t GetSSDCouplingPL() const {return fSSDCouplingPL;}
89	Double_t GetSSDCouplingNR() const {return fSSDCouplingNR;}
90	Double_t GetSSDCouplingNL() const {return fSSDCouplingNL;}
91
92	void SetNSigmaIntegration(Double_t p1) {fNsigmas=p1;}
93	Float_t GetNSigmaIntegration() const {return fNsigmas;}
94	void SetNLookUp(Int_t p1);
95	Int_t GetGausNLookUp() const {return fNcomps;}
96	Float_t GetGausLookUp(Int_t i) {
97	if (!fGaus) SetNLookUp(fgkNcompsDefault);
98	if(i<0 \|\| i>=fNcomps) return 0.;return fGaus->At(i);
99	}
100
101	void PrintParameters() const;
102
103	protected:
104
105	static const Float_t fgkSPDBiasVoltageDefault;//default for fSPDBiasVoltage
106	static const Double_t fgkSPDThreshDefault; //default for fThresh
107	static const Double_t fgkSPDSigmaDefault; //default for fSigma
108	static const TString fgkSPDCouplingOptDefault; // type of pixel Coupling (old or new)
109	static const Double_t fgkSPDCouplColDefault; //default for fSPDCouplCol
110	static const Double_t fgkSPDCouplRowDefault; //default for fSPDCouplRow
111	static const Float_t fgkSPDEccDiffDefault;//default for fSPDEccDiff
112	static const Float_t fgkSDDDiffCoeffDefault; // default for fSDDDiffCoeff
113	static const Float_t fgkSDDDiffCoeff1Default; // default for fSDDDiffCoeff1
114	static const Float_t fgkSDDJitterErrorDefault; // default for fSDDJitterError
115	static const Float_t fgkSDDDynamicRangeDefault; // default for fSDDDynamicRange
116	static const Int_t fgkSDDMaxAdcDefault; // default for fSDDMaxAdc
117	static const Float_t fgkSDDChargeLossDefault; // default for fSDDChargeLoss
118
119	static const Double_t fgkSSDCouplingPRDefault; // default values
120	static const Double_t fgkSSDCouplingPLDefault; // for the
121	static const Double_t fgkSSDCouplingNRDefault; // various SSD
122	static const Double_t fgkSSDCouplingNLDefault; // couplings
123	static const Int_t fgkSSDZSThresholdDefault; // default for fSSDZSThreshold
124
125	static const Float_t fgkNsigmasDefault; //default for fNsigmas
126	static const Int_t fgkNcompsDefault; //default for fNcomps
127
128	private:
129	Double_t fGeVcharge; // Energy to ionize (free an electron) in GeV
130	Double_t fDOverV; // The parameter d/v where d is the disance over which the
131	// the potential v is applied d/v [cm/volts]
132
133
134	Double_t fSPDBiasVoltage; // Bias Voltage for the SPD
135	Double_t fSPDThresh; // SPD Threshold value
136	Double_t fSPDSigma; // SPD Noise + threshold fluctuations value
137	TString fSPDCouplOpt; // SPD Coupling Option
138	Double_t fSPDCouplCol; // SPD Coupling parameter along the cols
139	Double_t fSPDCouplRow; // SPD Coupling parameter along the rows
140	Float_t fSPDEccDiff; // Eccentricity (i.e. asymmetry parameter) in the
141	// Gaussian diffusion for SPD
142
143	Int_t fSDDElectronics; // SDD Electronics Pascal (1) or OLA (2)
144	Float_t fSDDDiffCoeff; // SDD Diffusion Coefficient (scaling the time)
145	Float_t fSDDDiffCoeff1; // SDD Diffusion Coefficient (constant term)
146	Float_t fSDDJitterError; // SDD jitter error
147	Float_t fSDDDynamicRange; // SDD Dynamic Range
148	Float_t fSDDMaxAdc; // SDD ADC saturation value
149	Float_t fSDDChargeLoss; // Set Linear Coefficient for Charge Loss
150
151	Double_t fSSDADCpereV; // Constant to convert eV to ADC for SSD.
152	Double_t fSSDCouplingPR; // SSD couplings
153	Double_t fSSDCouplingPL; // SSD couplings
154	Double_t fSSDCouplingNR; // SSD couplings
155	Double_t fSSDCouplingNL; // SSD couplings
156	Int_t fSSDZSThreshold; // SSD threshold for the zero suppresion
157
158	Float_t fNsigmas; // Number of sigmas over which charge disintegration
159	// is performed
160	Int_t fNcomps; // Number of samplings along the gaussian
161	TArrayF *fGaus; // Gaussian lookup table for signal generation
162
163	ClassDef(AliITSSimuParam,1);
164	};
165	#endif