Hide concrete type returned by SpecularMagneticStrategy

Core/Computation/SpecularComputationTerm.cpp

@@ -16,7 +16,6 @@
 #include "DelayedProgressCounter.h"
 #include "ScalarRTCoefficients.h"
 #include "SpecularScalarStrategy.h"
-#include "SpecularMagneticStrategy.h"
 #include "SpecularSimulationElement.h"
 
 SpecularComputationTerm::SpecularComputationTerm() = default;
@@ -59,7 +58,7 @@ void SpecularMatrixTerm::eval(SpecularSimulationElement& elem,
 }
 
 double SpecularMatrixTerm::intensity(const SpecularSimulationElement& elem,
-                                     std::unique_ptr<MatrixRTCoefficients_v2>& coeff) const
+                                     SpecularMagneticStrategy::single_coeff_t& coeff) const
 {
     const auto& polarization = elem.polarizationHandler().getPolarization();
     const auto& analyzer = elem.polarizationHandler().getAnalyzerOperator();

Core/Computation/SpecularComputationTerm.h

@@ -15,6 +15,8 @@
 #ifndef SPECULARCOMPUTATIONTERM_H_
 #define SPECULARCOMPUTATIONTERM_H_
 
+#include "SpecularMagneticStrategy.h"
+
 #include <memory>
 #include <vector>
 
@@ -57,7 +59,7 @@ class SpecularMatrixTerm : public SpecularComputationTerm
 protected:
     void eval(SpecularSimulationElement& elem, const std::vector<Slice>& slices) const override;
     double intensity(const SpecularSimulationElement& elem,
-                     std::unique_ptr<MatrixRTCoefficients_v2>& coeff) const;
+                     SpecularMagneticStrategy::single_coeff_t& coeff) const;
 };
 
 #endif /* SPECULARCOMPUTATIONTERM_H_ */

Core/Multilayer/MatrixFresnelMap.cpp

@@ -80,19 +80,19 @@ MatrixFresnelMap::getCoefficients(const kvector_t& kvec, size_t layer_index,
                                   const std::vector<Slice>& slices, CoefficientHash& hash_table) const
 {
     if (!m_use_cache) {
-        auto coeffs = computeRT<RTCoefficients>(slices, kvec);
-        return std::unique_ptr<RTCoefficients>(coeffs[layer_index]->clone());
+        auto coeffs = computeRT<MatrixRTCoefficients_v2>(slices, kvec);
+        return SpecularMagneticStrategy::single_coeff_t(coeffs[layer_index]->clone());
     }
     const auto& coef_vector = getCoefficientsFromCache(kvec, slices, hash_table);
-    return std::unique_ptr<RTCoefficients>(coef_vector[layer_index]->clone());
+    return SpecularMagneticStrategy::single_coeff_t(coef_vector[layer_index]->clone());
 }
 
-const std::vector<std::unique_ptr<MatrixFresnelMap::RTCoefficients>>&
+const SpecularMagneticStrategy::coeffs_t&
 MatrixFresnelMap::getCoefficientsFromCache(kvector_t kvec, const std::vector<Slice>& slices,
                                            MatrixFresnelMap::CoefficientHash& hash_table) const
 {
     auto it = hash_table.find(kvec);
     if (it == hash_table.end())
-        it = hash_table.insert({kvec, computeRT<RTCoefficients>(slices, kvec)}).first;
+        it = hash_table.insert({kvec, computeRT<MatrixRTCoefficients_v2>(slices, kvec)}).first;
     return it->second;
 }

Core/Multilayer/MatrixFresnelMap.h

@@ -18,6 +18,7 @@
 #include "IFresnelMap.h"
 #include "MatrixRTCoefficients.h"
 #include "MatrixRTCoefficients_v2.h"
+#include "SpecularMagneticStrategy.h"
 #include <cstddef>
 #include <memory>
 #include <unordered_map>
@@ -34,8 +35,6 @@ class SimulationElement;
 class BA_CORE_API_ MatrixFresnelMap : public IFresnelMap
 {
 public:
-    using RTCoefficients = MatrixRTCoefficients_v2;
-
     MatrixFresnelMap();
     ~MatrixFresnelMap() override;
 
@@ -53,7 +52,7 @@ private:
         size_t operator()(const kvector_t& kvec) const noexcept;
     };
 
-    using CoefficientHash = std::unordered_map<kvector_t, std::vector<std::unique_ptr<RTCoefficients>>, HashKVector>;
+    using CoefficientHash = std::unordered_map<kvector_t, SpecularMagneticStrategy::coeffs_t, HashKVector>;
 
     std::unique_ptr<const ILayerRTCoefficients> getCoefficients(const kvector_t& kvec,
                                                                 size_t layer_index) const override;
@@ -65,7 +64,7 @@ private:
     mutable CoefficientHash m_hash_table_out;
     mutable CoefficientHash m_hash_table_in;
 
-    const std::vector<std::unique_ptr<MatrixFresnelMap::RTCoefficients>>&
+    const SpecularMagneticStrategy::coeffs_t&
     getCoefficientsFromCache(kvector_t kvec, const std::vector<Slice>& slices,
                              CoefficientHash& hash_table) const;
 };

Core/Multilayer/SpecularMagneticStrategy.cpp

@@ -29,21 +29,19 @@ constexpr double magnetic_prefactor = PhysConsts::m_n * PhysConsts::g_factor_n *
 constexpr complex_t I(0.0, 1.0);
 }
 
-std::vector<std::unique_ptr<MatrixRTCoefficients_v2>>
-SpecularMagneticStrategy::Execute(const std::vector<Slice>& slices,
-                                  const kvector_t& k) const
+SpecularMagneticStrategy::coeffs_t
+SpecularMagneticStrategy::Execute(const std::vector<Slice>& slices, const kvector_t& k) const
 {
     return Execute(slices, KzComputation::computeReducedKz(slices, k));
 }
 
-std::vector<std::unique_ptr<MatrixRTCoefficients_v2>>
-SpecularMagneticStrategy::Execute(const std::vector<Slice>& slices,
-                                  const std::vector<complex_t>& kz) const
+SpecularMagneticStrategy::coeffs_t
+SpecularMagneticStrategy::Execute(const std::vector<Slice>& slices, const std::vector<complex_t>& kz) const
 {
     if(slices.size() != kz.size())
         throw std::runtime_error("Number of slices does not match the size of the kz-vector");
 
-    std::vector<std::unique_ptr<MatrixRTCoefficients_v2>> result;
+    SpecularMagneticStrategy::coeffs_t result;
     for(auto& coeff : computeTR(slices, kz))
         result.push_back( std::make_unique<MatrixRTCoefficients_v2>(coeff) );
 

Core/Multilayer/SpecularMagneticStrategy.h

@@ -28,14 +28,17 @@ class Slice;
 class BA_CORE_API_ SpecularMagneticStrategy
 {
 public:
+    typedef std::unique_ptr<const MatrixRTCoefficients_v2> single_coeff_t;
+    typedef std::vector<single_coeff_t> coeffs_t;
+
     //! Computes refraction angle reflection/transmission coefficients
     //! for given sliced multilayer and wavevector k
-    std::vector<std::unique_ptr<MatrixRTCoefficients_v2>>
+    coeffs_t
     Execute(const std::vector<Slice>& slices, const kvector_t& k) const;
 
     //! Computes refraction angle reflection/transmission coefficients
     //! for given sliced multilayer and a set of kz projections corresponding to each slice
-    std::vector<std::unique_ptr<MatrixRTCoefficients_v2>>
+    coeffs_t
     Execute(const std::vector<Slice>& slices, const std::vector<complex_t>& kz) const;
 
     static std::vector<MatrixRTCoefficients_v2> computeTR(const std::vector<Slice>& slices,