JFrame.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JFRAME__
#define __JTRIGGER__JFRAME__

#include <vector>

#include "JDAQ/JDAQHit.hh"
#include "JDAQ/JDAQClock.hh"
#include "JTrigger/JPMTHeader.hh"
#include "JTrigger/JHitToolkit.hh"
#include "JTrigger/JCalibration.hh"


/**
 * \author mdejong
 */

namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }

namespace JTRIGGER {

  using KM3NETDAQ::JDAQHit;


  /**
   * Data frame for calibrated hits of one PMT.
   *
   * Note that the calibration is applied on the fly in the method JFrame::push_back.
   */
  template<class JElement_t, class JAllocator_t = std::allocator<JElement_t> >
  class JFrame :
    public JPMTHeader,
    public JCalibration,
    public std::vector<JElement_t, JAllocator_t>,
    public JHitToolkit<JElement_t>
  {
  public:

    using std::vector<JElement_t, JAllocator_t>::push_back;

    /**
     * Default constructor.
     */
    JFrame() :
      JPMTHeader  (),
      JCalibration(),
      std::vector<JElement_t, JAllocator_t>(),
      JHitToolkit<JElement_t>()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     * \param  id             PMT identifier
     * \param  axis           PMT axis
     * \param  calibration    calibration
     */
    JFrame(const JDAQChronometer&   chronometer,
           const JDAQPMTIdentifier& id,
           const JAxis3D&           axis,
           const JCalibration&      calibration) :
      JPMTHeader  (chronometer, id, axis),
      JCalibration(calibration),
      std::vector<JElement_t, JAllocator_t>(),
      JHitToolkit<JElement_t>()
    {}


    /**
     * Append DAQ hit.
     *
     * The time calibration is applied before the hit is appended.
     *
     * \param  hit            DAQ hit
     */
    void push_back(const JDAQHit& hit)
    {
      std::vector<JElement_t, JAllocator_t>::push_back(this->getHit(hit, this->getCalibration()));
    }


    /**
     * Append end marker to data.
     */
    void putEndMarker() 
    {
      std::vector<JElement_t, JAllocator_t>::push_back(this->getEndMarker());
    }


    /**
     * Reset.\n
     * The contents of this frame is reduced to a single end marker. 
     */
    void reset()
    {
      this->clear();
      this->putEndMarker();
    }


    /**
     * Apply high-rate veto.\n
     * If vetoed, the contents of this frame is reduced to a single end marker. 
     *
     * \param  rate_Hz        high-rate veto [Hz] 
     */
    void applyHighRateVeto(const double rate_Hz)
    {
      using KM3NETDAQ::getFrameTime;

      if (this->size() * 1.0e9 / getFrameTime() > rate_Hz) {
        this->reset();
      }
    }


    /**
     * Join consecutive hits when matched according given criterion.
     *
     * The template argument <tt>JMatch_t</tt> refers to a data structure which should have the following operator:
     *   - <tt>bool %operator()(const JElement_t&, const JElement_t) const;</tt>
     *
     * The element of this container should provide for the member method:
     *   - <tt>void %join(const JElement_t&);</tt>
     *
     * \param  match          match criterion
     */
    template<class JMatch_t>
    void join(const JMatch_t& match)
    {
      typename std::vector<JElement_t, JAllocator_t>::iterator out = this->begin();

      for (typename std::vector<JElement_t, JAllocator_t>::const_iterator p = this->begin(); p != this->end(); ) {

        *out = *p;

        while (++p != this->end() && match(*out,*p)) {
          out->join(*p);
        }

        ++out;
      }

      this->erase(out, this->end());
    }


    /**
     * Filter consecutive hits when matched according given criterion.
     *
     * The template argument <tt>JMatch_t</tt> refers to a data structure which should have the following operator:
     *   - <tt>bool %operator()(const JElement_t&, const JElement_t) const;</tt>
     *
     * \param  match          match criterion
     */
    template<class JMatch_t>
    void filter(const JMatch_t& match)
    {
      using namespace std;

      typename std::vector<JElement_t, JAllocator_t>::iterator out = this->begin();

      for (typename std::vector<JElement_t, JAllocator_t>::const_iterator p = this->begin(); p != this->end(); ) {

        typename std::vector<JElement_t, JAllocator_t>::const_iterator q = p; 

        while (++q != this->end() && match(*p,*q)) {}

        if (distance(p,q) == 1) {

          *out = *p;

          ++out;
        }

        p = q;
      }

      this->erase(out, this->end());
    }
  };
}

#endif