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