Data structure that contains preprocessed data for a single layout. More...

Collaboration diagram for ProcessedLayout:

Public Member Functions
	ProcessedLayout (const ParticleLayout &layout, const std::vector< Slice > &slices, double z_ref, const IFresnelMap *p_fresnel_map, bool polarized)

	ProcessedLayout (ProcessedLayout &&other)

	~ProcessedLayout ()

const std::vector< FormFactorCoherentSum > &	formFactorList () const

const IInterferenceFunction *	interferenceFunction () const

size_t	numberOfSlices () const

std::map< size_t, std::vector< HomogeneousRegion > >	regionMap () const

double	surfaceDensity () const

Private Member Functions
void	collectFormFactors (const ParticleLayout &layout, const std::vector< Slice > &slices, double z_ref)

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

FormFactorCoherentSum	processParticle (const IParticle &particle, const std::vector< Slice > &slices, double z_ref)

Private Attributes
std::vector< FormFactorCoherentSum >	m_formfactors

const IFresnelMap *	m_fresnel_map

std::unique_ptr< IInterferenceFunction >	m_iff

size_t	m_n_slices

bool	m_polarized

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

double	m_surface_density

Detailed Description

Data structure that contains preprocessed data for a single layout.

If particles in the layout crossed the limits of the layer slices, these particles will be sliced themselves.

Definition at line 42 of file ProcessedLayout.h.

Constructor & Destructor Documentation

◆ ProcessedLayout() [1/2]

ProcessedLayout::ProcessedLayout	(	const ParticleLayout &	layout,
		const std::vector< Slice > &	slices,
		double	z_ref,
		const IFresnelMap *	p_fresnel_map,
		bool	polarized
	)

Definition at line 42 of file ProcessedLayout.cpp.

     : m_fresnel_map(p_fresnel_map), m_polarized(polarized)
 {
     m_n_slices = slices.size();
     collectFormFactors(layout, slices, z_ref);
     if (const auto* iff = layout.interferenceFunction())
         m_iff.reset(iff->clone());
 }

References collectFormFactors(), ParticleLayout::interferenceFunction(), m_iff, and m_n_slices.

Here is the call graph for this function:

◆ ProcessedLayout() [2/2]

ProcessedLayout::ProcessedLayout ( ProcessedLayout && other )

Definition at line 52 of file ProcessedLayout.cpp.

 {
     m_fresnel_map = other.m_fresnel_map;
     m_polarized = other.m_polarized;
     m_n_slices = other.m_n_slices;
     m_surface_density = other.m_surface_density;
     m_formfactors = std::move(other.m_formfactors);
     m_iff = std::move(other.m_iff);
     m_region_map = std::move(other.m_region_map);
 }

References m_formfactors, m_fresnel_map, m_iff, m_n_slices, m_polarized, m_region_map, and m_surface_density.

◆ ~ProcessedLayout()

ProcessedLayout::~ProcessedLayout ( )

default

Member Function Documentation

◆ collectFormFactors()

void ProcessedLayout::collectFormFactors	(	const ParticleLayout &	layout,
		const std::vector< Slice > &	slices,
		double	z_ref
	)

private

Definition at line 90 of file ProcessedLayout.cpp.

 {
     double layout_abundance = layout.getTotalAbundance();
     for (const auto* particle : layout.particles()) {
         FormFactorCoherentSum ff_coh = processParticle(*particle, slices, z_ref);
         ff_coh.scaleRelativeAbundance(layout_abundance);
         m_formfactors.emplace_back(ff_coh);
     }
     double weight = layout.weight();
     m_surface_density = weight * layout.totalParticleSurfaceDensity();
     double scale_factor = m_surface_density / layout_abundance;
     ScaleRegionMap(m_region_map, scale_factor);
 }

References ParticleLayout::getTotalAbundance(), m_formfactors, m_region_map, m_surface_density, ParticleLayout::particles(), processParticle(), FormFactorCoherentSum::scaleRelativeAbundance(), ParticleLayout::totalParticleSurfaceDensity(), and ParticleLayout::weight().

Referenced by ProcessedLayout().

Here is the call graph for this function:

◆ formFactorList()

const std::vector< FormFactorCoherentSum > & ProcessedLayout::formFactorList ( ) const

Definition at line 73 of file ProcessedLayout.cpp.

 {
     return m_formfactors;
 }

References m_formfactors.

◆ interferenceFunction()

const IInterferenceFunction * ProcessedLayout::interferenceFunction ( ) const

Definition at line 78 of file ProcessedLayout.cpp.

 {
     return m_iff.get();
 }

References m_iff.

◆ mergeRegionMap()

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

private

Definition at line 142 of file ProcessedLayout.cpp.

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

References m_region_map.

Referenced by processParticle().

◆ numberOfSlices()

size_t ProcessedLayout::numberOfSlices ( ) const

Definition at line 63 of file ProcessedLayout.cpp.

 {
     return m_n_slices;
 }

References m_n_slices.

◆ processParticle()

FormFactorCoherentSum ProcessedLayout::processParticle	(	const IParticle &	particle,
		const std::vector< Slice > &	slices,
		double	z_ref
	)

private

Definition at line 105 of file ProcessedLayout.cpp.

 {
     double abundance = particle.abundance();
     auto sliced_ffs = SlicedFormFactorList::createSlicedFormFactors(particle, slices, z_ref);
     auto region_map = sliced_ffs.regionMap();
     ScaleRegionMap(region_map, abundance);
     mergeRegionMap(region_map);
     auto result = FormFactorCoherentSum(abundance);
     for (size_t i = 0; i < sliced_ffs.size(); ++i) {
         const auto ff_pair = sliced_ffs[i];
         std::unique_ptr<IComputeFF> ff_framework;
         if (slices.size() > 1) {
             if (m_polarized)
                 ff_framework = std::make_unique<ComputeDWBAPol>(*ff_pair.first);
             else
                 ff_framework = std::make_unique<ComputeDWBA>(*ff_pair.first);
         } else {
             if (m_polarized)
                 ff_framework = std::make_unique<ComputeBAPol>(*ff_pair.first);
             else
                 ff_framework = std::make_unique<ComputeBA>(*ff_pair.first);
         }
  
         size_t slice_index = ff_pair.second;
         const Material slice_material = slices[slice_index].material();
         ff_framework->setAmbientMaterial(slice_material);
  
         auto part = FormFactorCoherentPart(ff_framework.release());
         part.setSpecularInfo(m_fresnel_map, slice_index);
  
         result.addCoherentPart(part);
     }
     return result;
 }