looks worse, but prepares for removal of ISimulation inheritance

Core/Computation/DecoratedLayerComputation.cpp

@@ -21,7 +21,6 @@
 #include "LayerStrategyBuilder.h"
 #include "Logger.h"
 #include "MultiLayer.h"
-#include "Simulation.h"
 #include "SimulationElement.h"
 
 DecoratedLayerComputation::DecoratedLayerComputation(const Layer* p_layer, size_t layout_index)
@@ -36,14 +35,19 @@ DecoratedLayerComputation::~DecoratedLayerComputation()
     delete mp_specular_info;
 }
 
-void DecoratedLayerComputation::run()
+void DecoratedLayerComputation::eval(
+    bool polarized,
+    const MultiLayer& sample,
+    std::vector<SimulationElement>::iterator begin_it,
+    std::vector<SimulationElement>::iterator end_it)
 {
-    const std::unique_ptr<const IInterferenceFunctionStrategy>
-        p_strategy(createAndInitStrategy());
+    LayerStrategyBuilder builder(*mp_layer, sample, m_sim_options, m_layout_index);
+    assert(mp_specular_info);
+    builder.setRTInfo(*mp_specular_info);
+    const std::unique_ptr<const IInterferenceFunctionStrategy> p_strategy(builder.createStrategy());
     double total_surface_density = mp_layer->getTotalParticleSurfaceDensity(m_layout_index);
-    bool polarization_present = mp_simulation->getSample()->containsMagneticMaterial();
 
-    for (std::vector<SimulationElement>::iterator it = m_begin_it; it != m_end_it; ++it) {
+    for (std::vector<SimulationElement>::iterator it = begin_it; it != end_it; ++it) {
         if (!m_progress.update())
             break;
         double alpha_f = it->getAlphaMean();
@@ -51,7 +55,7 @@ void DecoratedLayerComputation::run()
         if (n_layers > 1 && alpha_f < 0)
             continue;
         // each ffdwba: one call to getOutCoeffs
-        if (polarization_present)
+        if (polarized)
             it->setIntensity(p_strategy->evaluatePol(*it) * total_surface_density);
         else
             it->setIntensity(p_strategy->evaluate(*it) * total_surface_density);
@@ -59,16 +63,6 @@ void DecoratedLayerComputation::run()
     m_progress.finished();
 }
 
-IInterferenceFunctionStrategy* DecoratedLayerComputation::createAndInitStrategy() const
-{
-    LayerStrategyBuilder builder(*mp_layer, *mp_simulation->getSample(),
-                                 m_sim_options, m_layout_index);
-    assert(mp_specular_info);
-    builder.setRTInfo(*mp_specular_info);
-    IInterferenceFunctionStrategy* p_strategy = builder.createStrategy();
-    return p_strategy;
-}
-
 void DecoratedLayerComputation::setSpecularInfo(const LayerSpecularInfo& specular_info)
 {
     if (mp_specular_info != &specular_info) {

Core/Computation/DecoratedLayerComputation.h

@@ -21,6 +21,7 @@
 class IInterferenceFunctionStrategy;
 class Layer;
 class LayerSpecularInfo;
+class MultiLayer;
 
 //! Computes the scattering contribution from one layer with particles in/on it.
 //! Controlled by MainComputation.
@@ -32,12 +33,13 @@ public:
     DecoratedLayerComputation(const Layer* p_layer, size_t layout_index=0);
     ~DecoratedLayerComputation() final;
 
-    void run() final;
+    void eval(bool polarized,
+              const MultiLayer& sample,
+              std::vector<SimulationElement>::iterator begin_it,
+              std::vector<SimulationElement>::iterator end_it);
     void setSpecularInfo(const LayerSpecularInfo& specular_info);
 
 private:
-    IInterferenceFunctionStrategy* createAndInitStrategy() const;
-
     Layer* mp_layer;
     LayerSpecularInfo* mp_specular_info;
     size_t m_layout_index;

Core/Computation/MainComputation.cpp

@@ -25,6 +25,7 @@
 #include "MultiLayer.h"
 #include "RoughMultiLayerComputation.h"
 #include "ScalarSpecularInfoMap.h"
+#include "Simulation.h"
 #include "SimulationElement.h"
 #include "SpecularMagnetic.h"
 #include "SpecularMatrix.h"
@@ -96,10 +97,12 @@ void MainComputation::runProtected()
     // run through layers and run layer simulations
     std::vector<SimulationElement> layer_elements;
     std::copy(m_begin_it, m_end_it, std::back_inserter(layer_elements));
+    bool polarized = mp_simulation->getSample()->containsMagneticMaterial();
     for (auto& layer_comp: m_layer_computation) {
         for (DecoratedLayerComputation* comp: layer_comp) {
             comp->init(m_sim_options, *mp_simulation, layer_elements.begin(), layer_elements.end());
-            comp->run();
+            comp->eval(polarized, *mp_simulation->getSample(),
+                       layer_elements.begin(), layer_elements.end());
             addElementsWithWeight(layer_elements.begin(), layer_elements.end(), m_begin_it, 1.0);
         }
     }