Beam.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Device/Beam/Beam.cpp
//! @brief     Implements class Beam.
//!
//! @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 "Device/Beam/Beam.h"
#include "Base/Math/Constants.h"
#include "Base/Spin/SpinMatrix.h"
#include "Base/Util/Assert.h"
#include "Device/Beam/FootprintGauss.h"
#include <heinz/Complex.h>
 
namespace {
 
// Allow for 90 degrees by adding a relatively small constant to pi/2
constexpr double INCLINATION_LIMIT = M_PI_2 + 1e-10;
 
const auto wavelengthLimits = RealLimits::nonnegative();
const auto phiLimits = RealLimits::limited(-M_PI_2, M_PI_2);
 
} // namespace
 
 
Beam::Beam(double intensity, double wavelength, const Direction& direction)
    : m_intensity(intensity)
    , m_wavelength(wavelength)
    // , m_direction(direction)
    , m_alpha(direction.alpha())
    , m_phi(direction.phi())
    , m_alphaLimits(RealLimits::limited(-INCLINATION_LIMIT, INCLINATION_LIMIT))
{
    RealLimits::nonnegative().check("Intensity", m_intensity);
 
    wavelengthLimits.check("Wavelength", m_wavelength);
    m_alphaLimits.check("InclinationAngle", m_alpha);
    phiLimits.check("AzimuthalAngle", m_phi);
}
 
Beam Beam::horizontalBeam()
{
    return Beam(1.0, 1.0, {0, 0});
}
 
Beam::Beam(const Beam& other)
    : Beam(other.m_intensity, other.m_wavelength, other.direction())
{
    m_beamPolarization = other.m_beamPolarization;
    if (other.m_shape_factor)
        m_shape_factor.reset(other.m_shape_factor->clone());
}
 
Beam& Beam::operator=(const Beam& other)
{
    if (&other == this)
        return *this;
    m_intensity = other.m_intensity;
    m_wavelength = other.m_wavelength;
    // m_direction = other.m_direction;
    m_alpha = other.m_alpha;
    m_phi = other.m_phi;
    m_beamPolarization = other.m_beamPolarization;
    if (other.m_shape_factor)
        m_shape_factor.reset(other.m_shape_factor->clone());
    else
        m_shape_factor.release();
    return *this;
}
 
Beam::~Beam() = default;
 
Beam* Beam::clone() const
{
    return new Beam(*this);
}
 
void Beam::setWavelength(double wavelength)
{
    if (wavelength <= 0.0)
        throw std::runtime_error("Invalid beam parameter: Wavelength can't be negative or zero.");
    m_wavelength = wavelength;
}
 
void Beam::setDirection(const Direction& direction)
{
    if (direction.alpha() < 0.0)
        throw std::runtime_error(
            "Invalid beam parameter: Inclination angle alpha_i can't be negative.");
    // m_direction = direction;
    m_alpha = direction.alpha();
    m_phi = direction.phi();
}
 
void Beam::setInclination(const double alpha)
{
    m_alpha = alpha;
}
 
void Beam::setInclinationLimits(const RealLimits& limits)
{
    m_alphaLimits = limits;
}
 
const IFootprintFactor* Beam::footprintFactor() const
{
    return m_shape_factor.get();
}
 
void Beam::setInclinationAngleGuarded(double value)
{
    m_alphaLimits.check("inclination angle", value);
    m_alpha = value;
}
 
void Beam::setAzimuthalAngleGuarded(double value)
{
    phiLimits.check("azimuthal angle", value);
    m_phi = value;
}
 
void Beam::setWavelengthGuarded(double value)
{
    wavelengthLimits.check("wavelength", value);
    m_wavelength = value;
}
 
void Beam::setFootprintFactor(const IFootprintFactor& shape_factor)
{
    m_shape_factor.reset(shape_factor.clone());
}
 
void Beam::setPolarization(const R3 bloch_vector)
{
    if (bloch_vector.mag() > 1.0) {
        throw std::runtime_error(
            "Beam::setPolarization: "
            "The given Bloch vector cannot represent a real physical ensemble");
    }
    m_beamPolarization = bloch_vector;
}
 
R3 Beam::polVector() const
{
    return m_beamPolarization;
}
 
SpinMatrix Beam::polMatrix() const
{
    return SpinMatrix::FromBlochVector(m_beamPolarization);
}
 
std::vector<const INode*> Beam::nodeChildren() const
{
    if (m_shape_factor)
        return {m_shape_factor.get()};
    return {};
}