FitComparisonController.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/View/PlotComparison/FitComparisonController.cpp
//! @brief     Implements class FitComparisonController
//!
//! @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/PlotComparison/FitComparisonController.h"
#include "Device/Histo/DiffUtil.h"
#include "GUI/Model/Data/IntensityDataItem.h"
#include "GUI/Model/Data/RealDataItem.h"
#include "GUI/Model/Data/SpecularDataItem.h"
#include "GUI/Model/Device/AxesItems.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/View/PlotComparison/PropertyRepeater.h"
 
namespace {
 
// different limits on relative difference plot are required
// to provide the best appearance
const double relative_diff_min_2d = 1e-05;
const double relative_diff_max_2d = 1.0;
 
} // namespace
 
class FitComparisonController2D::DiffItemController : public QObject {
public:
    DiffItemController(const QString& data_type, QObject* parent);
    ~DiffItemController() override;
    void setItem(JobItem* job_item);
    void updateDiffData();
    DataItem* diffItem();
    void subscribe();
    void unsubscribe();
 
private:
    JobItem* m_current_item;
    SessionModel* m_tempIntensityDataModel;
    DataItem* m_diff_item;
};
 
using DiffItemController = FitComparisonController2D::DiffItemController;
 
FitComparisonController2D::FitComparisonController2D(QObject* parent)
    : QObject(parent)
    , m_diff_item_controller(new DiffItemController(IntensityDataItem::M_TYPE, this))
    , m_appearanceRepeater(new PropertyRepeater(this))
    , m_xAxisRepeater(new PropertyRepeater(this))
    , m_yAxisRepeater(new PropertyRepeater(this))
    , m_zAxisRepeater(new PropertyRepeater(this))
{
}
 
IntensityDataItem* FitComparisonController2D::diffItem()
{
    ASSERT(dynamic_cast<IntensityDataItem*>(m_diff_item_controller->diffItem()));
    return dynamic_cast<IntensityDataItem*>(m_diff_item_controller->diffItem());
}
 
void FitComparisonController2D::setItem(JobItem* job_item)
{
    ASSERT(job_item);
 
    clear();
    m_diff_item_controller->setItem(job_item);
 
    auto* sim_data_item = dynamic_cast<IntensityDataItem*>(job_item->dataItem());
    auto* real_data_item = dynamic_cast<IntensityDataItem*>(job_item->realDataItem()->dataItem());
 
    double zmin = real_data_item->getLowerZ();
    double zmax = real_data_item->getUpperZ();
    sim_data_item->setLowerAndUpperZ(zmin, zmax);
 
    diffItem()->xAxisItem()->setTitle(sim_data_item->getXaxisTitle());
    diffItem()->yAxisItem()->setTitle(sim_data_item->getYaxisTitle());
    diffItem()->setLowerAndUpperZ(relative_diff_min_2d, relative_diff_max_2d);
    diffItem()->setAxesRangeToData();
 
    m_appearanceRepeater->addItem(real_data_item);
    m_appearanceRepeater->addItem(sim_data_item);
    m_appearanceRepeater->addItem(diffItem());
 
    m_xAxisRepeater->addItem(real_data_item->xAxisItem());
    m_xAxisRepeater->addItem(sim_data_item->xAxisItem());
    m_xAxisRepeater->addItem(diffItem()->xAxisItem());
 
    m_yAxisRepeater->addItem(real_data_item->yAxisItem());
    m_yAxisRepeater->addItem(sim_data_item->yAxisItem());
    m_yAxisRepeater->addItem(diffItem()->yAxisItem());
 
    m_zAxisRepeater->addItem(real_data_item->zAxisItem());
    m_zAxisRepeater->addItem(sim_data_item->zAxisItem());
}
 
void FitComparisonController2D::updateDiffData()
{
    m_diff_item_controller->updateDiffData();
}
 
void FitComparisonController2D::resetDiffItem()
{
    diffItem()->resetView();
    diffItem()->setLowerAndUpperZ(relative_diff_min_2d, relative_diff_max_2d);
}
 
void FitComparisonController2D::clear()
{
    m_diff_item_controller->unsubscribe();
 
    m_appearanceRepeater->clear();
    m_xAxisRepeater->clear();
    m_yAxisRepeater->clear();
    m_zAxisRepeater->clear();
}
 
DiffItemController::DiffItemController(const QString& data_type, QObject* parent)
    : QObject(parent)
    , m_current_item(nullptr)
    , m_tempIntensityDataModel(new SessionModel("TempIntensityDataModel", this))
    , m_diff_item(dynamic_cast<DataItem*>(m_tempIntensityDataModel->insertNewItem(data_type)))
{
    ASSERT(m_diff_item);
}
 
DiffItemController::~DiffItemController()
{
    unsubscribe();
}
 
void DiffItemController::setItem(JobItem* job_item)
{
    ASSERT(job_item);
    if (m_current_item)
        unsubscribe();
    m_current_item = job_item;
    subscribe();
    updateDiffData();
}
 
void DiffItemController::updateDiffData()
{
    ASSERT(m_current_item);
 
    auto* sim_data = m_current_item->dataItem();
    auto* real_data = m_current_item->realDataItem()->dataItem();
    ASSERT(sim_data && real_data);
 
    if (!sim_data->getDatafield()) // job failed
        return;
 
    m_diff_item->setDatafield(
        DiffUtil::relativeDifferenceField(*sim_data->getDatafield(), *real_data->getDatafield()));
}
 
DataItem* DiffItemController::diffItem()
{
    return m_diff_item;
}
 
void DiffItemController::subscribe()
{
    if (!m_current_item) {
        ASSERT(false);
        return;
    }
 
    // on simulation data change
    connect(m_current_item->dataItem(), &DataItem::datafieldChanged, this,
            [=](Datafield*) { updateDiffData(); });
 
    // on diff item units change
    connect(m_diff_item, &DataItem::axesUnitsChanged, this, [=](const ComboProperty&) {
        m_diff_item->updateCoords(m_current_item->instrumentItem());
    });
}
 
void DiffItemController::unsubscribe()
{
    if (!m_current_item)
        return;
 
    disconnect(m_current_item->dataItem(), nullptr, this, nullptr);
    disconnect(m_diff_item, nullptr, this, nullptr);
    m_current_item = nullptr;
}