Enable SpecularStrategyBuilder

Core/Computation/ProcessedSample.cpp

@@ -24,12 +24,12 @@
 #include "ScalarFresnelMap.h"
 #include "SimulationOptions.h"
 #include "Slice.h"
-#include "SpecularScalarStrategy.h"
-#include "SpecularMagneticStrategy.h"
+#include "SpecularStrategyBuilder.h"
 
 namespace
 {
-std::unique_ptr<IFresnelMap> CreateFresnelMap(const std::vector<Slice>& slices,
+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);
@@ -44,7 +44,7 @@ ProcessedSample::ProcessedSample(const MultiLayer& sample, const SimulationOptio
       m_ext_field{sample.externalField()}
 {
     initSlices(sample, options);
-    mP_fresnel_map = CreateFresnelMap(m_slices, options);
+    mP_fresnel_map = CreateFresnelMap(sample, m_slices, options);
     initBFields();
     initLayouts(sample);
     initFresnelMap(options);
@@ -279,14 +279,15 @@ void ProcessedSample::initFresnelMap(const SimulationOptions& sim_options)
 
 namespace
 {
-std::unique_ptr<IFresnelMap> CreateFresnelMap(const std::vector<Slice>& slices,
+std::unique_ptr<IFresnelMap> CreateFresnelMap(const MultiLayer& sample,
+                                              const std::vector<Slice>& slices,
                                               const SimulationOptions& options)
 {
     std::unique_ptr<IFresnelMap> P_result;
     if (ContainsMagneticSlice(slices))
-        P_result.reset(new MatrixFresnelMap(std::make_unique<SpecularMagneticStrategy>()));
+        P_result.reset(new MatrixFresnelMap(SpecularStrategyBuilder::build(sample, true)));
     else
-        P_result.reset(new ScalarFresnelMap(std::make_unique<SpecularScalarStrategy>()));
+        P_result.reset(new ScalarFresnelMap(SpecularStrategyBuilder::build(sample, false)));
     if (options.isIntegrate())
         P_result->disableCaching();
     return P_result;

Core/Computation/SpecularComputation.cpp

@@ -16,9 +16,8 @@
 #include "MultiLayer.h"
 #include "ProcessedSample.h"
 #include "ProgressHandler.h"
-#include "SpecularScalarStrategy.h"
-#include "SpecularMagneticStrategy.h"
 #include "SpecularSimulationElement.h"
+#include "SpecularStrategyBuilder.h"
 
 static_assert(std::is_copy_constructible<SpecularComputation>::value == false,
               "SpecularComputation should not be copy constructible");
@@ -35,9 +34,9 @@ SpecularComputation::SpecularComputation(const MultiLayer& multilayer,
 {
     if (mP_processed_sample->containsMagneticMaterial()
         || mP_processed_sample->externalField() != kvector_t{})
-        m_computation_term.reset(new SpecularMatrixTerm(std::make_unique<SpecularMagneticStrategy>()));
+        m_computation_term.reset(new SpecularMatrixTerm(SpecularStrategyBuilder::build(multilayer, true)));
     else
-        m_computation_term.reset(new SpecularScalarTerm(std::make_unique<SpecularScalarStrategy>()));
+        m_computation_term.reset(new SpecularScalarTerm(SpecularStrategyBuilder::build(multilayer, false)));
 }
 
 SpecularComputation::~SpecularComputation() = default;