JMuonFeatures.hh

Go to the documentation of this file.

#ifndef __JRECONSTRUCTION__JMUONFEATURES__
#define __JRECONSTRUCTION__JMUONFEATURES__
 
#include <string>
#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
 
#include <map>
 
#include "km3net-dataformat/online/JDAQEvent.hh"
#include "km3net-dataformat/online/JDAQSummaryslice.hh"
#include "km3net-dataformat/definitions/fitparameters.hh"
 
#include "JTrigger/JHitL0.hh"
#include "JTrigger/JBuildL0.hh"
 
#include "JFit/JFitToolkit.hh"
#include "JFit/JLine1Z.hh"
#include "JFit/JLine3Z.hh"
#include "JFit/JModel.hh"
#include "JFit/JGandalf.hh"
#include "JFit/JLine3ZRegressor.hh"
 
#include "JReconstruction/JHitW0.hh"
#include "JReconstruction/JEvt.hh"
#include "JReconstruction/JEvtToolkit.hh"
#include "JReconstruction/JMuonGandalfParameters_t.hh"
 
#include "JPhysics/JPDFTable.hh"
#include "JPhysics/JPDFToolkit.hh"
#include "JPhysics/JGeane.hh"
 
#include "JDetector/JModuleRouter.hh"
 
#include "JDynamics/JCoverage.hh"
 
#include "JSupport/JSummaryRouter.hh"
 
#include "JGeometry3D/JRotation3D.hh"
 
#include "JTools/JRange.hh"
 
#include "Jeep/JMessage.hh"
 
#include "JLang/JVectorize.hh"
 
 
/**
 * \author eleguirriec, mdejong
 */
 
namespace JRECONSTRUCTION {}
namespace JPP { using namespace JRECONSTRUCTION; }
 
namespace JRECONSTRUCTION {
 
  using KM3NETDAQ::JDAQEvent;
  using JDETECTOR::JModuleRouter;
  using JSUPPORT::JSummaryRouter;
  using JFIT::JRegressor;
  using JFIT::JLine3Z;
  using JFIT::JGandalf;
  using JFIT::JTimeRange;
  using JDYNAMICS::coverage_type;
 
 
  /**
   * Wrapper class to add features after the final fit of muon trajectory.
   *
   * JMuonFeatures computes value of number of hists, number of doms and number of lines from the hits of an event.
   * Note that no values computed at previous steps are modified.
   */
  struct JMuonFeatures :
    public JMuonGandalfParameters_t,
    public JRegressor<JLine3Z, JGandalf>
  {
    typedef JRegressor<JLine3Z, JGandalf>        JRegressor_t;
    typedef JHitW0                               hit_type;
    typedef std::vector<hit_type>                buffer_type;
 
    using JRegressor_t::operator();
 
    /**
     * Input data type.
     */
    struct input_type :
      public JDAQEventHeader
    {
      /**
       * Default constructor.
       */
      input_type()
      {}
 
 
      /**
       * Constructor.
       *
       * \param  header         header
       * \param  in             start values
       * \param  coverage       coverage
       */
      input_type(const JDAQEventHeader& header,
                 const JEvt&            in,
                 const coverage_type&   coverage) :
        JDAQEventHeader(header),
        in(in),
        coverage(coverage)
      {}
 
      JEvt          in;
      buffer_type   data;
      coverage_type coverage;
      std::map<int, int> mapString;
    };
    
    /**
     * Constructor
     *
     * \param  parameters    parameters
     * \param  storage       storage
     * \param  debug         debug
     */
    JMuonFeatures(const JMuonGandalfParameters_t& parameters,
                  const storage_type&             storage,
                  const int                       debug = 0) :
      JMuonGandalfParameters_t(parameters),
      JRegressor_t(storage)
    {
      using namespace JFIT;
      
      if (this->getRmax() < roadWidth_m) {
        roadWidth_m = this->getRmax();
      }
 
      JRegressor_t::debug              = debug;
      JRegressor_t::T_ns.setRange(TMin_ns, TMax_ns);
      JRegressor_t::Vmax_npe           = VMax_npe;
      JRegressor_t::MAXIMUM_ITERATIONS = NMax;
      
      this->parameters.resize(5);
      
      this->parameters[0] = JLine3Z::pX();
      this->parameters[1] = JLine3Z::pY();
      this->parameters[2] = JLine3Z::pT();
      this->parameters[3] = JLine3Z::pDX();
      this->parameters[4] = JLine3Z::pDY();
        
    }
 
    /**
     * Get input data.
     *
     * \param  router        module router
     * \param  summary       summary data
     * \param  event         event
     * \param  in            start values
     * \param  coverage      coverage
     * \return               input data
     */
    input_type getInput(const JModuleRouter&  router,
                        const JSummaryRouter& summary,
                        const JDAQEvent&      event,
                        const JEvt&           in,
                        const coverage_type&  coverage) const
    {
      using namespace std;
      using namespace JTRIGGER;
 
      const JBuildL0<JHitL0>  buildL0;
 
      input_type     input(event.getDAQEventHeader(), in, coverage);
 
      vector<JHitL0> data;
      
      buildL0(event, router, true, back_inserter(data));
 
      for (const auto& hit : data) {
        input.data.push_back(hit_type(hit, summary.getRate(hit.getPMTIdentifier(), this->R_Hz)));
        input.mapString[hit.getModuleID()] = router.getModule(hit.getModuleID()).getString();
      }
      
      return input;
    }
    
 
    /**
     * Fit function.
     *
     * \param  input         input data
     * \return               fit results
     */
    JEvt operator()(const input_type& input)
    {
      using namespace std;
      using namespace JFIT;
      using namespace JGEOMETRY3D;
 
      JEvent event(JMUONFEATURES);
      
      JEvt out;
 
      const buffer_type& data = input.data;
 
      // select start values
 
      JEvt in = input.in;
      
      in.select(numberOfPrefits, qualitySorter);
 
      if (!in.empty()) {
        in.select(JHistory::is_event(in.begin()->getHistory()));
      }
      
      for (JEvt::const_iterator track = in.begin(); track != in.end(); ++track) {
 
        const JRotation3D  R (getDirection(*track));
        const JLine1Z      tz(getPosition (*track).rotate(R), track->getT());
        JRange<double>     Z_m;
      
        if (track->hasW(JSTART_LENGTH_METRES)       && 
            track->getW(JSTART_LENGTH_METRES) > 0.0) {
          Z_m = JZRange(ZMin_m, ZMax_m + track->getW(JSTART_LENGTH_METRES));
        }
 
        const JModel<JLine1Z> match(tz, roadWidth_m, JRegressor_t::T_ns, Z_m);
 
        // hit selection based on start value
 
        buffer_type buffer;
        
        for (buffer_type::const_iterator i = data.begin(); i != data.end(); ++i) {
 
          hit_type hit(*i);
            
          hit.rotate(R);
 
          if (match(hit)) {
            buffer.push_back(hit);
          }
        }
        
        // select first hit
 
        std::map<int, int> mapString = input.mapString;
        
        std::set<int> stringSet;
        for (buffer_type::const_iterator i = buffer.begin(); i != buffer.end(); ++i) {
          auto it = mapString.find((*i).getModuleID());
          stringSet.insert(it->second);
        }
        
        const int number_of_hits = JLANG::getCount(JLANG::make_array(buffer.begin(), buffer.end(), &JHitW0::getPMTIdentifier));
        const int number_of_doms = JLANG::getCount(JLANG::make_array(buffer.begin(), buffer.end(), &JHitW0::getModuleIdentifier));
        const int number_of_lines = stringSet.size();
 
        const int NDF = number_of_hits - this->parameters.size();
        
        if (NDF > 0) {
 
          out.push_back(JFit(*track).add(JMUONFEATURES));
 
          // set additional values
 
          out.rbegin()->setW(JMUONFEATURES_NUMBER_OF_HITS      , number_of_hits);
          out.rbegin()->setW(JMUONFEATURES_NUMBER_OF_DOMS      , number_of_doms);
          out.rbegin()->setW(JMUONFEATURES_NUMBER_OF_LINES     , number_of_lines);
          
        }
      }
 
      // apply default sorter
      
      sort(out.begin(), out.end(), qualitySorter);
 
      copy(input.in.begin(), input.in.end(), back_inserter(out));
      
      return out;
    }
 
  };
}
 
#endif