JBuildL2.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JBUILDL2__
#define __JTRIGGER__JBUILDL2__

#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/JHitL2.hh"
#include "JTrigger/JHitR2.hh"
#include "JTrigger/JBuildHelper.hh"
#include "JTrigger/JBuildL1.hh"
#include "JTrigger/JTriggerParameters.hh"
#include "JGeometry3D/JAxis3D.hh"
#include "JDAQ/JDAQSuperFrame.hh"
#include "JDetector/JModule.hh"
#include "JMath/JMathToolkit.hh"


/**
 * \author mdejong
 */

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

namespace JTRIGGER {

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


  /**
   * Template L2 builder.
   *
   * An L2 hit is a local coincidence between two or more hits from different PMTs
   * within the same optical module satisfying:
   *   - minimal number of hits requirement; 
   *   - maximal time difference between hits; and 
   *   - maximal space angle requirement between the PMT axes.
   */
  template<class JElement_t>
  class JBuildL2 :
    public JL2Parameters,
    public JHitToolkit<JElement_t>,
    public JBuildHelper< JBuildL2<JElement_t> >
  {
  public:

    using JBuildHelper< JBuildL2<JElement_t> >::operator();
    
    typedef JElement_t   value_type;


    /**
     * Constructor.
     *
     * \param  numberOfHits    minimal number of hits
     * \param  Tmax_ns         maximal time difference [ns]
     * \param  ctMin           minimal cosine space angle between PMT axes
     */
    JBuildL2(const int    numberOfHits,
             const double Tmax_ns,
             const double ctMin) :
      JL2Parameters(numberOfHits, Tmax_ns, ctMin)
    {}
    

    /**
     * Constructor.
     *
     * \param  parameters        L2 parameters
     */
    JBuildL2(const JL2Parameters& parameters) :
      JL2Parameters(parameters)
    {}


    /**
     * Build hits from calibrated data.
     *
     * Only the input hits that satify the predefined requirements are copied from input to output.
     * The requirements are checked using the calibrated data of each PMT inside the same module.
     * The input data should be time sorted.
     * The output data are time sorted.
     *
     * \param  super_frame       input  L0 data
     * \param  input             input  L1 data
     * \param  out               output L2 data
     */
    template<template<class, class> class JContainer_t, class JAllocator_t, class JOutput_t>
    void operator()(const JSuperFrame2D<JElement_t>&               super_frame,
                    const JContainer_t <JElement_t, JAllocator_t>& input,
                    JOutput_t                                      out) const
    {
      clone = super_frame;

      for (typename JContainer_t<JElement_t, JAllocator_t>::const_iterator __p = input.begin(); __p != input.end(); ++__p) {

        clone.fast_forward(*__p);

        if (isL2(*__p)) {
          *out = *__p;
          ++out;
        }
      }
    }


    /**
     * Build hits from calibrated data.
     *
     * The calibrated data of each PMT inside the optical module are used to build L1 coincidences.
     * The predefined requirements are then checked using the same calibrated data of each PMT.
     * The output data are time sorted.
     *
     * \param  input             input  L0 data
     * \param  out               output L2 data
     */
    template<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->TMaxLocal_ns, true);

      build(input, back_inserter(buffer));

      (*this)(input, buffer, out);
    }


    /**
     * Build hits from DAQ data.
     *
     * The time calibration is applied and the requirements are applied to the calibrated data.
     * The output data are time sorted.
     *
     * \param  input             DAQ super frame
     * \param  module            module
     * \param  out               output L2 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);
      }
    }

  protected:
    /**
     * Test if requirements for given hit are satisfied.
     * The internal iterators should be set before this test operation.
     *
     * \param  hit               L1 hit
     * \return                   true is L2 condition is satisfied; else false
     */
    bool isL2(const JElement_t& hit) const
    {
      for (typename JSuperFrameClone2D<JElement_t>::const_iterator i = clone.begin(); i != clone.end(); ++i) {
        
        if (this->getTimeDifference(hit,*(i->get())) <= TMaxLocal_ns) {
          
          int n = 1;

          for (typename JSuperFrameClone2D<JElement_t>::const_iterator j = i; ++j != clone.end(); ) {
            
            if (this->getTimeDifference(hit,*(j->get())) <= TMaxLocal_ns) {
              
              if (JMATH::getDot(i->getDirection(), j->getDirection()) >= ctMin) {
                
                if (++n >= numberOfHits) {
                  return true;
                }
              }
            }
          }
        }
      }

      return false;
    }


    mutable JSuperFrameClone2D<JElement_t> clone;
  };


  /**
   * Template specialisation of L2 builder for JHitL1 data type.
   *
   * An L2 hit is a local coincidence between two or more hits from different PMTs
   * within the same optical module satisfying:
   *   - minimal number of hits requirement; 
   *   - maximal time difference between hits; and
   *   - maximal space angle requirement between the PMT axes.
   */
  template<>
  class JBuildL2<JHitL2> :
    public JL2Parameters,
    public JBuildHelper< JBuildL2<JHitL2> >
  {
  public:

    using JBuildHelper< JBuildL2<JHitL2> >::operator();
    
    typedef JHitL2       value_type;


    /**
     * Constructor.
     *
     * \param  numberOfHits    minimal number of hits
     * \param  Tmax_ns         maximal time difference [ns]
     * \param  ctMin           minimal cosine space angle between PMT axes
     */
    JBuildL2(const int    numberOfHits,
             const double Tmax_ns,
             const double ctMin) :
      JL2Parameters(numberOfHits, Tmax_ns, ctMin)
    {}
    

    /**
     * Constructor.
     *
     * \param  parameters        L2 parameters
     */
    JBuildL2(const JL2Parameters& parameters) :
      JL2Parameters(parameters)
    {}


    /**
     * Build hits from calibrated data.
     *
     * Only the input hits that satify the predefined requirements are copied from input to output.
     * The requirements are checked using the calibrated data of each PMT inside the same module.
     * The input data should be time sorted.
     * The output data are time sorted.
     *
     * \param  super_frame       input  L0 data
     * \param  input             input  L1 data
     * \param  out               output L2 data
     */
    template<class JElement_t, template<class, class> class JContainer_t, class JAllocator_t, class JOutput_t>
    void operator()(const JSuperFrame2D<JElement_t>&               super_frame,
                    const JContainer_t <JElement_t, JAllocator_t>& input,
                    JOutput_t                                      out) const
    {
      using namespace std;

      typedef JSuperFrameClone2D<JElement_t>  JSuperFrameClone2D_t;

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

      build(super_frame, input, back_inserter(buffer));

      JSuperFrameClone2D_t clone(super_frame);

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

        JHitL1 hit(super_frame.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 calibrated data.
     *
     * The calibrated data of each PMT inside the optical module are used to build L1 coincidences.
     * The predefined requirements are then checked using the same calibrated data of each PMT.
     * 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->TMaxLocal_ns, true);

      build(input, back_inserter(buffer));

      (*this)(input, buffer, out);
    }


    /**
     * Build hits from DAQ data.
     *
     * The time calibration is applied and the requirements are applied to the calibrated data.
     * The output data are time sorted.
     *
     * \param  input             DAQ super frame
     * \param  module            module
     * \param  out               output L2 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 L2 builder for JHitR1 data type.
   *
   * An L2 hit is a local coincidence between two or more hits from different PMTs
   * within the same optical module satisfying:
   *   - minimal number of hits requirement; 
   *   - maximal time difference between hits; and
   *   - maximal space angle requirement between the PMT axes.
   */
  template<>
  class JBuildL2<JHitR2> :
    public JL2Parameters,
    public JBuildHelper< JBuildL2<JHitR2> >
  {
  public:

    using JBuildHelper< JBuildL2<JHitR2> >::operator();
    
    typedef JHitR2       value_type;


    /**
     * Constructor.
     *
     * \param  numberOfHits    minimal number of hits
     * \param  Tmax_ns         maximal time difference [ns]
     * \param  ctMin           minimal cosine space angle between PMT axes
     */
    JBuildL2(const int    numberOfHits,
             const double Tmax_ns,
             const double ctMin) :
      JL2Parameters(numberOfHits, Tmax_ns, ctMin)
    {}
    

    /**
     * Constructor.
     *
     * \param  parameters        L2 parameters
     */
    JBuildL2(const JL2Parameters& parameters) :
      JL2Parameters(parameters)
    {}


    /**
     * Build hits from calibrated data.
     *
     * Only the input hits that satify the predefined requirements are copied from input to output.
     * The requirements are checked using the calibrated data of each PMT inside the same module.
     * The input data should be time sorted.
     * The output data are time sorted.
     *
     * \param  super_frame       input  L0 data
     * \param  input             input  L1 data
     * \param  out               output L2 data
     */
    template<class JElement_t, template<class, class> class JContainer_t, class JAllocator_t, class JOutput_t>
    void operator()(const JSuperFrame2D<JElement_t>&               super_frame,
                    const JContainer_t <JElement_t, JAllocator_t>& input,
                    JOutput_t                                      out) const
    {
      using namespace std;

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

      build(super_frame, input, back_inserter(buffer));

      JSuperFrameClone2D<JElement_t> clone(super_frame);

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

        JHitR2 hit(super_frame.getModuleID(),
                   super_frame.getPosition());
  
        clone.fast_forward(*__p);
    
        for (typename JSuperFrameClone2D<JElement_t>::const_iterator i = clone.begin(); i != clone.end(); ++i) {
        
          if (i->getTimeDifference(*__p) <= TMaxLocal_ns) {

            if (hit.getN() == 0)
              hit.set(i->getJHit());
            else
              hit.add(i->getJHit());
          }
        }
         
        *out = hit;
        ++out;
      }
    }


    /**
     * Build hits from calibrated data.
     *
     * The calibrated data of each PMT inside the optical module are used to build L1 coincidences.
     * The predefined requirements are then checked using the same calibrated data of each PMT.
     * 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->TMaxLocal_ns, true);

      build(input, back_inserter(buffer));

      (*this)(input, buffer, out);
    }


    /**
     * Build hits from DAQ data.
     *
     * The time calibration is applied and the requirements are applied to the calibrated data.
     * The output data are time sorted.
     *
     * \param  input             DAQ super frame
     * \param  module            module
     * \param  out               output L2 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