JMixingAngle.hh

Go to the documentation of this file.

#ifndef __JOSCPROB__JMIXINGANGLE__
#define __JOSCPROB__JMIXINGANGLE__

#include "JLang/JException.hh"

#include "JTools/JGrid.hh"

#include "JOscProb/JOscParameter.hh"


/**
 * \author bjung, mdejong
 */

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

namespace JOSCPROB {

  using JTOOLS::JGrid;
  

  /**
   * Implementation of oscillation mixing angle.
   */
  template<class T = double>
  struct JMixingAngle :
    public JOscParameter<T>
  {
    typedef JMixingAngle<T>                           JMixingAngle_t;
    typedef JOscParameter<T>                          JOscParameter_t;
    
    typedef typename JOscParameter_t::JParameter_t    JParameter_t;
    typedef typename JOscParameter_t::argument_type   argument_type;
    
    
    /**
     * Default constructor.
     */
    JMixingAngle() :
      JOscParameter_t()
    {}


    /**
     * Constructor.
     *
     * \param  value     mixing angle value [rad]
     */
    explicit JMixingAngle(argument_type value) :
      JOscParameter_t(value)
    {
      using namespace JPP;
      
      if (!is_valid()) {
        THROW(JValueOutOfRange, "JMixingAngle::JMixingAngle(): Invalid mixing angle " << value);
      }
    }


    /**
     * Assignment operator.
     *
     * \param  value      mixing angle value [rad]
     * \return            mixing angle
     */
    JMixingAngle_t& operator=(argument_type value)
    {
      this->setValue(value);

      return *this;
    }


    /**
     * Check validity of oscillation parameter.
     *
     * \return            true if valid; else false
     */
    bool is_valid() const override
    {
      const T& angle = this->getValue();
      
      return this->isDefined() ? !(angle < 0.0 || angle > M_PI / 2.0) : true;
    }


    /**
     * Auxiliary function to create a mixing angle parameter.
     *
     * \param  value             mixing angle value [rad]
     * \return                   mixing angle parameter
     */
    static JMixingAngle_t make_parameter(argument_type value)
    {
      return JMixingAngle_t(value);
    }
  };


  /**
   * Template specialization for parameter grid.
   */
  template<>
  struct JMixingAngle<JGrid<double> > :
    public JOscParameter<JGrid<double> >
  {
    typedef JGrid<double>                              JGrid_t;
    typedef JMixingAngle<JGrid_t>                      JMixingAngle_t;
    typedef JOscParameter<JGrid_t>                     JOscParameter_t;
    
    typedef typename JOscParameter_t::JParameter_t     JParameter_t;
    typedef typename JOscParameter_t::argument_type    argument_type;
    
    typedef typename JGrid_t::abscissa_type            abscissa_type;
    
    
    /**
     * Default constructor.
     */
    JMixingAngle()
    {}


    /**
     * Constructor.
     *
     * \param  grid       mixing angle parameter grid [rad]
     */
    explicit JMixingAngle(argument_type grid) :
      JOscParameter_t(grid)
    {
      using namespace JPP;
      
      if (!is_valid()) {
        THROW(JValueOutOfRange, "JMixingAngle::JMixingAngle(): Invalid mixing angle parameter grid " << grid);
      }
    }


    /**
     * Constructor.
     *
     * \param  nx         number of elements
     * \param  Xmin       lower limit
     * \param  Xmax       upper limit
     */
    JMixingAngle(const int            nx,
                 const abscissa_type& xmin,
                 const abscissa_type& xmax) :
      JOscParameter_t(JGrid_t(nx, xmin, xmax))
    {}


    /**
     * Constructor.
     *
     * \param  value      value
     */
    explicit JMixingAngle(const abscissa_type& value) :
      JMixingAngle(1, value, value)
    {}


    /**
     * Assignment operator.
     *
     * \param  value      mixing angle parameter grid [rad]
     * \return            mixing angle
     */
    JMixingAngle_t& operator=(argument_type grid)
    {
      this->setValue(grid);

      return *this;
    }
    
    
    /**
     * Check validity of oscillation parameter.
     *
     * \return            true if valid; else false
     */
    bool is_valid() const override
    {
      const abscissa_type minAngle = this->getValue().getXmin();
      const abscissa_type maxAngle = this->getValue().getXmax();      
      
      return (this->isDefined() ? !(minAngle < 0.0 || minAngle > M_PI / 2.0 ||
                                    maxAngle < 0.0 || maxAngle > M_PI / 2.0) : true);
    }


    /**
     * Auxiliary function to create a mixing angle parameter grid.
     *
     * \param  value             mixing angle value [rad]
     * \return                   mixing angle parameter grid
     */
    static JMixingAngle_t make_parameter(const abscissa_type& value)
    {
      return JMixingAngle_t(value);
    }
  };
}

#endif