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

Inheritance diagram for DecouplingApproximationStrategy:

Collaboration diagram for DecouplingApproximationStrategy:

Public Member Functions
	DecouplingApproximationStrategy (const std::vector< FormFactorCoherentSum > &weighted_formfactors, const IInterferenceFunction *iff, SimulationOptions sim_params, bool polarized)

double	evaluate (const SimulationElement &sim_element) const
	Calculates the intensity for scalar particles/interactions. More...

Protected Attributes
const SimulationOptions	m_options

std::vector< FormFactorCoherentSum >	m_weighted_formfactors

Private Member Functions
double	evaluate_for_fixed_angles (double fractions, size_t dim, void params) const

double	evaluateSinglePoint (const SimulationElement &sim_element) const

double	MCIntegratedEvaluate (const SimulationElement &sim_element) const
	Performs a Monte Carlo integration over the bin for the evaluation of the intensity. More...

double	polarizedCalculation (const SimulationElement &sim_element) const override
	This is the polarized version. More...

double	scalarCalculation (const SimulationElement &sim_element) const override
	Returns the total incoherent and coherent scattering intensity for given kf and for one particle layout (implied by the given particle form factors). More...

Private Attributes
std::unique_ptr< IInterferenceFunction >	m_iff

std::unique_ptr< IntegratorMCMiser< IInterferenceFunctionStrategy > >	m_integrator

bool	m_polarized

Detailed Description

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

Definition at line 31 of file DecouplingApproximationStrategy.h.

Constructor & Destructor Documentation

◆ DecouplingApproximationStrategy()

DecouplingApproximationStrategy::DecouplingApproximationStrategy	(	const std::vector< FormFactorCoherentSum > &	weighted_formfactors,
		const IInterferenceFunction *	iff,
		SimulationOptions	sim_params,
		bool	polarized
	)

Definition at line 22 of file DecouplingApproximationStrategy.cpp.

     : IInterferenceFunctionStrategy(weighted_formfactors, sim_params, polarized)
     , m_iff(iff ? iff->clone() : new InterferenceFunctionNone())
  
 {
 }

Member Function Documentation

◆ evaluate()

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

inherited

Calculates the intensity for scalar particles/interactions.

Definition at line 35 of file IInterferenceFunctionStrategy.cpp.

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

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

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 60 of file IInterferenceFunctionStrategy.cpp.

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

References IInterferenceFunctionStrategy::evaluateSinglePoint(), SimulationElement::integrationFactor(), and SimulationElement::pointElement().

Here is the call graph for this function:

◆ evaluateSinglePoint()

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

privateinherited

Definition at line 43 of file IInterferenceFunctionStrategy.cpp.

 {
     if (!m_polarized)
         return scalarCalculation(sim_element);
     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 52 of file IInterferenceFunctionStrategy.cpp.

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

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

Referenced by IInterferenceFunctionStrategy::evaluate().

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 55 of file DecouplingApproximationStrategy.cpp.

 {
     Eigen::Matrix2cd mean_intensity = Eigen::Matrix2cd::Zero();
     Eigen::Matrix2cd mean_amplitude = Eigen::Matrix2cd::Zero();
  
     const auto& polarization_handler = sim_element.polarizationHandler();
     for (const auto& ffw : m_weighted_formfactors) {
         const Eigen::Matrix2cd ff = ffw.evaluatePol(sim_element);
         if (!ff.allFinite())
             throw std::runtime_error("DecouplingApproximationStrategy::polarizedCalculation() -> "
                                      "Error! Form factor contains NaN or infinite");
         const double fraction = ffw.relativeAbundance();
         mean_amplitude += fraction * ff;
         mean_intensity += fraction * (ff * polarization_handler.getPolarization() * ff.adjoint());
     }
     const Eigen::Matrix2cd amplitude_matrix =
         polarization_handler.getAnalyzerOperator() * mean_amplitude
         * polarization_handler.getPolarization() * mean_amplitude.adjoint();
     const Eigen::Matrix2cd intensity_matrix =
         polarization_handler.getAnalyzerOperator() * 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->evaluate(sim_element.meanQ());
     return intensity_trace + amplitude_trace * (coherence_factor - 1.0);
 }

References m_iff, IInterferenceFunctionStrategy::m_weighted_formfactors, SimulationElement::meanQ(), and SimulationElement::polarizationHandler().

Here is the call graph for this function:

◆ 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 35 of file DecouplingApproximationStrategy.cpp.

 {
     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.evaluate(sim_element);
         if (std::isnan(ff.real()))
             throw std::runtime_error(
                 "DecouplingApproximationStrategy::scalarCalculation() -> Error! Amplitude is NaN");
         double fraction = ffw.relativeAbundance();
         amplitude += fraction * ff;
         intensity += fraction * std::norm(ff);
     }
     const double amplitude_norm = std::norm(amplitude);
     const double coherence_factor = m_iff->evaluate(sim_element.meanQ());
     return intensity + amplitude_norm * (coherence_factor - 1.0);
 }