ProcessedSample Class Reference

Collaboration diagram for ProcessedSample:

Public Member Functions
	ProcessedSample (const MultiLayer &sample, const SimulationOptions &options)
	~ProcessedSample ()
size_t	numberOfSlices () const
const std::vector< Slice > &	slices () const
const std::vector< Slice > &	averageSlices () const
const std::vector< ProcessedLayout > &	layouts () const
const IFresnelMap *	fresnelMap () const
double	crossCorrelationLength () const
kvector_t	externalField () const
const LayerRoughness *	bottomRoughness (size_t i) const
double	sliceTopZ (size_t i) const
double	sliceBottomZ (size_t i) const
bool	containsMagneticMaterial () const
bool	hasRoughness () const
double	crossCorrSpectralFun (const kvector_t kvec, size_t j, size_t k) const

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

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

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 37 of file ProcessedSample.h.

Constructor & Destructor Documentation

ProcessedSample()

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

Definition at line 40 of file ProcessedSample.cpp.

    : m_slices{}, m_top_z{0.0}, m_polarized{false}, m_crossCorrLength{sample.crossCorrLength()},
      m_ext_field{sample.externalField()}
{
    initSlices(sample, options);
    mP_fresnel_map = CreateFresnelMap(sample, m_slices, options);
    initBFields();
    initLayouts(sample);
    initFresnelMap(options);
}

References anonymous_namespace{ProcessedSample.cpp}::CreateFresnelMap(), initBFields(), initFresnelMap(), initLayouts(), initSlices(), m_slices, and mP_fresnel_map.

Here is the call graph for this function:

~ProcessedSample()

ProcessedSample::~ProcessedSample ( )

default

Member Function Documentation

numberOfSlices()

size_t ProcessedSample::numberOfSlices

(

)

const

Definition at line 53 of file ProcessedSample.cpp.

{
    return m_slices.size();
}

References m_slices.

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

slices()

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

(

)

const

Definition at line 58 of file ProcessedSample.cpp.

{
    return m_slices;
}

References m_slices.

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

averageSlices()

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

(

)

const

Definition at line 63 of file ProcessedSample.cpp.

{
    return mP_fresnel_map->slices();
}

References mP_fresnel_map.

Referenced by ProfileHelper::ProfileHelper().

layouts()

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

(

)

const

Definition at line 68 of file ProcessedSample.cpp.

{
    return m_layouts;
}

References m_layouts.

fresnelMap()

const IFresnelMap * ProcessedSample::fresnelMap

(

)

const

Definition at line 73 of file ProcessedSample.cpp.

{
    return mP_fresnel_map.get();
}

References mP_fresnel_map.

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

crossCorrelationLength()

double ProcessedSample::crossCorrelationLength

(

)

const

Definition at line 78 of file ProcessedSample.cpp.

{
    return m_crossCorrLength;
}

References m_crossCorrLength.

Referenced by RoughMultiLayerComputation::compute().

externalField()

kvector_t ProcessedSample::externalField

(

)

const

Definition at line 83 of file ProcessedSample.cpp.

{
    return m_ext_field;
}

References m_ext_field.

bottomRoughness()

const LayerRoughness * ProcessedSample::bottomRoughness

(

size_t

i

)

const

Definition at line 88 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 RoughMultiLayerComputation::compute(), crossCorrSpectralFun(), RoughMultiLayerComputation::get_sum8terms(), and ProfileHelper::ProfileHelper().

sliceTopZ()

double ProcessedSample::sliceTopZ

(

size_t

i

)

const

Definition at line 96 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:

sliceBottomZ()

double ProcessedSample::sliceBottomZ

(

size_t

i

)

const

Definition at line 103 of file ProcessedSample.cpp.

{
    if (numberOfSlices() < 2)
        return m_top_z;
    // Last slice has no bottom:
    if (i + 2 > numberOfSlices())
        i = numberOfSlices() - 2;
    auto 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 DepthProbeComputationTerm::compute(), crossCorrSpectralFun(), ProfileHelper::ProfileHelper(), and sliceTopZ().

Here is the call graph for this function:

containsMagneticMaterial()

bool ProcessedSample::containsMagneticMaterial

(

)

const

Definition at line 116 of file ProcessedSample.cpp.

{
    return m_polarized;
}

References m_polarized.

hasRoughness()

bool ProcessedSample::hasRoughness

(

)

const

Definition at line 121 of file ProcessedSample.cpp.

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

References m_slices.

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 130 of file ProcessedSample.cpp.

{
    if (m_crossCorrLength <= 0.0)
        return 0.0;
    double z_j = sliceBottomZ(j);
    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;
    double sigma_j = rough_j->getSigma();
    double sigma_k = rough_k->getSigma();
    if (sigma_j <= 0 || sigma_k <= 0)
        return 0.0;
    double corr = 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);
    return corr;
}

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

Referenced by RoughMultiLayerComputation::compute().

Here is the call graph for this function:

initSlices()

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

private

Definition at line 152 of file ProcessedSample.cpp.

{
    if (sample.numberOfLayers() == 0)
        return;
    bool use_slicing = options.useAvgMaterials() && sample.numberOfLayers() > 1;
    auto layer_limits = MultiLayerUtils::ParticleRegions(sample, use_slicing);
    for (size_t i = 0; i < sample.numberOfLayers(); ++i) {
        auto p_layer = sample.layer(i);
        auto n_slices = p_layer->numberOfSlices();
        const ZLimits& slice_limits = layer_limits[i];
        double tl = p_layer->thickness();
        const Material* p_material = p_layer->material();
        auto p_roughness = MultiLayerUtils::LayerTopRoughness(sample, i);
        if (p_roughness && p_roughness->getSigma() <= 0)
            p_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, *p_material, p_roughness);
            continue;
        }
        double top = slice_limits.upperLimit().m_value;
        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, *p_material);
            addNSlices(n_slices, top - bottom, *p_material);
            if (bottom > 0) {
                addSlice(bottom, *p_material);
            }
            m_top_z = top;
        }
        // middle or bottom layer
        else {
            if (top < 0) {
                addSlice(-top, *p_material, p_roughness);
                addNSlices(n_slices, top - bottom, *p_material);
            } else {
                addNSlices(n_slices, top - bottom, *p_material, p_roughness);
            }
            // middle layer
            if (i < sample.numberOfLayers() - 1 && bottom > -tl) {
                addSlice(bottom + tl, *p_material);
            }
            // bottom layer
            if (i == sample.numberOfLayers() - 1) {
                addSlice(0.0, *p_material);
            }
        }
    }
}

References addNSlices(), addSlice(), ZLimits::isFinite(), MultiLayer::layer(), MultiLayerUtils::LayerTopRoughness(), ZLimits::lowerLimit(), m_top_z, OneSidedLimit::m_value, anonymous_namespace{SlicedCylindersBuilder.cpp}::n_slices(), MultiLayer::numberOfLayers(), MultiLayerUtils::ParticleRegions(), ZLimits::upperLimit(), 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 208 of file ProcessedSample.cpp.

{
    double z_ref = -m_top_z;
    m_polarized = ContainsMagneticMaterial(sample);
    for (size_t i = 0; i < sample.numberOfLayers(); ++i) {
        if (i > 1)
            z_ref -= MultiLayerUtils::LayerThickness(sample, i - 1);
        auto p_layer = sample.layer(i);
        for (auto p_layout : p_layer->layouts()) {
            m_layouts.emplace_back(*p_layout, m_slices, z_ref, mP_fresnel_map.get(), m_polarized);
            mergeRegionMap(m_layouts.back().regionMap());
        }
    }
}

References anonymous_namespace{ProcessedSample.cpp}::ContainsMagneticMaterial(), MultiLayer::layer(), MultiLayerUtils::LayerThickness(), m_layouts, m_polarized, m_slices, m_top_z, mergeRegionMap(), mP_fresnel_map, and MultiLayer::numberOfLayers().

Referenced by ProcessedSample().

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 223 of file ProcessedSample.cpp.

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

References m_slices.

Referenced by addNSlices(), and initSlices().

addNSlices()

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

private

Definition at line 233 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.");
    double slice_thickness = thickness / n;
    addSlice(slice_thickness, material, p_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:

initBFields()

void ProcessedSample::initBFields ( )

private

Definition at line 248 of file ProcessedSample.cpp.

{
    if (m_slices.empty())
        return;
    double m_z0 = m_slices[0].material().magnetization().z();
    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:

mergeRegionMap()

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

private

Definition at line 259 of file ProcessedSample.cpp.

{
    for (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().

initFresnelMap()

void ProcessedSample::initFresnelMap ( const SimulationOptions &  sim_options )

private

Definition at line 269 of file ProcessedSample.cpp.

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

References anonymous_namespace{ProcessedSample.cpp}::CreateAverageMaterialSlices(), m_region_map, m_slices, mP_fresnel_map, and SimulationOptions::useAvgMaterials().

Referenced by ProcessedSample().

Here is the call graph for this function:

Member Data Documentation

mP_fresnel_map

std::unique_ptr<IFresnelMap> ProcessedSample::mP_fresnel_map

private

Definition at line 70 of file ProcessedSample.h.

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

m_slices

std::vector<Slice> ProcessedSample::m_slices

private

Definition at line 71 of file ProcessedSample.h.

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

m_top_z

double ProcessedSample::m_top_z

private

Definition at line 72 of file ProcessedSample.h.

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

m_polarized

bool ProcessedSample::m_polarized

private

Definition at line 73 of file ProcessedSample.h.

Referenced by containsMagneticMaterial(), and initLayouts().

m_layouts

std::vector<ProcessedLayout> ProcessedSample::m_layouts

private

Definition at line 74 of file ProcessedSample.h.

Referenced by initLayouts(), and layouts().

m_crossCorrLength

double ProcessedSample::m_crossCorrLength

private

Definition at line 75 of file ProcessedSample.h.

Referenced by crossCorrelationLength(), and crossCorrSpectralFun().

m_ext_field

kvector_t ProcessedSample::m_ext_field

private

Definition at line 76 of file ProcessedSample.h.

Referenced by externalField(), and initBFields().

m_region_map

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

private

Definition at line 77 of file ProcessedSample.h.

Referenced by initFresnelMap(), and mergeRegionMap().

---

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

• /home/www/ba/Core/Computation/ProcessedSample.h
• /home/www/ba/Core/Computation/ProcessedSample.cpp