Base class of all interference function strategy classes. More...

Inheritance diagram for IInterferenceFunctionStrategy:

Collaboration diagram for IInterferenceFunctionStrategy:

Public Member Functions
	IInterferenceFunctionStrategy (const std::vector< FormFactorCoherentSum > &weighted_formfactors, const SimulationOptions &sim_params, bool polarized)

virtual	~IInterferenceFunctionStrategy ()

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

virtual double	polarizedCalculation (const SimulationElement &sim_element) const =0
	Evaluates the intensity in the polarized case. More...

virtual double	scalarCalculation (const SimulationElement &sim_element) const =0
	Evaluates the intensity in the scalar case. More...

Private Attributes
std::unique_ptr< IntegratorMCMiser< IInterferenceFunctionStrategy > >	m_integrator

bool	m_polarized

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 46 of file IInterferenceFunctionStrategy.h.

Constructor & Destructor Documentation

◆ IInterferenceFunctionStrategy()

IInterferenceFunctionStrategy::IInterferenceFunctionStrategy	(	const std::vector< FormFactorCoherentSum > &	weighted_formfactors,
		const SimulationOptions &	sim_params,
		bool	polarized
	)

Definition at line 21 of file IInterferenceFunctionStrategy.cpp.

     : m_weighted_formfactors(weighted_formfactors)
     , m_options(sim_params)
     , m_polarized(polarized)
     , m_integrator(
           make_integrator_miser(this, &IInterferenceFunctionStrategy::evaluate_for_fixed_angles, 2))
 {
     ASSERT(!m_weighted_formfactors.empty());
 }

References ASSERT, and m_weighted_formfactors.

◆ ~IInterferenceFunctionStrategy()

IInterferenceFunctionStrategy::~IInterferenceFunctionStrategy ( )

virtualdefault

Member Function Documentation

◆ evaluate()

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

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 evaluateSinglePoint(), SimulationOptions::isIntegrate(), m_options, 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

private

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 evaluateSinglePoint(), SimulationElement::integrationFactor(), and SimulationElement::pointElement().

Here is the call graph for this function:

◆ evaluateSinglePoint()

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

private

Definition at line 43 of file IInterferenceFunctionStrategy.cpp.

 {
     if (!m_polarized)
         return scalarCalculation(sim_element);
     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 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());
 }