HTofinoDigitizer

class HTofinoDigitizer : public HReconstructor

    private:

      Int_t findFirstHitInTofino(HGeantTof* pOld, HGeantTof** pNew, Int_t* count)

    public:

                               HTofinoDigitizer()
                               HTofinoDigitizer(Text_t* name, Text_t* title)
                               ~HTofinoDigitizer()
                static TClass* Class()
                          void doFinalCheckOnArray()
                 virtual Int_t execute()
                          void fillArray()
                          void fillOutput()
                virtual Bool_t finalize()
      static HTofinoDigitizer* getTofinoDigtizer()
                virtual Bool_t init()
                        Bool_t initParContainer()
               virtual TClass* IsA() const
                          void setDebug(Bool_t flag)
                          void setStoreFirstTrack(Int_t flag)
                  virtual void ShowMembers(TMemberInspector& insp, char* parent)
                  virtual void Streamer(TBuffer& b)
                          void StreamerNVirtual(TBuffer& b)

Data Members

    private:

                     HLocation fLoc                    ! Location for new object
                     HLocation ffLoc                   ! Location for new object
                    HCategory* fGeantCat               ! Pointer to HGeant data category
                    HCategory* fCalCat                 ! Pointer to Cal data category
              HLinearCategory* fGeantKineCat           ! Pointer to GeantKine data category
                    HIterator* iterGeant               ! Iterator over HGeantTof category
                    HIterator* iterCal                 ! Iterator over HTofinoCalSim category
              HTofinoDigitPar* pTofinoDigitPar         ! Digit parameters
                    TObjArray* array                   ! temporary array for HTofinoCalSim objects
                         Int_t numTracks[6][4][10]     ! temporary array
                         Int_t ctTracks[6][4]          ! temporary array
                       Float_t geaTofTracks[6][4][10]  ! temporary array
                       Float_t tdcTofTracks[6][4][10]  ! temporary array
                         Int_t storeFirstTrack         ! flag:
                        Bool_t debug                   ! change stored tracknumbers (when storeFirstTrack!=0)
      static HTofinoDigitizer* pTofinoDigi             ! pointer to this

Class Description

  HTofinofDigitizer digitizes HGeant data, puts output values into
  cal data category
  The input data are read from the HGeantTof category. After calculating
  TOF and Charge of the hit etc the output is stored in the HTofinoCalSim
  category.

   ----------------------                                 -----------
  |   HTofinoCalibrater  |                               | HGeantTof |
  |   (embedding mode)   |                               -----------
  |                      |                                   ||
   ----------------------                                    || input to digitizer
                                                             
                           ---------------    read real     ------------------
                          | HTofinoCalSim | ------------>  | HTofinoDigitizer |
                           ---------------  <-----------   |                  |
                                            write output    ------------------


  In the case of TRACK EMBEDDING of simulated tracks into
  experimental data the real data are written by the HTofinoCalibrater into
  HTofinoCalSim category. The real hits are taken into
  account by the digitizer (adding of charges, sorting by first hit in
  photo multiplier). 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)

  The output object HTofinoCalSim contains additional to the tof and
  charge a list of up to 5 tracks hitting the tofino cell. The track numbers
  are stored by increasing tof. In parallel the tof from GEANT is stored in a
  list. In case of embedding the first and second track recieved via getTrack()
  contains real or geant data depending wheater or not there has been a
  embedded track and sim or real was first. In case of no embedded track in the cell
  the list contains only the geant hits.

  tofinocal->getNHit()      number of hits in the cell (val 1-5)
  tofinocal->getTrack(0)    contains real data / geant data (real if real was faster)
  tofinocal->getTrack(1)    contains real data / geant data (sim  if real was faster)
  tofinocal->getTrack(2)    contains geant data
      .
      .
      .
  tofinocal->getTrack(4)    contains geant data

 For the suppression of secondaries produced in the TOF itself there are
 several configuration possibilities:
 They can be switched via setStoreFirstTrack(Int_t flag):
     flag ==  0 realistic (secondaries included)
              1 primary particle is stored
              2 (default) the first track number entering the tof in SAME SECTOR is stored
              3 as 2 but SAME SECTOR && CELL

 To make the influence of the above selections easily visible
 in the output HTofCalSim a debug mode can be switched with
 void   setDebug(Bool_t flag). In this case the track numbers
 affected by the criteria 1-3 will have negative track numbers
 (multiples of -200). The multiplication factor gives the number
 of steps from the start point to the stored track (chain of
 secondaries). In case 1 it is always -200 if a particle has not
 been a primary one.

-------------------------------------------------
 fill temporary array from geant.
 all sim data will be collected and in the end
 will be a check on the total charge etc. in doFinalCheckOnArray()
 before it is written to the output category (and in
 embedding mode merged with the real data) in fillOutput()

-------------------------------------------------
 now do the final check on collected data and
 convert times from channel to nanosecond to write
 to output category (and merge with real data in fillOutput() )
 fill list of tracks/geaTof other than the fastest hit

 write to output category (and merge with real data)
 fill list of tracks/geaTof other than the fastest hit

-------------------------------------------------
 find the first track ID entering the TOFINO
 Used to suppress the secondaries created in the
 TOF itself.
        0 (default) = realistic (secondaries included)
        1 primary particle is stored
        2 the first track number entering the tof in SAME SECTOR is stored
        3 as 2 but SAME SECTOR && ROD

Inline Functions

        HTofinoDigitizer* getTofinoDigtizer()
                     void setStoreFirstTrack(Int_t flag)
                     void setDebug(Bool_t flag)
                  TClass* Class()
                  TClass* IsA() const
                     void ShowMembers(TMemberInspector& insp, char* parent)
                     void Streamer(TBuffer& b)
                     void StreamerNVirtual(TBuffer& b)