SpecularBeamInclinationItem.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/SpecularBeamInclinationItem.cpp
//! @brief     Implements class SpecularBeamInclinationItem
//!
//! @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/SpecularBeamInclinationItem.h"
#include "Base/Axis/IAxis.h"
#include "Base/Const/Units.h"
#include "GUI/Model/CatDevice/DistributionItemCatalog.h"
#include "GUI/Model/Device/PointwiseAxisItem.h"
#include "GUI/Support/XML/Serialize.h"
 
namespace {
 
void setAxisPresentationDefaults(BasicAxisItem* axisItem)
{
    ASSERT(axisItem);
 
    axisItem->setTitle("alpha_i");
    axisItem->binsItem()->setToolTip("Number of points in scan");
    axisItem->minItem()->setToolTip("Starting value [deg]");
    axisItem->maxItem()->setToolTip("Ending value [deg]");
    axisItem->minItem()->setLimits(RealLimits::limited(0., 90.));
    axisItem->maxItem()->setLimits(RealLimits::limited(0., 90.));
 
    if (!dynamic_cast<PointwiseAxisItem*>(axisItem)) {
        axisItem->setLowerBound(0.0);
        axisItem->setUpperBound(3.0);
        axisItem->setBinCount(500);
    }
}
 
void initDistribution(DistributionItem* newDistribution,
                      const DistributionItem* currentDistribution)
{
    newDistribution->setLimits(RealLimits::limited(-90.0, 90.0));
    newDistribution->setUnit(Unit::degree);
 
    double meanVal = 0.0;
    if (auto* cd = dynamic_cast<const SymmetricResolutionItem*>(currentDistribution))
        meanVal = cd->mean();
 
    if (auto* nd = dynamic_cast<SymmetricResolutionItem*>(newDistribution)) {
        nd->setMean(meanVal);
        nd->setMeanDecimals(3);
    }
 
    newDistribution->initDistribution(meanVal);
};
 
 
} // namespace
 
SpecularBeamInclinationItem::SpecularBeamInclinationItem(const InstrumentItem* owningInstrument)
    : BeamDistributionItem()
    , m_owningInstrument(owningInstrument)
{
    m_distribution.initWithInitializer<DistributionItemCatalog>(
        "Distribution", "", "distribution", DistributionItemCatalog::symmetricTypes(),
        initDistribution);
 
    m_uniformAlphaAxis.reset(new BasicAxisItem());
    setAxisPresentationDefaults(m_uniformAlphaAxis.get());
    m_currentAxisIsUniformAxis = true;
}
 
void SpecularBeamInclinationItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwSelected<DistributionItemCatalog>(s, m_distribution);
    Serialize::rwValue(s, "currentAxisIsUniformAxis", m_currentAxisIsUniformAxis);
    Serialize::rwInitializable<BasicAxisItem>(s, "uniformAxis", m_uniformAlphaAxis,
                                              setAxisPresentationDefaults);
    Serialize::rwInitializable<PointwiseAxisItem>(s, "pointwiseAxis", m_pointwiseAlphaAxis,
                                                  setAxisPresentationDefaults);
 
    if (s.xmlReader()) {
        m_distribution->setLimits(RealLimits::limited(-90.0, 90.0));
        m_distribution->setUnit(Unit::degree);
        if (m_pointwiseAlphaAxis)
            m_pointwiseAlphaAxis->setOwningInstrument(m_owningInstrument);
    }
}
 
double SpecularBeamInclinationItem::scaleFactor() const
{
    return Units::deg;
}
 
BasicAxisItem* SpecularBeamInclinationItem::alphaAxis() const
{
    return m_currentAxisIsUniformAxis ? m_uniformAlphaAxis.get() : m_pointwiseAlphaAxis.get();
}
 
bool SpecularBeamInclinationItem::pointwiseAlphaAxisDefined() const
{
    return m_pointwiseAlphaAxis.get() != nullptr;
}
 
bool SpecularBeamInclinationItem::pointwiseAlphaAxisSelected() const
{
    return !m_currentAxisIsUniformAxis;
}
 
bool SpecularBeamInclinationItem::uniformAlphaAxisSelected() const
{
    return m_currentAxisIsUniformAxis;
}
 
void SpecularBeamInclinationItem::selectUniformAxis()
{
    m_currentAxisIsUniformAxis = true;
}
 
void SpecularBeamInclinationItem::selectPointwiseAxis()
{
    ASSERT(pointwiseAlphaAxisDefined());
    m_currentAxisIsUniformAxis = false;
}
 
void SpecularBeamInclinationItem::initUniformAxis(const IAxis& axis)
{
    m_uniformAlphaAxis->setBinCount(static_cast<int>(axis.size()));
}
 
void SpecularBeamInclinationItem::initPointwiseAxis(const IAxis& axis, QString units)
{
    if (!m_pointwiseAlphaAxis) {
        m_pointwiseAlphaAxis.reset(new PointwiseAxisItem());
        m_pointwiseAlphaAxis->setOwningInstrument(m_owningInstrument);
        setAxisPresentationDefaults(m_pointwiseAlphaAxis.get());
    }
 
    m_pointwiseAlphaAxis->init(axis, units);
    m_pointwiseAlphaAxis->updateIndicators();
}