BeamItems.cpp

//  ************************************************************************************************
//
//  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 "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/BeamItems.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 {

namespace Tag {

const QString Intensity("Intensity");
const QString Wavelength("Wavelength");
const QString AzimuthalAngle("AzimuthalAngle");
const QString InclinationAngle("InclinationAngle");

}

// 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, Tag::Intensity, m_intensity);
    Serialize::rwClass(s, Tag::Wavelength, *m_wavelengthItem);
    Serialize::rwClass(s, Tag::AzimuthalAngle, *m_azimuthalAngleItem);
    Serialize::rwClass(s, Tag::InclinationAngle, *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::shared_ptr<Beam> BeamItem::createBeam() const
{
    double lambda = wavelength();
    double inclination_angle = Units::deg2rad(getInclinationAngle());
    double azimuthal_angle = Units::deg2rad(getAzimuthalAngle());

    auto result =
        std::make_shared<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;
}