Inheritance diagram for SSCApproximationStrategy:

Collaboration diagram for SSCApproximationStrategy:

Public Member Functions
	SSCApproximationStrategy (SimulationOptions sim_params, double kappa, 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
void	strategy_specific_post_init () override

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

Private Attributes
SSCAHelper	m_helper

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 size-spacing correlation approximation.

Definition at line 26 of file SSCApproximationStrategy.h.

Constructor & Destructor Documentation

◆ SSCApproximationStrategy()

SSCApproximationStrategy::SSCApproximationStrategy	(	SimulationOptions	sim_params,
		double	kappa,
		bool	polarized
	)

Definition at line 23 of file SSCApproximationStrategy.cpp.

     : IInterferenceFunctionStrategy(sim_params, polarized), m_helper(kappa)
 {
 }

Member Function Documentation

◆ strategy_specific_post_init()

void SSCApproximationStrategy::strategy_specific_post_init ( )

overrideprivatevirtual

Reimplemented from IInterferenceFunctionStrategy.

Definition at line 29 of file SSCApproximationStrategy.cpp.

 {
     m_helper.init(m_formfactor_wrappers);
 }

References SSCAHelper::init(), IInterferenceFunctionStrategy::m_formfactor_wrappers, and m_helper.

Here is the call graph for this function:

◆ scalarCalculation()

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

overrideprivatevirtual

Returns the total 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 SSCApproximationStrategy.cpp.

 {
     double qp = sim_element.getMeanQ().magxy();
     double diffuse_intensity = 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];
         double fraction = m_formfactor_wrappers[i].relativeAbundance();
         diffuse_intensity += fraction * std::norm(ff);
     }
     complex_t mean_ff_norm =
         m_helper.getMeanFormfactorNorm(qp, precomputed_ff, m_formfactor_wrappers);
     complex_t p2kappa = m_helper.getCharacteristicSizeCoupling(qp, m_formfactor_wrappers);
     complex_t omega = m_helper.getCharacteristicDistribution(qp, mP_iff.get());
     double iff = 2.0 * (mean_ff_norm * omega / (1.0 - p2kappa * omega)).real();
     double dw_factor = mP_iff->DWfactor(sim_element.getMeanQ());
     return diffuse_intensity + dw_factor * iff;
 }

References SSCAHelper::getCharacteristicDistribution(), SSCAHelper::getCharacteristicSizeCoupling(), SSCAHelper::getMeanFormfactorNorm(), SimulationElement::getMeanQ(), IInterferenceFunctionStrategy::m_formfactor_wrappers, m_helper, BasicVector3D< T >::magxy(), IInterferenceFunctionStrategy::mP_iff, and InterferenceFunctionUtils::PrecomputeScalarFormFactors().

Here is the call graph for this function:

◆ polarizedCalculation()

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

overrideprivatevirtual

This is the polarized version.

Implements IInterferenceFunctionStrategy.

Definition at line 57 of file SSCApproximationStrategy.cpp.

 {
     double qp = sim_element.getMeanQ().magxy();
     Eigen::Matrix2cd diffuse_matrix = 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];
         double fraction = m_formfactor_wrappers[i].relativeAbundance();
         diffuse_matrix += fraction * (ff * polarization_handler.getPolarization() * ff.adjoint());
     }
     Eigen::Matrix2cd mff_orig, mff_conj; // original and conjugated mean formfactor
     m_helper.getMeanFormfactors(qp, mff_orig, mff_conj, precomputed_ff, m_formfactor_wrappers);
     complex_t p2kappa = m_helper.getCharacteristicSizeCoupling(qp, m_formfactor_wrappers);
     complex_t omega = m_helper.getCharacteristicDistribution(qp, mP_iff.get());
     Eigen::Matrix2cd interference_matrix = (2.0 * omega / (1.0 - p2kappa * omega))
                                            * polarization_handler.getAnalyzerOperator() * mff_orig
                                            * polarization_handler.getPolarization() * mff_conj;
     Eigen::Matrix2cd diffuse_matrix2 = polarization_handler.getAnalyzerOperator() * diffuse_matrix;
     double interference_trace = std::abs(interference_matrix.trace());
     double diffuse_trace = std::abs(diffuse_matrix2.trace());
     double dw_factor = mP_iff->DWfactor(sim_element.getMeanQ());
     return diffuse_trace + dw_factor * interference_trace;
 }

References SSCAHelper::getCharacteristicDistribution(), SSCAHelper::getCharacteristicSizeCoupling(), SSCAHelper::getMeanFormfactors(), SimulationElement::getMeanQ(), IInterferenceFunctionStrategy::m_formfactor_wrappers, m_helper, BasicVector3D< T >::magxy(), 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);
 }