Preliminary implementation of new model parameter interface.

A new model parameter interface has been implemented that puts the internal workings of the class more in the background. For example, the real_xxx() methods have been replaced by Xxx() methods, and the xxx() methods became factor_xxx(). For example, real_value() becomes Value() and value() becomes factor_value(). For the moment, upper case letters are used so that no mix with the former xxx() methods occur. This is for validating the change, and will be modified in a future commit.

Preliminary implementation of new model parameter interface.
A new model parameter interface has been implemented that puts the internal workings of the class more in the background. For example, the real_xxx() methods have been replaced by Xxx() methods, and the xxx() methods became factor_xxx(). For example, real_value() becomes Value() and value() becomes factor_value(). For the moment, upper case letters are used so that no mix with the former xxx() methods occur. This is for validating the change, and will be modified in a future commit.
Jürgen Knödlseder
1 parent 15c02402
Showing 3 changed files with 635 additions and 268 deletions
include/GModelPar.hpp
pyext/GModelPar.i
src/model/GModelPar.cpp
@@ -38,70 +38,116 @@
  *
  * @brief Model parameter class
  *
- * This method implements a model parameter. The model parameter is
- * factorised into a "value" and a "scale" factor, the real parameter value
- * being the product of both. Parameter optimization is only done on the
- * "value" part of the parameter. This allows scaling of the parameter to
- * have a "value" around unity (which makes the optimizer routines better
- * behave). Methods that work on the real value (i.e. the product of
- * "value" and "scale") are prefixed with "real_".
+ * This class implements a model parameter. A model parameter is a numerical
+ * value that is used to describe a model. A model parameter has the
+ * following attributes:
+ * - @p value gives the numerical value of the parameter
+ * - @p error gives the statistical uncertainty in the parameter value
+ * - @p gradient gives the gradient of a the model with respect to the
+ *      parameter
+ * - @p min gives the minimum value that the parameter value can take
+ * - @p max gives the maximum value that the parameter value can take
  *
- * The parameter "value" can optionally by bounded by a minimum and/or
- * maximum value. Note that the boundaries apply to "value".
+ * The parameter attributes are set and retrieved using the value(),
+ * error(), gradient(), min() and max() methods, respectively. Furthermore,
+ * the range() method is used to simultaneously set the minimum and maximum
+ * value of a parameter.
  *
- * Each parameter has a name, and holds optionally information about its
- * gradient (if "hasgrad" is true).
+ * The minimum and maximum values are optional, and existence of these
+ * attributes is tested using the hasmin() and hasmax() methods,
+ * respectively. The minimum value, maximum value are removed using the
+ * remove_min() and remove_max() methods. Simultaneous removal of minimum
+ * and maximum values is done using the remove_range() method.
+ *
+ * Each parameter has furthermore the following properties:
+ * - @p free specifies whether the parameter should be fitted
+ * - @p grad specifies whether the parameter gradient is computed
+ *      analytically (true) or numerically (false)
+ *
+ * The parameter property @p free is set using the free() and fix()
+ * methods and it is retrieved using the isfree() and isfixed() methods.
+ * The attribute @p grad is set and retrieved using the has hasgrad()
+ * methods.
+ *
+ * Each model parameter is factorized into a @p factor and a @p scale
+ * term. The GModelPar class stores the factors and the scale factor has
+ * data members, and the true values are computed using the following
+ * relations:
+ *
+ *     value    = m_factor_value    * m_scale
+ *     error    = m_factor_error    * m_scale
+ *     gradient = m_factor_gradient * m_scale
+ *     min      = m_factor_min      * m_scale
+ *     max      = m_factor_max      * m_scale
+ *
+ * The @p factor and @p scale terms can be set and retrieved using the
+ * factor_value(), factor_error(), factor_gradient(), factor_min(),
+ * factor_max() and scale() methods.
  ***************************************************************************/
 class GModelPar : public GBase {
 public:
     // Constructors and destructors
     GModelPar(void);
-    GModelPar(const std::string& name, const double& value, 
-              const double& scale = 1.0);
+    explicit GModelPar(const std::string& name, const double& value, int i);
+    explicit GModelPar(const std::string& name, const double& factor, const double& scale);
     GModelPar(const GModelPar& par);
     virtual ~GModelPar(void);
     // Operators
     GModelPar& operator=(const GModelPar& par);
-    // Methods
-    void        clear(void);
-    GModelPar*  clone(void) const;
-    std::string name(void) const { return m_name; }
-    std::string unit(void) const { return m_unit; }
-    double      real_value(void) const { return m_value*m_scale; }
-    double      real_error(void) const { return m_error*m_scale; }
-    double      real_gradient(void) const { return m_gradient*m_scale; }
-    double      real_min(void) const { return m_min*m_scale; }
-    double      real_max(void) const { return m_max*m_scale; }
-    double      value(void) const { return m_value; }
-    double      error(void) const { return m_error; }
-    double      gradient(void) const { return m_gradient; }
-    double      min(void) const { return m_min; }
-    double      max(void) const { return m_max; }
-    double      scale(void) const { return m_scale; }
-    bool        isfree(void) const { return m_free; }
+    // Attribute methods 
+    double      Value(void) const;
+    double      Error(void) const { return m_factor_error*m_scale; }
+    double      Gradient(void) const { return m_factor_gradient*m_scale; }
+    double      Min(void) const { return m_factor_min*m_scale; }
+    double      Max(void) const { return m_factor_max*m_scale; }
+    void        Value(const double& value);
+    void        Error(const double& error);
+    void        Gradient(const double& gradient);
+    void        Min(const double& min);
+    void        Max(const double& max);
+    void        Range(const double& min, const double& max);
+
+    // Factorization methods
+    const double& factor_value(void) const { return m_factor_value; }
+    const double& factor_error(void) const { return m_factor_error; }
+    const double& factor_gradient(void) const { return m_factor_gradient; }
+    const double& factor_min(void) const { return m_factor_min; }
+    const double& factor_max(void) const { return m_factor_max; }
+    const double& scale(void) const { return m_scale; }
+    void          factor_value(const double& value);
+    void          factor_error(const double& error) { m_factor_error=error; }
+    void          factor_gradient(const double& gradient) { m_factor_gradient=gradient; }
+    void          factor_min(const double& min);
+    void          factor_max(const double& max);
+    void          factor_range(const double& min, const double& max);
+    void          Scale(const double& scale);
+
+    // Boundary methods
     bool        hasmin(void) const { return m_hasmin; }
     bool        hasmax(void) const { return m_hasmax; }
-    bool        hasgrad(void) const { return m_hasgrad; }
-    void        name(const std::string& name) { m_name=name; }
-    void        unit(const std::string& unit) { m_unit=unit; }
-    void        real_value(const double& value);
-    void        real_error(const double& error);
-    void        value(const double& value);
-    void        error(const double& error)  { m_error=error; }
-    void        gradient(const double& gradient) { m_gradient=gradient; }
-    void        min(const double& min);
-    void        max(const double& max);
-    void        scale(const double& scale) { m_scale=scale; }
-    void        range(const double& min, const double& max);
+    bool        hasrange(void) const { return m_hasmin && m_hasmax; }
     void        remove_min(void) { m_hasmin=false; }
     void        remove_max(void) { m_hasmax=false; }
     void        remove_range(void) { m_hasmin=false; m_hasmax=false; }
+
+    // Property methods
+    bool        isfree(void) const { return m_free; }
+    bool        isfixed(void) const { return !m_free; }
+    bool        hasgrad(void) const { return m_hasgrad; }
     void        free(void) { m_free=true; }
     void        fix(void) { m_free=false; }
     void        hasgrad(const bool& grad) { m_hasgrad=grad; }
+
+    // Other methods
+    void        clear(void);
+    GModelPar*  clone(void) const;
+    std::string name(void) const { return m_name; }
+    std::string unit(void) const { return m_unit; }
+    void        name(const std::string& name) { m_name=name; }
+    void        unit(const std::string& unit) { m_unit=unit; }
     void        autoscale(void);
     void        read(const GXmlElement& xml);
     void        write(GXmlElement& xml) const;
@@ -114,18 +160,32 @@ protected:
     void free_members(void);
     // Proteced data members
-    std::string m_name;      //!< Parameter name
-    std::string m_unit;      //!< Parameter unit
-    double      m_value;     //!< Parameter value
-    double      m_error;     //!< Uncertainty in parameter value
-    double      m_gradient;  //!< Model gradient
-    double      m_min;       //!< Parameter minimum
-    double      m_max;       //!< Parameter maximum
-    double      m_scale;     //!< Parameter scale (real = m_value * m_scale)
-    bool        m_free;      //!< Parameter is free
-    bool        m_hasmin;    //!< Parameter has minimum boundary
-    bool        m_hasmax;    //!< Parameter has maximum boundary
-    bool        m_hasgrad;   //!< Parameter has analytic gradient
+    std::string m_name;            //!< Parameter name
+    std::string m_unit;            //!< Parameter unit
+    double      m_factor_value;    //!< Parameter value factor
+    double      m_factor_error;    //!< Uncertainty in parameter value factor
+    double      m_factor_gradient; //!< Model gradient factor
+    double      m_factor_min;      //!< Parameter minimum factor
+    double      m_factor_max;      //!< Parameter maximum factor
+    double      m_scale;           //!< Parameter scaling (true = factor * scale)
+    bool        m_free;            //!< Parameter is free
+    bool        m_hasmin;          //!< Parameter has minimum boundary
+    bool        m_hasmax;          //!< Parameter has maximum boundary
+    bool        m_hasgrad;         //!< Parameter has analytic gradient
 };
+
+/***********************************************************************//**
+ * @brief Return parameter value
+ *
+ * @return True parameter value.
+ *
+ * Returns the true parameter value
+ ***************************************************************************/
+inline
+double GModelPar::Value(void) const
+{
+    return (m_factor_value*m_scale);
+}
+
 #endif /* GMODELPAR_HPP */
@@ -40,48 +40,61 @@ class GModelPar : public GBase {
 public:
     // Constructors and destructors
     GModelPar(void);
-    GModelPar(const std::string& name, const double& value, 
-              const double& scale = 1.0);
-    GModelPar(const GModelPar& par);
+    explicit GModelPar(const std::string& name, const double& value, int i);
+    explicit GModelPar(const std::string& name, const double& factor, const double& scale);
     virtual ~GModelPar(void);
-    // Methods
+    // Attribute methods 
+    double      Value(void) const;
+    double      Error(void) const { return m_factor_error*m_scale; }
+    double      Gradient(void) const { return m_factor_gradient*m_scale; }
+    double      Min(void) const { return m_factor_min*m_scale; }
+    double      Max(void) const { return m_factor_max*m_scale; }
+    void        Value(const double& value);
+    void        Error(const double& error);
+    void        Gradient(const double& min);
+    void        Min(const double& min);
+    void        Max(const double& max);
+    void        Range(const double& min, const double& max);
+
+    // Factorization methods
+    const double& factor_value(void) const { return m_factor_value; }
+    const double& factor_error(void) const { return m_factor_error; }
+    const double& factor_gradient(void) const { return m_factor_gradient; }
+    const double& factor_min(void) const { return m_factor_min; }
+    const double& factor_max(void) const { return m_factor_max; }
+    const double& scale(void) const { return m_scale; }
+    void          factor_value(const double& value);
+    void          factor_error(const double& error) { m_factor_error=error; }
+    void          factor_gradient(const double& gradient) { m_factor_gradient=gradient; }
+    void          factor_min(const double& min);
+    void          factor_max(const double& max);
+    void          factor_range(const double& min, const double& max);
+    void          Scale(const double& scale);
+
+    // Boundary methods
+    bool        hasmin(void) const { return m_hasmin; }
+    bool        hasmax(void) const { return m_hasmax; }
+    bool        hasrange(void) const { return m_hasmin && m_hasmax; }
+    void        remove_min(void) { m_hasmin=false; }
+    void        remove_max(void) { m_hasmax=false; }
+    void        remove_range(void) { m_hasmin=false; m_hasmax=false; }
+
+    // Property methods
+    bool        isfree(void) const { return m_free; }
+    bool        isfixed(void) const { return !m_free; }
+    bool        hasgrad(void) const { return m_hasgrad; }
+    void        free(void) { m_free=true; }
+    void        fix(void) { m_free=false; }
+    void        hasgrad(const bool& grad) { m_hasgrad=grad; }
+
+    // Other methods
     void        clear(void);
     GModelPar*  clone(void) const;
-    std::string name(void) const;
-    std::string unit(void) const;
-    double      real_value(void) const;
-    double      real_error(void) const;
-    double      real_gradient(void) const;
-    double      real_min(void) const;
-    double      real_max(void) const;
-    double      value(void) const;
-    double      error(void) const;
-    double      gradient(void) const;
-    double      min(void) const;
-    double      max(void) const;
-    double      scale(void) const;
-    bool        isfree(void) const;
-    bool        hasmin(void) const;
-    bool        hasmax(void) const;
-    bool        hasgrad(void) const;
-    void        name(const std::string& name);
-    void        unit(const std::string& unit);
-    void        real_value(const double& value);
-    void        real_error(const double& error);
-    void        value(const double& value);
-    void        error(const double& error);
-    void        gradient(const double& gradient);
-    void        min(const double& min);
-    void        max(const double& max);
-    void        scale(const double& scale);
-    void        range(const double& min, const double& max);
-    void        remove_min(void);
-    void        remove_max(void);
-    void        remove_range(void);
-    void        free(void);
-    void        fix(void);
-    void        hasgrad(const bool& grad);
+    std::string name(void) const { return m_name; }
+    std::string unit(void) const { return m_unit; }
+    void        name(const std::string& name) { m_name=name; }
+    void        unit(const std::string& unit) { m_unit=unit; }
     void        autoscale(void);
     void        read(const GXmlElement& xml);
     void        write(GXmlElement& xml) const;
@@ -33,12 +33,14 @@
 #include "GTools.hpp"
 /* __ Method name definitions ____________________________________________ */
-#define G_REAL_VALUE                         "GModelPar::real_value(double&)"
-#define G_REAL_ERROR                         "GModelPar::real_error(double&)"
-#define G_VALUE                                   "GModelPar::value(double&)"
-#define G_MIN                                       "GModelPar::min(double&)"
-#define G_MAX                                       "GModelPar::max(double&)"
-#define G_RANGE                          "GModelPar::range(double&, double&)"
+#define G_VALUE                                   "GModelPar::Value(double&)"
+#define G_ERROR                                   "GModelPar::Error(double&)"
+#define G_FACTOR_VALUE                     "GModelPar::factor_value(double&)"
+#define G_FACTOR_MIN                         "GModelPar::factor_min(double&)"
+#define G_FACTOR_MAX                         "GModelPar::factor_max(double&)"
+#define G_FACTOR_RANGE            "GModelPar::factor_range(double&, double&)"
+#define G_SCALE                                   "GModelPar::Scale(double&)"
+#define G_READ                                "GModelPar::read(GXmlElement&)"
 /* __ Macros _____________________________________________________________ */
@@ -71,22 +73,59 @@ GModelPar::GModelPar(void)
  *
  * @param[in] name Parameter name.
  * @param[in] value Parameter value.
- * @param[in] scale Parameter scaling (default = 1.0).
  *
- * Constructs a model parameter from parameter name, value and scaling. The
- * real value of the parameter is the specified value times the scaling.
+ * Constructs a model parameter from a parameter @p name and a parameter
+ * @p value.
+ *
+ * The parameter is auto-scaled, which for a @p value that differs from zero
+ * sets the scale factor to @p value and the @p factor_value to unity. For a
+ * @p value of zero, the scale factor will be set to unity and the 
+ * @p factor_value will be set to @p value.
+ ***************************************************************************/
+GModelPar::GModelPar(const std::string& name, const double& value, int i)
+{
+    // Initialise members
+    init_members();
+
+    // Set name attribute
+    m_name = name;
+
+    // Set auto-scaled factor and scale attributes
+    if (value != 0.0) {
+        m_factor_value = 1.0;
+        m_scale        = value;
+    }
+    else {
+        m_factor_value = value;
+        m_scale        = 1.0;
+    }
+
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Parameter constructor
+ *
+ * @param[in] name Parameter name.
+ * @param[in] factor Parameter factor.
+ * @param[in] scale Parameter scaling.
+ *
+ * Constructs a model parameter from a parameter @p name, @p factor and
+ * @p scale factor.
  ***************************************************************************/
 GModelPar::GModelPar(const std::string& name,
-                     const double&      value,
+                     const double&      factor,
                      const double&      scale)
 {
     // Initialise members
     init_members();
     // Set attributes
-    this->name(name);
-    this->value(value);
-    this->scale(scale);
+    m_name         = name;
+    m_factor_value = factor;
+    m_scale        = scale;
     // Return
     return;
@@ -192,28 +231,40 @@ GModelPar* GModelPar::clone(void) const
 /***********************************************************************//**
- * @brief Set real parameter value
+ * @brief Set parameter value
  *
- * @param[in] value Real parameter value.
+ * @param[in] value Parameter value.
  *
- * @exception GException::model_invalid_parscale
- *            Parameter has a zero scale factor
+ * Sets the parameter value. The method stores the value factor which is
+ * obtained by dividing the @p value by the scale factor.
  *
- * Assigns the real parameter value by dividing by the parameter scale.
+ * The method calls factor_value() for assigning the value factor, and this
+ * method will verify that the value lies within the specified boundaries.
  ***************************************************************************/
-void GModelPar::real_value(const double& value)
+void GModelPar::Value(const double& value)
 {
-    // Throw error if scale is 0
-    if (m_scale == 0.0) {
-        throw GException::model_invalid_parscale(G_REAL_VALUE, m_scale,
-              "Zero scale not allowed for model parameter.");
-    }
-    
-    // Compute value
-    double val = value / m_scale;
+    // Set value factor. The GModelPar class makes sure that m_scale is
+    // never 0, so no test is needed here
+    factor_value(value / m_scale);
+	
+    // Return
+    return;
+}
-    // Assign value
-    this->value(val);
+
+/***********************************************************************//**
+ * @brief Set parameter error
+ *
+ * @param[in] error Parameter error.
+ *
+ * Sets the parameter error. The method stores the error factor which is
+ * obtained by dividing the @p error by the scale factor.
+ ***************************************************************************/
+void GModelPar::Error(const double& error)
+{
+    // Set error factor. The GModelPar class makes sure that m_scale is
+    // never 0, so no test is needed here
+    factor_error(error / m_scale);
     // Return
     return;
@@ -221,28 +272,56 @@ void GModelPar::real_value(const double&amp; value)
 /***********************************************************************//**
- * @brief Set real parameter error
+ * @brief Set parameter gradient
  *
- * @param[in] error Real parameter error.
+ * @param[in] gradient Parameter gradient.
+ *
+ * Sets the parameter gradient. The method stores the gradient factor which
+ * is obtained by dividing @p gradient by the scale factor.
+ ***************************************************************************/
+void GModelPar::Gradient(const double& gradient)
+{
+    // Set gradient factor. The GModelPar class makes sure that m_scale is
+    // never 0, so no test is needed here
+    factor_gradient(gradient / m_scale);
+	
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Set minimum parameter boundary
  *
- * @exception GException::model_invalid_parscale
- *            Parameter has a zero scale factor
+ * @param[in] min Parameter minimum.
  *
- * Assigns the real parameter error by dividing by the parameter scale.
+ * Sets the minimum parameter boundary. The method stores the minimum
+ * boundary factor which is obtained by dividing @p min by the scale factor.
  ***************************************************************************/
-void GModelPar::real_error(const double& error)
+void GModelPar::Min(const double& min)
 {
-    // Throw error if scale is 0
-    if (m_scale == 0.0) {
-        throw GException::model_invalid_parscale(G_REAL_ERROR, m_scale,
-              "Zero scale not allowed for model parameter.");
-    }
-    
-    // Compute error
-    double err = error / m_scale;
+    // Set minimum boundary factor. The GModelPar class makes sure that
+    // m_scale is never 0, so no test is needed here
+    factor_min(min / m_scale);
+	
+    // Return
+    return;
+}
-    // Assign error
-    this->error(err);
+
+/***********************************************************************//**
+ * @brief Set maximum parameter boundary
+ *
+ * @param[in] max Parameter maximum.
+ *
+ * Sets the maximum parameter boundary. The method stores the maximum
+ * boundary factor which is obtained by dividing @p max by the scale factor.
+ ***************************************************************************/
+void GModelPar::Max(const double& max)
+{
+    // Set maximum boundary factor. The GModelPar class makes sure that
+    // m_scale is never 0, so no test is needed here
+    factor_max(max / m_scale);
     // Return
     return;
@@ -250,29 +329,58 @@ void GModelPar::real_error(const double&amp; error)
 /***********************************************************************//**
- * @brief Set parameter value
+ * @brief Set minimum and maximum parameter boundaries
  *
- * @param[in] value Parameter value.
+ * @param[in] min Parameter minimum.
+ * @param[in] max Parameter maximum.
  *
- * @exception GException::out_of_range
- *            Parameter value outside valid range
+ * Sets the minimum and maximum parameter boundaries. The method calls the
+ * min() and max() methods to set the boundaries.
  ***************************************************************************/
-void GModelPar::value(const double& value)
+void GModelPar::Range(const double& min, const double& max)
+{
+    // Set minimum and maximum
+    this->Min(min);
+    this->Max(max);
+	
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Set parameter value factor
+ *
+ * @param[in] value Value factor.
+ *
+ * @exception GException::invalid_argument
+ *            Parameter @p value outside [min,max] boundaries.
+ *
+ * Sets the value factor of the model parameter. The method makes sure that
+ * none of the boundaries is violated. Otherwise, exceptions are thrown.
+ ***************************************************************************/
+void GModelPar::factor_value(const double& value)
 {
     // If there is a minimum boundary and if value is below this boundary
-    // then throw an error
-    if (m_hasmin && value < m_min) {
-        throw GException::out_of_range(G_VALUE, value, m_min, m_max);
+    // then throw an exception
+    if (m_hasmin && value < m_factor_min) {
+        std::string msg = "Specified value factor "+str(value)+
+                          " is smaller than the minimum boundary "+
+                          str(m_factor_min)+".";
+        throw GException::invalid_argument(G_FACTOR_VALUE, msg);
     }
     // If there is a maximum boundary and if value is above this boundary
-    // then throw an error
-    if (m_hasmax && value > m_max) {
-        throw GException::out_of_range(G_VALUE, value, m_min, m_max);
+    // then throw an exception
+    if (m_hasmax && value > m_factor_max) {
+        std::string msg = "Specified value factor "+str(value)+
+                          " is larger than the maximum boundary "+
+                          str(m_factor_max)+".";
+        throw GException::invalid_argument(G_FACTOR_VALUE, msg);
     }
     // Assign value
-    m_value = value;
+    m_factor_value = value;
     // Return
     return;
@@ -280,22 +388,29 @@ void GModelPar::value(const double&amp; value)
 /***********************************************************************//**
- * @brief Set parameter minimum
+ * @brief Set parameter minimum factor
  *
- * @param[in] min Parameter minimum.
+ * @param[in] min Minimum factor.
+ *
+ * @exception GException::invalid_argument
+ *            Parameter @p min larger than value factor.
  *
- * @exception GException::out_of_range
- *            Parameter minimum is larger than actual parameter value.
+ * Sets the minimum boundary factor of the model parameter. The method makes
+ * sure that the minimum is not larger than the actual value factor.
+ * Otherwise, an exception is thrown.
  ***************************************************************************/
-void GModelPar::min(const double& min)
+void GModelPar::factor_min(const double& min)
 {
-    // If minimum is above actual value then throw error
-    if (m_value < min) {
-        throw GException::out_of_range(G_MIN, m_value, min, m_max);
+    // Check if minimum is larger than value
+    if (min > m_factor_value) {
+        std::string msg = "Specified minimum factor "+str(min)+
+                          " is larger than the value factor "+
+                          str(m_factor_value)+".";
+        throw GException::invalid_argument(G_FACTOR_VALUE, msg);
     }
-    // Assign minimum
-    m_min = min;
+    // Assign minimum factor
+    m_factor_min = min;
     // Flag that minimum was set
     m_hasmin = true;
@@ -306,22 +421,29 @@ void GModelPar::min(const double&amp; min)
 /***********************************************************************//**
- * @brief Set parameter maximum
+ * @brief Set parameter maximum factor
  *
- * @param[in] max Parameter maximum.
+ * @param[in] max Maximum factor.
+ *
+ * @exception GException::invalid_argument
+ *            Parameter @p max smaller than value factor.
  *
- * @exception GException::out_of_range
- *            Parameter maximum is smaller than actual parameter value.
+ * Sets the maximum boundary factor of the model parameter. The method makes
+ * sure that the maximum is not smaller than the actual value factor.
+ * Otherwise, an exception is thrown.
  ***************************************************************************/
-void GModelPar::max(const double& max)
+void GModelPar::factor_max(const double& max)
 {
-    // If maximum is below value then throw error
-    if (m_value > max) {
-        throw GException::out_of_range(G_MAX, m_value, m_min, max);
+    // Check if maximum is smaller than value
+    if (max < m_factor_value) {
+        std::string msg = "Specified maximum factor "+str(max)+
+                          " is smaller than the value factor "+
+                          str(m_factor_value)+".";
+        throw GException::invalid_argument(G_FACTOR_VALUE, msg);
     }
     // Assign maximum
-    m_max = max;
+    m_factor_max = max;
     // Flag that maximum was set
     m_hasmax = true;
@@ -332,29 +454,91 @@ void GModelPar::max(const double&amp; max)
 /***********************************************************************//**
- * @brief Set parameter minimum and maximum
+ * @brief Set parameter minimum and maximum factors
  *
- * @param[in] min Parameter minimum.
- * @param[in] max Parameter maximum.
+ * @param[in] min Minimum factor.
+ * @param[in] max Maximum factor.
  *
- * @exception GException::out_of_range
- *            Parameter boundaries are in conflict with actual parameter
- *            value.
+ * Sets the minimum and maximum boundary factors. The method calls the
+ * factor_min() and factor_max() methods which perform validity checking
+ * of the arguments.
  ***************************************************************************/
-void GModelPar::range(const double& min, const double& max)
+void GModelPar::factor_range(const double& min, const double& max)
 {
-    // If maximum is below value then throw error
-    if (m_value < min || m_value > max || min > max) {
-        throw GException::out_of_range(G_RANGE, m_value, min, max);
+    // Set minimum and maximum
+    factor_min(min);
+    factor_max(max);
+    
+    // Return
+    return;
+}
+
+
+/***********************************************************************//**
+ * @brief Set scale factor
+ *
+ * @param[in] scale Scale factor.
+ *
+ * @exception GException::invalid_argument
+ *            Sacle factor of 0 specified.
+ *
+ * Sets the scale factor of the model parameter. All parameter attributes are
+ * rescaled accordingly.
+ *
+ * Special care is taken for value boundaries, that need swaping if the scale
+ * factor changes its sign. In case of sign change the following logic applies:
+ * - if minimum and maximum boundaries are set they are swapped
+ * - if only a minimum boundary exists it will be replaced by a maximum boundary
+ * - if only a maximum boundary exists it will be replaced by a minimum boundary
+ *
+ * An exception is thrown if a scale factor of 0 is specified.
+ ***************************************************************************/
+void GModelPar::Scale(const double& scale)
+{
+    // Make sure that scale is not zero
+    if (scale == 0.0) {
+        std::string msg = "Specified scale factor of 0.\n"
+                          "Model parameters need a non-zero scale factor.";
+        throw GException::invalid_argument(G_SCALE, msg);
     }
-    // Assign range
-    m_min = min;
-    m_max = max;
-    
-    // Flag that range was set
-    m_hasmin = true;
-    m_hasmax = true;
+    // Set rescaling
+    double rescale = m_scale/scale;
+
+    // Set new scale factor
+    m_scale = scale;
+
+    // Set values, error, gradient, min and max
+    m_factor_value    *= rescale;
+    m_factor_error    *= rescale;
+    m_factor_gradient *= rescale;
+    if (m_hasmin) {
+        m_factor_min *= rescale;
+    }
+    if (m_hasmax) {
+        m_factor_max *= rescale;
+    }
+
+    // Takes care of boundaries in case of sign change
+    if (rescale < 0.0) {
+        if (m_hasmin && m_hasmax) {
+            double swap  = m_factor_min;
+            m_factor_min = m_factor_max;
+            m_factor_max = swap;
+        }
+        else if (m_hasmin) {
+            m_factor_max = m_factor_min;
+            m_hasmax     = true;
+            m_factor_min = 0.0;
+            m_hasmin     = false;
+        }
+        else if (m_hasmax) {
+            m_factor_min = m_factor_max;
+            m_hasmin     = true;
+            m_factor_max = 0.0;
+            m_hasmax     = false;
+        }
+    }
     // Return
     return;
@@ -364,35 +548,61 @@ void GModelPar::range(const double&amp; min, const double&amp; max)
 /***********************************************************************//**
  * @brief Autoscale parameter
  *
- * Sets the value to unity and the scale factor to the real value of the
- * parameter. The method will also adjust the error and the gradient
- * accodringly. If parameter boundaries exist they will also be adjusted
- * accordingly.
+ * Sets the value factor to unity and the scale factor to the real value
+ * of the parameter. The method will also adjust the error factor and
+ * gradient factor, as well as the minimum and maximum factors if they
+ * exist.
  *
- * The method does nothing if the actual value is zero.
+ * Special care is taken for value boundaries, that need swaping if the scale
+ * factor changes its sign. In case of sign change the following logic applies:
+ * - if minimum and maximum boundaries are set they are swapped
+ * - if only a minimum boundary exists it will be replaced by a maximum boundary
+ * - if only a maximum boundary exists it will be replaced by a minimum boundary
+ *
+ * The method does nothing if the actual value factor is zero.
  ***************************************************************************/
 void GModelPar::autoscale(void)
 {
-    // Continue only if the value is non-zero
-    if (m_value != 0.0) {
+    // Continue only if the value factor is non-zero
+    if (m_factor_value != 0.0) {
         // Set the scale factor
-        m_scale *= m_value;
+        m_scale *= m_factor_value;
         // Get inverse scaling factor
-        double invscale = 1.0 / m_value;
+        double invscale = 1.0 / m_factor_value;
         // Set values, error, gradient, min and max
-        m_value    *= invscale;
-        m_error    *= invscale;
-        m_gradient *= invscale;
+        m_factor_value    *= invscale;
+        m_factor_error    *= invscale;
+        m_factor_gradient *= invscale;
         if (m_hasmin) {
-            m_min *= invscale;
+            m_factor_min *= invscale;
         }
         if (m_hasmax) {
-            m_max *= invscale;
+            m_factor_max *= invscale;
         }
+        // Takes care of boundaries in case of sign change
+        if (invscale < 0.0) {
+            if (m_hasmin && m_hasmax) {
+                double swap  = m_factor_min;
+                m_factor_min = m_factor_max;
+                m_factor_max = swap;
+            }
+            else if (m_hasmin) {
+                m_factor_max = m_factor_min;
+                m_hasmax     = true;
+                m_factor_min = 0.0;
+                m_hasmin     = false;
+            }
+            else if (m_hasmax) {
+                m_factor_min = m_factor_max;
+                m_hasmin     = true;
+                m_factor_max = 0.0;
+                m_hasmax     = false;
+            }
+        }
     } // endif: value was non-zero
@@ -406,50 +616,112 @@ void GModelPar::autoscale(void)
  *
  * @param[in] xml XML element
  *
- * The following parameter attributes may exist (they take the default
- * values when they are not found in the XML element):
- * "value" (default=0.0), "error" (default=0.0), "scale" (default=1.0),
- * "min" (default=INDEF), "max" (default=INDEF), "free" (default=0).
+ * @exception GException::invalid_value
+ *            Invalid combination of parameter attributes encountered.
+ *
+ * Extracts the parameter attributes from an XML element of the form
+ *
+ *     <parameter name=".." value=".." error=".." scale=".." min=".." max="..' free="..">
+ *
+ * Each of the attributes are optional, with the following scheme for
+ * assigning default values in case that the attribute was not found:
+ * - @p value sets @p m_factor_value (defaults to 0.0)
+ * - @p error sets @p m_factor_error (defaults to 0.0)
+ * - @p scale sets @p m_scale (defaults to 1.0)
+ * - @p min sets @p m_factor_min (will remove_min() if not found)
+ * - @p max sets @p m_factor_max (will remove_max() if not found)
+ * - @p free sets @p m_free (papameter will be fixed if not found)
  ***************************************************************************/
 void GModelPar::read(const GXmlElement& xml)
 {
     // Get value
     std::string arg = xml.attribute("value");
-    if (arg != "")
-        m_value = todouble(arg);
-    else
-        m_value = 0.0;
+    if (arg != "") {
+        m_factor_value = todouble(arg);
+    }
+    else {
+        m_factor_value = 0.0;
+    }
     // Get error
     arg = xml.attribute("error");
-    if (arg != "")
-        m_error = todouble(arg);
-    else
-        m_error = 0.0;
+    if (arg != "") {
+        m_factor_error = todouble(arg);
+    }
+    else {
+        m_factor_error = 0.0;
+    }
     // Get scale factor
     arg = xml.attribute("scale");
-    if (arg != "")
+    if (arg != "") {
         m_scale = todouble(arg);
-    else
+    }
+    else {
         m_scale = 1.0;
+    }
     // Get min
     arg = xml.attribute("min");
-    if (arg != "")
-        min(todouble(arg));
+    if (arg != "") {
+        m_factor_min = todouble(arg);
+        m_hasmin     = true;
+    }
+    else {
+        remove_min();
+    }
     // Get max
     arg = xml.attribute("max");
-    if (arg != "")
-        max(todouble(arg));
+    if (arg != "") {
+        m_factor_max = todouble(arg);
+        m_hasmax     = true;
+    }
+    else {
+        remove_max();
+    }
     // Get free
     if (xml.attribute("free") == "1" || 
-        tolower(xml.attribute("free")) == "true")
+        tolower(xml.attribute("free")) == "true") {
         free();
-    else
+    }
+    else {
         fix();
+    }
+
+    // If there is a minimum and maximum, make sure that the maximum is
+    // not smaller than the minimum
+    if (m_hasmin && m_hasmax) {
+        if (m_factor_min > m_factor_max) {
+            std::string msg = "The model parameter "+m_name+
+                              " in the XML document has a minimum boundary "+
+                              str(m_factor_min)+
+                              " that is larger than the maximum boundary "+
+                              str(m_factor_max)+".\n"+xml.print();
+            throw GException::invalid_value(G_READ, msg);
+        }
+    }
+
+    // If there is a minimum, make sure that the value is not below it
+    if (m_hasmin && m_factor_value < m_factor_min) {
+        std::string msg = "The model parameter "+m_name+
+                          " in the XML document has a value "+
+                            str(m_factor_value)+
+                            " that is smaller than the minimum boundary "+
+                            str(m_factor_min)+".\n"+xml.print();
+        throw GException::invalid_value(G_READ, msg);
+    }
+
+    // If there is a maximum, make sure that the value is not above it
+    if (m_hasmax && m_factor_value > m_factor_max) {
+        std::string msg = "The model parameter "+m_name+
+                          " in the XML document has a value "+
+                            str(m_factor_value)+
+                            " that is larger than the maximum boundary "+
+                            str(m_factor_max)+".\n"+xml.print();
+        throw GException::invalid_value(G_READ, msg);
+    }
     // Return
     return;
@@ -461,36 +733,48 @@ void GModelPar::read(const GXmlElement&amp; xml)
  *
  * @param[in] xml XML element.
  *
- * The following parameter attributes may exist (they take the default
- * values when they are not found in the XML element):
- * "value" (default=0.0), "error" (default=0.0), "scale" (default=1.0),
- * "min" (default=INDEF), "max" (default=INDEF), "free" (default=0).
+ * Sets or updates the parameter attributes in an XML element of the form
+ *
+ *     <parameter name=".." value=".." error=".." scale=".." min=".." max="..' free="..">
+ *
+ * The following attributes will be set:
+ * - @p value
+ * - @p error (only in case that the parameter is free)
+ * - @p scale
+ * - @p min (only in case that a minimum exists)
+ * - @p max (only in case that a maximum exists)
+ * - @p free
  ***************************************************************************/
 void GModelPar::write(GXmlElement& xml) const
 {
     // Set value
-    xml.attribute("value", str(m_value));
+    xml.attribute("value", str(m_factor_value));
     // Set error (only if parameter is free)
-    if (isfree())
-        xml.attribute("error", str(m_error));
+    if (isfree()) {
+        xml.attribute("error", str(m_factor_error));
+    }
     // Set scale
     xml.attribute("scale", str(m_scale));
     // Set minimum
-    if (hasmin())
-        xml.attribute("min", str(m_min));
+    if (hasmin()) {
+        xml.attribute("min", str(m_factor_min));
+    }
     // Set maximum
-    if (hasmax())
-        xml.attribute("max", str(m_max));
+    if (hasmax()) {
+        xml.attribute("max", str(m_factor_max));
+    }
     // Set free/fix flag
-    if (isfree())
+    if (isfree()) {
         xml.attribute("free", "1");
-    else
+    }
+    else {
         xml.attribute("free", "0");
+    }
     // Return
     return;
@@ -499,6 +783,8 @@ void GModelPar::write(GXmlElement&amp; xml) const
 /***********************************************************************//**
  * @brief Print parameter information
+ *
+ * @return String with model parameter information.
  ***************************************************************************/
 std::string GModelPar::print(void) const
 {
@@ -508,38 +794,46 @@ std::string GModelPar::print(void) const
     // Append parameter name
     result.append(parformat(" "+name()));
-    // Append real value
-    result.append(str(real_value()));
+    // Append value
+    result.append(str(Value()));
     // For free parameters, append statistical uncertainty
-    if (m_free)
-        result.append(" +/- "+str(fabs(real_error())));
+    if (m_free) {
+        result.append(" +/- "+str(std::abs(Error())));
+    }
     // Append parameter limites if they exist
-    if (m_hasmin && m_hasmax)
-        result.append(" ["+str(real_min()) + ","+str(real_max())+"]");
-    else if (m_hasmin)
-        result.append(" ["+str(real_min()) + ",infty[");
-    else if (m_hasmax)
-        result.append(" ]-infty,"+str(real_max())+"]");
+    if (m_hasmin && m_hasmax) {
+        result.append(" ["+str(Min()) + ","+str(Max())+"]");
+    }
+    else if (m_hasmin) {
+        result.append(" ["+str(Min()) + ",infty[");
+    }
+    else if (m_hasmax) {
+        result.append(" ]-infty,"+str(Max())+"]");
+    }
     // Append parameter unit
     result.append(" "+m_unit);
     // Signal if parameter was free or fixed
-    if (m_free)
+    if (m_free) {
         result.append(" (free");
-    else
+    }
+    else {
         result.append(" (fixed");
+    }
     // Append parameter scale
     result.append(",scale="+str(m_scale));
     // Signal if parameter has analytic gradient
-    if (m_hasgrad)
+    if (m_hasgrad) {
         result.append(",gradient)");
-    else
+    }
+    else {
         result.append(")");
+    }
     // Return result
     return result;
@@ -560,16 +854,16 @@ void GModelPar::init_members(void)
     // Initialise members
     m_name.clear();
     m_unit.clear();
-    m_value    = 0.0;
-    m_error    = 0.0;
-    m_gradient = 0.0;
-    m_min      = 0.0;
-    m_max      = 0.0;
-    m_scale    = 1.0;
-    m_free     = true;
-    m_hasmin   = false;
-    m_hasmax   = false;
-    m_hasgrad  = false;
+    m_factor_value    = 0.0;
+    m_factor_error    = 0.0;
+    m_factor_gradient = 0.0;
+    m_factor_min      = 0.0;
+    m_factor_max      = 0.0;
+    m_scale           = 1.0;
+    m_free            = true;
+    m_hasmin          = false;
+    m_hasmax          = false;
+    m_hasgrad         = false;
     // Return
     return;
@@ -584,18 +878,18 @@ void GModelPar::init_members(void)
 void GModelPar::copy_members(const GModelPar& par)
 {
     // Copy members
-    m_name    = par.m_name;
-    m_unit    = par.m_unit;
-    m_value   = par.m_value;
-    m_error   = par.m_error;
-    m_gradient = par.m_gradient;
-    m_min     = par.m_min;
-    m_max     = par.m_max;
-    m_scale   = par.m_scale;
-    m_free    = par.m_free;
-    m_hasmin  = par.m_hasmin;
-    m_hasmax  = par.m_hasmax;
-    m_hasgrad = par.m_hasgrad;
+    m_name            = par.m_name;
+    m_unit            = par.m_unit;
+    m_factor_value    = par.m_factor_value;
+    m_factor_error    = par.m_factor_error;
+    m_factor_gradient = par.m_factor_gradient;
+    m_factor_min      = par.m_factor_min;
+    m_factor_max      = par.m_factor_max;
+    m_scale           = par.m_scale;
+    m_free            = par.m_free;
+    m_hasmin          = par.m_hasmin;
+    m_hasmax          = par.m_hasmax;
+    m_hasgrad         = par.m_hasgrad;
     // Return
     return;