JEvtWeightFactorFunction.hh

Go to the documentation of this file.

#ifndef __JAANET__JEVTWEIGHTFACTORFUNCTION__
#define __JAANET__JEVTWEIGHTFACTORFUNCTION__
 
#include "km3net-dataformat/offline/Evt.hh"
 
#include "flux/Flux.hh"
 
#include "JLang/JClonable.hh"
 
#include "JAAnet/JEvtWeightFactor.hh"
#include "JAAnet/JFlux.hh"
#include "JAAnet/JDiffuseFlux.hh"
 
 
/**
 * \author bjung
 */
namespace JAANET {}
namespace JPP { using namespace JAANET; }
 
namespace JAANET {
  
  using JLANG::JClonable;
  
  
  /**
   * Implementation of event-weight factor interface.
   *
   * The first template argument refers to a function of which the copy constructor needs to be defined.
   * The second template argument corresponds to the desired event-weight factor interface class.
   */
  template<class JFunction_t,
           class JEvtWeightFactor_t>
  struct JEvtWeightFactorFunction final :
    public JClonable<JEvtWeightFactor_t, JEvtWeightFactorFunction<JFunction_t,
                                                                  JEvtWeightFactor_t> >
  {
    typedef JEvtWeightFactorFunction<JFunction_t, JEvtWeightFactor_t>  JEvtWeightFactorFunction_t;
    
    
    /** 
     * Constructor.
     *
     * \param  function          function for event-weight factor
     */
    JEvtWeightFactorFunction(const JFunction_t& function) :
      function(function)
    {}
 
    
    /**
     * Get weight-factor for given event.
     *
     * \param  evt               event
     * \return                   event-weight factor
     */
    double getFactor(const Evt& evt) const override final
    {
      return function(evt);
    }
    
    
  private:
    
    JFunction_t function; //!< event-weight factor object.
  };
 
 
  /**
   * Implementation of event-weight factor interface for diffuse flux objects.
   *
   * The template argument corresponds to a function of which the copy constructor needs to be defined.
   */
  template<class JDiffuseFluxFunction_t>
  struct JEvtWeightFactorFunction<JDiffuseFluxFunction_t, JDiffuseFlux> final :
    public JClonable<JDiffuseFlux, JEvtWeightFactorFunction<JDiffuseFluxFunction_t,
                                                            JDiffuseFlux> >
  {
    typedef JEvtWeightFactorFunction<JDiffuseFluxFunction_t, JDiffuseFlux>   JEvtWeightFactorFunction_t;
 
    
    /**
     * Constructor.
     *
     * \param  function          flux function
     */
    JEvtWeightFactorFunction(const JDiffuseFluxFunction_t& function) :
      function(function)
    {}
 
 
    /**
     * Get event-weight factor for given particle PDG-identifier, energy and zenith-angle.
     *
     * \param  type              PDG particle type
     * \param  log10E            logarithmic neutrino energy [GeV]
     * \param  costh             cosine zenith angle
     * \return                   event-weight factor
     */
    double dNdEdOmega(int    type,
                      double log10E,
                      double costh) const override final
    {
      return function.dNdEdOmega(type, log10E, costh);
    }
    
  private:
    
    JDiffuseFluxFunction_t function; //!< diffuse flux function object
  };
 
 
  /**
   * Specialisation of event-weight factor interface for atmospheric neutrino flux.
   */
  template<>
  struct JEvtWeightFactorFunction<Flux_Atmospheric, JDiffuseFlux> final :
    public JClonable<JDiffuseFlux, JEvtWeightFactorFunction<Flux_Atmospheric, JDiffuseFlux> >
  {
    typedef JEvtWeightFactorFunction<Flux_Atmospheric, JDiffuseFlux>   JEvtWeightFactorFunction_t;
    
 
    /**
     * Get event-weight factor for given particle PDG-identifier, energy and zenith-angle.
     *
     * \param  type              PDG particle type
     * \param  log10E            logarithmic neutrino energy [GeV]
     * \param  costh             cosine zenith angle
     * \return                   event-weight factor
     */
    double dNdEdOmega(int    type,
                      double log10E,
                      double costh) const override final
    {
      return flux.dNdEdOmega(type, log10E, costh);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) override final
    {
      return JFluxFunctionHelper(eqpars);
    }
    
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JEvtWeightFactor::getEquationParameters()) const override final
    {
      return JFluxFunctionHelper(eqpars);
    }
    
 
  private:
 
    /**
     * Auxiliary class for I/O of atmospheric neutrino flux function.
     */
    struct JFluxFunctionHelper :
      public JProperties
    {
      /**
       * Constructor.
       *
       * \param  eqpars        equation parameters 
       */
      JFluxFunctionHelper(const JEquationParameters& eqpars) :
        JProperties(eqpars, 1)
      {
        (*this)[JEvtWeightFactor::getTypeKey()] = "atmospheric neutrino flux";
      }
    };
    
    static const Flux_Atmospheric flux; //!< atmospheric flux function
  };
 
 
  const Flux_Atmospheric JEvtWeightFactorFunction<Flux_Atmospheric, JDiffuseFlux>::flux = Flux_Atmospheric(); //!< Atmospheric flux function initialisation
 
  
  /** Type alias for atmospheric flux function interface **/
  using JFluxAtmospheric = JEvtWeightFactorFunction<Flux_Atmospheric, JDiffuseFlux>;
  
 
  /** Type definition of event-weight factor pointer. */
  typedef double (*pEvtWeightFactor)(const Evt&);
 
 
  /** Type definition of flux function pointer. */
  using pFlux = pEvtWeightFactor;
  
  
  /**
   * Implementation of C-style event-weight factor.
   *
   * The template argument refers to the desired event-weight factor interface class.
   */
  template<class JEvtWeightFactor_t>
  struct JEvtWeightFactorFunction<pEvtWeightFactor, JEvtWeightFactor_t> final :
    public JClonable<JEvtWeightFactor_t, JEvtWeightFactorFunction<pEvtWeightFactor,
                                                                  JEvtWeightFactor_t> >
  {
    /** 
     * Constructor.
     *
     * \param  pFunction         pointer to event-weight factor
     */
    JEvtWeightFactorFunction(pEvtWeightFactor pFunction) :
      pFunction(pFunction)
    {}
    
    
    /**
     * Get weight-factor for given event.
     *
     * \param  evt               event
     * \return                   event-weight factor
     */
    double getFactor(const Evt& evt) const override final
    {
      return (*pFunction)(evt);
    }
    
  private:    
 
    pEvtWeightFactor pFunction; //!< Event-weight factor pointer.
  };
 
  
  /** Type definition of pointer to diffuse flux function. */
  typedef double (*pDiffuseFlux)(int, double, double);
 
    
  /**
   * Implementation of C-style diffuse flux event-weight factor.
   */
  template<>
  struct JEvtWeightFactorFunction<pDiffuseFlux, JDiffuseFlux> final :
    public JClonable<JDiffuseFlux, JEvtWeightFactorFunction<pDiffuseFlux,
                                                            JDiffuseFlux> >
  {
    /** 
     * Constructor.
     *
     * \param  pFunction         pointer to diffuse flux function
     */
    JEvtWeightFactorFunction(pDiffuseFlux pFunction) :
      pFunction(pFunction)
    {}
 
    
    /**
     * Get event-weight factor for given particle PDG-identifier, energy and zenith-angle.
     *
     * \param  type              PDG particle type
     * \param  log10E            logarithmic neutrino energy [GeV]
     * \param  costh             cosine zenith angle
     * \return                   event-weight factor
     */
    double dNdEdOmega(int    type,
                      double log10E,
                      double costh) const override final
    {
      return (*pFunction)(type, log10E, costh);
    }
    
  private:    
 
    pDiffuseFlux pFunction; //!< Pointer to diffuse flux function.
  };
  
 
 
  /**
   * Auxiliary method for creating an interface to an event-weight factor.
   *
   * \param  function             function object
   * \return                      event-weight factor interface
   */
  template<class JFunction_t, class JEvtWeightFactor_t = JEvtWeightFactor>
  inline JEvtWeightFactorFunction<JFunction_t, JEvtWeightFactor_t> make_weightFactor(const JFunction_t& function) {
    return JEvtWeightFactorFunction<JFunction_t, JEvtWeightFactor_t>(function);
  }  
 
 
  /**
   * Auxiliary method for creating an interface to an event-weight factor.
   *
   * \param  function             function pointer
   * \return                      event-weight factor interface
   */
  template<class JEvtWeightFactor_t = JEvtWeightFactor>
  inline JEvtWeightFactorFunction<pEvtWeightFactor, JEvtWeightFactor_t> make_weightFactor(pEvtWeightFactor function) {
    return JEvtWeightFactorFunction<pEvtWeightFactor, JEvtWeightFactor_t>(function);
  }
 
 
  /**
   * Auxiliary method for creating an interface to a flux function.
   *
   * \param  flux                 flux function object
   * \return                      flux function interface
   */
  template<class JFunction_t>
  inline JEvtWeightFactorFunction<JFunction_t, JFlux> make_fluxFunction(const JFunction_t& flux) {
    return JEvtWeightFactorFunction<JFunction_t, JFlux>(flux);
  }
 
 
  /**
   * Auxiliary method for creating an interface to a flux function.
   *
   * \param  flux                 flux function pointer
   * \return                      flux function interface
   */
  inline JEvtWeightFactorFunction<pFlux, JFlux> make_fluxFunction(pFlux flux) {
    return JEvtWeightFactorFunction<pFlux, JFlux>(flux);
  }
 
 
  /**
   * Auxiliary method for creating an interface to a diffuse flux function.
   *
   * \param  flux                 diffuse flux function object
   * \return                      diffuse flux function interface
   */
  template<class JFunction_t>
  inline JEvtWeightFactorFunction<JFunction_t, JDiffuseFlux> make_diffuseFluxFunction(const JFunction_t& flux) {
    return JEvtWeightFactorFunction<JFunction_t, JDiffuseFlux>(flux);
  }
 
 
  /**
   * Auxiliary method for creating an interface to a diffuse flux function.
   *
   * \param  flux                 diffuse flux function pointer
   * \return                      diffuse flux function interface
   */
  inline JEvtWeightFactorFunction<pDiffuseFlux, JDiffuseFlux> make_diffuseFluxFunction(pDiffuseFlux flux) {
    return JEvtWeightFactorFunction<pDiffuseFlux, JDiffuseFlux>(flux);
  }
}
 
#endif