TRD/AliTRDdigitizer.h

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