FitParameterItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Job/FitParameterItem.cpp
//! @brief     Implements FitParameterItems family of classes
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/Model/Job/FitParameterItem.h"
#include "Base/Util/Assert.h"
#include "GUI/Model/Job/FitParameterLinkItem.h"
#include "GUI/Model/Model/SessionModel.h"
#include "GUI/Util/ComboProperty.h"
 
namespace {
 
ComboProperty fitParameterTypeCombo()
{
    QStringList tooltips = QStringList() << "Fixed at given value"
                                         << "Limited in the range [min, max]"
                                         << "Limited at lower bound [min, inf]"
                                         << "Limited at upper bound [-inf, max]"
                                         << "No limits imposed to parameter value";
 
    ComboProperty result;
    result << "fixed"
           << "limited"
           << "lower limited"
           << "upper limited"
           << "free";
    result.setValue("limited");
    result.setToolTips(tooltips);
    return result;
}
 
const double range_factor = 0.5;
 
} // namespace
 
 
FitParameterItem::FitParameterItem()
    : SessionItem(M_TYPE)
{
    addProperty(P_TYPE, fitParameterTypeCombo().variant());
    addProperty(P_START_VALUE, 0.0);
    addProperty(P_MIN, 0.0);
    addProperty(P_MAX, 0.0)->setEnabled(false);
    registerTag(T_LINK, 0, -1, {FitParameterLinkItem::M_TYPE});
    setDefaultTag(T_LINK);
 
    getItem(P_START_VALUE)->setLimits(RealLimits::limitless());
    getItem(P_MIN)->setLimits(RealLimits::limitless());
    getItem(P_MAX)->setLimits(RealLimits::limitless());
 
    mapper()->setOnPropertyChange([this](const QString& name) {
        if (name == P_TYPE)
            onTypeChange();
    });
 
    onTypeChange();
}
 
//! Inits P_MIN and P_MAX taking into account current value and external limits
 
void FitParameterItem::initMinMaxValues(const RealLimits& limits)
{
    double value = getItemValue(P_START_VALUE).toDouble();
 
    double dr(0);
    if (value == 0.0)
        dr = 1.0 * range_factor;
    else
        dr = std::abs(value) * range_factor;
 
    double min = value - dr;
    double max = value + dr;
 
    if (limits.hasLowerLimit() && min < limits.lowerLimit())
        min = limits.lowerLimit();
 
    if (limits.hasUpperLimit() && max > limits.upperLimit())
        max = limits.upperLimit();
 
    setItemValue(P_MIN, min);
    getItem(P_MIN)->setLimits(limits);
    setItemValue(P_MAX, max);
    getItem(P_MAX)->setLimits(limits);
 
    getItem(P_START_VALUE)->setLimits(limits);
}
 
//! Constructs Limits correspodning to current GUI settings.
 
AttLimits FitParameterItem::attLimits() const
{
    if (isFixed())
        return AttLimits::fixed();
    if (isLimited())
        return AttLimits::limited(getItemValue(P_MIN).toDouble(), getItemValue(P_MAX).toDouble());
    if (isLowerLimited())
        return AttLimits::lowerLimited(getItemValue(P_MIN).toDouble());
    if (isUpperLimited())
        return AttLimits::upperLimited(getItemValue(P_MAX).toDouble());
    if (isFree())
        return AttLimits::limitless();
    ASSERT(0);
}
 
bool FitParameterItem::isValid() const
{
    if (isFixed() || isFree())
        return true;
 
    double value = getItemValue(P_START_VALUE).toDouble();
    double min = getItemValue(P_MIN).toDouble();
    double max = getItemValue(P_MAX).toDouble();
 
    if (isLowerLimited())
        return min <= value;
    if (isUpperLimited())
        return value <= max;
    return min <= value && value <= max;
}
 
double FitParameterItem::startValue() const
{
    return getItemValue(P_START_VALUE).toDouble();
}
 
void FitParameterItem::setStartValue(const double start_value)
{
    setItemValue(P_START_VALUE, start_value);
}
 
SessionItem* FitParameterItem::startValueItem() const
{
    return getItem(P_START_VALUE);
}
 
double FitParameterItem::minimum() const
{
    return getItemValue(P_MIN).toDouble();
}
 
void FitParameterItem::setMinimum(const double minimum)
{
    setItemValue(P_MIN, minimum);
}
 
SessionItem* FitParameterItem::minimumItem() const
{
    return getItem(P_MIN);
}
 
double FitParameterItem::maximum() const
{
    return getItemValue(P_MAX).toDouble();
}
 
void FitParameterItem::setMaximum(const double maximum)
{
    setItemValue(P_MAX, maximum);
}
 
SessionItem* FitParameterItem::maximumItem() const
{
    return getItem(P_MAX);
}
 
void FitParameterItem::addLink(const QString& title, const QString& link)
{
    auto* newLink = model()->insertItem<FitParameterLinkItem>(this);
    newLink->setTitle(title);
    newLink->setLink(link);
}
 
QVector<FitParameterLinkItem*> FitParameterItem::linkItems() const
{
    return items<FitParameterLinkItem>(T_LINK);
}
 
QStringList FitParameterItem::links() const
{
    QStringList links;
    for (FitParameterLinkItem* linkItem : linkItems())
        links << linkItem->link();
    return links;
}
 
void FitParameterItem::removeLink(const QString& link)
{
    for (FitParameterLinkItem* linkItem : linkItems()) {
        if (linkItem->link() == link)
            model()->removeRow(linkItem->index().row(), linkItem->index().parent());
    }
}
 
SessionItem* FitParameterItem::typeItem() const
{
    return getItem(P_TYPE);
}
 
QString FitParameterItem::parameterType() const
{
    auto partype = getItemValue(P_TYPE).value<ComboProperty>();
    return partype.getValue();
}
 
//! Enables/disables min, max properties on FitParameterItem's type
 
void FitParameterItem::onTypeChange()
{
    if (isFixed()) {
        setLimitEnabled(P_MIN, false);
        setLimitEnabled(P_MAX, false);
    }
 
    else if (isLimited()) {
        setLimitEnabled(P_MIN, true);
        setLimitEnabled(P_MAX, true);
    }
 
    else if (isLowerLimited()) {
        setLimitEnabled(P_MIN, true);
        setLimitEnabled(P_MAX, false);
    }
 
    else if (isUpperLimited()) {
        setLimitEnabled(P_MIN, false);
        setLimitEnabled(P_MAX, true);
    }
 
    else if (isFree()) {
        setLimitEnabled(P_MIN, false);
        setLimitEnabled(P_MAX, false);
    }
}
 
//! Set limit property with given name to the enabled state
 
void FitParameterItem::setLimitEnabled(const QString& name, bool enabled)
{
    if (isTag(name)) {
        SessionItem* propertyItem = getItem(name);
        ASSERT(propertyItem);
        propertyItem->setEnabled(enabled);
        propertyItem->setEditable(enabled);
    }
}
 
bool FitParameterItem::isLimited() const
{
    return parameterType() == "limited";
}
 
bool FitParameterItem::isFree() const
{
    return parameterType() == "free";
}
 
bool FitParameterItem::isLowerLimited() const
{
    return parameterType() == "lower limited";
}
 
bool FitParameterItem::isUpperLimited() const
{
    return parameterType() == "upper limited";
}
 
bool FitParameterItem::isFixed() const
{
    return parameterType() == "fixed";
}