SpecularMagneticNewStrategy Class Reference

Inheritance diagram for SpecularMagneticNewStrategy:

Collaboration diagram for SpecularMagneticNewStrategy:

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

Private Member Functions
std::vector< MatrixRTCoefficients_v3 >	computeTR (const std::vector< Slice > &slices, const std::vector< complex_t > &kzs) const
virtual std::pair< Eigen::Matrix2cd, Eigen::Matrix2cd >	computeBackwardsSubmatrices (const MatrixRTCoefficients_v3 &coeff_i, const MatrixRTCoefficients_v3 &coeff_i1, double sigma) const =0
void	calculateUpwards (std::vector< MatrixRTCoefficients_v3 > &coeff, const std::vector< Slice > &slices) 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 33 of file SpecularMagneticNewStrategy.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 SpecularMagneticNewStrategy::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 35 of file SpecularMagneticNewStrategy.cpp.

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

References KzComputation::computeReducedKz(), and Execute().

Referenced by Execute().

Here is the call graph for this function:

Execute() [2/2]

ISpecularStrategy::coeffs_t SpecularMagneticNewStrategy::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 42 of file SpecularMagneticNewStrategy.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_v3>(coeff));
 
    return result;
}

References computeTR().

Here is the call graph for this function:

computeTR()

std::vector< MatrixRTCoefficients_v3 > SpecularMagneticNewStrategy::computeTR ( const std::vector< Slice > &  slices, const std::vector< complex_t > &  kzs  ) const

private

Definition at line 56 of file SpecularMagneticNewStrategy.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_v3> 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(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::checkForUnderflow(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::eigenvalues(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::eps, and anonymous_namespace{SpecularMagneticNewStrategy.cpp}::magneticSLD().

Referenced by Execute().

Here is the call graph for this function:

computeBackwardsSubmatrices()

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

privatepure virtual

Implemented in SpecularMagneticNewTanhStrategy, and SpecularMagneticNewNCStrategy.

Referenced by calculateUpwards().

calculateUpwards()

void SpecularMagneticNewStrategy::calculateUpwards ( std::vector< MatrixRTCoefficients_v3 > &  coeff, const std::vector< Slice > &  slices  ) const

private

Definition at line 101 of file SpecularMagneticNewStrategy.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 mpmm = computeBackwardsSubmatrices(coeff[i], coeff[i + 1], sigma);
        const Eigen::Matrix2cd mp = mpmm.first;
        const Eigen::Matrix2cd mm = mpmm.second;
 
        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(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::GetBottomRoughness(), and MathFunctions::Si().

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