PointwiseAxisItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/PointwiseAxisItem.cpp
//! @brief     Implements pointwise axis item
//!
//! @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/Device/PointwiseAxisItem.h"
#include "Base/Axis/PointwiseAxis.h"
#include "Device/Coord/ICoordSystem.h"
#include "Device/Data/Datafield.h"
#include "Device/IO/IOFactory.h"
#include "Device/IO/ReadWriteINT.h"
#include "GUI/Model/Device/InstrumentItems.h"
#include "GUI/Support/XML/Serialize.h"
 
PointwiseAxisItem::PointwiseAxisItem()
    : BasicAxisItem(M_TYPE)
    , m_instrumentItem(nullptr)
{
    minItem()->setEnabled(false);
    binsItem()->setEnabled(false);
    maxItem()->setEnabled(false);
    addProperty(P_NATIVE_AXIS_UNITS, "nbins");
}
 
PointwiseAxisItem::~PointwiseAxisItem() = default;
 
void PointwiseAxisItem::serialize(Streamer& s)
{
    QByteArray a;
    if (s.xmlWriter())
        a = serializeBinaryData();
 
    s.assertVersion(0);
    Serialize::rwBaseClass<BasicAxisItem>(s, "base", this);
    Serialize::rwSessionItem<QString>(s, "nativeUnits", getItem(P_NATIVE_AXIS_UNITS));
    Serialize::rwValue(s, "axisData", a);
 
    if (s.xmlReader())
        deserializeBinaryData(a);
}
 
void PointwiseAxisItem::init(const IAxis& axis, const QString& units_label)
{
    m_axis = std::unique_ptr<IAxis>(axis.clone());
    setItemValue(P_NATIVE_AXIS_UNITS, units_label);
}
 
void PointwiseAxisItem::setOwningInstrument(const InstrumentItem* instrument)
{
    // only specular instruments are relevant
    m_instrumentItem = dynamic_cast<const SpecularInstrumentItem*>(instrument);
}
 
const IAxis* PointwiseAxisItem::axis() const
{
    return m_axis.get();
}
 
QString PointwiseAxisItem::getUnitsLabel() const
{
    return getItemValue(P_NATIVE_AXIS_UNITS).toString();
}
 
std::unique_ptr<IAxis> PointwiseAxisItem::createAxis(double scale) const
{
    if (!checkValidity())
        return nullptr;
 
    auto* const converter = m_instrumentItem->createCoordSystem();
    std::unique_ptr<IAxis> converted_axis(converter->createConvertedAxis(0, Coords::DEGREES));
 
    // applying scaling
    std::vector<double> centers = converted_axis->binCenters();
    for (double& e : centers)
        e *= scale;
 
    return std::make_unique<PointwiseAxis>(converted_axis->axisName(), std::move(centers));
}
 
QByteArray PointwiseAxisItem::serializeBinaryData() const
{
    if (!m_axis)
        return {};
    Datafield axisData({m_axis->clone()});
 
    std::stringstream ss;
    ReadWriteINT().writeDatafield(axisData, ss);
    return QByteArray(ss.str().c_str(), static_cast<int>(ss.str().size()));
}
 
void PointwiseAxisItem::deserializeBinaryData(const QByteArray& data)
{
    if (data.isEmpty())
        return;
 
    std::istringstream str(data.toStdString());
    std::unique_ptr<Datafield> d(ReadWriteINT().readDatafield(str));
    m_axis = std::unique_ptr<IAxis>(d->axis(0).clone());
}
 
bool PointwiseAxisItem::checkValidity() const
{
    return m_axis && m_instrumentItem && getUnitsLabel() != "nbins";
}
 
void PointwiseAxisItem::updateIndicators()
{
    if (!checkValidity())
        return;
 
    auto* const converter = m_instrumentItem->createCoordSystem();
    setLowerBound(converter->calculateMin(0, Coords::DEGREES));
    setUpperBound(converter->calculateMax(0, Coords::DEGREES));
    setBinCount(static_cast<int>(m_axis->size()));
 
    emitDataChanged();
}