ITS/UPGRADE/AliITSUSimulation.h

   1 #ifndef ALIITSUSIMULATION_H
   2 #define ALIITSUSIMULATION_H
   3 /**************************************************************************
   4  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
   5  *                                                                        *
   6  * Author: The ALICE Off-line Project.                                    *
   7  * Contributors are mentioned in the code where appropriate.              *
   8  *                                                                        *
   9  * Permission to use, copy, modify and distribute this software and its   *
  10  * documentation strictly for non-commercial purposes is hereby granted   *
  11  * without fee, provided that the above copyright notice appears in all   *
  12  * copies and that both the copyright notice and this permission notice   *
  13  * appear in the supporting documentation. The authors make no claims     *
  14  * about the suitability of this software for any purpose. It is          *
  15  * provided "as is" without express or implied warranty.                  *
  16  **************************************************************************/
  17
  18 #include <TObject.h>
  19 #include "AliITSUSensMap.h"
  20 #include "AliITSsegmentation.h"
  21 #include "AliMathBase.h"
  22 #include <TArrayS.h>
  23
  24 class AliITSCalibration;
  25 class AliITSUSimuParam;
  26 class AliITSUChip;
  27 class TRandom;
  28 class TSegCollection;
  29 class AliITSUParamList;
  30
  31 // This is the base class for ITS detector signal simulations. Data members
  32 // include are a pointer to the detectors specific response and segmentation
  33 // classes. See the detector specific implementations for the propper code.
  34 // The detector-specific implementations are responsible for processing detector type,
  35 // which still may have different segmentations!
  36 // Note: the detector specific objects (segmentation, calib, etc.) are not owned
  37 // by the object but set externaly
  38
  39 class AliITSUSimulation : public TObject
  40 {
  41  public:
  42   enum {kMaxROCycleAccept=126};             // flag for read-out cycle to discard
  43   //
  44   AliITSUSimulation();
  45   AliITSUSimulation(AliITSUSimuParam* sim, AliITSUSensMap* map);
  46   virtual ~AliITSUSimulation() {}
  47   AliITSUSimulation(const AliITSUSimulation &source);
  48   AliITSUSimulation& operator=(const AliITSUSimulation &source);
  49   virtual void Init() = 0;
  50   //
  51   void UpdateMapSignal(UInt_t col,UInt_t row, Int_t trk,Int_t ht,Double_t signal, Int_t roCycle=0);
  52   void UpdateMapNoise(UInt_t col,UInt_t row, Double_t noise, Int_t roCycle=0);
  53   virtual void InitSimulationChip(AliITSUChip* mod, Int_t ev, AliITSsegmentation* seg, AliITSUParamList* resp);
  54   //
  55   // Hits -> SDigits
  56   virtual void SDigitiseChip() = 0;
  57   virtual void FinishSDigitiseChip() = 0;
  58   virtual Bool_t AddSDigitsToChip( TSeqCollection *pItemArray, Int_t mask );
  59   //
  60   // Hits -> Digits
  61   virtual void DigitiseChip() = 0;
  62   virtual void CreateFastRecPoints(AliITSUChip *,Int_t,TRandom *,TClonesArray* /*recp*/) {}
  63   //
  64   // readout phase (strobe, timing etc) generation
  65   virtual Double_t GenerateReadOutCycleOffset();
  66   //
  67   AliITSCalibration*  GetCalibDead()                   const {return fCalibDead;}
  68   AliITSCalibration*  GetCalibNoisy()                  const {return fCalibNoisy;}
  69   AliITSsegmentation* GetSegmentation()                const {return fSeg;}
  70   AliITSUSimuParam*   GetSimuParam()                   const {return fSimuParam;}
  71   AliITSUSensMap*     GetMap()                         const {return fSensMap;}
  72   AliITSUChip*      GetChip()                      const {return fChip;}
  73   AliITSUParamList*   GetResponseParam()               const {return fResponseParam;}
  74   Int_t               GetEvent()                       const {return fEvent;}
  75   Bool_t              GetDebug(Int_t level=1)          const {return fDebug>=level;}
  76
  77   //
  78   void SetCalibDead(AliITSCalibration *calib)              {fCalibDead = calib;}
  79   void SetCalibNoisy(AliITSCalibration *calib)             {fCalibNoisy = calib;}
  80   void SetSegmentation(AliITSsegmentation *seg)            {fSeg = seg; if (seg&&fSensMap) fSensMap->SetDimensions(seg->Npz(),seg->Npx(),kMaxROCycleAccept);}
  81   void SetSimuParam(AliITSUSimuParam *sp)                  {fSimuParam = sp;}
  82   virtual void SetResponseParam(AliITSUParamList* resp)    {fResponseParam = resp;}
  83   void SetMap(AliITSUSensMap *p)                           {fSensMap = p;}
  84   void SetChip(AliITSUChip* mod)                       {fChip=mod;}
  85   void SetEvent(Int_t evnt)                                {fEvent=evnt;}
  86   void SetDebug(Int_t level=5)                             {fDebug=level;}
  87   void SetNoDebug()                                        {fDebug=0;}
  88   void ClearMap()                                          {fSensMap->Clear();}
  89   //
  90   Double_t GetReadOutCycleOffset()              const      {return fReadOutCycleOffset;}
  91   void     SetReadOutCycleOffset(Double_t v=0)             {fReadOutCycleOffset = v;}
  92   //
  93   Double_t GetReadOutCycleLength()              const      {return fReadOutCycleLength;}
  94   void     SetReadOutCycleLength(Double_t v=25e-6)         {fReadOutCycleLength = v;}
  95   //
  96   static  Int_t GenOrderedSample(UInt_t nmax,UInt_t ngen,TArrayI &vals,TArrayI &ind);
  97   //
  98   static  Double_t GausInt1D(Double_t sig,Double_t a,Double_t b);
  99   static  Double_t GausInt2D(Double_t sig0,Double_t a0,Double_t b0,
 100                              Double_t sig1,Double_t a1,Double_t b1);
 101   //
 102  protected:
 103   AliITSsegmentation  *fSeg;            //! segmentation
 104   AliITSCalibration   *fCalibDead;      //! dead channels
 105   AliITSCalibration   *fCalibNoisy;     //! noisy channels
 106   AliITSUSensMap      *fSensMap;        //! sensor map for hits manipulations
 107   AliITSUSimuParam    *fSimuParam;      //! simulation parameters
 108   AliITSUParamList    *fResponseParam;  //! response parameterization data
 109   AliITSUChip       *fChip;         //! chip being processed
 110   Float_t              fReadOutCycleOffset; //! The phase of the RO with respect to the trigger
 111   Float_t              fReadOutCycleLength; //! readout cycle lenght in s
 112
 113   Int_t                fEvent;          //! event number being processed
 114   Int_t                fDebug;          //!  debug flag
 115   Bool_t               fCyclesID[2*kMaxROCycleAccept+1]; //! status of RO cycles
 116
 117   ClassDef(AliITSUSimulation,2)       // Simulation base class
 118
 119 };
 120
 121 //_____________________________________________________________________________
 122 inline Double_t AliITSUSimulation::GausInt1D(Double_t sig,Double_t a,Double_t b)
 123 {
 124   // calculate gaussian integral from a to b (with respecto to mean)
 125   const Double_t kRoot2 = 1.414213562; // Sqrt(2).
 126   double sp = 1.0/(sig*kRoot2);
 127   return 0.5*TMath::Abs( AliMathBase::ErfcFast(sp*a) - AliMathBase::ErfcFast(sp*b) );
 128 }
 129
 130 //_____________________________________________________________________________
 131 inline Double_t AliITSUSimulation::GausInt2D(Double_t sig0,Double_t a0,Double_t b0,
 132                                              Double_t sig1,Double_t a1,Double_t b1)
 133 {
 134   // calculate gaussian 2D integral from x0 to x1 (with respect to mean)
 135   const Double_t kRoot2 = 1.414213562; // Sqrt(2).
 136   double sp0 = 1.0/(sig0*kRoot2);
 137   double sp1 = 1.0/(sig1*kRoot2);
 138   return 0.25*TMath::Abs( (AliMathBase::ErfcFast(sp0*a0) - AliMathBase::ErfcFast(sp0*b0)) *
 139                           (AliMathBase::ErfcFast(sp1*a1) - AliMathBase::ErfcFast(sp1*b1)));
 140 }
 141
 142 #endif