Inheritance diagram for IInterferenceFunctionStrategy:

Collaboration diagram for IInterferenceFunctionStrategy:

Public Member Functions
	IInterferenceFunctionStrategy (const SimulationOptions &sim_params, bool polarized)

virtual	~IInterferenceFunctionStrategy ()

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	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 ()

virtual double	scalarCalculation (const SimulationElement &sim_element) const =0

virtual double	polarizedCalculation (const SimulationElement &sim_element) const =0

Private Attributes
bool	m_polarized

std::unique_ptr< IntegratorMCMiser< IInterferenceFunctionStrategy > >	mP_integrator

Detailed Description

Base class of all interference function strategy classes.

Provides an 'evaluate' function that computes the total scattering intensity from a decorated layer, taking into account a specific inter-particle interference function. This function uses the low-level functions scalarCalculation and polarizedCalculation that are to be overriden in the derived classes. Inheritance is used to support different approximation schemes (DecouplingApproximationStrategy, SSCApproximationStrategy).

Instantiation of child classes takes place in LayoutStrategyBuilder::createStrategy, which is called from ParticleLayoutComputation::eval.

Definition at line 41 of file IInterferenceFunctionStrategy.h.

Constructor & Destructor Documentation

◆ IInterferenceFunctionStrategy()

IInterferenceFunctionStrategy::IInterferenceFunctionStrategy	(	const SimulationOptions &	sim_params,
		bool	polarized
	)

Definition at line 22 of file IInterferenceFunctionStrategy.cpp.

     : mP_iff(nullptr), m_options(sim_params), m_polarized(polarized),
       mP_integrator(
           make_integrator_miser(this, &IInterferenceFunctionStrategy::evaluate_for_fixed_angles, 2))
 {
 }

◆ ~IInterferenceFunctionStrategy()

IInterferenceFunctionStrategy::~IInterferenceFunctionStrategy ( )

virtualdefault

Member Function Documentation

◆ init()

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

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(), m_formfactor_wrappers, mP_iff, and strategy_specific_post_init().

Here is the call graph for this function:

◆ evaluate()

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

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 evaluateSinglePoint(), SimulationElement::getSolidAngle(), SimulationOptions::isIntegrate(), m_options, and MCIntegratedEvaluate().

Here is the call graph for this function:

◆ evaluateSinglePoint()

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

private

Definition at line 56 of file IInterferenceFunctionStrategy.cpp.

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

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

Referenced by evaluate(), and evaluate_for_fixed_angles().

Here is the call graph for this function:

◆ MCIntegratedEvaluate()

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

private

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(), m_options, and mP_integrator.

Referenced by 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

private

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);
 }