MinimizerSettingsWidget.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Fit/MinimizerSettingsWidget.cpp
//! @brief     Implements class MinimizerSettingsWidget
//!
//! @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/View/Fit/MinimizerSettingsWidget.h"
#include "GUI/Model/Job/FitSuiteItem.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Model/Job/MinimizerItem.h"
#include "GUI/View/Common/DoubleSpinBox.h"
#include "GUI/View/Tool/LayoutUtils.h"
#include "GUI/View/Tool/WidgetUtils.h"
#include <QComboBox>
#include <QFormLayout>
#include <QPushButton>
#include <QVBoxLayout>
 
MinimizerSettingsWidget::MinimizerSettingsWidget(QWidget* parent)
    : QWidget(parent)
    , m_currentItem(nullptr)
{
    setWindowTitle(QLatin1String("Minimizer Settings"));
    setAttribute(Qt::WA_StyledBackground, true);
    setProperty("stylable", true); // for stylesheet addressing
 
    m_mainLayout = new QFormLayout(this);
    m_mainLayout->setContentsMargins(8, 8, 8, 8);
    m_mainLayout->setSpacing(5);
}
 
void MinimizerSettingsWidget::setItem(JobItem* jobItem)
{
    ASSERT(jobItem);
    setItem(jobItem->fitSuiteItem()->minimizerContainerItem());
}
 
void MinimizerSettingsWidget::setItem(MinimizerContainerItem* minimizerItem)
{
    ASSERT(minimizerItem);
 
    GUI::Util::Layout::clearLayout(m_mainLayout);
    m_updaters.clear();
    m_currentItem = minimizerItem;
 
    if (!m_currentItem)
        return;
 
    auto minimizerDescriptor = m_currentItem->minimizers();
    auto* minimizerCombo = GUI::Util::createSelectionCombo(this, minimizerDescriptor,
                                                           [=](int) { createMimimizerEdits(); });
 
    m_updaters << [=]() {
        QSignalBlocker b(minimizerCombo);
        minimizerCombo->setCurrentIndex(minimizerDescriptor.currentIndex());
    };
    m_mainLayout->addRow("Minimizer:", minimizerCombo);
 
    auto* w = new QWidget(this);
    m_minimizerLayout = new QFormLayout(w);
    m_minimizerLayout->setContentsMargins(10, 8, 0, 8);
    m_mainLayout->addRow("", w);
 
    m_mainLayout->addRow("Objective metric:", createComboBox(m_currentItem->objectiveMetric()));
    m_mainLayout->addRow("Norm function:", createComboBox(m_currentItem->normFunction()));
 
    createMimimizerEdits();
    updateUIValues();
}
 
QWidget* MinimizerSettingsWidget::createComboBox(SelectionDescriptor<QString> d)
{
    auto* combo = new QComboBox(this);
    combo->addItems(d.options);
    combo->setMaxCount(d.options.size());
    combo->setToolTip(d.tooltip);
 
    connect(combo, qOverload<int>(&QComboBox::currentIndexChanged),
            [=](int newIndex) { d.setCurrentIndex(newIndex); });
 
    m_updaters << [=]() {
        QSignalBlocker b(combo);
        combo->setCurrentIndex(d.currentIndex());
    };
 
    return combo;
}
 
QWidget* MinimizerSettingsWidget::createDoubleSpinbox(DoubleDescriptor d)
{
    auto* spinBox = new DoubleSpinBox(this, d);
    spinBox->setToolTip(d.tooltip);
    QObject::connect(spinBox, &DoubleSpinBox::baseValueChanged,
                     [=](double newValue) { d.set(newValue); });
 
    m_updaters << [=]() { spinBox->updateValue(); };
 
    return spinBox;
}
 
QWidget* MinimizerSettingsWidget::createSpinbox(UIntDescriptor d)
{
    auto* spinBox = new QSpinBox(this);
    spinBox->setToolTip(d.tooltip);
    spinBox->setMaximum(std::numeric_limits<int>::max());
    spinBox->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
 
    if (d.limits.hasLowerLimit())
        spinBox->setMinimum(static_cast<int>(d.limits.lowerLimit()));
    if (d.limits.hasUpperLimit())
        spinBox->setMaximum(static_cast<int>(d.limits.upperLimit()));
 
    spinBox->setValue(d.get());
 
    QObject::connect(spinBox, QOverload<int>::of(&QSpinBox::valueChanged),
                     [=](int newValue) { d.set(newValue); });
 
    m_updaters << [=]() {
        QSignalBlocker b(spinBox);
        spinBox->setValue(d.get());
    };
 
    return spinBox;
}
 
void MinimizerSettingsWidget::createMimimizerEdits()
{
    GUI::Util::Layout::clearLayout(m_minimizerLayout);
 
    for (auto v : m_currentItem->minimizers().currentItem()->valueDescriptorsForUI()) {
        if (std::holds_alternative<DoubleDescriptor>(v)) {
            auto d = std::get<DoubleDescriptor>(v);
            m_minimizerLayout->addRow(d.label + ":", createDoubleSpinbox(d));
        } else if (std::holds_alternative<SelectionDescriptor<QString>>(v)) {
            auto d = std::get<SelectionDescriptor<QString>>(v);
            m_minimizerLayout->addRow(d.label + ":", createComboBox(d));
        } else if (std::holds_alternative<UIntDescriptor>(v)) {
            auto d = std::get<UIntDescriptor>(v);
            m_minimizerLayout->addRow(d.label + ":", createSpinbox(d));
        }
    }
}
 
void MinimizerSettingsWidget::updateUIValues()
{
    for (const auto& updater : m_updaters)
        updater();
}