IComputeFF: rm clone fct, and don't clone when initializing

Resample/FFCompute/ComputeBA.cpp

@@ -17,15 +17,11 @@
 #include "Resample/Element/DiffuseElement.h"
 #include "Sample/Scattering/IFormFactor.h"
 
-ComputeBA::ComputeBA(const IFormFactor& ff, size_t i_layer) : IComputeScalar(ff, i_layer) {}
+ComputeBA::ComputeBA(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer)
+    : IComputeScalar(std::move(ff), i_layer) {}
 
 ComputeBA::~ComputeBA() = default;
 
-ComputeBA* ComputeBA::clone() const
-{
-    return new ComputeBA(*m_ff, m_i_layer);
-}
-
 complex_t ComputeBA::coherentFF(const DiffuseElement& ele) const
 {
     const WavevectorInfo& wavevectors = ele.wavevectorInfo();

Resample/FFCompute/ComputeBA.h

@@ -27,11 +27,9 @@
 
 class ComputeBA : public IComputeScalar {
 public:
-    ComputeBA(const IFormFactor& ff, size_t i_layer);
+    ComputeBA(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer);
     ~ComputeBA() override;
 
-    ComputeBA* clone() const override;
-
     //! Calculates and returns a form factor calculation in BA
     complex_t coherentFF(const DiffuseElement& ele) const override;
 };

Resample/FFCompute/ComputeBAPol.cpp

@@ -17,15 +17,11 @@
 #include "Resample/Element/DiffuseElement.h"
 #include "Sample/Scattering/IFormFactor.h"
 
-ComputeBAPol::ComputeBAPol(const IFormFactor& ff, size_t i_layer) : IComputePol(ff, i_layer) {}
+ComputeBAPol::ComputeBAPol(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer)
+    : IComputePol(std::move(ff), i_layer) {}
 
 ComputeBAPol::~ComputeBAPol() = default;
 
-ComputeBAPol* ComputeBAPol::clone() const
-{
-    return new ComputeBAPol(*m_ff, m_i_layer);
-}
-
 Eigen::Matrix2cd ComputeBAPol::coherentPolFF(const DiffuseElement& ele) const
 {
     Eigen::Matrix2cd ff_BA = m_ff->thePolFF(ele.wavevectorInfo());

Resample/FFCompute/ComputeBAPol.h

@@ -27,11 +27,9 @@
 
 class ComputeBAPol : public IComputePol {
 public:
-    ComputeBAPol(const IFormFactor& ff, size_t i_layer);
+    ComputeBAPol(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer);
     ~ComputeBAPol() override;
 
-    ComputeBAPol* clone() const override;
-
     //! Calculates and returns a polarized form factor calculation in BA
     Eigen::Matrix2cd coherentPolFF(const DiffuseElement& ele) const override;
 };

Resample/FFCompute/ComputeDWBA.cpp

@@ -19,15 +19,11 @@
 #include "Resample/Flux/ScalarFlux.h"
 #include "Sample/Scattering/IFormFactor.h"
 
-ComputeDWBA::ComputeDWBA(const IFormFactor& ff, size_t i_layer) : IComputeScalar(ff, i_layer) {}
+ComputeDWBA::ComputeDWBA(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer)
+    : IComputeScalar(std::move(ff), i_layer) {}
 
 ComputeDWBA::~ComputeDWBA() = default;
 
-ComputeDWBA* ComputeDWBA::clone() const
-{
-    return new ComputeDWBA(*m_ff, m_i_layer);
-}
-
 complex_t ComputeDWBA::coherentFF(const DiffuseElement& ele) const
 {
     const WavevectorInfo& wavevectors = ele.wavevectorInfo();

Resample/FFCompute/ComputeDWBA.h

@@ -29,11 +29,9 @@ class IFlux;
 
 class ComputeDWBA : public IComputeScalar {
 public:
-    ComputeDWBA(const IFormFactor& ff, size_t i_layer);
+    ComputeDWBA(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer);
     ~ComputeDWBA() override;
 
-    ComputeDWBA* clone() const override;
-
     //! Returns the coherent sum of the four DWBA terms for scalar scattering.
     complex_t coherentFF(const DiffuseElement& ele) const override;
 

Resample/FFCompute/ComputeDWBAPol.cpp

@@ -30,15 +30,11 @@ complex_t VecMatVecProduct(const Eigen::Vector2cd& vec1, const Eigen::Matrix2cd&
 } // namespace
 
 
-ComputeDWBAPol::ComputeDWBAPol(const IFormFactor& ff, size_t i_layer) : IComputePol(ff, i_layer) {}
+ComputeDWBAPol::ComputeDWBAPol(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer)
+    : IComputePol(std::move(ff), i_layer) {}
 
 ComputeDWBAPol::~ComputeDWBAPol() = default;
 
-ComputeDWBAPol* ComputeDWBAPol::clone() const
-{
-    return new ComputeDWBAPol(*m_ff, m_i_layer);
-}
-
 Eigen::Matrix2cd ComputeDWBAPol::coherentPolFF(const DiffuseElement& ele) const
 {
     const WavevectorInfo& wavevectors = ele.wavevectorInfo();

Resample/FFCompute/ComputeDWBAPol.h

@@ -27,11 +27,9 @@
 
 class ComputeDWBAPol : public IComputePol {
 public:
-    ComputeDWBAPol(const IFormFactor& ff, size_t i_layer);
+    ComputeDWBAPol(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer);
     ~ComputeDWBAPol() override;
 
-    ComputeDWBAPol* clone() const override;
-
     //! Returns the coherent sum of the four DWBA terms for polarized scattering.
     Eigen::Matrix2cd coherentPolFF(const DiffuseElement& ele) const override;
 

Resample/FFCompute/IComputeFF.cpp

@@ -15,7 +15,8 @@
 #include "Resample/FFCompute/IComputeFF.h"
 #include "Sample/Scattering/IFormFactor.h"
 
-IComputeFF::IComputeFF(const IFormFactor& ff, size_t i_layer) : m_ff(ff.clone()), m_i_layer(i_layer)
+IComputeFF::IComputeFF(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer)
+    : m_ff(std::move(ff)), m_i_layer(i_layer)
 {
 }
 

Resample/FFCompute/IComputeFF.h

@@ -35,7 +35,6 @@ class WavevectorInfo; // used by all children
 class IComputeFF {
 public:
     virtual ~IComputeFF();
-    virtual IComputeFF* clone() const = 0;
 
     size_t iLayer() const { return m_i_layer; }
 
@@ -44,7 +43,7 @@ public:
     double topZ(const IRotation& rotation) const;
 
 protected:
-    IComputeFF(const IFormFactor& ff, size_t i_layer);
+    IComputeFF(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer);
 
     const std::unique_ptr<const IFormFactor> m_ff;
     const size_t m_i_layer;

Resample/FFCompute/IComputePol.h

@@ -32,7 +32,8 @@ public:
     virtual Eigen::Matrix2cd coherentPolFF(const DiffuseElement& ele) const = 0;
 
 protected:
-    IComputePol(const IFormFactor& ff, size_t i_layer) : IComputeFF(ff, i_layer) {}
+    IComputePol(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer)
+        : IComputeFF(std::move(ff), i_layer) {}
 };
 
 #endif // BORNAGAIN_RESAMPLE_FFCOMPUTE_ICOMPUTEPOL_H

Resample/FFCompute/IComputeScalar.h

@@ -34,7 +34,8 @@ public:
     virtual complex_t coherentFF(const DiffuseElement& sim_element) const = 0;
 
 protected:
-    IComputeScalar(const IFormFactor& ff, size_t i_layer) : IComputeFF(ff, i_layer) {}
+    IComputeScalar(std::unique_ptr<const IFormFactor>&& ff, size_t i_layer)
+        : IComputeFF(std::move(ff), i_layer) {}
 };
 
 #endif // BORNAGAIN_RESAMPLE_FFCOMPUTE_ICOMPUTESCALAR_H

Resample/Processed/ProcessedLayout.cpp

@@ -192,21 +192,21 @@ CoherentFFSum ProcessedLayout::processParticle(const IParticle& particle, const
         const auto& pair = tmp_ff_list.at(i);
         const size_t i_layer = pair.second;
         const Material& material = slices[i_layer].material();
-        const std::unique_ptr<IFormFactor> ff(pair.first->clone());
+        std::unique_ptr<IFormFactor> ff(pair.first->clone());
         ff->setAmbientMaterial(material);
 
         std::unique_ptr<IComputeFF> computer;
         if (slices.size() > 1) {
             if (m_polarized)
-                computer = std::make_unique<ComputeDWBAPol>(*ff, i_layer);
+                computer = std::make_unique<ComputeDWBAPol>(std::move(ff), i_layer);
             else
-                computer = std::make_unique<ComputeDWBA>(*ff, i_layer);
+                computer = std::make_unique<ComputeDWBA>(std::move(ff), i_layer);
         } else {
             // no need for DWBA, use BA
             if (m_polarized)
-                computer = std::make_unique<ComputeBAPol>(*ff, i_layer);
+                computer = std::make_unique<ComputeBAPol>(std::move(ff), i_layer);
             else
-                computer = std::make_unique<ComputeBA>(*ff, i_layer);
+                computer = std::make_unique<ComputeBA>(std::move(ff), i_layer);
         }
         terms.emplace_back(computer.release());
     }

Tests/UnitTests/Core/Sample/FormFactorCoherentSumTest.cpp

@@ -8,8 +8,8 @@ class CoherentFFSumTest : public ::testing::Test {
 
 TEST_F(CoherentFFSumTest, RelAbundance)
 {
-    FormFactorFullSphere ff(5.0);
-    std::shared_ptr<const IComputeFF> part(new ComputeBA(ff, 0));
+    auto ff = std::make_unique<FormFactorFullSphere>(5.0);
+    std::shared_ptr<const IComputeFF> part(new ComputeBA(std::move(ff), 0));
     CoherentFFSum ffw(1.0, {part});
     EXPECT_EQ(1.0, ffw.relativeAbundance());
     EXPECT_EQ(5.0, ffw.radialExtension());