SpecularMagneticStrategy Class Reference

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

Inheritance diagram for SpecularMagneticStrategy:

Collaboration diagram for SpecularMagneticStrategy:

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 =0
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 38 of file SpecularMagneticStrategy.h.

Member Typedef Documentation

coefficient_entry_type

using SpecularMagneticStrategy::coefficient_entry_type = Eigen::Matrix2cd

Definition at line 42 of file SpecularMagneticStrategy.h.

coefficient_pointer_type

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

Definition at line 44 of file SpecularMagneticStrategy.h.

coefficient_type

using SpecularMagneticStrategy::coefficient_type = MatrixRTCoefficients

Definition at line 43 of file SpecularMagneticStrategy.h.

coeffs_t

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

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

private

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 computeBackwardsSubmatrices().

Referenced by computeTR().

Here is the call graph for this function:

computeBackwardsSubmatrices()

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

privatepure virtual

Implemented in SpecularMagneticTanhStrategy, and SpecularMagneticNCStrategy.

Referenced by calculateUpwards(), and computeTopLayerR().

computeTopLayerR()

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

overridevirtual

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 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

private

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 calculateUpwards().

Referenced by 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

virtual

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

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 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 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/SpecularMagneticStrategy.h
• /home/www/ba/Sample/Specular/SpecularMagneticStrategy.cpp