JORCAShowerReconstruction.hh

Go to the documentation of this file.

#ifndef __JRECONSTRUCTION__JORCASHOWERRECONSTRUCTION__
#define __JRECONSTRUCTION__JORCASHOWERRECONSTRUCTION__
 
#include <string>
#include <iomanip>
 
#include "km3net-dataformat/online/JDAQEvent.hh"
#include "km3net-dataformat/online/JDAQSummaryslice.hh"
 
#include "JReconstruction/JEvt.hh"
#include "JReconstruction/JShowerPrefit.hh"
#include "JReconstruction/JShowerPrefitParameters_t.hh"
#include "JReconstruction/JShowerPointSimplex.hh"
#include "JReconstruction/JShowerPointSimplexParameters_t.hh"
#include "JReconstruction/JShowerPositionFit.hh"
#include "JReconstruction/JShowerPositionFitParameters_t.hh"
#include "JReconstruction/JShowerDirectionPrefit.hh"
#include "JReconstruction/JShowerDirectionPrefitParameters_t.hh"
#include "JReconstruction/JEnergyCorrection.hh"
#include "JReconstruction/JShowerFit.hh"
#include "JReconstruction/JShowerFitParameters_t.hh"
#include "JReconstruction/JShowerFeatures.hh"
 
 
#include "Jeep/JProperties.hh"
 
/**
 * \author mdejong
 */
 
namespace JRECONSTRUCTION {}
namespace JPP { using namespace JRECONSTRUCTION; }
 
namespace JRECONSTRUCTION {
 
  /**
   * ORCA shower reconstruction.
   */
  struct JORCAShowerReconstruction {
    /**
     * 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(position));
        properties.insert(gmake_property(direction));
        properties.insert(gmake_property(fit));
        properties.insert(gmake_property(features));
      }
 
      JShowerPrefitParameters_t           prefit;
      JShowerPointSimplexParameters_t     simplex;
      JShowerPositionFitParameters_t      position;
      JShowerDirectionPrefitParameters_t  direction;
      JShowerFitParameters_t              fit;
      JShowerFitParameters_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) :
        position (fileDescriptor, JTimeRange(parameters.position .TMin_ns, parameters.position .TMax_ns), parameters.position.TTS_ns),
        direction(fileDescriptor, JTimeRange(parameters.direction.TMin_ns, parameters.direction.TMax_ns)),
        fit      (fileDescriptor, JTimeRange(parameters.fit      .TMin_ns, parameters.fit      .TMax_ns)),
        features (fileDescriptor, JTimeRange(parameters.features .TMin_ns, parameters.features .TMax_ns))
      {}
 
      JShowerPositionFit    ::storage_type position;
      JShowerDirectionPrefit::storage_type direction;
      JShowerFit            ::storage_type fit;
      JShowerFeatures       ::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)
      {}
 
      JShowerPrefit         ::input_type  prefit;
      JShowerPointSimplex   ::input_type  simplex;
      JShowerPositionFit    ::input_type  position;
      JShowerDirectionPrefit::input_type  direction;
      JShowerFit            ::input_type  fit;
      JShowerFeatures       ::input_type  features;
 
    };
 
 
    /**
     * Constructor.
     *
     * \param  parameters         parameters
     * \param  storage            storage
     * \param  pmtParameters      PMT parameters
     * \param  correct            energy correction
     * \param  debug              debug
     */
    JORCAShowerReconstruction(const JParameters_t&     parameters,
                              const JStorage_t&        storage,
                              const JPMTParametersMap& pmtParameters,
                              const JEnergyCorrection& correct,
                              const int                debug) :
      prefit   (parameters.prefit,    debug),
      simplex  (parameters.simplex,   debug),
      position (parameters.position,  storage.position,  pmtParameters, debug),
      direction(parameters.direction, storage.direction, pmtParameters, debug),
      fit      (parameters.fit,       storage.fit,       pmtParameters, correct, debug),
      features (parameters.features,  storage.features,  pmtParameters, 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.position  = position .getInput(router, summary, event, JEvt(), coverage);
      input.direction = direction.getInput(router, summary, event, JEvt(), coverage);
      input.fit       = fit      .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;
 
      input.simplex.in   = prefit(input.prefit);
 
      apps.push_back(JSHOWERPREFIT);
 
      input.position.in  = simplex(input.simplex);
 
      apps.push_back(JSHOWERPOINTSIMPLEX);
 
      input.direction.in = position(input.position);
 
      apps.push_back(JSHOWERPOSITIONFIT);
 
      input.fit.in       = direction(input.direction);
 
      apps.push_back(JSHOWERDIRECTIONPREFIT);
 
      input.features.in  = fit(input.fit);
 
      apps.push_back(JSHOWERCOMPLETEFIT);
 
      JEvt out           = features(input.features);
 
      apps.push_back(JSHOWERFEATURES);
 
      for (JFIT::JEvt::iterator i = out.begin(); i != out.end(); ++i) {
        i->setStatus(i->getHistory().getStatus(apps) ? COMPLETE_CHAIN : INCOMPLETE_CHAIN);
      }
 
      return out;
    }
 
 
    JShowerPrefit           prefit;
    JShowerPointSimplex     simplex;
    JShowerPositionFit      position;
    JShowerDirectionPrefit  direction;
    JShowerFit              fit;
    JShowerFeatures         features;
 
  };
}
 
#endif