ISimulation2D Class Reference

Description

Abstract base class of simulations that generate 2D patterns.

Base class of OffspecSimulation and ScatteringSimulation.

Holds the common implementations for simulations with a 2D detector.

Definition at line 34 of file ISimulation2D.h.

Inheritance diagram for ISimulation2D:

Collaboration diagram for ISimulation2D:

Public Member Functions
	ISimulation2D (const Beam &beam, const MultiLayer &sample, const IDetector &detector)
	ISimulation2D (const MultiLayer &sample)
	~ISimulation2D () override
void	addMask (const IShape2D &shape, bool mask_value=true)
	Adds mask of given shape to the stack of detector masks. The mask value 'true' means that the channel will be excluded from the simulation. The mask which is added last has priority. More...
void	addParameterDistribution (const ParameterDistribution &par_distr)
void	addParameterDistribution (ParameterDistribution::WhichParameter whichParameter, const IDistribution1D &distribution, size_t nbr_samples, double sigma_factor=0.0, const RealLimits &limits=RealLimits())
const IBackground *	background () const
Beam &	beam ()
const Beam &	beam () const
void	checkNodeArgs () const
	Raises exception if a parameter value is invalid. More...
virtual std::string	className () const =0
	Returns the class name, to be hard-coded in each leaf class that inherits from INode. More...
virtual ICoordSystem *	createCoordSystem () const =0
IDetector &	detector ()
const IDetector &	detector () const
bool	force_polarized () const override
	Force polarized computation even in absence of sample magnetization or external fields. More...
const IDetector *	getDetector () const
const std::vector< ParameterDistribution > &	getDistributions () const
virtual size_t	intensityMapSize () const =0
	Returns the total number of the intensity values in the simulation result. More...
void	maskAll ()
	Put the mask for all detector channels (i.e. exclude whole detector from the analysis) More...
std::vector< const INode * >	nodeChildren () const override
	Returns all children. More...
std::vector< const INode * >	nodeOffspring () const
	Returns all descendants. More...
SimulationOptions &	options ()
const SimulationOptions &	options () const
virtual std::vector< ParaMeta >	parDefs () const
	Returns the parameter definitions, to be hard-coded in each leaf class. More...
const MultiLayer *	sample () const
void	setBackground (const IBackground &bg)
void	setRegionOfInterest (double xlow, double ylow, double xup, double yup)
	Sets rectangular region of interest with lower left and upper right corners defined. More...
void	setTerminalProgressMonitor ()
	Initializes a progress monitor that prints to stdout. More...
SimulationResult	simulate ()
	Run a simulation, and return the result. More...
void	subscribe (const std::function< bool(size_t)> &inform)
std::string	unitOfParameter (ParameterDistribution::WhichParameter which) const

Protected Member Functions
void	addBackgroundIntensity (size_t start_ind, size_t n_elements) override
void	addDataToCache (double weight) override
std::unique_ptr< IComputation >	createComputation (const reSample &re_sample, size_t start, size_t n_elements) override
	Generate a single threaded computation for a given range of simulation elements. More...
std::vector< std::unique_ptr< DiffuseElement > >	generateElements (const Beam &beam)
	Generate simulation elements for given beam. More...
virtual void	initCoordSystem ()
void	initDistributionHandler () override
	init callbacks for setting the parameter values More...
virtual void	initElementVector ()=0
	Initializes the vector of ISimulation elements. More...
void	moveDataFromCache () override
void	normalize (size_t start_ind, size_t n_elements) override
	Normalize the detector counts to beam intensity, to solid angle, and to exposure angle. More...
size_t	numberOfElements () const override
	Gets the number of elements this simulation needs to calculate. More...
virtual SimulationResult	pack_result ()=0
	Sets m_result. More...
void	prepareSimulation () override
	Put into a clean state for running a simulation. More...
ProgressHandler &	progress ()
virtual void	updateIntensityMap ()

Protected Attributes
std::unique_ptr< Beam >	m_beam
std::vector< double >	m_cache
std::unique_ptr< IDetector >	m_detector
DistributionHandler	m_distribution_handler
std::vector< std::unique_ptr< DiffuseElement > >	m_eles
std::vector< double >	m_P

Private Member Functions
void	runSingleSimulation (const reSample &re_sample, size_t batch_start, size_t batch_size, double weight=1.0)
	Runs a single simulation with fixed parameter values. If desired, the simulation is run in several threads. More...
virtual void	validateParametrization (const ParameterDistribution &) const
	Checks the distribution validity for simulation. More...

Private Attributes
std::shared_ptr< IBackground >	m_background
std::unique_ptr< DetectorContext >	m_detector_context
std::shared_ptr< SimulationOptions >	m_options
std::shared_ptr< ProgressHandler >	m_progress
std::shared_ptr< MultiLayer >	m_sample

Constructor & Destructor Documentation

ISimulation2D() [1/2]

ISimulation2D::ISimulation2D	(	const Beam &	beam,
		const MultiLayer &	sample,
		const IDetector &	detector
	)

Definition at line 25 of file ISimulation2D.cpp.

    : ISimulation(sample)
    , m_beam(beam.clone())
    , m_detector(detector.clone())
{
    m_detector->setDetectorNormal(m_beam->direction().zReflected());
}

References m_beam, and m_detector.

ISimulation2D() [2/2]

ISimulation2D::ISimulation2D

(

const MultiLayer &

sample

)

Definition at line 33 of file ISimulation2D.cpp.

    : ISimulation(sample)
    , m_beam(Beam::horizontalBeam().clone())
    , m_detector(new SphericalDetector())
{
}

~ISimulation2D()

ISimulation2D::~ISimulation2D ( )

overridedefault

Member Function Documentation

addBackgroundIntensity()

void ISimulation2D::addBackgroundIntensity ( size_t  start_ind, size_t  n_elements  )

overrideprotectedvirtual

Implements ISimulation.

Definition at line 124 of file ISimulation2D.cpp.

{
    if (!background())
        return;
    for (size_t i = start_ind, stop_point = start_ind + n_elements; i < stop_point; ++i) {
        DiffuseElement& element = *m_eles[i];
        element.setIntensity(background()->addBackground(element.intensity()));
    }
}

References ISimulation::background(), DiffuseElement::intensity(), m_eles, and DiffuseElement::setIntensity().

Here is the call graph for this function:

addDataToCache()

void ISimulation2D::addDataToCache ( double  weight )

overrideprotectedvirtual

Implements ISimulation.

Definition at line 134 of file ISimulation2D.cpp.

{
    if (m_eles.size() != m_cache.size())
        throw std::runtime_error("Error in ISimulation2D::addDataToCache(double): cache size"
                                 " not the same as element size");
    for (unsigned i = 0; i < m_eles.size(); i++)
        m_cache[i] += m_eles[i]->intensity() * weight;
}

References m_cache, and m_eles.

addMask()

void ISimulation2D::addMask	(	const IShape2D &	shape,
		bool	mask_value = true
	)

Adds mask of given shape to the stack of detector masks. The mask value 'true' means that the channel will be excluded from the simulation. The mask which is added last has priority.

Parameters

shape	The shape of mask (Rectangle, Polygon, Line, Ellipse)
mask_value	The value of mask

Definition at line 56 of file ISimulation2D.cpp.

{
    detector().addMask(shape, mask_value);
}

References IDetector::addMask(), and detector().

Here is the call graph for this function:

addParameterDistribution() [1/2]

void ISimulation::addParameterDistribution ( const ParameterDistribution &  par_distr )

inherited

Definition at line 231 of file ISimulation.cpp.

{
    validateParametrization(par_distr);
    m_distribution_handler.addParameterDistribution(par_distr);
}

References DistributionHandler::addParameterDistribution(), ISimulation::m_distribution_handler, and ISimulation::validateParametrization().

Here is the call graph for this function:

addParameterDistribution() [2/2]

void ISimulation::addParameterDistribution ( ParameterDistribution::WhichParameter  whichParameter, const IDistribution1D &  distribution, size_t  nbr_samples, double  sigma_factor = 0.0, const RealLimits &  limits = RealLimits()  )

inherited

Definition at line 222 of file ISimulation.cpp.

{
    ParameterDistribution par_distr(whichParameter, distribution, nbr_samples, sigma_factor,
                                    limits);
    addParameterDistribution(par_distr);
}

background()

const IBackground* ISimulation::background ( ) const

inlineinherited

Definition at line 76 of file ISimulation.h.

{ return m_background.get(); }

References ISimulation::m_background.

Referenced by DepthProbeSimulation::addBackgroundIntensity(), addBackgroundIntensity(), and SpecularSimulation::addBackgroundIntensity().

beam() [1/2]

Beam& ISimulation2D::beam ( )

inline

Definition at line 57 of file ISimulation2D.h.

{ return *m_beam; }

References m_beam.

Referenced by DepthProbeSimulation::DepthProbeSimulation(), DepthProbeSimulation::createCoordSystem(), OffspecSimulation::createCoordSystem(), ScatteringSimulation::createCoordSystem(), DepthProbeSimulation::generateElements(), generateElements(), initDistributionHandler(), DepthProbeSimulation::initElementVector(), OffspecSimulation::initElementVector(), ScatteringSimulation::initElementVector(), DepthProbeSimulation::normalize(), normalize(), DepthProbeSimulation::setBeamParameters(), and OffspecSimulation::setBeamParameters().

beam() [2/2]

const Beam& ISimulation2D::beam ( ) const

inline

Definition at line 62 of file ISimulation2D.h.

{ return *m_beam; }

References m_beam.

checkNodeArgs()

void INode::checkNodeArgs ( ) const

inherited

Raises exception if a parameter value is invalid.

Definition at line 27 of file INode.cpp.

{
    size_t nP = m_P.size();
    if (parDefs().size() != nP) {
        std::cerr << "BUG in class " << className() << std::endl;
        std::cerr << "#m_P = " << nP << std::endl;
        std::cerr << "#PDf = " << parDefs().size() << std::endl;
        for (const ParaMeta& pm : parDefs())
            std::cerr << "  PDf: " << pm.name << std::endl;
        ASSERT(0);
    }
    ASSERT(parDefs().size() == nP);
    for (size_t i = 0; i < nP; ++i) {
        const ParaMeta pm = parDefs()[i];
 
        RealLimits limits = RealLimits::limitless();
        if (pm.vMin == -INF) {
            ASSERT(pm.vMax == +INF);
            // nothing to do
        } else if (pm.vMax == +INF) {
            ASSERT(pm.vMin == 0);
            limits = RealLimits::nonnegative();
        } else {
            limits = RealLimits::limited(pm.vMin, pm.vMax);
        }
        limits.check(pm.name, m_P[i]);
    }
}

References ASSERT, RealLimits::check(), INode::className(), INF, RealLimits::limited(), RealLimits::limitless(), INode::m_P, ParaMeta::name, RealLimits::nonnegative(), INode::parDefs(), ParaMeta::vMax, and ParaMeta::vMin.

Referenced by BarGauss::BarGauss(), BarLorentz::BarLorentz(), Bipyramid4::Bipyramid4(), Box::Box(), CantellatedCube::CantellatedCube(), Cone::Cone(), ConstantBackground::ConstantBackground(), CosineRippleBox::CosineRippleBox(), CosineRippleGauss::CosineRippleGauss(), CosineRippleLorentz::CosineRippleLorentz(), Cylinder::Cylinder(), DistributionCosine::DistributionCosine(), DistributionGate::DistributionGate(), DistributionGaussian::DistributionGaussian(), DistributionLogNormal::DistributionLogNormal(), DistributionLorentz::DistributionLorentz(), DistributionTrapezoid::DistributionTrapezoid(), Dodecahedron::Dodecahedron(), EllipsoidalCylinder::EllipsoidalCylinder(), FootprintGauss::FootprintGauss(), FootprintSquare::FootprintSquare(), FuzzySphere::FuzzySphere(), GaussSphere::GaussSphere(), HemiEllipsoid::HemiEllipsoid(), HollowSphere::HollowSphere(), HorizontalCylinder::HorizontalCylinder(), Icosahedron::Icosahedron(), LongBoxGauss::LongBoxGauss(), LongBoxLorentz::LongBoxLorentz(), PlatonicOctahedron::PlatonicOctahedron(), PlatonicTetrahedron::PlatonicTetrahedron(), Prism3::Prism3(), Prism6::Prism6(), Profile1DCauchy::Profile1DCauchy(), Profile1DCosine::Profile1DCosine(), Profile1DGate::Profile1DGate(), Profile1DGauss::Profile1DGauss(), Profile1DTriangle::Profile1DTriangle(), Profile1DVoigt::Profile1DVoigt(), Profile2DCauchy::Profile2DCauchy(), Profile2DCone::Profile2DCone(), Profile2DGate::Profile2DGate(), Profile2DGauss::Profile2DGauss(), Profile2DVoigt::Profile2DVoigt(), Pyramid2::Pyramid2(), Pyramid3::Pyramid3(), Pyramid4::Pyramid4(), Pyramid6::Pyramid6(), RotationEuler::RotationEuler(), RotationX::RotationX(), RotationY::RotationY(), RotationZ::RotationZ(), SawtoothRippleBox::SawtoothRippleBox(), SawtoothRippleGauss::SawtoothRippleGauss(), SawtoothRippleLorentz::SawtoothRippleLorentz(), Sphere::Sphere(), Spheroid::Spheroid(), TruncatedCube::TruncatedCube(), TruncatedSphere::TruncatedSphere(), and TruncatedSpheroid::TruncatedSpheroid().

Here is the call graph for this function:

className()

virtual std::string INode::className ( ) const

pure virtualinherited

Returns the class name, to be hard-coded in each leaf class that inherits from INode.

Implemented in Particle, SphericalDetector, SpecularSimulation, ScatteringSimulation, OffspecSimulation, DepthProbeSimulation, PoissonBackground, ConstantBackground, GaussSphere, FuzzySphere, RotationEuler, RotationZ, RotationY, RotationX, IdentityRotation, ParticleCoreShell, ParticleComposition, MesoCrystal, Crystal, MultiLayer, Layer, Lattice3D, HexagonalLattice2D, SquareLattice2D, BasicLattice2D, LayerRoughness, LayerInterface, TruncatedSpheroid, TruncatedSphere, TruncatedCube, Spheroid, Sphere, SawtoothRippleLorentz, SawtoothRippleGauss, SawtoothRippleBox, Pyramid6, Pyramid4, Pyramid3, Pyramid2, Prism6, Prism3, PlatonicTetrahedron, PlatonicOctahedron, LongBoxLorentz, LongBoxGauss, Icosahedron, HorizontalCylinder, HollowSphere, HemiEllipsoid, EllipsoidalCylinder, Dodecahedron, Cylinder, CosineRippleLorentz, CosineRippleGauss, CosineRippleBox, Cone, CantellatedCube, Box, Bipyramid4, BarLorentz, BarGauss, Profile2DVoigt, Profile2DCone, Profile2DGate, Profile2DGauss, Profile2DCauchy, Profile1DVoigt, Profile1DCosine, Profile1DTriangle, Profile1DGate, Profile1DGauss, Profile1DCauchy, MisesGaussPeakShape, MisesFisherGaussPeakShape, LorentzFisherPeakShape, GaussFisherPeakShape, IsotropicLorentzPeakShape, IsotropicGaussPeakShape, ParticleLayout, InterferenceTwin, InterferenceRadialParaCrystal, InterferenceNone, InterferenceHardDisk, InterferenceFinite3DLattice, InterferenceFinite2DLattice, Interference3DLattice, Interference2DSuperLattice, Interference2DParaCrystal, Interference2DLattice, Interference1DLattice, DistributionTrapezoid, DistributionCosine, DistributionLogNormal, DistributionGaussian, DistributionLorentz, DistributionGate, ResolutionFunction2DGaussian, ConvolutionDetectorResolution, PolFilter, RectangularDetector, FootprintSquare, FootprintGauss, and Beam.

Referenced by INode::checkNodeArgs(), ExemplarySamples::createBasic2DParaCrystalWithFTDis(), IProfile1D::pythonConstructor(), IProfile2D::pythonConstructor(), IFormFactor::pythonConstructor(), and IFormFactor::shapeName().

createComputation()

std::unique_ptr< IComputation > ISimulation2D::createComputation ( const reSample &  re_sample, size_t  start, size_t  n_elements  )

overrideprotectedvirtual

Generate a single threaded computation for a given range of simulation elements.

Parameters

re_sample	Preprocessed version of our sample
start	Index of the first element to include into computation
n_elements	Number of elements to process

Implements ISimulation.

Definition at line 78 of file ISimulation2D.cpp.

{
    ASSERT(start < m_eles.size() && start + n_elements <= m_eles.size());
    const auto& begin = m_eles.begin() + static_cast<long>(start);
    return std::make_unique<DWBAComputation>(re_sample, options(), progress(), begin,
                                             begin + static_cast<long>(n_elements));
}

References ASSERT, m_eles, ISimulation::options(), and ISimulation::progress().

Here is the call graph for this function:

createCoordSystem()

virtual ICoordSystem* ISimulation::createCoordSystem ( ) const

pure virtualinherited

Implemented in SpecularSimulation, ScatteringSimulation, OffspecSimulation, and DepthProbeSimulation.

detector() [1/2]

IDetector& ISimulation2D::detector ( )

inline

Definition at line 58 of file ISimulation2D.h.

{ return *m_detector; }

References m_detector.

Referenced by addMask(), OffspecSimulation::checkInitialization(), OffspecSimulation::createCoordSystem(), force_polarized(), generateElements(), OffspecSimulation::intensityMapSize(), ScatteringSimulation::intensityMapSize(), maskAll(), OffspecSimulation::pack_result(), ScatteringSimulation::pack_result(), prepareSimulation(), ScatteringSimulation::prepareSimulation(), setRegionOfInterest(), OffspecSimulation::transferDetectorImage(), and OffspecSimulation::updateIntensityMap().

detector() [2/2]

const IDetector& ISimulation2D::detector ( ) const

inline

Definition at line 63 of file ISimulation2D.h.

{ return *m_detector; }

References m_detector.

force_polarized()

bool ISimulation2D::force_polarized ( ) const

overridevirtual

Force polarized computation even in absence of sample magnetization or external fields.

Implements ISimulation.

Definition at line 153 of file ISimulation2D.cpp.

{
    return detector().analyzer().analyzerDirection() != R3{};
}

References IDetector::analyzer(), PolFilter::analyzerDirection(), and detector().

Here is the call graph for this function:

generateElements()

std::vector< std::unique_ptr< DiffuseElement > > ISimulation2D::generateElements ( const Beam &  beam )

protected

Generate simulation elements for given beam.

Definition at line 87 of file ISimulation2D.cpp.

{
    const double wavelength = beam.wavelength();
    const double alpha_i = -beam.direction().alpha(); // Defined to be always positive in Beam
    const double phi_i = beam.direction().phi();
    const SpinMatrix beam_polMatrices = beam.polMatrix();
 
    const SpinMatrix analyzer_operator = detector().analyzer().matrix();
    const size_t spec_index = detector().indexOfSpecular(beam);
 
    const size_t N = m_detector_context->numberOfElements();
 
    std::vector<std::unique_ptr<DiffuseElement>> result;
    result.reserve(N);
    for (size_t element_index = 0; element_index < N; ++element_index)
        result.emplace_back(std::make_unique<DiffuseElement>(
            wavelength, alpha_i, phi_i, m_detector_context->createPixel(element_index),
            beam_polMatrices, analyzer_operator,
            m_detector_context->detectorIndex(element_index) == spec_index));
    return result;
}

References Direction::alpha(), IDetector::analyzer(), beam(), detector(), Beam::direction(), IDetector::indexOfSpecular(), m_detector_context, PolFilter::matrix(), N, Direction::phi(), Beam::polMatrix(), and Beam::wavelength().

Referenced by OffspecSimulation::initElementVector(), and ScatteringSimulation::initElementVector().

Here is the call graph for this function:

getDetector()

const IDetector* ISimulation2D::getDetector ( ) const

inline

Definition at line 64 of file ISimulation2D.h.

{ return m_detector.get(); }

References m_detector.

Referenced by ScatteringSimulation::createCoordSystem().

getDistributions()

const std::vector< ParameterDistribution > & ISimulation::getDistributions ( ) const

inherited

Definition at line 237 of file ISimulation.cpp.

{
    return m_distribution_handler.getDistributions();
}

References DistributionHandler::getDistributions(), and ISimulation::m_distribution_handler.

Here is the call graph for this function:

initCoordSystem()

virtual void ISimulation2D::initCoordSystem ( )

inlineprotectedvirtual

Definition at line 70 of file ISimulation2D.h.

{}

initDistributionHandler()

void ISimulation2D::initDistributionHandler ( )

overrideprotectedvirtual

init callbacks for setting the parameter values

Reimplemented from ISimulation.

Definition at line 159 of file ISimulation2D.cpp.

{
    for (const auto& distribution : m_distribution_handler.getDistributions()) {
        const auto* dc = const_cast<ParameterDistribution*>(&distribution);
 
        switch (dc->whichParameter()) {
        case ParameterDistribution::BeamAzimuthalAngle:
            m_distribution_handler.defineCallbackForDistribution(
                dc, [&](double d) { beam().setAzimuthalAngleGuarded(d); });
            break;
        case ParameterDistribution::BeamInclinationAngle:
            m_distribution_handler.defineCallbackForDistribution(
                dc, [&](double d) { beam().setInclinationAngleGuarded(d); });
            break;
        case ParameterDistribution::BeamWavelength:
            m_distribution_handler.defineCallbackForDistribution(
                dc, [&](double d) { beam().setWavelengthGuarded(d); });
            break;
        default:
            ASSERT(0);
        }
    }
}

References ASSERT, beam(), ParameterDistribution::BeamAzimuthalAngle, ParameterDistribution::BeamInclinationAngle, ParameterDistribution::BeamWavelength, DistributionHandler::defineCallbackForDistribution(), DistributionHandler::getDistributions(), ISimulation::m_distribution_handler, Beam::setAzimuthalAngleGuarded(), Beam::setInclinationAngleGuarded(), and Beam::setWavelengthGuarded().

Here is the call graph for this function:

initElementVector()

virtual void ISimulation::initElementVector ( )

protectedpure virtualinherited

Initializes the vector of ISimulation elements.

Implemented in SpecularSimulation, ScatteringSimulation, OffspecSimulation, and DepthProbeSimulation.

Referenced by ISimulation::runSingleSimulation().

intensityMapSize()

virtual size_t ISimulation::intensityMapSize ( ) const

pure virtualinherited

Returns the total number of the intensity values in the simulation result.

Implemented in SpecularSimulation, ScatteringSimulation, OffspecSimulation, and DepthProbeSimulation.

maskAll()

void ISimulation2D::maskAll

(

)

Put the mask for all detector channels (i.e. exclude whole detector from the analysis)

Definition at line 61 of file ISimulation2D.cpp.

{
    detector().maskAll();
}

References detector(), and IDetector::maskAll().

Here is the call graph for this function:

moveDataFromCache()

void ISimulation2D::moveDataFromCache ( )

overrideprotectedvirtual

Implements ISimulation.

Definition at line 143 of file ISimulation2D.cpp.

{
    ASSERT(!m_cache.empty());
    if (!m_cache.empty()) {
        for (unsigned i = 0; i < m_eles.size(); i++)
            m_eles[i]->setIntensity(m_cache[i]);
        m_cache.clear();
    }
}

References ASSERT, m_cache, and m_eles.

nodeChildren()

std::vector< const INode * > ISimulation2D::nodeChildren ( ) const

overridevirtual

Returns all children.

Reimplemented from ISimulation.

Definition at line 42 of file ISimulation2D.cpp.

{
    std::vector<const INode*> result = ISimulation::nodeChildren();
    result.push_back(m_beam.get());
    if (m_detector)
        result.push_back(m_detector.get());
    return result;
}

References m_beam, m_detector, and ISimulation::nodeChildren().

Here is the call graph for this function:

nodeOffspring()

std::vector< const INode * > INode::nodeOffspring ( ) const

inherited

Returns all descendants.

Definition at line 61 of file INode.cpp.

{
    std::vector<const INode*> result;
    result.push_back(this);
    for (const auto* child : nodeChildren()) {
        for (const auto* p : child->nodeOffspring())
            result.push_back(p);
    }
    return result;
}

References INode::nodeChildren().

Here is the call graph for this function:

normalize()

void ISimulation2D::normalize ( size_t  start_ind, size_t  n_elements  )

overrideprotectedvirtual

Normalize the detector counts to beam intensity, to solid angle, and to exposure angle.

Parameters

start_ind	Index of the first element to operate on
n_elements	Number of elements to process

Implements ISimulation.

Definition at line 109 of file ISimulation2D.cpp.

{
    const double beam_intensity = beam().intensity();
    for (size_t i = start_ind, stop_point = start_ind + n_elements; i < stop_point; ++i) {
        DiffuseElement& element = *m_eles[i];
        double sin_alpha_i = std::abs(std::sin(element.alphaI()));
        if (sin_alpha_i == 0.0) {
            element.setIntensity(0);
            continue;
        }
        const double solid_angle = element.solidAngle();
        element.setIntensity(element.intensity() * beam_intensity * solid_angle / sin_alpha_i);
    }
}

References DiffuseElement::alphaI(), beam(), Beam::intensity(), DiffuseElement::intensity(), m_eles, DiffuseElement::setIntensity(), and DiffuseElement::solidAngle().

Here is the call graph for this function:

numberOfElements()

size_t ISimulation2D::numberOfElements ( ) const

overrideprotectedvirtual

Gets the number of elements this simulation needs to calculate.

Implements ISimulation.

Reimplemented in OffspecSimulation.

Definition at line 71 of file ISimulation2D.cpp.

{
    if (!m_detector_context)
        throw std::runtime_error("Error in numberOfElements(): no detector context");
    return m_detector_context->numberOfElements();
}

References m_detector_context.

Referenced by OffspecSimulation::numberOfElements().

options() [1/2]

SimulationOptions & ISimulation::options ( )

inherited

Definition at line 123 of file ISimulation.cpp.

{
    ASSERT(m_options);
    return *m_options;
}

References ASSERT, and ISimulation::m_options.

options() [2/2]

const SimulationOptions & ISimulation::options ( ) const

inherited

Definition at line 117 of file ISimulation.cpp.

{
    ASSERT(m_options);
    return *m_options;
}

References ASSERT, and ISimulation::m_options.

Referenced by DepthProbeSimulation::createComputation(), createComputation(), SpecularSimulation::createComputation(), and ISimulation::simulate().

pack_result()

virtual SimulationResult ISimulation::pack_result ( )

protectedpure virtualinherited

Sets m_result.

Implemented in SpecularSimulation, ScatteringSimulation, OffspecSimulation, and DepthProbeSimulation.

Referenced by ISimulation::simulate().

parDefs()

virtual std::vector<ParaMeta> INode::parDefs ( ) const

inlinevirtualinherited

Returns the parameter definitions, to be hard-coded in each leaf class.

Reimplemented in ConstantBackground, GaussSphere, FuzzySphere, RotationEuler, RotationZ, RotationY, RotationX, Crystal, Layer, HexagonalLattice2D, SquareLattice2D, BasicLattice2D, LayerRoughness, TruncatedSpheroid, TruncatedSphere, TruncatedCube, Spheroid, Sphere, SawtoothRippleLorentz, SawtoothRippleGauss, SawtoothRippleBox, Pyramid6, Pyramid4, Pyramid3, Pyramid2, Prism6, Prism3, PlatonicTetrahedron, PlatonicOctahedron, LongBoxLorentz, LongBoxGauss, Icosahedron, HorizontalCylinder, HollowSphere, HemiEllipsoid, EllipsoidalCylinder, Dodecahedron, Cylinder, CosineRippleLorentz, CosineRippleGauss, CosineRippleBox, Cone, CantellatedCube, Box, Bipyramid4, BarLorentz, BarGauss, Profile2DVoigt, Profile2DCone, Profile2DGate, Profile2DGauss, Profile2DCauchy, Profile1DVoigt, Profile1DCosine, Profile1DTriangle, Profile1DGate, Profile1DGauss, Profile1DCauchy, MisesGaussPeakShape, MisesFisherGaussPeakShape, LorentzFisherPeakShape, GaussFisherPeakShape, IsotropicLorentzPeakShape, IsotropicGaussPeakShape, ParticleLayout, InterferenceTwin, InterferenceRadialParaCrystal, InterferenceHardDisk, Interference2DSuperLattice, Interference2DParaCrystal, Interference1DLattice, DistributionTrapezoid, DistributionCosine, DistributionLogNormal, DistributionGaussian, DistributionLorentz, DistributionGate, ResolutionFunction2DGaussian, PolFilter, FootprintSquare, and FootprintGauss.

Definition at line 51 of file INode.h.

{ return {}; }

Referenced by INode::checkNodeArgs(), and IFormFactor::pythonConstructor().

prepareSimulation()

void ISimulation2D::prepareSimulation ( )

overrideprotectedvirtual

Put into a clean state for running a simulation.

Implements ISimulation.

Reimplemented in ScatteringSimulation, and OffspecSimulation.

Definition at line 51 of file ISimulation2D.cpp.

{
    m_detector_context = detector().createContext();
}

References IDetector::createContext(), detector(), and m_detector_context.

Referenced by OffspecSimulation::prepareSimulation(), and ScatteringSimulation::prepareSimulation().

Here is the call graph for this function:

progress()

ProgressHandler & ISimulation::progress ( )

protectedinherited

Definition at line 129 of file ISimulation.cpp.

{
    ASSERT(m_progress);
    return *m_progress;
}

References ASSERT, and ISimulation::m_progress.

Referenced by DepthProbeSimulation::createComputation(), createComputation(), and SpecularSimulation::createComputation().

runSingleSimulation()

void ISimulation::runSingleSimulation ( const reSample &  re_sample, size_t  batch_start, size_t  batch_size, double  weight = 1.0  )

privateinherited

Runs a single simulation with fixed parameter values. If desired, the simulation is run in several threads.

Definition at line 245 of file ISimulation.cpp.

{
    initElementVector();
 
    const size_t n_threads = m_options->getNumberOfThreads();
    ASSERT(n_threads > 0);
 
    std::vector<std::unique_ptr<IComputation>> computations;
 
    for (size_t i_thread = 0; i_thread < n_threads; ++i_thread) {
        const size_t thread_start = batch_start + startIndex(n_threads, i_thread, batch_size);
        const size_t thread_size = batchSize(n_threads, i_thread, batch_size);
        if (thread_size == 0)
            break;
        computations.emplace_back(createComputation(re_sample, thread_start, thread_size));
    }
    runComputations(computations);
 
    normalize(batch_start, batch_size);
    addBackgroundIntensity(batch_start, batch_size);
    addDataToCache(weight);
}

References ISimulation::addBackgroundIntensity(), ISimulation::addDataToCache(), ASSERT, ISimulation::createComputation(), ISimulation::initElementVector(), ISimulation::m_options, and ISimulation::normalize().

Referenced by ISimulation::simulate().

Here is the call graph for this function:

sample()

const MultiLayer * ISimulation::sample ( ) const

inherited

Definition at line 191 of file ISimulation.cpp.

{
    return m_sample.get();
}

References ISimulation::m_sample.

Referenced by ISimulation::simulate(), and DepthProbeSimulation::validityCheck().

setBackground()

void ISimulation::setBackground ( const IBackground &  bg )

inherited

Definition at line 196 of file ISimulation.cpp.

{
    m_background.reset(bg.clone());
}

References IBackground::clone(), and ISimulation::m_background.

Here is the call graph for this function:

setRegionOfInterest()

void ISimulation2D::setRegionOfInterest	(	double	xlow,
		double	ylow,
		double	xup,
		double	yup
	)

Sets rectangular region of interest with lower left and upper right corners defined.

Definition at line 66 of file ISimulation2D.cpp.

{
    detector().setRegionOfInterest(xlow, ylow, xup, yup);
}

References detector(), and IDetector::setRegionOfInterest().

Here is the call graph for this function:

setTerminalProgressMonitor()

void ISimulation::setTerminalProgressMonitor ( )

inherited

Initializes a progress monitor that prints to stdout.

Definition at line 142 of file ISimulation.cpp.

{
    m_progress->subscribe([](size_t percentage_done) -> bool {
        if (percentage_done < 100)
            std::cout << std::setprecision(2) << "\r... " << percentage_done << "%" << std::flush;
        else // wipe out
            std::cout << "\r... 100%\n";
        return true;
    });
}

References ISimulation::m_progress.

simulate()

SimulationResult ISimulation::simulate ( )

inherited

Run a simulation, and return the result.

Runs simulation with possible averaging over parameter distributions; returns result.

Definition at line 154 of file ISimulation.cpp.

{
    if (!SampleUtils::Multilayer::ContainsCompatibleMaterials(*m_sample))
        throw std::runtime_error("Sample contains incompatible material definitions");
    gsl_set_error_handler_off();
 
    prepareSimulation();
 
    const auto re_sample = reSample::make(*sample(), options(), force_polarized());
 
    const size_t total_size = numberOfElements();
    size_t param_combinations = m_distribution_handler.getTotalNumberOfSamples();
 
    m_progress->reset();
    m_progress->setExpectedNTicks(param_combinations * total_size);
 
    // restrict calculation to current batch
    const size_t n_batches = m_options->getNumberOfBatches();
    const size_t current_batch = m_options->getCurrentBatch();
 
    const size_t batch_start = startIndex(n_batches, current_batch, total_size);
    const size_t batch_size = batchSize(n_batches, current_batch, total_size);
    ASSERT(batch_size);
 
    if (param_combinations == 1)
        runSingleSimulation(re_sample, batch_start, batch_size, 1.);
    else {
        initDistributionHandler();
        for (size_t index = 0; index < param_combinations; ++index) {
            double weight = m_distribution_handler.setParameterValues(index);
            runSingleSimulation(re_sample, batch_start, batch_size, weight);
        }
    }
    moveDataFromCache();
    return pack_result();
}

References ASSERT, SampleUtils::Multilayer::ContainsCompatibleMaterials(), ISimulation::force_polarized(), DistributionHandler::getTotalNumberOfSamples(), ISimulation::initDistributionHandler(), ISimulation::m_distribution_handler, ISimulation::m_options, ISimulation::m_progress, ISimulation::m_sample, reSample::make(), ISimulation::moveDataFromCache(), ISimulation::numberOfElements(), ISimulation::options(), ISimulation::pack_result(), ISimulation::prepareSimulation(), ISimulation::runSingleSimulation(), ISimulation::sample(), and DistributionHandler::setParameterValues().

Here is the call graph for this function:

subscribe()

void ISimulation::subscribe ( const std::function< bool(size_t)> &  inform )

inherited

Definition at line 135 of file ISimulation.cpp.

{
    ASSERT(m_progress);
    m_progress->subscribe(inform);
}

References ASSERT, and ISimulation::m_progress.

unitOfParameter()

std::string ISimulation::unitOfParameter ( ParameterDistribution::WhichParameter  which ) const

inherited

Definition at line 209 of file ISimulation.cpp.

{
    switch (which) {
    case ParameterDistribution::BeamWavelength:
        return "nm";
    case ParameterDistribution::BeamAzimuthalAngle:
    case ParameterDistribution::BeamInclinationAngle:
        return "rad";
    default:
        throw std::runtime_error("ISimulation::unitOfParameter(): missing implementation");
    }
}

References ParameterDistribution::BeamAzimuthalAngle, ParameterDistribution::BeamInclinationAngle, and ParameterDistribution::BeamWavelength.

updateIntensityMap()

virtual void ISimulation::updateIntensityMap ( )

inlineprotectedvirtualinherited

Reimplemented in OffspecSimulation.

Definition at line 97 of file ISimulation.h.

{}

validateParametrization()

virtual void ISimulation::validateParametrization ( const ParameterDistribution &  ) const

inlineprivatevirtualinherited

Checks the distribution validity for simulation.

Reimplemented in SpecularSimulation, OffspecSimulation, and DepthProbeSimulation.

Definition at line 120 of file ISimulation.h.

{}

Referenced by ISimulation::addParameterDistribution().

Member Data Documentation

m_background

std::shared_ptr<IBackground> ISimulation::m_background

privateinherited

Definition at line 137 of file ISimulation.h.

Referenced by ISimulation::background(), and ISimulation::setBackground().

m_beam

std::unique_ptr<Beam> ISimulation2D::m_beam

protected

Definition at line 98 of file ISimulation2D.h.

Referenced by ISimulation2D(), beam(), and nodeChildren().

m_cache

std::vector<double> ISimulation2D::m_cache

protected

Definition at line 101 of file ISimulation2D.h.

Referenced by addDataToCache(), OffspecSimulation::initElementVector(), ScatteringSimulation::initElementVector(), and moveDataFromCache().

m_detector

std::unique_ptr<IDetector> ISimulation2D::m_detector

protected

Definition at line 99 of file ISimulation2D.h.

Referenced by ISimulation2D(), detector(), getDetector(), and nodeChildren().

m_detector_context

std::unique_ptr<DetectorContext> ISimulation2D::m_detector_context

private

Definition at line 104 of file ISimulation2D.h.

Referenced by generateElements(), numberOfElements(), and prepareSimulation().

m_distribution_handler

DistributionHandler ISimulation::m_distribution_handler

protectedinherited

Definition at line 104 of file ISimulation.h.

Referenced by ISimulation::addParameterDistribution(), ISimulation::getDistributions(), initDistributionHandler(), and ISimulation::simulate().

m_eles

std::vector<std::unique_ptr<DiffuseElement> > ISimulation2D::m_eles

protected

Definition at line 100 of file ISimulation2D.h.

Referenced by addBackgroundIntensity(), addDataToCache(), createComputation(), OffspecSimulation::initElementVector(), ScatteringSimulation::initElementVector(), moveDataFromCache(), normalize(), OffspecSimulation::pack_result(), ScatteringSimulation::pack_result(), and OffspecSimulation::transferDetectorImage().

m_options

std::shared_ptr<SimulationOptions> ISimulation::m_options

privateinherited

Definition at line 135 of file ISimulation.h.

Referenced by ISimulation::options(), ISimulation::runSingleSimulation(), and ISimulation::simulate().

m_P

std::vector<double> INode::m_P

protectedinherited

Definition at line 63 of file INode.h.

Referenced by IFootprintFactor::IFootprintFactor(), INode::checkNodeArgs(), IProfile1D::pythonConstructor(), IProfile2D::pythonConstructor(), IFormFactor::pythonConstructor(), Profile1DVoigt::pythonConstructor(), and Profile2DVoigt::pythonConstructor().

m_progress

std::shared_ptr<ProgressHandler> ISimulation::m_progress

privateinherited

Definition at line 136 of file ISimulation.h.

Referenced by ISimulation::progress(), ISimulation::setTerminalProgressMonitor(), ISimulation::simulate(), and ISimulation::subscribe().

m_sample

std::shared_ptr<MultiLayer> ISimulation::m_sample

privateinherited

Definition at line 133 of file ISimulation.h.

Referenced by ISimulation::nodeChildren(), ISimulation::sample(), and ISimulation::simulate().

---

The documentation for this class was generated from the following files:

• /home/build/builds/o5h8MZZm/0/mlz/bornagain/Sim/Simulation/ISimulation2D.h
• /home/build/builds/o5h8MZZm/0/mlz/bornagain/Sim/Simulation/ISimulation2D.cpp