Collaboration diagram for SpecularSimulationElement:

Public Member Functions
	SpecularSimulationElement (double kz, bool computable)

	SpecularSimulationElement (double wavelength, double alpha, bool computable)

	SpecularSimulationElement (const SpecularSimulationElement &other)

	SpecularSimulationElement (SpecularSimulationElement &&other) noexcept

	~SpecularSimulationElement ()

SpecularSimulationElement &	operator= (const SpecularSimulationElement &other)

void	setPolarizationHandler (const PolarizationHandler &handler)

const PolarizationHandler &	polarizationHandler () const

double	getIntensity () const

void	setIntensity (double intensity)

bool	isCalculated () const

std::vector< complex_t >	produceKz (const std::vector< Slice > &slices)

Private Member Functions
void	swapContent (SpecularSimulationElement &other)

Private Attributes
PolarizationHandler	m_polarization

double	m_intensity

const bool	m_computable

std::function< std::vector< complex_t >const std::vector< Slice > &)>	m_kz_computation

Detailed Description

Data stucture containing both input and output of a single image pixel for specular simulation.

Definition at line 29 of file SpecularSimulationElement.h.

Constructor & Destructor Documentation

◆ SpecularSimulationElement() [1/4]

SpecularSimulationElement::SpecularSimulationElement	(	double	kz,
		bool	computable
	)

Definition at line 18 of file SpecularSimulationElement.cpp.

     : m_intensity(0.0), m_computable(computable),
       m_kz_computation([kz](const std::vector<Slice>& slices) {
           return KzComputation::computeKzFromSLDs(slices, kz);
       })
 {
 }

References KzComputation::computeKzFromSLDs().

Here is the call graph for this function:

◆ SpecularSimulationElement() [2/4]

SpecularSimulationElement::SpecularSimulationElement	(	double	wavelength,
		double	alpha,
		bool	computable
	)

Definition at line 26 of file SpecularSimulationElement.cpp.

     : m_intensity(0.0), m_computable(computable),
       m_kz_computation(
           [k = vecOfLambdaAlphaPhi(wavelength, alpha, 0.0)](const std::vector<Slice>& slices) {
               return KzComputation::computeKzFromRefIndices(slices, k);
           })
 {
 }

References KzComputation::computeKzFromRefIndices().

Here is the call graph for this function:

◆ SpecularSimulationElement() [3/4]

SpecularSimulationElement::SpecularSimulationElement ( const SpecularSimulationElement & other )

Definition at line 36 of file SpecularSimulationElement.cpp.

     : m_polarization(other.m_polarization), m_intensity(other.m_intensity),
       m_computable(other.m_computable), m_kz_computation(other.m_kz_computation)
 {
 }

◆ SpecularSimulationElement() [4/4]

SpecularSimulationElement::SpecularSimulationElement ( SpecularSimulationElement && other )

noexcept

Definition at line 42 of file SpecularSimulationElement.cpp.

     : m_polarization(std::move(other.m_polarization)), m_intensity(other.m_intensity),
       m_computable(other.m_computable), m_kz_computation(std::move(other.m_kz_computation))
 {
 }

◆ ~SpecularSimulationElement()

SpecularSimulationElement::~SpecularSimulationElement ( )

default

Member Function Documentation

◆ operator=()

SpecularSimulationElement & SpecularSimulationElement::operator= ( const SpecularSimulationElement & other )

Definition at line 51 of file SpecularSimulationElement.cpp.

 {
     if (this != &other) {
         SpecularSimulationElement tmp(other);
         tmp.swapContent(*this);
     }
     return *this;
 }

References swapContent().

Here is the call graph for this function:

◆ setPolarizationHandler()

void SpecularSimulationElement::setPolarizationHandler ( const PolarizationHandler & handler )

Assigns PolarizationHandler.

Definition at line 60 of file SpecularSimulationElement.cpp.

 {
     m_polarization = handler;
 }

References m_polarization.

◆ polarizationHandler()

const PolarizationHandler& SpecularSimulationElement::polarizationHandler ( ) const

inline

Returns assigned PolarizationHandler.

Definition at line 46 of file SpecularSimulationElement.h.

46 { return m_polarization; }

References m_polarization.

Referenced by anonymous_namespace{SpecularComputationTerm.cpp}::matrix_intensity().

◆ getIntensity()

double SpecularSimulationElement::getIntensity ( ) const

inline

Definition at line 48 of file SpecularSimulationElement.h.

48 { return m_intensity; }

References m_intensity.

◆ setIntensity()

void SpecularSimulationElement::setIntensity ( double intensity )

inline

Definition at line 49 of file SpecularSimulationElement.h.

49 { m_intensity = intensity; }

References m_intensity.

Referenced by SpecularScalarTerm::eval(), and SpecularMatrixTerm::eval().

◆ isCalculated()

bool SpecularSimulationElement::isCalculated ( ) const

inline

Returns calculation flag (if it's false, zero intensity is assigned to the element)

Definition at line 52 of file SpecularSimulationElement.h.

52 { return m_computable; }

References m_computable.

Referenced by SpecularComputationTerm::computeIntensity().

◆ produceKz()

std::vector< complex_t > SpecularSimulationElement::produceKz ( const std::vector< Slice > & slices )

Returns kz values for Abeles computation of reflection/transition coefficients.

Definition at line 65 of file SpecularSimulationElement.cpp.

 {
     return m_kz_computation(slices);
 }

References m_kz_computation.

Referenced by SpecularScalarTerm::eval(), and SpecularMatrixTerm::eval().

◆ swapContent()

void SpecularSimulationElement::swapContent ( SpecularSimulationElement & other )

private

Definition at line 70 of file SpecularSimulationElement.cpp.

 {
     m_polarization.swapContent(other.m_polarization);
     std::swap(m_intensity, other.m_intensity);
     m_kz_computation.swap(other.m_kz_computation);
 }