JTriggerMXShower.hh

Go to the documentation of this file.

#ifndef __JTRIGGER__JTRIGGERMXSHOWER__
#define __JTRIGGER__JTRIGGERMXSHOWER__
 
#include "JTrigger/JTriggerMXShower_t.hh"
#include "JTrigger/JParametersHelper.hh"
#include "JTrigger/JTriggerInterface.hh"
#include "JTrigger/JTimeslice.hh"
#include "JTrigger/JTimesliceClone.hh"
#include "JDetector/JDetector.hh"
#include "JDetector/JModuleMapper.hh"
#include "JMath/JMathToolkit.hh"
#include "JTools/JConstants.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JTRIGGER {}
namespace JPP { using namespace JTRIGGER; }
 
namespace JTRIGGER {
 
  using JDETECTOR::JModule;
  using JDETECTOR::JModuleMapper;
  using JDETECTOR::JDetector;
  using JDETECTOR::JMaximalDistance;
 
 
  /**
   * Module attributes.
   */
  struct JAttributes {
    double Tmin_ns;         //!< minimal time difference [ns]
    double Tmax_ns;         //!< maximal time difference [ns]
  };
 
 
  /**
   * Set module attributes.
   *
   * \param  first          first  module
   * \param  second         second module
   * \param  attributes     module attributes
   */
  inline void setAttributes(const JModule& first,
                            const JModule& second,
                            JAttributes&   attributes)
  {
    using namespace JMATH;
    using namespace JTOOLS;
 
    typedef JTriggerMXShower_t::JParameters  JParameters_t;
 
    // get trigger parameters
 
    const JParameters_t& parameters = JParametersHelper<JParameters_t>::getParameters();
 
    const double d = getDistance(first, second);
 
    double t1 = 0.0;
 
    if      (d <= 0.5 * parameters.DMax_m)
      t1 =  d                      * getIndexOfRefraction() * getInverseSpeedOfLight()  +  parameters.TMaxExtra_ns;
    else if (d <= parameters.DMax_m)
      t1 = (parameters.DMax_m - d) * getIndexOfRefraction() * getInverseSpeedOfLight()  +  parameters.TMaxExtra_ns;
 
    attributes.Tmin_ns = -t1;
    attributes.Tmax_ns = +t1;
  }
 
 
  /**
   * Shower trigger.
   */
  class JTriggerMXShower : 
    public JTriggerMXShower_t,
    public JTriggerInterface
  {
  public:
 
    /**
     * Type definition of module mapper.
     */
    typedef JModuleMapper<JAttributes>   JModuleMapper_t;
 
 
    /**
     * Constructor.
     *
     * \param  input          trigger parameters
     * \param  detector       detector;
     */
    JTriggerMXShower(const JParameters& input,
                     const JDetector&   detector) :
      parameters(input),
      mapper(detector, JMaximalDistance(parameters.DMax_m)),
      match(parameters.DMax_m, parameters.TMaxExtra_ns)
    {
      using namespace JTOOLS;
 
      TMaxEvent_ns = parameters.DMax_m * getIndexOfRefraction() * getInverseSpeedOfLight()  +  parameters.TMaxExtra_ns;
 
      if (parameters.numberOfHits == 0) {
        parameters.numberOfHits = 1;
      }
 
      if (parameters.numberOfHits == 1) {
        parameters.factoryLimit = 1;
      }
 
      if (parameters.numberOfModules < 1) {
        parameters.numberOfModules = 1;
      }
    }
 
 
    /**
     * Process trigger.
     *
     * \param  inputL1        input L1 data
     * \param  inputL0        input L0 data
     * \param  out            output data
     */
    template<class JElement_t>
    void operator()(const JTriggerInput&         inputL1,
                    const JTimeslice<JElement_t> inputL0,
                    std::back_insert_iterator<JTriggerOutput> out) const
    {
      typedef JTimesliceClone<JElement_t>                JTimeslice_t;
      typedef typename JTimeslice_t::value_type          JFrame_t;
      typedef typename JModuleMapper_t::container_type   container_type;
 
      if (parameters.enabled) {
 
        JTimeslice_t clone(inputL0, mapper);
 
        for (JTriggerInput::const_iterator root = inputL1.begin(); root != inputL1.end(); ++root) {
 
          buffer.clear();
 
          const container_type& zip = mapper.getList(root->getModuleID());
 
          for (typename container_type::const_iterator mod = zip.begin(); mod != zip.end(); ++mod) {
 
            const double Tmin  = root->getT() + mod->Tmin_ns;
            const double Tmax  = root->getT() + mod->Tmax_ns;
 
            JFrame_t&    frame = clone[mod->first];
 
            frame.fast_forward(root->getT() - TMaxEvent_ns);
 
            for (typename JFrame_t::const_iterator i = frame.get(); *i <= Tmax; ++i) {
 
              if (*i >= Tmin) {
                buffer.push_back(JHitR1(frame.getModuleID(),
                                        frame.getPosition(),
                                        frame.getJHit(*i)));
              }
            }
          }
 
          if (distance          (buffer.begin(), buffer.end()) >= parameters.numberOfHits    - 1 &&
              getNumberOfModules(buffer.begin(), buffer.end()) >= parameters.numberOfModules - 1) {
 
            if (distance(buffer.begin(), buffer.end()) < parameters.factoryLimit) {
 
              JTriggerInput::iterator q = clusterize(buffer.begin(), buffer.end(), match, parameters.numberOfHits - 1);
 
              if (distance          (buffer.begin(), q) >= parameters.numberOfHits    - 1 &&
                  getNumberOfModules(buffer.begin(), q) >= parameters.numberOfModules - 1) {
                *out = JEvent(inputL1.getDAQChronometer(), *root, buffer.begin(), q, this->getTriggerBit());
                ++out;
              }
 
            } else {
 
              // Anomalous large event
        
              *out = JEvent(inputL1.getDAQChronometer(), *root, buffer.begin(), buffer.end(), this->getTriggerBit());
              ++out;
            }
          }
        }
      }
    }  
 
  private:
    JParametersHelper<JParameters> parameters;
    JModuleMapper_t                mapper;
    mutable std::vector<JHitR1>    buffer;
    JMatch3G<JHitR1>               match;
    double                         TMaxEvent_ns;
  };
}
 
#endif