Compute::SpecularScalar Namespace Reference

Description

Methods to compute scalar propagation directions and fluxes as function of slice.

Functions
Fluxes	fluxes (const SliceStack &slices, const R3 &k)
	Computes refraction angles and transmission/reflection coefficients for given coherent wave propagation in a sample. More...
complex_t	topLayerR (const SliceStack &slices, const std::vector< complex_t > &kz)
	Computes the Fresnel R coefficient for the top layer only. Introduced in order to speed up pure reflectivity computations. More...

Function Documentation

fluxes()

Fluxes Compute::SpecularScalar::fluxes	(	const SliceStack &	slices,
		const R3 &	k
	)

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

Definition at line 122 of file ComputeFluxScalar.cpp.

{
    const bool top_exit = k.z() <= 0; // true if source or detector pixel are at z>=0
    std::vector<complex_t> kz = Compute::Kz::computeReducedKz(slices, k);
    ASSERT(slices.size() == kz.size());
 
    const std::vector<Spinor> TR = computeTR(slices, kz, slices.roughnessModel(), top_exit);
 
    Fluxes result;
    for (size_t i = 0; i < kz.size(); ++i)
        result.emplace_back(std::make_unique<const ScalarFlux>(kz[i], TR[i]));
    return result;
}

References ASSERT, Compute::Kz::computeReducedKz(), and SliceStack::roughnessModel().

Referenced by reSample::fluxesIn(), and reSample::fluxesOut().

Here is the call graph for this function:

topLayerR()

complex_t Compute::SpecularScalar::topLayerR	(	const SliceStack &	slices,
		const std::vector< complex_t > &	kz
	)

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

Definition at line 136 of file ComputeFluxScalar.cpp.

{
    const RoughnessModel& r_model = slices.roughnessModel();
 
    ASSERT(slices.size() == kz.size());
    const size_t N = slices.size();
    if (N == 1)
        return 0.; // only one layer present, there's nothing left to calculate
    if (kz[0] == 0.)
        return -1.;
 
    complex_t R_i1 = 0.;
 
    for (size_t i = N - 1; i > 0; i--) {
        double sigma = 0.0;
        if (const auto* const roughness = slices.bottomRoughness(i - 1))
            sigma = roughness->sigma();
 
        const auto [mp, mm] = transition(kz[i - 1], kz[i], sigma, r_model);
 
        const complex_t delta = exp_I(kz[i - 1] * slices[i - 1].thicknessOr0());
 
        R_i1 = pow(delta, 2) * (mm + mp * R_i1) / (mp + mm * R_i1);
    }
 
    return R_i1;
}

References ASSERT, SliceStack::bottomRoughness(), N, and SliceStack::roughnessModel().

Referenced by SpecularComputation::runProtected().

Here is the call graph for this function: