Compute::SpecularMagnetic Namespace Reference

Description

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

Implements the transfer matrix formalism for the calculation of wave amplitudes of the coherent wave solution in a sample with magnetization. For a description, see internal document "Polarized Implementation of the Transfer Matrix Method"

Functions
Fluxes	fluxes (const SliceStack &slices, const R3 &k, bool forward)
	Computes refraction angle reflection/transmission coefficients for given sliced sample and wavevector k. More...
SpinMatrix	topLayerR (const SliceStack &slices, const std::vector< complex_t > &kzs, bool forward)
	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::SpecularMagnetic::fluxes	(	const SliceStack &	slices,
		const R3 &	k,
		bool	forward
	)

Computes refraction angle reflection/transmission coefficients for given sliced sample and wavevector k.

Definition at line 176 of file ComputeFluxMagnetic.cpp.

{
    if (slices.size() > 1 && k.z() > 0)
        throw std::runtime_error(
            "source or detector below horizon not yet implemented for polarized scattering");
    std::vector<complex_t> kz = Compute::Kz::computeReducedKz(slices, k);
    ASSERT(slices.size() == kz.size());
 
    Fluxes result;
    for (auto& coeff : computeFlux(slices, kz, slices.roughnessModel(), forward))
        result.emplace_back(std::make_unique<const MatrixFlux>(coeff));
 
    return result;
}

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

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

Here is the call graph for this function:

topLayerR()

SpinMatrix Compute::SpecularMagnetic::topLayerR	(	const SliceStack &	slices,
		const std::vector< complex_t > &	kzs,
		bool	forward
	)

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

Definition at line 191 of file ComputeFluxMagnetic.cpp.

{
    const RoughnessModel& r_model = slices.roughnessModel();
 
    ASSERT(slices.size() == kzs.size());
    const auto N = slices.size();
    if (N == 1)
        return SpinMatrix();
    if (kzs[0] == 0.)
        return -SpinMatrix::One();
 
    auto B_0 = slices.front().bField();
    const double kz_sign = kzs.front().real() >= 0.0 ? 1.0 : -1.0; // save sign to restore it later
 
    auto createCoeff = [&slices, &kzs, kz_sign, B_0, forward](size_t i) {
        const auto B = (forward ? +1 : -1) * (slices[i].bField() - B_0);
        const auto magnetic_SLD = magneticSLD(B);
 
        return MatrixFlux(kz_sign, checkForUnderflow(eigenvalues(kzs[i], magnetic_SLD)),
                          B.mag() > eps ? B / B.mag() : R3{0.0, 0.0, 0.0}, magnetic_SLD);
    };
 
    auto c_i1 = createCoeff(N - 1);
 
    // bottom boundary condition
    c_i1.m_R = SpinMatrix();
 
    for (size_t i = N - 1; i > 0; --i) {
        auto c_i = createCoeff(i - 1);
 
        double sigma = 0.;
        if (const auto* const roughness = slices.bottomRoughness(i - 1))
            sigma = roughness->sigma();
 
        // compute the 2x2 submatrices in the write-up denoted as P+, P- and delta
        const auto [mp, mm] = computeBackwardsSubmatrices(c_i, c_i1, sigma, r_model);
 
        const SpinMatrix delta = c_i.computeDeltaMatrix(slices[i - 1].thicknessOr0());
 
        // compute the rotation matrix
        SpinMatrix Si = mp + mm * c_i1.m_R;
        SpinMatrix S(Si.d, -Si.b, -Si.c, Si.a);
        const complex_t norm = S.determinant();
        S = S * (delta / norm);
 
        c_i.m_R = delta * (mm + mp * c_i1.m_R) * S;
        c_i1 = c_i;
    }
    return c_i1.m_R;
}

References SpinMatrix::a, ASSERT, SpinMatrix::b, SliceStack::bottomRoughness(), SpinMatrix::c, SpinMatrix::d, SpinMatrix::determinant(), N, SpinMatrix::One(), and SliceStack::roughnessModel().

Referenced by SpecularComputation::runProtected().

Here is the call graph for this function: