Compute::Kz Namespace Reference

Functions
std::vector< complex_t >	computeKzFromRefIndices (const SliceStack &slices, R3 k)
	Computes kz values from k-vector of the incoming beam known at a distant point in vacuum. It is assumed, that the beam penetrates fronting medium from a side. More...
std::vector< complex_t >	computeKzFromSLDs (const SliceStack &slices, double kz)
	Computes kz values from kz of the incoming beam known at a distant point in vacuum. It is assumed, that the beam penetrates fronting medium from a side. More...
std::vector< complex_t >	computeReducedKz (const SliceStack &slices, R3 k)
	Computes kz values from known k vector and slices with the following assumptions: More...

Function Documentation

computeKzFromRefIndices()

std::vector< complex_t > Compute::Kz::computeKzFromRefIndices	(	const SliceStack &	slices,
		R3	k
	)

Computes kz values from k-vector of the incoming beam known at a distant point in vacuum. It is assumed, that the beam penetrates fronting medium from a side.

Definition at line 78 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 = M_TWOPI / 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 M_TWOPI, and N.

Referenced by SpecularElement::FromAlphaScan().

computeKzFromSLDs()

std::vector< complex_t > Compute::Kz::computeKzFromSLDs	(	const SliceStack &	slices,
		double	kz
	)

Computes kz values from kz of the incoming beam known at a distant point in vacuum. It is assumed, that the beam penetrates fronting medium from a side.

Definition at line 62 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 N.

Referenced by SpecularElement::FromQzScan().

computeReducedKz()

std::vector< complex_t > Compute::Kz::computeReducedKz	(	const SliceStack &	slices,
		R3	k
	)

Computes kz values from known k vector and slices with the following assumptions:

• the beam penetrates fronting medium from a side
• the wavelength is known for a distant point in vacuum (ref. index = 1)
• the incident angle is known for the sample surface

This function is used in GISAS and off-spec computations mainly for back-compatibility reasons and should be replaced with computeKzFromRefIndices.

Definition at line 43 of file KzComputation.cpp.

{
    const size_t N = slices.size();
 
    const size_t i_ref = k.z() > 0. ? N - 1 : 0;
    const double n_ref = slices[i_ref].material().refractiveIndex(M_TWOPI / 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.
    for (size_t i = 0; i < N; ++i) {
        complex_t rad = slices[i].scalarReducedPotential(k, n_ref);
        if (i != i_ref)
            rad = checkForUnderflow(rad);
        result[i] = k_base * std::sqrt(rad);
    }
    return result;
}

References M_TWOPI, N, and Units::rad.

Referenced by Compute::SpecularScalar::fluxes(), and Compute::SpecularMagnetic::fluxes().