[u/mrichter/AliRoot.git] / TRD / AliTRDsimTR.h

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

/* $Id$ */

////////////////////////////////////////////////////////////////////////////
//                                                                        //
//  TRD simulation - multimodule (regular rad.)                           //
//                                                                        //
////////////////////////////////////////////////////////////////////////////

#include <TObject.h>
#include <TMath.h>

class TH1D;

class AliModule;

class AliTRDsimTR : public TObject {

 public:

  AliTRDsimTR();
  AliTRDsimTR(const AliTRDsimTR &s);
  AliTRDsimTR(AliModule *mod, Int_t foil, Int_t gap);
  virtual ~AliTRDsimTR();
  AliTRDsimTR &operator=(const AliTRDsimTR &s);

  virtual void     Copy(TObject &s) const;
  virtual void     Init();
  virtual Int_t    CreatePhotons(Int_t pdg, Float_t p
                               , Int_t &nPhoton, Float_t *ePhoton);
  virtual Int_t    TrPhotons(Float_t p, Float_t mass
                           , Int_t &nPhoton, Float_t *ePhoton);
  virtual Double_t Sigma(Double_t energykeV);
  virtual Double_t Interpolate(Double_t energyMeV
                             , Double_t *en, Double_t *mu, Int_t n);
  virtual Int_t    Locate(Double_t *xv, Int_t n, Double_t xval
                        , Int_t &kl, Double_t &dx);
  virtual Double_t Omega(Float_t rho, Float_t z, Float_t a)  { return (28.8 * TMath::Sqrt(rho * z / a)); };
  virtual Int_t    SelectNFoils(Float_t p) const;

          void     SetFoilThick(Float_t t)                   { fFoilThick = t;
                                                               SetSigma();                                  };
          void     SetGapThick(Float_t t)                    { fGapThick  = t;
                                                               SetSigma();                                  };
          void     SetFoilDens(Float_t d)                    { fFoilDens  = d; 
                                                               fFoilOmega = Omega(fFoilDens,fFoilZ,fFoilA);
                                                               SetSigma();                                  };
          void     SetFoilZ(Float_t z)                       { fFoilZ     = z; 
                                                               fFoilOmega = Omega(fFoilDens,fFoilZ,fFoilA); };
          void     SetFoilA(Float_t a)                       { fFoilA     = a; 
                                                               fFoilOmega = Omega(fFoilDens,fFoilZ,fFoilA); };
          void     SetGapDens(Float_t d)                     { fGapDens   = d;
                                                               fGapOmega  = Omega(fGapDens ,fGapZ ,fGapA );
                                                               SetSigma();                                  };
          void     SetGapZ(Float_t z)                        { fGapZ      = z;
                                                               fGapOmega  = Omega(fGapDens ,fGapZ ,fGapA ); };
          void     SetGapA(Float_t a)                        { fGapA      = a;
                                                               fGapOmega  = Omega(fGapDens ,fGapZ ,fGapA ); };
          void     SetTemp(Float_t t)                        { fTemp      = t; 
                                                               SetSigma();                                  };
          void     SetSigma();

  virtual Double_t GetMuPo(Double_t energyMeV);
  virtual Double_t GetMuCO(Double_t energyMeV);
  virtual Double_t GetMuXe(Double_t energyMeV);
  virtual Double_t GetMuAr(Double_t energyMeV);
  virtual Double_t GetMuMy(Double_t energyMeV);
  virtual Double_t GetMuN2(Double_t energyMeV);
  virtual Double_t GetMuO2(Double_t energyMeV);
  virtual Double_t GetMuHe(Double_t energyMeV);
  virtual Double_t GetMuAi(Double_t energyMeV);

          Float_t  GetFoilThick() const                      { return fFoilThick;     };
          Float_t  GetGapThick() const                       { return fGapThick;      };
          Float_t  GetFoilDens() const                       { return fFoilDens;      };
          Float_t  GetGapDens() const                        { return fGapDens;       };
          Double_t GetFoilOmega() const                      { return fFoilOmega;     };
          Double_t GetGapOmega() const                       { return fGapOmega;      };
          Float_t  GetTemp() const                           { return fTemp / 273.16; };
          TH1D    *GetSpectrum() const                       { return fSpectrum;      };

 protected:

          Int_t     fNFoilsDim;            //  Dimension of the NFoils array
          Int_t    *fNFoils;               //[fNFoilsDim] Number of foils in the radiator stack
          Double_t *fNFoilsUp;             //[fNFoilsDim] Upper momenta for a given number of foils
          Float_t   fFoilThick;            //  Thickness of the foils (cm)
          Float_t   fGapThick;             //  Thickness of the gaps between the foils (cm)

          Float_t   fFoilDens;             //  Density of the radiator foils (g/cm^3) 
          Float_t   fGapDens;              //  Density of the gas in the radiator gaps (g/cm^3)

          Double_t  fFoilOmega;            //  Plasma frequency of the radiator foils
          Double_t  fGapOmega;             //  Plasma frequency of the gas in the radiator gaps

          Float_t   fFoilZ;                //  Z of the foil material
          Float_t   fGapZ;                 //  Z of the gas in the gaps

          Float_t   fFoilA;                //  A of the foil material
          Float_t   fGapA;                 //  A of the gas in the gaps

          Float_t   fTemp;                 //  Temperature of the radiator gas (Kelvin)

          Int_t     fSpNBins;              //  Number of bins of the TR spectrum
          Float_t   fSpRange;              //  Range of the TR spectrum
          Float_t   fSpBinWidth;           //  Bin width of the TR spectrum
          Float_t   fSpLower;              //  Lower border of the TR spectrum
          Float_t   fSpUpper;              //  Upper border of the TR spectrum

          Double_t *fSigma;                //[fSpNBins] Array of sigma values

          TH1D     *fSpectrum;             //! TR photon energy spectrum

  ClassDef(AliTRDsimTR,1)                  //  Simulates TR photons

};
#endif
Commit	Line	Data
cb2f9e9b	1	#ifndef ALITRDSIMTR_H
cb2f9e9b	2	#define ALITRDSIMTR_H
46d29e70	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
3bc9d03e	8	////////////////////////////////////////////////////////////////////////////
	9	// //
	10	// TRD simulation - multimodule (regular rad.) //
	11	// //
	12	////////////////////////////////////////////////////////////////////////////
0a29d0f1	13
46d29e70	14	#include <TObject.h>
090026bf	15	#include <TMath.h>
46d29e70	16
	17	class TH1D;
	18
	19	class AliModule;
	20
cb2f9e9b	21	class AliTRDsimTR : public TObject {
46d29e70	22
	23	public:
	24
cb2f9e9b	25	AliTRDsimTR();
	26	AliTRDsimTR(const AliTRDsimTR &s);
	27	AliTRDsimTR(AliModule *mod, Int_t foil, Int_t gap);
	28	virtual ~AliTRDsimTR();
	29	AliTRDsimTR &operator=(const AliTRDsimTR &s);
46d29e70	30
3bc9d03e	31	virtual void Copy(TObject &s) const;
	32	virtual void Init();
	33	virtual Int_t CreatePhotons(Int_t pdg, Float_t p
	34	, Int_t &nPhoton, Float_t *ePhoton);
	35	virtual Int_t TrPhotons(Float_t p, Float_t mass
	36	, Int_t &nPhoton, Float_t *ePhoton);
	37	virtual Double_t Sigma(Double_t energykeV);
	38	virtual Double_t Interpolate(Double_t energyMeV
	39	, Double_t en, Double_t mu, Int_t n);
	40	virtual Int_t Locate(Double_t *xv, Int_t n, Double_t xval
	41	, Int_t &kl, Double_t &dx);
	42	virtual Double_t Omega(Float_t rho, Float_t z, Float_t a) { return (28.8 * TMath::Sqrt(rho * z / a)); };
c8ab4518	43	virtual Int_t SelectNFoils(Float_t p) const;
3bc9d03e	44
	45	void SetFoilThick(Float_t t) { fFoilThick = t;
	46	SetSigma(); };
	47	void SetGapThick(Float_t t) { fGapThick = t;
	48	SetSigma(); };
	49	void SetFoilDens(Float_t d) { fFoilDens = d;
	50	fFoilOmega = Omega(fFoilDens,fFoilZ,fFoilA);
	51	SetSigma(); };
	52	void SetFoilZ(Float_t z) { fFoilZ = z;
	53	fFoilOmega = Omega(fFoilDens,fFoilZ,fFoilA); };
	54	void SetFoilA(Float_t a) { fFoilA = a;
	55	fFoilOmega = Omega(fFoilDens,fFoilZ,fFoilA); };
	56	void SetGapDens(Float_t d) { fGapDens = d;
	57	fGapOmega = Omega(fGapDens ,fGapZ ,fGapA );
	58	SetSigma(); };
	59	void SetGapZ(Float_t z) { fGapZ = z;
	60	fGapOmega = Omega(fGapDens ,fGapZ ,fGapA ); };
	61	void SetGapA(Float_t a) { fGapA = a;
	62	fGapOmega = Omega(fGapDens ,fGapZ ,fGapA ); };
	63	void SetTemp(Float_t t) { fTemp = t;
	64	SetSigma(); };
	65	void SetSigma();
	66
	67	virtual Double_t GetMuPo(Double_t energyMeV);
	68	virtual Double_t GetMuCO(Double_t energyMeV);
	69	virtual Double_t GetMuXe(Double_t energyMeV);
f2979d08	70	virtual Double_t GetMuAr(Double_t energyMeV);
3bc9d03e	71	virtual Double_t GetMuMy(Double_t energyMeV);
	72	virtual Double_t GetMuN2(Double_t energyMeV);
	73	virtual Double_t GetMuO2(Double_t energyMeV);
	74	virtual Double_t GetMuHe(Double_t energyMeV);
	75	virtual Double_t GetMuAi(Double_t energyMeV);
	76
	77	Float_t GetFoilThick() const { return fFoilThick; };
	78	Float_t GetGapThick() const { return fGapThick; };
	79	Float_t GetFoilDens() const { return fFoilDens; };
	80	Float_t GetGapDens() const { return fGapDens; };
	81	Double_t GetFoilOmega() const { return fFoilOmega; };
	82	Double_t GetGapOmega() const { return fGapOmega; };
	83	Float_t GetTemp() const { return fTemp / 273.16; };
	84	TH1D *GetSpectrum() const { return fSpectrum; };
46d29e70	85
	86	protected:
	87
3bc9d03e	88	Int_t fNFoilsDim; // Dimension of the NFoils array
	89	Int_t *fNFoils; //[fNFoilsDim] Number of foils in the radiator stack
	90	Double_t *fNFoilsUp; //[fNFoilsDim] Upper momenta for a given number of foils
	91	Float_t fFoilThick; // Thickness of the foils (cm)
	92	Float_t fGapThick; // Thickness of the gaps between the foils (cm)
46d29e70	93
3bc9d03e	94	Float_t fFoilDens; // Density of the radiator foils (g/cm^3)
3bc9d03e	95	Float_t fGapDens; // Density of the gas in the radiator gaps (g/cm^3)
46d29e70	96
3bc9d03e	97	Double_t fFoilOmega; // Plasma frequency of the radiator foils
3bc9d03e	98	Double_t fGapOmega; // Plasma frequency of the gas in the radiator gaps
46d29e70	99
3bc9d03e	100	Float_t fFoilZ; // Z of the foil material
3bc9d03e	101	Float_t fGapZ; // Z of the gas in the gaps
46d29e70	102
3bc9d03e	103	Float_t fFoilA; // A of the foil material
3bc9d03e	104	Float_t fGapA; // A of the gas in the gaps
46d29e70	105
3bc9d03e	106	Float_t fTemp; // Temperature of the radiator gas (Kelvin)
46d29e70	107
3bc9d03e	108	Int_t fSpNBins; // Number of bins of the TR spectrum
	109	Float_t fSpRange; // Range of the TR spectrum
	110	Float_t fSpBinWidth; // Bin width of the TR spectrum
	111	Float_t fSpLower; // Lower border of the TR spectrum
	112	Float_t fSpUpper; // Upper border of the TR spectrum
46d29e70	113
3bc9d03e	114	Double_t *fSigma; //[fSpNBins] Array of sigma values
46d29e70	115
3bc9d03e	116	TH1D *fSpectrum; //! TR photon energy spectrum
46d29e70	117
cb2f9e9b	118	ClassDef(AliTRDsimTR,1) // Simulates TR photons
46d29e70	119
	120	};
	121	#endif