AlphaScan Class Reference

Description

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

Definition at line 27 of file AlphaScan.h.

Inheritance diagram for AlphaScan:

Collaboration diagram for AlphaScan:

Public Member Functions
	AlphaScan (double wl, const IAxis &inc_angle)
	AlphaScan (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. More...
	AlphaScan (double wl, std::vector< double > inc_angle)
	~AlphaScan () override
const PolFilter *	analyzer () const
const ScanResolution *	angleResolution () const
AlphaScan *	clone () const override
const IAxis *	coordinateAxis () const override
	Returns coordinate axis assigned to the data holder. More...
CoordSystem1D *	createCoordSystem () const override
std::vector< double >	createIntensities (const std::vector< SpecularElement > &eles) const override
	Returns intensity vector corresponding to convolution of given simulation elements. More...
std::vector< double >	footprint (size_t start, size_t n_elements) const override
	Returns footprint correction factor for a range of simulation elements of size n_elements and starting from element with index i. More...
const IFootprintFactor *	footprintFactor () const override
	Returns IFootprintFactor object pointer. More...
std::vector< SpecularElement >	generateElements () const override
	Generates simulation elements for specular simulations. More...
size_t	numberOfElements () const override
	Returns the number of simulation elements. More...
bool	polarized () const
PolMatrices	polMatrices () const
void	setAbsoluteAngularResolution (const IRangedDistribution &distr, const std::vector< double > &std_dev)
	Sets angular resolution values via IRangedDistribution 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. More...
void	setAbsoluteAngularResolution (const IRangedDistribution &distr, double std_dev)
void	setAbsoluteWavelengthResolution (const IRangedDistribution &distr, const std::vector< double > &std_dev)
	Sets wavelength resolution values via IRangedDistribution 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. More...
void	setAbsoluteWavelengthResolution (const IRangedDistribution &distr, double std_dev)
void	setAnalyzer (R3 direction, double efficiency, double total_transmission)
	Sets the polarization analyzer characteristics of the detector. More...
void	setAngleResolution (const ScanResolution &resolution)
	Sets angle resolution values via ScanResolution object. More...
void	setFootprintFactor (const IFootprintFactor *f_factor)
	Sets footprint correction factor. More...
void	setPolarization (R3 bloch_vector)
	Sets the polarization density matrix according to the given Bloch vector. More...
void	setRelativeAngularResolution (const IRangedDistribution &distr, const std::vector< double > &rel_dev)
	Sets angular resolution values via IRangedDistribution 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. More...
void	setRelativeAngularResolution (const IRangedDistribution &distr, double rel_dev)
void	setRelativeWavelengthResolution (const IRangedDistribution &distr, const std::vector< double > &rel_dev)
	Sets wavelength resolution values via IRangedDistribution 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. More...
void	setRelativeWavelengthResolution (const IRangedDistribution &distr, double rel_dev)
void	setWavelengthResolution (const ScanResolution &resolution)
	Sets wavelength resolution values via ScanResolution object. More...
virtual void	transferToCPP ()
	Used for Python overriding of clone (see swig/tweaks.py) More...
double	wavelength () const override
const ScanResolution *	wavelengthResolution () const

Protected Attributes
std::unique_ptr< R3 >	m_beamPolarization
	Bloch vector encoding the beam's polarization. More...
std::unique_ptr< PolFilter >	m_polAnalyzer

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

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

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

Member Typedef Documentation

DistrOutput

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

private

Definition at line 109 of file AlphaScan.h.

Constructor & Destructor Documentation

AlphaScan() [1/3]

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

Definition at line 48 of file AlphaScan.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:

AlphaScan() [2/3]

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

Definition at line 57 of file AlphaScan.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:

AlphaScan() [3/3]

AlphaScan::AlphaScan	(	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 66 of file AlphaScan.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:

~AlphaScan()

AlphaScan::~AlphaScan ( )

overridedefault

Member Function Documentation

analyzer()

const PolFilter* ISpecularScan::analyzer ( ) const

inlineinherited

Definition at line 45 of file ISpecularScan.h.

{ return m_polAnalyzer.get(); }

References ISpecularScan::m_polAnalyzer.

angleResolution()

const ScanResolution* AlphaScan::angleResolution ( ) const

inline

Definition at line 64 of file AlphaScan.h.

{ return m_inc_resolution.get(); }

References m_inc_resolution.

applyIncResolution()

AlphaScan::DistrOutput AlphaScan::applyIncResolution ( ) const

private

Definition at line 278 of file AlphaScan.cpp.

{
    return m_inc_resolution->generateSamples(m_inc_angle->binCenters());
}

References m_inc_angle, and m_inc_resolution.

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

applyWlResolution()

AlphaScan::DistrOutput AlphaScan::applyWlResolution ( ) const

private

Definition at line 273 of file AlphaScan.cpp.

{
    return m_wl_resolution->generateSamples(m_wl, m_inc_angle->size());
}

References m_inc_angle, m_wl, and m_wl_resolution.

Referenced by createIntensities(), and generateElements().

checkInitialization()

void AlphaScan::checkInitialization ( )

private

Definition at line 259 of file AlphaScan.cpp.

{
    if (m_wl <= 0.0)
        throw std::runtime_error(
            "Error in AlphaScan::checkInitialization: wavelength shell be positive");
 
    const std::vector<double> axis_values = m_inc_angle->binCenters();
    if (!std::is_sorted(axis_values.begin(), axis_values.end()))
        throw std::runtime_error("Error in AlphaScan::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 AlphaScan().

clone()

AlphaScan * AlphaScan::clone ( ) const

overridevirtual

Implements ISpecularScan.

Definition at line 75 of file AlphaScan.cpp.

{
    auto* result = new AlphaScan(m_wl, *m_inc_angle);
    result->setFootprintFactor(m_footprint.get());
    result->setWavelengthResolution(*m_wl_resolution);
    result->setAngleResolution(*m_inc_resolution);
    if (m_beamPolarization)
        result->m_beamPolarization.reset(new R3(*m_beamPolarization));
    if (m_polAnalyzer)
        result->m_polAnalyzer.reset(new PolFilter(*m_polAnalyzer));
    return result;
}

References AlphaScan(), ISpecularScan::m_beamPolarization, m_footprint, m_inc_angle, m_inc_resolution, ISpecularScan::m_polAnalyzer, m_wl, and m_wl_resolution.

Here is the call graph for this function:

coordinateAxis()

const IAxis* AlphaScan::coordinateAxis ( ) const

inlineoverridevirtual

Returns coordinate axis assigned to the data holder.

Implements ISpecularScan.

Definition at line 45 of file AlphaScan.h.

{ return m_inc_angle.get(); }

References m_inc_angle.

Referenced by createCoordSystem().

createCoordSystem()

CoordSystem1D * AlphaScan::createCoordSystem ( ) const

overridevirtual

Implements ISpecularScan.

Definition at line 230 of file AlphaScan.cpp.

{
    return new AngularReflectometryCoordinates(wavelength(), *coordinateAxis());
}

References coordinateAxis(), and wavelength().

Here is the call graph for this function:

createIntensities()

std::vector< double > AlphaScan::createIntensities ( const std::vector< SpecularElement > &  eles ) const

overridevirtual

Returns intensity vector corresponding to convolution of given simulation elements.

Implements ISpecularScan.

Definition at line 235 of file AlphaScan.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 += eles[elem_pos].intensity() * inc_weight * wl_weights[i][j];
                ++elem_pos;
            }
        }
    }
    return result;
}

References applyIncResolution(), applyWlResolution(), m_inc_angle, and ParameterSample::weight.

Here is the call graph for this function:

footprint()

std::vector< double > AlphaScan::footprint ( size_t  start, 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 188 of file AlphaScan.cpp.

{
    if (start + n_elements > numberOfElements())
        throw std::runtime_error("Error in AlphaScan::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(), m_footprint, m_inc_resolution, M_PI_2, m_wl_resolution, numberOfElements(), and ParameterSample::value.

Here is the call graph for this function:

footprintFactor()

const IFootprintFactor* AlphaScan::footprintFactor ( ) const

inlineoverridevirtual

Returns IFootprintFactor object pointer.

Implements ISpecularScan.

Definition at line 48 of file AlphaScan.h.

{ return m_footprint.get(); }

References m_footprint.

generateElements()

std::vector< SpecularElement > AlphaScan::generateElements ( ) const

overridevirtual

Generates simulation elements for specular simulations.

Implements ISpecularScan.

Definition at line 90 of file AlphaScan.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<SpecularElement> result;
    result.reserve(numberOfElements());
    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 alpha = incs[i][k];
            for (size_t j = 0, size_wls = wls[i].size(); j < size_wls; ++j) {
                const double wavelength = wls[i][j];
                const bool computable = wavelength >= 0 && alpha >= 0 && alpha <= M_PI_2;
                result.emplace_back(
                    SpecularElement::FromAlphaScan(wavelength, -alpha, polMatrices(), computable));
            }
        }
    }
    return result;
}

References applyIncResolution(), applyWlResolution(), SpecularElement::FromAlphaScan(), m_inc_angle, M_PI_2, numberOfElements(), ISpecularScan::polMatrices(), ParameterSample::value, and wavelength().

Here is the call graph for this function:

numberOfElements()

size_t AlphaScan::numberOfElements ( ) const

overridevirtual

Returns the number of simulation elements.

Implements ISpecularScan.

Definition at line 225 of file AlphaScan.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 generateElements().

polarized()

bool ISpecularScan::polarized ( ) const

inherited

Definition at line 31 of file ISpecularScan.cpp.

{
    return m_beamPolarization || m_polAnalyzer;
}

References ISpecularScan::m_beamPolarization, and ISpecularScan::m_polAnalyzer.

polMatrices()

PolMatrices ISpecularScan::polMatrices ( ) const

inherited

Definition at line 36 of file ISpecularScan.cpp.

{
    PolMatrices result;
    if (m_beamPolarization)
        result.setPolarizerMatrix(SpinMatrix::FromBlochVector(*m_beamPolarization));
    if (m_polAnalyzer)
        result.setAnalyzerMatrix(m_polAnalyzer->matrix());
    return result;
}

References SpinMatrix::FromBlochVector(), ISpecularScan::m_beamPolarization, ISpecularScan::m_polAnalyzer, PolMatrices::setAnalyzerMatrix(), and PolMatrices::setPolarizerMatrix().

Referenced by generateElements(), and QzScan::generateElements().

Here is the call graph for this function:

setAbsoluteAngularResolution() [1/2]

void AlphaScan::setAbsoluteAngularResolution	(	const IRangedDistribution &	distr,
		const std::vector< double > &	std_dev
	)

Sets angular resolution values via IRangedDistribution 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 180 of file AlphaScan.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 AlphaScan::setAbsoluteAngularResolution	(	const IRangedDistribution &	distr,
		double	std_dev
	)

Definition at line 173 of file AlphaScan.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:

setAbsoluteWavelengthResolution() [1/2]

void AlphaScan::setAbsoluteWavelengthResolution	(	const IRangedDistribution &	distr,
		const std::vector< double > &	std_dev
	)

Sets wavelength resolution values via IRangedDistribution 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 145 of file AlphaScan.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 AlphaScan::setAbsoluteWavelengthResolution	(	const IRangedDistribution &	distr,
		double	std_dev
	)

Definition at line 138 of file AlphaScan.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:

setAnalyzer()

void ISpecularScan::setAnalyzer ( R3  direction, double  efficiency, double  total_transmission  )

inherited

Sets the polarization analyzer characteristics of the detector.

Definition at line 26 of file ISpecularScan.cpp.

{
    m_polAnalyzer.reset(new PolFilter(direction, efficiency, total_transmission));
}

References ISpecularScan::m_polAnalyzer.

setAngleResolution()

void AlphaScan::setAngleResolution

(

const ScanResolution &

resolution

)

Sets angle resolution values via ScanResolution object.

Definition at line 153 of file AlphaScan.cpp.

{
    m_inc_resolution.reset(resolution.clone());
}

References ScanResolution::clone(), and m_inc_resolution.

Referenced by setAbsoluteAngularResolution(), and setRelativeAngularResolution().

Here is the call graph for this function:

setFootprintFactor()

void AlphaScan::setFootprintFactor

(

const IFootprintFactor *

f_factor

)

Sets footprint correction factor.

Definition at line 113 of file AlphaScan.cpp.

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

References IFootprintFactor::clone(), and m_footprint.

Here is the call graph for this function:

setPolarization()

void ISpecularScan::setPolarization ( R3  bloch_vector )

inherited

Sets the polarization density matrix according to the given Bloch vector.

Definition at line 21 of file ISpecularScan.cpp.

{
    m_beamPolarization.reset(new R3(bloch_vector));
}

References ISpecularScan::m_beamPolarization.

setRelativeAngularResolution() [1/2]

void AlphaScan::setRelativeAngularResolution	(	const IRangedDistribution &	distr,
		const std::vector< double > &	rel_dev
	)

Sets angular resolution values via IRangedDistribution 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 165 of file AlphaScan.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 AlphaScan::setRelativeAngularResolution	(	const IRangedDistribution &	distr,
		double	rel_dev
	)

Definition at line 158 of file AlphaScan.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:

setRelativeWavelengthResolution() [1/2]

void AlphaScan::setRelativeWavelengthResolution	(	const IRangedDistribution &	distr,
		const std::vector< double > &	rel_dev
	)

Sets wavelength resolution values via IRangedDistribution 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 130 of file AlphaScan.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 AlphaScan::setRelativeWavelengthResolution	(	const IRangedDistribution &	distr,
		double	rel_dev
	)

Definition at line 123 of file AlphaScan.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:

setWavelengthResolution()

void AlphaScan::setWavelengthResolution

(

const ScanResolution &

resolution

)

Sets wavelength resolution values via ScanResolution object.

Definition at line 118 of file AlphaScan.cpp.

{
    m_wl_resolution.reset(resolution.clone());
}

References ScanResolution::clone(), and m_wl_resolution.

Referenced by setAbsoluteWavelengthResolution(), and setRelativeWavelengthResolution().

Here is the call graph for this function:

transferToCPP()

virtual void ICloneable::transferToCPP ( )

inlinevirtualinherited

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

Definition at line 32 of file ICloneable.h.

wavelength()

double AlphaScan::wavelength ( ) const

inlineoverridevirtual

Implements ISpecularScan.

Definition at line 67 of file AlphaScan.h.

{ return m_wl; }

References m_wl.

Referenced by createCoordSystem(), and generateElements().

wavelengthResolution()

const ScanResolution* AlphaScan::wavelengthResolution ( ) const

inline

Definition at line 63 of file AlphaScan.h.

{ return m_wl_resolution.get(); }

References m_wl_resolution.

Member Data Documentation

m_beamPolarization

std::unique_ptr<R3> ISpecularScan::m_beamPolarization

protectedinherited

Bloch vector encoding the beam's polarization.

Definition at line 77 of file ISpecularScan.h.

Referenced by clone(), QzScan::clone(), ISpecularScan::polarized(), ISpecularScan::polMatrices(), and ISpecularScan::setPolarization().

m_footprint

std::unique_ptr<IFootprintFactor> AlphaScan::m_footprint

private

Definition at line 117 of file AlphaScan.h.

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

m_inc_angle

const std::unique_ptr<IAxis> AlphaScan::m_inc_angle

private

Definition at line 116 of file AlphaScan.h.

Referenced by applyIncResolution(), applyWlResolution(), checkInitialization(), clone(), coordinateAxis(), createIntensities(), generateElements(), and numberOfElements().

m_inc_resolution

std::unique_ptr<ScanResolution> AlphaScan::m_inc_resolution

private

Definition at line 120 of file AlphaScan.h.

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

m_polAnalyzer

std::unique_ptr<PolFilter> ISpecularScan::m_polAnalyzer

protectedinherited

Definition at line 78 of file ISpecularScan.h.

Referenced by ISpecularScan::analyzer(), clone(), QzScan::clone(), ISpecularScan::polarized(), ISpecularScan::polMatrices(), and ISpecularScan::setAnalyzer().

m_wl

const double AlphaScan::m_wl

private

Definition at line 115 of file AlphaScan.h.

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

m_wl_resolution

std::unique_ptr<ScanResolution> AlphaScan::m_wl_resolution

private

Definition at line 119 of file AlphaScan.h.

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

---

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

• /home/build/builds/o5h8MZZm/0/mlz/bornagain/Sim/Scan/AlphaScan.h
• /home/build/builds/o5h8MZZm/0/mlz/bornagain/Sim/Scan/AlphaScan.cpp