SimulationView.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/Toplevel/SimulationView.cpp
//! @brief     Implements class SimulationView
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2021
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "GUI/View/Toplevel/SimulationView.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Model/Model/JobModel.h"
#include "GUI/Model/Model/RealDataModel.h"
#include "GUI/Model/Project/ProjectDocument.h"
#include "GUI/Model/Sample/MultiLayerItem.h"
#include "GUI/Model/Sample/SampleValidator.h"
#include "GUI/Support/Data/SimulationOptionsItem.h"
#include "GUI/View/Global/Globals.h"
#include "GUI/View/Project/ProjectManager.h"
#include "GUI/View/Script/PythonScriptWidget.h"
#include "GUI/View/Tool/GroupBoxCollapser.h"
#include "ui_SimulationView.h"
#include <QButtonGroup>
#include <QMessageBox>
#include <thread>
 
SimulationView::SimulationView(QWidget* parent, ProjectDocument* document)
    : QWidget(parent)
    , m_ui(new Ui::SimulationView)
    , m_document(document)
{
    m_ui->setupUi(this);
 
    setAttribute(Qt::WA_StyledBackground, true);
    setProperty("stylable", true); // for stylesheet addressing
 
    GroupBoxCollapser::installIntoGroupBox(m_ui->groupBox_3);
    GroupBoxCollapser::installIntoGroupBox(m_ui->groupBox_2);
    GroupBoxCollapser::installIntoGroupBox(m_ui->groupBox);
 
    auto* buttonGroup = new QButtonGroup(this);
    buttonGroup->addButton(m_ui->runPolicyImmediatelyRadio);
    buttonGroup->addButton(m_ui->runPolicyBackgroundRadio);
 
    auto* computationButtonGroup = new QButtonGroup(this);
    computationButtonGroup->addButton(m_ui->analyticalRadio);
    computationButtonGroup->addButton(m_ui->monteCarloRadio);
 
    buttonGroup = new QButtonGroup(this);
    buttonGroup->addButton(m_ui->ambientLayerRadio);
    buttonGroup->addButton(m_ui->averageLayerRadio);
 
    // -- fill combo for "number of threads"
    const int nthreads = static_cast<int>(std::thread::hardware_concurrency());
    m_ui->numberOfThreadsCombo->addItem(QString("Max (%1 threads)").arg(nthreads), nthreads);
    for (int i = nthreads - 1; i > 1; i--)
        m_ui->numberOfThreadsCombo->addItem(QString("%1 threads").arg(i), i);
    m_ui->numberOfThreadsCombo->addItem("1 thread", 1);
 
    updateFunctionalityNarrowing();
 
    connect(m_ui->simulateButton, &QPushButton::clicked, this, &SimulationView::simulate);
    connect(m_ui->exportToPyScriptButton, &QPushButton::clicked, this,
            &SimulationView::exportPythonScript);
    connect(computationButtonGroup, QOverload<int>::of(&QButtonGroup::buttonClicked), this,
            &SimulationView::updateEnabling);
 
    connect(m_ui->runPolicyImmediatelyRadio, &QRadioButton::toggled,
            [=]() { document->setModified(); });
 
    connect(m_ui->analyticalRadio, &QRadioButton::toggled, [=]() { document->setModified(); });
 
    connect(m_ui->averageLayerRadio, &QRadioButton::toggled, [=]() { document->setModified(); });
 
    connect(m_ui->numberOfThreadsCombo, QOverload<int>::of(&QComboBox::currentIndexChanged),
            [=]() { document->setModified(); });
 
    connect(m_ui->numberOfMonteCarloPoints, QOverload<int>::of(&QSpinBox::valueChanged),
            [=]() { document->setModified(); });
 
    connect(m_ui->includeSpecularCheck, &QCheckBox::toggled, [=]() { document->setModified(); });
 
    connect(m_document, &ProjectDocument::modified, this,
            &SimulationView::updateFunctionalityNarrowing);
}
 
void SimulationView::showEvent(QShowEvent*)
{
    writeOptionsToUI();
}
 
void SimulationView::writeOptionsToUI()
{
    QSignalBlocker b1(m_ui->runPolicyImmediatelyRadio);
    QSignalBlocker b2(m_ui->analyticalRadio);
    QSignalBlocker b3(m_ui->averageLayerRadio);
    QSignalBlocker b4(m_ui->numberOfThreadsCombo);
    QSignalBlocker b5(m_ui->numberOfMonteCarloPoints);
    QSignalBlocker b6(m_ui->includeSpecularCheck);
 
    // -- selection group
    updateSelection(m_ui->instrumentCombo, m_document->collectedItems()->instrumentNames());
    updateSelection(m_ui->sampleCombo, m_document->sampleItems()->sampleNames());
    updateSelection(m_ui->realDataCombo, m_document->realDataModel()->realDataNames(), true);
 
    // -- options group
    optionsItem()->runImmediately() ? m_ui->runPolicyImmediatelyRadio->setChecked(true)
                                    : m_ui->runPolicyBackgroundRadio->setChecked(true);
 
    optionsItem()->useAnalytical() ? m_ui->analyticalRadio->setChecked(true)
                                   : m_ui->monteCarloRadio->setChecked(true);
 
    optionsItem()->useAverageMaterials() ? m_ui->averageLayerRadio->setChecked(true)
                                         : m_ui->ambientLayerRadio->setChecked(true);
 
    m_ui->numberOfThreadsCombo->setCurrentIndex(
        m_ui->numberOfThreadsCombo->findData(optionsItem()->numberOfThreads()));
    m_ui->numberOfMonteCarloPoints->setValue(optionsItem()->numberOfMonteCarloPoints());
    m_ui->includeSpecularCheck->setChecked(optionsItem()->includeSpecularPeak());
 
    updateEnabling();
}
 
void SimulationView::hideEvent(QHideEvent*)
{
    // Storing the options has do be done here because on a showEvent the values are set again from
    // the SimulationOptionsItem (=> keep values when switching views)
    readOptionsFromUI();
}
 
void SimulationView::simulate()
{
    readOptionsFromUI();
    if (const QString msg = validateSimulationSetup(true); !msg.isEmpty()) {
        QMessageBox::warning(this, "Can't run the job",
                             "Can't run the job with current settings\n\n" + msg);
        return;
    }
    JobModel* jobModel = m_document->jobModel();
    JobItem* jobItem = jobModel->addJob(selectedSample(), selectedInstrument(), selectedRealData(),
                                        *optionsItem());
    jobModel->runJob(jobItem);
}
 
void SimulationView::exportPythonScript()
{
    readOptionsFromUI();
    if (const QString msg = validateSimulationSetup(false); !msg.isEmpty()) {
        QMessageBox::warning(this, "Can't export to Python",
                             "Can't export to Python with current settings\n\n" + msg);
        return;
    }
    auto* pythonWidget = new PythonScriptWidget(GUI::Global::mainWindow);
    pythonWidget->show();
    pythonWidget->raise();
    pythonWidget->generatePythonScript(selectedSample(), selectedInstrument(), *optionsItem(),
                                       ProjectManager::instance()->projectDir());
}
 
void SimulationView::readOptionsFromUI()
{
    optionsItem()->setRunImmediately(m_ui->runPolicyImmediatelyRadio->isChecked());
    optionsItem()->setNumberOfThreads(m_ui->numberOfThreadsCombo->currentData().toInt());
    if (m_ui->analyticalRadio->isChecked())
        optionsItem()->setUseAnalytical();
    else
        optionsItem()->setUseMonteCarloIntegration(m_ui->numberOfMonteCarloPoints->value());
    optionsItem()->setUseAverageMaterials(m_ui->averageLayerRadio->isChecked());
    optionsItem()->setIncludeSpecularPeak(m_ui->includeSpecularCheck->isChecked());
}
 
void SimulationView::updateEnabling()
{
    m_ui->numberOfMonteCarloPoints->setEnabled(m_ui->monteCarloRadio->isChecked());
}
 
void SimulationView::updateSelection(QComboBox* comboBox, QStringList itemList, bool allowNone)
{
    const QString previousItem = comboBox->currentText();
 
    comboBox->clear();
    comboBox->setEnabled(!itemList.isEmpty());
 
    if (itemList.isEmpty()) {
        comboBox->addItem("Not yet defined");
        return;
    }
 
    if (allowNone)
        itemList.insert(-1, "None");
    comboBox->addItems(itemList);
    if (itemList.contains(previousItem))
        comboBox->setCurrentIndex(itemList.indexOf(previousItem));
}
 
QString SimulationView::validateSimulationSetup(bool validateRealData) const
{
    QString messages;
    const auto append = [&](const QString& m) { messages.append("- " + m + "\n"); };
 
    if (!selectedSample())
        append("No sample selected");
    else {
        SampleValidator sampleValidator;
        if (!sampleValidator.isValidMultiLayer(selectedSample()))
            append(sampleValidator.getValidationMessage());
    }
 
    if (!selectedInstrument())
        append("No instrument selected");
 
    if (validateRealData && selectedRealData() && selectedInstrument()
        && !selectedInstrument()->alignedWith(selectedRealData()))
        append("The experimental data does not fit in the selected instrument. Try linking "
               "them in Import Tab.");
 
    return messages;
}
 
void SimulationView::updateFunctionalityNarrowing()
{
    m_ui->instrumentCombo->setVisible(!m_document->singleInstrumentMode());
    m_ui->instrumentLabel->setVisible(!m_document->singleInstrumentMode());
}
 
QVector<MultiLayerItem*> SimulationView::sampleItems() const
{
    return m_document->sampleItems()->sampleItems();
}
 
QVector<InstrumentItem*> SimulationView::collectedItems() const
{
    return m_document->collectedItems()->collectedItems();
}
 
QVector<RealDataItem*> SimulationView::realDataItems() const
{
    return m_document->realDataModel()->realDataItems();
}
 
SimulationOptionsItem* SimulationView::optionsItem() const
{
    return m_document->simulationOptionsItem();
}
 
const MultiLayerItem* SimulationView::selectedSample() const
{
    return sampleItems().value(m_ui->sampleCombo->currentIndex(), nullptr);
}
 
const InstrumentItem* SimulationView::selectedInstrument() const
{
    return collectedItems().value(m_ui->instrumentCombo->currentIndex(), nullptr);
}
 
const RealDataItem* SimulationView::selectedRealData() const
{
    return realDataItems().value(m_ui->realDataCombo->currentIndex() - 1, nullptr); // -1: "None"
}