JOscProbInterface.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JOSCPROBINTERFACE__
#define __JOSCPROB__JOSCPROBINTERFACE__
 
#include <memory>
 
#include "JSystem/JStat.hh"
 
#include "JLang/JClonable.hh"
#include "JLang/JException.hh"
#include "JLang/JStringStream.hh"
#include "JLang/JEquationParameters.hh"
 
#include "JOscProb/JOscChannel.hh"
#include "JOscProb/JOscParametersHelper.hh"
#include "JOscProb/JBaselineComputerInterface.hh"
 
 
/**
 * \author bjung, mdejong
 */
 
namespace JOSCPROB {}
namespace JPP { using namespace JOSCPROB; }
 
namespace JOSCPROB {
 
  using JLANG::JClonable;
 
 
  /**
   * Low-level interface for oscillation probability calculators.
   */
  class JOscProbInterface :
    public JBaselineComputerInterface,
    public JOscParametersHelper<double&>,
    public JClonable<JOscProbInterface>
  {
  public:
 
    typedef JOscParametersHelper<double&>                        JOscParametersHelper_t;
 
    typedef JOscParametersInterface<double>                      JOscParameters_t;
    typedef JOscParametersInterface<double&>                     JOscParameterReferences_t;
    
    typedef typename JOscParameters_t::JOscParameter_t           JOscParameter_t;    
    typedef typename JOscParameters_t::JParameter_t              JParameter_t;
    
 
    /**
     * Default constructor.
     */
    JOscProbInterface()
    {}
 
 
    /**
     * Constructor.
     *
     * \param  parameters         oscillation parameters
     */
    JOscProbInterface(const JOscParameterReferences_t& parameters) :
      JOscParametersHelper_t(parameters)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  parameters         oscillation parameters
     * \param  name               parameter name
     * \param  value              parameter value
     * \param  args               remaining pairs of parameter names and values
     */
    template<class ...Args>
    JOscProbInterface(const JOscParameterReferences_t& parameters,
                      const std::string&               name,
                      double&                          value,
                      const Args&                   ...args) :
      JOscParametersHelper_t(parameters, name, value, args...)
    {}
 
 
    /**
     * Virtual destructor.
     */
    virtual ~JOscProbInterface()
    {}
 
 
    /**
     * Get type keyword.
     *
     * \return                 type keyword
     */
    static const char* const getTypeKey()
    {
      return "type";
    }
 
 
    /**
     * Get oscillation probability for a given oscillation channel.
     *
     * \param  channel            oscillation channel
     * \param  E                  neutrino energy [GeV]
     * \param  costh              cosine zenith angle
     * \return                    oscillation probability
     */
    virtual double getP(const JOscChannel&    channel,
                        const double          E,
                        const double          costh) const = 0;
 
 
    /**
     * Get oscillation probability for a given set of oscillation parameters\n
     * and a given oscillation channel.
     *
     * \param  channel            oscillation channel
     * \param  parameters         oscillation parameters
     * \param  E                  neutrino energy [GeV]
     * \param  costh              cosine zenith angle
     * \return                    oscillation probability
     */
    double getP(const JOscParameters_t& parameters,
                const JOscChannel&      channel,
                const double            E,
                const double            costh) const
    {
      this->set(parameters);
 
      return getP(channel, E, costh);      
    }
 
 
    /**
     * Get oscillation probability for a given oscillation parameter\n
     * and a given oscillation channel.
     *
     * \param  name               parameter name
     * \param  value              parameter value
     * \param  channel            oscillation channel
     * \param  E                  neutrino energy [GeV]
     * \param  costh              cosine zenith angle
     * \return                    oscillation probability
     */
    double getP(const std::string& name,
                const double       value,
                const JOscChannel& channel,
                const double       E,
                const double       costh) const
    {
      this->set(name, value);
 
      return getP(channel, E, costh);
    }
    
 
    /**
     * Get oscillation probability for a given set of oscillation parameters\n
     * and a given oscillation channel.
     *
     * \param  name               parameter name
     * \param  value              parameter value
     * \param  args               remaining arguments
     */
    template<class ...Args>
    double getP(const std::string& name,
                const double       value,
                const Args&     ...args) const
    {
      this->set(name, value);
      
      return getP(args...);
    }
 
    
    /**
     * Get oscillation probability for a given oscillation channel.
     *
     * \param  channel            oscillation channel
     * \param  E                  neutrino energy [GeV]
     * \param  costh              cosine zenith angle
     * \return                    oscillation probability
     */
    double operator()(const JOscChannel&    channel,
                      const double          E,
                      const double          costh) const
    {
      return getP(channel, E, costh);
    }
    
    
    /**
     * Get oscillation probability for a given set of oscillation parameters\n
     * and a given oscillation channel.
     *
     * \param  channel            oscillation channel
     * \param  parameters         oscillation parameters
     * \param  E                  neutrino energy [GeV]
     * \param  costh              cosine zenith angle
     * \return                    oscillation probability
     */
    double operator()(const JOscParameters_t& parameters,
                      const JOscChannel&      channel,
                      const double            E,
                      const double            costh) const
    {
      return getP(parameters, channel, E, costh);
    }
 
 
    /**
     * Get oscillation probability for a given oscillation parameter\n
     * and a given oscillation channel.
     *
     * \param  name               parameter name
     * \param  value              parameter value
     * \param  channel            oscillation channel
     * \param  E                  neutrino energy [GeV]
     * \param  costh              cosine zenith angle
     * \return                    oscillation probability
     */
    double operator()(const std::string& name,
                      const double       value,
                      const JOscChannel& channel,
                      const double       E,
                      const double       costh) const
    {
      return getP(name, value, channel, E, costh);
    }
 
 
    /**
     * Get oscillation probability for a given set of oscillation parameters\n
     * and a given oscillation channel.
     *
     * \param  name               parameter name
     * \param  value              parameter value
     * \param  args               remaining arguments
     */
    template<class ...Args>    
    double operator()(const std::string& name,
                      const double       value,
                      const Args&     ...args) const
    {
      return getP(name, value, args...);
    }
 
 
    /**
     * Get equation parameters.
     *
     * \return                 equation parameters
     */
    static inline JEquationParameters& getEquationParameters()
    {
      static JEquationParameters equation("=", "\n\t\v\f\r, ", "./", "#");
       
      return equation;
    }    
 
 
    /**
     * Set equation parameters.
     *
     * \param  eqpars          equation parameters
     */
    static inline void setEquationParameters(const JEquationParameters& eqpars)
    {
      getEquationParameters() = eqpars;
    }
 
 
    /**
     * Read configuration of oscillation probability calculator from input.
     *
     * \param  in                 input stream
     * \return                    input stream
     */
    virtual std::istream& read(std::istream& in)
    {
      using namespace std;
      using namespace JPP;
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
      
      is >> getProperties();
      
      return in;
    }
 
 
    /**
     * Write configuration of oscillation probability calculator to output.
     *
     * \param  out                output stream
     * \return                    output stream
     */
    virtual std::ostream& write(std::ostream& out) const
    {
      return out << getProperties();
    }
 
    
    /**
     * Read oscillation probability calculator from input.
     *
     * \param  in                 input stream
     * \param  object             oscillation probability calculator
     * \return                    input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JOscProbInterface& object)
    {
      return object.read(in);
    }
 
 
    /** 
     * Write oscillation probability calculator to output.
     *
     * \param  out                output stream
     * \param  object             oscillation probability calculator
     * \return                    output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JOscProbInterface& object)
    {
      return object.write(out);
    }
  };
}
 
#endif