DiffuseElement.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Resample/Element/DiffuseElement.cpp
//! @brief     Implements class DiffuseElement.
//!
//! @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 "Resample/Element/DiffuseElement.h"
#include "Base/Pixel/IPixel.h"
#include "Base/Vector/Direction.h"
#include "Base/Vector/WavevectorInfo.h"
#include "Resample/Flux/IFlux.h"
 
DiffuseElement::DiffuseElement(double wavelength, double alpha_i, double phi_i,
                               std::unique_ptr<IPixel> pixel, const SpinMatrix& beam_polMatrices,
                               const SpinMatrix& analyzer, bool isSpecular_,
                               const Fluxes* const fluxes_in, const Fluxes* const fluxes_out)
    : IElement({beam_polMatrices, analyzer})
    , m_wavelength(wavelength)
    , m_alpha_i(alpha_i)
    , m_phi_i(phi_i)
    , m_k_i(vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i))
    , m_mean_kf(pixel->getK(0.5, 0.5, m_wavelength))
    , m_pixel(std::move(pixel))
    , m_is_specular(isSpecular_)
    , m_fluxes_in(fluxes_in)
    , m_fluxes_out(fluxes_out)
    , m_intensity(0.0)
{
}
 
DiffuseElement::DiffuseElement(DiffuseElement&& other)
    : IElement(other.m_polMatrices)
    , m_wavelength(other.m_wavelength)
    , m_alpha_i(other.m_alpha_i)
    , m_phi_i(other.m_phi_i)
    , m_k_i(other.m_k_i)
    , m_mean_kf(other.m_mean_kf)
    , m_pixel(std::move(other.m_pixel))
    , m_is_specular(other.m_is_specular)
    , m_fluxes_in(other.m_fluxes_in)
    , m_fluxes_out(other.m_fluxes_out)
    , m_intensity(other.m_intensity)
{
}
 
DiffuseElement::~DiffuseElement() = default;
 
void DiffuseElement::setFluxes(const Fluxes* fluxes_in, const Fluxes* fluxes_out)
{
    m_fluxes_in = fluxes_in;
    m_fluxes_out = fluxes_out;
}
 
const IFlux* DiffuseElement::fluxIn(size_t i_layer) const
{
    return (*m_fluxes_in)[i_layer].get();
}
 
const IFlux* DiffuseElement::fluxOut(size_t i_layer) const
{
    return (*m_fluxes_out)[i_layer].get();
}
 
DiffuseElement DiffuseElement::pointElement(double x, double y) const
{
    return {m_wavelength,
            m_alpha_i,
            m_phi_i,
            std::unique_ptr<IPixel>(m_pixel->createZeroSizePixel(x, y)), // TODO simplify
            m_polMatrices.polarizerMatrix(),
            m_polMatrices.analyzerMatrix(),
            m_is_specular,
            m_fluxes_in,
            m_fluxes_out};
}
 
R3 DiffuseElement::getKi() const
{
    return m_k_i;
}
 
R3 DiffuseElement::meanKf() const
{
    return m_mean_kf;
}
 
//! Returns outgoing wavevector Kf for in-pixel coordinates x,y.
//! In-pixel coordinates take values from 0 to 1.
R3 DiffuseElement::getKf(double x, double y) const
{
    return m_pixel->getK(x, y, m_wavelength);
}
 
R3 DiffuseElement::meanQ() const
{
    return getKi() - meanKf();
}
 
//! Returns scattering vector Q, with Kf determined from in-pixel coordinates x,y.
//! In-pixel coordinates take values from 0 to 1.
R3 DiffuseElement::getQ(double x, double y) const
{
    return getKi() - m_pixel->getK(x, y, m_wavelength);
}
 
double DiffuseElement::alpha(double x, double y) const
{
    return M_PI_2 - R3Util::theta(getKf(x, y));
}
 
double DiffuseElement::getPhi(double x, double y) const
{
    return R3Util::phi(getKf(x, y));
}
 
WavevectorInfo DiffuseElement::wavevectorInfo() const
{
    return WavevectorInfo(getKi(), meanKf(), wavelength());
}
 
double DiffuseElement::integrationFactor(double x, double y) const
{
    return m_pixel->integrationFactor(x, y);
}
 
double DiffuseElement::solidAngle() const
{
    return m_pixel->solidAngle();
}