Fixes

Core/Computation/DWBAComputation.cpp

@@ -31,11 +31,15 @@ static_assert(std::is_copy_assignable<DWBAComputation>::value == false,
 DWBAComputation::DWBAComputation(const MultiLayer& multilayer, const SimulationOptions& options,
                                  ProgressHandler& progress,
                                  std::vector<SimulationElement>::iterator begin_it,
-                                 std::vector<SimulationElement>::iterator end_it)
-    : IComputation(multilayer, options, progress), m_begin_it(begin_it), m_end_it(end_it)
+                                 std::vector<SimulationElement>::iterator end_it,
+                                 bool forcePolarized)
+    : IComputation(multilayer, options, progress, forcePolarized)
+    , m_begin_it(begin_it)
+    , m_end_it(end_it)
 {
     const IFresnelMap* p_fresnel_map = m_processed_sample->fresnelMap();
-    bool polarized = m_processed_sample->containsMagneticMaterial();
+    bool polarized = m_processed_sample->containsMagneticMaterial() || forcePolarized;
+
     for (const ProcessedLayout& layout : m_processed_sample->layouts()) {
         m_single_computation.addLayoutComputation(
             new ParticleLayoutComputation(layout, m_sim_options, polarized));

Core/Computation/DWBAComputation.h

@@ -36,7 +36,7 @@ class DWBAComputation : public IComputation {
 public:
     DWBAComputation(const MultiLayer& multilayer, const SimulationOptions& options,
                     ProgressHandler& progress, std::vector<SimulationElement>::iterator begin_it,
-                    std::vector<SimulationElement>::iterator end_it);
+                    std::vector<SimulationElement>::iterator end_it, bool forcePolarized=false);
     ~DWBAComputation() override;
 
 private:

Core/Computation/IComputation.cpp

@@ -19,10 +19,10 @@
 #include "Sample/Processed/ProcessedSample.h"
 
 IComputation::IComputation(const MultiLayer& sample, const SimulationOptions& options,
-                           ProgressHandler& progress)
+                           ProgressHandler& progress, bool forcePolarized)
     : m_sim_options(options)
     , m_progress(&progress)
-    , m_processed_sample(std::make_unique<ProcessedSample>(sample, options))
+    , m_processed_sample(std::make_unique<ProcessedSample>(sample, options, forcePolarized))
 {
 }
 

Core/Computation/IComputation.h

@@ -39,7 +39,7 @@ class ProgressHandler;
 class IComputation {
 public:
     IComputation(const MultiLayer& sample, const SimulationOptions& options,
-                 ProgressHandler& progress);
+                 ProgressHandler& progress, bool forcePolarized=false);
     virtual ~IComputation();
 
     void run();

Core/Computation/SpecularComputation.cpp

@@ -27,11 +27,13 @@ static_assert(std::is_copy_assignable<SpecularComputation>::value == false,
 SpecularComputation::SpecularComputation(const MultiLayer& multilayer,
                                          const SimulationOptions& options,
                                          ProgressHandler& progress, SpecularElementIter begin_it,
-                                         SpecularElementIter end_it)
+                                         SpecularElementIter end_it, bool forcePolarized)
     : IComputation(multilayer, options, progress), m_begin_it(begin_it), m_end_it(end_it)
 {
     if (m_processed_sample->containsMagneticMaterial()
-        || m_processed_sample->externalField() != kvector_t{})
+        || m_processed_sample->externalField() != kvector_t{}
+        || forcePolarized)
+
         m_computation_term.reset(
             new SpecularMatrixTerm(SpecularStrategyBuilder::build(multilayer, true)));
     else

Core/Computation/SpecularComputation.h

@@ -38,7 +38,7 @@ class SpecularComputation : public IComputation {
 public:
     SpecularComputation(const MultiLayer& multilayer, const SimulationOptions& options,
                         ProgressHandler& progress, SpecularElementIter begin_it,
-                        SpecularElementIter end_it);
+                        SpecularElementIter end_it, bool forcePolarized=false);
     ~SpecularComputation() override;
 
 private:

Core/Simulation/ISimulation2D.cpp

@@ -102,8 +102,10 @@ std::unique_ptr<IComputation> ISimulation2D::generateSingleThreadedComputation(s
 {
     ASSERT(start < m_sim_elements.size() && start + n_elements <= m_sim_elements.size());
     const auto& begin = m_sim_elements.begin() + static_cast<long>(start);
+    const auto polarized =
+        this->detector().detectionProperties().analyzerDirection() != kvector_t{};
     return std::make_unique<DWBAComputation>(*sample(), options(), progress(), begin,
-                                             begin + static_cast<long>(n_elements));
+                                             begin + static_cast<long>(n_elements), polarized);
 }
 
 std::vector<SimulationElement> ISimulation2D::generateSimulationElements(const Beam& beam)

Sample/Processed/ProcessedSample.cpp

@@ -108,10 +108,11 @@ std::vector<ZLimits> particleRegions(const MultiLayer& multilayer, bool use_slic
 //  class ProcessedSample
 //  ************************************************************************************************
 
-ProcessedSample::ProcessedSample(const MultiLayer& sample, const SimulationOptions& options)
+ProcessedSample::ProcessedSample(const MultiLayer& sample, const SimulationOptions& options,
+                                 bool forcePolarized)
     : m_slices{}
     , m_top_z{0.0}
-    , m_polarized{false}
+    , m_polarized{forcePolarized}
     , m_crossCorrLength{sample.crossCorrLength()}
     , m_ext_field{sample.externalField()}
 {
@@ -277,7 +278,8 @@ void ProcessedSample::initSlices(const MultiLayer& sample, const SimulationOptio
 void ProcessedSample::initLayouts(const MultiLayer& sample)
 {
     double z_ref = -m_top_z;
-    m_polarized = sample.isMagnetic();
+    m_polarized = m_polarized || sample.isMagnetic();
+
     for (size_t i = 0; i < sample.numberOfLayers(); ++i) {
         if (i > 1)
             z_ref -= sample.layer(i - 1)->thickness();

Sample/Processed/ProcessedSample.h

@@ -41,7 +41,8 @@ class SimulationOptions;
 
 class ProcessedSample {
 public:
-    ProcessedSample(const MultiLayer& sample, const SimulationOptions& options);
+    ProcessedSample(const MultiLayer& sample, const SimulationOptions& options,
+                    bool forcePolarized = false);
     ~ProcessedSample();
 
     size_t numberOfSlices() const;