Revamp typedefs for RT coefficients and delete copy constructor for ISpecularStrategy

Core/Computation/SpecularComputationTerm.cpp

@@ -69,7 +69,7 @@ void SpecularMatrixTerm::eval(SpecularSimulationElement& elem,
 }
 
 double SpecularMatrixTerm::intensity(const SpecularSimulationElement& elem,
-                                     ISpecularStrategy::single_coeff_t& coeff) const
+                                     const ISpecularStrategy::coefficient_pointer_type& coeff) const
 {
     const auto& polarization = elem.polarizationHandler().getPolarization();
     const auto& analyzer = elem.polarizationHandler().getAnalyzerOperator();

Core/Computation/SpecularComputationTerm.h

@@ -85,7 +85,7 @@ private:
 protected:
     void eval(SpecularSimulationElement& elem, const std::vector<Slice>& slices) const override;
     double intensity(const SpecularSimulationElement& elem,
-                     ISpecularStrategy::single_coeff_t& coeff) const;
+                     const ISpecularStrategy::coefficient_pointer_type& coeff) const;
 };
 
 #endif // BORNAGAIN_CORE_COMPUTATION_SPECULARCOMPUTATIONTERM_H

Core/Multilayer/ISpecularStrategy.h

@@ -29,8 +29,13 @@ class BA_CORE_API_ ISpecularStrategy
 {
 public:
     virtual ~ISpecularStrategy() = default;
-    using single_coeff_t = std::unique_ptr<const ILayerRTCoefficients>;
-    using coeffs_t = std::vector<single_coeff_t>;
+    ISpecularStrategy() = default;
+    ISpecularStrategy& operator=(const ISpecularStrategy& other) = delete;
+    ISpecularStrategy(const ISpecularStrategy& other) = delete;
+
+    using coefficient_type         = ILayerRTCoefficients;
+    using coefficient_pointer_type = std::unique_ptr<const coefficient_type>;
+    using coeffs_t = std::vector<coefficient_pointer_type>;
 
     virtual coeffs_t Execute(const std::vector<Slice>& slices, const kvector_t& k) const = 0;
 

Core/Multilayer/MatrixFresnelMap.cpp

@@ -61,10 +61,10 @@ MatrixFresnelMap::getCoefficients(const kvector_t& kvec, size_t layer_index,
 {
     if (!m_use_cache) {
         auto coeffs = m_Strategy->Execute(slices, kvec);
-        return ISpecularStrategy::single_coeff_t(coeffs[layer_index]->clone());
+        return ISpecularStrategy::coefficient_pointer_type(coeffs[layer_index]->clone());
     }
     const auto& coef_vector = getCoefficientsFromCache(kvec, slices, hash_table);
-    return ISpecularStrategy::single_coeff_t(coef_vector[layer_index]->clone());
+    return ISpecularStrategy::coefficient_pointer_type(coef_vector[layer_index]->clone());
 }
 
 const ISpecularStrategy::coeffs_t&

Core/Multilayer/ScalarFresnelMap.cpp

@@ -44,10 +44,10 @@ ScalarFresnelMap::getCoefficients(const kvector_t& kvec, size_t layer_index) con
 {
     if (!m_use_cache) {
         auto coeffs = m_Strategy->Execute(m_slices, kvec);
-        return ISpecularStrategy::single_coeff_t(coeffs[layer_index]->clone());
+        return ISpecularStrategy::coefficient_pointer_type(coeffs[layer_index]->clone());
     }
     const auto& coef_vector = getCoefficientsFromCache(kvec);
-    return ISpecularStrategy::single_coeff_t(coef_vector[layer_index]->clone());
+    return ISpecularStrategy::coefficient_pointer_type(coef_vector[layer_index]->clone());
 }
 
 const ISpecularStrategy::coeffs_t& ScalarFresnelMap::getCoefficientsFromCache(kvector_t kvec) const

Core/Multilayer/SpecularMagneticStrategy.h

@@ -33,6 +33,10 @@ class Slice;
 class BA_CORE_API_ SpecularMagneticStrategy : public ISpecularStrategy
 {
 public:
+    using coefficient_type         = MatrixRTCoefficients_v2;
+    using coefficient_pointer_type = std::unique_ptr<const coefficient_type>;
+    using coeffs_t                 = std::vector<coefficient_pointer_type>;
+
     //! Computes refraction angle reflection/transmission coefficients
     //! for given sliced multilayer and wavevector k
     ISpecularStrategy::coeffs_t Execute(const std::vector<Slice>& slices, const kvector_t& k) const;
@@ -42,6 +46,7 @@ public:
     ISpecularStrategy::coeffs_t Execute(const std::vector<Slice>& slices,
                                         const std::vector<complex_t>& kz) const;
 
+private:
     static std::vector<MatrixRTCoefficients_v2> computeTR(const std::vector<Slice>& slices,
                                                           const std::vector<complex_t>& kzs);
 

Core/Multilayer/SpecularScalarStrategy.h

@@ -34,6 +34,10 @@ class Slice;
 class BA_CORE_API_ SpecularScalarStrategy : public ISpecularStrategy
 {
 public:
+    using coefficient_type         = ScalarRTCoefficients;
+    using coefficient_pointer_type = std::unique_ptr<const coefficient_type>;
+    using coeffs_t = std::vector<coefficient_pointer_type>;
+
     //! Computes refraction angles and transmission/reflection coefficients
     //! for given coherent wave propagation in a multilayer.
     virtual ISpecularStrategy::coeffs_t Execute(const std::vector<Slice>& slices,