Merge pull request #1032 from jwuttke/ref2

Core: implement clone() without copy constructor, and similar refactorings

CHANGELOG

@@ -7,6 +7,7 @@ BornAgain-1.17.99, work in progress
        (Lorentz, Debye-Bueche, Ornstein-Zernike)
     5) Removed default argument values from node constructors
     6) Swap order of arguments gamma and eta in 2D decay and distribution Voigt functions
+    7) FormFactorSphereLogNormalRadius is now positioned at center, not at bottom
   > Changes in build configuration:
     1) Python2 no longer supported
     2) OpenGL can no longer be deselected

Core/Aggregate/IInterferenceFunction.cpp

@@ -17,15 +17,16 @@
 #include <algorithm>
 #include <stdexcept>
 
-IInterferenceFunction::IInterferenceFunction() : m_position_var{0.0}
+IInterferenceFunction::IInterferenceFunction(const NodeMeta& meta,
+                                             const std::vector<double>& PValues)
+    : ISample(meta, PValues)
 {
-    init_parameters();
+    registerParameter("PositionVariance", &m_position_var).setUnit("nm^2").setNonnegative();
 }
 
-IInterferenceFunction::IInterferenceFunction(const IInterferenceFunction& other)
-    : m_position_var(other.m_position_var)
+IInterferenceFunction::IInterferenceFunction(double position_var) : m_position_var(position_var)
 {
-    init_parameters();
+    registerParameter("PositionVariance", &m_position_var).setUnit("nm^2").setNonnegative();
 }
 
 IInterferenceFunction::~IInterferenceFunction() = default;
@@ -58,8 +59,3 @@ double IInterferenceFunction::iff_no_inner(const kvector_t q, double outer_iff)
 {
     return DWfactor(q) * (iff_without_dw(q) * outer_iff - 1.0) + 1.0;
 }
-
-void IInterferenceFunction::init_parameters()
-{
-    registerParameter("PositionVariance", &m_position_var).setUnit("nm^2").setNonnegative();
-}

Core/Aggregate/IInterferenceFunction.h

@@ -24,8 +24,8 @@
 class BA_CORE_API_ IInterferenceFunction : public ISample
 {
 public:
-    IInterferenceFunction();
-    IInterferenceFunction(const IInterferenceFunction& other);
+    IInterferenceFunction(const NodeMeta& meta, const std::vector<double>& PValues);
+    IInterferenceFunction(double position_var);
     virtual ~IInterferenceFunction();
 
     virtual IInterferenceFunction* clone() const = 0;
@@ -57,8 +57,6 @@ protected:
     //! Calculates the structure factor without Debye-Waller factor
     virtual double iff_without_dw(const kvector_t q) const = 0;
 
-private:
-    void init_parameters();
     double m_position_var;
 };
 

Core/Aggregate/InterferenceFunction1DLattice.cpp

@@ -13,11 +13,11 @@
 // ************************************************************************** //
 
 #include "Core/Aggregate/InterferenceFunction1DLattice.h"
-#include "Core/Aggregate/FTDecay1D.h"
-#include "Core/Aggregate/FTDecay2D.h"
 #include "Core/Basics/Assert.h"
 #include "Core/Basics/Exceptions.h"
 #include "Core/Basics/MathConstants.h"
+#include "Core/Correlations/FTDecay1D.h"
+#include "Core/Correlations/FTDecay2D.h"
 #include "Core/Parametrization/RealParameter.h"
 #include <algorithm>
 
@@ -33,7 +33,7 @@ static const int min_points = 4;
 //! @param length: lattice constant in nanometers
 //! @param xi: rotation of lattice with respect to x-axis in radians
 InterferenceFunction1DLattice::InterferenceFunction1DLattice(double length, double xi)
-    : m_length(length), m_xi(xi), m_na{0}
+    : IInterferenceFunction(0), m_length(length), m_xi(xi), m_na{0}
 {
     setName("Interference1DLattice");
     registerParameter("Length", &m_length).setUnit("nm").setNonnegative();
@@ -45,6 +45,7 @@ InterferenceFunction1DLattice::~InterferenceFunction1DLattice() {}
 InterferenceFunction1DLattice* InterferenceFunction1DLattice::clone() const
 {
     auto* ret = new InterferenceFunction1DLattice(m_length, m_xi);
+    ret->setPositionVariance(m_position_var);
     ret->m_na = m_na;
     if (mP_decay)
         ret->setDecayFunction(*mP_decay);

Core/Aggregate/InterferenceFunction2DLattice.cpp

@@ -26,6 +26,13 @@ static const int nmax = 20;
 static const int min_points = 4;
 } // namespace
 
+InterferenceFunction2DLattice::InterferenceFunction2DLattice(const Lattice2D& lattice)
+    : IInterferenceFunction(0), m_integrate_xi(false)
+{
+    setName("Interference2DLattice");
+    setLattice(lattice);
+}
+
 //! Constructor of two-dimensional interference function.
 //! @param length_1: length of the first basis vector in nanometers
 //! @param length_2: length of the second basis vector  in nanometers
@@ -33,24 +40,20 @@ static const int min_points = 4;
 //! @param xi: rotation of the lattice with respect to the x-axis (beam direction) in radians
 InterferenceFunction2DLattice::InterferenceFunction2DLattice(double length_1, double length_2,
                                                              double alpha, double xi)
-    : m_integrate_xi(false), m_na(0), m_nb(0)
-{
-    setName("Interference2DLattice");
-    setLattice(BasicLattice(length_1, length_2, alpha, xi));
-}
-
-InterferenceFunction2DLattice::InterferenceFunction2DLattice(const Lattice2D& lattice)
-    : m_integrate_xi(false)
+    : InterferenceFunction2DLattice(BasicLattice(length_1, length_2, alpha, xi))
 {
-    setName("Interference2DLattice");
-    setLattice(lattice);
 }
 
-InterferenceFunction2DLattice::~InterferenceFunction2DLattice() {}
+InterferenceFunction2DLattice::~InterferenceFunction2DLattice() = default;
 
 InterferenceFunction2DLattice* InterferenceFunction2DLattice::clone() const
 {
-    return new InterferenceFunction2DLattice(*this);
+    auto* ret = new InterferenceFunction2DLattice(*m_lattice);
+    ret->setPositionVariance(m_position_var);
+    ret->setIntegrationOverXi(integrationOverXi());
+    if (m_decay)
+        ret->setDecayFunction(*m_decay);
+    return ret;
 }
 
 //! Creates square lattice.
@@ -125,18 +128,6 @@ double InterferenceFunction2DLattice::iff_without_dw(const kvector_t q) const
            / M_TWOPI;
 }
 
-InterferenceFunction2DLattice::InterferenceFunction2DLattice(
-    const InterferenceFunction2DLattice& other)
-    : IInterferenceFunction(other)
-{
-    setName(other.getName());
-    if (other.m_lattice)
-        setLattice(*other.m_lattice);
-    if (other.m_decay)
-        setDecayFunction(*other.m_decay);
-    setIntegrationOverXi(other.integrationOverXi());
-}
-
 void InterferenceFunction2DLattice::setLattice(const Lattice2D& lattice)
 {
     m_lattice.reset(lattice.clone());

Core/Aggregate/InterferenceFunction2DLattice.h

@@ -15,9 +15,9 @@
 #ifndef BORNAGAIN_CORE_AGGREGATE_INTERFERENCEFUNCTION2DLATTICE_H
 #define BORNAGAIN_CORE_AGGREGATE_INTERFERENCEFUNCTION2DLATTICE_H
 
-#include "Core/Aggregate/FTDecay1D.h"
-#include "Core/Aggregate/FTDecay2D.h"
 #include "Core/Aggregate/IInterferenceFunction.h"
+#include "Core/Correlations/FTDecay1D.h"
+#include "Core/Correlations/FTDecay2D.h"
 #include "Core/Lattice/Lattice2D.h"
 #include "Core/Tools/Integrator.h"
 
@@ -54,7 +54,6 @@ public:
 
 private:
     double iff_without_dw(const kvector_t q) const override final;
-    InterferenceFunction2DLattice(const InterferenceFunction2DLattice& other);
     void setLattice(const Lattice2D& lattice);
 
     double interferenceForXi(double xi) const;

Core/Aggregate/InterferenceFunction2DParaCrystal.cpp

@@ -23,12 +23,14 @@ InterferenceFunction2DParaCrystal::InterferenceFunction2DParaCrystal(const Latti
                                                                      double damping_length,
                                                                      double domain_size_1,
                                                                      double domain_size_2)
-    : m_integrate_xi(false), m_damping_length(damping_length)
+    : IInterferenceFunction(0), m_integrate_xi(false), m_damping_length(damping_length)
 {
     setName("Interference2DParaCrystal");
     setLattice(lattice);
     setDomainSizes(domain_size_1, domain_size_2);
-    init_parameters();
+    registerParameter("DampingLength", &m_damping_length).setUnit("nm").setNonnegative();
+    registerParameter("DomainSize1", &m_domain_sizes[0]).setUnit("nm").setNonnegative();
+    registerParameter("DomainSize2", &m_domain_sizes[1]).setUnit("nm").setNonnegative();
 }
 
 //! Constructor of interference function of two-dimensional paracrystal.
@@ -42,26 +44,22 @@ InterferenceFunction2DParaCrystal::InterferenceFunction2DParaCrystal(double leng
                                                                      double length_2, double alpha,
                                                                      double xi,
                                                                      double damping_length)
-    : m_integrate_xi(false), m_damping_length(damping_length)
+    : InterferenceFunction2DParaCrystal(BasicLattice(length_1, length_2, alpha, xi), damping_length,
+                                        0, 0)
 {
-    setName("Interference2DParaCrystal");
-    setLattice(BasicLattice(length_1, length_2, alpha, xi));
-    setDomainSizes(0.0, 0.0);
-    init_parameters();
 }
 
-InterferenceFunction2DParaCrystal::~InterferenceFunction2DParaCrystal() {}
+InterferenceFunction2DParaCrystal::~InterferenceFunction2DParaCrystal() = default;
 
 InterferenceFunction2DParaCrystal* InterferenceFunction2DParaCrystal::clone() const
 {
-    return new InterferenceFunction2DParaCrystal(*this);
-}
-
-void InterferenceFunction2DParaCrystal::init_parameters()
-{
-    registerParameter("DampingLength", &m_damping_length).setUnit("nm").setNonnegative();
-    registerParameter("DomainSize1", &m_domain_sizes[0]).setUnit("nm").setNonnegative();
-    registerParameter("DomainSize2", &m_domain_sizes[1]).setUnit("nm").setNonnegative();
+    auto* ret = new InterferenceFunction2DParaCrystal(*m_lattice, m_damping_length,
+                                                      m_domain_sizes[0], m_domain_sizes[1]);
+    ret->setPositionVariance(m_position_var);
+    if (m_pdf1 && m_pdf2)
+        ret->setProbabilityDistributions(*m_pdf1, *m_pdf2);
+    ret->setIntegrationOverXi(m_integrate_xi);
+    return ret;
 }
 
 //! Sets the probability distributions (Fourier transformed) for the two lattice directions.
@@ -107,21 +105,6 @@ double InterferenceFunction2DParaCrystal::iff_without_dw(const kvector_t q) cons
            / M_TWOPI;
 }
 
-InterferenceFunction2DParaCrystal::InterferenceFunction2DParaCrystal(
-    const InterferenceFunction2DParaCrystal& other)
-    : IInterferenceFunction(other)
-{
-    setName(other.getName());
-    m_damping_length = other.m_damping_length;
-    if (other.m_lattice)
-        setLattice(*other.m_lattice);
-    if (other.m_pdf1 && other.m_pdf2)
-        setProbabilityDistributions(*other.m_pdf1, *other.m_pdf2);
-    setDomainSizes(other.m_domain_sizes[0], other.m_domain_sizes[1]);
-    setIntegrationOverXi(other.m_integrate_xi);
-    init_parameters();
-}
-
 void InterferenceFunction2DParaCrystal::setLattice(const Lattice2D& lattice)
 {
     m_lattice.reset(lattice.clone());

Core/Aggregate/InterferenceFunction2DParaCrystal.h

@@ -15,9 +15,9 @@
 #ifndef BORNAGAIN_CORE_AGGREGATE_INTERFERENCEFUNCTION2DPARACRYSTAL_H
 #define BORNAGAIN_CORE_AGGREGATE_INTERFERENCEFUNCTION2DPARACRYSTAL_H
 
-#include "Core/Aggregate/FTDistributions2D.h"
 #include "Core/Aggregate/IInterferenceFunction.h"
 #include "Core/Basics/Complex.h"
+#include "Core/Correlations/FTDistributions2D.h"
 #include "Core/Lattice/Lattice2D.h"
 #include "Core/Tools/Integrator.h"
 #include <memory>
@@ -76,10 +76,8 @@ public:
 
 private:
     double iff_without_dw(const kvector_t q) const override final;
-    InterferenceFunction2DParaCrystal(const InterferenceFunction2DParaCrystal& other);
     void setLattice(const Lattice2D& lattice);
 
-    void init_parameters();
     double interferenceForXi(double xi) const;
     double interference1D(double qx, double qy, double xi, size_t index) const;
     complex_t FTPDF(double qx, double qy, double xi, size_t index) const;
@@ -88,7 +86,7 @@ private:
 
     bool m_integrate_xi; //!< Integrate over the orientation xi
     std::unique_ptr<IFTDistribution2D> m_pdf1, m_pdf2;
-    std::unique_ptr<Lattice2D> m_lattice;
+    std::unique_ptr<Lattice2D> m_lattice; // TODO ASAP name as in other i-fcts
     double m_damping_length;  //!< Damping length for removing delta function singularity at q=0.
     double m_domain_sizes[2]; //!< Coherence domain sizes
     mutable double m_qx;

Core/Aggregate/InterferenceFunction2DSuperLattice.cpp

@@ -21,17 +21,15 @@
 
 #include <limits>
 
-using MathFunctions::Laue;
-
 InterferenceFunction2DSuperLattice::InterferenceFunction2DSuperLattice(const Lattice2D& lattice,
                                                                        unsigned size_1,
                                                                        unsigned size_2)
-    : m_integrate_xi(false), mP_substructure(nullptr), m_size_1(size_1), m_size_2(size_2)
+    : IInterferenceFunction(0), m_integrate_xi(false), mP_substructure(nullptr), m_size_1(size_1),
+      m_size_2(size_2)
 {
     setName("Interference2DSuperLattice");
     setLattice(lattice);
     setSubstructureIFF(InterferenceFunctionNone());
-    init_parameters();
 }
 
 //! Constructor of two-dimensional interference function.
@@ -41,19 +39,20 @@ InterferenceFunction2DSuperLattice::InterferenceFunction2DSuperLattice(const Lat
 //! @param xi: rotation of lattice with respect to x-axis (beam direction) in radians
 InterferenceFunction2DSuperLattice::InterferenceFunction2DSuperLattice(
     double length_1, double length_2, double alpha, double xi, unsigned size_1, unsigned size_2)
-    : m_integrate_xi(false), mP_substructure(nullptr), m_size_1(size_1), m_size_2(size_2)
+    : InterferenceFunction2DSuperLattice(BasicLattice(length_1, length_2, alpha, xi), size_1,
+                                         size_2)
 {
-    setName("Interference2DSuperLattice");
-    setLattice(BasicLattice(length_1, length_2, alpha, xi));
-    setSubstructureIFF(InterferenceFunctionNone());
-    init_parameters();
 }
 
 InterferenceFunction2DSuperLattice::~InterferenceFunction2DSuperLattice() = default;
 
 InterferenceFunction2DSuperLattice* InterferenceFunction2DSuperLattice::clone() const
 {
-    return new InterferenceFunction2DSuperLattice(*this);
+    auto* ret = new InterferenceFunction2DSuperLattice(*mP_lattice, m_size_1, m_size_2);
+    ret->setPositionVariance(m_position_var);
+    ret->setSubstructureIFF(*mP_substructure);
+    ret->setIntegrationOverXi(integrationOverXi());
+    return ret;
 }
 
 void InterferenceFunction2DSuperLattice::setSubstructureIFF(const IInterferenceFunction& sub_iff)
@@ -122,26 +121,16 @@ std::vector<const INode*> InterferenceFunction2DSuperLattice::getChildren() cons
 
 double InterferenceFunction2DSuperLattice::iff_without_dw(const kvector_t q) const
 {
-    double a = mP_lattice->length1();
-    double b = mP_lattice->length2();
-    double xialpha = m_xi + mP_lattice->latticeAngle();
+    using MathFunctions::Laue;
 
-    double qadiv2 = (q.x() * a * std::cos(m_xi) + q.y() * a * std::sin(m_xi)) / 2.0;
-    double qbdiv2 = (q.x() * b * std::cos(xialpha) + q.y() * b * std::sin(xialpha)) / 2.0;
-    double ampl = Laue(qadiv2, m_size_1) * Laue(qbdiv2, m_size_2);
-    return ampl * ampl / (m_size_1 * m_size_2);
-}
+    const double a = mP_lattice->length1();
+    const double b = mP_lattice->length2();
+    const double xialpha = m_xi + mP_lattice->latticeAngle();
 
-InterferenceFunction2DSuperLattice::InterferenceFunction2DSuperLattice(
-    const InterferenceFunction2DSuperLattice& other)
-    : IInterferenceFunction(other), m_size_1(other.m_size_1), m_size_2(other.m_size_2)
-{
-    setName(other.getName());
-    if (other.mP_lattice)
-        setLattice(*other.mP_lattice);
-    setSubstructureIFF(*other.mP_substructure);
-    setIntegrationOverXi(other.integrationOverXi());
-    init_parameters();
+    const double qadiv2 = (q.x() * a * std::cos(m_xi) + q.y() * a * std::sin(m_xi)) / 2.0;
+    const double qbdiv2 = (q.x() * b * std::cos(xialpha) + q.y() * b * std::sin(xialpha)) / 2.0;
+    const double ampl = Laue(qadiv2, m_size_1) * Laue(qbdiv2, m_size_2);
+    return ampl * ampl / (m_size_1 * m_size_2);
 }
 
 void InterferenceFunction2DSuperLattice::setLattice(const Lattice2D& lattice)
@@ -150,15 +139,11 @@ void InterferenceFunction2DSuperLattice::setLattice(const Lattice2D& lattice)
     registerChild(mP_lattice.get());
 }
 
-void InterferenceFunction2DSuperLattice::init_parameters() {}
-
 double InterferenceFunction2DSuperLattice::interferenceForXi(double xi) const
 {
-    m_xi = xi;
-    kvector_t q = kvector_t(m_qx, m_qy, 0.0);
-    double outer_iff = iff_no_inner(q, m_outer_iff);
-
-    double delta_xi = xi - mP_lattice->rotationAngle();
-    q = q.rotatedZ(-delta_xi);
-    return mP_substructure->evaluate(q, outer_iff);
+    m_xi = xi; // TODO ASAP don't set as collateratel effect; rm mutable
+    const kvector_t q = kvector_t(m_qx, m_qy, 0.0);
+    const double outer_iff = iff_no_inner(q, m_outer_iff);
+    const double delta_xi = xi - mP_lattice->rotationAngle();
+    return mP_substructure->evaluate(q.rotatedZ(-delta_xi), outer_iff);
 }

Core/Aggregate/InterferenceFunction2DSuperLattice.h

@@ -56,10 +56,8 @@ public:
 
 private:
     double iff_without_dw(const kvector_t q) const override final;
-    InterferenceFunction2DSuperLattice(const InterferenceFunction2DSuperLattice& other);
     void setLattice(const Lattice2D& lattice);
 
-    void init_parameters();
     double interferenceForXi(double xi) const;
 
     bool m_integrate_xi; //!< Integrate over the orientation xi

Core/Aggregate/InterferenceFunction3DLattice.cpp

@@ -13,12 +13,12 @@
 // ************************************************************************** //
 
 #include "Core/Aggregate/InterferenceFunction3DLattice.h"
-#include "Core/Aggregate/IPeakShape.h"
 #include "Core/Basics/Exceptions.h"
+#include "Core/Correlations/IPeakShape.h"
 #include <algorithm>
 
 InterferenceFunction3DLattice::InterferenceFunction3DLattice(const Lattice& lattice)
-    : m_lattice(lattice), mP_peak_shape(nullptr), m_rec_radius(0.0)
+    : IInterferenceFunction(0), m_lattice(lattice), mP_peak_shape(nullptr), m_rec_radius(0.0)
 {
     setName("Interference3DLattice");
     initRecRadius();
@@ -28,7 +28,11 @@ InterferenceFunction3DLattice::~InterferenceFunction3DLattice() = default;
 
 InterferenceFunction3DLattice* InterferenceFunction3DLattice::clone() const
 {
-    return new InterferenceFunction3DLattice(*this);
+    auto* ret = new InterferenceFunction3DLattice(m_lattice);
+    ret->setPositionVariance(m_position_var);
+    if (mP_peak_shape)
+        ret->setPeakShape(*mP_peak_shape);
+    return ret;
 }
 
 void InterferenceFunction3DLattice::setPeakShape(const IPeakShape& peak_shape)
@@ -74,17 +78,6 @@ double InterferenceFunction3DLattice::iff_without_dw(const kvector_t q) const
     return result;
 }
 
-InterferenceFunction3DLattice::InterferenceFunction3DLattice(
-    const InterferenceFunction3DLattice& other)
-    : IInterferenceFunction(other), m_lattice(other.m_lattice), mP_peak_shape(nullptr),
-      m_rec_radius(0.0)
-{
-    setName(other.getName());
-    initRecRadius();
-    if (other.mP_peak_shape)
-        setPeakShape(*other.mP_peak_shape);
-}
-
 void InterferenceFunction3DLattice::initRecRadius()
 {
     kvector_t a1 = m_lattice.getBasisVectorA();

Core/Aggregate/InterferenceFunction3DLattice.h

@@ -45,9 +45,9 @@ public:
 
 private:
     double iff_without_dw(const kvector_t q) const override final;
-    InterferenceFunction3DLattice(const InterferenceFunction3DLattice& other);
     void initRecRadius();
-    Lattice m_lattice;
+
+    Lattice m_lattice; // TODO ASAP unique_ptr as in otehr InterferenceFunction%s
     std::unique_ptr<IPeakShape> mP_peak_shape;
     double m_rec_radius; //!< radius in reciprocal space defining the nearest q vectors to use
 };

Core/Aggregate/InterferenceFunctionFinite2DLattice.cpp

@@ -28,11 +28,10 @@ using MathFunctions::Laue;
 //! @param N_2: number of lattice cells in the second lattice direction
 InterferenceFunctionFinite2DLattice::InterferenceFunctionFinite2DLattice(const Lattice2D& lattice,
                                                                          unsigned N_1, unsigned N_2)
-    : m_integrate_xi(false), m_N_1(N_1), m_N_2(N_2)
+    : IInterferenceFunction(0), m_integrate_xi(false), m_N_1(N_1), m_N_2(N_2)
 {
     setName("InterferenceFinite2DLattice");
     setLattice(lattice);
-    init_parameters();
 }
 
 //! Constructor of two-dimensional finite lattice interference function.
@@ -46,18 +45,18 @@ InterferenceFunctionFinite2DLattice::InterferenceFunctionFinite2DLattice(double
                                                                          double length_2,
                                                                          double alpha, double xi,
                                                                          unsigned N_1, unsigned N_2)
-    : m_integrate_xi(false), m_N_1(N_1), m_N_2(N_2)
+    : InterferenceFunctionFinite2DLattice(BasicLattice(length_1, length_2, alpha, xi), N_1, N_2)
 {
-    setName("InterferenceFinite2DLattice");
-    setLattice(BasicLattice(length_1, length_2, alpha, xi));
-    init_parameters();
 }
 
 InterferenceFunctionFinite2DLattice::~InterferenceFunctionFinite2DLattice() = default;
 
 InterferenceFunctionFinite2DLattice* InterferenceFunctionFinite2DLattice::clone() const
 {
-    return new InterferenceFunctionFinite2DLattice(*this);
+    auto* ret = new InterferenceFunctionFinite2DLattice(*mP_lattice, m_N_1, m_N_2);
+    ret->setPositionVariance(m_position_var);
+    ret->setIntegrationOverXi(integrationOverXi());
+    return ret;
 }
 
 //! Creates square lattice.
@@ -109,8 +108,6 @@ std::vector<const INode*> InterferenceFunctionFinite2DLattice::getChildren() con
     return std::vector<const INode*>() << mP_lattice;
 }
 
-void InterferenceFunctionFinite2DLattice::init_parameters() {}
-
 double InterferenceFunctionFinite2DLattice::iff_without_dw(const kvector_t q) const
 {
     m_qx = q.x();
@@ -122,17 +119,6 @@ double InterferenceFunctionFinite2DLattice::iff_without_dw(const kvector_t q) co
            / M_TWOPI;
 }
 
-InterferenceFunctionFinite2DLattice::InterferenceFunctionFinite2DLattice(
-    const InterferenceFunctionFinite2DLattice& other)
-    : IInterferenceFunction(other), m_N_1(other.m_N_1), m_N_2(other.m_N_2)
-{
-    setName(other.getName());
-    if (other.mP_lattice)
-        setLattice(*other.mP_lattice);
-    setIntegrationOverXi(other.integrationOverXi());
-    init_parameters();
-}
-
 void InterferenceFunctionFinite2DLattice::setLattice(const Lattice2D& lattice)
 {
     mP_lattice.reset(lattice.clone());

Core/Aggregate/InterferenceFunctionFinite2DLattice.h

@@ -54,10 +54,8 @@ public:
 
 private:
     double iff_without_dw(const kvector_t q) const override final;
-    InterferenceFunctionFinite2DLattice(const InterferenceFunctionFinite2DLattice& other);
     void setLattice(const Lattice2D& lattice);
 
-    void init_parameters();
     double interferenceForXi(double xi) const;
 
     bool m_integrate_xi; //!< Integrate over the orientation xi

Core/Aggregate/InterferenceFunctionFinite3DLattice.cpp

@@ -20,8 +20,6 @@
 
 #include <limits>
 
-using MathFunctions::Laue;
-
 //! Constructor of three-dimensional finite lattice interference function.
 //! @param lattice: object specifying a 2d lattice structure
 //! @param N_1: number of lattice cells in the first lattice direction
@@ -29,7 +27,7 @@ using MathFunctions::Laue;
 InterferenceFunctionFinite3DLattice::InterferenceFunctionFinite3DLattice(const Lattice& lattice,
                                                                          unsigned N_1, unsigned N_2,
                                                                          unsigned N_3)
-    : m_N_1(N_1), m_N_2(N_2), m_N_3(N_3)
+    : IInterferenceFunction(0), m_N_1(N_1), m_N_2(N_2), m_N_3(N_3)
 {
     setName("InterferenceFinite3DLattice");
     setLattice(lattice);
@@ -39,7 +37,9 @@ InterferenceFunctionFinite3DLattice::~InterferenceFunctionFinite3DLattice() = de
 
 InterferenceFunctionFinite3DLattice* InterferenceFunctionFinite3DLattice::clone() const
 {
-    return new InterferenceFunctionFinite3DLattice(*this);
+    auto* ret = new InterferenceFunctionFinite3DLattice(*mP_lattice, m_N_1, m_N_2, m_N_3);
+    ret->setPositionVariance(m_position_var);
+    return ret;
 }
 
 const Lattice& InterferenceFunctionFinite3DLattice::lattice() const
@@ -57,22 +57,14 @@ std::vector<const INode*> InterferenceFunctionFinite3DLattice::getChildren() con
 
 double InterferenceFunctionFinite3DLattice::iff_without_dw(const kvector_t q) const
 {
-    double qadiv2 = q.dot(mP_lattice->getBasisVectorA()) / 2.0;
-    double qbdiv2 = q.dot(mP_lattice->getBasisVectorB()) / 2.0;
-    double qcdiv2 = q.dot(mP_lattice->getBasisVectorC()) / 2.0;
-    double ampl = Laue(qadiv2, m_N_1) * Laue(qbdiv2, m_N_2) * Laue(qcdiv2, m_N_3);
+    using MathFunctions::Laue;
+    const double qadiv2 = q.dot(mP_lattice->getBasisVectorA()) / 2.0;
+    const double qbdiv2 = q.dot(mP_lattice->getBasisVectorB()) / 2.0;
+    const double qcdiv2 = q.dot(mP_lattice->getBasisVectorC()) / 2.0;
+    const double ampl = Laue(qadiv2, m_N_1) * Laue(qbdiv2, m_N_2) * Laue(qcdiv2, m_N_3);
     return ampl * ampl / (m_N_1 * m_N_2 * m_N_3);
 }
 
-InterferenceFunctionFinite3DLattice::InterferenceFunctionFinite3DLattice(
-    const InterferenceFunctionFinite3DLattice& other)
-    : IInterferenceFunction(other), m_N_1(other.m_N_1), m_N_2(other.m_N_2), m_N_3(other.m_N_3)
-{
-    setName(other.getName());
-    if (other.mP_lattice)
-        setLattice(*other.mP_lattice);
-}
-
 void InterferenceFunctionFinite3DLattice::setLattice(const Lattice& lattice)
 {
     mP_lattice.reset(new Lattice(lattice));

Core/Aggregate/InterferenceFunctionFinite3DLattice.h

@@ -44,7 +44,6 @@ public:
 
 private:
     double iff_without_dw(const kvector_t q) const override final;
-    InterferenceFunctionFinite3DLattice(const InterferenceFunctionFinite3DLattice& other);
     void setLattice(const Lattice& lattice);
 
     std::unique_ptr<Lattice> mP_lattice;

Core/Aggregate/InterferenceFunctionHardDisk.cpp

@@ -20,24 +20,28 @@
 namespace
 {
 static const double p = 7.0 / 3.0 - 4.0 * std::sqrt(3.0) / M_PI;
-double Czero(double packing);
+double Czero(double packing); // TODO ASAP why these variables?
 double S2(double packing);
 double W2(double x);
 } // namespace
 
-InterferenceFunctionHardDisk::InterferenceFunctionHardDisk(double radius, double density)
-    : m_radius(radius), m_density(density)
+InterferenceFunctionHardDisk::InterferenceFunctionHardDisk(double radius, double density,
+                                                           double position_var)
+    : IInterferenceFunction(position_var), m_radius(radius), m_density(density)
 {
     setName("InterferenceHardDisk");
-    validateParameters();
-    init_parameters();
+    if (m_radius < 0.0 || m_density < 0.0 || packingRatio() > 0.65)
+        throw std::runtime_error("InterferenceFunctionHardDisk::validateParameters: "
+                                 "radius and density must be positive and packing ratio between "
+                                 "0 and 0.65");
+    registerParameter("Radius", &m_radius).setUnit("nm").setNonnegative();
+    registerParameter("TotalParticleDensity", &m_density).setUnit("nm").setNonnegative();
 }
 
-InterferenceFunctionHardDisk::~InterferenceFunctionHardDisk() = default;
-
 InterferenceFunctionHardDisk* InterferenceFunctionHardDisk::clone() const
 {
-    return new InterferenceFunctionHardDisk(*this);
+    auto* ret = new InterferenceFunctionHardDisk(m_radius, m_density, m_position_var);
+    return ret;
 }
 
 double InterferenceFunctionHardDisk::getParticleDensity() const
@@ -55,15 +59,6 @@ double InterferenceFunctionHardDisk::density() const
     return m_density;
 }
 
-InterferenceFunctionHardDisk::InterferenceFunctionHardDisk(
-    const InterferenceFunctionHardDisk& other)
-    : IInterferenceFunction(other), m_radius(other.m_radius), m_density(other.m_density)
-{
-    setName("InterferenceHardDisk");
-    validateParameters();
-    init_parameters();
-}
-
 double InterferenceFunctionHardDisk::iff_without_dw(const kvector_t q) const
 {
     double qx = q.x();
@@ -79,20 +74,6 @@ double InterferenceFunctionHardDisk::iff_without_dw(const kvector_t q) const
     return 1.0 / (1.0 - rho * c_q);
 }
 
-void InterferenceFunctionHardDisk::init_parameters()
-{
-    registerParameter("Radius", &m_radius).setUnit("nm").setNonnegative();
-    registerParameter("TotalParticleDensity", &m_density).setUnit("nm").setNonnegative();
-}
-
-void InterferenceFunctionHardDisk::validateParameters() const
-{
-    if (m_radius < 0.0 || m_density < 0.0 || packingRatio() > 0.65)
-        throw std::runtime_error("InterferenceFunctionHardDisk::validateParameters: "
-                                 "radius and density must be positive and packing ratio between "
-                                 "0 and 0.65");
-}
-
 double InterferenceFunctionHardDisk::packingRatio() const
 {
     return M_PI * m_radius * m_radius * m_density;

Core/Aggregate/InterferenceFunctionHardDisk.h

@@ -28,8 +28,8 @@
 class BA_CORE_API_ InterferenceFunctionHardDisk : public IInterferenceFunction
 {
 public:
-    InterferenceFunctionHardDisk(double radius, double density);
-    ~InterferenceFunctionHardDisk() final;
+    InterferenceFunctionHardDisk(double radius, double density, double position_var = 0);
+    ~InterferenceFunctionHardDisk() final = default;
 
     InterferenceFunctionHardDisk* clone() const override final;
 
@@ -41,14 +41,13 @@ public:
     double density() const;
 
 private:
-    InterferenceFunctionHardDisk(const InterferenceFunctionHardDisk& other);
     double iff_without_dw(const kvector_t q) const override final;
-    void init_parameters();
-    void validateParameters() const;
     double packingRatio() const;
     double integrand(double x) const;
+
     double m_radius;
     double m_density;
+
     mutable double m_q, m_c_zero, m_s2, m_packing;
     mutable RealIntegrator m_integrator;
 };

Core/Aggregate/InterferenceFunctionNone.cpp

@@ -14,23 +14,19 @@
 
 #include "Core/Aggregate/InterferenceFunctionNone.h"
 
-InterferenceFunctionNone::InterferenceFunctionNone()
+InterferenceFunctionNone::InterferenceFunctionNone() : IInterferenceFunction(0)
 {
     setName("InterferenceNone");
 }
 
 InterferenceFunctionNone* InterferenceFunctionNone::clone() const
 {
-    return new InterferenceFunctionNone(*this);
+    auto* ret = new InterferenceFunctionNone();
+    ret->setPositionVariance(m_position_var);
+    return ret;
 }
 
 double InterferenceFunctionNone::iff_without_dw(const kvector_t) const
 {
     return 1.0;
 }
-
-InterferenceFunctionNone::InterferenceFunctionNone(const InterferenceFunctionNone& other)
-    : IInterferenceFunction(other)
-{
-    setName(other.getName());
-}

Core/Aggregate/InterferenceFunctionNone.h

@@ -31,7 +31,6 @@ public:
 
 private:
     double iff_without_dw(const kvector_t q) const override final;
-    InterferenceFunctionNone(const InterferenceFunctionNone& other);
 };
 
 #endif // BORNAGAIN_CORE_AGGREGATE_INTERFERENCEFUNCTIONNONE_H