HRichDigitizer

class HRichDigitizer : public HReconstructor

    private:

           void addNoiseToCharge(HRichCalSim* calSim)
        Float_t calcChargeOnWire(Int_t sector, Float_t xhit, Float_t yhit, Float_t nTrack, Float_t nFlag, Float_t ene)
         Bool_t calcFeedBack(Int_t sec, Float_t xhit, Float_t yhit, Float_t& ene, Float_t& xhittFB, Float_t& yhittFB, Float_t charge)
        Float_t calcIndCharge(float yCharge, float q4, int iPdaIndex, int iWireNr)
        Float_t calcNoiseOnPad(Float_t sigma, Float_t floatMean)
         Bool_t calcQE(const Float_t photlen, Int_t sec)
           void digitiseCherenkovHits(HGeantRichPhoton* pCerHit, Int_t count)
           void digitiseDirectHits(HGeantRichDirect* pDirHit)
           void digitisePads()
        Float_t feedBackProb(Float_t x)
        Float_t GaussFun(Float_t mean, Float_t sigma)
          Int_t getWireNr(Float_t xhit)
           void makeNoiseOnPads()
           void processPhoton(Float_t ene, Float_t xPos, Float_t yPos, Int_t track, Int_t sector)
        Float_t q4Calc(float charge, float pos, float par1, float par2)
        Float_t qX(float pos)
      HRichPad* translateCorners(HRichPad* pPad, Float_t dx, Float_t dy)
           void updateCharge(Int_t sector, HRichPad* pPad, Float_t charge, TVector* rTrack, Float_t ene)
           void updateTrack(HRichCalSim* pCalSim, HLocation& loc, TVector* rTrack)

    public:

                      HRichDigitizer()
                      HRichDigitizer(Text_t* name, Text_t* title, Bool_t kNoise = kFALSE, Bool_t oem = kFALSE)
                      HRichDigitizer(const HRichDigitizer& source)
                      ~HRichDigitizer()
                Int_t checkPad(HRichCalSim* calSim)
       static TClass* Class()
        virtual Int_t execute()
       virtual Bool_t finalize()
           HCategory* getCerInputCat()
             HParSet* getDigitisationPar()
           HCategory* getDirInputCat()
             HParSet* getGeometryPar()
           HCategory* getOutputCat()
             HParSet* getRichCalPar()
           HCategory* getTrackOutputCat()
       virtual Bool_t init()
      virtual TClass* IsA() const
      HRichDigitizer& operator=(HRichDigitizer& source)
       virtual Bool_t reinit()
                 void setCalPar(HParSet* pPar)
                 void setCerInputCat(HCategory* pInCat)
                 void setDigitisationPar(HParSet* pPar)
                 void setDirInputCat(HCategory* pInCat)
                 void setGeometryPar(HParSet* pPar)
                 void setOutputCat(HCategory* pOutCat)
                 void setTrackOutputCat(HCategory* pOutCat)
         virtual void ShowMembers(TMemberInspector& insp, char* parent)
         virtual void Streamer(TBuffer& b)
                 void StreamerNVirtual(TBuffer& b)

Data Members

    private:

      HCategory* fCerInputCat        Pointer to the raw data category
      HCategory* fDirInputCat        Pointer to the raw data category
      HCategory* fOutputCat          Pointer to the cal data category
      HCategory* fTrackOutputCat     Pointer to the richtrack category        
        HParSet* fDigitisationPar    Pointer to digitisation parameters
        HParSet* fGeometryPar        Pointer to geometry parameters
        HParSet* fCalPar             Pointer to calibration parameters
      HIterator* fCerIter            !
      HIterator* fDirIter            !
      HIterator* fTrackIter          !           
      HIterator* fCalIter            !
         Float_t fQupper             !
         Float_t fChargePerChannel   !
         Float_t fChargeScaling      !
         Float_t fDigitPadMatrix[9]  !
         Float_t noiseCharge[1000]   !
           TList fChargeOnWireList   !//holds charge on a wire
           TList fTrackNumberList    !// holds track number and flag for a hit
       HLocation loc                 
           Int_t isActiveNoise       flag to switch on/off the electronic noise
           Int_t isOEM               flag to select oem analysis.
           Int_t countNoisePad       number of pads with a noise cont. above threshold.
         Float_t fYShift             shift on the y pad plane coordinate necessary to get the correct pad position and the correct theta.
         Float_t distWirePads        distance between wires and pad plane. in cm
         Float_t fIncreaseNoise      
         Float_t fSigmaValue         
         Float_t fMeanPad            mean value of the noise distribution 
         Float_t fSigmaPad           sigma of the noise distribution 
         Float_t fFloatMean          float part of the mean value
         Float_t fCharge             
         Float_t fFactor1            
         Float_t fFactor2            
         Float_t fFactor1Sig         
         Float_t fFactor2Sig         
         Float_t fParam1             
         Float_t fParam2             
         Float_t param21             
         Float_t param11             
         Float_t fInt                
         Float_t a1                  
         Float_t a2                  
         Float_t b1                  
         Float_t b2                  
          TFile* output              
           TH1F* position            
            TF1* ga                  ! Gauss function
           Int_t cont                
           Int_t countFBphot         
           Int_t countPhotSec[6]     to be removed!

    public:

      Int_t lNrEvent  

Class Description

_______________________________________________________
  HRichDigitizer

 For each digitized pad the corresponding track numbers of the
 direct hits and photons are stored in a linear category
 (catRichTrack<-HRichTrack) that is made sortable by the pad address.
 Each pad object of the HRichCalSim class has 2 members, nTrack1, nTrack2,
 that give the indexes of the first and the last track numbers in the linear
 category (catRichTrack) corresponding to a pad.
 This method allows to store as many particle track numbers as the pad
 " sees ".
  here are listed the values of some useful variables
  # means non costant value.
  Each value refers to the 1 fired pad.

  realID=gHades->getEmbeddingRealTrackId()

                        track Number      Flag     energy
  Cheren. Phot.            #               0        #
  Feedback Phot.          -5               0        0
  Direct Hits              #               1        0
  Noise Hits               0               0        0
  REAL Hits (embedding)    realID          0        0
---------------------------------------------------------


  -----------------------                                -------------
  |  HRichUnpackerCal99  |                               | HGeantRich |
  |   (embedding mode)   |                              -------------
  |                      |                                   ||
  -----------------------                                    || input to digitizer
                                                             
                          -------------    read real    ------------------
                         | HRichCalSim | ------------>  |                 |
                          -------------  <-----------   |                 |
                                                        | HRichDigitizer  |
                          -------------                 |                 |
                         | HRichTrack  | <-----------   |                 |
                          -------------                 ------------------
                                         write output

  In the case of TRACK EMBEDDING of simulated tracks into
  experimental data the real data are written by the HRichUnpackerCal99 into
  HRichCalSim category. The real hits are taken into
  account by the digitizer (adding of charges, adding track numbers to HRichTrack).
  The embedding mode is recognized automatically by analyzing the
  gHades->getEmbeddingMode() flag.
            Mode ==0 means no embedding
                 ==1 realistic embedding (first real or sim hit makes the game)
                 ==2 keep GEANT tracks   (as 1, but GEANT track numbers will always
                     win against real data. besides the tracknumber the output will
                     be the same as in 1)

 dummy

 this function calculates the charge on each wire and saves it in a TList
 moreover, it saves the track number and the corresponding flag
 (cf HRichTrack) in a second TList.
 The charge is calculated according to one exponential function
 obtained fitting the total charge distribution of the photon candidates
 belonging to class one.
( OEM data).
 That means that the so calculated charge isn't in reality the
 original charge deposited on the wire but the total amount of the charge
 coupled to the pads. Therefore it isn't any longer necessary to
 use an additional coupling factor. ( 75%)

 for every photon hit on a pad the resulting charge on a wire
 is calculated and the track number of the photon parent is stored.
 (cf. calcChargeOnWire).

We assume that the feed back photon is produced on the anodic wire, the number of the feed back photon is proportional to the value A0.

 for every direct hit (charge particle hitting the RICH or ionizing
 the gas near the surface of the photon detector)  the
 resulting charge on the wires is calculated and the track number
 of the charged particle hitting the pad is stored.
 (cf. calcChargeOnWire)

 for each wire on which some charge has been deposited
 the corresponding coupled pads are calculated.
 The function updateCharge creates a HRichCalSim obj if
 the charge on the pad is greater than zero.
 A cut off threshold is applied to each pad in the execute func.
 after the digitilasation of all the hits.
 If the pad is hit twice in the same event, the charges
 corresponding to the 2 different hits are added.
 The particle track number is passed to the function
 updateCharge, too.

 this function creates an HRichCalSim obj that corresponds
 to a fired pad, it calls the function updateTrack,
 that stores the corresponding track numbers.

 this function stores the track numbers of parent
 particles of photons and of direct hits in a linear
 category (HRichTrack). This category is set sortable.

Inline Functions

        HRichDigitizer& operator=(HRichDigitizer& source)
             HCategory* getCerInputCat()
             HCategory* getDirInputCat()
             HCategory* getOutputCat()
             HCategory* getTrackOutputCat()
               HParSet* getRichCalPar()
               HParSet* getDigitisationPar()
               HParSet* getGeometryPar()
                   void setCerInputCat(HCategory* pInCat)
                   void setDirInputCat(HCategory* pInCat)
                   void setOutputCat(HCategory* pOutCat)
                   void setTrackOutputCat(HCategory* pOutCat)
                   void setDigitisationPar(HParSet* pPar)
                   void setGeometryPar(HParSet* pPar)
                   void setCalPar(HParSet* pPar)
                TClass* Class()
                TClass* IsA() const
                   void ShowMembers(TMemberInspector& insp, char* parent)
                   void Streamer(TBuffer& b)
                   void StreamerNVirtual(TBuffer& b)