Strategy class to compute the total scattering from a particle layout in the size-spacing correlation approximation. More...

Inheritance diagram for SSCApproximationStrategy:

[legend]

Collaboration diagram for SSCApproximationStrategy:

[legend]

Public Member Functions
	SSCApproximationStrategy (const std::vector< FormFactorCoherentSum > &weighted_formfactors, const InterferenceFunctionRadialParaCrystal *iff, SimulationOptions sim_params, bool polarized, double kappa)

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
complex_t	calculatePositionOffsetPhase (double qp, double radial_extension) const

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

double	evaluateSinglePoint (const SimulationElement &sim_element) const

complex_t	getCharacteristicSizeCoupling (double qp, const std::vector< FormFactorCoherentSum > &ff_wrappers) const

void	init (const std::vector< FormFactorCoherentSum > &ff_wrappers)

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 scattering intensity for given kf and for one particle layout (implied by the given particle form factors). More...

Private Attributes
std::unique_ptr< InterferenceFunctionRadialParaCrystal >	m_iff

std::unique_ptr< IntegratorMCMiser< IInterferenceFunctionStrategy > >	m_integrator

double	m_kappa

double	m_mean_radius

bool	m_polarized

Detailed Description

Strategy class to compute the total scattering from a particle layout in the size-spacing correlation approximation.

Definition at line 33 of file SSCApproximationStrategy.h.

Constructor & Destructor Documentation

◆ SSCApproximationStrategy()

SSCApproximationStrategy::SSCApproximationStrategy	(	const std::vector< FormFactorCoherentSum > &	weighted_formfactors,
		const InterferenceFunctionRadialParaCrystal *	iff,
		SimulationOptions	sim_params,
		bool	polarized,
		double	kappa
	)

Definition at line 20 of file SSCApproximationStrategy.cpp.

     : IInterferenceFunctionStrategy(weighted_formfactors, sim_params, polarized)
     , m_iff(iff->clone())
     , m_kappa(kappa)
 {
     m_mean_radius = 0.0;
     for (const auto& ffw : m_weighted_formfactors)
         m_mean_radius += ffw.relativeAbundance() * ffw.radialExtension();
 }

References m_mean_radius, and IInterferenceFunctionStrategy::m_weighted_formfactors.

Member Function Documentation

◆ calculatePositionOffsetPhase()

complex_t SSCApproximationStrategy::calculatePositionOffsetPhase	(	double	qp,
		double	radial_extension
	)		const

private

Definition at line 100 of file SSCApproximationStrategy.cpp.

 {
     return exp_I(m_kappa * qp * (radial_extension - m_mean_radius));
 }

References exp_I(), m_kappa, and m_mean_radius.

Referenced by getCharacteristicSizeCoupling(), polarizedCalculation(), and scalarCalculation().

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 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:

◆ getCharacteristicSizeCoupling()

complex_t SSCApproximationStrategy::getCharacteristicSizeCoupling	(	double	qp,
		const std::vector< FormFactorCoherentSum > &	ff_wrappers
	)		const

private

Definition at line 90 of file SSCApproximationStrategy.cpp.

 {
     complex_t result = 0;
     for (const auto& ffw : ff_wrappers)
         result +=
             ffw.relativeAbundance() * calculatePositionOffsetPhase(2.0 * qp, ffw.radialExtension());
     return result;
 }

References calculatePositionOffsetPhase().

Referenced by polarizedCalculation(), and scalarCalculation().

Here is the call graph for this function:

◆ init()

void SSCApproximationStrategy::init ( const std::vector< FormFactorCoherentSum > & ff_wrappers )

private

◆ 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 SSCApproximationStrategy::polarizedCalculation ( const SimulationElement & sim_element ) const

overrideprivatevirtual

This is the polarized version.

Implements IInterferenceFunctionStrategy.

Definition at line 60 of file SSCApproximationStrategy.cpp.

 {
     const double qp = sim_element.meanQ().magxy();
     Eigen::Matrix2cd diffuse_matrix = Eigen::Matrix2cd::Zero();
     const auto& polarization_handler = sim_element.polarizationHandler();
     Eigen::Matrix2cd ff_orig = Eigen::Matrix2cd::Zero();
     Eigen::Matrix2cd ff_conj = Eigen::Matrix2cd::Zero();
     for (const auto& ffw : m_weighted_formfactors) {
         const Eigen::Matrix2cd ff = ffw.evaluatePol(sim_element);
         const double fraction = ffw.relativeAbundance();
         diffuse_matrix += fraction * (ff * polarization_handler.getPolarization() * ff.adjoint());
         const double radial_extension = ffw.radialExtension();
         const complex_t prefac =
             ffw.relativeAbundance() * calculatePositionOffsetPhase(qp, radial_extension);
         ff_orig += prefac * ff;
         ff_conj += prefac * ff.adjoint();
     }
     const complex_t p2kappa = getCharacteristicSizeCoupling(qp, m_weighted_formfactors);
     const complex_t omega = m_iff->FTPDF(qp);
     const Eigen::Matrix2cd interference_matrix =
         (2.0 * omega / (1.0 - p2kappa * omega)) * polarization_handler.getAnalyzerOperator()
         * ff_orig * polarization_handler.getPolarization() * ff_conj;
     const Eigen::Matrix2cd diffuse_matrix2 =
         polarization_handler.getAnalyzerOperator() * diffuse_matrix;
     const double interference_trace = std::abs(interference_matrix.trace());
     const double diffuse_trace = std::abs(diffuse_matrix2.trace());
     const double dw_factor = m_iff->DWfactor(sim_element.meanQ());
     return diffuse_trace + dw_factor * interference_trace;
 }

References calculatePositionOffsetPhase(), getCharacteristicSizeCoupling(), m_iff, IInterferenceFunctionStrategy::m_weighted_formfactors, BasicVector3D< T >::magxy(), SimulationElement::meanQ(), and SimulationElement::polarizationHandler().

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 36 of file SSCApproximationStrategy.cpp.

 {
     const double qp = sim_element.meanQ().magxy();
     double diffuse_intensity = 0.0;
     complex_t ff_orig = 0., ff_conj = 0.; // original and conjugated mean formfactor
     for (const auto& ffw : m_weighted_formfactors) {
         complex_t ff = ffw.evaluate(sim_element);
         double fraction = ffw.relativeAbundance();
         diffuse_intensity += fraction * std::norm(ff);
         double radial_extension = ffw.radialExtension();
         complex_t prefac =
             ffw.relativeAbundance() * calculatePositionOffsetPhase(qp, radial_extension);
         ff_orig += prefac * ff;
         ff_conj += prefac * std::conj(ff);
     }
     const complex_t mean_ff_norm = ff_orig * ff_conj;
     const complex_t p2kappa = getCharacteristicSizeCoupling(qp, m_weighted_formfactors);
     const complex_t omega = m_iff->FTPDF(qp);
     const double iff = 2.0 * (mean_ff_norm * omega / (1.0 - p2kappa * omega)).real();
     const double dw_factor = m_iff->DWfactor(sim_element.meanQ());
     return diffuse_intensity + dw_factor * iff;
 }