HShowerPadDigitizer

class HShowerPadDigitizer : public HShowerDigitizer

    private:

               void analyticCalc(HShowerPad* pPad, HShowerGeantWire* pWireHit)
            Float_t calcCharge(Float_t charge, Float_t dist, Float_t Xd, Float_t Yd, Float_t Xu, Float_t Yu)
              Int_t calcLimit(Float_t fCor, Int_t nMatrixRange, Float_t fBoxSize)
               void digiPads(HShowerGeantWire* pWireHit)
               void moveCoord(HShowerPad* pPad, Float_t distWire, Float_t fDx, Float_t fDy, Float_t* corXld, Float_t* corYld, Float_t* corXlu, Float_t* corYlu, Float_t* corXrd, Float_t* corYrd, Float_t* corXru, Float_t* corYru)
                int numericalCalc(HShowerPad* pPad, HShowerGeantWire* pWireHit, Float_t* pfValues)
      virtual Int_t sort()
               void updatePad(HShowerPad* pPad, Float_t fIndQ, Int_t nSect, Int_t nMod, Int_t nTrack)
               void updateTrack(HShowerRaw* pShowerRaw, HLocation& loc, Int_t nTrack)

    public:

                           HShowerPadDigitizer()
                           HShowerPadDigitizer(Text_t* name, Text_t* title)
                           ~HShowerPadDigitizer()
                    Bool_t checkEfficiency(HShowerRawMatr* pRaw)
            static TClass* Class()
            virtual Bool_t digitize(TObject* pHit)
             virtual Int_t execute()
            virtual Bool_t finalize()
                  Double_t gainCharge(HShowerRawMatr* pRaw)
                HCategory* getTrackCat()
            virtual Bool_t init()
           virtual TClass* IsA() const
      HShowerPadDigitizer& operator=(HShowerPadDigitizer& c)
                      void setTrackCat(HCategory* pTrackCat)
              virtual void ShowMembers(TMemberInspector& insp, char* parent)
              virtual void Streamer(TBuffer& b)
                      void StreamerNVirtual(TBuffer& b)

Data Members

    private:

               Float_t fChannelCoeff       
            HCategory* m_pTrackCat         !Pointer to the raw data category
            HIterator* fTrackIter          !
            HIterator* fShowerCalIter      !
            HIterator* fShowerRawMatrIter  !
      HShowerSimulPar* m_pSimulPar         

Class Description

  HShowerPadDigitizer

 This class digitizes the shower pads. For each fired wire it calculates all
 the pads which the charge couples to. For each pad the track numbers of the
 particles that fired the pad are stored in a linear category (HShowerTrack).
 This category is sortable, in particular the track numbers are sorted by
 the respective pad address.
 All the fired pads are stored in a matrix category (catShowerRawMatr,
 this matrix category is used only for the simulated data).

  The Shower digitization is split into several tasks as shown
  in the flow diagram below.

   ----------------------                                                                               
  |     HShowerUnpacker  |                                                                              
  |   (embedding mode)   |                                                                             
  |                      |        ------------------                                                   
   ----------------------   |     |  HGeantShower    |                                                  
                            |      ------------------                                                  
                            |                                                                          
                            |      ------------------  ------------->  ----------------------          
                            |     |  HGeantWire      |   <------------ |  HShowerHitDigitizer |         
                            |      ------------------                  ----------------------          
                            |                                                                          
                 -------------     ------------------  ------------->  -----------------------         
             -- | HShowerRaw  |   |  HShowerRawMatr  |   <------------ |  HShowerPadDigitizer  |        
            |    -------------     ------------------                 |( creates track objects|        
            |                                                         |  for real tracks in   |        
   ----------------------          ------------------                 |  embedding mode too)  |        
  |   HShowerCalibrater  |        |  HShowerTrack    |  <------------  -----------------------         
  |   (embedding mode)   |         ------------------                                                 
   ----------------------                                             -----------------------         
            |                      ------------------     ----------> |   HShowerCopy         |        
             -------------------> |  HShowerCal      |  <------------ |(add charge of real hit|        
                                   ------------------                | in embedding too )    |        
                                                                      -----------------------         
                                   ------------------  ------------->  -----------------------         
                                  |  HShowerHitHdr   |   <----------- |  HShowerHitFinder     |        
                                   ------------------                  -----------------------         
                                   ------------------                 |                                
                                  |  HShowerPID      |   <------------|                                
                                   ------------------                 |                                
                                   ------------------                 |                                
                                  |  HShowerHit      |   <------------|                                
                                   ------------------                                                 
                                                                                                      
                                   ------------------   -------------> ------------------------        
                                  |  HShowerHitTrack |   <------------ | HShowerHitTrackMatcher |       
                                   ------------------                   ------------------------        




  In the case of TRACK EMBEDDING of simulated tracks into
  experimental data the real data are written by the HShowerUnpacker into
  HShowerRaw category. The real hits are taken into
  account by the digitizer (adding of charges). 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)

 creates ShowerGeantWire(input), ShowerRawMatr(output) and ShowerTrack
 categories and adds them to current event
 creates an iterator for ShowerTrack category

    if (((HLinearCategory*)getTrackCat())->IsSortable())

 this function eliminates double track for the same  address
 it means that with one hit should be connected no more than one pad address and one track

charge density matrix is calculated

 gain charge in simulation

 check efficiency
 model good for post converters

charge density matrix is delimited to the sensitive area which covers fired pads

 moves charge density matrix to the place where is placed induced charge on the sense wire

 this function calculates charge induced on pad analytically
 it is useful only for square or rectangular pads

Inline Functions

        HShowerPadDigitizer& operator=(HShowerPadDigitizer& c)
                  HCategory* getTrackCat()
                        void setTrackCat(HCategory* pTrackCat)
                      Bool_t finalize()
                     TClass* Class()
                     TClass* IsA() const
                        void ShowMembers(TMemberInspector& insp, char* parent)
                        void Streamer(TBuffer& b)
                        void StreamerNVirtual(TBuffer& b)