JSuperFrame1D.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JSUPERFRAME1D__
#define __JTRIGGER__JSUPERFRAME1D__

#include <vector>

#include "km3net-dataformat/online/JDAQSuperFrame.hh"
#include "JDetector/JModule.hh"
#include "JTools/JMergeSort.hh"
#include "JTrigger/JModuleHeader.hh"
#include "JTrigger/JSuperFrame2D.hh"
#include "JLang/JSTDToolkit.hh"


/**
 * \author mdejong
 */

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

namespace JTRIGGER {
  
  using KM3NETDAQ::JDAQSuperFrame;
  using JDETECTOR::JModule;


  /**
   * 1-dimensional frame with time calibrated data from one optical module.
   *
   * This class can be used to merge the data from different PMTs contained in a JSuperFrame2D object.\n
   * The data will then be time sorted.
   *
   * The static data member JSuperFrame1D::multiplex can be used as an I/O buffer.
   */
  template<class JElement_t, class JAllocator_t = std::allocator<JElement_t> >
  class JSuperFrame1D :
    public JModuleHeader,
    public std::vector<JElement_t, JAllocator_t>,
    public JHitToolkit<JElement_t>
  {
  public:
    /**
     * Default constructor.
     */
    JSuperFrame1D() :
      JModuleHeader(),
      std::vector<JElement_t, JAllocator_t>(),
      JHitToolkit<JElement_t>()
    {}


    /**
     * Constructor.
     *
     * \param  chronometer    DAQ chronometer
     * \param  id             module identifier
     * \param  pos            module position
     */
    JSuperFrame1D(const JDAQChronometer&      chronometer,
                  const JDAQModuleIdentifier& id,
                  const JPosition3D&          pos) :
      JModuleHeader(chronometer, id, pos),
      std::vector<JElement_t, JAllocator_t>(),
      JHitToolkit<JElement_t>()
    {}


    /**
     * Constructor.
     *
     * \param  input          2D super frame
     */
    JSuperFrame1D(const JSuperFrame2D<JElement_t>& input) :
      JModuleHeader(input.getModuleHeader()),
      std::vector<JElement_t, JAllocator_t>(),
      JHitToolkit<JElement_t>()
    {
      merge(input.begin(), input.end(), static_cast<std::vector<JElement_t, JAllocator_t>&>(*this), this->getToolkit());
    }


    /**
     * Copy constructor.
     *
     * \param  input          1D super frame
     */
    JSuperFrame1D(const JSuperFrame1D<JElement_t, JAllocator_t>& input) :
      JModuleHeader(input.getModuleHeader()),
      std::vector<JElement_t, JAllocator_t>(input.begin(), input.end()),
      JHitToolkit<JElement_t>()
    {
      if (input.hasEndMarker()) {
        this->putEndMarker();
      }
    }


    /**
     * Check presence of end marker.
     *
     * \return                true if end marker present; else false
     */
    bool hasEndMarker() const
    {
      return (this->capacity() > this->size() && this->getT(*(this->end())) == this->getT(this->getEndMarker()));
    }


    /**
     * Append end marker to data.
     *
     * Note that the end marker is put within the capacity of the container whilst its size is maintained.
     */
    void putEndMarker()
    {
      JPP::putEndMarker(*this, this->getEndMarker());
    }


    /**
     * Process 2D super frame.
     *
     * The data are sorted in time and an appropriate end marker is added.
     *
     * \param  input          2D super frame
     * \return                this 1D super frame
     */
    JSuperFrame1D& operator()(const JSuperFrame2D<JElement_t>& input)
    {
      this->setModuleHeader(input.getModuleHeader());

      merge(input.begin(), input.end(), static_cast<std::vector<JElement_t, JAllocator_t>&>(*this), this->getToolkit());

      return *this;
    }


    /**
     * Process set of 2D super frame data.
     *
     * The data are sorted in time and an appropriate end marker is added.
     * Note that this method only updates the data in the container.
     *
     * \param  __begin        begin of 2D super frame data
     * \param  __end          end   of 2D super frame data
     * \return                this 1D super frame
     */
    JSuperFrame1D& operator()(typename JSuperFrame2D<JElement_t>::const_iterator __begin,
                              typename JSuperFrame2D<JElement_t>::const_iterator __end)
    {
      merge(__begin, __end, static_cast<std::vector<JElement_t, JAllocator_t>&>(*this), this->getToolkit());
      
      return *this;
    }


    /**
     * Process DAQ super frame.
     *
     * The time calibration is applied, data are sorted in time and an appropriate end marker is added.
     *
     * \param  input          DAQ super frame
     * \param  module         module data
     * \return                this 1D super frame
     */
    JSuperFrame1D& operator()(const JDAQSuperFrame& input,
                              const JModule&        module)
    {
      return (*this)(buffer(input, module));
    }


    /**
     * Multiplexer.
     */
    static JSuperFrame1D<JElement_t, JAllocator_t> multiplex;


  private:
    static JTOOLS::JMergeSort<JElement_t> merge;
    static JSuperFrame2D     <JElement_t> buffer;
  };


  /**
   * Internal merge method.
   */
  template<class JElement_t, class JAllocator_t>
  JTOOLS::JMergeSort<JElement_t> JSuperFrame1D<JElement_t, JAllocator_t>::merge;

  
  /**
   * Internal buffer.
   */
  template<class JElement_t, class JAllocator_t>
  JSuperFrame2D<JElement_t> JSuperFrame1D<JElement_t, JAllocator_t>::buffer;


  /**
   * Multiplexer.
   */
  template<class JElement_t, class JAllocator_t>
  JSuperFrame1D<JElement_t, JAllocator_t> JSuperFrame1D<JElement_t, JAllocator_t>::multiplex;
}

#endif