JDAQChronometer.hh

Go to the documentation of this file.

#ifndef __JDAQCHRONOMETER__
#define __JDAQCHRONOMETER__

#include <ostream>
#include <iomanip>

#include "JIO/JSerialisable.hh"
#include "JDAQ/JDAQRoot.hh"
#include "JDAQ/JDAQUTCExtended.hh"
#include "JDAQ/JDAQClock.hh"


/**
 * \author mdejong
 */

namespace KM3NETDAQ {

  using JIO::JReader;
  using JIO::JWriter;


  /**
   * DAQ chronometer.
   */
  class JDAQChronometer
  {
  public:
    /**
     * Default constructor.
     */
    JDAQChronometer() :
      detector_id(0),
      run        (0),
      frame_index(0),
      timeslice_start()
    {}


    /**
     * Constructor.
     *
     * \param  __detector_id        detector identifier
     * \param  __run                run number
     * \param  __frame_index        frame index
     */
    JDAQChronometer(const int __detector_id,
                    const int __run,
                    const int __frame_index) :
      detector_id(__detector_id),
      run        (__run),
      frame_index(__frame_index),
      timeslice_start(getTimeOfFrame(__frame_index))
    {}


    /**
     * Constructor.
     *
     * \param  __detector_id        detector identifier
     * \param  __run                run number
     * \param  __frame_index        frame index
     * \param  __timeslice_start    start of time slice
     */
    JDAQChronometer(const int __detector_id,
                    const int __run,
                    const int __frame_index,
                    const JDAQUTCExtended& __timeslice_start) :
      detector_id(__detector_id),
      run        (__run),
      frame_index(__frame_index),
      timeslice_start(__timeslice_start)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JDAQChronometer()
    {}


    /**
     * Get DAQ chronometer.
     *
     * \return                DAQ chronometer
     */
    const JDAQChronometer& getDAQChronometer() const 
    { 
      return static_cast<const JDAQChronometer&>(*this); 
    }


    /**
     * Set DAQ chronometer.
     *
     * \param chronometer     DAQ chronometer
     */
    void setDAQChronometer(const JDAQChronometer& chronometer)
    { 
      static_cast<JDAQChronometer&>(*this) = chronometer;
    }


    /**
     * Get detector identifier.
     *
     * \return                detector identifier
     */
    int getDetectorID() const 
    { 
      return detector_id; 
    }


    /**
     * Get run number.
     *
     * \return                run number
     */
    int getRunNumber() const 
    { 
      return run; 
    }


    /**
     * Get frame index.
     *
     * \return                frame index
     */
    int getFrameIndex() const 
    { 
      return frame_index; 
    }
    
    
    /**
     * Get start of timeslice
     *
     * \return                timeslice start
     */
    
    const JDAQUTCExtended& getTimesliceStart() const
    {
      return timeslice_start;
    }
    

    /**
     * Set run number.
     *
     * \param run             run number
     */
    void setRunNumber(const int run)
    { 
      this->run = run;
    }


    /**
     * Set frame index.
     *
     * \param frame_index     frame index
     */
    void setFrameIndex(const int frame_index)
    { 
      this->frame_index = frame_index;
    }

    
    /**
     * Set timeslice start time
     *
     * \param timeslice_start timeslice start time
     */    
    void setTimesliceStart(const JDAQUTCExtended& timeslice_start)
    {
      this->timeslice_start = timeslice_start;
    }
    

    /**
     * Read DAQ chronometer from input.
     *
     * \param  in             JReader
     * \param  chronometer    JDAQChronometer
     * \return                JReader
     */
    friend inline JReader& operator>>(JReader& in, JDAQChronometer& chronometer)
    {
      in >> chronometer.detector_id;
      in >> chronometer.run;
      in >> chronometer.frame_index;
      in >> chronometer.timeslice_start;

      return in;
    }


    /**
     * Write DAQ chronometer to output.
     *
     * \param  out           JWriter
     * \param  chronometer   JDAQChronometer
     * \return               JWriter
     */
    friend inline JWriter& operator<<(JWriter& out, const JDAQChronometer& chronometer)
    {
      out << chronometer.detector_id;
      out << chronometer.run;
      out << chronometer.frame_index;
      out << chronometer.timeslice_start;
      
      return out;
    }


    /**
     * Get size of object.
     *
     * \return               number of bytes
     */
    static int sizeOf()
    {
      return (sizeof(int) +
              sizeof(int) +
              sizeof(int) +
              JDAQUTCExtended::sizeOf());
    }


    ClassDef(JDAQChronometer,3);


  protected:
    int detector_id;
    int run;
    int frame_index;
    JDAQUTCExtended timeslice_start;
  };


  /**
   * Print DAQ chronometer.
   *
   * \param  out           output stream
   * \param  chronometer   JDAQChronometer
   * \return               output stream
   */
  inline std::ostream& operator<<(std::ostream& out, const JDAQChronometer& chronometer)
  {
    using namespace std;

    out << setw(8) << chronometer.getDetectorID();
    out << ' ';
    out << setw(8) << chronometer.getRunNumber();
    out << ' ';
    out << setw(8) << chronometer.getFrameIndex();
    out << ' ';
    out <<            chronometer.getTimesliceStart();
    
    return out;
  }


  /**
   * Get time of last RTS in ns since start of run for a given chronometer.
   *
   * \param  chronometer  chronometer
   * \return              time [ns]
   */
  inline double getTimeOfRTS(const JDAQChronometer& chronometer)
  {
    return getTimeOfRTS(chronometer.getFrameIndex());
  }


  /**
   * Equal operator for DAQ chronometers.
   *
   * \param  first     chronometer
   * \param  second    chronometer
   * \result           true if first chronometer equal to second; else false
   */
  inline bool operator==(const JDAQChronometer& first,
                         const JDAQChronometer& second)
  {
    return (first.getDetectorID()     == second.getDetectorID()    &&
            first.getRunNumber()      == second.getRunNumber()     &&
            first.getFrameIndex()     == second.getFrameIndex()    &&
            first.getTimesliceStart() == second.getTimesliceStart());
  }


  /**
   * Not-equal operator for DAQ chronometers.
   *
   * \param  first     chronometer
   * \param  second    chronometer
   * \result           true if first chronometer not equal to second; else false
   */
  inline bool operator!=(const JDAQChronometer& first,
                         const JDAQChronometer& second)
  {
    return !(first == second);
  }
}

#endif