ProfileHelper.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Resample/Slice/ProfileHelper.cpp
//! @brief     Implements class ProfileHelper.
//!
//! @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/Slice/ProfileHelper.h"
#include "Resample/Slice/SliceStack.h"
#include "Sample/Interface/LayerRoughness.h"
 
namespace {
 
const double prefactor = std::sqrt(2.0 / M_PI);
 
double TransitionTanh(double x)
{
    return (1.0 - std::tanh(prefactor * x)) / 2.0;
}
 
double Transition(double x, double sigma)
{
    if (sigma <= 0.0)
        return x < 0.0 ? 1.0 : 0.0;
    return TransitionTanh(x / sigma);
}
 
} // namespace
 
 
ProfileHelper::ProfileHelper(const SliceStack& stack)
    : m_stack(stack)
{
}
 
// Note: for refractive index materials, the material interpolation actually happens at the level
// of n^2. To first order in delta and beta, this implies the same smooth interpolation of delta
// and beta, as is done here.
std::vector<complex_t> ProfileHelper::calculateProfile(const std::vector<double>& z_values) const
{
    const complex_t top_value = !m_stack.empty() ? m_stack.at(0).material().materialData() : 0.0;
    std::vector<complex_t> result(z_values.size(), top_value);
    for (size_t i = 1; i < m_stack.size(); ++i) {
        const Slice& slice = m_stack.at(i);
        const Slice& sliceAbove = m_stack.at(i - 1);
        const complex_t sld_diff =
            slice.material().materialData() - sliceAbove.material().materialData();
        for (size_t j = 0; j < z_values.size(); ++j) {
            const double arg = (z_values[j] - slice.zTop());
            const LayerRoughness* roughness = slice.topRoughness();
            const double t = Transition(arg, roughness ? roughness->sigma() : 0);
            result[j] += sld_diff * t;
        }
    }
    return result;
}
 
std::pair<double, double> ProfileHelper::defaultLimits() const
{
    if (m_stack.size() < 2)
        return {0.0, 0.0};
    double interface_span = m_stack.front().zBottom() - m_stack.back().zTop();
    double default_margin = interface_span > 0.0 ? interface_span / 20.0 : 10.0;
    const LayerRoughness* topRoughness = m_stack.at(1).topRoughness();
    const LayerRoughness* bottomRoughness = m_stack.back().topRoughness();
 
    double top_margin =
        topRoughness && topRoughness->sigma() > 0 ? 5.0 * topRoughness->sigma() : default_margin;
    double bottom_margin = bottomRoughness && bottomRoughness->sigma() > 0
                               ? 5.0 * bottomRoughness->sigma()
                               : default_margin;
    double z_min = m_stack.back().zTop() - bottom_margin;
    double z_max = m_stack.front().zBottom() + top_margin;
    return {z_min, z_max};
}