BeamItems.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      GUI/Model/Device/BeamItems.cpp
//! @brief     Implements BeamItem hierarchy
//!
//! @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/BeamItems.h"
#include "Base/Axis/IAxis.h"
#include "Base/Const/Units.h"
#include "Device/Beam/Beam.h"
#include "GUI/Model/CatDevice/FootprintItemCatalog.h"
#include "GUI/Model/Device/BeamAngleItems.h"
#include "GUI/Model/Device/BeamWavelengthItem.h"
#include "GUI/Model/Device/FootprintItems.h"
#include "GUI/Model/Device/PointwiseAxisItem.h"
#include "GUI/Support/XML/Serialize.h"
#include <cmath>
 
namespace {
 
// defines wavelength limits according to given maximum q value
RealLimits getLimits(double max_q)
{
    double upper_lim = std::nextafter(4.0 * M_PI / max_q, 0.0);
    RealLimits result = RealLimits::positive();
    result.setUpperLimit(upper_lim);
    return result;
}
 
} // namespace
 
BeamItem::BeamItem()
{
    m_intensity.init("Intensity", "Beam intensity in neutrons (or gammas) per sec.", 1e+08,
                     Unit::unitless, 3, RealLimits::limited(0.0, 1e+32), "intensity");
 
    m_azimuthalAngleItem.reset(new BeamAzimuthalAngleItem());
}
 
void BeamItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwProperty(s, m_intensity);
    Serialize::rwClass(s, "wavelength", *m_wavelengthItem);
    Serialize::rwClass(s, "azimuth", *m_azimuthalAngleItem);
    Serialize::rwClass(s, "inclination", *m_inclinationAngleItem);
}
 
double BeamItem::wavelength() const
{
    return m_wavelengthItem->wavelength();
}
 
void BeamItem::setWavelength(double value)
{
    m_wavelengthItem->resetToValue(value);
}
 
BeamWavelengthItem* BeamItem::wavelengthItem() const
{
    return m_wavelengthItem.get();
}
 
void BeamItem::setInclinationAngle(double value)
{
    m_inclinationAngleItem->resetToValue(value);
}
 
BeamDistributionItem* BeamItem::inclinationAngleItem() const
{
    return m_inclinationAngleItem.get();
}
 
double BeamItem::getAzimuthalAngle() const
{
    return m_azimuthalAngleItem->azimuthalAngle();
}
 
void BeamItem::setAzimuthalAngle(double value)
{
    m_azimuthalAngleItem->resetToValue(value);
}
 
BeamAzimuthalAngleItem* BeamItem::azimuthalAngleItem() const
{
    return m_azimuthalAngleItem.get();
}
 
std::unique_ptr<Beam> BeamItem::createBeam() const
{
    double lambda = wavelength();
    double inclination_angle = Units::deg2rad(getInclinationAngle());
    double azimuthal_angle = Units::deg2rad(getAzimuthalAngle());
 
    auto result =
        std::make_unique<Beam>(intensity(), lambda, Direction(inclination_angle, azimuthal_angle));
 
    return result;
}
 
template <typename T>
void BeamItem::initWavelength()
{
    m_wavelengthItem.reset(new T());
}
 
template <typename T>
void BeamItem::initInclinationAngle()
{
    m_inclinationAngleItem.reset(new T());
}
 
// Specular beam item
/* ------------------------------------------------------------------------- */
 
SpecularBeamItem::SpecularBeamItem(const InstrumentItem* owningInstrument)
{
    m_inclinationAngleItem.reset(new SpecularBeamInclinationItem(owningInstrument));
    initWavelength<SpecularBeamWavelengthItem>();
 
    m_footprint.init<FootprintItemCatalog>("Type", "Footprint type", "footprint");
}
 
void SpecularBeamItem::serialize(Streamer& s)
{
    s.assertVersion(0);
    Serialize::rwBaseClass<BeamItem>(s, "BeamItem", this);
    Serialize::rwSelected<FootprintItemCatalog>(s, m_footprint);
}
 
double SpecularBeamItem::getInclinationAngle() const
{
    return 0.0;
}
 
void SpecularBeamItem::setInclinationAngle(double value)
{
    ASSERT(value == 0.0);
    value = 0.0;
    BeamItem::setInclinationAngle(value);
}
 
SpecularBeamInclinationItem* SpecularBeamItem::inclinationAngleItem() const
{
    return dynamic_cast<SpecularBeamInclinationItem*>(BeamItem::inclinationAngleItem());
}
 
BasicAxisItem* SpecularBeamItem::inclinationAxis() const
{
    return inclinationAngleItem()->alphaAxis();
}
 
FootprintItem* SpecularBeamItem::footprint() const
{
    return m_footprint.get();
}
 
SelectionDescriptor<FootprintItem*> SpecularBeamItem::footprintSelection() const
{
    return m_footprint;
}
 
void SpecularBeamItem::setGaussianFootprint(double value)
{
    m_footprint.set(new FootprintGaussianItem(value));
}
 
void SpecularBeamItem::setSquareFootprint(double value)
{
    m_footprint.set(new FootprintSquareItem(value));
}
 
void SpecularBeamItem::updateToData(const IAxis& axis, QString units)
{
    if (units == "nbins") {
        inclinationAngleItem()->initUniformAxis(axis);
        inclinationAngleItem()->selectUniformAxis();
    } else {
        inclinationAngleItem()->initPointwiseAxis(axis, units);
        inclinationAngleItem()->selectPointwiseAxis();
    }
    updateWavelength();
}
 
void SpecularBeamItem::updateWavelength()
{
    auto* item = inclinationAngleItem()->alphaAxis();
    auto* wavelength = dynamic_cast<SpecularBeamWavelengthItem*>(wavelengthItem());
    if (auto* pointwiseAxis = dynamic_cast<PointwiseAxisItem*>(item)) {
        const auto* axis = pointwiseAxis->axis();
        if (axis && pointwiseAxis->getUnitsLabel() == "q-space")
            wavelength->setToRange(getLimits(axis->max()));
    } else
        wavelength->setToRange(RealLimits::positive());
}
 
// GISAS beam item
/* ------------------------------------------------------------------------- */
 
GISASBeamItem::GISASBeamItem()
{
    initInclinationAngle<BeamInclinationAngleItem>();
    initWavelength<BeamWavelengthItem>();
}
 
double GISASBeamItem::getInclinationAngle() const
{
    return m_inclinationAngleGetter
               ? m_inclinationAngleGetter()
               : dynamic_cast<BeamInclinationAngleItem*>(inclinationAngleItem())
                     ->inclinationAngle();
}
 
void GISASBeamItem::setInclinationAngleGetter(std::function<double()> getter)
{
    m_inclinationAngleGetter = getter;
}