Use weight in computations

Core/Computation/IComputationUtils.cpp

@@ -59,8 +59,8 @@ std::unique_ptr<MultiLayer> CreateAveragedMultilayer(
     return P_multilayer;
 }
 
-std::unique_ptr<MultiLayer> CreateAveragedMultilayer(
-        const MultiLayer& multilayer, const SimulationOptions& sim_options)
+std::unique_ptr<MultiLayer> CreateAveragedMultilayer(const MultiLayer& multilayer,
+                                                     const SimulationOptions& sim_options)
 {
     return CreateAveragedMultilayer(multilayer, sim_options, GetRegionMap(multilayer));
 }
@@ -73,7 +73,8 @@ std::map<size_t, std::vector<HomogeneousRegion>> GetRegionMap(const MultiLayer&
         const Layer* layer = multilayer.layer(i);
         for (auto p_layout : layer->layouts()) {
             double layout_abundance = p_layout->getTotalAbundance();
-            double scale_factor = p_layout->totalParticleSurfaceDensity()/layout_abundance;
+            double weight = p_layout->weight();
+            double scale_factor = weight*p_layout->totalParticleSurfaceDensity()/layout_abundance;
             for (const IParticle* particle: p_layout->particles()) {
                 auto sliced_ffs = SlicedFormFactorList::CreateSlicedFormFactors(
                                       *particle, multilayer, i);

Core/Computation/ParticleLayoutComputation.cpp

@@ -23,16 +23,19 @@
 #include "ProgressHandler.h"
 #include "SimulationElement.h"
 
-ParticleLayoutComputation::ParticleLayoutComputation(
-        const MultiLayer* p_multilayer, const IFresnelMap* p_fresnel_map, const ILayout* p_layout,
-        size_t layer_index, const SimulationOptions& options, bool polarized)
+ParticleLayoutComputation::ParticleLayoutComputation(const MultiLayer* p_multilayer,
+                                                     const IFresnelMap* p_fresnel_map,
+                                                     const ILayout* p_layout, size_t layer_index,
+                                                     const SimulationOptions& options,
+                                                     bool polarized)
     : m_multilayer_info(p_multilayer, p_fresnel_map)
 {
-    LayoutStrategyBuilder builder(p_multilayer, p_layout, p_fresnel_map,
-                                  polarized, options, layer_index);
+    LayoutStrategyBuilder builder(p_multilayer, p_layout, p_fresnel_map, polarized, options,
+                                  layer_index);
     mP_strategy.reset(builder.releaseStrategy());
     m_region_map = builder.regionMap();
-    m_surface_density = p_layout->totalParticleSurfaceDensity();
+    double weight = p_layout->weight();
+    m_surface_density = weight * p_layout->totalParticleSurfaceDensity();
 }
 
 ParticleLayoutComputation::~ParticleLayoutComputation() =default;

Core/Multilayer/LayoutStrategyBuilder.cpp

@@ -100,12 +100,13 @@ SafePointerVector<class FormFactorCoherentSum> LayoutStrategyBuilder::collectFor
 {
     SafePointerVector<class FormFactorCoherentSum> result;
     double layout_abundance = mp_layout->getTotalAbundance();
-    for (const IParticle* particle: mp_layout->particles()) {
+    for (const IParticle* particle : mp_layout->particles()) {
         auto p_ff_coh = createFormFactorCoherentSum(particle);
         p_ff_coh->scaleRelativeAbundance(layout_abundance);
         result.push_back(p_ff_coh);
     }
-    double scale_factor = mp_layout->totalParticleSurfaceDensity()/layout_abundance;
+    double weight = mp_layout->weight();
+    double scale_factor = weight * mp_layout->totalParticleSurfaceDensity() / layout_abundance;
     ScaleRegionMap(m_region_map, scale_factor);
     return result;
 }