JDetector/JCalibration.hh

Go to the documentation of this file.

#ifndef __JDETECTOR__JCALIBRATION__
#define __JDETECTOR__JCALIBRATION__
 
#include <istream>
#include <ostream>
 
#include "JIO/JSerialisable.hh"
#include "JLang/JClass.hh"
 
 
/**
 * \file
 *
 * PMT calibration (including definition of sign of time offset).
 * \author mdejong
 */
namespace JDETECTOR {}
namespace JPP { using namespace JDETECTOR; }
 
namespace JDETECTOR {
 
  using JIO::JReader;
  using JIO::JWriter;
 
 
  /**
   * Specification for time-over-threshold corresponding to a one photo-electron pulse.
   */
  const double TIME_OVER_THRESHOLD_NS = 26.4;   // [ns]
 
 
  /**
   * Data structure for PMT calibration.
   */
  class JCalibration
  {
  public:
    /**
     * Default constructor.
     */
    JCalibration() :
      t0(0.0)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  __t0       time offset [ns]
     */
    JCalibration(const double __t0) :
      t0(__t0)
    {}
 
 
    /**
     * Get calibration.
     *
     * \return            calibration
     */
    const JCalibration& getCalibration() const
    {
      return *this;
    }
 
 
    /**
     * Set calibration.
     *
     * \param  cal        calibration
     */
    void setCalibration(const JCalibration& cal)
    {
      *this = cal;
    }
 
 
    /**
     * Get time offset.
     *
     * \return            time offset [ns]
     */
    double getT0() const 
    {
      return t0;
    }
 
 
    /**
     * Set time offset.
     *
     * \param  t0            time offset [ns]
     */
    void setT0(const double t0)
    {
      this->t0 = t0;
    }
 
 
    /**
     * Add time offset.
     *
     * \param  t0            time offset [ns]
     */
    void addT0(const double t0)
    {
      this->t0 += t0;
    }
 
 
    /**
     * Subtract time offset.
     *
     * \param  t0            time offset [ns]
     */
    void subT0(const double t0)
    {
      this->t0 -= t0;
    }
 
 
    /**
     * Read JCalibration from input.
     *
     * \param  in         input stream
     * \param  cal        JCalibration
     * \return            input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JCalibration& cal)
    {
      in >> cal.t0;
 
      return in;
    }
 
 
    /**
     * Write JCalibration to output.
     *
     * \param  out        output stream
     * \param  cal        JCalibration
     * \return            output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JCalibration& cal)
    {
      out << cal.t0;
 
      return out;
    }
 
 
    /**
     * Read JCalibration from input.
     *
     * \param  in       JReader
     * \param  cal      JCalibration
     * \return          JReader
     */
    friend inline JReader& operator>>(JReader& in, JCalibration& cal)
    {
      in >> cal.t0;
 
      return in;
    }
 
 
    /**
     * Write JCalibration to output.
     *
     * \param  out      JWriter
     * \param  cal      JCalibration
     * \return          JWriter
     */
    friend inline JWriter& operator<<(JWriter& out, const JCalibration& cal)
    {
      out << cal.t0;
 
      return out;
    }
 
 
  protected:
    double t0;
  };
 
 
  /**
   * Auxiliary class to apply (de-)calibration to template hit.
   */
  template<class T, bool is_primitive = JLANG::JClass<T>::is_primitive>
  struct JCalibrator;
 
 
  /**
   * Get calibrated time.
   *
   * \param  t1         time [ns]
   * \param  cal        calibration
   * \return            time [ns]
   */
  template<class T>
  inline double getTime(const T& t1, const JCalibration& cal)
  {
    return JCalibrator<T>::getTime(t1, cal);
  }
    
 
  /**
   * Get de-calibrated time.
   *
   * \param  t1         time [ns]
   * \param  cal        calibration
   * \return            time [ns]
   */
  template<class T>
  inline double putTime(const T& t1, const JCalibration& cal)
  {
    return JCalibrator<T>::putTime(t1, cal);
  }
    
 
  /**
   * Get calibrated time-over-threshold of hit.
   *
   * \param  tot        time-over-threshold [ns]
   * \param  cal        calibration
   * \return            time-over-threshold [ns]
   */
  template<class T>
  inline double getToT(const T& tot, const JCalibration& cal)
  {
    return JCalibrator<T>::getToT(tot, cal);
  }
  
    
  /**
   * Get de-calibrated time-over-threshold of hit.
   *
   * \param  tot        time-over-threshold [ns]
   * \param  cal        calibration
   * \return            time-over-threshold [ns]
   */
  template<class T>
  inline double putToT(const T& tot, const JCalibration& cal)
  {
    return JCalibrator<T>::putToT(tot, cal);
  }
 
 
  /**
   * Template specialisation of JCalibrator for primitive data types.
   */
  template<class T>
  struct JCalibrator<T, true>
  {
    /**
     * Get calibrated time.
     *
     * \param  t1         time [ns]
     * \param  cal        calibration
     * \return            time [ns]
     */
    static inline double getTime(const T t1, const JCalibration& cal)
    {
      return t1 + cal.getT0();
    }
    
 
    /**
     * Get de-calibrated time.
     *
     * \param  t1         time [ns]
     * \param  cal        calibration
     * \return            time [ns]
     */
    static inline double putTime(const T t1, const JCalibration& cal)
    {
      return t1 - cal.getT0();
    }
    
 
    /**
     * Get calibrated time-over-threshold of hit.
     *
     * \param  tot        time-over-threshold [ns]
     * \param  cal        calibration
     * \return            time-over-threshold [ns]
     */
    static inline double getToT(const T tot, const JCalibration& cal)
    {
      return tot;
    }
 
    
    /**
     * Get de-calibrated time-over-threshold of hit.
     *
     * \param  tot        time-over-threshold [ns]
     * \param  cal        calibration
     * \return            time-over-threshold [ns]
     */
    static inline double putToT(const T tot, const JCalibration& cal)
    {
      return tot;
    }
  };
  
 
  /**
   * Template specialisation of JCalibrator for non-primitive data types.
   * It is assumed that the template class has the following methods:
   * <pre>
   *      %getT();
   *      %getToT();
   * </pre>
   * which should return the time (ns) and time-over-threshold (ns), respectively.
   */
  template<class JHit_t>
  struct JCalibrator<JHit_t, false> {
    /**
     * Get calibrated time of hit.
     *
     * \param  hit            hit
     * \param  cal            calibration
     * \return                time [ns]
     */
    static inline double getTime(const JHit_t& hit, const JCalibration& cal)
    {
      return JDETECTOR::getTime(hit.getT(), cal);
    }
    
 
    /**
     * Get de-calibrated time of hit.
     *
     * \param  hit        hit
     * \param  cal        calibration
     * \return            time [ns]
     */
    static inline double putTime(const JHit_t& hit, const JCalibration& cal)
    {
      return JDETECTOR::putTime(hit.getT(), cal);
    }
    
    
    /**
     * Get calibrated time-over-threshold of hit.
     *
     * \param  hit        hit
     * \param  cal        calibration
     * \return            time-over-threshold [ns]
     */
    static inline double getToT(const JHit_t& hit, const JCalibration& cal)
    {
      return JDETECTOR::getToT(hit.getToT(), cal);
    }
    
 
    /**
     * Get de-calibrated time-over-threshold of hit.
     *
     * \param  hit        hit
     * \param  cal        calibration
     * \return            time-over-threshold [ns]
     */
    inline double putToT(const JHit_t& hit, const JCalibration& cal)
    {
      return JDETECTOR::putToT(hit.getToT(), cal);
    }
  };
}
 
#endif