TransitionMagneticTanh.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Resample/Specular/TransitionMagneticTanh.cpp
//! @brief     Implements class SpecularMagneticTanhStrategy.
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2020
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "Resample/Specular/TransitionMagneticTanh.h"
#include "Base/Math/Constants.h"
#include "Base/Math/Functions.h"
#include "Resample/Flux/MatrixFlux.h"
 
namespace {
 
SpinMatrix computeRoughnessMatrix(const MatrixFlux& coeff, double sigma, bool inverse)
{
    if (sigma < 10 * std::numeric_limits<double>::epsilon())
        return SpinMatrix::One();
 
    const double sigeff = std::pow(M_PI_2, 1.5) * sigma;
    const auto b = coeff.m_b;
 
    if (std::abs(b.mag() - 1.) < std::numeric_limits<double>::epsilon() * 10.) {
        const double factor1 = 2. * (1. + b.z());
        SpinMatrix Q((1. + b.z()), (I * b.y() - b.x()), (b.x() + I * b.y()), (b.z() + 1.));
 
        complex_t l1 = std::sqrt(Math::tanhc(sigeff * coeff.m_lambda.v));
        complex_t l2 = std::sqrt(Math::tanhc(sigeff * coeff.m_lambda.u));
 
        if (inverse) {
            l1 = 1. / l1;
            l2 = 1. / l2;
        }
 
        const SpinMatrix lambda(l1, 0, 0, l2);
 
        return Q * lambda * Q.adjoint() / factor1;
    }
 
    if (b.mag() < 10 * std::numeric_limits<double>::epsilon()) {
        complex_t alpha =
            std::sqrt(Math::tanhc(0.5 * sigeff * (coeff.m_lambda.v + coeff.m_lambda.u)));
        if (inverse)
            alpha = 1. / alpha;
        const SpinMatrix lambda(alpha, 0, 0, alpha);
 
        return lambda;
    }
 
    throw std::runtime_error("Broken magnetic field vector");
}
 
} // namespace
 
 
std::pair<SpinMatrix, SpinMatrix>
Compute::TransitionMagneticTanh::backwardsSubmatrices(const MatrixFlux& coeff_i,
                                                      const MatrixFlux& coeff_i1, double sigma)
{
    SpinMatrix R{SpinMatrix::One()};
    SpinMatrix RInv{SpinMatrix::One()};
 
    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 SpinMatrix mproduct = coeff_i.computeInverseP() * coeff_i1.computeP();
    const SpinMatrix mp = 0.5 * (RInv + mproduct * R);
    const SpinMatrix mm = 0.5 * (RInv - mproduct * R);
 
    return {mp, mm};
}