JBuildL1.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JBUILDL1__
#define __JTRIGGER__JBUILDL1__

#include <vector>
#include <iterator>

#include "JTrigger/JHitToolkit.hh"
#include "JTrigger/JSuperFrame1D.hh"
#include "JTrigger/JSuperFrame2D.hh"
#include "JTrigger/JSuperFrameClone2D.hh"
#include "JTrigger/JHit.hh"
#include "JTrigger/JHitL0.hh"
#include "JTrigger/JHitL1.hh"
#include "JTrigger/JHitR1.hh"
#include "JTrigger/JBuildHelper.hh"
#include "JTrigger/JBuildL0.hh"
#include "JTrigger/JTriggerParameters.hh"
#include "JGeometry3D/JAxis3D.hh"
#include "JDAQ/JDAQSuperFrame.hh"
#include "JDetector/JModule.hh"


/**
 * \author mdejong
 */

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

namespace JTRIGGER {

  using KM3NETDAQ::JDAQSuperFrame;
  using JDETECTOR::JModule;


  /**
   * Auxiliary data structure for L1 build parameters.
   */
  struct JBuildL1Parameters
  {
    /**
     * Constructor.
     *
     * \param  Tmax_ns           maximal time difference of L1 [ns]
     * \param  combine           combine multiple L1 within given time window 
     */
    JBuildL1Parameters(const double Tmax_ns,
                       const bool   combine) :
      TMaxLocal_ns(Tmax_ns),
      combineL1   (combine)
    {}


    /**
     * Constructor.
     *
     * \param  parameters        trigger parameters
     */
    JBuildL1Parameters(const JTriggerParameters& parameters) :
      TMaxLocal_ns(parameters.TMaxLocal_ns),
      combineL1   (parameters.combineL1)
    {}


    double TMaxLocal_ns;
    bool   combineL1;
  };


  /**
   * Template L1 hit builder.
   *
   * An L1 hit is a local coincidence between two different PMTs within the same optical module.
   */
  template<class JElement_t>
  class JBuildL1 :
    public JBuildL1Parameters,
    public JHitToolkit<JElement_t>,
    public JBuildHelper< JBuildL1<JElement_t> >
  {
  public:

    using JBuildHelper< JBuildL1<JElement_t> >::operator();

    typedef JElement_t   value_type;


    /**
     * Constructor.
     *
     * \param  Tmax_ns           maximal time difference of L1 [ns]
     * \param  combine           combine multiple L1 within given time window 
     */
    JBuildL1(const double Tmax_ns,
             const bool   combine) :
      JBuildL1Parameters(Tmax_ns, combine)
    {}


    /**
     * Constructor.
     *
     * \param  parameters        trigger parameters
     */
    JBuildL1(const JTriggerParameters& parameters) :
      JBuildL1Parameters(parameters)
    {}


    /**
     * Constructor.
     *
     * \param  parameters        build L1 parameters
     */
    JBuildL1(const JBuildL1Parameters& parameters) :
      JBuildL1Parameters(parameters)
    {}


    /**
     * Build hits from calibrated data.
     *
     * The output data are time sorted.
     *
     * \param  input             input  L0 data
     * \param  out               output L1 data
     */
    template<class JOutput_t>
    void operator()(const JSuperFrame2D<JElement_t>& input, JOutput_t out) const
    {
      (*this)(input.begin(), input.end(), out);
    }


    /**
     * Build hits from set of frames with calibrated data.
     *
     * The output data are time sorted.
     *
     * \param  __begin           begin of input L0 data
     * \param  __end             end   of input L0 data
     * \param  out               output L1 data
     */
    template<class JOutput_t>
    void operator()(typename JSuperFrame2D<JElement_t>::const_iterator __begin,
                    typename JSuperFrame2D<JElement_t>::const_iterator __end,
                    JOutput_t out) const
    {
      (*this)(JSuperFrame1D<JElement_t>::multiplex(__begin, __end), out);
    }


    /**
     * Build hits from calibrated data.
     *
     * The output data are time sorted.
     *
     * \param  input             input  L0 data
     * \param  out               output L1 data
     */
    template<class JOutput_t>
    void operator()(const JSuperFrame1D<JElement_t>& input, JOutput_t out) const
    {
      int n = (int) input.size() - 1;    // remove end marker

      for (typename JSuperFrame1D<JElement_t>::const_iterator q = input.begin(), p = q++; n != 0; ++q, --n) {
          
        if (this->getTimeDifference(*p,*q) <= TMaxLocal_ns) {
          
          *out = *p;
          ++out;
          
          if (combineL1) {
            for (++q, --n; this->getTimeDifference(*p,*q) <= TMaxLocal_ns; ++q, --n) {}
          }
        }
        
        p = q;
      }
    }


    /**
     * Build hits from DAQ data.
     *
     * The time calibration is applied.
     * The output data are time sorted.
     *
     * \param  input             DAQ super frame
     * \param  module            module
     * \param  out               output L1 data
     */
    template<class JOutput_t>
    void operator()(const JDAQSuperFrame& input,
                    const JModule&        module,
                    JOutput_t             out) const
    {
      if (!input.empty()) {
        (*this)(JSuperFrame2D<JElement_t>::demultiplex(input, module), out);
      }
    }
  };


  /**
   * Template specialisation of L1 builder for JHitL1 data type.
   */
  template<>
  class JBuildL1<JHitL1> :
    public JBuildL1Parameters,
    public JBuildHelper< JBuildL1<JHitL1> >
  {
  public:

    using JBuildHelper< JBuildL1<JHitL1> >::operator();

    typedef JHitL1       value_type;


    /**
     * Constructor.
     *
     * \param  Tmax_ns           maximal time difference of L1 [ns]
     * \param  combine           combine multiple L1 within given time window 
     */
    JBuildL1(const double Tmax_ns,
             const bool   combine) :
      JBuildL1Parameters(Tmax_ns, combine)
    {}


    /**
     * Constructor.
     *
     * \param  parameters        trigger parameters
     */
    JBuildL1(const JTriggerParameters& parameters) :
      JBuildL1Parameters(parameters)
    {}


    /**
     * Constructor.
     *
     * \param  parameters        build L1 parameters
     */
    JBuildL1(const JBuildL1Parameters& parameters) :
      JBuildL1Parameters(parameters)
    {}


    /**
     * Build hits from calibrated data.
     *
     * The output data are time sorted.
     *
     * \param  input             input  L0 data
     * \param  out               output L1 data
     */
    template<class JElement_t, class JOutput_t>
    void operator()(const JSuperFrame2D<JElement_t>& input, JOutput_t out) const
    {
      using namespace std;

      typedef JSuperFrameClone2D<JElement_t>  JSuperFrameClone2D_t;

      vector  <JElement_t> buffer;
      JBuildL1<JElement_t> build(*this);

      build(JSuperFrame1D<JElement_t>::multiplex(input), back_inserter(buffer));

      JSuperFrameClone2D_t clone(input);

      for (typename vector<JElement_t>::const_iterator __p = buffer.begin(); __p != buffer.end(); ++__p) {

        JHitL1 hit(input.getModuleID());
  
        for (typename JSuperFrameClone2D_t::const_iterator i = clone.begin(); i != clone.end(); ++i) {
        
          for (typename JSuperFrameClone2D_t::value_type::const_iterator __q = i->fast_forward(*__p); JSuperFrameClone2D_t::getTimeDifference(*__p,*__q) <= TMaxLocal_ns; ++__q) {

            hit.push_back(JHitL0(i->getPMTIdentifier(),
                                 i->getAxis(),
                                 JSuperFrameClone2D_t::getJHit(*__q)));
          }
        }
         
        *out = hit.sort();
        ++out;
      }
    }


    /**
     * Build hits from uncalibrated DAQ data.
     *
     * The time calibration is applied.
     * The output data are time sorted.
     *
     * \param  input             DAQ super frame
     * \param  module            module
     * \param  out               output L1 data
     */
    template<class JOutput_t>
    void operator()(const JDAQSuperFrame& input,
                    const JModule&        module,
                    JOutput_t             out) const
    {
      if (!input.empty()) {
        (*this)(JSuperFrame2D<JHit>::demultiplex(input, module), out);
      }
    }
  };


  /**
   * Template specialisation of L1 builder for JHitR1 data type.
   *
   * Note that by constuction all hits which consitute an L1 hits are combined.
   */
  template<>
  class JBuildL1<JHitR1> :
    public JBuildL1Parameters,
    public JBuildHelper< JBuildL1<JHitR1> >
  {
  public:

    using JBuildHelper< JBuildL1<JHitR1> >::operator();

    typedef JHitR1       value_type;


    /**
     * Constructor.
     *
     * \param  Tmax_ns           maximal time difference of L1 [ns]
     * \param  combine           combine multiple L1 within given time window 
     */
    JBuildL1(const double Tmax_ns,
             const bool   combine) :
      JBuildL1Parameters(Tmax_ns, combine)
    {}


    /**
     * Constructor.
     *
     * \param  parameters        trigger parameters
     */
    JBuildL1(const JTriggerParameters& parameters) :
      JBuildL1Parameters(parameters)
    {}


    /**
     * Constructor.
     *
     * \param  parameters        build L1 parameters
     */
    JBuildL1(const JBuildL1Parameters& parameters) :
      JBuildL1Parameters(parameters)
    {}


    /**
     * Build hits from calibrated data.
     *
     * The output data are time sorted.
     *
     * \param  input             input  L0 data
     * \param  out               output L1 data
     */
    template<class JElement_t, class JOutput_t>
    void operator()(const JSuperFrame2D<JElement_t>& input, JOutput_t out) const
    {
      using namespace std;

      vector  <JElement_t> buffer;
      JBuildL1<JElement_t> build(*this);

      build(JSuperFrame1D<JElement_t>::multiplex(input), back_inserter(buffer));

      for (typename vector<JElement_t>::const_iterator __p = buffer.begin(); __p != buffer.end(); ++__p) {

        *out = JHitR1(input.getModuleID(),
                      input.getPosition(),
                      JHitToolkit<JElement_t>::getJHit(*__p));
        ++out;
      }
    }


    /**
     * Build hits from uncalibrated DAQ data.
     *
     * The time calibration is applied.
     * The output data are time sorted.
     *
     * \param  input             DAQ super frame
     * \param  module            module
     * \param  out               output L1 data
     */
    template<class JOutput_t>
    void operator()(const JDAQSuperFrame& input,
                    const JModule&        module,
                    JOutput_t             out) const
    {
      if (!input.empty()) {
        (*this)(JSuperFrame2D<JHit>::demultiplex(input, module), out);
      }
    }
  };
}

#endif