JOscProbHelper.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JOSCPROBHELPER__
#define __JOSCPROB__JOSCPROBHELPER__
 
#include <memory>
 
#include "JSystem/JStat.hh"
 
#include "JLang/JEquation.hh"
#include "JLang/JException.hh"
#include "JLang/JStringStream.hh"
 
#include "Jeep/JProperties.hh"
 
#include "JOscProb/JOscChannel.hh"
#include "JOscProb/JOscParameters.hh"
#include "JOscProb/JOscProbInterface.hh"
 
 
/**
 * \author bjung
 */
 
namespace JOSCPROB {}
namespace JPP { using namespace JOSCPROB; }
 
namespace JOSCPROB {
  
  /**
   * Helper class for oscillation probability calculators.
   */
  struct JOscProbHelper :
    public std::shared_ptr<JOscProbInterface>
  {
    typedef typename JOscProbInterface::JOscParameters_t            JOscParameters_t;
    typedef typename JOscProbInterface::JOscParameterReferences_t   JOscParameterReferences_t;
    typedef typename JOscProbInterface::JParameter_t                JParameter_t;
 
    typedef typename JOscProbInterface::argument_type               argument_type;
    typedef typename JOscProbInterface::value_type                  value_type;
 
    typedef std::shared_ptr<JOscProbInterface>                      pointer_type;
    
 
    /**
     * Default constructor.
     */
    JOscProbHelper()
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  pOscProb            shared pointer to oscillation probability function
     */
    JOscProbHelper(const pointer_type& pOscProb) :
      pointer_type(pOscProb)
    {}
 
 
    /**
     * Constructor.
     *
     * \param  oscProb             oscillation probability function
     */
    JOscProbHelper(const JOscProbInterface& oscProb)
    {
      configure(oscProb);
    }
 
 
    /**
     * Configure oscillation probability function.
     *
     * \param  pOscProb            shared pointer to oscillation probability function
     */    
    void configure(const pointer_type& pOscProb)
    {
      static_cast<pointer_type&>(*this) = pOscProb;
    }
 
 
    /**
     * Configure oscillation probability function.
     *
     * \param  oscProb             oscillation probability function
     */
    void configure(const JOscProbInterface& oscProb)
    {
      this->reset(oscProb.clone());
    }
 
 
    /**
     * Get reference to oscillation probability interface.
     *
     * \return                 oscillation parameters
     */
    JOscProbInterface& getOscProbInterface() const
    {
      using namespace JPP;
 
      if (static_cast<const JOscProbHelper&>(*this)) {
        return *(this->get());
      } else {
        THROW(JNullPointerException, "JOscProbHelper::getOscProbInterface(): Oscillation probability interface is not set.");
      }
    }
 
 
    /**
     * Get reference to oscillation parameters interface.
     *
     * \return                 reference to oscillation parameters interface
     */
    JOscParameterReferences_t& getParameters() const
    {
      return getOscProbInterface().getParameters();
    }
 
 
    /**
     * Set oscillation parameters.
     *
     * \param  parameters      oscillation parameters
     */
    void set(const JOscParameters_t& parameters) const
    {
      return getParameters().set(parameters);
    }
 
 
    /**
     * Set value for a given oscillation parameter.
     *
     * \param  name            parameter name
     * \param  value           parameter value
     */
    void set(const std::string& name,
             const value_type&  value) const
    {
      getParameters().set(name, value);
    }
 
 
    /**
     * Set value for given list of oscillation parameters.
     *
     * \param  name            parameter name
     * \param  value           parameter value
     * \param  args            remaining pairs of parameter names and values
     */
    template<class ...Args>
    void set(const std::string& name,
             const value_type&  value,
             const Args&     ...args) const
    {
      getParameters().set(name, value, args...);
    }
 
 
    /**
     * Get cosine zenith angle for a given baseline.
     *
     * \param  L                  baseline [km]
     * \return                    cosine zenith angle
     */
    double getCosth(const double L) const
    {
      return getOscProbInterface().getCosth(L);
    }
 
 
    /**
     * Get baseline for a given cosine zenith angle.
     *
     * \param  costh              cosine zenith angle
     * \return                    baseline [km]
     */
    double getBaseline(const double costh) const
    {
      return getOscProbInterface().getBaseline(costh);
    }
 
 
    /**
     * Get oscillation probability corresponding to given oscillation channel,
     * neutrino energy and zenith angle.
     *
     * \param  channel             oscillation channel
     * \param  energy              neutrino energy [GeV]
     * \param  costh               cosine zenith angle
     * \return                     oscillation probability
     */
    double getP(const JOscChannel& channel,
                const double       energy,
                const double       costh) const
    {
      return getOscProbInterface().getP(channel, energy, 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  energy             neutrino energy [GeV]
     * \param  costh              cosine zenith angle
     * \return                    oscillation probability
     */
    double getP(const JOscParameters_t& parameters,
                const JOscChannel&      channel,
                const double            energy,
                const double            costh) const
    {
      return getOscProbInterface().getP(parameters, channel, energy, 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
    {
      return getOscProbInterface().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 getP(const std::string& name,
                const double       value,
                const Args&     ...args) const
    {
      return getOscProbInterface().getP(name, value, args...);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JOscProbInterface::getEquationParameters())
    {
      return getOscProbInterface().getProperties(eqpars);
    }
 
 
    /**
     * Get properties of this class.
     *
     * \param  eqpars          equation parameters
     */
    JProperties getProperties(const JEquationParameters& eqpars = JOscProbInterface::getEquationParameters()) const
    {
      return getOscProbInterface().getProperties(eqpars);
    }
 
 
    /**
     * Read from input.
     *
     * Input syntax according to one of the following options:
     *   1. <tt><oscprob_file></tt>,
     *   2. <tt>oscprob=<oscprob_file></tt>,
     *   3. <tt><oscprob_key>=<oscprob_value>[<end of line> <oscprob_key>=<oscprob_value> ...]</tt> or
     *   4. <tt>oscprob.<oscprob_key>=<oscprob_value>[<end of line> oscprob.<oscprob_key>=<oscprob_value> ...]</tt>,
     * where:
     *   - <tt>oscprob_key</tt> refers to an oscillation probability calculator configuration key;
     *   - <tt>oscprob_value</tt>      to an oscillation probability calculator configuration value;
     *   - <tt>oscprob_file</tt>       to an oscillation probability calculator configuration file with key-value pairs.
     *
     * \param  in                 input stream
     * \param  object             object
     * \return                    input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JOscProbHelper& object)
    {
      using namespace std;
      using namespace JPP;
    
      static const char* KEYWORD = "oscprob";
 
      if (!object) { return in; }
 
      JStringStream is(in);
 
      if (getFileStatus(is.str().c_str())) {
        is.load();
      }
 
      const streampos         pos   = is.tellg();
      const ios_base::iostate state = is.rdstate();
      
      JProperties properties1 = object.getProperties();
      
      const JEquationFacet facet(JOscProbInterface::getEquationParameters());
      
      is.imbue(locale(is.getloc(), facet.clone()));
      
      JEquation equation;
      is >> equation;
 
      if (equation.getKey() == KEYWORD) {
        
        if (getFileStatus(equation.getValue().c_str())) {
                                
          properties1.getEndOfLine() += '\n';
        
          ifstream ifs(equation.getValue().c_str());
 
          ifs >> properties1;
        
          ifs.close();
 
        } else {
 
          is.clear(state);
          is.seekg(pos);
 
          JProperties properties2;
            
          properties2[KEYWORD] = properties1;
 
          is >> properties2;
        }
        
      } else if (!equation.getValue().empty()) {
 
        is.clear(state);
        is.seekg(pos);
 
        is >> properties1;
        
      } else {
 
        is.setstate(ios::badbit);
      }
 
      return in;
    }
 
 
    /** 
     * Write to output.
     *
     * \param  out                output stream
     * \param  object             object
     * \return                    output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JOscProbHelper& object)
    {
      if (object) {
        out << object.getProperties();
      }
 
      return out;
    }
  };
}
 
#endif