SpecularMagneticStrategy Class Reference

Inheritance diagram for SpecularMagneticStrategy:

Collaboration diagram for SpecularMagneticStrategy:

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

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

Static Private Member Functions
static std::vector< MatrixRTCoefficients_v2 >	computeTR (const std::vector< Slice > &slices, const std::vector< complex_t > &kzs)
static void	calculateTR (MatrixRTCoefficients_v2 &coeff)
static void	calculateZeroFieldTR (MatrixRTCoefficients_v2 &coeff)
static void	setNoTransmission (MatrixRTCoefficients_v2 &coeff)
static void	nullifyBottomReflection (MatrixRTCoefficients_v2 &coeff)
static void	propagateBackwardsForwards (std::vector< MatrixRTCoefficients_v2 > &coeff, const std::vector< Slice > &slices)
static std::pair< Eigen::Matrix2cd, complex_t >	findNormalizationCoefficients (const MatrixRTCoefficients_v2 &coeff)

Detailed Description

Implements the magnetic Fresnel computation without roughness.

Implements the matrix formalism for the calculation of wave amplitudes of the coherent wave solution in a multilayer with magnetization. For a detailed description see internal document "Polarized Specular Reflectometry"

Definition at line 32 of file SpecularMagneticStrategy.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

Execute() [1/2]

ISpecularStrategy::coeffs_t SpecularMagneticStrategy::Execute ( const std::vector< Slice > &  slices, const kvector_t &  k  ) const

virtual

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

Implements ISpecularStrategy.

Definition at line 32 of file SpecularMagneticStrategy.cpp.

{
    return Execute(slices, KzComputation::computeReducedKz(slices, k));
}

References KzComputation::computeReducedKz().

Here is the call graph for this function:

Execute() [2/2]

ISpecularStrategy::coeffs_t SpecularMagneticStrategy::Execute ( const std::vector< Slice > &  slices, const std::vector< complex_t > &  kz  ) const

virtual

Computes refraction angle reflection/transmission coefficients for given sliced multilayer and a set of kz projections corresponding to each slice.

Implements ISpecularStrategy.

Definition at line 39 of file SpecularMagneticStrategy.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<MatrixRTCoefficients_v2>(coeff));
 
    return result;
}

References computeTR().

Here is the call graph for this function:

computeTR()

std::vector< MatrixRTCoefficients_v2 > SpecularMagneticStrategy::computeTR ( const std::vector< Slice > &  slices, const std::vector< complex_t > &  kzs  )

staticprivate

Definition at line 53 of file SpecularMagneticStrategy.cpp.

{
    if (kzs[0] == 0.)
        throw std::runtime_error("Edge case k_z = 0 not implemented");
 
    if (slices.size() != kzs.size())
        throw std::runtime_error(
            "Error in SpecularMagnetic_::execute: kz vector and slices size shall coinside.");
    if (slices.empty())
        return {};
 
    std::vector<MatrixRTCoefficients_v2> result;
    result.reserve(slices.size());
 
    const double kz_sign = kzs.front().real() > 0.0 ? 1.0 : -1.0; // save sign to restore it later
    const kvector_t b_0 = magneticImpact(slices.front().bField());
    result.emplace_back(kz_sign, eigenvalues(kzs.front(), 0.0), kvector_t{0.0, 0.0, 0.0});
    for (size_t i = 1, size = slices.size(); i < size; ++i) {
        kvector_t b = magneticImpact(slices[i].bField()) - b_0;
        result.emplace_back(kz_sign, checkForUnderflow(eigenvalues(kzs[i], b.mag())), b);
    }
 
    if (result.front().m_lambda == Eigen::Vector2cd::Zero()) {
        std::for_each(result.begin(), result.end(), [](auto& coeff) { setNoTransmission(coeff); });
        return result;
    }
 
    std::for_each(result.begin(), result.end(), [](auto& coeff) { calculateTR(coeff); });
    nullifyBottomReflection(result.back());
    propagateBackwardsForwards(result, slices);
 
    return result;
}

References anonymous_namespace{SpecularMagneticStrategy.cpp}::checkForUnderflow(), anonymous_namespace{SpecularMagneticStrategy.cpp}::eigenvalues(), BasicVector3D< T >::mag(), anonymous_namespace{SpecularMagneticStrategy.cpp}::magneticImpact(), nullifyBottomReflection(), and propagateBackwardsForwards().

Referenced by Execute().

Here is the call graph for this function:

calculateTR()

void SpecularMagneticStrategy::calculateTR ( MatrixRTCoefficients_v2 &  coeff )

staticprivate

Computes frobenius matrices for multilayer solution.

Definition at line 88 of file SpecularMagneticStrategy.cpp.

{
    const double b = coeff.m_b.mag();
    if (b == 0.0) {
        calculateZeroFieldTR(coeff);
        return;
    }
 
    const double bpbz = b + coeff.m_b.z();
    const double bmbz = b - coeff.m_b.z();
    const complex_t bxmby = coeff.m_b.x() - I * coeff.m_b.y();
    const complex_t bxpby = coeff.m_b.x() + I * coeff.m_b.y();
    const complex_t l_1 = coeff.m_lambda(0);
    const complex_t l_2 = coeff.m_lambda(1);
 
    auto& T1 = coeff.T1;
    T1 << bmbz, -bxmby, -bmbz * l_1, bxmby * l_1, -bxpby, bpbz, bxpby * l_1, -bpbz * l_1,
        -bmbz / l_1, bxmby / l_1, bmbz, -bxmby, bxpby / l_1, -bpbz / l_1, -bxpby, bpbz;
    T1 /= 4.0 * b;
 
    auto& R1 = coeff.R1;
    R1 << T1(0, 0), T1(0, 1), -T1(0, 2), -T1(0, 3), T1(1, 0), T1(1, 1), -T1(1, 2), -T1(1, 3),
        -T1(2, 0), -T1(2, 1), T1(2, 2), T1(2, 3), -T1(3, 0), -T1(3, 1), T1(3, 2), T1(3, 3);
 
    auto& T2 = coeff.T2;
    T2 << bpbz, bxmby, -bpbz * l_2, -bxmby * l_2, bxpby, bmbz, -bxpby * l_2, -bmbz * l_2,
        -bpbz / l_2, -bxmby / l_2, bpbz, bxmby, -bxpby / l_2, -bmbz / l_2, bxpby, bmbz;
    T2 /= 4.0 * b;
 
    auto& R2 = coeff.R2;
    R2 << T2(0, 0), T2(0, 1), -T2(0, 2), -T2(0, 3), T2(1, 0), T2(1, 1), -T2(1, 2), -T2(1, 3),
        -T2(2, 0), -T2(2, 1), T2(2, 2), T2(2, 3), -T2(3, 0), -T2(3, 1), T2(3, 2), T2(3, 3);
}

References calculateZeroFieldTR(), I, MatrixRTCoefficients_v2::m_b, MatrixRTCoefficients_v2::m_lambda, BasicVector3D< T >::mag(), MatrixRTCoefficients_v2::R1, MatrixRTCoefficients_v2::R2, MatrixRTCoefficients_v2::T1, MatrixRTCoefficients_v2::T2, BasicVector3D< T >::x(), BasicVector3D< T >::y(), and BasicVector3D< T >::z().

Here is the call graph for this function:

calculateZeroFieldTR()

void SpecularMagneticStrategy::calculateZeroFieldTR ( MatrixRTCoefficients_v2 &  coeff )

staticprivate

Definition at line 122 of file SpecularMagneticStrategy.cpp.

{
    coeff.T1 = Eigen::Matrix4cd::Zero();
    coeff.R1 = Eigen::Matrix4cd::Zero();
    coeff.T2 = Eigen::Matrix4cd::Zero();
    coeff.R2 = Eigen::Matrix4cd::Zero();
 
    // lambda_1 == lambda_2, no difference which one to use
    const complex_t eigen_value = coeff.m_lambda(0);
 
    Eigen::Matrix3cd Tblock;
    Tblock << 0.5, 0.0, -0.5 * eigen_value, 0.0, 0.0, 0.0, -0.5 / eigen_value, 0.0, 0.5;
 
    Eigen::Matrix3cd Rblock;
    Rblock << 0.5, 0.0, 0.5 * eigen_value, 0.0, 0.0, 0.0, 0.5 / eigen_value, 0.0, 0.5;
 
    coeff.T1.block<3, 3>(1, 1) = Tblock;
    coeff.R1.block<3, 3>(1, 1) = Rblock;
    coeff.T2.block<3, 3>(0, 0) = Tblock;
    coeff.R2.block<3, 3>(0, 0) = Rblock;
}

References MatrixRTCoefficients_v2::m_lambda, MatrixRTCoefficients_v2::R1, MatrixRTCoefficients_v2::R2, MatrixRTCoefficients_v2::T1, and MatrixRTCoefficients_v2::T2.

Referenced by calculateTR().

setNoTransmission()

void SpecularMagneticStrategy::setNoTransmission ( MatrixRTCoefficients_v2 &  coeff )

staticprivate

Definition at line 144 of file SpecularMagneticStrategy.cpp.

{
    coeff.m_w_plus = Eigen::Vector4cd::Zero();
    coeff.m_w_min = Eigen::Vector4cd::Zero();
    coeff.T1 = Eigen::Matrix4cd::Identity() / 4.0;
    coeff.R1 = coeff.T1;
    coeff.T2 = coeff.T1;
    coeff.R2 = coeff.T1;
}

References MatrixRTCoefficients_v2::m_w_min, MatrixRTCoefficients_v2::m_w_plus, MatrixRTCoefficients_v2::R1, MatrixRTCoefficients_v2::R2, MatrixRTCoefficients_v2::T1, and MatrixRTCoefficients_v2::T2.

nullifyBottomReflection()

void SpecularMagneticStrategy::nullifyBottomReflection ( MatrixRTCoefficients_v2 &  coeff )

staticprivate

initializes reflectionless bottom boundary condition.

Definition at line 154 of file SpecularMagneticStrategy.cpp.

{
    const complex_t l_1 = coeff.m_lambda(0);
    const complex_t l_2 = coeff.m_lambda(1);
    const double b_mag = coeff.m_b.mag();
    const kvector_t& b = coeff.m_b;
 
    if (b_mag == 0.0) {
        // both eigenvalues are the same, no difference which one to take
        coeff.m_w_plus << -l_1, 0.0, 1.0, 0.0;
        coeff.m_w_min << 0.0, -l_1, 0.0, 1.0;
        return;
    }
 
    // First basis vector that has no upward going wave amplitude
    coeff.m_w_min(0) = (b.x() - I * b.y()) * (l_1 - l_2) / 2.0 / b_mag;
    coeff.m_w_min(1) = b.z() * (l_2 - l_1) / 2.0 / b_mag - (l_1 + l_2) / 2.0;
    coeff.m_w_min(2) = 0.0;
    coeff.m_w_min(3) = 1.0;
 
    // Second basis vector that has no upward going wave amplitude
    coeff.m_w_plus(0) = -(l_1 + l_2) / 2.0 - b.z() / (l_1 + l_2);
    coeff.m_w_plus(1) = (b.x() + I * b.y()) * (l_1 - l_2) / 2.0 / b_mag;
    coeff.m_w_plus(2) = 1.0;
    coeff.m_w_plus(3) = 0.0;
}

References I, MatrixRTCoefficients_v2::m_b, MatrixRTCoefficients_v2::m_lambda, MatrixRTCoefficients_v2::m_w_min, MatrixRTCoefficients_v2::m_w_plus, BasicVector3D< T >::mag(), BasicVector3D< T >::x(), BasicVector3D< T >::y(), and BasicVector3D< T >::z().

Referenced by computeTR().

Here is the call graph for this function:

propagateBackwardsForwards()

void SpecularMagneticStrategy::propagateBackwardsForwards ( std::vector< MatrixRTCoefficients_v2 > &  coeff, const std::vector< Slice > &  slices  )

staticprivate

Propagates boundary conditions from the bottom to the top of the layer stack.

Used to compute boundary conditions from the bottom one (with nullified reflection) simultaneously propagates amplitudes forward again Due to the use of temporary objects this is combined into one function now

Definition at line 181 of file SpecularMagneticStrategy.cpp.

{
    const int size = static_cast<int>(coeff.size());
    std::vector<Eigen::Matrix2cd> SMatrices(coeff.size());
    std::vector<complex_t> Normalization(coeff.size());
 
    for (int index = size - 2; index >= 0; --index) {
        const size_t i = static_cast<size_t>(index);
        const double t = slices[i].thickness();
        const auto kz = coeff[i].getKz();
        const Eigen::Matrix4cd l = coeff[i].R1 * GetImExponential(kz(0) * t)
                                   + coeff[i].T1 * GetImExponential(-kz(0) * t)
                                   + coeff[i].R2 * GetImExponential(kz(1) * t)
                                   + coeff[i].T2 * GetImExponential(-kz(1) * t);
        coeff[i].m_w_plus = l * coeff[i + 1].m_w_plus;
        coeff[i].m_w_min = l * coeff[i + 1].m_w_min;
 
        // rotate and normalize polarization
        const auto Snorm = findNormalizationCoefficients(coeff[i]);
        auto S = Snorm.first;
        auto norm = Snorm.second;
 
        SMatrices[i] = S;
        Normalization[i] = norm;
 
        const complex_t a_plus = S(0, 0) / norm;
        const complex_t b_plus = S(1, 0) / norm;
        const complex_t a_min = S(0, 1) / norm;
        const complex_t b_min = S(1, 1) / norm;
 
        const Eigen::Vector4cd w_plus = a_plus * coeff[i].m_w_plus + b_plus * coeff[i].m_w_min;
        const Eigen::Vector4cd w_min = a_min * coeff[i].m_w_plus + b_min * coeff[i].m_w_min;
 
        coeff[i].m_w_plus = std::move(w_plus);
        coeff[i].m_w_min = std::move(w_min);
    }
 
    complex_t dumpingFactor = 1;
    Eigen::Matrix2cd S = Eigen::Matrix2cd::Identity();
    for (size_t i = 1; i < coeff.size(); ++i) {
        dumpingFactor = dumpingFactor * Normalization[i - 1];
        S = SMatrices[i - 1] * S;
 
        if (std::isinf(std::norm(dumpingFactor))) {
            // not entirely sure, whether this is the correct edge case
            std::for_each(coeff.begin() + i, coeff.end(),
                          [](auto& coeff) { setNoTransmission(coeff); });
            break;
        }
 
        const complex_t a_plus = S(0, 0) / dumpingFactor;
        const complex_t b_plus = S(1, 0) / dumpingFactor;
        const complex_t a_min = S(0, 1) / dumpingFactor;
        const complex_t b_min = S(1, 1) / dumpingFactor;
 
        Eigen::Vector4cd w_plus = a_plus * coeff[i].m_w_plus + b_plus * coeff[i].m_w_min;
        Eigen::Vector4cd w_min = a_min * coeff[i].m_w_plus + b_min * coeff[i].m_w_min;
 
        coeff[i].m_w_plus = std::move(w_plus);
        coeff[i].m_w_min = std::move(w_min);
    }
}

References findNormalizationCoefficients(), and anonymous_namespace{SpecularMagneticStrategy.cpp}::GetImExponential().

Referenced by computeTR().

Here is the call graph for this function:

findNormalizationCoefficients()

std::pair< Eigen::Matrix2cd, complex_t > SpecularMagneticStrategy::findNormalizationCoefficients ( const MatrixRTCoefficients_v2 &  coeff )

staticprivate

finds linear coefficients for normalizing transmitted wave to unity.

The left column of the returned matrix corresponds to the coefficients for pure spin-up wave, while the right column - to the coefficients for the spin-down one.

Definition at line 246 of file SpecularMagneticStrategy.cpp.

{
    const Eigen::Vector2cd Ta = coeff.T1plus() + coeff.T2plus();
    const Eigen::Vector2cd Tb = coeff.T1min() + coeff.T2min();
 
    Eigen::Matrix2cd S;
    S << Ta(0), Tb(0), Ta(1), Tb(1);
 
    Eigen::Matrix2cd SInverse;
    SInverse << S(1, 1), -S(0, 1), -S(1, 0), S(0, 0);
    const complex_t d1 = S(1, 1) - S(0, 1);
    const complex_t d2 = S(1, 0) - S(0, 0);
    const complex_t denominator = S(0, 0) * d1 - d2 * S(0, 1);
 
    return {SInverse, denominator};
}

References MatrixRTCoefficients_v2::T1min(), MatrixRTCoefficients_v2::T1plus(), MatrixRTCoefficients_v2::T2min(), and MatrixRTCoefficients_v2::T2plus().

Referenced by propagateBackwardsForwards().

Here is the call graph for this function:

---

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

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