SpecularScalarNCStrategy Class Reference

Implements Nevot-Croce roughness for a scaler computation. More...

Inheritance diagram for SpecularScalarNCStrategy:

Collaboration diagram for SpecularScalarNCStrategy:

Public Types
using	coefficient_pointer_type = std::unique_ptr< const coefficient_type >
using	coefficient_type = ScalarRTCoefficients
using	coeffs_t = std::vector< coefficient_pointer_type >

Public Member Functions
virtual std::variant< complex_t, Eigen::Matrix2cd >	computeTopLayerR (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const override
	Computes the Fresnel R coefficient for the top layer only Introduced in order to speed up pure reflectivity computations. More...
virtual ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const kvector_t &k) const override
	Computes refraction angles and transmission/reflection coefficients for given coherent wave propagation in a multilayer. More...
virtual ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const override

Private Member Functions
void	calculateUpFromLayer (std::vector< ScalarRTCoefficients > &coeff, const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const
std::vector< ScalarRTCoefficients >	computeTR (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const
virtual std::pair< complex_t, complex_t >	transition (complex_t kzi, complex_t kzi1, double sigma) const override
	Roughness is modelled by a Gaussian profile, i.e. More...

Static Private Member Functions
static void	setZeroBelow (std::vector< ScalarRTCoefficients > &coeff, size_t current_layer)

Detailed Description

Implements Nevot-Croce roughness for a scaler computation.

Implements the transition function that includes Nevot-Croce roughness in the computation of the coefficients for coherent wave propagation in a multilayer by applying modified Fresnel coefficients.

Definition at line 35 of file SpecularScalarNCStrategy.h.

Member Typedef Documentation

coefficient_pointer_type

using SpecularScalarStrategy::coefficient_pointer_type = std::unique_ptr<const coefficient_type>

inherited

Definition at line 43 of file SpecularScalarStrategy.h.

coefficient_type

using SpecularScalarStrategy::coefficient_type = ScalarRTCoefficients

inherited

Definition at line 42 of file SpecularScalarStrategy.h.

coeffs_t

using SpecularScalarStrategy::coeffs_t = std::vector<coefficient_pointer_type>

inherited

Definition at line 44 of file SpecularScalarStrategy.h.

Member Function Documentation

calculateUpFromLayer()

void SpecularScalarStrategy::calculateUpFromLayer ( std::vector< ScalarRTCoefficients > &  coeff, const std::vector< Slice > &  slices, const std::vector< complex_t > &  kz  ) const

privateinherited

Definition at line 116 of file SpecularScalarStrategy.cpp.

{
    auto N = slices.size();
 
    coeff.back().t_r(0) = 1.0;
    coeff.back().t_r(1) = 0.0;
    std::vector<complex_t> factors(N - 1);
    for (int i = N - 2; i >= 0; i--) {
        double sigma = 0.0;
        if (const auto roughness = GetBottomRoughness(slices, i))
            sigma = roughness->getSigma();
 
        const auto [mp, mm] = transition(kz[i], kz[i + 1], sigma);
 
        const complex_t delta = exp_I(kz[i] * slices[i].thickness());
 
        complex_t S = mp + mm * coeff[i + 1].t_r(1);
        S = 1. / S * delta;
        factors[i] = S;
 
        coeff[i].t_r(1) = delta * (mm + mp * coeff[i + 1].t_r(1)) * S;
    }
 
    // now correct all amplitudes by dividing the with the remaining factors in forward direction
    // at some point this divison underflows, which is the point when all further amplitudes are set
    // to zero
    complex_t dumpingFactor = 1;
    for (size_t j = 1; j < N; ++j) {
        dumpingFactor = dumpingFactor * factors[j - 1];
 
        coeff[j].t_r(0) = dumpingFactor;
        coeff[j].t_r(1) *= dumpingFactor;
    }
}

References exp_I(), and SpecularScalarStrategy::transition().

Referenced by SpecularScalarStrategy::computeTR().

Here is the call graph for this function:

computeTopLayerR()

std::variant< complex_t, Eigen::Matrix2cd > SpecularScalarStrategy::computeTopLayerR ( const std::vector< Slice > &  slices, const std::vector< complex_t > &  kz  ) const

overridevirtualinherited

Computes the Fresnel R coefficient for the top layer only Introduced in order to speed up pure reflectivity computations.

Implements ISpecularStrategy.

Definition at line 49 of file SpecularScalarStrategy.cpp.

{
    if (slices.size() != kz.size())
        throw std::runtime_error("Number of slices does not match the size of the kz-vector");
 
    auto N = slices.size();
 
    if (N == 1) { // If only one layer present, there's nothing left to calculate
        return 0.;
    }else if (kz[0] == 0.)
        return -1.;
 
    complex_t R_i1 = 0.;
 
    for (int i = N - 2; i >= 0; i--) {
        double sigma = 0.0;
        if (const auto roughness = GetBottomRoughness(slices, i))
            sigma = roughness->getSigma();
 
        const auto [mp, mm] = transition(kz[i], kz[i + 1], sigma);
 
        const complex_t delta = exp_I(kz[i] * slices[i].thickness());
 
        complex_t S = mp + mm * R_i1;
        S = 1. / S * delta;
 
        R_i1 = delta * (mm + mp * R_i1) * S;
    }
 
    return R_i1;
}

References exp_I(), and SpecularScalarStrategy::transition().

Here is the call graph for this function:

computeTR()

std::vector< ScalarRTCoefficients > SpecularScalarStrategy::computeTR ( const std::vector< Slice > &  slices, const std::vector< complex_t > &  kz  ) const

privateinherited

Definition at line 83 of file SpecularScalarStrategy.cpp.

{
    const size_t N = slices.size();
    std::vector<ScalarRTCoefficients> coeff(N);
 
    for (size_t i = 0; i < N; ++i)
        coeff[i].kz = kz[i];
 
    if (N == 1) { // If only one layer present, there's nothing left to calculate
        coeff[0].t_r = {1.0, 0.0};
        return coeff;
    } else if (kz[0] == 0.0) { // If kz in layer 0 is zero, R0 = -T0 and all others equal to 0
        coeff[0].t_r = {1.0, -1.0};
        for (size_t i = 1; i < N; ++i)
            coeff[i].t_r.setZero();
        return coeff;
    }
 
    // Calculate transmission/refraction coefficients t_r for each layer, from bottom to top.
    calculateUpFromLayer(coeff, slices, kz);
    return coeff;
}

References SpecularScalarStrategy::calculateUpFromLayer().

Referenced by SpecularScalarStrategy::Execute().

Here is the call graph for this function:

Execute() [1/2]

ISpecularStrategy::coeffs_t SpecularScalarStrategy::Execute ( const std::vector< Slice > &  slices, const kvector_t &  k  ) const

overridevirtualinherited

Computes refraction angles and transmission/reflection coefficients for given coherent wave propagation in a multilayer.

Implements ISpecularStrategy.

Definition at line 28 of file SpecularScalarStrategy.cpp.

{
    std::vector<complex_t> kz = KzComputation::computeReducedKz(slices, k);
    return Execute(slices, kz);
}

References KzComputation::computeReducedKz().

Here is the call graph for this function:

Execute() [2/2]

ISpecularStrategy::coeffs_t SpecularScalarStrategy::Execute ( const std::vector< Slice > &  slices, const std::vector< complex_t > &  kz  ) const

overridevirtualinherited

Implements ISpecularStrategy.

Definition at line 35 of file SpecularScalarStrategy.cpp.

{
    if (slices.size() != kz.size())
        throw std::runtime_error("Number of slices does not match the size of the kz-vector");
 
    ISpecularStrategy::coeffs_t result;
    for (auto& coeff : computeTR(slices, kz))
        result.push_back(std::make_unique<ScalarRTCoefficients>(coeff));
 
    return result;
}

References SpecularScalarStrategy::computeTR().

Here is the call graph for this function:

setZeroBelow()

void SpecularScalarStrategy::setZeroBelow ( std::vector< ScalarRTCoefficients > &  coeff, size_t  current_layer  )

staticprivateinherited

Definition at line 107 of file SpecularScalarStrategy.cpp.

{
    size_t N = coeff.size();
    for (size_t i = current_layer + 1; i < N; ++i) {
        coeff[i].t_r.setZero();
    }
}

transition()

std::pair< complex_t, complex_t > SpecularScalarNCStrategy::transition ( complex_t  kzi, complex_t  kzi1, double  sigma  ) const

overrideprivatevirtual

Roughness is modelled by a Gaussian profile, i.e.

Nevot-Croce factors for the reflection coefficients. Implementation follows A. Gibaud and G. Vignaud, in X-ray and Neutron Reflectivity, edited by J. Daillant and A. Gibaud, volume 770 of Lecture Notes in Physics (2009)

Implements SpecularScalarStrategy.

Definition at line 18 of file SpecularScalarNCStrategy.cpp.

{
    complex_t roughness_diff = 1;
    complex_t roughness_sum = 1;
    if (sigma > 0.0) {
        roughness_diff = std::exp(-(kzi1 - kzi) * (kzi1 - kzi) * sigma * sigma / 2.);
        roughness_sum = std::exp(-(kzi1 + kzi) * (kzi1 + kzi) * sigma * sigma / 2.);
    }
    const complex_t kz_ratio = kzi1 / kzi;
 
    const complex_t a00 = 0.5 * (1. + kz_ratio) * roughness_diff;
    const complex_t a01 = 0.5 * (1. - kz_ratio) * roughness_sum;
 
    return {a00, a01};
}

---

The documentation for this class was generated from the following files:

• /home/www/ba/Sample/Specular/SpecularScalarNCStrategy.h
• /home/www/ba/Sample/Specular/SpecularScalarNCStrategy.cpp