SpecularDataItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Data/SpecularDataItem.cpp
//! @brief     Implements class SpecularDataItem
//!
//! @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/SpecularDataItem.h"
#include "Base/Axis/IAxis.h"
#include "GUI/Model/Data/JobItemUtils.h"
#include "GUI/Model/Device/AxesItems.h"
#include "GUI/Support/IO/ImportDataInfo.h"
#include "GUI/Util/Error.h"
 
namespace {
 
const QString x_axis_default_name = "X [nbins]";
const QString y_axis_default_name = "Signal [a.u.]";
 
} // namespace
 
SpecularDataItem::SpecularDataItem()
    : DataItem(M_TYPE)
{
    addProperty(P_TITLE, QString());
 
    addProperty<BasicAxisItem>(P_XAXIS);
 
    auto* amplitudeAxis = addProperty<AmplitudeAxisItem>(P_YAXIS);
    amplitudeAxis->visibilityItem()->setValue(true);
 
    xAxisItem()->setTitle(x_axis_default_name);
    yAxisItem()->setTitle(y_axis_default_name);
}
 
void SpecularDataItem::setDatafield(Datafield* data)
{
    if (data != nullptr) {
        if (data->rank() != 1)
            throw Error("Error in SpecularDataItem::setDatafield: cannot handle non-1D data");
        DataItem::setDatafield(data);
        updateAxesZoomLevel();
    } else {
        DataItem::setDatafield(data);
    }
 
    emitDataChanged();
}
 
int SpecularDataItem::getNbins() const
{
    return xAxisItem()->binCount();
}
 
double SpecularDataItem::getLowerX() const
{
    return xAxisItem()->min();
}
 
double SpecularDataItem::getUpperX() const
{
    return xAxisItem()->max();
}
 
double SpecularDataItem::xMin() const
{
    const double defaultXmin(0.0);
    return m_data ? m_data->axis(0).min() : defaultXmin;
}
 
double SpecularDataItem::xMax() const
{
    const double defaultXmax(1.0);
    return m_data ? m_data->axis(0).max() : defaultXmax;
}
 
double SpecularDataItem::getLowerY() const
{
    return yAxisItem()->min();
}
 
double SpecularDataItem::getUpperY() const
{
    return yAxisItem()->max();
}
 
double SpecularDataItem::yMin() const
{
    return dataRange().first;
}
 
double SpecularDataItem::yMax() const
{
    return dataRange().second;
}
 
bool SpecularDataItem::isLog() const
{
    return yAxisItem()->isLogScale();
}
 
QString SpecularDataItem::getXaxisTitle() const
{
    return xAxisItem()->title();
}
 
QString SpecularDataItem::getYaxisTitle() const
{
    return yAxisItem()->title();
}
 
void SpecularDataItem::setXaxisTitle(const QString& title)
{
    xAxisItem()->setTitle(title);
}
 
void SpecularDataItem::setYaxisTitle(const QString& title)
{
    yAxisItem()->setTitle(title);
}
 
//! set zoom range of x,y axes to axes of input data
void SpecularDataItem::setAxesRangeToData()
{
    setLowerX(xMin());
    setUpperX(xMax());
    setLowerY(yMin());
    setUpperY(yMax());
}
 
void SpecularDataItem::updateCoords(const InstrumentItem* instrument)
{
    GUI::Model::JobItemUtils::updateDataAxes(this, instrument);
}
 
std::vector<int> SpecularDataItem::shape() const
{
    return {getNbins()};
}
 
void SpecularDataItem::reset(ImportDataInfo data)
{
    ComboProperty combo = ComboProperty() << data.unitsLabel();
    setAxesUnits(combo);
    setXaxisTitle(data.axisLabel(0));
    setYaxisTitle(data.axisLabel(1));
    setDatafield(std::move(data).intensityData().release());
    setAxesRangeToData();
}
 
bool SpecularDataItem::isXaxisPropertyName(const QString& name)
{
    return name == P_XAXIS;
}
 
bool SpecularDataItem::isYaxisPropertyName(const QString& name)
{
    return name == P_YAXIS;
}
 
void SpecularDataItem::setLowerX(double value)
{
    xAxisItem()->setLowerBound(value);
}
 
void SpecularDataItem::setUpperX(double value)
{
    xAxisItem()->setUpperBound(value);
}
 
void SpecularDataItem::setLowerY(double value)
{
    yAxisItem()->setLowerBound(value);
}
 
void SpecularDataItem::setUpperY(double value)
{
    yAxisItem()->setUpperBound(value);
}
 
void SpecularDataItem::setLog(bool log_flag)
{
    yAxisItem()->setLogScale(log_flag);
}
 
//! Sets zoom range of X,Y axes, if it was not yet defined.
 
void SpecularDataItem::updateAxesZoomLevel()
{
    // set zoom range of x-axis to min, max values if it was not set already
    if (getUpperX() < getLowerX()) {
        setLowerX(xMin());
        setUpperX(xMax());
    }
 
    // set zoom range of y-axis to min, max values if it was not set already
    if (getUpperY() < getLowerY()) {
        setLowerY(yMin());
        setUpperY(yMax());
    }
 
    const int nx = static_cast<int>(m_data->axis(0).size());
    xAxisItem()->setBinCount(nx);
}
 
//! Init ymin, ymax to match the intensity values range.
QPair<double, double> SpecularDataItem::dataRange() const
{
    const double default_min = 0.0;
    const double default_max = 1.0;
    const Datafield* data = getDatafield();
    if (!data)
        return QPair<double, double>(default_min, default_max);
 
    const auto vec = data->flatVector();
    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);
}
 
const BasicAxisItem* SpecularDataItem::xAxisItem() const
{
    return item<BasicAxisItem>(P_XAXIS);
}
 
BasicAxisItem* SpecularDataItem::xAxisItem()
{
    return item<BasicAxisItem>(P_XAXIS);
}
 
const AmplitudeAxisItem* SpecularDataItem::yAxisItem() const
{
    return item<AmplitudeAxisItem>(P_YAXIS);
}
 
AmplitudeAxisItem* SpecularDataItem::yAxisItem()
{
    return item<AmplitudeAxisItem>(P_YAXIS);
}
 
//! Set axes viewport to original data.
 
void SpecularDataItem::resetView()
{
    setAxesRangeToData();
}