SpecularScalarTanhStrategy Class Reference

Inheritance diagram for SpecularScalarTanhStrategy:

Collaboration diagram for SpecularScalarTanhStrategy:

Public Types
using	coeffs_t = std::vector< std::unique_ptr< const ILayerRTCoefficients > >

Public Member Functions
virtual ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const kvector_t &k) const override
virtual ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const override

Private Member Functions
virtual std::pair< complex_t, complex_t >	transition (complex_t kzi, complex_t kzi1, double sigma) const override
std::vector< ScalarRTCoefficients >	computeTR (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const
void	calculateUpFromLayer (std::vector< ScalarRTCoefficients > &coeff, const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const

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

Detailed Description

Implements an tanh transition function to model roughness in a scaler computation.

Implements the transition function that includes the analytical roughness model of an tanh interface transition in the computation of the coefficients for coherent wave propagation in a multilayer by applying modified Fresnel coefficients.

Definition at line 29 of file SpecularScalarTanhStrategy.h.

Member Typedef Documentation

coeffs_t

using ISpecularStrategy::coeffs_t = std::vector<std::unique_ptr<const ILayerRTCoefficients> >

inherited

Definition at line 40 of file ISpecularStrategy.h.

Member Function Documentation

transition()

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

overrideprivatevirtual

Roughness is modelled by tanh profile [see e.g. Phys. Rev. B, vol. 47 (8), p. 4385 (1993)].

Implements SpecularScalarStrategy.

Definition at line 26 of file SpecularScalarTanhStrategy.cpp.

{
    complex_t roughness = 1;
    if (sigma > 0.0) {
        const double sigeff = pi2_15 * sigma;
        roughness =
            std::sqrt(MathFunctions::tanhc(sigeff * kzi1) / MathFunctions::tanhc(sigeff * kzi));
    }
    const complex_t inv_roughness = 1.0 / roughness;
    const complex_t kz_ratio = kzi1 / kzi * roughness;
 
    const complex_t a00 = 0.5 * (inv_roughness + kz_ratio);
    const complex_t a01 = 0.5 * (inv_roughness - kz_ratio);
 
    return {a00, a01};
}

References anonymous_namespace{SpecularScalarTanhStrategy.cpp}::pi2_15, and MathFunctions::tanhc().

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 29 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 36 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:

computeTR()

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

privateinherited

Definition at line 50 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:

setZeroBelow()

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

staticprivateinherited

Definition at line 74 of file SpecularScalarStrategy.cpp.

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

calculateUpFromLayer()

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

privateinherited

Definition at line 83 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 mpmm = transition(kz[i], kz[i + 1], sigma);
        const complex_t mp = mpmm.first;
        const complex_t mm = mpmm.second;
 
        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(), anonymous_namespace{SpecularScalarStrategy.cpp}::GetBottomRoughness(), and SpecularScalarStrategy::transition().

Referenced by SpecularScalarStrategy::computeTR().

Here is the call graph for this function:

---

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

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