JChecksum.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JCHECKSUM__
#define __JTRIGGER__JCHECKSUM__
 
#include <vector>
#include <limits>
 
#include "JDAQ/JDAQ.hh"
#include "JDAQ/JDAQClock.hh"
#include "JDAQ/JDAQHit.hh"
#include "JDAQ/JDAQSuperFrame.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }
 
/**
 * Checksum.
 */
namespace JTRIGGER {
 
  using KM3NETDAQ::JDAQHit;
  using KM3NETDAQ::JDAQSuperFrame;
  using KM3NETDAQ::NUMBER_OF_PMTS;
 
  using JLANG::JValueOutOfRange;
  using JLANG::JIndexOutOfRange;
 
 
  /**
   * Auxiliary class to perform check-sum on raw data.
   */
  struct JChecksum {
    /**
     * Error types.
     */
    enum error_types {
      EPMT_t = 1,      //!< PMT error
      ETDC_t,          //!< TDC error
      ETOT_t           //!< time-over-threshold error
    };
 
 
    /**
     * Error.
     */
    struct error {
      /**
       * Default constructor.
       */
      error() :
        pos (-1),
        type(-1)
      {}
 
 
      /**
       * Constructor.
       *
       * \param  pos           index in frame
       * \param  type          error type
       */
      error(const int pos,
            const int type) :
        pos (pos),
        type(type)
      {}
 
      
      int pos;            //!< index in frame
      int type;           //!< error type
    };
 
 
    typedef std::vector<error>                         result_type;
    typedef result_type::const_iterator                const_iterator;
    typedef result_type::const_reverse_iterator        const_reverse_iterator;
 
 
    /**
     * Default constructor.
     */
    JChecksum()
    {
      t0.resize(NUMBER_OF_PMTS, 0);
    }
 
 
    /**
     * Check sum.
     *
     * \param  frame         DAQ frame
     * \return               list of errors; empty if all okay
     */
    const result_type& get(const JDAQSuperFrame& frame) const
    {
      using namespace KM3NETDAQ;
 
      //const double Tmin = getTimeSinceRTS(frame.getFrameIndex()) - 0.05 * getFrameTime();    // [ns]
      const double Tmax = getTimeSinceRTS(frame.getFrameIndex()) + 1.05 * getFrameTime();    // [ns]
 
      buffer.clear();
 
      for (std::vector<JDAQHit::JTDC_t>::iterator i = t0.begin(); i != t0.end(); ++i) {
        *i = 0;
      }
 
      for (JDAQSuperFrame::const_iterator hit = frame.begin(); hit != frame.end(); ++hit) {
 
        const JDAQHit::JTDC_t pmt = hit->getPMT();
        const JDAQHit::JTDC_t tdc = hit->getT();
 
        if (pmt < NUMBER_OF_PMTS) {
 
          if (tdc < t0[pmt]) {
            buffer.push_back(error(std::distance(frame.begin(), hit), ETDC_t));
          }
 
          t0[pmt] = tdc;
 
        } else {
 
          buffer.push_back(error(std::distance(frame.begin(), hit), EPMT_t));     
        }
      }
 
      for (std::vector<JDAQHit::JTDC_t>::const_iterator i = t0.begin(); i != t0.end(); ++i) {
        if (*i > Tmax) {
          buffer.push_back(error(frame.size(), ETDC_t));
        }
      }
 
      return buffer;
    }
 
 
    /**
     * Check sum.
     *
     * \param  frame         DAQ frame
     * \return               true if okay; else false
     */
    bool operator()(const JDAQSuperFrame& frame) const
    {
      return get(frame).empty();
    }
 
 
  private:
    mutable std::vector<JDAQHit::JTDC_t> t0;
    mutable result_type buffer;
  };
 
 
  /**
   * Function object to perform check-sum of raw data.
   */
  static const JChecksum checksum;
}
 
#endif