JSuperFrame2D.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JSUPERFRAME2D__
#define __JTRIGGER__JSUPERFRAME2D__

#include <vector>

#include "JDAQ/JDAQ.hh"
#include "JDAQ/JDAQSuperFrame.hh"
#include "JDetector/JModule.hh"
#include "JTrigger/JModuleHeader.hh"
#include "JTrigger/JFrame.hh"


/**
 * \author mdejong
 */

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

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


  /**
   * 2-dimensional frame with time calibrated data from one optical module.\n
   * For each PMT, data are stored in a separate frame.
   * In the following, the data of a single PMT are assumed to be time ordered.\n
   * Note that the data of each PMT are terminated with an end marker.
   *
   * The data of a given PMT are reduced to a single end marker when:
   *  - high-rate veto bit is on; or
   *  - FIFO (almost) full bit is on; or 
   *  - PMT has status bit set. 
   *
   * The data member JSuperFrame2D::demultiplex can be used as an I/O buffer.
   */
  template<class JElement_t>
  class JSuperFrame2D :
    public JModuleHeader,
    public std::vector< JFrame<JElement_t> >
  {
  public:

    typedef JFrame<JElement_t>                                           frame_type;
    
    typedef typename std::vector<frame_type>::iterator                   iterator;
    typedef typename std::vector<frame_type>::const_iterator             const_iterator;
    typedef typename std::vector<frame_type>::reverse_iterator           reverse_iterator;
    typedef typename std::vector<frame_type>::const_reverse_iterator     const_reverse_iterator;


    /**
     * Default constructor.
     */
    JSuperFrame2D() :
      JModuleHeader(),
      std::vector< JFrame<JElement_t> >()
    {}


    /**
     * Process DAQ super frame.
     * The time calibration is applied and an appropriate end marker is added.
     *
     * \param  input          DAQ super frame
     * \param  module         module data
     * \return                this 2D super frame
     */
    JSuperFrame2D& operator()(const JDAQSuperFrame& input,
                              const JModule&        module)
    {
      using KM3NETDAQ::NUMBER_OF_PMTS;
      using JDETECTOR::JPMT;

      this->setDAQChronometer  (input.getDAQChronometer());
      this->setModuleIdentifier(input.getModuleIdentifier());
      this->setPosition        (module.getPosition());

      this->resize(NUMBER_OF_PMTS);

      for (int i = 0; i != NUMBER_OF_PMTS; ++i) {

        JFrame<JElement_t>& frame = (*this)[i];

        frame.clear();

        frame.setDAQChronometer(this->getDAQChronometer());
        frame.setPMTIdentifier (JDAQPMTIdentifier(this->getModuleID(), i));
        frame.setAxis          (module.getPMT(i).getAxis());
        frame.setCalibration   (module.getPMT(i).getCalibration());
      }

      int n = input.size();

      for (JDAQSuperFrame::const_iterator i = input.begin(); n != 0; --n, ++i) {
        (*this)[i->getPMT()].push_back(*i);
      }

      for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
        (*this)[i].putEndMarker();
      }

      if (input.testHighRateVeto()) {
        for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
          if (input.testHighRateVeto(i)) {
            (*this)[i].reset();
          }
        }
      }

      if (input.testFIFOStatus()) {
        for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
          if (input.testFIFOStatus(i)) {
            (*this)[i].reset();
          }
        }
      }

      for (int i = 0; i != NUMBER_OF_PMTS; ++i) {
        if (module.getPMT(i).has(JPMT::PMT_STATUS)) {
          (*this)[i].reset();
        }
      }

      return *this;
    }
 

    /**
     * Apply high-rate veto.
     *
     * \param  rate_Hz        high-rate veto [Hz] 
     */
    void applyHighRateVeto(const double rate_Hz)
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
        i->applyHighRateVeto(rate_Hz);
      }
    }


    /**
     * Demultiplexer.
     */
    static JSuperFrame2D<JElement_t> demultiplex;
  };


  /**
   * Demultiplexer.
   */
  template<class JElement_t>
  JSuperFrame2D<JElement_t> JSuperFrame2D<JElement_t>::demultiplex;
}

#endif