DistributionEditor.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Instrument/DistributionEditor.cpp
//! @brief     Implements classes DistributionSelector and DistributionEditor
//!
//! @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/Instrument/DistributionEditor.h"
#include "GUI/Model/CatDevice/DistributionItemCatalog.h"
#include "GUI/Model/Descriptor/DistributionItems.h"
#include "GUI/Model/Device/BeamDistributionItem.h"
#include "GUI/Support/XML/Backup.h"
#include "GUI/Support/XML/Streamer.h"
#include "GUI/View/Common/DoubleSpinBox.h"
#include "GUI/View/Common/ScientificSpinBox.h"
#include "GUI/View/Instrument/DistributionPlot.h"
#include "GUI/View/Tool/GroupBoxCollapser.h"
#include "GUI/View/Tool/WidgetUtils.h"
#include <QComboBox>
#include <QFormLayout>
#include <QStackedLayout>
#include <utility>
 
//==================================================================================================
// DistributionSelector
//==================================================================================================
 
DistributionSelector::DistributionSelector(std::optional<MeanConfig> mean_config,
                                           GUI::ID::Distributions distributions, QWidget* parent,
                                           BeamDistributionItem* item)
    : QWidget(parent)
    , m_item(item)
    , m_meanConfig(std::move(mean_config))
    , m_distributions(distributions)
{
    ASSERT(item);
    m_formLayout = new QFormLayout(this);
    m_formLayout->setMargin(0);
 
    m_distributionCombo =
        GUI::Util::createSelectionCombo(this, item->distributionSelection(), [=](int) {
            createDistributionWidgets();
            emit distributionChanged();
        });
    m_formLayout->addRow("Distribution:", m_distributionCombo);
 
    createDistributionWidgets();
}
 
void DistributionSelector::createDistributionWidgets()
{
    while (m_formLayout->rowCount() > 1)
        m_formLayout->removeRow(1);
 
    if (auto* cosine = dynamic_cast<DistributionCosineItem*>(m_item->distribution())) {
        createMeanSpinBox(cosine->mean());
        createSpinBox(cosine->sigma());
        createSpinBox(cosine->numberOfSamples());
        createSpinBox(cosine->sigmaFactor());
    } else if (auto* gate = dynamic_cast<DistributionGateItem*>(m_item->distribution())) {
        auto* minSpinbox = createSpinBox(gate->minimum());
        auto* maxSpinbox = createSpinBox(gate->maximum());
        connect(minSpinbox, &DoubleSpinBox::baseValueChanged, [=](double d) {
            if (d > gate->maximum()) {
                gate->setMaximum(d);
                maxSpinbox->updateValue();
            }
        });
        connect(maxSpinbox, &DoubleSpinBox::baseValueChanged, [=](double d) {
            if (d < gate->minimum()) {
                gate->setMinimum(d);
                minSpinbox->updateValue();
            }
        });
        createSpinBox(gate->numberOfSamples());
    } else if (auto* gauss = dynamic_cast<DistributionGaussianItem*>(m_item->distribution())) {
        createMeanSpinBox(gauss->mean());
        createSpinBox(gauss->standardDeviation());
        createSpinBox(gauss->numberOfSamples());
        createSpinBox(gauss->sigmaFactor());
    } else if (auto* logNormal = dynamic_cast<DistributionLogNormalItem*>(m_item->distribution())) {
        createSpinBox(logNormal->median());
        createSpinBox(logNormal->scaleParameter());
        createSpinBox(logNormal->numberOfSamples());
        createSpinBox(logNormal->sigmaFactor());
    } else if (auto* lorentz = dynamic_cast<DistributionLorentzItem*>(m_item->distribution())) {
        createMeanSpinBox(lorentz->mean());
        createSpinBox(lorentz->hwhm());
        createSpinBox(lorentz->numberOfSamples());
        createSpinBox(lorentz->sigmaFactor());
    } else if (auto* none = dynamic_cast<DistributionNoneItem*>(m_item->distribution())) {
        createMeanSpinBox(none->mean());
    } else if (auto* trapezoid = dynamic_cast<DistributionTrapezoidItem*>(m_item->distribution())) {
        createSpinBox(trapezoid->center());
        createSpinBox(trapezoid->leftWidth());
        createSpinBox(trapezoid->middleWidth());
        createSpinBox(trapezoid->rightWidth());
        createSpinBox(trapezoid->numberOfSamples());
    }
}
 
DoubleSpinBox* DistributionSelector::createSpinBox(const DoubleDescriptor& d)
{
    auto* sb = GUI::Util::createSpinBox(m_formLayout, d);
    connect(sb, &DoubleSpinBox::baseValueChanged, [=](double v) {
        d.set(v);
        emit distributionChanged();
    });
    return sb;
}
 
QSpinBox* DistributionSelector::createSpinBox(const UIntDescriptor& d)
{
    auto* sb = GUI::Util::createSpinBox(m_formLayout, d);
    connect(sb, QOverload<int>::of(&QSpinBox::valueChanged), [=](int v) {
        d.set(v);
        emit distributionChanged();
    });
    return sb;
}
 
void DistributionSelector::createMeanSpinBox(const DoubleDescriptor& d)
{
    if (m_meanConfig) {
        if (m_meanConfig->scientific) {
            auto* sb = GUI::Util::createScientificSpinBox(m_formLayout, d);
            connect(sb, &ScientificSpinBox::valueChanged, [=](double v) {
                d.set(v);
                emit distributionChanged();
            });
        } else
            createSpinBox(d);
    }
}
 
BeamDistributionItem* DistributionSelector::item() const
{
    return m_item;
}
 
GUI::ID::Distributions DistributionSelector::distributions() const
{
    return m_distributions;
}
 
void DistributionSelector::refresh()
{
    QSignalBlocker b(m_distributionCombo);
    m_distributionCombo->setCurrentIndex(m_item->distributionSelection().currentIndex());
    createDistributionWidgets();
}
 
 
//==================================================================================================
// DistributionEditor
//==================================================================================================
 
DistributionEditor::DistributionEditor(const QString& title,
                                       const std::optional<MeanConfig>& mean_config,
                                       GUI::ID::Distributions distributions, QWidget* parent,
                                       BeamDistributionItem* item)
    : QGroupBox(title, parent)
{
    setProperty("subgroup", true); // for stylesheet addressing
    auto* hLayout = new QHBoxLayout(this);
    m_selector = new DistributionSelector(mean_config, distributions, this, item);
    hLayout->addWidget(m_selector);
    hLayout->setSpacing(50);
 
    m_plot = new DistributionPlot(this);
    m_plot->setFixedSize(280, 170);
    m_plot->setShowMouseCoords(false);
    hLayout->addWidget(m_plot);
    hLayout->addStretch(1);
 
    GroupBoxCollapser::installIntoGroupBox(this);
 
    connect(m_selector, &DistributionSelector::distributionChanged, this,
            &DistributionEditor::distributionChanged);
    connect(m_selector, &DistributionSelector::distributionChanged, this,
            &DistributionEditor::updatePlot);
 
    updatePlot();
}
 
void DistributionEditor::updateData()
{
    m_selector->refresh();
}
 
void DistributionEditor::updatePlot()
{
    auto* d = m_selector->item()->distribution();
    m_plot->setVisible(!dynamic_cast<const DistributionNoneItem*>(d));
    m_plot->setItem(d);
    m_plot->plotItem();
}