AxesItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/AxesItems.cpp
//! @brief     Implements various axis items
//!
//! @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/AxesItems.h"
#include "Base/Axis/FixedBinAxis.h"
#include "GUI/Support/XML/Serialize.h"
 
const int max_detector_pixels = 65536;
 
BasicAxisItem::BasicAxisItem()
    : BasicAxisItem(M_TYPE)
{
}
 
int BasicAxisItem::binCount() const
{
    return getItemValue(P_NBINS).toInt();
}
 
void BasicAxisItem::setBinCount(size_t value)
{
    setItemValue(P_NBINS, (int)value);
}
 
SessionItem* BasicAxisItem::binsItem() const
{
    return getItem(P_NBINS);
}
 
DoubleDescriptor BasicAxisItem::min(const QString& unit) const
{
    DoubleDescriptor d(getItem(P_MIN_DEG), unit);
    d.label = "Min";
    return d;
}
 
void BasicAxisItem::setLowerBound(double value)
{
    setItemValue(P_MIN_DEG, value);
}
 
SessionItem* BasicAxisItem::minItem() const
{
    return getItem(P_MIN_DEG);
}
 
DoubleDescriptor BasicAxisItem::max(const QString& unit) const
{
    DoubleDescriptor d(getItem(P_MAX_DEG), unit);
    d.label = "Max";
    return d;
}
 
void BasicAxisItem::setUpperBound(double value)
{
    setItemValue(P_MAX_DEG, value);
}
 
SessionItem* BasicAxisItem::maxItem() const
{
    return getItem(P_MAX_DEG);
}
 
bool BasicAxisItem::isBoundsPropertiesName(const QString& name)
{
    return name == P_MIN_DEG || name == P_MAX_DEG;
}
 
QString BasicAxisItem::title() const
{
    return getItemValue(P_TITLE).toString();
}
 
void BasicAxisItem::setTitle(const QString& title)
{
    setItemValue(P_TITLE, title);
}
 
SessionItem* BasicAxisItem::titleItem() const
{
    return getItem(P_TITLE);
}
 
bool BasicAxisItem::isTitlePropertyName(const QString& name)
{
    return name == P_TITLE;
}
 
bool BasicAxisItem::isTitleVisible() const
{
    return getItemValue(P_TITLE_IS_VISIBLE).toBool();
}
 
bool BasicAxisItem::isTitleVisiblePropertyName(const QString& name)
{
    return name == P_TITLE_IS_VISIBLE;
}
 
std::unique_ptr<IAxis> BasicAxisItem::createAxis(double scale) const
{
    return std::make_unique<FixedBinAxis>(title().toStdString(), binCount(), min() * scale,
                                          max() * scale);
}
 
SessionItem* BasicAxisItem::visibilityItem() const
{
    return getItem(P_IS_VISIBLE);
}
 
bool BasicAxisItem::visibilityValue() const
{
    return visibilityItem()->value().toBool();
}
 
void BasicAxisItem::setVisibilityValue(bool b)
{
    setItemValue(P_IS_VISIBLE, b);
}
 
bool BasicAxisItem::isVisibilityPropertyName(const QString& name)
{
    return name == P_IS_VISIBLE;
}
 
BasicAxisItem::~BasicAxisItem() = default;
 
BasicAxisItem::BasicAxisItem(const QString& type)
    : SessionItem(type)
{
    addProperty(P_IS_VISIBLE, true);
    addProperty(P_NBINS, 100)->setLimits(RealLimits::limited(1, max_detector_pixels));
    addProperty(P_MIN_DEG, 0.0)->setDecimals(3).setLimits(RealLimits::limitless());
    addProperty(P_MAX_DEG, -1.0)->setDecimals(3).setLimits(RealLimits::limitless());
    addProperty(P_TITLE, QString());
    addProperty(P_TITLE_IS_VISIBLE, true);
}
 
void BasicAxisItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSessionItem<bool>(s, "visible", getItem(P_IS_VISIBLE));
    Serialize::rwSessionItem<int>(s, "nbins", getItem(P_NBINS));
    Serialize::rwSessionItem<double>(s, "min", getItem(P_MIN_DEG));
    Serialize::rwSessionItem<double>(s, "max", getItem(P_MAX_DEG));
    Serialize::rwSessionItem<QString>(s, "title", getItem(P_TITLE));
    Serialize::rwSessionItem<bool>(s, "titleVisible", getItem(P_TITLE_IS_VISIBLE));
}
 
// ---------------------------------------------------------------------------------------------- //
 
AmplitudeAxisItem::AmplitudeAxisItem()
    : BasicAxisItem(M_TYPE)
{
    addProperty(P_LOCK_MIN_MAX, false);
    addProperty(P_IS_LOGSCALE, true);
    visibilityItem();
}
 
void AmplitudeAxisItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwBaseClass<BasicAxisItem>(s, "base", this);
    Serialize::rwSessionItem<bool>(s, "lockMinMax", getItem(P_LOCK_MIN_MAX));
    Serialize::rwSessionItem<bool>(s, "log", getItem(P_IS_LOGSCALE));
}
 
bool AmplitudeAxisItem::isLogScale() const
{
    return getItemValue(P_IS_LOGSCALE).toBool();
}
 
void AmplitudeAxisItem::setLogScale(bool value)
{
    setItemValue(P_IS_LOGSCALE, value);
}
 
SessionItem* AmplitudeAxisItem::logScaleItem() const
{
    return getItem(P_IS_LOGSCALE);
}
 
bool AmplitudeAxisItem::isLogScalePropertyName(const QString& name)
{
    return name == P_IS_LOGSCALE;
}
 
bool AmplitudeAxisItem::isLocked() const
{
    return getItemValue(P_LOCK_MIN_MAX).toBool();
}
 
void AmplitudeAxisItem::setLocked(bool locked)
{
    setItemValue(P_LOCK_MIN_MAX, locked);
}