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

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

/* $Id$ */

#include "AliDigitizer.h"

class TFile;
class TF1;

class AliRunDigitizer;

class AliTRD;
class AliTRDdigitsManager;
class AliTRDgeometry;

///////////////////////////////////////////////////////
//  Produces digits from the hits information        //
///////////////////////////////////////////////////////

class AliTRDdigitizer : public AliDigitizer {

 public:

  AliTRDdigitizer();
  AliTRDdigitizer(const Text_t* name, const Text_t* title);
  AliTRDdigitizer(AliRunDigitizer *manager, const Text_t* name, const Text_t* title);
  AliTRDdigitizer(AliRunDigitizer *manager);
  AliTRDdigitizer(const AliTRDdigitizer &d);
  virtual ~AliTRDdigitizer();
  AliTRDdigitizer &operator=(const AliTRDdigitizer &d);

  virtual void         Copy(TObject &d);
  virtual Bool_t       Init();
  virtual Bool_t       InitDetector();
  virtual Bool_t       ReInit();
  virtual void         Exec(Option_t* option = 0);  
  virtual Bool_t       Open(const Char_t *file, Int_t nEvent = 0);
  virtual Bool_t       MakeBranch(const Char_t *file = 0);
  virtual Bool_t       MakeDigits();
  virtual void         AddSDigitsManager(AliTRDdigitsManager *manager);
  virtual Bool_t       ConvertSDigits();
  virtual Bool_t       MergeSDigits();
  virtual Bool_t       SDigits2Digits();
  virtual Bool_t       WriteDigits();

  virtual void         SetGasGain(Float_t gasgain)          { fGasGain        = gasgain;  };
  virtual void         SetNoise(Float_t noise)              { fNoise          = noise;    };
  virtual void         SetChipGain(Float_t chipgain)        { fChipGain       = chipgain; };
  virtual void         SetADCoutRange(Float_t range)        { fADCoutRange    = range;    };
  virtual void         SetADCinRange(Float_t range)         { fADCinRange     = range;    };
  virtual void         SetADCthreshold(Int_t thresh)        { fADCthreshold   = thresh;   };
  virtual void         SetDiffusion(Int_t diffOn = 1)       { fDiffusionOn    = diffOn;   };
  virtual void         SetElAttach(Int_t elOn = 1)          { fElAttachOn     = elOn;     };
  virtual void         SetElAttachProp(Float_t prop)        { fElAttachProp   = prop;     };
  virtual void         SetExB(Int_t exbOn = 1)              { fExBOn          = exbOn;    };
  virtual void         SetPadResponse(Int_t prfOn = 1)      { fPRFOn          = prfOn;    };
  virtual void         SetTimeResponse(Int_t trfOn = 1)     { fTRFOn          = trfOn;   
                                                              ReInit();                   };
  virtual void         SetCrossTalk(Int_t ctOn = 1)         { fCTOn           = ctOn;   
                                                              ReInit();                   };
  virtual void         SetTailCancelation(Int_t tcOn = 1)   { fTCOn           = tcOn;     };
  virtual void         SetNexponential(Int_t nexp)          { fTCnexp         = nexp;     };
  virtual void         SetDriftVelocity(Float_t v)          { fDriftVelocity  = v;       
                                                              ReInit();                   };
  virtual void         SetPadCoupling(Float_t v)            { fPadCoupling    = v;        };
  virtual void         SetTimeCoupling(Float_t v)           { fTimeCoupling   = v;        };
  virtual void         SetTiltingAngle(Float_t v);
  virtual void         SetCompress(Int_t c = 1)             { fCompress       = c;        };
  virtual void         SetDebug(Int_t v = 1)                { fDebug          = v;        };
  virtual void         SetSDigits(Int_t v = 1)              { fSDigits        = v;        };
  virtual void         SetSDigitsScale(Float_t s)           { fSDigitsScale   = s;        };
  virtual void         SetEvent(Int_t v = 0)                { fEvent          = v;        };
  virtual void         SetManager(AliTRDdigitsManager *man) { fDigitsManager  = man;      };    

  AliTRDdigitsManager *Digits() const                       { return fDigitsManager;      };

          Float_t      GetGasGain() const                   { return fGasGain;            };
          Float_t      GetNoise() const                     { return fNoise;              };
          Float_t      GetChipGain() const                  { return fChipGain;           };
          Float_t      GetADCoutRange() const               { return fADCoutRange;        };
          Float_t      GetADCinRange() const                { return fADCinRange;         };
          Int_t        GetADCthreshold() const              { return fADCthreshold;       };
          Float_t      GetDiffusionT() const                { return fDiffusionT;         };
          Float_t      GetDiffusionL() const                { return fDiffusionL;         };
          Float_t      GetElAttachProp() const              { return fElAttachProp;       };
          Int_t        GetExB() const                       { return fExBOn;              };
          Float_t      GetOmegaTau() const                  { return fOmegaTau;           };
          Float_t      GetDriftVelocity() const             { return fDriftVelocity;      };
          Float_t      GetPadCoupling() const               { return fPadCoupling;        };
          Float_t      GetTimeCoupling() const              { return fTimeCoupling;       };
          Bool_t       GetCompress() const                  { return fCompress;           };
          Bool_t       GetSDigits() const                   { return fSDigits;            };
          Float_t      GetSDigitsScale() const              { return fSDigitsScale;       };
          Float_t      GetTimeBinWidth() const              { return fTimeBinWidth;       };
          Float_t      GetTiltingAngle() const;
  virtual Float_t      GetDiffusionL(Float_t vd, Float_t b);
  virtual Float_t      GetDiffusionT(Float_t vd, Float_t b);
  virtual Float_t      GetOmegaTau(Float_t vd, Float_t b);

 protected:

  TFile               *fInputFile;          //! ALIROOT-file
  AliTRDdigitsManager *fDigitsManager;      //! Manager for the output digits
  AliTRDdigitsManager *fSDigitsManager;     //! Manager for the summed input s-digits
  TList               *fSDigitsManagerList; //! List of managers of input s-digits
  AliTRD              *fTRD;                //! TRD detector class
  AliTRDgeometry      *fGeo;                //! TRD geometry
  
  Int_t                fEvent;              //! Event number

  Int_t               *fMasks;              //! Masks for the merging

  Float_t              fField;              //  Magnetic field
  Float_t              fGasGain;            //  Gas gain
  Float_t              fNoise;              //  Electronics noise
  Float_t              fChipGain;           //  Electronics gain
  Float_t              fADCoutRange;        //  ADC output range (number of channels)
  Float_t              fADCinRange;         //  ADC input range (input charge)
  Int_t                fADCthreshold;       //  ADC threshold in ADC channel
  Int_t                fDiffusionOn;        //  Switch for the diffusion
  Float_t              fDiffusionT;         //  Diffusion in transverse direction
  Float_t              fDiffusionL;         //  Diffusion in longitudinal direction
  Int_t                fElAttachOn;         //  Switch for the electron attachment
  Float_t              fElAttachProp;       //  Propability for electron attachment (for 1m)
  Int_t                fExBOn;              //  Switch for the ExB effects
  Float_t              fOmegaTau;           //  Tangens of the Lorentz angle 
  Float_t              fLorentzFactor;      //  Factor due to Lorentz force
  Int_t                fPRFOn;              //  Switch for the pad response
  Float_t             *fPRFsmp;             //! Sampled pad response
  Int_t                fPRFbin;             //  Number of bins for the PRF
  Float_t              fPRFlo;              //  Lower boundary of the PRF
  Float_t              fPRFhi;              //  Higher boundary of the PRF
  Float_t              fPRFwid;             //  Bin width of the sampled PRF
  Int_t                fPRFpad;             //  Distance to next pad in PRF
  Int_t                fTRFOn;              //  Switch for the time response
  Float_t             *fTRFsmp;             //! Integrated time response
  Int_t                fTRFbin;             //  Number of bins for the TRF
  Float_t              fTRFlo;              //  Lower boundary of the TRF
  Float_t              fTRFhi;              //  Higher boundary of the TRF
  Float_t              fTRFwid;             //  Bin width of the integrated TRF
  Int_t                fCTOn;               //  Switch for cross talk
  Float_t             *fCTsmp;              //! Integrated cross talk
  Int_t                fTCOn;               //  Switch for the tail cancelation
  Int_t                fTCnexp;             //  Number of exponential of the digital filter
  Float_t              fDriftVelocity;      //  Drift velocity (cm / mus)
  Float_t              fTimeBinWidth;       //  Time bin width in ns
  Float_t              fPadCoupling;        //  Pad coupling factor
  Float_t              fTimeCoupling;       //  Time coupling factor (image charge of moving ions)
  Float_t              fTiltingAngle;       //  Tilting angle of the readout pads
  Bool_t               fCompress;           //  Switch to keep only compressed data in memory
  Int_t                fDebug;              //  Sets the debug level
  Bool_t               fSDigits;            //  Switch for the summable digits
  Float_t              fSDigitsScale;       //  Scale factor for the summable digits 

 private:

  virtual Float_t      Col0Tilted(Float_t col0, Float_t rowOffset, Int_t plane);
  virtual Float_t      CrossTalk(Float_t time); 
  virtual Int_t        Diffusion(Float_t driftlength, Float_t *xyz);
  virtual Int_t        ExB(Float_t driftlength, Float_t *xyz);  
  virtual Int_t        PadResponse(Float_t signal, Float_t dist, Int_t plane, Float_t *pad);
  virtual Float_t      TimeResponse(Float_t time);  
  virtual void         DeConvExp(Double_t *source, Double_t *target, Int_t n, Int_t nexp);
  virtual Bool_t       CheckDetector(Int_t plane, Int_t chamber, Int_t sector);
  virtual void         SamplePRF();
  virtual void         SampleTRF();

  ClassDef(AliTRDdigitizer,6)               //  Produces TRD-Digits

};

#endif
Commit	Line	Data
dd9a6ee3	1	#ifndef ALITRDDIGITIZER_H
dd9a6ee3	2	#define ALITRDDIGITIZER_H
f7336fa3	3	/* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
	6	/* $Id$ */
	7
85cbec76	8	#include "AliDigitizer.h"
f7336fa3	9
793ff80c	10	class TFile;
	11	class TF1;
	12
85cbec76	13	class AliRunDigitizer;
85cbec76	14
793ff80c	15	class AliTRD;
6f1e466d	16	class AliTRDdigitsManager;
793ff80c	17	class AliTRDgeometry;
f7336fa3	18
	19	///////////////////////////////////////////////////////
	20	// Produces digits from the hits information //
	21	///////////////////////////////////////////////////////
	22
85cbec76	23	class AliTRDdigitizer : public AliDigitizer {
f7336fa3	24
	25	public:
	26
	27	AliTRDdigitizer();
	28	AliTRDdigitizer(const Text_t* name, const Text_t* title);
85cbec76	29	AliTRDdigitizer(AliRunDigitizer manager, const Text_t name, const Text_t* title);
bfc40adc	30	AliTRDdigitizer(AliRunDigitizer *manager);
dd9a6ee3	31	AliTRDdigitizer(const AliTRDdigitizer &d);
8230f242	32	virtual ~AliTRDdigitizer();
dd9a6ee3	33	AliTRDdigitizer &operator=(const AliTRDdigitizer &d);
f7336fa3	34
dd9a6ee3	35	virtual void Copy(TObject &d);
85cbec76	36	virtual Bool_t Init();
abaf1f1d	37	virtual Bool_t InitDetector();
85cbec76	38	virtual Bool_t ReInit();
e23fbb27	39	virtual void Exec(Option_t* option = 0);
e23fbb27	40	virtual Bool_t Open(const Char_t *file, Int_t nEvent = 0);
abaf1f1d	41	virtual Bool_t MakeBranch(const Char_t *file = 0);
6f1e466d	42	virtual Bool_t MakeDigits();
85cbec76	43	virtual void AddSDigitsManager(AliTRDdigitsManager *manager);
abaf1f1d	44	virtual Bool_t ConvertSDigits();
	45	virtual Bool_t MergeSDigits();
	46	virtual Bool_t SDigits2Digits();
6f1e466d	47	virtual Bool_t WriteDigits();
793ff80c	48
16bf9884	49	virtual void SetGasGain(Float_t gasgain) { fGasGain = gasgain; };
	50	virtual void SetNoise(Float_t noise) { fNoise = noise; };
	51	virtual void SetChipGain(Float_t chipgain) { fChipGain = chipgain; };
	52	virtual void SetADCoutRange(Float_t range) { fADCoutRange = range; };
	53	virtual void SetADCinRange(Float_t range) { fADCinRange = range; };
	54	virtual void SetADCthreshold(Int_t thresh) { fADCthreshold = thresh; };
	55	virtual void SetDiffusion(Int_t diffOn = 1) { fDiffusionOn = diffOn; };
	56	virtual void SetElAttach(Int_t elOn = 1) { fElAttachOn = elOn; };
	57	virtual void SetElAttachProp(Float_t prop) { fElAttachProp = prop; };
	58	virtual void SetExB(Int_t exbOn = 1) { fExBOn = exbOn; };
	59	virtual void SetPadResponse(Int_t prfOn = 1) { fPRFOn = prfOn; };
	60	virtual void SetTimeResponse(Int_t trfOn = 1) { fTRFOn = trfOn;
	61	ReInit(); };
e23fbb27	62	virtual void SetCrossTalk(Int_t ctOn = 1) { fCTOn = ctOn;
	63	ReInit(); };
	64	virtual void SetTailCancelation(Int_t tcOn = 1) { fTCOn = tcOn; };
	65	virtual void SetNexponential(Int_t nexp) { fTCnexp = nexp; };
16bf9884	66	virtual void SetDriftVelocity(Float_t v) { fDriftVelocity = v;
	67	ReInit(); };
	68	virtual void SetPadCoupling(Float_t v) { fPadCoupling = v; };
	69	virtual void SetTimeCoupling(Float_t v) { fTimeCoupling = v; };
e23fbb27	70	virtual void SetTiltingAngle(Float_t v);
16bf9884	71	virtual void SetCompress(Int_t c = 1) { fCompress = c; };
e23fbb27	72	virtual void SetDebug(Int_t v = 1) { fDebug = v; };
16bf9884	73	virtual void SetSDigits(Int_t v = 1) { fSDigits = v; };
abaf1f1d	74	virtual void SetSDigitsScale(Float_t s) { fSDigitsScale = s; };
16bf9884	75	virtual void SetEvent(Int_t v = 0) { fEvent = v; };
abaf1f1d	76	virtual void SetManager(AliTRDdigitsManager *man) { fDigitsManager = man; };
793ff80c	77
abaf1f1d	78	AliTRDdigitsManager *Digits() const { return fDigitsManager; };
872a7aba	79
16bf9884	80	Float_t GetGasGain() const { return fGasGain; };
	81	Float_t GetNoise() const { return fNoise; };
	82	Float_t GetChipGain() const { return fChipGain; };
	83	Float_t GetADCoutRange() const { return fADCoutRange; };
	84	Float_t GetADCinRange() const { return fADCinRange; };
	85	Int_t GetADCthreshold() const { return fADCthreshold; };
	86	Float_t GetDiffusionT() const { return fDiffusionT; };
	87	Float_t GetDiffusionL() const { return fDiffusionL; };
	88	Float_t GetElAttachProp() const { return fElAttachProp; };
	89	Int_t GetExB() const { return fExBOn; };
	90	Float_t GetOmegaTau() const { return fOmegaTau; };
	91	Float_t GetDriftVelocity() const { return fDriftVelocity; };
	92	Float_t GetPadCoupling() const { return fPadCoupling; };
	93	Float_t GetTimeCoupling() const { return fTimeCoupling; };
	94	Bool_t GetCompress() const { return fCompress; };
	95	Bool_t GetSDigits() const { return fSDigits; };
abaf1f1d	96	Float_t GetSDigitsScale() const { return fSDigitsScale; };
16bf9884	97	Float_t GetTimeBinWidth() const { return fTimeBinWidth; };
e23fbb27	98	Float_t GetTiltingAngle() const;
db30bf0f	99	virtual Float_t GetDiffusionL(Float_t vd, Float_t b);
	100	virtual Float_t GetDiffusionT(Float_t vd, Float_t b);
	101	virtual Float_t GetOmegaTau(Float_t vd, Float_t b);
f7336fa3	102
	103	protected:
	104
abaf1f1d	105	TFile *fInputFile; //! ALIROOT-file
	106	AliTRDdigitsManager *fDigitsManager; //! Manager for the output digits
	107	AliTRDdigitsManager *fSDigitsManager; //! Manager for the summed input s-digits
	108	TList *fSDigitsManagerList; //! List of managers of input s-digits
	109	AliTRD *fTRD; //! TRD detector class
	110	AliTRDgeometry *fGeo; //! TRD geometry
f7336fa3	111
abaf1f1d	112	Int_t fEvent; //! Event number
abaf1f1d	113
e23fbb27	114	Int_t *fMasks; //! Masks for the merging
e23fbb27	115
abaf1f1d	116	Float_t fField; // Magnetic field
	117	Float_t fGasGain; // Gas gain
	118	Float_t fNoise; // Electronics noise
	119	Float_t fChipGain; // Electronics gain
	120	Float_t fADCoutRange; // ADC output range (number of channels)
	121	Float_t fADCinRange; // ADC input range (input charge)
	122	Int_t fADCthreshold; // ADC threshold in ADC channel
	123	Int_t fDiffusionOn; // Switch for the diffusion
	124	Float_t fDiffusionT; // Diffusion in transverse direction
	125	Float_t fDiffusionL; // Diffusion in longitudinal direction
	126	Int_t fElAttachOn; // Switch for the electron attachment
	127	Float_t fElAttachProp; // Propability for electron attachment (for 1m)
	128	Int_t fExBOn; // Switch for the ExB effects
	129	Float_t fOmegaTau; // Tangens of the Lorentz angle
	130	Float_t fLorentzFactor; // Factor due to Lorentz force
	131	Int_t fPRFOn; // Switch for the pad response
	132	Float_t *fPRFsmp; //! Sampled pad response
	133	Int_t fPRFbin; // Number of bins for the PRF
	134	Float_t fPRFlo; // Lower boundary of the PRF
	135	Float_t fPRFhi; // Higher boundary of the PRF
	136	Float_t fPRFwid; // Bin width of the sampled PRF
	137	Int_t fPRFpad; // Distance to next pad in PRF
	138	Int_t fTRFOn; // Switch for the time response
	139	Float_t *fTRFsmp; //! Integrated time response
	140	Int_t fTRFbin; // Number of bins for the TRF
	141	Float_t fTRFlo; // Lower boundary of the TRF
	142	Float_t fTRFhi; // Higher boundary of the TRF
	143	Float_t fTRFwid; // Bin width of the integrated TRF
e23fbb27	144	Int_t fCTOn; // Switch for cross talk
	145	Float_t *fCTsmp; //! Integrated cross talk
	146	Int_t fTCOn; // Switch for the tail cancelation
	147	Int_t fTCnexp; // Number of exponential of the digital filter
abaf1f1d	148	Float_t fDriftVelocity; // Drift velocity (cm / mus)
	149	Float_t fTimeBinWidth; // Time bin width in ns
	150	Float_t fPadCoupling; // Pad coupling factor
	151	Float_t fTimeCoupling; // Time coupling factor (image charge of moving ions)
e23fbb27	152	Float_t fTiltingAngle; // Tilting angle of the readout pads
abaf1f1d	153	Bool_t fCompress; // Switch to keep only compressed data in memory
e23fbb27	154	Int_t fDebug; // Sets the debug level
abaf1f1d	155	Bool_t fSDigits; // Switch for the summable digits
abaf1f1d	156	Float_t fSDigitsScale; // Scale factor for the summable digits
f7336fa3	157
	158	private:
	159
e23fbb27	160	virtual Float_t Col0Tilted(Float_t col0, Float_t rowOffset, Int_t plane);
e23fbb27	161	virtual Float_t CrossTalk(Float_t time);
793ff80c	162	virtual Int_t Diffusion(Float_t driftlength, Float_t *xyz);
793ff80c	163	virtual Int_t ExB(Float_t driftlength, Float_t *xyz);
e23fbb27	164	virtual Int_t PadResponse(Float_t signal, Float_t dist, Int_t plane, Float_t *pad);
793ff80c	165	virtual Float_t TimeResponse(Float_t time);
e23fbb27	166	virtual void DeConvExp(Double_t source, Double_t target, Int_t n, Int_t nexp);
793ff80c	167	virtual Bool_t CheckDetector(Int_t plane, Int_t chamber, Int_t sector);
e153aaf6	168	virtual void SamplePRF();
6244debe	169	virtual void SampleTRF();
793ff80c	170
d13f9a3e	171	ClassDef(AliTRDdigitizer,6) // Produces TRD-Digits
f7336fa3	172
	173	};
	174
	175	#endif