KzComputation Namespace Reference

Functions
std::vector< complex_t >	computeReducedKz (const std::vector< Slice > &slices, kvector_t k)
std::vector< complex_t >	computeKzFromSLDs (const std::vector< Slice > &slices, double kz)
std::vector< complex_t >	computeKzFromRefIndices (const std::vector< Slice > &slices, kvector_t k)

Detailed Description

Namespace containing functions for computing kz values for given multilayer and k (or kz) value on the surface of the sample.

Function Documentation

computeReducedKz()

std::vector< complex_t > KzComputation::computeReducedKz	(	const std::vector< Slice > &	slices,
		kvector_t	k
	)

Definition at line 41 of file KzComputation.cpp.

{
    const size_t N = slices.size();
    const double n_ref = slices[0].material().refractiveIndex(2 * M_PI / k.mag()).real();
    const double k_base = k.mag() * (k.z() > 0.0 ? -1 : 1);
 
    std::vector<complex_t> result(N);
    // Calculate refraction angle, expressed as k_z, for each layer.
    complex_t rad = slices[0].scalarReducedPotential(k, n_ref);
    result[0] = k_base * std::sqrt(rad);
    for (size_t i = 1; i < N; ++i) {
        rad = checkForUnderflow(slices[i].scalarReducedPotential(k, n_ref));
        result[i] = k_base * std::sqrt(rad);
    }
    return result;
}

References anonymous_namespace{KzComputation.cpp}::checkForUnderflow(), M_PI, BasicVector3D< T >::mag(), Units::rad, and BasicVector3D< T >::z().

Referenced by SpecularMagneticNewStrategy::Execute(), SpecularMagneticStrategy::Execute(), and SpecularScalarStrategy::Execute().

Here is the call graph for this function:

computeKzFromSLDs()

std::vector< complex_t > KzComputation::computeKzFromSLDs	(	const std::vector< Slice > &	slices,
		double	kz
	)

Definition at line 59 of file KzComputation.cpp.

{
    const size_t N = slices.size();
    const double k_sign = kz > 0.0 ? -1 : 1;
    complex_t kz2_base = kz * kz + normalizedSLD(slices[0].material());
 
    std::vector<complex_t> result(N);
    result[0] = -kz;
    // Calculate refraction angle, expressed as k_z, for each layer.
    for (size_t i = 1; i < N; ++i) {
        complex_t kz2 = checkForUnderflow(kz2_base - normalizedSLD(slices[i].material()));
        result[i] = k_sign * std::sqrt(kz2);
    }
    return result;
}

References anonymous_namespace{KzComputation.cpp}::checkForUnderflow(), and anonymous_namespace{KzComputation.cpp}::normalizedSLD().

Referenced by SpecularSimulationElement::SpecularSimulationElement().

Here is the call graph for this function:

computeKzFromRefIndices()

std::vector< complex_t > KzComputation::computeKzFromRefIndices	(	const std::vector< Slice > &	slices,
		kvector_t	k
	)

Definition at line 75 of file KzComputation.cpp.

{
    const size_t N = slices.size();
    const double kz = k.z();
    const double k_sign = kz > 0.0 ? -1 : 1;
    const double k2 = k.mag2();
    const double kz2 = kz * kz;
    const double wl = 2 * M_PI / std::sqrt(k2);
    const complex_t n2_ref = slices[0].material().refractiveIndex2(wl);
 
    std::vector<complex_t> result(N);
    result[0] = -kz;
    for (size_t i = 1; i < N; ++i) {
        const complex_t n2_norm = slices[i].material().refractiveIndex2(wl) - n2_ref;
        result[i] = k_sign * std::sqrt(checkForUnderflow(k2 * n2_norm + kz2));
    }
    return result;
}

References anonymous_namespace{KzComputation.cpp}::checkForUnderflow(), M_PI, BasicVector3D< T >::mag2(), and BasicVector3D< T >::z().

Referenced by SpecularSimulationElement::SpecularSimulationElement().

Here is the call graph for this function: