JORCAMuonReconstruction.hh

Go to the documentation of this file.

#ifndef __JRECONSTRUCTION__JORCAMUONRECONSTRUCTION__
#define __JRECONSTRUCTION__JORCAMUONRECONSTRUCTION__
 
#include <string>
#include <iomanip>
 
#include "km3net-dataformat/online/JDAQEvent.hh"
#include "km3net-dataformat/online/JDAQSummaryslice.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 "Jeep/JProperties.hh"
 
/**
 * \author mdejong
 */
 
namespace JRECONSTRUCTION {}
namespace JPP { using namespace JRECONSTRUCTION; }
 
namespace JRECONSTRUCTION {
 
  /**
   * ORCA muon reconstruction.
   */
  struct JORCAMuonReconstruction {
    /**
     * 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(start));
        properties.insert(gmake_property(gandalf));
        properties.insert(gmake_property(start2));
        properties.insert(gmake_property(energy));
      }
 
      JMuonPrefitParameters_t   prefit;
      JMuonSimplexParameters_t  simplex;
      JMuonStartParameters_t    start;
      JMuonGandalfParameters_t  gandalf;
      JMuonStartParameters_t    start2;
      JMuonEnergyParameters_t   energy;
 
      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)),
        start2 (fileDescriptor, JTimeRange(parameters.start2 .TMin_ns, parameters.start2 .TMax_ns))
      {}
    
      JMuonGandalf::storage_type gandalf;
      JMuonStart  ::storage_type start;
      JMuonEnergy ::storage_type energy;
      JMuonStart  ::storage_type start2;
    };
 
 
    /**
     * 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;
      JMuonStart  ::input_type  start;
      JMuonGandalf::input_type  gandalf;
      JMuonStart  ::input_type  start2;
      JMuonEnergy ::input_type  energy;
    };
 
 
    /**
     * Constructor.
     *
     * \param  parameters         parameters
     * \param  storage            storage
     * \param  rates_Hz           K40 rates [Hz]
     * \param  correct            energy correction
     * \param  debug              debug
     */
    JORCAMuonReconstruction(const JParameters_t&     parameters,
                            const JStorage_t&        storage,
                            const JK40Rates&         rates_Hz,
                            const JEnergyCorrection& correct,
                            const int                debug) :
      prefit (parameters.prefit,  debug),
      simplex(parameters.simplex, debug),
      start  (parameters.start,   storage.start,   rates_Hz, debug),
      gandalf(parameters.gandalf, storage.gandalf, debug),
      start2 (parameters.start2,  storage.start2,  rates_Hz, debug),
      energy (parameters.energy,  storage.energy,  correct,  debug)
    {}
 
 
    /**
     * 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.start   = start  .getInput(router, summary, event, JEvt(), coverage);
      input.gandalf = gandalf.getInput(router, summary, event, JEvt(), coverage);
      input.start2  = start2 .getInput(router, summary, event, JEvt(), coverage);
      input.energy  = energy .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;
 
      JEvt out;
 
      {
        out = prefit(input.prefit);
 
        apps.push_back(JMUONPREFIT);
      }
      {
        input.simplex.in = out;
 
        out = simplex(input.simplex);
 
        apps.push_back(JMUONSIMPLEX);
      }
      {
        input.start.in = out;
 
        out = start(input.start);
 
        apps.push_back(JMUONSTART);
      }
      {
        input.gandalf.in = out;
 
        out = gandalf(input.gandalf);
 
        apps.push_back(JMUONGANDALF);
      }
      {
        input.start2.in = out;
 
        out = start(input.start2);
 
        apps.push_back(JMUONSTART);
      }
      {
        input.energy.in = out;
 
        out = energy(input.energy);
 
        apps.push_back(JMUONENERGY);
      }
      {
        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;
    JMuonStart    start;
    JMuonGandalf  gandalf;
    JMuonStart    start2;
    JMuonEnergy   energy;
  };
}
 
#endif