JOscParameter.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JOSCPARAMETER__
#define __JOSCPROB__JOSCPARAMETER__

#include "JLang/JException.hh"
#include "JLang/JParameter.hh"

#include "JTools/JGrid.hh"


/**
 * \author bjung, mdejong
 */

namespace JOSCPROB {}
namespace JPP { using namespace JOSCPROB; }

namespace JOSCPROB {
  
  using JLANG::JParameter;
  
  using JTOOLS::JGrid;
  
  
  /**
   * Abstract base class for oscillation parameter.
   */
  template<class T = double>
  struct JOscParameter :
    public JParameter<T>
  {
    typedef JParameter<T>                            JParameter_t;
    
    typedef typename JParameter_t::argument_type     argument_type;

    
    /**
     * Default constructor.
     */
    JOscParameter() :
      JParameter_t()
    {}


    /**
     * Constructor.
     *
     * \param  value           oscillation parameter value
     */
    explicit JOscParameter(argument_type value) :
      JParameter_t(value)
    {}


    /**
     * Assignment operator.
     *
     * \param  value           oscillation parameter value
     * \return                 oscillation parameter
     */
    JOscParameter<T>& operator=(argument_type value)
    {
      setValue(value);

      return *this;
    }


    /**
     * Set parameter.
     *
     * \param value            oscillation parameter value
     */
    void setValue(argument_type value)
    {
      using namespace JPP;

      JParameter_t::setValue(value);

      if (!this->is_valid()) {
        THROW(JValueOutOfRange, "JOscParameter<T>::setValue(): Given oscillation parameter is invalid " << value);
      }
    }
    
    
    /**
     * Check validity of oscillation parameter.
     *
     * \return                 true if valid; else false
     */
    virtual bool is_valid() const = 0;


    /**
     * Stream input.
     *
     * \param  in              input stream
     * \param  parameter       oscillation parameter
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JOscParameter<T>& parameter)
    {
      using namespace JPP;
      
      in >> static_cast<JParameter_t&>(parameter);

      if (!parameter.is_valid()) {
        THROW(JValueOutOfRange, "JOscParameter<T>::operator>>(): Given oscillation parameter is invalid " << parameter);
      }

      return in;
    }


    /**
     * Stream output.
     *
     * \param  out             output stream
     * \param  parameter       oscillation parameter
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JOscParameter<T>& parameter)
    {
      return out << static_cast<const JParameter_t&>(parameter);
    }
  };


  /**
   * Get size of given oscillation parameter grid.
   *
   * \param  grid              oscillation parameteter grid
   * \return                   size of oscillation parameter
   */
  inline size_t getSize(const JOscParameter<JGrid<double> >& grid)
  {
    return (grid.isDefined() ? grid.getValue().getSize() : 0);
  }
}

#endif