DecouplingApproximationStrategy.cpp

Go to the documentation of this file.

//  ************************************************************************************************
//
//  BornAgain: simulate and fit reflection and scattering
//
//! @file      Resample/Interparticle/DecouplingApproximationStrategy.cpp
//! @brief     Implements class DecouplingApproximationStrategy.
//!
//! @homepage  http://www.bornagainproject.org
//! @license   GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors   Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
//  ************************************************************************************************
 
#include "Resample/Interparticle/DecouplingApproximationStrategy.h"
#include "Base/Math/Functions.h"
#include "Resample/Coherence/CoherentFFSum.h"
#include "Resample/Element/DiffuseElement.h"
#include "Sample/Aggregate/InterferenceNone.h"
 
DecouplingApproximationStrategy::DecouplingApproximationStrategy(
    const std::vector<std::unique_ptr<const CoherentFFSum>>& weighted_formfactors,
    const IInterference* iff, SimulationOptions sim_params, bool polarized)
    : IInterparticleStrategy(weighted_formfactors, sim_params, polarized)
    , m_iff(iff ? iff->clone() : new InterferenceNone())
 
{
}
 
//! Returns the total incoherent and coherent scattering intensity for given kf and
//! for one particle layout (implied by the given particle form factors).
//! This is the scalar version
double DecouplingApproximationStrategy::scalarCalculation(const DiffuseElement& ele) const
{
    double intensity = 0.0;
    complex_t amplitude = complex_t(0.0, 0.0);
    for (const auto& ffw : m_weighted_formfactors) {
        const complex_t ff = ffw->summedFF(ele);
        if (std::isnan(ff.real()))
            throw std::runtime_error(
                "numerical error in coherent sum (scalar, DA): amplitude is NaN");
        const double fraction = ffw->relativeAbundance();
        amplitude += fraction * ff;
        intensity += fraction * std::norm(ff);
    }
    const double amplitude_norm = std::norm(amplitude); // squared magnitude
    const double coherence_factor = m_iff->structureFactor(ele.meanQ());
    return intensity + amplitude_norm * (coherence_factor - 1.0);
}
 
//! This is the polarized version
double DecouplingApproximationStrategy::polarizedCalculation(const DiffuseElement& ele) const
{
    SpinMatrix mean_intensity;
    SpinMatrix mean_amplitude;
 
    const auto& polarization_handler = ele.polMatrices();
    for (const auto& ffw : m_weighted_formfactors) {
        const SpinMatrix ff = ffw->summedPolFF(ele);
        if (!ff.allFinite())
            throw std::runtime_error(
                "numerical error in coherent sum (polarized, DA): amplitude is NaN");
        const double fraction = ffw->relativeAbundance();
        mean_amplitude += fraction * ff;
        mean_intensity += fraction * (ff * polarization_handler.polarizerMatrix() * ff.adjoint());
    }
    const SpinMatrix amplitude_matrix = polarization_handler.analyzerMatrix() * mean_amplitude
                                        * polarization_handler.polarizerMatrix()
                                        * mean_amplitude.adjoint();
    const SpinMatrix intensity_matrix = polarization_handler.analyzerMatrix() * mean_intensity;
    const double amplitude_trace = std::abs(amplitude_matrix.trace());
    const double intensity_trace = std::abs(intensity_matrix.trace());
    const double coherence_factor = m_iff->structureFactor(ele.meanQ());
    return intensity_trace + amplitude_trace * (coherence_factor - 1.0);
}