anonymous_namespace{ProcessedSample.cpp} Namespace Reference

Functions
std::unique_ptr< IFresnelMap >	CreateFresnelMap (const MultiLayer &sample, const std::vector< Slice > &slices, const SimulationOptions &options)
bool	ContainsMagneticMaterial (const MultiLayer &sample)
bool	ContainsMagneticSlice (const std::vector< Slice > &slices)
bool	CheckRegions (const std::vector< HomogeneousRegion > &regions)
std::vector< Slice >	CreateAverageMaterialSlices (const std::vector< Slice > &slices, const std::map< size_t, std::vector< HomogeneousRegion >> &region_map)

Function Documentation

CreateFresnelMap()

std::unique_ptr< IFresnelMap > anonymous_namespace{ProcessedSample.cpp}::CreateFresnelMap	(	const MultiLayer &	sample,
		const std::vector< Slice > &	slices,
		const SimulationOptions &	options
	)

Definition at line 280 of file ProcessedSample.cpp.

{
    std::unique_ptr<IFresnelMap> P_result;
    if (ContainsMagneticSlice(slices))
        P_result = std::make_unique<MatrixFresnelMap>(SpecularStrategyBuilder::build(sample, true));
    else
        P_result =
            std::make_unique<ScalarFresnelMap>(SpecularStrategyBuilder::build(sample, false));
    if (options.isIntegrate())
        P_result->disableCaching();
    return P_result;
}

References SpecularStrategyBuilder::build(), ContainsMagneticSlice(), and SimulationOptions::isIntegrate().

Referenced by ProcessedSample::ProcessedSample().

Here is the call graph for this function:

ContainsMagneticMaterial()

bool anonymous_namespace{ProcessedSample.cpp}::ContainsMagneticMaterial

(

const MultiLayer &

sample

)

Definition at line 295 of file ProcessedSample.cpp.

{
    for (const Material* mat : sample.containedMaterials())
        if (mat->isMagneticMaterial())
            return true;
    return false;
}

References ISample::containedMaterials().

Referenced by ProcessedSample::initLayouts().

Here is the call graph for this function:

ContainsMagneticSlice()

bool anonymous_namespace{ProcessedSample.cpp}::ContainsMagneticSlice

(

const std::vector< Slice > &

slices

)

Definition at line 303 of file ProcessedSample.cpp.

{
    for (size_t i = 0; i < slices.size(); ++i) {
        if (slices[i].material().isMagneticMaterial())
            return true;
    }
    return false;
}

Referenced by CreateFresnelMap().

CheckRegions()

bool anonymous_namespace{ProcessedSample.cpp}::CheckRegions

(

const std::vector< HomogeneousRegion > &

regions

)

Definition at line 312 of file ProcessedSample.cpp.

{
    double total_fraction = 0.0;
    for (auto& region : regions)
        total_fraction += region.m_volume;
    return (total_fraction >= 0 && total_fraction <= 1);
}

Referenced by CreateAverageMaterialSlices().

CreateAverageMaterialSlices()

std::vector< Slice > anonymous_namespace{ProcessedSample.cpp}::CreateAverageMaterialSlices	(	const std::vector< Slice > &	slices,
		const std::map< size_t, std::vector< HomogeneousRegion >> &	region_map
	)

Definition at line 321 of file ProcessedSample.cpp.

{
    std::vector<Slice> result = slices;
    auto last_slice_index = slices.size() - 1;
    for (auto& entry : region_map) {
        auto i_slice = entry.first;
        if (i_slice == 0 || i_slice == last_slice_index)
            continue; // skip semi-infinite layers
        auto slice_mat = slices[i_slice].material();
        if (!CheckRegions(entry.second))
            throw std::runtime_error("CreateAverageMaterialSlices: "
                                     "total volumetric fraction of particles exceeds 1!");
        auto new_material = createAveragedMaterial(slice_mat, entry.second);
        result[i_slice].setMaterial(new_material);
    }
    return result;
}

References CheckRegions(), and createAveragedMaterial().

Referenced by ProcessedSample::initFresnelMap().

Here is the call graph for this function: