JARCAMuonReconstruction.hh

Go to the documentation of this file.

#ifndef __JRECONSTRUCTION__JARCAMUONRECONSTRUCTION__
#define __JRECONSTRUCTION__JARCAMUONRECONSTRUCTION__
 
#include <string>
#include <iomanip>
 
#include "km3net-dataformat/online/JDAQEvent.hh"
#include "km3net-dataformat/online/JDAQSummaryslice.hh"
 
#include "JLang/JClock.hh"
 
#include "JReconstruction/JEvt.hh"
#include "JReconstruction/JMuonPrefit.hh"
#include "JReconstruction/JMuonPrefitParameters_t.hh"
#include "JReconstruction/JMuonSimplex.hh"
#include "JReconstruction/JMuonSimplexParameters_t.hh"
#include "JReconstruction/JMuonGandalf.hh"
#include "JReconstruction/JMuonGandalfParameters_t.hh"
#include "JReconstruction/JMuonStart.hh"
#include "JReconstruction/JMuonStartParameters_t.hh"
#include "JReconstruction/JEnergyCorrection.hh"
#include "JReconstruction/JMuonEnergy.hh"
#include "JReconstruction/JMuonEnergyParameters_t.hh"
#include "JReconstruction/JMuonFeatures.hh"
 
#include "Jeep/JProperties.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JRECONSTRUCTION {}
namespace JPP { using namespace JRECONSTRUCTION; }
 
namespace JRECONSTRUCTION {
 
  /**
   * ARCA muon reconstruction.
   */
  struct JARCAMuonReconstruction {
    /**
     * Parameters.
     */
    struct JParameters_t {
      /**
       * Default constructor.
       */
      JParameters_t() :
        properties(JEquationParameters(".", "\n;", "", "#"))
      {
        properties.insert(gmake_property(prefit));
        properties.insert(gmake_property(simplex));
        properties.insert(gmake_property(gandalf));
        properties.insert(gmake_property(start));
        properties.insert(gmake_property(energy));
        properties.insert(gmake_property(features));
      }
 
      JMuonPrefitParameters_t   prefit;
      JMuonSimplexParameters_t  simplex;
      JMuonGandalfParameters_t  gandalf;
      JMuonStartParameters_t    start;
      JMuonEnergyParameters_t   energy;
      JMuonGandalfParameters_t  features;
 
      JEEP::JProperties properties;
    };
 
 
    /**
     * Storage for PDFs.
     */
    struct JStorage_t {
      /**
       * Constructor.
       *
       * \param  fileDescriptor     PDF file descriptor
       * \param  parameters         parameters
       */
      JStorage_t(const std::string&   fileDescriptor,
                 const JParameters_t& parameters) :
        gandalf (fileDescriptor, JTimeRange(parameters.gandalf .TMin_ns, parameters.gandalf .TMax_ns), parameters.gandalf.TTS_ns),
        start   (fileDescriptor, JTimeRange(parameters.start   .TMin_ns, parameters.start   .TMax_ns)),
        energy  (fileDescriptor, JTimeRange(parameters.energy  .TMin_ns, parameters.energy  .TMax_ns)),
        features(fileDescriptor, JTimeRange(parameters.features.TMin_ns, parameters.features.TMax_ns), parameters.features.TTS_ns)
      {}
    
      JMuonGandalf::storage_type gandalf;
      JMuonStart  ::storage_type start;
      JMuonEnergy ::storage_type energy;
      JMuonGandalf::storage_type features;
    };
 
 
    /**
     * Input data type.
     */
    struct input_type :
      public JDAQEventHeader
    {
      /**
       * Default constructor.
       */
      input_type()
      {}
 
 
      /**
       * Constructor.
       *
       * \param  header         header
       */
      input_type(const JDAQEventHeader& header) :
        JDAQEventHeader(header)
      {}
 
      JMuonPrefit  ::input_type  prefit;
      JMuonSimplex ::input_type  simplex;
      JMuonGandalf ::input_type  gandalf;
      JMuonStart   ::input_type  start;
      JMuonEnergy  ::input_type  energy;
      JMuonFeatures::input_type  features;
    };
 
 
    /**
     * Constructor.
     *
     * \param  parameters         parameters
     * \param  storage            storage
     * \param  rates_Hz           K40 rates [Hz]
     * \param  pmtParameters      PMT parameters
     * \param  correct            energy correction
     * \param  debug              debug
     */
    JARCAMuonReconstruction(const JParameters_t&     parameters,
                            const JStorage_t&        storage,
                            const JK40Rates&         rates_Hz,
                            const JPMTParametersMap& pmtParameters,
                            const JEnergyCorrection& correct,
                            const int                debug) :
      prefit  (parameters.prefit,   debug),
      simplex (parameters.simplex,  debug),
      gandalf (parameters.gandalf,  storage.gandalf,  pmtParameters, debug),
      start   (parameters.start,    storage.start,    rates_Hz, debug),
      energy  (parameters.energy,   storage.energy,   pmtParameters, correct,  debug),
      features(parameters.features, storage.features, debug)
    {
      clock.resize(6);
 
      clock[0].setTitle("prefit");
      clock[1].setTitle("simplex");
      clock[2].setTitle("gandalf");
      clock[3].setTitle("start");
      clock[4].setTitle("energy");
      clock[5].setTitle("features");
    }
    
 
    /**
     * Get input data.
     *
     * \param  router        module router
     * \param  summary       summary data
     * \param  event         event
     * \param  coverage      coverage
     * \return               input data
     */
    input_type getInput(const JModuleRouter&  router,
                        const JSummaryRouter& summary,
                        const JDAQEvent&      event,
                        const coverage_type&  coverage) const
    {
      input_type input(event.getDAQEventHeader());
 
      input.prefit   = prefit  .getInput(router, event, coverage);
      input.simplex  = simplex .getInput(router, event, JEvt(), coverage);
      input.gandalf  = gandalf .getInput(router, summary, event, JEvt(), coverage);
      input.start    = start   .getInput(router, summary, event, JEvt(), coverage);
      input.energy   = energy  .getInput(router, summary, event, JEvt(), coverage);
      input.features = features.getInput(router, summary, event, JEvt(), coverage);
 
      return input;
    }
 
 
    /**
     * Fit function.
     *
     * \param  input         input data
     * \return               fit results
     */
    JEvt operator()(input_type& input)
    {
      std::vector<int> apps;
 
      {
        JLANG::JClock::sentry sentry(clock[0]);
 
        input.simplex.in  = prefit(input.prefit);
 
        apps.push_back(JMUONPREFIT);
      }
      {
        JLANG::JClock::sentry sentry(clock[1]);
 
        input.gandalf.in  = simplex(input.simplex);
 
        apps.push_back(JMUONSIMPLEX);
      }
      {
        JLANG::JClock::sentry sentry(clock[2]);
 
        input.start.in    = gandalf(input.gandalf);
 
        apps.push_back(JMUONGANDALF);
      }
      {
        JLANG::JClock::sentry sentry(clock[3]);
 
        input.energy.in   = start(input.start);
 
        apps.push_back(JMUONSTART);
      }
      {
        JLANG::JClock::sentry sentry(clock[4]);
 
        input.features.in = energy(input.energy);
 
        apps.push_back(JMUONENERGY);
      }
 
      JLANG::JClock::sentry sentry(clock[5]);
 
      JEvt out = features(input.features);
 
      apps.push_back(JMUONFEATURES);
 
      for (JFIT::JEvt::iterator i = out.begin(); i != out.end(); ++i) {
        i->setStatus(i->getHistory().getStatus(apps) ? COMPLETE_CHAIN : INCOMPLETE_CHAIN);
      }
 
      return out;
    }
 
    JMuonPrefit   prefit;
    JMuonSimplex  simplex;
    JMuonGandalf  gandalf;
    JMuonStart    start;
    JMuonEnergy   energy;
    JMuonFeatures features;
 
    std::vector<JLANG::JClock> clock;
  };
}
 
#endif