SpecularMagneticNewTanhStrategy Class Reference

Inheritance diagram for SpecularMagneticNewTanhStrategy:

Collaboration diagram for SpecularMagneticNewTanhStrategy:

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
virtual std::pair< Eigen::Matrix2cd, Eigen::Matrix2cd >	computeBackwardsSubmatrices (const MatrixRTCoefficients_v3 &coeff_i, const MatrixRTCoefficients_v3 &coeff_i1, double sigma) const
Eigen::Matrix2cd	computeRoughnessMatrix (const MatrixRTCoefficients_v3 &coeff, double sigma, bool inverse=false) const
std::vector< MatrixRTCoefficients_v3 >	computeTR (const std::vector< Slice > &slices, const std::vector< complex_t > &kzs) const
void	calculateUpwards (std::vector< MatrixRTCoefficients_v3 > &coeff, const std::vector< Slice > &slices) const

Detailed Description

Implements the magnetic Fresnel computation with the analytical Tanh 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 28 of file SpecularMagneticNewTanhStrategy.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

computeBackwardsSubmatrices()

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

privatevirtual

Implements SpecularMagneticNewStrategy.

Definition at line 65 of file SpecularMagneticNewTanhStrategy.cpp.

{
    Eigen::Matrix2cd R{Eigen::Matrix2cd::Identity()};
    Eigen::Matrix2cd RInv{Eigen::Matrix2cd::Identity()};
 
    if (sigma != 0.) {
        R = computeRoughnessMatrix(coeff_i1, sigma, false)
            * computeRoughnessMatrix(coeff_i, sigma, true);
 
        RInv = computeRoughnessMatrix(coeff_i, sigma, false)
               * computeRoughnessMatrix(coeff_i1, sigma, true);
    }
 
    const Eigen::Matrix2cd mproduct = coeff_i.computeInverseP() * coeff_i1.computeP();
    const Eigen::Matrix2cd mp = 0.5 * (RInv + mproduct * R);
    const Eigen::Matrix2cd mm = 0.5 * (RInv - mproduct * R);
 
    return {mp, mm};
}

References MatrixRTCoefficients_v3::computeInverseP(), MatrixRTCoefficients_v3::computeP(), and computeRoughnessMatrix().

Here is the call graph for this function:

computeRoughnessMatrix()

Eigen::Matrix2cd SpecularMagneticNewTanhStrategy::computeRoughnessMatrix ( const MatrixRTCoefficients_v3 &  coeff, double  sigma, bool  inverse = false  ) const

private

Definition at line 25 of file SpecularMagneticNewTanhStrategy.cpp.

{
    if (sigma < 10 * std::numeric_limits<double>::epsilon())
        return Eigen::Matrix2cd{Eigen::Matrix2cd::Identity()};
 
    const double sigeff = pi2_15 * sigma;
    const auto b = coeff.m_b;
 
    if (std::abs(b.mag() - 1.) < std::numeric_limits<double>::epsilon() * 10.) {
        Eigen::Matrix2cd Q;
        const double factor1 = 2. * (1. + b.z());
        Q << (1. + b.z()), (I * b.y() - b.x()), (b.x() + I * b.y()), (b.z() + 1.);
 
        complex_t l1 = std::sqrt(MathFunctions::tanhc(sigeff * coeff.m_lambda(1)));
        complex_t l2 = std::sqrt(MathFunctions::tanhc(sigeff * coeff.m_lambda(0)));
 
        if (inverse) {
            l1 = 1. / l1;
            l2 = 1. / l2;
        }
 
        const Eigen::Matrix2cd lambda = Eigen::DiagonalMatrix<complex_t, 2>({l1, l2});
 
        return Q * lambda * Q.adjoint() / factor1;
 
    } else if (b.mag() < 10 * std::numeric_limits<double>::epsilon()) {
        complex_t alpha =
            std::sqrt(MathFunctions::tanhc(0.5 * sigeff * (coeff.m_lambda(1) + coeff.m_lambda(0))));
        if (inverse)
            alpha = 1. / alpha;
        const Eigen::Matrix2cd lambda = Eigen::DiagonalMatrix<complex_t, 2>({alpha, alpha});
 
        return lambda;
    }
 
    throw std::runtime_error("Broken magnetic field vector");
}

References I, MatrixRTCoefficients_v3::m_b, MatrixRTCoefficients_v3::m_lambda, anonymous_namespace{SpecularMagneticNewTanhStrategy.cpp}::pi2_15, and MathFunctions::tanhc().

Referenced by computeBackwardsSubmatrices().

Here is the call graph for this function:

Execute() [1/2]

ISpecularStrategy::coeffs_t SpecularMagneticNewStrategy::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 35 of file SpecularMagneticNewStrategy.cpp.

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

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

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

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

privateinherited

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 SpecularMagneticNewStrategy::calculateUpwards(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::checkForUnderflow(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::eigenvalues(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::eps, and anonymous_namespace{SpecularMagneticNewStrategy.cpp}::magneticSLD().

Referenced by SpecularMagneticNewStrategy::Execute().

Here is the call graph for this function:

calculateUpwards()

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

privateinherited

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 SpecularMagneticNewStrategy::computeBackwardsSubmatrices(), anonymous_namespace{SpecularMagneticNewStrategy.cpp}::GetBottomRoughness(), and MathFunctions::Si().

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