AngularSpecScan Class Reference

Inheritance diagram for AngularSpecScan:

Collaboration diagram for AngularSpecScan:

Public Member Functions
	AngularSpecScan (double wl, std::vector< double > inc_angle)
	AngularSpecScan (double wl, const IAxis &inc_angle)
	AngularSpecScan (double wl, int nbins, double alpha_i_min, double alpha_i_max)
	~AngularSpecScan () override
AngularSpecScan *	clone () const override
std::vector< SpecularSimulationElement >	generateSimulationElements () const override
virtual const IAxis *	coordinateAxis () const override
virtual const IFootprintFactor *	footprintFactor () const override
std::vector< double >	footprint (size_t i, size_t n_elements) const override
size_t	numberOfSimulationElements () const override
std::vector< double >	createIntensities (const std::vector< SpecularSimulationElement > &sim_elements) const override
std::string	print () const override
double	wavelength () const
const ScanResolution *	wavelengthResolution () const
const ScanResolution *	angleResolution () const
void	setFootprintFactor (const IFootprintFactor *f_factor)
void	setWavelengthResolution (const ScanResolution &resolution)
void	setRelativeWavelengthResolution (const RangedDistribution &distr, double rel_dev)
void	setRelativeWavelengthResolution (const RangedDistribution &distr, const std::vector< double > &rel_dev)
void	setAbsoluteWavelengthResolution (const RangedDistribution &distr, double std_dev)
void	setAbsoluteWavelengthResolution (const RangedDistribution &distr, const std::vector< double > &std_dev)
void	setAngleResolution (const ScanResolution &resolution)
void	setRelativeAngularResolution (const RangedDistribution &distr, double rel_dev)
void	setRelativeAngularResolution (const RangedDistribution &distr, const std::vector< double > &rel_dev)
void	setAbsoluteAngularResolution (const RangedDistribution &distr, double std_dev)
void	setAbsoluteAngularResolution (const RangedDistribution &distr, const std::vector< double > &std_dev)
virtual void	transferToCPP ()

Private Types
using	DistrOutput = std::vector< std::vector< ParameterSample > >

Private Member Functions
void	checkInitialization ()
DistrOutput	applyWlResolution () const
DistrOutput	applyIncResolution () const

Private Attributes
double	m_wl
std::unique_ptr< IAxis >	m_inc_angle
std::unique_ptr< IFootprintFactor >	m_footprint
std::unique_ptr< ScanResolution >	m_wl_resolution
DistrOutput	m_wl_res_cache
std::unique_ptr< ScanResolution >	m_inc_resolution
DistrOutput	m_inc_res_cache

Detailed Description

Scan type with inclination angles as coordinate values and a unique wavelength.

Features footprint correction.

Definition at line 27 of file AngularSpecScan.h.

Member Typedef Documentation

DistrOutput

using AngularSpecScan::DistrOutput = std::vector<std::vector<ParameterSample> >

private

Definition at line 112 of file AngularSpecScan.h.

Constructor & Destructor Documentation

AngularSpecScan() [1/3]

AngularSpecScan::AngularSpecScan	(	double	wl,
		std::vector< double >	inc_angle
	)

Definition at line 46 of file AngularSpecScan.cpp.

    : m_wl(wl),
      m_inc_angle(std::make_unique<PointwiseAxis>("inc_angles", std::move(inc_angle))),
      m_wl_resolution(ScanResolution::scanEmptyResolution()),
      m_inc_resolution(ScanResolution::scanEmptyResolution())
{
    checkInitialization();
}

References checkInitialization().

Referenced by clone().

Here is the call graph for this function:

AngularSpecScan() [2/3]

AngularSpecScan::AngularSpecScan	(	double	wl,
		const IAxis &	inc_angle
	)

Definition at line 55 of file AngularSpecScan.cpp.

    : m_wl(wl), m_inc_angle(inc_angle.clone()),
      m_wl_resolution(ScanResolution::scanEmptyResolution()),
      m_inc_resolution(ScanResolution::scanEmptyResolution())
{
    checkInitialization();
}

References checkInitialization().

Here is the call graph for this function:

AngularSpecScan() [3/3]

AngularSpecScan::AngularSpecScan	(	double	wl,
		int	nbins,
		double	alpha_i_min,
		double	alpha_i_max
	)

Sets angle-defined specular scan.

The first parameter is always a wavelength in nm. Second parameter is either a numpy array of incident angles in radians or an IAxis object with angle values. Alternatively an axis can be defined in-place, then the second passed parameter is the number of bins, third - minimum on-axis angle value, fourth - maximum on-axis angle value.

Definition at line 63 of file AngularSpecScan.cpp.

    : m_wl(wl),
      m_inc_angle(std::make_unique<FixedBinAxis>("inc_angles", nbins, alpha_i_min, alpha_i_max)),
      m_wl_resolution(ScanResolution::scanEmptyResolution()),
      m_inc_resolution(ScanResolution::scanEmptyResolution())
{
    checkInitialization();
}

References checkInitialization().

Here is the call graph for this function:

~AngularSpecScan()

AngularSpecScan::~AngularSpecScan ( )

overridedefault

Member Function Documentation

clone()

AngularSpecScan * AngularSpecScan::clone ( ) const

overridevirtual

Implements ISpecularScan.

Definition at line 72 of file AngularSpecScan.cpp.

{
    auto* result = new AngularSpecScan(m_wl, *m_inc_angle);
    result->setFootprintFactor(m_footprint.get());
    result->setWavelengthResolution(*m_wl_resolution);
    result->setAngleResolution(*m_inc_resolution);
    return result;
}

References AngularSpecScan(), m_footprint, m_inc_angle, m_inc_resolution, m_wl, and m_wl_resolution.

Here is the call graph for this function:

generateSimulationElements()

std::vector< SpecularSimulationElement > AngularSpecScan::generateSimulationElements ( ) const

overridevirtual

Generates simulation elements for specular simulations.

Implements ISpecularScan.

Definition at line 83 of file AngularSpecScan.cpp.

{
    const auto wls = extractValues(applyWlResolution(),
                                   [](const ParameterSample& sample) { return sample.value; });
    const auto incs = extractValues(applyIncResolution(),
                                    [](const ParameterSample& sample) { return sample.value; });
 
    std::vector<SpecularSimulationElement> result;
    result.reserve(numberOfSimulationElements());
    for (size_t i = 0; i < m_inc_angle->size(); ++i) {
        for (size_t k = 0, size_incs = incs[i].size(); k < size_incs; ++k) {
            const double inc = incs[i][k];
            for (size_t j = 0, size_wls = wls[i].size(); j < size_wls; ++j) {
                const double wl = wls[i][j];
                result.emplace_back(
                    SpecularSimulationElement(wl, -inc, wl >= 0 && inc >= 0 && inc <= M_PI_2));
            }
        }
    }
    return result;
}

References applyIncResolution(), applyWlResolution(), anonymous_namespace{AngularSpecScan.cpp}::extractValues(), m_inc_angle, M_PI_2, numberOfSimulationElements(), and ParameterSample::value.

Here is the call graph for this function:

coordinateAxis()

virtual const IAxis* AngularSpecScan::coordinateAxis ( ) const

inlineoverridevirtual

Returns coordinate axis assigned to the data holder.

Implements ISpecularScan.

Definition at line 46 of file AngularSpecScan.h.

{ return m_inc_angle.get(); }

References m_inc_angle.

Referenced by anonymous_namespace{SpecularSimulation.cpp}::mangledScan(), and print().

footprintFactor()

virtual const IFootprintFactor* AngularSpecScan::footprintFactor ( ) const

inlineoverridevirtual

Returns IFootprintFactor object pointer.

Implements ISpecularScan.

Definition at line 49 of file AngularSpecScan.h.

{ return m_footprint.get(); }

References m_footprint.

Referenced by anonymous_namespace{SpecularSimulation.cpp}::mangledScan().

footprint()

std::vector< double > AngularSpecScan::footprint ( size_t  i, size_t  n_elements  ) const

overridevirtual

Returns footprint correction factor for a range of simulation elements of size n_elements and starting from element with index i.

Implements ISpecularScan.

Definition at line 186 of file AngularSpecScan.cpp.

{
    if (start + n_elements > numberOfSimulationElements())
        throw std::runtime_error("Error in AngularSpecScan::footprint: given index exceeds the "
                                 "number of simulation elements");
 
    std::vector<double> result(n_elements, 1.0);
    if (!m_footprint)
        return result;
 
    const size_t n_wl_samples = m_wl_resolution->nSamples();
    const size_t n_inc_samples = m_inc_resolution->nSamples();
 
    const auto sample_values = extractValues(
        applyIncResolution(), [](const ParameterSample& sample) { return sample.value; });
 
    const size_t pos_out = start / (n_wl_samples * n_inc_samples);
    size_t pos_inc = (start - pos_out * n_wl_samples * n_inc_samples) / n_wl_samples;
    size_t pos_wl = (start - pos_inc * n_wl_samples);
    int left = static_cast<int>(n_elements);
    size_t pos_res = 0;
    for (size_t i = pos_out; left > 0; ++i)
        for (size_t k = pos_inc; k < n_inc_samples && left > 0; ++k) {
            pos_inc = 0;
            const double angle = sample_values[i][k];
            const double footprint =
                (angle >= 0 && angle <= M_PI_2) ? m_footprint->calculate(angle) : 1.0;
            for (size_t j = pos_wl; j < n_wl_samples && left > 0; ++j) {
                pos_wl = 0;
                result[pos_res] = footprint;
                ++pos_res;
                --left;
            }
        }
    return result;
}

References applyIncResolution(), anonymous_namespace{AngularSpecScan.cpp}::extractValues(), m_footprint, m_inc_resolution, M_PI_2, m_wl_resolution, numberOfSimulationElements(), and ParameterSample::value.

Here is the call graph for this function:

numberOfSimulationElements()

size_t AngularSpecScan::numberOfSimulationElements ( ) const

overridevirtual

Returns the number of simulation elements.

Implements ISpecularScan.

Definition at line 223 of file AngularSpecScan.cpp.

{
    return m_inc_angle->size() * m_wl_resolution->nSamples() * m_inc_resolution->nSamples();
}

References m_inc_angle, m_inc_resolution, and m_wl_resolution.

Referenced by footprint(), and generateSimulationElements().

createIntensities()

std::vector< double > AngularSpecScan::createIntensities ( const std::vector< SpecularSimulationElement > &  sim_elements ) const

overridevirtual

Returns intensity vector corresponding to convolution of given simulation elements.

Implements ISpecularScan.

Definition at line 229 of file AngularSpecScan.cpp.

{
    const size_t axis_size = m_inc_angle->size();
    std::vector<double> result(axis_size, 0.0);
 
    const auto wl_weights = extractValues(
        applyWlResolution(), [](const ParameterSample& sample) { return sample.weight; });
    const auto inc_weights = extractValues(
        applyIncResolution(), [](const ParameterSample& sample) { return sample.weight; });
 
    size_t elem_pos = 0;
    for (size_t i = 0; i < axis_size; ++i) {
        double& current = result[i];
        for (size_t k = 0, size_incs = inc_weights[i].size(); k < size_incs; ++k) {
            const double inc_weight = inc_weights[i][k];
            for (size_t j = 0, size_wls = wl_weights[i].size(); j < size_wls; ++j) {
                current += sim_elements[elem_pos].getIntensity() * inc_weight * wl_weights[i][j];
                ++elem_pos;
            }
        }
    }
    return result;
}

References applyIncResolution(), applyWlResolution(), anonymous_namespace{AngularSpecScan.cpp}::extractValues(), m_inc_angle, and ParameterSample::weight.

Here is the call graph for this function:

print()

std::string AngularSpecScan::print ( ) const

overridevirtual

Print scan definition in python format.

Implements ISpecularScan.

Definition at line 253 of file AngularSpecScan.cpp.

{
    std::stringstream result;
    result << "\n" << pyfmt::indent() << "# Defining specular scan:\n";
    const std::string axis_def = pyfmt::indent() + "axis = ";
    result << axis_def << coordinateAxis()->pyString("rad", axis_def.size()) << "\n";
 
    result << pyfmt::indent() << "scan = ";
    result << "ba.AngularSpecScan(" << pyfmt::printDouble(m_wl) << ", axis)\n";
 
    if (m_footprint) {
        result << *m_footprint << "\n";
        result << pyfmt::indent() << "scan.setFootprintFactor(footprint)\n";
    }
    if (!m_inc_resolution->empty()) {
        result << "\n" << pyfmt::indent() << "# Defining angular resolution\n";
        result << *m_inc_resolution << "\n";
        result << pyfmt::indent() << "scan.setAngleResolution(resolution)\n";
    }
    if (!m_wl_resolution->empty()) {
        result << "\n" << pyfmt::indent() << "# Defining wavelength resolution\n";
        result << *m_wl_resolution << "\n";
        result << pyfmt::indent() << "scan.setWavelengthResolution(resolution)\n";
    }
    return result.str();
}

References coordinateAxis(), pyfmt::indent(), m_footprint, m_inc_resolution, m_wl, m_wl_resolution, pyfmt::printDouble(), and IAxis::pyString().

Here is the call graph for this function:

wavelength()

double AngularSpecScan::wavelength ( ) const

inline

Definition at line 65 of file AngularSpecScan.h.

{ return m_wl; }

References m_wl.

wavelengthResolution()

const ScanResolution* AngularSpecScan::wavelengthResolution ( ) const

inline

Definition at line 68 of file AngularSpecScan.h.

{ return m_wl_resolution.get(); }

References m_wl_resolution.

Referenced by anonymous_namespace{SpecularSimulation.cpp}::mangledScan().

angleResolution()

const ScanResolution* AngularSpecScan::angleResolution ( ) const

inline

Definition at line 69 of file AngularSpecScan.h.

{ return m_inc_resolution.get(); }

References m_inc_resolution.

Referenced by anonymous_namespace{SpecularSimulation.cpp}::mangledScan().

setFootprintFactor()

void AngularSpecScan::setFootprintFactor

(

const IFootprintFactor *

f_factor

)

Sets footprint correction factor.

Definition at line 105 of file AngularSpecScan.cpp.

{
    m_footprint.reset(f_factor ? f_factor->clone() : nullptr);
}

References IFootprintFactor::clone(), and m_footprint.

Referenced by StandardSimulations::SpecularWithGaussianBeam(), and StandardSimulations::SpecularWithSquareBeam().

Here is the call graph for this function:

setWavelengthResolution()

void AngularSpecScan::setWavelengthResolution

(

const ScanResolution &

resolution

)

Sets wavelength resolution values via ScanResolution object.

Definition at line 110 of file AngularSpecScan.cpp.

{
    m_wl_resolution.reset(resolution.clone());
    m_wl_res_cache.clear();
    m_wl_res_cache.shrink_to_fit();
}

References ScanResolution::clone(), m_wl_res_cache, and m_wl_resolution.

Referenced by setAbsoluteWavelengthResolution(), setRelativeWavelengthResolution(), and StandardSimulations::SpecularDivergentBeam().

Here is the call graph for this function:

setRelativeWavelengthResolution() [1/2]

void AngularSpecScan::setRelativeWavelengthResolution	(	const RangedDistribution &	distr,
		double	rel_dev
	)

Definition at line 117 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanRelativeResolution(distr, rel_dev));
    setWavelengthResolution(*resolution);
}

References ScanResolution::scanRelativeResolution(), and setWavelengthResolution().

Here is the call graph for this function:

setRelativeWavelengthResolution() [2/2]

void AngularSpecScan::setRelativeWavelengthResolution	(	const RangedDistribution &	distr,
		const std::vector< double > &	rel_dev
	)

Sets wavelength resolution values via RangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value).

rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.

Definition at line 125 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanRelativeResolution(distr, rel_dev));
    setWavelengthResolution(*resolution);
}

References ScanResolution::scanRelativeResolution(), and setWavelengthResolution().

Here is the call graph for this function:

setAbsoluteWavelengthResolution() [1/2]

void AngularSpecScan::setAbsoluteWavelengthResolution	(	const RangedDistribution &	distr,
		double	std_dev
	)

Definition at line 133 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanAbsoluteResolution(distr, std_dev));
    setWavelengthResolution(*resolution);
}

References ScanResolution::scanAbsoluteResolution(), and setWavelengthResolution().

Here is the call graph for this function:

setAbsoluteWavelengthResolution() [2/2]

void AngularSpecScan::setAbsoluteWavelengthResolution	(	const RangedDistribution &	distr,
		const std::vector< double > &	std_dev
	)

Sets wavelength resolution values via RangedDistribution and values of standard deviations.

std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.

Definition at line 141 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanAbsoluteResolution(distr, std_dev));
    setWavelengthResolution(*resolution);
}

References ScanResolution::scanAbsoluteResolution(), and setWavelengthResolution().

Here is the call graph for this function:

setAngleResolution()

void AngularSpecScan::setAngleResolution

(

const ScanResolution &

resolution

)

Sets angle resolution values via ScanResolution object.

Definition at line 149 of file AngularSpecScan.cpp.

{
    m_inc_resolution.reset(resolution.clone());
    m_inc_res_cache.clear();
    m_inc_res_cache.shrink_to_fit();
}

References ScanResolution::clone(), m_inc_res_cache, and m_inc_resolution.

Referenced by setAbsoluteAngularResolution(), setRelativeAngularResolution(), and StandardSimulations::SpecularDivergentBeam().

Here is the call graph for this function:

setRelativeAngularResolution() [1/2]

void AngularSpecScan::setRelativeAngularResolution	(	const RangedDistribution &	distr,
		double	rel_dev
	)

Definition at line 156 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanRelativeResolution(distr, rel_dev));
    setAngleResolution(*resolution);
}

References ScanResolution::scanRelativeResolution(), and setAngleResolution().

Here is the call graph for this function:

setRelativeAngularResolution() [2/2]

void AngularSpecScan::setRelativeAngularResolution	(	const RangedDistribution &	distr,
		const std::vector< double > &	rel_dev
	)

Sets angular resolution values via RangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value).

rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.

Definition at line 163 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanRelativeResolution(distr, rel_dev));
    setAngleResolution(*resolution);
}

References ScanResolution::scanRelativeResolution(), and setAngleResolution().

Here is the call graph for this function:

setAbsoluteAngularResolution() [1/2]

void AngularSpecScan::setAbsoluteAngularResolution	(	const RangedDistribution &	distr,
		double	std_dev
	)

Definition at line 171 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanAbsoluteResolution(distr, std_dev));
    setAngleResolution(*resolution);
}

References ScanResolution::scanAbsoluteResolution(), and setAngleResolution().

Here is the call graph for this function:

setAbsoluteAngularResolution() [2/2]

void AngularSpecScan::setAbsoluteAngularResolution	(	const RangedDistribution &	distr,
		const std::vector< double > &	std_dev
	)

Sets angular resolution values via RangedDistribution and values of standard deviations.

std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.

Definition at line 178 of file AngularSpecScan.cpp.

{
    std::unique_ptr<ScanResolution> resolution(
        ScanResolution::scanAbsoluteResolution(distr, std_dev));
    setAngleResolution(*resolution);
}

References ScanResolution::scanAbsoluteResolution(), and setAngleResolution().

Here is the call graph for this function:

checkInitialization()

void AngularSpecScan::checkInitialization ( )

private

Definition at line 280 of file AngularSpecScan.cpp.

{
    if (m_wl <= 0.0)
        throw std::runtime_error(
            "Error in AngularSpecScan::checkInitialization: wavelength shell be positive");
 
    const std::vector<double> axis_values = m_inc_angle->getBinCenters();
    if (!std::is_sorted(axis_values.begin(), axis_values.end()))
        throw std::runtime_error("Error in AngularSpecScan::checkInitialization: q-vector values "
                                 "shall be sorted in ascending order.");
 
    // TODO: check for inclination angle limits after switching to pointwise resolution.
}

References m_inc_angle, and m_wl.

Referenced by AngularSpecScan().

applyWlResolution()

AngularSpecScan::DistrOutput AngularSpecScan::applyWlResolution ( ) const

private

Definition at line 294 of file AngularSpecScan.cpp.

{
    if (m_wl_res_cache.empty())
        m_wl_res_cache = m_wl_resolution->generateSamples(m_wl, m_inc_angle->size());
    return m_wl_res_cache;
}

References m_inc_angle, m_wl, m_wl_res_cache, and m_wl_resolution.

Referenced by createIntensities(), and generateSimulationElements().

applyIncResolution()

AngularSpecScan::DistrOutput AngularSpecScan::applyIncResolution ( ) const

private

Definition at line 301 of file AngularSpecScan.cpp.

{
    if (m_inc_res_cache.empty())
        m_inc_res_cache = m_inc_resolution->generateSamples(m_inc_angle->getBinCenters());
    return m_inc_res_cache;
}

References m_inc_angle, m_inc_res_cache, and m_inc_resolution.

Referenced by createIntensities(), footprint(), and generateSimulationElements().

transferToCPP()

virtual void ICloneable::transferToCPP ( )

inlinevirtualinherited

Used for Python overriding of clone (see swig/tweaks.py)

Definition at line 34 of file ICloneable.h.

Member Data Documentation

m_wl

double AngularSpecScan::m_wl

private

Definition at line 118 of file AngularSpecScan.h.

Referenced by applyWlResolution(), checkInitialization(), clone(), print(), and wavelength().

m_inc_angle

std::unique_ptr<IAxis> AngularSpecScan::m_inc_angle

private

Definition at line 119 of file AngularSpecScan.h.

Referenced by applyIncResolution(), applyWlResolution(), checkInitialization(), clone(), coordinateAxis(), createIntensities(), generateSimulationElements(), and numberOfSimulationElements().

m_footprint

std::unique_ptr<IFootprintFactor> AngularSpecScan::m_footprint

private

Definition at line 120 of file AngularSpecScan.h.

Referenced by clone(), footprint(), footprintFactor(), print(), and setFootprintFactor().

m_wl_resolution

std::unique_ptr<ScanResolution> AngularSpecScan::m_wl_resolution

private

Definition at line 122 of file AngularSpecScan.h.

Referenced by applyWlResolution(), clone(), footprint(), numberOfSimulationElements(), print(), setWavelengthResolution(), and wavelengthResolution().

m_wl_res_cache

DistrOutput AngularSpecScan::m_wl_res_cache

mutableprivate

Definition at line 123 of file AngularSpecScan.h.

Referenced by applyWlResolution(), and setWavelengthResolution().

m_inc_resolution

std::unique_ptr<ScanResolution> AngularSpecScan::m_inc_resolution

private

Definition at line 125 of file AngularSpecScan.h.

Referenced by angleResolution(), applyIncResolution(), clone(), footprint(), numberOfSimulationElements(), print(), and setAngleResolution().

m_inc_res_cache

DistrOutput AngularSpecScan::m_inc_res_cache

mutableprivate

Definition at line 126 of file AngularSpecScan.h.

Referenced by applyIncResolution(), and setAngleResolution().

---

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

• /home/www/ba/Core/Scan/AngularSpecScan.h
• /home/www/ba/Core/Scan/AngularSpecScan.cpp