]> git.uio.no Git - u/mrichter/AliRoot.git/blobdiff - TRD/AliTRDdigitizer.h
Adjust needed statistics for Vd calibration and normalization with TPC signal for...
[u/mrichter/AliRoot.git] / TRD / AliTRDdigitizer.h
index a732c56e51e3f54064e8eb6ab4439a7cd8384a84..304fa8b677f6431c1eb8ae7e91ee605a2bf164c6 100644 (file)
 
 /* $Id$ */
 
+////////////////////////////////////////////////////////////////////////////
+//                                                                        //
+//  Produces digits from the hits information                             //
+//                                                                        //
+////////////////////////////////////////////////////////////////////////////
+
 #include "AliDigitizer.h"
 
 class TFile;
 class TF1;
 
-class AliRunDigitizer;
+class AliDigitizationInput;
 class AliRunLoader;
 
 class AliTRD;
 class AliTRDdigitsManager;
 class AliTRDgeometry;
-class AliTRDparameter;
-
-///////////////////////////////////////////////////////
-//  Produces digits from the hits information        //
-///////////////////////////////////////////////////////
+class AliTRDarraySignal;
+class AliTRDarrayADC;
+class AliTRDmcmSim;
 
 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 Text_t *name, const Text_t *title);
+  AliTRDdigitizer(AliDigitizationInput* digInput, const Text_t *name, const Text_t *title);
+  AliTRDdigitizer(AliDigitizationInput* digInput);
   AliTRDdigitizer(const AliTRDdigitizer &d);
-  virtual ~AliTRDdigitizer();
-  AliTRDdigitizer &operator=(const AliTRDdigitizer &d);
+  virtual             ~AliTRDdigitizer();
+  AliTRDdigitizer     &operator=(const AliTRDdigitizer &d);
 
   virtual void         Copy(TObject &d) const;
-  virtual Bool_t       InitDetector();
-  virtual void         Exec(Option_t* option = 0);  
+          Bool_t       InitDetector();
+          void         InitOutput(Int_t iEvent);
+  virtual void         Digitize(const Option_t * option = 0);  
+
   virtual Bool_t       Open(const Char_t *file, Int_t nEvent = 0);
-  virtual Bool_t       MakeBranch(TTree* tree) const;
-  virtual Bool_t       MakeDigits();
+  virtual Bool_t       Open(AliRunLoader * const runLoader, Int_t nEvent = 0);
+  virtual Bool_t       MakeBranch(TTree *tree) const;
+  virtual Bool_t       WriteDigits() const;
+
   virtual void         AddSDigitsManager(AliTRDdigitsManager *manager);
   virtual void         DeleteSDigitsManager();
-  virtual Bool_t       ConvertSDigits();
-  virtual Bool_t       MergeSDigits();
-  virtual Bool_t       SDigits2Digits();
-  virtual Bool_t       WriteDigits() const;
 
-          void         InitOutput(Int_t iEvent);
-  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; };   
-  virtual void         SetGeometry(AliTRDgeometry *geo)     { fGeo             = geo; };
-  virtual void         SetParameter(AliTRDparameter *par)   { fPar             = par; };
-  virtual void         SetMergeSignalOnly(Bool_t m = kTRUE) { fMergeSignalOnly = m;   };
-  virtual void         SetSimple(Int_t v = 1)               { fSimpleSim       = v;
-                                                              fSimpleDet       = 12;
-                                                              fCompress        = kFALSE; };
-
-  AliTRDdigitsManager *Digits()                       const { return fDigitsManager; };
-
-          Bool_t       GetCompress()                  const { return fCompress;      };
-          Bool_t       GetSDigits()                   const { return fSDigits;       };
-          Float_t      GetSDigitsScale()              const { return fSDigitsScale;  };
-  AliTRDparameter     *GetParameter()                 const { return fPar;           };
-          Bool_t       GetSimple()                    const { return fSimpleSim;     };
+  virtual Bool_t       MakeDigits();
+
+          Bool_t       SortHits(Float_t **hits, Int_t *nhit);
+          Bool_t       ConvertHits(Int_t det, const Float_t * const hits, Int_t nhit, AliTRDarraySignal *signals);
+          Bool_t       ConvertSignals(Int_t det, AliTRDarraySignal *signals);
+
+          Bool_t       Digits2SDigits(AliTRDdigitsManager * const manDig, AliTRDdigitsManager * const manSDig);
+          Bool_t       SDigits2Digits();
+          Bool_t       MergeSDigits();
+          Bool_t       ConvertSDigits();
+
+          Bool_t       Signal2ADC(Int_t det, AliTRDarraySignal *signals);
+          Bool_t       Signal2SDigits(Int_t det, AliTRDarraySignal *signals);
+          Bool_t       CopyDictionary(Int_t det);
+         void         CompressOutputArrays(Int_t det);
+
+          void         SetCompress(Int_t c = 1)                    { fCompress        = c;   }
+          void         SetSDigits(Int_t v = 1)                     { fSDigits         = v;   }
+          void         SetEvent(Int_t v = 0)                       { fEvent           = v;   }
+          void         SetManager(AliTRDdigitsManager * const man) { fDigitsManager   = man; }
+          void         SetGeometry(AliTRDgeometry * const geo)     { fGeo             = geo; }
+          void         SetMergeSignalOnly(Bool_t m = kTRUE)        { fMergeSignalOnly = m;   }
+
+  AliTRDdigitsManager *Digits() const                              { return fDigitsManager;  }
+
+          Bool_t       GetCompress() const                         { return fCompress;       }
+          Bool_t       GetSDigits() const                          { return fSDigits;        }
+
+          Int_t        Diffusion(Float_t vdrift, Double_t absdriftlength, Double_t exbvalue
+                               , Double_t &lRow, Double_t &lCol, Double_t &lTime);
+         void         RunDigitalProcessing(Int_t det = 0);
 
  protected:
 
-  //TFile               *fInputFile;          //! ALIROOT-file
   AliRunLoader        *fRunLoader;          //! Local pointer
   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
-  AliTRDparameter     *fPar;                //  TRD digitization parameter object
-  Int_t                fEvent;              //! Event number
-  Int_t               *fMasks;              //! Masks for the merging
-  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 
-  Bool_t               fMergeSignalOnly;    //  Merge only detectors that contain a signal
-  Bool_t               fSimpleSim;          //  Switch for the simplified simulation
-  Int_t                fSimpleDet;          //  Detecttor number used in the simplified simulation
- private:
-
-  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);
-
-  ClassDef(AliTRDdigitizer,7)               //  Produces TRD-Digits
 
-};
+  AliTRDmcmSim        *fMcmSim;             //! MCM simulation for digital processing
+
+          Int_t        fEvent;              //! Event number
+          Int_t       *fMasks;              //! Masks for the merging
+          Bool_t       fCompress;           //  Switch to keep only compressed data in memory
+          Bool_t       fSDigits;            //  Switch for the summable digits
+          Bool_t       fMergeSignalOnly;    //  Merge only detectors that contain a signal
 
+  ClassDef(AliTRDdigitizer,20)              //  Produces TRD-Digits
+
+};
 #endif