Inheritance diagram for DecouplingApproximationStrategy:

Collaboration diagram for DecouplingApproximationStrategy:

Public Member Functions
	DecouplingApproximationStrategy (SimulationOptions sim_params, bool polarized)

void	init (const std::vector< FormFactorCoherentSum > &weighted_formfactors, const IInterferenceFunction *p_iff)

double	evaluate (const SimulationElement &sim_element) const

Protected Attributes
std::vector< FormFactorCoherentSum >	m_formfactor_wrappers

std::unique_ptr< IInterferenceFunction >	mP_iff

SimulationOptions	m_options

Private Member Functions
double	scalarCalculation (const SimulationElement &sim_element) const override

double	polarizedCalculation (const SimulationElement &sim_element) const override

double	evaluateSinglePoint (const SimulationElement &sim_element) const

double	MCIntegratedEvaluate (const SimulationElement &sim_element) const

double	evaluate_for_fixed_angles (double fractions, size_t dim, void params) const

virtual void	strategy_specific_post_init ()

Private Attributes
bool	m_polarized

std::unique_ptr< IntegratorMCMiser< IInterferenceFunctionStrategy > >	mP_integrator

Detailed Description

Strategy class to compute the total scattering from a particle layout in the decoupling approximation.

Definition at line 26 of file DecouplingApproximationStrategy.h.

Constructor & Destructor Documentation

◆ DecouplingApproximationStrategy()

DecouplingApproximationStrategy::DecouplingApproximationStrategy	(	SimulationOptions	sim_params,
		bool	polarized
	)

Definition at line 27 of file DecouplingApproximationStrategy.cpp.

     : IInterferenceFunctionStrategy(sim_params, polarized)
 {
 }

Member Function Documentation

◆ scalarCalculation()

double DecouplingApproximationStrategy::scalarCalculation ( const SimulationElement & sim_element ) const

overrideprivatevirtual

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

Implements IInterferenceFunctionStrategy.

Definition at line 37 of file DecouplingApproximationStrategy.cpp.

 {
     double intensity = 0.0;
     complex_t amplitude = complex_t(0.0, 0.0);
     auto precomputed_ff = PrecomputeScalarFormFactors(sim_element, m_formfactor_wrappers);
     for (size_t i = 0; i < m_formfactor_wrappers.size(); ++i) {
         complex_t ff = precomputed_ff[i];
         if (std::isnan(ff.real()))
             throw Exceptions::RuntimeErrorException(
                 "DecouplingApproximationStrategy::scalarCalculation() -> Error! Amplitude is NaN");
         double fraction = m_formfactor_wrappers[i].relativeAbundance();
         amplitude += fraction * ff;
         intensity += fraction * std::norm(ff);
     }
     double amplitude_norm = std::norm(amplitude);
     double itf_function = mP_iff->evaluate(sim_element.getMeanQ());
     return intensity + amplitude_norm * (itf_function - 1.0);
 }

References SimulationElement::getMeanQ(), IInterferenceFunctionStrategy::m_formfactor_wrappers, IInterferenceFunctionStrategy::mP_iff, and InterferenceFunctionUtils::PrecomputeScalarFormFactors().

Here is the call graph for this function:

◆ polarizedCalculation()

double DecouplingApproximationStrategy::polarizedCalculation ( const SimulationElement & sim_element ) const

overrideprivatevirtual

This is the polarized version.

Implements IInterferenceFunctionStrategy.

Definition at line 58 of file DecouplingApproximationStrategy.cpp.

 {
     Eigen::Matrix2cd mean_intensity = Eigen::Matrix2cd::Zero();
     Eigen::Matrix2cd mean_amplitude = Eigen::Matrix2cd::Zero();
  
     auto precomputed_ff = PrecomputePolarizedFormFactors(sim_element, m_formfactor_wrappers);
     const auto& polarization_handler = sim_element.polarizationHandler();
     for (size_t i = 0; i < m_formfactor_wrappers.size(); ++i) {
         Eigen::Matrix2cd ff = precomputed_ff[i];
         if (!ff.allFinite())
             throw Exceptions::RuntimeErrorException(
                 "DecouplingApproximationStrategy::polarizedCalculation() -> "
                 "Error! Form factor contains NaN or infinite");
         double fraction = m_formfactor_wrappers[i].relativeAbundance();
         mean_amplitude += fraction * ff;
         mean_intensity += fraction * (ff * polarization_handler.getPolarization() * ff.adjoint());
     }
     Eigen::Matrix2cd amplitude_matrix = polarization_handler.getAnalyzerOperator() * mean_amplitude
                                         * polarization_handler.getPolarization()
                                         * mean_amplitude.adjoint();
     Eigen::Matrix2cd intensity_matrix = polarization_handler.getAnalyzerOperator() * mean_intensity;
     double amplitude_trace = std::abs(amplitude_matrix.trace());
     double intensity_trace = std::abs(intensity_matrix.trace());
     double itf_function = mP_iff->evaluate(sim_element.getMeanQ());
     return intensity_trace + amplitude_trace * (itf_function - 1.0);
 }

References SimulationElement::getMeanQ(), IInterferenceFunctionStrategy::m_formfactor_wrappers, IInterferenceFunctionStrategy::mP_iff, SimulationElement::polarizationHandler(), and InterferenceFunctionUtils::PrecomputePolarizedFormFactors().

Here is the call graph for this function:

◆ init()

void IInterferenceFunctionStrategy::init	(	const std::vector< FormFactorCoherentSum > &	weighted_formfactors,
		const IInterferenceFunction *	p_iff
	)

inherited

Initializes the object with form factors and an interference function.

Definition at line 32 of file IInterferenceFunctionStrategy.cpp.

 {
     if (weighted_formfactors.empty())
         throw Exceptions::ClassInitializationException(
             "IInterferenceFunctionStrategy::init: strategy gets no form factors.");
     m_formfactor_wrappers = weighted_formfactors;
     if (p_iff)
         mP_iff.reset(p_iff->clone());
     else
         mP_iff.reset(new InterferenceFunctionNone());
  
     strategy_specific_post_init();
 }

References IInterferenceFunction::clone(), IInterferenceFunctionStrategy::m_formfactor_wrappers, IInterferenceFunctionStrategy::mP_iff, and IInterferenceFunctionStrategy::strategy_specific_post_init().

Here is the call graph for this function:

◆ evaluate()

double IInterferenceFunctionStrategy::evaluate ( const SimulationElement & sim_element ) const

inherited

Calculates the intensity for scalar particles/interactions.

Definition at line 48 of file IInterferenceFunctionStrategy.cpp.

 {
     if (m_options.isIntegrate() && (sim_element.getSolidAngle() > 0.0))
         return MCIntegratedEvaluate(sim_element);
     return evaluateSinglePoint(sim_element);
 }

References IInterferenceFunctionStrategy::evaluateSinglePoint(), SimulationElement::getSolidAngle(), SimulationOptions::isIntegrate(), IInterferenceFunctionStrategy::m_options, and IInterferenceFunctionStrategy::MCIntegratedEvaluate().

Here is the call graph for this function:

◆ evaluateSinglePoint()

double IInterferenceFunctionStrategy::evaluateSinglePoint ( const SimulationElement & sim_element ) const

privateinherited

Definition at line 56 of file IInterferenceFunctionStrategy.cpp.

 {
     if (!m_polarized)
         return scalarCalculation(sim_element);
     else
         return polarizedCalculation(sim_element);
 }

References IInterferenceFunctionStrategy::m_polarized, IInterferenceFunctionStrategy::polarizedCalculation(), and IInterferenceFunctionStrategy::scalarCalculation().

Referenced by IInterferenceFunctionStrategy::evaluate(), and IInterferenceFunctionStrategy::evaluate_for_fixed_angles().

Here is the call graph for this function:

◆ MCIntegratedEvaluate()

double IInterferenceFunctionStrategy::MCIntegratedEvaluate ( const SimulationElement & sim_element ) const

privateinherited

Performs a Monte Carlo integration over the bin for the evaluation of the intensity.

Definition at line 66 of file IInterferenceFunctionStrategy.cpp.

 {
     double min_array[] = {0.0, 0.0};
     double max_array[] = {1.0, 1.0};
     return mP_integrator->integrate(min_array, max_array, (void*)&sim_element,
                                     m_options.getMcPoints());
 }

References SimulationOptions::getMcPoints(), IInterferenceFunctionStrategy::m_options, and IInterferenceFunctionStrategy::mP_integrator.

Referenced by IInterferenceFunctionStrategy::evaluate().

Here is the call graph for this function:

◆ evaluate_for_fixed_angles()

double IInterferenceFunctionStrategy::evaluate_for_fixed_angles	(	double *	fractions,
		size_t	dim,
		void *	params
	)		const

privateinherited

Definition at line 74 of file IInterferenceFunctionStrategy.cpp.

 {
     double par0 = fractions[0];
     double par1 = fractions[1];
  
     SimulationElement* pars = static_cast<SimulationElement*>(params);
  
     SimulationElement sim_element(*pars, par0, par1);
     return pars->getIntegrationFactor(par0, par1) * evaluateSinglePoint(sim_element);
 }