Data1DViewItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Data/Data1DViewItem.cpp
//! @brief     Implements class Data1DViewItem
//!
//! @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/Data/Data1DViewItem.h"
#include "GUI/Model/Data/DataItem.h"
#include "GUI/Model/Data/DataProperties.h"
#include "GUI/Model/Data/DataPropertyContainer.h"
#include "GUI/Model/Data/DataViewUtils.h"
#include "GUI/Model/Device/AxesItems.h"
#include "GUI/Model/Job/JobItem.h"
#include "GUI/Util/ComboProperty.h"
#include "GUI/Util/Error.h"
 
namespace {
 
const QString x_axis_default_name = "X [nbins]";
const QString y_axis_default_name = "Signal [a.u.]";
 
const double default_min = 0.0;
const double default_max = 1.0;
 
} // namespace
 
Data1DViewItem::Data1DViewItem()
    : SessionItem(M_TYPE)
    , m_job_item(nullptr)
{
    addProperty(P_TITLE, QString());
 
    auto* basicAxis = addProperty<BasicAxisItem>(P_XAXIS);
    basicAxis->binsItem();
 
    auto* amplitudeAxis = addProperty<AmplitudeAxisItem>(P_YAXIS);
    amplitudeAxis->binsItem();
    amplitudeAxis->titleItem();
    amplitudeAxis->visibilityItem()->setValue(true);
    amplitudeAxis->visibilityItem();
 
    registerTag(T_DATA_PROPERTIES, 1, 1, {DataPropertyContainer::M_TYPE});
 
    ComboProperty combo = ComboProperty() << "nbins";
    addProperty(P_AXES_UNITS, combo.variant());
 
    mapper()->setOnPropertyChange([this](const QString& name) {
        if (name != P_AXES_UNITS)
            return;
        setAxesRangeToData();
        GUI::Model::DataViewUtils::updateAxesTitle(this);
    });
 
    setLowerX(default_min);
    setUpperX(default_max);
    setLowerY(default_min);
    setUpperY(default_max);
    setXaxisTitle(x_axis_default_name);
    setYaxisTitle(y_axis_default_name);
}
 
int Data1DViewItem::getNbins() const
{
    return xAxisItem()->binCount();
}
 
double Data1DViewItem::getLowerX() const
{
    return xAxisItem()->min();
}
 
double Data1DViewItem::getUpperX() const
{
    return xAxisItem()->max();
}
 
double Data1DViewItem::getLowerY() const
{
    return yAxisItem()->min();
}
 
double Data1DViewItem::getUpperY() const
{
    return yAxisItem()->max();
}
 
bool Data1DViewItem::isLog() const
{
    return yAxisItem()->isLogScale();
}
 
QString Data1DViewItem::getXaxisTitle() const
{
    return xAxisItem()->title();
}
 
QString Data1DViewItem::getYaxisTitle() const
{
    return yAxisItem()->title();
}
 
void Data1DViewItem::setXaxisTitle(const QString& title)
{
    xAxisItem()->setTitle(title);
}
 
void Data1DViewItem::setYaxisTitle(const QString& title)
{
    yAxisItem()->setTitle(title);
}
 
//! set zoom range of x,y axes to axes of input data
void Data1DViewItem::setAxesRangeToData()
{
    const auto data = GUI::Model::DataViewUtils::getTranslatedData(
        this, propertyContainerItem()->basicDataItem());
 
    // For data loading from disk: items appear earlier than
    // actual data.
    if (!data)
        return;
 
    setLowerX(data->axis(0).min());
    setUpperX(data->axis(0).max());
 
    auto data_range = dataRange(data.get());
    setLowerY(data_range.first);
    setUpperY(data_range.second);
}
 
ComboProperty Data1DViewItem::axesUnits() const
{
    return getItemValue(P_AXES_UNITS).value<ComboProperty>();
}
 
void Data1DViewItem::setAxesUnits(const ComboProperty& units)
{
    setItemValue(Data1DViewItem::P_AXES_UNITS, units.variant());
}
 
SelectionDescriptor<QString> Data1DViewItem::axesUnitsDescriptor() const
{
    return SelectionDescriptor<QString>(getItem(P_AXES_UNITS));
}
 
bool Data1DViewItem::isAxesUnitsPropertyName(const QString& name)
{
    return name == P_AXES_UNITS;
}
 
void Data1DViewItem::resetToDefault()
{
    // TODO: implement when applying DataITem1DView in ImportView
    throw Error("Error in DataItem1DView::resetToDefault: not implemented");
}
 
QPair<QVector<double>, QVector<double>> Data1DViewItem::graphData(Data1DProperties* property_item)
{
    const auto data = GUI::Model::DataViewUtils::getTranslatedData(this, property_item->dataItem());
    if (!data)
        return {};
 
#if QT_VERSION >= QT_VERSION_CHECK(5, 14, 0)
    auto centers = data->axis(0).binCenters();
    auto values = data->flatVector();
    return {QVector<double>(centers.cbegin(), centers.cend()),
            QVector<double>(values.cbegin(), values.cend())};
#else
    return {QVector<double>::fromStdVector(data->axis(0).binCenters()),
            QVector<double>::fromStdVector(data->flatVector())};
#endif
}
 
JobItem* Data1DViewItem::jobItem()
{
    if (m_job_item != nullptr)
        return m_job_item; // returning preset job item
 
    auto* item = parentItem();
    do {
        if (item->modelType() == JobItem::M_TYPE) {
            m_job_item = dynamic_cast<JobItem*>(item);
            return m_job_item;
        }
    } while ((item = item->parentItem()));
    throw Error("Error in DataItem1DView::jobItem: passed item is not owned by any job item");
}
 
void Data1DViewItem::setLowerX(double value)
{
    xAxisItem()->setLowerBound(value);
}
 
void Data1DViewItem::setUpperX(double value)
{
    xAxisItem()->setUpperBound(value);
}
 
void Data1DViewItem::setLowerY(double value)
{
    yAxisItem()->setLowerBound(value);
}
 
void Data1DViewItem::setUpperY(double value)
{
    yAxisItem()->setUpperBound(value);
}
 
void Data1DViewItem::setLog(bool log_flag)
{
    yAxisItem()->setLogScale(log_flag);
}
 
DataPropertyContainer* Data1DViewItem::propertyContainerItem()
{
    return item<DataPropertyContainer>(T_DATA_PROPERTIES);
}
 
DataPropertyContainer* Data1DViewItem::createPropertyContainerItem()
{
    return model()->insertItem<DataPropertyContainer>(this, -1, T_DATA_PROPERTIES);
}
 
const BasicAxisItem* Data1DViewItem::xAxisItem() const
{
    return item<BasicAxisItem>(P_XAXIS);
}
 
BasicAxisItem* Data1DViewItem::xAxisItem()
{
    return item<BasicAxisItem>(P_XAXIS);
}
 
const AmplitudeAxisItem* Data1DViewItem::yAxisItem() const
{
    return item<AmplitudeAxisItem>(P_YAXIS);
}
 
AmplitudeAxisItem* Data1DViewItem::yAxisItem()
{
    return item<AmplitudeAxisItem>(P_YAXIS);
}
 
bool Data1DViewItem::isXAxisPropertyName(const QString& name)
{
    return name == P_XAXIS;
}
 
bool Data1DViewItem::isYAxisPropertyName(const QString& name)
{
    return name == P_YAXIS;
}
 
//! Set axes viewport to original data.
 
void Data1DViewItem::resetView()
{
    setAxesRangeToData();
}
 
//! Init ymin, ymax to match the intensity values range.
QPair<double, double> Data1DViewItem::dataRange(const Datafield* data) const
{
    if (!data)
        return QPair<double, double>(default_min, default_max);
 
    const auto vec =
        data->flatVector(); // TODO merge code here, SpecularDataItem, IntensityDataItem
    double min(*std::min_element(vec.cbegin(), vec.cend()));
    double max(*std::max_element(vec.cbegin(), vec.cend()));
 
    min /= 2.0;
    min = std::numeric_limits<double>::epsilon() < min ? min : default_min;
    max *= 2.0;
    max = max > min ? max : default_max;
 
    return QPair<double, double>(min, max);
}