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

#ifndef ALIITSRESPONSESSD_H
#define ALIITSRESPONSESSD_H
 
#include "AliITSresponse.h"

// response for SSD

//-----------------------------
class AliITSresponseSSD :
public AliITSresponse {

public:
  
  AliITSresponseSSD();
  virtual ~AliITSresponseSSD();
  AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
  AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
  
  virtual void    SetDiffCoeff(Float_t p1=0.) {
    // Diffusion coefficient
    fDiffCoeff=p1;
  }
  virtual Float_t DiffCoeff() {
    // Get diffusion coefficient
    return fDiffCoeff;
  }
  
  virtual  void   SetNoiseParam(Float_t np=420., Float_t nn=625.) {
    // set noise par
    fNoiseP=np; fNoiseN=nn;
  }
  virtual void    GetNoiseParam(Float_t &np, Float_t &nn) {
    // get noise par
    np=fNoiseP; nn=fNoiseN;
  }
  
  virtual void    SetParamOptions(Option_t *opt1="", Option_t *opt2="") {
    // parameters: "SetInvalid" to simulate the invalid strips
    fOption1=opt1; fOption2=opt2;
  }
  virtual void    ParamOptions(Option_t *&opt1,Option_t *&opt2) {
    // options
    opt1=fOption1; opt2=fOption2;
  }
  
  // Number of parameters to be set
  // 4 couplings, mean number of invalid strips, RMS of invalid strips
  virtual  void   SetNDetParam(Int_t npar=6) {
    // set number of param
    fNPar=npar;
  }

  virtual  void   SetDetParam(Float_t *par);
  
  // Parameters options
  virtual Int_t   NDetParam() {
    // number of param
    return fNPar;
  }
  virtual void    GetDetParam(Float_t *dpar); 

  virtual void    SetDataType(char *data="simulated") {
  // Type of data - real or simulated
    fDataType=data;
  }
  virtual const char  *DataType() {
    // Get data type
    return fDataType.Data();
  } 
  
  virtual void    SetSigmaSpread(Float_t p1=3., Float_t p2=2.) {
    // Set sigmas of the charge spread function: Pside-Nside
    // square of (microns)
    fSigmaP=p1; fSigmaN=p2;
  }
  virtual void    SigmaSpread(Float_t &sP, Float_t &sN) {
    // Get sigmas for the charge spread 
    sP=fSigmaP; sN=fSigmaN;
  }
  
protected:
  Int_t   fNPar;            // Number of detector param 
  Float_t *fDetPar       ;  // Array of parameters 
  
  Float_t fNoiseP;          // Noise on Pside
  Float_t fNoiseN;          // Noise on Nside
  
  Float_t fSigmaP;          // Sigma charge spread on Pside
  Float_t fSigmaN;          // Sigma charge spread on Nside
  Float_t fDiffCoeff;       // Diffusion Coefficient
  
  Option_t *fOption1;       // Simulate invalid strips option
  Option_t *fOption2;       // Not used for the moment
  
  TString  fDataType;       // Type of data - real or simulated
  
  ClassDef(AliITSresponseSSD,1) //Response class for SSD 

    };


#endif
Commit	Line	Data
b0f5e3fc	1	#ifndef ALIITSRESPONSESSD_H
	2	#define ALIITSRESPONSESSD_H
	3
	4	#include "AliITSresponse.h"
	5
	6	// response for SSD
	7
	8	//-----------------------------
	9	class AliITSresponseSSD :
	10	public AliITSresponse {
	11
	12	public:
	13
	14	AliITSresponseSSD();
	15	virtual ~AliITSresponseSSD();
	16	AliITSresponseSSD(const AliITSresponseSSD &source); // copy constructor
	17	AliITSresponseSSD& operator=(const AliITSresponseSSD &source); // ass. op.
	18
	19	virtual void SetDiffCoeff(Float_t p1=0.) {
	20	// Diffusion coefficient
	21	fDiffCoeff=p1;
	22	}
	23	virtual Float_t DiffCoeff() {
	24	// Get diffusion coefficient
	25	return fDiffCoeff;
	26	}
	27
	28	virtual void SetNoiseParam(Float_t np=420., Float_t nn=625.) {
	29	// set noise par
	30	fNoiseP=np; fNoiseN=nn;
	31	}
	32	virtual void GetNoiseParam(Float_t &np, Float_t &nn) {
	33	// get noise par
	34	np=fNoiseP; nn=fNoiseN;
	35	}
	36
	37	virtual void SetParamOptions(Option_t opt1="", Option_t opt2="") {
	38	// parameters: "SetInvalid" to simulate the invalid strips
	39	fOption1=opt1; fOption2=opt2;
	40	}
	41	virtual void ParamOptions(Option_t &opt1,Option_t &opt2) {
	42	// options
	43	opt1=fOption1; opt2=fOption2;
	44	}
	45
	46	// Number of parameters to be set
	47	// 4 couplings, mean number of invalid strips, RMS of invalid strips
	48	virtual void SetNDetParam(Int_t npar=6) {
	49	// set number of param
	50	fNPar=npar;
	51	}
	52
	53	virtual void SetDetParam(Float_t *par);
	54
	55	// Parameters options
	56	virtual Int_t NDetParam() {
	57	// number of param
	58	return fNPar;
	59	}
	60	virtual void GetDetParam(Float_t *dpar);
	61
	62	virtual void SetDataType(char *data="simulated") {
	63	// Type of data - real or simulated
	64	fDataType=data;
65	}
66	virtual const char *DataType() {
67	// Get data type
68	return fDataType.Data();
69	}
70
71	virtual void SetSigmaSpread(Float_t p1=3., Float_t p2=2.) {
72	// Set sigmas of the charge spread function: Pside-Nside
73	// square of (microns)
74	fSigmaP=p1; fSigmaN=p2;
75	}
76	virtual void SigmaSpread(Float_t &sP, Float_t &sN) {
77	// Get sigmas for the charge spread
78	sP=fSigmaP; sN=fSigmaN;
79	}
80
81	protected:
82	Int_t fNPar; // Number of detector param
83	Float_t *fDetPar ; // Array of parameters
84
85	Float_t fNoiseP; // Noise on Pside
86	Float_t fNoiseN; // Noise on Nside
87
88	Float_t fSigmaP; // Sigma charge spread on Pside
89	Float_t fSigmaN; // Sigma charge spread on Nside
90	Float_t fDiffCoeff; // Diffusion Coefficient
91
92	Option_t *fOption1; // Simulate invalid strips option
93	Option_t *fOption2; // Not used for the moment
94
95	TString fDataType; // Type of data - real or simulated
96
97	ClassDef(AliITSresponseSSD,1) //Response class for SSD
98
99	};
100
101
102
103	#endif
104
105
106
107
108
109
110