JORCAReconstruction.hh

Go to the documentation of this file.

#ifndef __JRECONSTRUCTION__JORCARECONSTRUCTION__
#define __JRECONSTRUCTION__JORCARECONSTRUCTION__
 
#include <string>
#include <iomanip>
 
#include "km3net-dataformat/online/JDAQEvent.hh"
#include "km3net-dataformat/online/JDAQSummaryslice.hh"
 
#include "JReconstruction/JEvt.hh"
#include "JReconstruction/JORCAMuonReconstruction.hh"
#include "JReconstruction/JORCAShowerReconstruction.hh"
 
#include "Jeep/JProperties.hh"
 
/**
 * \author mdejong
 */
 
namespace JRECONSTRUCTION {}
namespace JPP { using namespace JRECONSTRUCTION; }
 
namespace JRECONSTRUCTION {
 
  /**
   * ORCA reconstruction.
   */
  struct JORCAReconstruction {
    /**
     * Energy correction.
     */
    struct JEnergyCorrection_t {
      /**
       * Default constructor.
       */
      JEnergyCorrection_t() :
        properties(JEquationParameters("=", "\n;", "", "#"))
      {
        properties["muon"]   = muon;
        properties["shower"] = shower;
      }
 
      JEnergyCorrection       muon;
      JShowerEnergyCorrection shower;
      
      JEEP::JProperties properties;
    };
  
 
    /**
     * Parameters.
     */
    struct JParameters_t {
      /**
       * Default constructor.
       */
      JParameters_t() :
        properties(JEquationParameters(".", "\n;", "", "#"))
      {
        properties["muon"]   = muon  .properties;
        properties["shower"] = shower.properties;
      }
 
      JORCAMuonReconstruction  ::JParameters_t muon;
      JORCAShowerReconstruction::JParameters_t shower;
 
      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) :
        muon  (fileDescriptor, parameters.muon),
        shower(fileDescriptor, parameters.shower)
      {}
 
      JORCAMuonReconstruction  ::JStorage_t muon;
      JORCAShowerReconstruction::JStorage_t shower;
    };
 
 
    /**
     * Input data type.
     */
    struct input_type :
      public JDAQEventHeader
    {
      /**
       * Default constructor.
       */
      input_type()
      {}
 
 
      /**
       * Constructor.
       *
       * \param  header         header
       */
      input_type(const JDAQEventHeader& header) :
        JDAQEventHeader(header)
      {}
 
      JORCAMuonReconstruction  ::input_type muon;
      JORCAShowerReconstruction::input_type shower;
    };
 
 
    /**
     * Constructor.
     *
     * \param  parameters         parameters
     * \param  storage            storage
     * \param  rates_Hz           K40 rates [Hz]
     * \param  pmtParameters      PMT parameters
     * \param  correct            energy correction
     * \param  debug              debug
     */
    JORCAReconstruction(const JParameters_t&       parameters,
                        const JStorage_t&          storage,
                        const JK40Rates&           rates_Hz,
                        const JPMTParametersMap&   pmtParameters,
                        const JEnergyCorrection_t& correct,
                        const int                  debug) :
      muon  (parameters.muon,   storage.muon,   rates_Hz, pmtParameters, correct.muon, debug),
      shower(parameters.shower, storage.shower, correct.shower, 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.muon   = muon  .getInput(router, summary, event, coverage);
      input.shower = shower.getInput(router, summary, event, coverage);
 
      return input;
    }
 
 
    /**
     * Fit function.
     *
     * \param  input         input data
     * \return               fit results
     */
    JEvt operator()(input_type& input)
    {
      JEvt out;
 
      out += muon  (input.muon);
      out += shower(input.shower);
 
      return out;
    }
 
 
    JORCAMuonReconstruction   muon;
    JORCAShowerReconstruction shower;
  };
}
 
#endif