SpecularMagneticNCStrategy Class Reference

Implements the magnetic Fresnel computation with Nevot-Croce roughness. More...

Inheritance diagram for SpecularMagneticNCStrategy:

Collaboration diagram for SpecularMagneticNCStrategy:

Public Types
using	coefficient_entry_type = Eigen::Matrix2cd
using	coefficient_pointer_type = std::unique_ptr< const coefficient_type >
using	coefficient_type = MatrixRTCoefficients
using	coeffs_t = std::vector< coefficient_pointer_type >

Public Member Functions
virtual std::variant< complex_t, Eigen::Matrix2cd >	computeTopLayerR (const std::vector< Slice > &slices, const std::vector< complex_t > &kzs) const override
	Computes the Fresnel R coefficient for the top layer only Introduced in order to speed up pure reflectivity computations. More...
ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const kvector_t &k) const
	Computes refraction angle reflection/transmission coefficients for given sliced multilayer and wavevector k. More...
ISpecularStrategy::coeffs_t	Execute (const std::vector< Slice > &slices, const std::vector< complex_t > &kz) const
	Computes refraction angle reflection/transmission coefficients for given sliced multilayer and a set of kz projections corresponding to each slice. More...

Private Member Functions
void	calculateUpwards (std::vector< MatrixRTCoefficients > &coeff, const std::vector< Slice > &slices) const
virtual std::pair< Eigen::Matrix2cd, Eigen::Matrix2cd >	computeBackwardsSubmatrices (const MatrixRTCoefficients &coeff_i, const MatrixRTCoefficients &coeff_i1, double sigma) const
std::pair< Eigen::Matrix2cd, Eigen::Matrix2cd >	computeRoughnessMatrices (const MatrixRTCoefficients &coeff_i, const MatrixRTCoefficients &coeff_i1, double sigma) const
std::vector< MatrixRTCoefficients >	computeTR (const std::vector< Slice > &slices, const std::vector< complex_t > &kzs) const

Detailed Description

Implements the magnetic Fresnel computation with Nevot-Croce roughness.

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

Definition at line 35 of file SpecularMagneticNCStrategy.h.

Member Typedef Documentation

coefficient_entry_type

using SpecularMagneticStrategy::coefficient_entry_type = Eigen::Matrix2cd

inherited

Definition at line 42 of file SpecularMagneticStrategy.h.

coefficient_pointer_type

using SpecularMagneticStrategy::coefficient_pointer_type = std::unique_ptr<const coefficient_type>

inherited

Definition at line 44 of file SpecularMagneticStrategy.h.

coefficient_type

using SpecularMagneticStrategy::coefficient_type = MatrixRTCoefficients

inherited

Definition at line 43 of file SpecularMagneticStrategy.h.

coeffs_t

using SpecularMagneticStrategy::coeffs_t = std::vector<coefficient_pointer_type>

inherited

Definition at line 45 of file SpecularMagneticStrategy.h.

Member Function Documentation

calculateUpwards()

void SpecularMagneticStrategy::calculateUpwards ( std::vector< MatrixRTCoefficients > &  coeff, const std::vector< Slice > &  slices  ) const

privateinherited

Definition at line 156 of file SpecularMagneticStrategy.cpp.

{
    const auto N = slices.size();
    std::vector<Eigen::Matrix2cd> SMatrices(N - 1);
    std::vector<complex_t> Normalization(N - 1);
 
    // bottom boundary condition
    coeff.back().m_T = Eigen::Matrix2cd::Identity();
    coeff.back().m_R = Eigen::Matrix2cd::Zero();
 
    for (int i = N - 2; i >= 0; --i) {
        double sigma = 0.;
        if (const auto roughness = GetBottomRoughness(slices, i))
            sigma = roughness->getSigma();
 
        // compute the 2x2 submatrices in the write-up denoted as P+, P- and delta
        const auto [mp, mm] = computeBackwardsSubmatrices(coeff[i], coeff[i + 1], sigma);
 
        const Eigen::Matrix2cd delta = coeff[i].computeDeltaMatrix(slices[i].thickness());
 
        // compute the rotation matrix
        Eigen::Matrix2cd S, Si;
        Si = mp + mm * coeff[i + 1].m_R;
        S << Si(1, 1), -Si(0, 1), -Si(1, 0), Si(0, 0);
        const complex_t norm = S(0, 0) * S(1, 1) - S(0, 1) * S(1, 0);
        S = S * delta;
 
        // store the rotation matrix and normalization constant in order to rotate
        // the coefficients for all lower slices at the end of the computation
        SMatrices[i] = S;
        Normalization[i] = norm;
 
        // compute the reflection matrix and
        // rotate the polarization such that we have pure incoming states (T = I)
        S /= norm;
 
        // T is always equal to the identity at this point, no need to store
        coeff[i].m_R = delta * (mm + mp * coeff[i + 1].m_R) * S;
    }
 
    // now correct all amplitudes in forward direction by dividing with the remaining
    // normalization constants. In addition rotate the polarization by the amount
    // that was rotated above the current interface
    // if the normalization overflows, all amplitudes below that point are set to zero
    complex_t dumpingFactor = 1;
    Eigen::Matrix2cd S = Eigen::Matrix2cd::Identity();
    for (size_t i = 1; i < N; ++i) {
        dumpingFactor = dumpingFactor * Normalization[i - 1];
        S = SMatrices[i - 1] * S;
 
        if (std::isinf(std::norm(dumpingFactor))) {
            std::for_each(coeff.begin() + i, coeff.end(), [](auto& coeff) {
                coeff.m_T = Eigen::Matrix2cd::Zero();
                coeff.m_R = Eigen::Matrix2cd::Zero();
            });
            break;
        }
 
        coeff[i].m_T = S / dumpingFactor; // T * S omitted, since T is always I
        coeff[i].m_R *= S / dumpingFactor;
    }
}

References SpecularMagneticStrategy::computeBackwardsSubmatrices().

Referenced by SpecularMagneticStrategy::computeTR().

Here is the call graph for this function:

computeBackwardsSubmatrices()

std::pair< Eigen::Matrix2cd, Eigen::Matrix2cd > SpecularMagneticNCStrategy::computeBackwardsSubmatrices ( const MatrixRTCoefficients &  coeff_i, const MatrixRTCoefficients &  coeff_i1, double  sigma  ) const

privatevirtual

Implements SpecularMagneticStrategy.

Definition at line 67 of file SpecularMagneticNCStrategy.cpp.

{
    Eigen::Matrix2cd roughness_sum{Eigen::Matrix2cd::Identity()};
    Eigen::Matrix2cd roughness_diff{Eigen::Matrix2cd::Identity()};
    if (sigma != 0.) {
        const auto ret = computeRoughnessMatrices(coeff_i, coeff_i1, sigma);
        roughness_sum = std::get<0>(ret);
        roughness_diff = std::get<1>(ret);
    }
 
    const auto P = Eigen::Matrix2cd(coeff_i.computeInverseP() * coeff_i1.computeP());
    const auto mp = 0.5 * (Eigen::Matrix2cd::Identity() + P) * roughness_diff;
    const auto mm = 0.5 * (Eigen::Matrix2cd::Identity() - P) * roughness_sum;
 
    return {mp, mm};
}

References MatrixRTCoefficients::computeInverseP(), MatrixRTCoefficients::computeP(), and computeRoughnessMatrices().

Here is the call graph for this function:

computeRoughnessMatrices()

std::pair< Eigen::Matrix2cd, Eigen::Matrix2cd > SpecularMagneticNCStrategy::computeRoughnessMatrices ( const MatrixRTCoefficients &  coeff_i, const MatrixRTCoefficients &  coeff_i1, double  sigma  ) const

private

Definition at line 21 of file SpecularMagneticNCStrategy.cpp.

{
    complex_t beta_i = coeff_i.m_lambda(1) - coeff_i.m_lambda(0);
    complex_t beta_i1 = coeff_i1.m_lambda(1) - coeff_i1.m_lambda(0);
 
    auto roughness_matrix = [sigma, &coeff_i, &coeff_i1, beta_i, beta_i1](double sign) {
        const complex_t alpha_p = coeff_i1.m_lambda(0) + coeff_i1.m_lambda(1)
                                  + sign * (coeff_i.m_lambda(0) + coeff_i.m_lambda(1));
        auto b_p_vec = beta_i1 * coeff_i1.m_b + sign * beta_i * coeff_i.m_b;
 
        auto square = [](auto& v) { return v.x() * v.x() + v.y() * v.y() + v.z() * v.z(); };
        complex_t beta_p = std::sqrt(checkForUnderflow(square(b_p_vec)));
        b_p_vec /= beta_p;
 
        const complex_t alpha_pp = -(alpha_p * alpha_p + beta_p * beta_p) * sigma * sigma / 8.;
        const complex_t beta_pp = -alpha_p * beta_p * sigma * sigma / 4.;
 
        Eigen::Matrix2cd QL, QR;
 
        const complex_t factor1 = std::sqrt(2. * (1. + b_p_vec.z()));
        const complex_t factor2 = std::sqrt(2. * (1. - b_p_vec.z()));
        QL << (b_p_vec.z() + 1.) / factor1, (b_p_vec.z() - 1.) / factor2,
            (b_p_vec.x() + I * b_p_vec.y()) / factor1, (b_p_vec.x() + I * b_p_vec.y()) / factor2;
        QR << (b_p_vec.z() + 1.) / factor1, (b_p_vec.x() - I * b_p_vec.y()) / factor1,
            (b_p_vec.z() - 1.) / factor2, (b_p_vec.x() - I * b_p_vec.y()) / factor2;
 
        const Eigen::Matrix2cd exp1 =
            Eigen::DiagonalMatrix<complex_t, 2>({std::exp(alpha_pp), std::exp(alpha_pp)});
 
        if (std::abs(beta_p) > std::numeric_limits<double>::epsilon() * 10.) {
            Eigen::Matrix2cd exp2 = Eigen::Matrix2cd(
                Eigen::DiagonalMatrix<complex_t, 2>({std::exp(beta_pp), std::exp(-beta_pp)}));
            return Eigen::Matrix2cd{exp1 * QL * exp2 * QR};
        }
 
        return exp1;
    };
 
    const Eigen::Matrix2cd roughness_sum = roughness_matrix(1.);
    const Eigen::Matrix2cd roughness_diff = roughness_matrix(-1.);
 
    return {roughness_sum, roughness_diff};
}

References I, MatrixRTCoefficients::m_b, MatrixRTCoefficients::m_lambda, and BasicVector3D< T >::x().

Referenced by computeBackwardsSubmatrices().

Here is the call graph for this function:

computeTopLayerR()

std::variant< complex_t, Eigen::Matrix2cd > SpecularMagneticStrategy::computeTopLayerR ( const std::vector< Slice > &  slices, const std::vector< complex_t > &  kzs  ) const

overridevirtualinherited

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

Implements ISpecularStrategy.

Definition at line 55 of file SpecularMagneticStrategy.cpp.

{
    if (slices.size() != kzs.size())
        throw std::runtime_error("Number of slices does not match the size of the kz-vector");
 
    const auto N = slices.size();
 
    if(N == 1)
        return Eigen::Matrix2cd::Zero();
    else if(kzs[0] == 0.)
        return -Eigen::Matrix2cd::Identity();
 
    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](int i){
        const auto B = slices[i].bField() - B_0;
        const auto magnetic_SLD = magneticSLD(B);
 
        return MatrixRTCoefficients(kz_sign, checkForUnderflow(eigenvalues(kzs[i], magnetic_SLD)),
                B.mag() > eps ? B / B.mag() : kvector_t{0.0, 0.0, 0.0}, magnetic_SLD);
    };
 
    auto c_i1 = createCoeff(N-1);
 
    // bottom boundary condition
    c_i1.m_R = Eigen::Matrix2cd::Zero();
 
    for (int i = N - 2; i >= 0; --i) {
        auto c_i = createCoeff(i);
 
        double sigma = 0.;
        if (const auto roughness = GetBottomRoughness(slices, i))
            sigma = roughness->getSigma();
 
        // compute the 2x2 submatrices in the write-up denoted as P+, P- and delta
        const auto [mp, mm] = computeBackwardsSubmatrices(c_i, c_i1, sigma);
 
        const Eigen::Matrix2cd delta = c_i.computeDeltaMatrix(slices[i].thickness());
 
        // compute the rotation matrix
        Eigen::Matrix2cd S, Si;
        Si = mp + mm * c_i1.m_R;
        S << Si(1, 1), -Si(0, 1), -Si(1, 0), Si(0, 0);
        const complex_t norm = S(0, 0) * S(1, 1) - S(0, 1) * S(1, 0);
        S = S * delta;
        S /= norm;
 
        c_i.m_R = delta * (mm + mp * c_i1.m_R) * S;
        c_i1 = c_i;
    }
    return c_i1.m_R;
}

References SpecularMagneticStrategy::computeBackwardsSubmatrices().

Here is the call graph for this function:

computeTR()

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

privateinherited

Definition at line 111 of file SpecularMagneticStrategy.cpp.

{
    const size_t N = slices.size();
 
    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> result;
    result.reserve(N);
 
    const double kz_sign = kzs.front().real() >= 0.0 ? 1.0 : -1.0; // save sign to restore it later
 
    auto B_0 = slices.front().bField();
    result.emplace_back(kz_sign, eigenvalues(kzs.front(), 0.0), kvector_t{0.0, 0.0, 0.0}, 0.0);
    for (size_t i = 1, size = slices.size(); i < size; ++i) {
        auto B = slices[i].bField() - B_0;
        auto magnetic_SLD = magneticSLD(B);
        result.emplace_back(kz_sign, checkForUnderflow(eigenvalues(kzs[i], magnetic_SLD)),
                            B.mag() > eps ? B / B.mag() : kvector_t{0.0, 0.0, 0.0}, magnetic_SLD);
    }
 
    if (N == 1) {
        result[0].m_T = Eigen::Matrix2cd::Identity();
        result[0].m_R = Eigen::Matrix2cd::Zero();
        return result;
 
    } else if (kzs[0] == 0.) {
        result[0].m_T = Eigen::Matrix2cd::Identity();
        result[0].m_R = -Eigen::Matrix2cd::Identity();
        for (size_t i = 1; i < N; ++i) {
            result[i].m_T.setZero();
            result[i].m_R.setZero();
        }
        return result;
    }
 
    calculateUpwards(result, slices);
 
    return result;
}

References SpecularMagneticStrategy::calculateUpwards().

Referenced by SpecularMagneticStrategy::Execute().

Here is the call graph for this function:

Execute() [1/2]

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

virtualinherited

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

Implements ISpecularStrategy.

Definition at line 34 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

virtualinherited

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 41 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>(coeff));
 
    return result;
}

References SpecularMagneticStrategy::computeTR().

Here is the call graph for this function:

---

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

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