ProcessedSample Class Reference

Data structure that contains all the necessary data for scattering calculations. More...

Collaboration diagram for ProcessedSample:

Public Member Functions
	ProcessedSample (const MultiLayer &sample, const SimulationOptions &options, bool forcePolarized=false)
	~ProcessedSample ()
const std::vector< Slice > &	averageSlices () const
const LayerRoughness *	bottomRoughness (size_t i) const
bool	containsMagneticMaterial () const
double	crossCorrelationLength () const
double	crossCorrSpectralFun (const kvector_t kvec, size_t j, size_t k) const
	Fourier transform of the correlation function of roughnesses between the interfaces. More...
kvector_t	externalField () const
const IFresnelMap *	fresnelMap () const
bool	hasRoughness () const
const std::vector< ProcessedLayout > &	layouts () const
size_t	numberOfSlices () const
double	sliceBottomZ (size_t i) const
const std::vector< Slice > &	slices () const
double	sliceTopZ (size_t i) const

Private Member Functions
void	addNSlices (size_t n, double thickness, const Material &material, const LayerRoughness *p_roughness=nullptr)
void	addSlice (double thickness, const Material &material, const LayerRoughness *p_roughness=nullptr)
void	initBFields ()
void	initFresnelMap (const SimulationOptions &sim_options)
void	initLayouts (const MultiLayer &sample)
void	initSlices (const MultiLayer &sample, const SimulationOptions &options)
void	mergeRegionMap (const std::map< size_t, std::vector< HomogeneousRegion >> &region_map)

Private Attributes
double	m_crossCorrLength
kvector_t	m_ext_field
std::unique_ptr< IFresnelMap >	m_fresnel_map
std::vector< ProcessedLayout >	m_layouts
bool	m_polarized
std::map< size_t, std::vector< HomogeneousRegion > >	m_region_map
std::vector< Slice >	m_slices
double	m_top_z

Detailed Description

Data structure that contains all the necessary data for scattering calculations.

If the usage of average materials is requested, layers and particles are sliced into multiple slices and the average material is calculated for each slice.

Definition at line 42 of file ProcessedSample.h.

Constructor & Destructor Documentation

ProcessedSample()

ProcessedSample::ProcessedSample	(	const MultiLayer &	sample,
		const SimulationOptions &	options,
		bool	forcePolarized = false
	)

Definition at line 111 of file ProcessedSample.cpp.

    : m_slices{}
    , m_top_z{0.0}
    , m_polarized{forcePolarized}
    , m_crossCorrLength{sample.crossCorrLength()}
    , m_ext_field{sample.externalField()}
{
    initSlices(sample, options);
    m_fresnel_map = createFresnelMap(sample, m_slices, options);
    initBFields();
    initLayouts(sample);
    initFresnelMap(options);
}

References initBFields(), initFresnelMap(), initLayouts(), initSlices(), m_fresnel_map, and m_slices.

Here is the call graph for this function:

~ProcessedSample()

ProcessedSample::~ProcessedSample ( )

default

Member Function Documentation

addNSlices()

void ProcessedSample::addNSlices ( size_t  n, double  thickness, const Material &  material, const LayerRoughness *  p_roughness = nullptr  )

private

Definition at line 303 of file ProcessedSample.cpp.

{
    if (thickness <= 0.0)
        return;
    if (n == 0)
        throw std::runtime_error("ProcessedSample::addNSlices: number of slices should be "
                                 "bigger than zero.");
    const double slice_thickness = thickness / n;
    addSlice(slice_thickness, material, roughness);
    for (size_t i = 1; i < n; ++i)
        addSlice(slice_thickness, material);
}

References addSlice().

Referenced by initSlices().

Here is the call graph for this function:

addSlice()

void ProcessedSample::addSlice ( double  thickness, const Material &  material, const LayerRoughness *  p_roughness = nullptr  )

private

Definition at line 294 of file ProcessedSample.cpp.

{
    if (roughness)
        m_slices.emplace_back(thickness, material, *roughness);
    else
        m_slices.emplace_back(thickness, material);
}

References m_slices.

Referenced by addNSlices(), and initSlices().

averageSlices()

const std::vector< Slice > & ProcessedSample::averageSlices

(

)

const

Definition at line 138 of file ProcessedSample.cpp.

{
    return m_fresnel_map->slices();
}

References m_fresnel_map.

Referenced by ProfileHelper::ProfileHelper().

bottomRoughness()

const LayerRoughness * ProcessedSample::bottomRoughness

(

size_t

i

)

const

Definition at line 163 of file ProcessedSample.cpp.

{
    if (i + 2 > m_slices.size())
        throw std::runtime_error("ProcessedSample::bottomRoughness: "
                                 "index out of bounds.");
    return m_slices[i + 1].topRoughness();
}

References m_slices.

Referenced by ProfileHelper::ProfileHelper(), RoughMultiLayerComputation::compute(), crossCorrSpectralFun(), and RoughMultiLayerComputation::get_sum8terms().

containsMagneticMaterial()

bool ProcessedSample::containsMagneticMaterial

(

)

const

Definition at line 191 of file ProcessedSample.cpp.

{
    return m_polarized;
}

References m_polarized.

crossCorrelationLength()

double ProcessedSample::crossCorrelationLength

(

)

const

Definition at line 153 of file ProcessedSample.cpp.

{
    return m_crossCorrLength;
}

References m_crossCorrLength.

Referenced by RoughMultiLayerComputation::compute().

crossCorrSpectralFun()

double ProcessedSample::crossCorrSpectralFun	(	const kvector_t	kvec,
		size_t	j,
		size_t	k
	)		const

Fourier transform of the correlation function of roughnesses between the interfaces.

Definition at line 204 of file ProcessedSample.cpp.

{
    if (m_crossCorrLength <= 0.0)
        return 0.0;
    const double z_j = sliceBottomZ(j);
    const double z_k = sliceBottomZ(k);
    const LayerRoughness* rough_j = bottomRoughness(j);
    const LayerRoughness* rough_k = bottomRoughness(k);
    if (!rough_j || !rough_k)
        return 0.0;
    const double sigma_j = rough_j->getSigma();
    const double sigma_k = rough_k->getSigma();
    if (sigma_j <= 0 || sigma_k <= 0)
        return 0.0;
    return 0.5
           * ((sigma_k / sigma_j) * rough_j->getSpectralFun(kvec)
              + (sigma_j / sigma_k) * rough_k->getSpectralFun(kvec))
           * std::exp(-1 * std::abs(z_j - z_k) / m_crossCorrLength);
}

References bottomRoughness(), LayerRoughness::getSigma(), LayerRoughness::getSpectralFun(), m_crossCorrLength, and sliceBottomZ().

Referenced by RoughMultiLayerComputation::compute().

Here is the call graph for this function:

externalField()

kvector_t ProcessedSample::externalField

(

)

const

Definition at line 158 of file ProcessedSample.cpp.

{
    return m_ext_field;
}

References m_ext_field.

fresnelMap()

const IFresnelMap * ProcessedSample::fresnelMap

(

)

const

Definition at line 148 of file ProcessedSample.cpp.

{
    return m_fresnel_map.get();
}

References m_fresnel_map.

Referenced by DepthProbeComputationTerm::compute(), and RoughMultiLayerComputation::get_sum8terms().

hasRoughness()

bool ProcessedSample::hasRoughness

(

)

const

Definition at line 196 of file ProcessedSample.cpp.

{
    for (const auto& slice : m_slices)
        if (slice.topRoughness())
            return true;
    return false;
}

References m_slices.

initBFields()

void ProcessedSample::initBFields ( )

private

Definition at line 317 of file ProcessedSample.cpp.

{
    if (m_slices.empty())
        return;
    const double m_z0 = m_slices[0].material().magnetization().z();
    const double b_z = Slice::Magnetic_Permeability * (m_ext_field.z() + m_z0);
    for (size_t i = 0; i < m_slices.size(); ++i) {
        m_slices[i].initBField(m_ext_field, b_z);
    }
}

References m_ext_field, m_slices, Slice::Magnetic_Permeability, and BasicVector3D< T >::z().

Referenced by ProcessedSample().

Here is the call graph for this function:

initFresnelMap()

void ProcessedSample::initFresnelMap ( const SimulationOptions &  sim_options )

private

Definition at line 338 of file ProcessedSample.cpp.

{
    if (sim_options.useAvgMaterials()) {
        m_fresnel_map->setSlices(createAverageMaterialSlices(m_slices, m_region_map));
    } else {
        m_fresnel_map->setSlices(m_slices);
    }
}

References m_fresnel_map, m_region_map, m_slices, and SimulationOptions::useAvgMaterials().

Referenced by ProcessedSample().

Here is the call graph for this function:

initLayouts()

void ProcessedSample::initLayouts ( const MultiLayer &  sample )

private

Definition at line 278 of file ProcessedSample.cpp.

{
    double z_ref = -m_top_z;
    m_polarized = m_polarized || sample.isMagnetic();
 
    for (size_t i = 0; i < sample.numberOfLayers(); ++i) {
        if (i > 1)
            z_ref -= sample.layer(i - 1)->thickness();
        auto layer = sample.layer(i);
        for (const auto* layout : layer->layouts()) {
            m_layouts.emplace_back(*layout, m_slices, z_ref, m_fresnel_map.get(), m_polarized);
            mergeRegionMap(m_layouts.back().regionMap());
        }
    }
}

References ISampleNode::isMagnetic(), MultiLayer::layer(), m_fresnel_map, m_layouts, m_polarized, m_slices, m_top_z, mergeRegionMap(), MultiLayer::numberOfLayers(), and Layer::thickness().

Referenced by ProcessedSample().

Here is the call graph for this function:

initSlices()

void ProcessedSample::initSlices ( const MultiLayer &  sample, const SimulationOptions &  options  )

private

Definition at line 225 of file ProcessedSample.cpp.

{
    if (sample.numberOfLayers() == 0)
        return;
    bool use_slicing = options.useAvgMaterials() && sample.numberOfLayers() > 1;
    const auto layer_limits = particleRegions(sample, use_slicing);
    for (size_t i = 0; i < sample.numberOfLayers(); ++i) {
        const auto layer = sample.layer(i);
        const auto n_slices = layer->numberOfSlices();
        const ZLimits& slice_limits = layer_limits[i];
        double tl = layer->thickness();
        const Material* material = layer->material();
        auto roughness = MultiLayerUtils::LayerTopRoughness(sample, i);
        if (roughness && roughness->getSigma() <= 0)
            roughness = nullptr;
        // if no slicing is needed, create single slice for the layer
        if (!slice_limits.isFinite() || n_slices == 0) {
            if (i == sample.numberOfLayers() - 1)
                tl = 0.0;
            addSlice(tl, *material, roughness);
            continue;
        }
        const double top = slice_limits.upperLimit().m_value;
        const double bottom = slice_limits.lowerLimit().m_value;
        // top layer
        if (i == 0) {
            if (top <= 0)
                throw std::runtime_error("ProcessedSample::ProcessedSample: "
                                         "top limit for top layer must be > 0.");
            addSlice(0.0, *material);
            addNSlices(n_slices, top - bottom, *material);
            if (bottom > 0)
                addSlice(bottom, *material);
            m_top_z = top;
        }
        // middle or bottom layer
        else {
            if (top < 0) {
                addSlice(-top, *material, roughness);
                addNSlices(n_slices, top - bottom, *material);
            } else {
                addNSlices(n_slices, top - bottom, *material, roughness);
            }
            // middle layer
            if (i < sample.numberOfLayers() - 1 && bottom > -tl)
                addSlice(bottom + tl, *material);
            // bottom layer
            if (i == sample.numberOfLayers() - 1)
                addSlice(0.0, *material);
        }
    }
}

References addNSlices(), addSlice(), ZLimits::isFinite(), MultiLayer::layer(), MultiLayerUtils::LayerTopRoughness(), ZLimits::lowerLimit(), m_top_z, OneSidedLimit::m_value, MultiLayer::numberOfLayers(), Layer::numberOfSlices(), ZLimits::upperLimit(), and SimulationOptions::useAvgMaterials().

Referenced by ProcessedSample().

Here is the call graph for this function:

layouts()

const std::vector< ProcessedLayout > & ProcessedSample::layouts

(

)

const

Definition at line 143 of file ProcessedSample.cpp.

{
    return m_layouts;
}

References m_layouts.

mergeRegionMap()

void ProcessedSample::mergeRegionMap ( const std::map< size_t, std::vector< HomogeneousRegion >> &  region_map )

private

Definition at line 328 of file ProcessedSample.cpp.

{
    for (const auto& entry : region_map) {
        size_t i = entry.first;
        auto& regions = entry.second;
        m_region_map[i].insert(m_region_map[i].begin(), regions.begin(), regions.end());
    }
}

References m_region_map.

Referenced by initLayouts().

numberOfSlices()

size_t ProcessedSample::numberOfSlices

(

)

const

Definition at line 128 of file ProcessedSample.cpp.

{
    return m_slices.size();
}

References m_slices.

Referenced by ProfileHelper::ProfileHelper(), DepthProbeComputationTerm::compute(), RoughMultiLayerComputation::compute(), and sliceBottomZ().

sliceBottomZ()

double ProcessedSample::sliceBottomZ

(

size_t

i

)

const

Definition at line 178 of file ProcessedSample.cpp.

{
    if (numberOfSlices() < 2)
        return m_top_z;
    // Last slice has no bottom:
    if (i + 2 > numberOfSlices())
        i = numberOfSlices() - 2;
    double z = m_top_z;
    for (size_t j = 1; j <= i; ++j)
        z -= m_slices[j].thickness();
    return z;
}

References m_slices, m_top_z, and numberOfSlices().

Referenced by ProfileHelper::ProfileHelper(), DepthProbeComputationTerm::compute(), crossCorrSpectralFun(), and sliceTopZ().

Here is the call graph for this function:

slices()

const std::vector< Slice > & ProcessedSample::slices

(

)

const

Definition at line 133 of file ProcessedSample.cpp.

{
    return m_slices;
}

References m_slices.

Referenced by RoughMultiLayerComputation::get_refractive_term(), and RoughMultiLayerComputation::get_sum8terms().

sliceTopZ()

double ProcessedSample::sliceTopZ

(

size_t

i

)

const

Definition at line 171 of file ProcessedSample.cpp.

{
    if (i == 0)
        return m_top_z;
    return sliceBottomZ(i - 1);
}

References m_top_z, and sliceBottomZ().

Referenced by DepthProbeComputationTerm::compute().

Here is the call graph for this function:

Member Data Documentation

m_crossCorrLength

double ProcessedSample::m_crossCorrLength

private

Definition at line 81 of file ProcessedSample.h.

Referenced by crossCorrelationLength(), and crossCorrSpectralFun().

m_ext_field

kvector_t ProcessedSample::m_ext_field

private

Definition at line 82 of file ProcessedSample.h.

Referenced by externalField(), and initBFields().

m_fresnel_map

std::unique_ptr<IFresnelMap> ProcessedSample::m_fresnel_map

private

Definition at line 76 of file ProcessedSample.h.

Referenced by ProcessedSample(), averageSlices(), fresnelMap(), initFresnelMap(), and initLayouts().

m_layouts

std::vector<ProcessedLayout> ProcessedSample::m_layouts

private

Definition at line 80 of file ProcessedSample.h.

Referenced by initLayouts(), and layouts().

m_polarized

bool ProcessedSample::m_polarized

private

Definition at line 79 of file ProcessedSample.h.

Referenced by containsMagneticMaterial(), and initLayouts().

m_region_map

std::map<size_t, std::vector<HomogeneousRegion> > ProcessedSample::m_region_map

private

Definition at line 83 of file ProcessedSample.h.

Referenced by initFresnelMap(), and mergeRegionMap().

m_slices

std::vector<Slice> ProcessedSample::m_slices

private

Definition at line 77 of file ProcessedSample.h.

Referenced by ProcessedSample(), addSlice(), bottomRoughness(), hasRoughness(), initBFields(), initFresnelMap(), initLayouts(), numberOfSlices(), sliceBottomZ(), and slices().

m_top_z

double ProcessedSample::m_top_z

private

Definition at line 78 of file ProcessedSample.h.

Referenced by initLayouts(), initSlices(), sliceBottomZ(), and sliceTopZ().

---

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

• /home/www/ba/Sample/Processed/ProcessedSample.h
• /home/www/ba/Sample/Processed/ProcessedSample.cpp