JHit.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JHIT__
#define __JTRIGGER__JHIT__

#include "JTrigger/JGetRiseTime.hh"


/**
 * \file
 *
 * Basic data structure for time and time over threshold information of hit.
 * \author mdejong
 */
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }

namespace JTRIGGER {


  /**
   * Hit data structure.
   */
  class JHit
  {
  public:
    /**
     * Default constructor.
     */
    JHit() :
      t(0.0),      
      tot(0.0)
    {}


    /**
     * Constructor.
     *
     * \param  t_ns           calibrated time of hit [ns]
     */
    JHit(const double t_ns) :
      t(t_ns),
      tot(0.0)
    {}

    /**
     * Constructor.
     *
     * \param  t_ns           calibrated time of hit [ns]
     * \param  tot_ns         time over threshold of hit [ns]
     */
    JHit(const double t_ns, const double tot_ns) :
      t(t_ns),
      tot(tot_ns)
    {}


    /**
     * Get combined hit.
     *
     * Note that:
     *   - leading  edge of this hit is set to the earliest leading  edge of the all hits;
     *   - trailing edge of this hit is set to the latest   trailing edge of the all hits;
     *
     * It is assumed that the template class has the following methods:
     * <pre>
     *      %getT();
     *      %getToT();
     * </pre>
     * which should return the time and time over threshold, respectively.
     *
     * \param  __begin        begin of hits
     * \param  __end          end   of hits
     */
    template<class T>
    JHit(T __begin, T __end) :
      t(0.0),      
      tot(0.0)
    {
      if (__begin != __end) {

        double t1 = __begin->getT1();
        double t2 = __begin->getT2();
        
        for (T i = __begin; ++i != __end; ) {
          if (t1 > i->getT1()) { t1 = i->getT1(); }
          if (t2 < i->getT2()) { t2 = i->getT2(); }
        }
        
        this->t    =  t1;
        this->tot  =  t2 - t1;
      }
    }


    /**
     * Get hit.
     *     
     * \return                hit
     */
    const JHit& getHit() const
    {
      return static_cast<const JHit&>(*this);
    }


    /**
     * Get slewing option.
     *
     * \return                slewing option
     */
    static bool getSlewing() 
    {
      return get_slewing();
    }


    /**
     * Set slewing option.
     *
     * \param  slewing        slewing option
     */
    static void setSlewing(const bool slewing) 
    {
      get_slewing() = slewing;
    }


    /**
     * Type conversion.
     *
     * \return                time [ns]
     */
    inline operator double() const
    { 
      return t;
    }


    /**
     * Get calibrated time of hit.
     *
     * \return                time [ns]
     */
    inline double getT() const
    { 
      if (!getSlewing())
        return t;
      else
        return t - getRiseTime(tot);
    }


    /**
     * Get calibrated time over threshold of hit.
     *
     * \return                time over threshold [ns]
     */
    inline double getToT() const
    { 
      return tot;
    }


    /**
     * Get leading edge of hit.
     *
     * Note that no slewing correction is applied.
     *
     * \return                time [ns]
     */
    inline double getT1() const
    { 
      return t;
    }


    /**
     * Get trailing edge of hit.
     *
     * Note that no slewing correction is applied.
     *
     * \return                time [ns]
     */
    inline double getT2() const
    { 
      return t + tot;
    }


    /**
     * Join hit.
     *
     * Note that:
     *   - leading edge of this hit is maintained;
     *   - time over threshold of this hit is set to the difference between the trailing edge of given hit and leading edge of this hit;
     *
     * \param  hit            hit
     */
    void join(const JHit& hit)
    {
      this->tot = hit.getT2() - this->getT1(); 
    }

  protected:
    double  t;       //!< time of leading edge [ns]
    double  tot;     //!< time-ver-threshold   [ns]


    /**
     * Get reference to slewing parameter.
     *
     * \return                reference to slewing parameter
     */
    static bool& get_slewing() 
    {
      static bool slewing = true;

      return slewing;
    }
  };


  /**
   * Less than operator for hits.
   *
   * The less than operator is applied to the time of the hits.
   *
   * \param  first       first  hit
   * \param  second      second hit
   * \result             true if first hit earlier; else false
   */
  inline bool operator<(const JHit& first, const JHit& second)
  {
    return first.getT() < second.getT();
  }


  /**
   * Less than operator for hits.
   *
   * The less than operator is applied to the time of the hits.
   *
   * \param  hit         hit
   * \param  t1          time [ns]
   * \result             true if hit earlier than t; else false
   */
  inline bool operator<(const JHit& hit, const double t1)
  {
    return hit.getT() < t1;
  }


  /**
   * Equal operator for hits.
   *
   * The equal operator is applied to the time of the hits.
   *
   * \param  first       hit
   * \param  second      hit
   * \result             true if first hit time equal to second hit time; else false
   */
  inline bool operator==(const JHit& first, const JHit& second)
  {
    return first.getT() == second.getT();
  }


  /**
   * Auxiliary class to check whether two consecutive hits should be joined.
   *
   * The maximal time difference between trailing and leading edge of two consecutive hits
   * can be interpreted as the effective two-hit resolution of a PMT/TDC.
   *
   * Note that the hits should be time ordered.
   */
  struct JMatch_t {
    /**
     * Constructor.
     *
     * \param  Tmax_ns       maximal time difference between trailing and leading edge [ns]
     */
    JMatch_t(const double Tmax_ns) :
      Tmax_ns(Tmax_ns)
    {}
      
      
    /**
     * Match function.
     * 
     * \param  first         first  hit
     * \param  second        second hit
     * \return               true if time difference between trailing edge and leading edge less than specified time; else false
     */
    bool operator()(const JHit& first, const JHit& second) const
    {
      return (second.getT1() > first.getT1() &&
              second.getT1() < first.getT2() + Tmax_ns);
    }
      
    double Tmax_ns;
  };
}

#endif