From e1a4c22bd0787ca1e807d6b15bc538253d0aa4f1 Mon Sep 17 00:00:00 2001
From: "Joachim Wuttke (h)" <j.wuttke@fz-juelich.de>
Date: Fri, 14 Aug 2020 08:00:45 +0200
Subject: [PATCH] FT distribution functions now also delegating parameter
 registration to INode

rm fcts setGamma, setOmega
---
 Core/Correlations/FTDecay2D.h                 |   9 +-
 Core/Correlations/FTDistributions1D.cpp       |  67 +-
 Core/Correlations/FTDistributions1D.h         |  21 +-
 Core/Correlations/FTDistributions2D.cpp       |  57 +-
 Core/Correlations/FTDistributions2D.h         |  27 +-
 Core/StandardSamples/TwoDimLatticeBuilder.cpp |   4 +-
 .../Interference2DRotatedSquareLattice.py     |   2 +-
 .../Core/Parameters/FTDistributionsTest.cpp   |  40 +-
 auto/Wrap/libBornAgainCore.py                 | 125 +--
 auto/Wrap/libBornAgainCore_wrap.cpp           | 978 ++++++++++++++----
 10 files changed, 960 insertions(+), 370 deletions(-)

diff --git a/Core/Correlations/FTDecay2D.h b/Core/Correlations/FTDecay2D.h
index 61cf7582d10..315d8e40d1d 100644
--- a/Core/Correlations/FTDecay2D.h
+++ b/Core/Correlations/FTDecay2D.h
@@ -29,17 +29,12 @@ public:
 
     virtual IFTDecayFunction2D* clone() const = 0;
 
-    //! set angle between first lattice vector and X-axis of distribution (both in direct space)
-    void setGamma(double gamma) { m_P[2] = gamma; }
-
-    //! get angle between first lattice vector and X-axis of distribution (both in direct space)
-    double gamma() const { return m_gamma; }
-
     //! get decay length in distribution's X-direction
     double decayLengthX() const { return m_decay_length_x; }
-
     //! get decay length in distribution's  Y-direction
     double decayLengthY() const { return m_decay_length_y; }
+    //! get angle between first lattice vector and X-axis of distribution (both in direct space)
+    double gamma() const { return m_gamma; }
 
     //! evaluate Fourier transformed decay function for q in X,Y coordinates
     virtual double evaluate(double qx, double qy) const = 0;
diff --git a/Core/Correlations/FTDistributions1D.cpp b/Core/Correlations/FTDistributions1D.cpp
index 912eb0bbcd6..d76afd283b3 100644
--- a/Core/Correlations/FTDistributions1D.cpp
+++ b/Core/Correlations/FTDistributions1D.cpp
@@ -15,8 +15,6 @@
 #include "Core/Correlations/FTDistributions1D.h"
 #include "Core/Basics/Exceptions.h"
 #include "Core/Basics/MathConstants.h"
-#include "Core/Parametrization/ParameterPool.h"
-#include "Core/Parametrization/RealParameter.h"
 #include "Core/Tools/MathFunctions.h"
 #include <limits>
 
@@ -29,13 +27,9 @@ const double CosineDistributionFactor = 1.0 / 3.0 - 2.0 / M_PI / M_PI;
 // interface IFTDistribution1D
 // ************************************************************************** //
 
-IFTDistribution1D::IFTDistribution1D(double omega) : m_omega(omega)
-{
-    registerParameter("Omega", &m_omega);
-}
-
 IFTDistribution1D::IFTDistribution1D(const NodeMeta& meta, const std::vector<double>& PValues)
-    : INode(nodeMetaUnion({{"Omega", "nm", "Half-width", 0, INF, 1.}}, meta), PValues)
+    : INode(nodeMetaUnion({{"Omega", "nm", "Half-width", 0, INF, 1.}}, meta), PValues),
+            m_omega(m_P[0])
 {
 }
 
@@ -43,9 +37,14 @@ IFTDistribution1D::IFTDistribution1D(const NodeMeta& meta, const std::vector<dou
 // class FTDistribution1DCauchy
 // ************************************************************************** //
 
-FTDistribution1DCauchy::FTDistribution1DCauchy(double omega) : IFTDistribution1D(omega)
+FTDistribution1DCauchy::FTDistribution1DCauchy(const std::vector<double> P)
+    : IFTDistribution1D({"FTDistribution1DCauchy", "class_tooltip", {}}, P)
+{
+}
+
+FTDistribution1DCauchy::FTDistribution1DCauchy(double omega)
+    : FTDistribution1DCauchy(std::vector<double>{omega})
 {
-    setName("FTDistribution1DCauchy");
 }
 
 FTDistribution1DCauchy* FTDistribution1DCauchy::clone() const
@@ -73,9 +72,14 @@ std::unique_ptr<IDistribution1DSampler> FTDistribution1DCauchy::createSampler()
 // class FTDistribution1DGauss
 // ************************************************************************** //
 
-FTDistribution1DGauss::FTDistribution1DGauss(double omega) : IFTDistribution1D(omega)
+FTDistribution1DGauss::FTDistribution1DGauss(const std::vector<double> P)
+    : IFTDistribution1D({"FTDistribution1DGauss", "class_tooltip", {}}, P)
+{
+}
+
+FTDistribution1DGauss::FTDistribution1DGauss(double omega)
+    : FTDistribution1DGauss(std::vector<double>{omega})
 {
-    setName("FTDistribution1DGauss");
 }
 
 FTDistribution1DGauss* FTDistribution1DGauss::clone() const
@@ -103,9 +107,14 @@ std::unique_ptr<IDistribution1DSampler> FTDistribution1DGauss::createSampler() c
 // class FTDistribution1DGate
 // ************************************************************************** //
 
-FTDistribution1DGate::FTDistribution1DGate(double omega) : IFTDistribution1D(omega)
+FTDistribution1DGate::FTDistribution1DGate(const std::vector<double> P)
+    : IFTDistribution1D({"FTDistribution1DGate", "class_tooltip", {}}, P)
+{
+}
+
+FTDistribution1DGate::FTDistribution1DGate(double omega)
+    : FTDistribution1DGate(std::vector<double>{omega})
 {
-    setName("FTDistribution1DGate");
 }
 
 FTDistribution1DGate* FTDistribution1DGate::clone() const
@@ -132,9 +141,14 @@ std::unique_ptr<IDistribution1DSampler> FTDistribution1DGate::createSampler() co
 // class FTDistribution1DTriangle
 // ************************************************************************** //
 
-FTDistribution1DTriangle::FTDistribution1DTriangle(double omega) : IFTDistribution1D(omega)
+FTDistribution1DTriangle::FTDistribution1DTriangle(const std::vector<double> P)
+    : IFTDistribution1D({"FTDistribution1DTriangle", "class_tooltip", {}}, P)
+{
+}
+
+FTDistribution1DTriangle::FTDistribution1DTriangle(double omega)
+    : FTDistribution1DTriangle(std::vector<double>{omega})
 {
-    setName("FTDistribution1DTriangle");
 }
 
 FTDistribution1DTriangle* FTDistribution1DTriangle::clone() const
@@ -162,9 +176,14 @@ std::unique_ptr<IDistribution1DSampler> FTDistribution1DTriangle::createSampler(
 // class FTDistribution1DCosine
 // ************************************************************************** //
 
-FTDistribution1DCosine::FTDistribution1DCosine(double omega) : IFTDistribution1D(omega)
+FTDistribution1DCosine::FTDistribution1DCosine(const std::vector<double> P)
+    : IFTDistribution1D({"FTDistribution1DCosine", "class_tooltip", {}}, P)
+{
+}
+
+FTDistribution1DCosine::FTDistribution1DCosine(double omega)
+    : FTDistribution1DCosine(std::vector<double>{omega})
 {
-    setName("FTDistribution1DCosine");
 }
 
 FTDistribution1DCosine* FTDistribution1DCosine::clone() const
@@ -194,11 +213,17 @@ std::unique_ptr<IDistribution1DSampler> FTDistribution1DCosine::createSampler()
 // class FTDistribution1DVoigt
 // ************************************************************************** //
 
+FTDistribution1DVoigt::FTDistribution1DVoigt(const std::vector<double> P)
+    : IFTDistribution1D(
+        {"FTDistribution1DVoigt", "class_tooltip", {{"Eta", "", "para_tooltip", -INF, +INF, 0}}},
+        P),
+      m_eta(m_P[1])
+{
+}
+
 FTDistribution1DVoigt::FTDistribution1DVoigt(double omega, double eta)
-    : IFTDistribution1D(omega), m_eta(eta)
+    : FTDistribution1DVoigt(std::vector<double>{omega, eta})
 {
-    setName("FTDistribution1DVoigt");
-    registerParameter("Eta", &m_eta);
 }
 
 FTDistribution1DVoigt* FTDistribution1DVoigt::clone() const
diff --git a/Core/Correlations/FTDistributions1D.h b/Core/Correlations/FTDistributions1D.h
index 5b1f2ad3367..4702ae179a2 100644
--- a/Core/Correlations/FTDistributions1D.h
+++ b/Core/Correlations/FTDistributions1D.h
@@ -19,7 +19,6 @@
 #include "Core/Correlations/IDistribution1DSampler.h"
 #include "Core/Parametrization/INode.h"
 
-
 //! Interface for a one-dimensional distribution, with normalization adjusted so that
 //! the Fourier transform evaluate(q) is a decay function that starts at evaluate(0)=1.
 //! @ingroup distribution_internal
@@ -27,9 +26,6 @@
 class BA_CORE_API_ IFTDistribution1D : public ICloneable, public INode
 {
 public:
-    //! Constructor of one-dimensional probability distribution.
-    //! @param omega: half-width of the distribution in nanometers
-    IFTDistribution1D(double omega);
     IFTDistribution1D(const NodeMeta& meta, const std::vector<double>& PValues);
 
     virtual IFTDistribution1D* clone() const = 0;
@@ -38,7 +34,6 @@ public:
     //! is a decay function starting at evaluate(0)=1.
     virtual double evaluate(double q) const = 0;
 
-    void setOmega(double omega) { m_omega = omega; }
     double omega() const { return m_omega; }
 
     //! Returns the negative of the second order derivative in q space around q=0
@@ -49,10 +44,9 @@ public:
 #endif
 
 protected:
-    double m_omega;
+    const double& m_omega;
 };
 
-
 //! Exponential IFTDistribution1D exp(-|omega*x|);
 //! its Fourier transform evaluate(q) is a Cauchy-Lorentzian starting at evaluate(0)=1.
 //! @ingroup distributionFT
@@ -60,6 +54,7 @@ protected:
 class BA_CORE_API_ FTDistribution1DCauchy : public IFTDistribution1D
 {
 public:
+    FTDistribution1DCauchy(const std::vector<double> P);
     FTDistribution1DCauchy(double omega);
 
     FTDistribution1DCauchy* clone() const override final;
@@ -72,7 +67,6 @@ public:
 #endif
 };
 
-
 //! Gaussian IFTDistribution1D;
 //! its Fourier transform evaluate(q) is a Gaussian starting at evaluate(0)=1.
 //! @ingroup distributionFT
@@ -80,6 +74,7 @@ public:
 class BA_CORE_API_ FTDistribution1DGauss : public IFTDistribution1D
 {
 public:
+    FTDistribution1DGauss(const std::vector<double> P);
     FTDistribution1DGauss(double omega);
 
     FTDistribution1DGauss* clone() const override final;
@@ -92,7 +87,6 @@ public:
 #endif
 };
 
-
 //! Square gate IFTDistribution1D;
 //! its Fourier transform evaluate(q) is a sinc function starting at evaluate(0)=1.
 //! @ingroup distributionFT
@@ -100,6 +94,7 @@ public:
 class BA_CORE_API_ FTDistribution1DGate : public IFTDistribution1D
 {
 public:
+    FTDistribution1DGate(const std::vector<double> P);
     FTDistribution1DGate(double omega);
 
     FTDistribution1DGate* clone() const override final;
@@ -112,7 +107,6 @@ public:
 #endif
 };
 
-
 //! Triangle IFTDistribution1D [1-|x|/omega if |x|<omega, and 0 otherwise];
 //! its Fourier transform evaluate(q) is a squared sinc function starting at evaluate(0)=1.
 //! @ingroup distributionFT
@@ -120,6 +114,7 @@ public:
 class BA_CORE_API_ FTDistribution1DTriangle : public IFTDistribution1D
 {
 public:
+    FTDistribution1DTriangle(const std::vector<double> P);
     FTDistribution1DTriangle(double omega);
 
     FTDistribution1DTriangle* clone() const override final;
@@ -132,7 +127,6 @@ public:
 #endif
 };
 
-
 //! IFTDistribution1D consisting of one cosine wave
 //! [1+cos(pi*x/omega) if |x|<omega, and 0 otherwise];
 //! its Fourier transform evaluate(q) starts at evaluate(0)=1.
@@ -141,6 +135,7 @@ public:
 class BA_CORE_API_ FTDistribution1DCosine : public IFTDistribution1D
 {
 public:
+    FTDistribution1DCosine(const std::vector<double> P);
     FTDistribution1DCosine(double omega);
 
     FTDistribution1DCosine* clone() const override final;
@@ -153,7 +148,6 @@ public:
 #endif
 };
 
-
 //! IFTDistribution1D that provides a Fourier transform evaluate(q) in form
 //! of a pseudo-Voigt decay function eta*Gauss + (1-eta)*Cauchy, with both components
 //! starting at 1 for q=0.
@@ -165,6 +159,7 @@ public:
     //! Constructor of one-dimensional pseudo-Voigt probability distribution.
     //! @param omega: half-width of the distribution in nanometers
     //! @param eta: parameter [0,1] to balance between Cauchy (eta=0.0) and Gauss (eta=1.0)
+    FTDistribution1DVoigt(const std::vector<double> P);
     FTDistribution1DVoigt(double omega, double eta);
 
     FTDistribution1DVoigt* clone() const override final;
@@ -178,7 +173,7 @@ public:
 #endif
 
 protected:
-    double m_eta;
+    const double& m_eta;
 };
 
 #endif // BORNAGAIN_CORE_AGGREGATE_FTDISTRIBUTIONS1D_H
diff --git a/Core/Correlations/FTDistributions2D.cpp b/Core/Correlations/FTDistributions2D.cpp
index 1d38f370fa3..6c7d334f522 100644
--- a/Core/Correlations/FTDistributions2D.cpp
+++ b/Core/Correlations/FTDistributions2D.cpp
@@ -16,8 +16,6 @@
 #include "Core/Basics/Algorithms.h"
 #include "Core/Basics/Exceptions.h"
 #include "Core/Basics/MathConstants.h"
-#include "Core/Parametrization/ParameterPool.h"
-#include "Core/Parametrization/RealParameter.h"
 #include "Core/Tools/MathFunctions.h"
 #include <limits>
 
@@ -27,14 +25,6 @@ using algo::concat;
 // interface IFTDistribution1D
 // ************************************************************************** //
 
-IFTDistribution2D::IFTDistribution2D(double omega_x, double omega_y, double gamma)
-    : m_omega_x(omega_x), m_omega_y(omega_y), m_gamma(gamma)
-{
-    registerParameter("OmegaX", &m_omega_x).setUnit("nm").setNonnegative();
-    registerParameter("OmegaY", &m_omega_y).setUnit("nm").setNonnegative();
-    registerParameter("Gamma", &m_gamma).setUnit("rad").setLimited(-M_PI_2, M_PI_2);
-}
-
 IFTDistribution2D::IFTDistribution2D(const NodeMeta& meta, const std::vector<double>& PValues)
     : INode(nodeMetaUnion({{"OmegaX", "nm", "Half-width along x axis", 0, INF, 1.},
                            {"OmegaY", "nm", "Half-width along y axis", 0, INF, 1.},
@@ -42,7 +32,8 @@ IFTDistribution2D::IFTDistribution2D(const NodeMeta& meta, const std::vector<dou
                             "direct-space orientation with respect to the first lattice vector",
                             -M_PI_2, +M_PI_2, 0}},
                           meta),
-            PValues)
+            PValues),
+      m_omega_x(m_P[0]), m_omega_y(m_P[1]), m_gamma(m_P[2])
 {
 }
 
@@ -55,10 +46,14 @@ double IFTDistribution2D::sumsq(double qx, double qy) const
 // class FTDistribution2DCauchy
 // ************************************************************************** //
 
+FTDistribution2DCauchy::FTDistribution2DCauchy(const std::vector<double> P)
+    : IFTDistribution2D({"FTDistribution2DCauchy", "class_tooltip", {}}, P)
+{
+}
+
 FTDistribution2DCauchy::FTDistribution2DCauchy(double omega_x, double omega_y, double gamma)
-    : IFTDistribution2D(omega_x, omega_y, gamma)
+    : FTDistribution2DCauchy(std::vector<double>{omega_x, omega_y, gamma})
 {
-    setName("FTDistribution2DCauchy");
 }
 
 FTDistribution2DCauchy* FTDistribution2DCauchy::clone() const
@@ -80,10 +75,14 @@ std::unique_ptr<IDistribution2DSampler> FTDistribution2DCauchy::createSampler()
 // class FTDistribution2DGauss
 // ************************************************************************** //
 
+FTDistribution2DGauss::FTDistribution2DGauss(const std::vector<double> P)
+    : IFTDistribution2D({"FTDistribution2DGauss", "class_tooltip", {}}, P)
+{
+}
+
 FTDistribution2DGauss::FTDistribution2DGauss(double omega_x, double omega_y, double gamma)
-    : IFTDistribution2D(omega_x, omega_y, gamma)
+    : FTDistribution2DGauss(std::vector<double>{omega_x, omega_y, gamma})
 {
-    setName("FTDistribution2DGauss");
 }
 
 FTDistribution2DGauss* FTDistribution2DGauss::clone() const
@@ -105,10 +104,14 @@ std::unique_ptr<IDistribution2DSampler> FTDistribution2DGauss::createSampler() c
 // class FTDistribution2DGate
 // ************************************************************************** //
 
+FTDistribution2DGate::FTDistribution2DGate(const std::vector<double> P)
+    : IFTDistribution2D({"FTDistribution2DGate", "class_tooltip", {}}, P)
+{
+}
+
 FTDistribution2DGate::FTDistribution2DGate(double omega_x, double omega_y, double gamma)
-    : IFTDistribution2D(omega_x, omega_y, gamma)
+    : FTDistribution2DGate(std::vector<double>{omega_x, omega_y, gamma})
 {
-    setName("FTDistribution2DGate");
 }
 
 FTDistribution2DGate* FTDistribution2DGate::clone() const
@@ -131,10 +134,14 @@ std::unique_ptr<IDistribution2DSampler> FTDistribution2DGate::createSampler() co
 // class FTDistribution2DCone
 // ************************************************************************** //
 
+FTDistribution2DCone::FTDistribution2DCone(const std::vector<double> P)
+    : IFTDistribution2D({"FTDistribution2DCone", "class_tooltip", {}}, P)
+{
+}
+
 FTDistribution2DCone::FTDistribution2DCone(double omega_x, double omega_y, double gamma)
-    : IFTDistribution2D(omega_x, omega_y, gamma)
+    : FTDistribution2DCone(std::vector<double>{omega_x, omega_y, gamma})
 {
-    setName("FTDistribution2DCone");
 }
 
 FTDistribution2DCone* FTDistribution2DCone::clone() const
@@ -169,12 +176,18 @@ std::unique_ptr<IDistribution2DSampler> FTDistribution2DCone::createSampler() co
 //! @param gamma: angle in direct space between first lattice vector and x-axis
 //! of the distribution in radians
 
+FTDistribution2DVoigt::FTDistribution2DVoigt(const std::vector<double> P)
+    : IFTDistribution2D(
+        {"FTDistribution2DVoigt", "class_tooltip", {{"Eta", "", "para_tooltip", -INF, +INF, 0}}},
+        P),
+      m_eta(m_P[3])
+{
+}
+
 FTDistribution2DVoigt::FTDistribution2DVoigt(double omega_x, double omega_y, double gamma,
                                              double eta)
-    : IFTDistribution2D(omega_x, omega_y, gamma), m_eta(eta)
+    : FTDistribution2DVoigt(std::vector<double>{omega_x, omega_y, gamma, eta})
 {
-    setName("FTDistribution2DVoigt");
-    registerParameter("Eta", &m_eta);
 }
 
 FTDistribution2DVoigt* FTDistribution2DVoigt::clone() const
diff --git a/Core/Correlations/FTDistributions2D.h b/Core/Correlations/FTDistributions2D.h
index c640accb8c8..59fba08a012 100644
--- a/Core/Correlations/FTDistributions2D.h
+++ b/Core/Correlations/FTDistributions2D.h
@@ -21,27 +21,23 @@
 #include "Core/Parametrization/INode.h"
 #include "Core/Tools/Integrator.h"
 
-
 //! Interface for two-dimensional distributions in Fourier space.
 //! @ingroup distribution_internal
 
 class BA_CORE_API_ IFTDistribution2D : public ICloneable, public INode
 {
 public:
-    IFTDistribution2D(double omega_x, double omega_y, double gamma);
     IFTDistribution2D(const NodeMeta& meta, const std::vector<double>& PValues);
 
     IFTDistribution2D* clone() const = 0;
 
-    void setGamma(double gamma) { m_gamma = gamma; }
+    double omegaX() const { return m_omega_x; }
+    double omegaY() const { return m_omega_y; }
     double gamma() const { return m_gamma; }
 
     //! Angle in direct space between X- and Y-axis of distribution.
     double delta() const { return M_PI_2; }
 
-    double omegaX() const { return m_omega_x; }
-    double omegaY() const { return m_omega_y; }
-
     //! evaluate Fourier transformed distribution for q in X,Y coordinates
     //! the original distribution (in real space) is assumed to be normalized:
     //! total integral is equal to 1
@@ -54,13 +50,11 @@ public:
 protected:
     double sumsq(double qx, double qy) const;
 
-    double m_omega_x; //!< Half-width of the distribution along its x-axis in nanometers.
-    double m_omega_y; //!< Half-width of the distribution along its y-axis in nanometers.
-    //! Angle in direct space between first lattice vector and X-axis of distribution.
-    double m_gamma;
+    const double& m_omega_x;
+    const double& m_omega_y;
+    const double& m_gamma;
 };
 
-
 //! Two-dimensional Cauchy distribution in Fourier space;
 //! corresponds to a normalized exp(-r) in real space,
 //! with \f$r=\sqrt{(\frac{x}{\omega_x})^2 + (\frac{y}{\omega_y})^2}\f$.
@@ -69,6 +63,7 @@ protected:
 class BA_CORE_API_ FTDistribution2DCauchy : public IFTDistribution2D
 {
 public:
+    FTDistribution2DCauchy(const std::vector<double> P);
     FTDistribution2DCauchy(double omega_x, double omega_y, double gamma);
 
     FTDistribution2DCauchy* clone() const final;
@@ -79,7 +74,6 @@ public:
 #endif
 };
 
-
 //! Two-dimensional Gauss distribution in Fourier space;
 //! corresponds to normalized exp(-r^2/2) in real space
 //! with \f$r=\sqrt{(\frac{x}{\omega_x})^2 + (\frac{y}{\omega_y})^2}\f$.
@@ -88,6 +82,7 @@ public:
 class BA_CORE_API_ FTDistribution2DGauss : public IFTDistribution2D
 {
 public:
+    FTDistribution2DGauss(const std::vector<double> P);
     FTDistribution2DGauss(double omega_x, double omega_y, double gamma);
 
     FTDistribution2DGauss* clone() const final;
@@ -98,7 +93,6 @@ public:
 #endif
 };
 
-
 //! Two-dimensional gate distribution in Fourier space;
 //! corresponds to normalized constant if r<1 (and 0 otherwise) in real space,
 //! with \f$r=\sqrt{(\frac{x}{\omega_x})^2 + (\frac{y}{\omega_y})^2}\f$.
@@ -107,6 +101,7 @@ public:
 class BA_CORE_API_ FTDistribution2DGate : public IFTDistribution2D
 {
 public:
+    FTDistribution2DGate(const std::vector<double> P);
     FTDistribution2DGate(double omega_x, double omega_y, double gamma);
 
     FTDistribution2DGate* clone() const final;
@@ -117,7 +112,6 @@ public:
 #endif
 };
 
-
 //! Two-dimensional cone distribution in Fourier space;
 //! corresponds to 1-r if r<1 (and 0 otherwise) in real space
 //! with \f$r=\sqrt{(\frac{x}{\omega_x})^2 + (\frac{y}{\omega_y})^2}\f$.
@@ -126,6 +120,7 @@ public:
 class BA_CORE_API_ FTDistribution2DCone : public IFTDistribution2D
 {
 public:
+    FTDistribution2DCone(const std::vector<double> P);
     FTDistribution2DCone(double omega_x, double omega_y, double gamma);
 
     FTDistribution2DCone* clone() const final;
@@ -139,7 +134,6 @@ private:
     mutable RealIntegrator m_integrator;
 };
 
-
 //! Two-dimensional Voigt distribution in Fourier space;
 //! corresponds to eta*Gauss + (1-eta)*Cauchy
 //! @ingroup distributionFT
@@ -147,6 +141,7 @@ private:
 class BA_CORE_API_ FTDistribution2DVoigt : public IFTDistribution2D
 {
 public:
+    FTDistribution2DVoigt(const std::vector<double> P);
     FTDistribution2DVoigt(double omega_x, double omega_y, double gamma, double eta);
 
     FTDistribution2DVoigt* clone() const final;
@@ -158,7 +153,7 @@ public:
 #endif
 
 protected:
-    double m_eta;
+    const double& m_eta;
 };
 
 #endif // BORNAGAIN_CORE_AGGREGATE_FTDISTRIBUTIONS2D_H
diff --git a/Core/StandardSamples/TwoDimLatticeBuilder.cpp b/Core/StandardSamples/TwoDimLatticeBuilder.cpp
index 116e25fea63..06e645d858e 100644
--- a/Core/StandardSamples/TwoDimLatticeBuilder.cpp
+++ b/Core/StandardSamples/TwoDimLatticeBuilder.cpp
@@ -155,8 +155,8 @@ MultiLayer* RotatedSquareLatticeBuilder::buildSample() const
     std::unique_ptr<InterferenceFunction2DLattice> P_interference_function{
         InterferenceFunction2DLattice::createSquare(10.0 * Units::nanometer, 30.0 * Units::degree)};
     FTDecayFunction2DCauchy pdf(300.0 * Units::nanometer / 2.0 / M_PI,
-                                100.0 * Units::nanometer / 2.0 / M_PI, 0);
-    pdf.setGamma(30.0 * Units::degree);
+                                100.0 * Units::nanometer / 2.0 / M_PI,
+                                30.0 * Units::degree);
     P_interference_function->setDecayFunction(pdf);
 
     ParticleLayout particle_layout;
diff --git a/Examples/python/simulation/ex03_InterferenceFunctions/Interference2DRotatedSquareLattice.py b/Examples/python/simulation/ex03_InterferenceFunctions/Interference2DRotatedSquareLattice.py
index 3ba2783f12a..b631a3ec945 100644
--- a/Examples/python/simulation/ex03_InterferenceFunctions/Interference2DRotatedSquareLattice.py
+++ b/Examples/python/simulation/ex03_InterferenceFunctions/Interference2DRotatedSquareLattice.py
@@ -19,7 +19,7 @@ def get_sample():
     interference = ba.InterferenceFunction2DLattice.createSquare(
         25.0*nm, 30.0*deg)
     pdf = ba.FTDecayFunction2DCauchy(300.0*nm/2.0/numpy.pi, 100.0*nm/2.0/numpy.pi, 0)
-    pdf.setGamma(30.0*deg)
+    pdf.setParameterValue("Gamma", 30.0*deg)
     interference.setDecayFunction(pdf)
 
     cylinder_ff = ba.FormFactorCylinder(3.*nm, 3.*nm)
diff --git a/Tests/UnitTests/Core/Parameters/FTDistributionsTest.cpp b/Tests/UnitTests/Core/Parameters/FTDistributionsTest.cpp
index 37d1056a072..432bbeabc51 100644
--- a/Tests/UnitTests/Core/Parameters/FTDistributionsTest.cpp
+++ b/Tests/UnitTests/Core/Parameters/FTDistributionsTest.cpp
@@ -17,11 +17,8 @@ TEST_F(FTDistributionsTest, FTDistribution1DCauchyConstructor)
     EXPECT_EQ(1.0, P_1d_cauchy->omega());
     EXPECT_NEAR(0.961538, P_1d_cauchy->evaluate(0.2), 0.000001);
 
-    P_1d_cauchy->setOmega(3.0);
-    EXPECT_EQ(3.0, P_1d_cauchy->omega());
-
-    P_1d_cauchy->setParameterValue("Omega", -7.0);
-    EXPECT_EQ(-7.0, P_1d_cauchy->omega());
+    P_1d_cauchy->setParameterValue("Omega", 7.0);
+    EXPECT_EQ(7.0, P_1d_cauchy->omega());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution1DCauchyClone)
@@ -38,9 +35,6 @@ TEST_F(FTDistributionsTest, FTDistribution1DGaussConstructor)
     std::unique_ptr<IFTDistribution1D> P_1d_gauss{new FTDistribution1DGauss(1.0)};
     EXPECT_EQ(1.0, P_1d_gauss->omega());
     EXPECT_NEAR(0.9801987, P_1d_gauss->evaluate(0.2), 0.000001);
-
-    P_1d_gauss->setOmega(3.0);
-    EXPECT_EQ(3.0, P_1d_gauss->omega());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution1DGaussClone)
@@ -57,9 +51,6 @@ TEST_F(FTDistributionsTest, FTDistribution1DGateConstructor)
     std::unique_ptr<IFTDistribution1D> P_1d_gate{new FTDistribution1DGate(1.0)};
     EXPECT_EQ(1.0, P_1d_gate->omega());
     EXPECT_NEAR(0.993347, P_1d_gate->evaluate(0.2), 0.000001);
-
-    P_1d_gate->setOmega(3.0);
-    EXPECT_EQ(3.0, P_1d_gate->omega());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution1DGateClone)
@@ -76,9 +67,6 @@ TEST_F(FTDistributionsTest, FTDistribution1DTriangleConstructor)
     std::unique_ptr<IFTDistribution1D> P_1d_triangle{new FTDistribution1DTriangle(1.0)};
     EXPECT_EQ(1.0, P_1d_triangle->omega());
     EXPECT_NEAR(0.996671, P_1d_triangle->evaluate(0.2), 0.000001);
-
-    P_1d_triangle->setOmega(3.0);
-    EXPECT_EQ(3.0, P_1d_triangle->omega());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution1DTriangleClone)
@@ -95,9 +83,6 @@ TEST_F(FTDistributionsTest, FTDistribution1DCosineConstructor)
     std::unique_ptr<IFTDistribution1D> P_1d_cosine{new FTDistribution1DCosine(1.0)};
     EXPECT_EQ(1.0, P_1d_cosine->omega());
     EXPECT_NEAR(0.997389, P_1d_cosine->evaluate(0.2), 0.000001);
-
-    P_1d_cosine->setOmega(3.0);
-    EXPECT_EQ(3.0, P_1d_cosine->omega());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution1DCosineClone)
@@ -114,9 +99,6 @@ TEST_F(FTDistributionsTest, FTDistribution1DVoigtConstructor)
     std::unique_ptr<IFTDistribution1D> P_1d_voigt{new FTDistribution1DVoigt(1.0, 1.7)};
     EXPECT_EQ(1.0, P_1d_voigt->omega());
     EXPECT_NEAR(0.993261, P_1d_voigt->evaluate(0.2), 0.000001);
-
-    P_1d_voigt->setOmega(3.0);
-    EXPECT_EQ(3.0, P_1d_voigt->omega());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution1DVoigtClone)
@@ -141,9 +123,9 @@ TEST_F(FTDistributionsTest, FTDistribution2DCauchyConstructor)
     EXPECT_EQ(0.0, P_2d_cauchy->gamma());
     EXPECT_NEAR(0.343206, P_2d_cauchy->evaluate(0.2, 0.5), 0.000001);
 
-    P_2d_cauchy->setGamma(3.0);
-    EXPECT_EQ(3.0, P_2d_cauchy->gamma());
-    EXPECT_EQ(3.0, P_2d_cauchy->parameter("Gamma")->value());
+    P_2d_cauchy->setParameterValue("Gamma", .123);
+    EXPECT_EQ(.123, P_2d_cauchy->gamma());
+    EXPECT_EQ(.123, P_2d_cauchy->parameter("Gamma")->value());
 
     P_2d_cauchy->setParameterValue("OmegaX", 7.0);
     P_2d_cauchy->setParameterValue("OmegaY", 5.3);
@@ -171,9 +153,6 @@ TEST_F(FTDistributionsTest, FTDistribution2DGaussConstructor)
     EXPECT_EQ(M_PI / 2.0, P_2d_gauss->delta());
     EXPECT_EQ(0.0, P_2d_gauss->gamma());
     EXPECT_NEAR(0.5945205, P_2d_gauss->evaluate(0.2, 0.5), 0.000001);
-
-    P_2d_gauss->setGamma(3.0);
-    EXPECT_EQ(3.0, P_2d_gauss->gamma());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution2DGaussClone)
@@ -196,9 +175,6 @@ TEST_F(FTDistributionsTest, FTDistribution2DGateConstructor)
     EXPECT_EQ(M_PI / 2.0, P_2d_gate->delta());
     EXPECT_EQ(0.0, P_2d_gate->gamma());
     EXPECT_NEAR(0.875513, P_2d_gate->evaluate(0.2, 0.5), 0.000001);
-
-    P_2d_gate->setGamma(3.0);
-    EXPECT_EQ(3.0, P_2d_gate->gamma());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution2DGateClone)
@@ -221,9 +197,6 @@ TEST_F(FTDistributionsTest, FTDistribution2DConeConstructor)
     EXPECT_EQ(M_PI / 2.0, P_2d_cone->delta());
     EXPECT_EQ(0.0, P_2d_cone->gamma());
     EXPECT_NEAR(0.924374, P_2d_cone->evaluate(0.2, 0.5), 0.000001);
-
-    P_2d_cone->setGamma(3.0);
-    EXPECT_EQ(3.0, P_2d_cone->gamma());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution2DConeClone)
@@ -246,9 +219,6 @@ TEST_F(FTDistributionsTest, FTDistribution2DVoigtConstructor)
     EXPECT_EQ(M_PI / 2.0, P_2d_voigt->delta());
     EXPECT_EQ(0.0, P_2d_voigt->gamma());
     EXPECT_NEAR(1.2228072, P_2d_voigt->evaluate(0.2, 0.5), 0.000001);
-
-    P_2d_voigt->setGamma(3.0);
-    EXPECT_EQ(3.0, P_2d_voigt->gamma());
 }
 
 TEST_F(FTDistributionsTest, FTDistribution2DVoigtClone)
diff --git a/auto/Wrap/libBornAgainCore.py b/auto/Wrap/libBornAgainCore.py
index 2fb5a99c63c..46912fc9f6e 100644
--- a/auto/Wrap/libBornAgainCore.py
+++ b/auto/Wrap/libBornAgainCore.py
@@ -10506,26 +10506,6 @@ class IFTDecayFunction2D(ICloneable, INode):
         """
         return _libBornAgainCore.IFTDecayFunction2D_clone(self)
 
-    def setGamma(self, gamma):
-        r"""
-        setGamma(IFTDecayFunction2D self, double gamma)
-        void IFTDecayFunction2D::setGamma(double gamma)
-
-        set angle between first lattice vector and X-axis of distribution (both in direct space) 
-
-        """
-        return _libBornAgainCore.IFTDecayFunction2D_setGamma(self, gamma)
-
-    def gamma(self):
-        r"""
-        gamma(IFTDecayFunction2D self) -> double
-        double IFTDecayFunction2D::gamma() const
-
-        get angle between first lattice vector and X-axis of distribution (both in direct space) 
-
-        """
-        return _libBornAgainCore.IFTDecayFunction2D_gamma(self)
-
     def decayLengthX(self):
         r"""
         decayLengthX(IFTDecayFunction2D self) -> double
@@ -10546,6 +10526,16 @@ class IFTDecayFunction2D(ICloneable, INode):
         """
         return _libBornAgainCore.IFTDecayFunction2D_decayLengthY(self)
 
+    def gamma(self):
+        r"""
+        gamma(IFTDecayFunction2D self) -> double
+        double IFTDecayFunction2D::gamma() const
+
+        get angle between first lattice vector and X-axis of distribution (both in direct space) 
+
+        """
+        return _libBornAgainCore.IFTDecayFunction2D_gamma(self)
+
     def evaluate(self, qx, qy):
         r"""
         evaluate(IFTDecayFunction2D self, double qx, double qy) -> double
@@ -10793,14 +10783,6 @@ class IFTDistribution1D(ICloneable, INode):
         """
         return _libBornAgainCore.IFTDistribution1D_evaluate(self, q)
 
-    def setOmega(self, omega):
-        r"""
-        setOmega(IFTDistribution1D self, double omega)
-        void IFTDistribution1D::setOmega(double omega)
-
-        """
-        return _libBornAgainCore.IFTDistribution1D_setOmega(self, omega)
-
     def omega(self):
         r"""
         omega(IFTDistribution1D self) -> double
@@ -10836,13 +10818,14 @@ class FTDistribution1DCauchy(IFTDistribution1D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution1DCauchy self, vdouble1d_t P) -> FTDistribution1DCauchy
         __init__(FTDistribution1DCauchy self, double omega) -> FTDistribution1DCauchy
         FTDistribution1DCauchy::FTDistribution1DCauchy(double omega)
 
         """
-        _libBornAgainCore.FTDistribution1DCauchy_swiginit(self, _libBornAgainCore.new_FTDistribution1DCauchy(omega))
+        _libBornAgainCore.FTDistribution1DCauchy_swiginit(self, _libBornAgainCore.new_FTDistribution1DCauchy(*args))
 
     def clone(self):
         r"""
@@ -10899,13 +10882,14 @@ class FTDistribution1DGauss(IFTDistribution1D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution1DGauss self, vdouble1d_t P) -> FTDistribution1DGauss
         __init__(FTDistribution1DGauss self, double omega) -> FTDistribution1DGauss
         FTDistribution1DGauss::FTDistribution1DGauss(double omega)
 
         """
-        _libBornAgainCore.FTDistribution1DGauss_swiginit(self, _libBornAgainCore.new_FTDistribution1DGauss(omega))
+        _libBornAgainCore.FTDistribution1DGauss_swiginit(self, _libBornAgainCore.new_FTDistribution1DGauss(*args))
 
     def clone(self):
         r"""
@@ -10962,13 +10946,14 @@ class FTDistribution1DGate(IFTDistribution1D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution1DGate self, vdouble1d_t P) -> FTDistribution1DGate
         __init__(FTDistribution1DGate self, double omega) -> FTDistribution1DGate
         FTDistribution1DGate::FTDistribution1DGate(double omega)
 
         """
-        _libBornAgainCore.FTDistribution1DGate_swiginit(self, _libBornAgainCore.new_FTDistribution1DGate(omega))
+        _libBornAgainCore.FTDistribution1DGate_swiginit(self, _libBornAgainCore.new_FTDistribution1DGate(*args))
 
     def clone(self):
         r"""
@@ -11025,13 +11010,14 @@ class FTDistribution1DTriangle(IFTDistribution1D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution1DTriangle self, vdouble1d_t P) -> FTDistribution1DTriangle
         __init__(FTDistribution1DTriangle self, double omega) -> FTDistribution1DTriangle
         FTDistribution1DTriangle::FTDistribution1DTriangle(double omega)
 
         """
-        _libBornAgainCore.FTDistribution1DTriangle_swiginit(self, _libBornAgainCore.new_FTDistribution1DTriangle(omega))
+        _libBornAgainCore.FTDistribution1DTriangle_swiginit(self, _libBornAgainCore.new_FTDistribution1DTriangle(*args))
 
     def clone(self):
         r"""
@@ -11088,13 +11074,14 @@ class FTDistribution1DCosine(IFTDistribution1D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution1DCosine self, vdouble1d_t P) -> FTDistribution1DCosine
         __init__(FTDistribution1DCosine self, double omega) -> FTDistribution1DCosine
         FTDistribution1DCosine::FTDistribution1DCosine(double omega)
 
         """
-        _libBornAgainCore.FTDistribution1DCosine_swiginit(self, _libBornAgainCore.new_FTDistribution1DCosine(omega))
+        _libBornAgainCore.FTDistribution1DCosine_swiginit(self, _libBornAgainCore.new_FTDistribution1DCosine(*args))
 
     def clone(self):
         r"""
@@ -11151,8 +11138,9 @@ class FTDistribution1DVoigt(IFTDistribution1D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega, eta):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution1DVoigt self, vdouble1d_t P) -> FTDistribution1DVoigt
         __init__(FTDistribution1DVoigt self, double omega, double eta) -> FTDistribution1DVoigt
         FTDistribution1DVoigt::FTDistribution1DVoigt(double omega, double eta)
 
@@ -11168,7 +11156,7 @@ class FTDistribution1DVoigt(IFTDistribution1D):
         parameter [0,1] to balance between Cauchy (eta=0.0) and Gauss (eta=1.0) 
 
         """
-        _libBornAgainCore.FTDistribution1DVoigt_swiginit(self, _libBornAgainCore.new_FTDistribution1DVoigt(omega, eta))
+        _libBornAgainCore.FTDistribution1DVoigt_swiginit(self, _libBornAgainCore.new_FTDistribution1DVoigt(*args))
 
     def clone(self):
         r"""
@@ -11244,13 +11232,21 @@ class IFTDistribution2D(ICloneable, INode):
         """
         return _libBornAgainCore.IFTDistribution2D_clone(self)
 
-    def setGamma(self, gamma):
+    def omegaX(self):
         r"""
-        setGamma(IFTDistribution2D self, double gamma)
-        void IFTDistribution2D::setGamma(double gamma)
+        omegaX(IFTDistribution2D self) -> double
+        double IFTDistribution2D::omegaX() const
 
         """
-        return _libBornAgainCore.IFTDistribution2D_setGamma(self, gamma)
+        return _libBornAgainCore.IFTDistribution2D_omegaX(self)
+
+    def omegaY(self):
+        r"""
+        omegaY(IFTDistribution2D self) -> double
+        double IFTDistribution2D::omegaY() const
+
+        """
+        return _libBornAgainCore.IFTDistribution2D_omegaY(self)
 
     def gamma(self):
         r"""
@@ -11268,22 +11264,6 @@ class IFTDistribution2D(ICloneable, INode):
         """
         return _libBornAgainCore.IFTDistribution2D_delta(self)
 
-    def omegaX(self):
-        r"""
-        omegaX(IFTDistribution2D self) -> double
-        double IFTDistribution2D::omegaX() const
-
-        """
-        return _libBornAgainCore.IFTDistribution2D_omegaX(self)
-
-    def omegaY(self):
-        r"""
-        omegaY(IFTDistribution2D self) -> double
-        double IFTDistribution2D::omegaY() const
-
-        """
-        return _libBornAgainCore.IFTDistribution2D_omegaY(self)
-
     def evaluate(self, qx, qy):
         r"""
         evaluate(IFTDistribution2D self, double qx, double qy) -> double
@@ -11311,13 +11291,14 @@ class FTDistribution2DCauchy(IFTDistribution2D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega_x, omega_y, gamma):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution2DCauchy self, vdouble1d_t P) -> FTDistribution2DCauchy
         __init__(FTDistribution2DCauchy self, double omega_x, double omega_y, double gamma) -> FTDistribution2DCauchy
         FTDistribution2DCauchy::FTDistribution2DCauchy(double omega_x, double omega_y, double gamma=0)
 
         """
-        _libBornAgainCore.FTDistribution2DCauchy_swiginit(self, _libBornAgainCore.new_FTDistribution2DCauchy(omega_x, omega_y, gamma))
+        _libBornAgainCore.FTDistribution2DCauchy_swiginit(self, _libBornAgainCore.new_FTDistribution2DCauchy(*args))
 
     def clone(self):
         r"""
@@ -11364,13 +11345,14 @@ class FTDistribution2DGauss(IFTDistribution2D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega_x, omega_y, gamma):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution2DGauss self, vdouble1d_t P) -> FTDistribution2DGauss
         __init__(FTDistribution2DGauss self, double omega_x, double omega_y, double gamma) -> FTDistribution2DGauss
         FTDistribution2DGauss::FTDistribution2DGauss(double omega_x, double omega_y, double gamma=0)
 
         """
-        _libBornAgainCore.FTDistribution2DGauss_swiginit(self, _libBornAgainCore.new_FTDistribution2DGauss(omega_x, omega_y, gamma))
+        _libBornAgainCore.FTDistribution2DGauss_swiginit(self, _libBornAgainCore.new_FTDistribution2DGauss(*args))
 
     def clone(self):
         r"""
@@ -11417,13 +11399,14 @@ class FTDistribution2DGate(IFTDistribution2D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega_x, omega_y, gamma):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution2DGate self, vdouble1d_t P) -> FTDistribution2DGate
         __init__(FTDistribution2DGate self, double omega_x, double omega_y, double gamma) -> FTDistribution2DGate
         FTDistribution2DGate::FTDistribution2DGate(double omega_x, double omega_y, double gamma=0)
 
         """
-        _libBornAgainCore.FTDistribution2DGate_swiginit(self, _libBornAgainCore.new_FTDistribution2DGate(omega_x, omega_y, gamma))
+        _libBornAgainCore.FTDistribution2DGate_swiginit(self, _libBornAgainCore.new_FTDistribution2DGate(*args))
 
     def clone(self):
         r"""
@@ -11470,13 +11453,14 @@ class FTDistribution2DCone(IFTDistribution2D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega_x, omega_y, gamma):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution2DCone self, vdouble1d_t P) -> FTDistribution2DCone
         __init__(FTDistribution2DCone self, double omega_x, double omega_y, double gamma) -> FTDistribution2DCone
         FTDistribution2DCone::FTDistribution2DCone(double omega_x, double omega_y, double gamma=0)
 
         """
-        _libBornAgainCore.FTDistribution2DCone_swiginit(self, _libBornAgainCore.new_FTDistribution2DCone(omega_x, omega_y, gamma))
+        _libBornAgainCore.FTDistribution2DCone_swiginit(self, _libBornAgainCore.new_FTDistribution2DCone(*args))
 
     def clone(self):
         r"""
@@ -11523,8 +11507,9 @@ class FTDistribution2DVoigt(IFTDistribution2D):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
 
-    def __init__(self, omega_x, omega_y, gamma, eta):
+    def __init__(self, *args):
         r"""
+        __init__(FTDistribution2DVoigt self, vdouble1d_t P) -> FTDistribution2DVoigt
         __init__(FTDistribution2DVoigt self, double omega_x, double omega_y, double gamma, double eta) -> FTDistribution2DVoigt
         FTDistribution2DVoigt::FTDistribution2DVoigt(double omega_x, double omega_y, double eta, double gamma=0)
 
@@ -11546,7 +11531,7 @@ class FTDistribution2DVoigt(IFTDistribution2D):
         angle in direct space between first lattice vector and x-axis of the distribution in radians 
 
         """
-        _libBornAgainCore.FTDistribution2DVoigt_swiginit(self, _libBornAgainCore.new_FTDistribution2DVoigt(omega_x, omega_y, gamma, eta))
+        _libBornAgainCore.FTDistribution2DVoigt_swiginit(self, _libBornAgainCore.new_FTDistribution2DVoigt(*args))
 
     def clone(self):
         r"""
diff --git a/auto/Wrap/libBornAgainCore_wrap.cpp b/auto/Wrap/libBornAgainCore_wrap.cpp
index 0cf6893d320..9a12df0aca5 100644
--- a/auto/Wrap/libBornAgainCore_wrap.cpp
+++ b/auto/Wrap/libBornAgainCore_wrap.cpp
@@ -76526,36 +76526,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_setGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  IFTDecayFunction2D *arg1 = (IFTDecayFunction2D *) 0 ;
-  double arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
-  PyObject *swig_obj[2] ;
-  
-  if (!SWIG_Python_UnpackTuple(args, "IFTDecayFunction2D_setGamma", 2, 2, swig_obj)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDecayFunction2D, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDecayFunction2D_setGamma" "', argument " "1"" of type '" "IFTDecayFunction2D *""'"); 
-  }
-  arg1 = reinterpret_cast< IFTDecayFunction2D * >(argp1);
-  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFTDecayFunction2D_setGamma" "', argument " "2"" of type '" "double""'");
-  } 
-  arg2 = static_cast< double >(val2);
-  (arg1)->setGamma(arg2);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_decayLengthX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDecayFunction2D *arg1 = (IFTDecayFunction2D *) 0 ;
   void *argp1 = 0 ;
@@ -76567,10 +76538,10 @@ SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_gamma(PyObject *SWIGUNUSEDPARM(sel
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDecayFunction2D, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDecayFunction2D_gamma" "', argument " "1"" of type '" "IFTDecayFunction2D const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDecayFunction2D_decayLengthX" "', argument " "1"" of type '" "IFTDecayFunction2D const *""'"); 
   }
   arg1 = reinterpret_cast< IFTDecayFunction2D * >(argp1);
-  result = (double)((IFTDecayFunction2D const *)arg1)->gamma();
+  result = (double)((IFTDecayFunction2D const *)arg1)->decayLengthX();
   resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
@@ -76578,7 +76549,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_decayLengthX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_decayLengthY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDecayFunction2D *arg1 = (IFTDecayFunction2D *) 0 ;
   void *argp1 = 0 ;
@@ -76590,10 +76561,10 @@ SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_decayLengthX(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDecayFunction2D, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDecayFunction2D_decayLengthX" "', argument " "1"" of type '" "IFTDecayFunction2D const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDecayFunction2D_decayLengthY" "', argument " "1"" of type '" "IFTDecayFunction2D const *""'"); 
   }
   arg1 = reinterpret_cast< IFTDecayFunction2D * >(argp1);
-  result = (double)((IFTDecayFunction2D const *)arg1)->decayLengthX();
+  result = (double)((IFTDecayFunction2D const *)arg1)->decayLengthY();
   resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
@@ -76601,7 +76572,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_decayLengthY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDecayFunction2D *arg1 = (IFTDecayFunction2D *) 0 ;
   void *argp1 = 0 ;
@@ -76613,10 +76584,10 @@ SWIGINTERN PyObject *_wrap_IFTDecayFunction2D_decayLengthY(PyObject *SWIGUNUSEDP
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDecayFunction2D, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDecayFunction2D_decayLengthY" "', argument " "1"" of type '" "IFTDecayFunction2D const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDecayFunction2D_gamma" "', argument " "1"" of type '" "IFTDecayFunction2D const *""'"); 
   }
   arg1 = reinterpret_cast< IFTDecayFunction2D * >(argp1);
-  result = (double)((IFTDecayFunction2D const *)arg1)->decayLengthY();
+  result = (double)((IFTDecayFunction2D const *)arg1)->gamma();
   resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
@@ -77536,35 +77507,6 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDistribution1D_setOmega(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  IFTDistribution1D *arg1 = (IFTDistribution1D *) 0 ;
-  double arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
-  PyObject *swig_obj[2] ;
-  
-  if (!SWIG_Python_UnpackTuple(args, "IFTDistribution1D_setOmega", 2, 2, swig_obj)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDistribution1D, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution1D_setOmega" "', argument " "1"" of type '" "IFTDistribution1D *""'"); 
-  }
-  arg1 = reinterpret_cast< IFTDistribution1D * >(argp1);
-  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFTDistribution1D_setOmega" "', argument " "2"" of type '" "double""'");
-  } 
-  arg2 = static_cast< double >(val2);
-  (arg1)->setOmega(arg2);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
 SWIGINTERN PyObject *_wrap_IFTDistribution1D_omega(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDistribution1D *arg1 = (IFTDistribution1D *) 0 ;
@@ -77640,16 +77582,37 @@ SWIGINTERN PyObject *IFTDistribution1D_swigregister(PyObject *SWIGUNUSEDPARM(sel
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution1DCauchy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DCauchy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution1DCauchy *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution1DCauchy" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution1DCauchy *)new FTDistribution1DCauchy(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution1DCauchy, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DCauchy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double val1 ;
   int ecode1 = 0 ;
-  PyObject *swig_obj[1] ;
   FTDistribution1DCauchy *result = 0 ;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution1DCauchy" "', argument " "1"" of type '" "double""'");
@@ -77663,6 +77626,42 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DCauchy(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution1DCauchy", 0, 1, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FTDistribution1DCauchy__SWIG_1(self, argc, argv);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution1DCauchy__SWIG_0(self, argc, argv);
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution1DCauchy'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution1DCauchy::FTDistribution1DCauchy(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution1DCauchy::FTDistribution1DCauchy(double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution1DCauchy_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution1DCauchy *arg1 = (FTDistribution1DCauchy *) 0 ;
@@ -77801,16 +77800,37 @@ SWIGINTERN PyObject *FTDistribution1DCauchy_swiginit(PyObject *SWIGUNUSEDPARM(se
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution1DGauss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DGauss__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution1DGauss *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution1DGauss" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution1DGauss *)new FTDistribution1DGauss(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution1DGauss, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DGauss__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double val1 ;
   int ecode1 = 0 ;
-  PyObject *swig_obj[1] ;
   FTDistribution1DGauss *result = 0 ;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution1DGauss" "', argument " "1"" of type '" "double""'");
@@ -77824,6 +77844,42 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DGauss(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution1DGauss", 0, 1, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FTDistribution1DGauss__SWIG_1(self, argc, argv);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution1DGauss__SWIG_0(self, argc, argv);
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution1DGauss'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution1DGauss::FTDistribution1DGauss(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution1DGauss::FTDistribution1DGauss(double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution1DGauss_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution1DGauss *arg1 = (FTDistribution1DGauss *) 0 ;
@@ -77962,16 +78018,37 @@ SWIGINTERN PyObject *FTDistribution1DGauss_swiginit(PyObject *SWIGUNUSEDPARM(sel
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution1DGate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DGate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution1DGate *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution1DGate" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution1DGate *)new FTDistribution1DGate(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution1DGate, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DGate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double val1 ;
   int ecode1 = 0 ;
-  PyObject *swig_obj[1] ;
   FTDistribution1DGate *result = 0 ;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution1DGate" "', argument " "1"" of type '" "double""'");
@@ -77985,6 +78062,42 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DGate(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution1DGate", 0, 1, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FTDistribution1DGate__SWIG_1(self, argc, argv);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution1DGate__SWIG_0(self, argc, argv);
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution1DGate'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution1DGate::FTDistribution1DGate(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution1DGate::FTDistribution1DGate(double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution1DGate_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution1DGate *arg1 = (FTDistribution1DGate *) 0 ;
@@ -78123,16 +78236,37 @@ SWIGINTERN PyObject *FTDistribution1DGate_swiginit(PyObject *SWIGUNUSEDPARM(self
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution1DTriangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DTriangle__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution1DTriangle *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution1DTriangle" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution1DTriangle *)new FTDistribution1DTriangle(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution1DTriangle, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DTriangle__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double val1 ;
   int ecode1 = 0 ;
-  PyObject *swig_obj[1] ;
   FTDistribution1DTriangle *result = 0 ;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution1DTriangle" "', argument " "1"" of type '" "double""'");
@@ -78146,6 +78280,42 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DTriangle(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution1DTriangle", 0, 1, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FTDistribution1DTriangle__SWIG_1(self, argc, argv);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution1DTriangle__SWIG_0(self, argc, argv);
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution1DTriangle'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution1DTriangle::FTDistribution1DTriangle(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution1DTriangle::FTDistribution1DTriangle(double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution1DTriangle_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution1DTriangle *arg1 = (FTDistribution1DTriangle *) 0 ;
@@ -78284,16 +78454,37 @@ SWIGINTERN PyObject *FTDistribution1DTriangle_swiginit(PyObject *SWIGUNUSEDPARM(
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution1DCosine(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DCosine__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution1DCosine *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution1DCosine" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution1DCosine *)new FTDistribution1DCosine(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution1DCosine, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DCosine__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double val1 ;
   int ecode1 = 0 ;
-  PyObject *swig_obj[1] ;
   FTDistribution1DCosine *result = 0 ;
   
-  if (!args) SWIG_fail;
-  swig_obj[0] = args;
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution1DCosine" "', argument " "1"" of type '" "double""'");
@@ -78307,6 +78498,42 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DCosine(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[2] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution1DCosine", 0, 1, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      return _wrap_new_FTDistribution1DCosine__SWIG_1(self, argc, argv);
+    }
+  }
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution1DCosine__SWIG_0(self, argc, argv);
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution1DCosine'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution1DCosine::FTDistribution1DCosine(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution1DCosine::FTDistribution1DCosine(double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution1DCosine_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution1DCosine *arg1 = (FTDistribution1DCosine *) 0 ;
@@ -78445,7 +78672,30 @@ SWIGINTERN PyObject *FTDistribution1DCosine_swiginit(PyObject *SWIGUNUSEDPARM(se
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution1DVoigt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DVoigt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution1DVoigt *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution1DVoigt" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution1DVoigt *)new FTDistribution1DVoigt(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution1DVoigt, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DVoigt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double arg2 ;
@@ -78453,10 +78703,9 @@ SWIGINTERN PyObject *_wrap_new_FTDistribution1DVoigt(PyObject *SWIGUNUSEDPARM(se
   int ecode1 = 0 ;
   double val2 ;
   int ecode2 = 0 ;
-  PyObject *swig_obj[2] ;
   FTDistribution1DVoigt *result = 0 ;
   
-  if (!SWIG_Python_UnpackTuple(args, "new_FTDistribution1DVoigt", 2, 2, swig_obj)) SWIG_fail;
+  if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution1DVoigt" "', argument " "1"" of type '" "double""'");
@@ -78475,6 +78724,48 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution1DVoigt(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[3] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution1DVoigt", 0, 2, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution1DVoigt__SWIG_0(self, argc, argv);
+    }
+  }
+  if (argc == 2) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        return _wrap_new_FTDistribution1DVoigt__SWIG_1(self, argc, argv);
+      }
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution1DVoigt'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution1DVoigt::FTDistribution1DVoigt(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution1DVoigt::FTDistribution1DVoigt(double,double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution1DVoigt_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution1DVoigt *arg1 = (FTDistribution1DVoigt *) 0 ;
@@ -78659,36 +78950,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDistribution2D_setGamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
-  PyObject *resultobj = 0;
-  IFTDistribution2D *arg1 = (IFTDistribution2D *) 0 ;
-  double arg2 ;
-  void *argp1 = 0 ;
-  int res1 = 0 ;
-  double val2 ;
-  int ecode2 = 0 ;
-  PyObject *swig_obj[2] ;
-  
-  if (!SWIG_Python_UnpackTuple(args, "IFTDistribution2D_setGamma", 2, 2, swig_obj)) SWIG_fail;
-  res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDistribution2D, 0 |  0 );
-  if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_setGamma" "', argument " "1"" of type '" "IFTDistribution2D *""'"); 
-  }
-  arg1 = reinterpret_cast< IFTDistribution2D * >(argp1);
-  ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
-  if (!SWIG_IsOK(ecode2)) {
-    SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IFTDistribution2D_setGamma" "', argument " "2"" of type '" "double""'");
-  } 
-  arg2 = static_cast< double >(val2);
-  (arg1)->setGamma(arg2);
-  resultobj = SWIG_Py_Void();
-  return resultobj;
-fail:
-  return NULL;
-}
-
-
-SWIGINTERN PyObject *_wrap_IFTDistribution2D_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_IFTDistribution2D_omegaX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDistribution2D *arg1 = (IFTDistribution2D *) 0 ;
   void *argp1 = 0 ;
@@ -78700,10 +78962,10 @@ SWIGINTERN PyObject *_wrap_IFTDistribution2D_gamma(PyObject *SWIGUNUSEDPARM(self
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDistribution2D, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_gamma" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_omegaX" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
   }
   arg1 = reinterpret_cast< IFTDistribution2D * >(argp1);
-  result = (double)((IFTDistribution2D const *)arg1)->gamma();
+  result = (double)((IFTDistribution2D const *)arg1)->omegaX();
   resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
@@ -78711,7 +78973,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDistribution2D_delta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_IFTDistribution2D_omegaY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDistribution2D *arg1 = (IFTDistribution2D *) 0 ;
   void *argp1 = 0 ;
@@ -78723,10 +78985,10 @@ SWIGINTERN PyObject *_wrap_IFTDistribution2D_delta(PyObject *SWIGUNUSEDPARM(self
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDistribution2D, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_delta" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_omegaY" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
   }
   arg1 = reinterpret_cast< IFTDistribution2D * >(argp1);
-  result = (double)((IFTDistribution2D const *)arg1)->delta();
+  result = (double)((IFTDistribution2D const *)arg1)->omegaY();
   resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
@@ -78734,7 +78996,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDistribution2D_omegaX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_IFTDistribution2D_gamma(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDistribution2D *arg1 = (IFTDistribution2D *) 0 ;
   void *argp1 = 0 ;
@@ -78746,10 +79008,10 @@ SWIGINTERN PyObject *_wrap_IFTDistribution2D_omegaX(PyObject *SWIGUNUSEDPARM(sel
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDistribution2D, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_omegaX" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_gamma" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
   }
   arg1 = reinterpret_cast< IFTDistribution2D * >(argp1);
-  result = (double)((IFTDistribution2D const *)arg1)->omegaX();
+  result = (double)((IFTDistribution2D const *)arg1)->gamma();
   resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
@@ -78757,7 +79019,7 @@ fail:
 }
 
 
-SWIGINTERN PyObject *_wrap_IFTDistribution2D_omegaY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_IFTDistribution2D_delta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   IFTDistribution2D *arg1 = (IFTDistribution2D *) 0 ;
   void *argp1 = 0 ;
@@ -78769,10 +79031,10 @@ SWIGINTERN PyObject *_wrap_IFTDistribution2D_omegaY(PyObject *SWIGUNUSEDPARM(sel
   swig_obj[0] = args;
   res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IFTDistribution2D, 0 |  0 );
   if (!SWIG_IsOK(res1)) {
-    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_omegaY" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
+    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IFTDistribution2D_delta" "', argument " "1"" of type '" "IFTDistribution2D const *""'"); 
   }
   arg1 = reinterpret_cast< IFTDistribution2D * >(argp1);
-  result = (double)((IFTDistribution2D const *)arg1)->omegaY();
+  result = (double)((IFTDistribution2D const *)arg1)->delta();
   resultobj = SWIG_From_double(static_cast< double >(result));
   return resultobj;
 fail:
@@ -78847,7 +79109,30 @@ SWIGINTERN PyObject *IFTDistribution2D_swigregister(PyObject *SWIGUNUSEDPARM(sel
   return SWIG_Py_Void();
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution2DCauchy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DCauchy__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution2DCauchy *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution2DCauchy" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution2DCauchy *)new FTDistribution2DCauchy(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution2DCauchy, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DCauchy__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double arg2 ;
@@ -78858,10 +79143,9 @@ SWIGINTERN PyObject *_wrap_new_FTDistribution2DCauchy(PyObject *SWIGUNUSEDPARM(s
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
-  PyObject *swig_obj[3] ;
   FTDistribution2DCauchy *result = 0 ;
   
-  if (!SWIG_Python_UnpackTuple(args, "new_FTDistribution2DCauchy", 3, 3, swig_obj)) SWIG_fail;
+  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution2DCauchy" "', argument " "1"" of type '" "double""'");
@@ -78885,6 +79169,54 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DCauchy(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution2DCauchy", 0, 3, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution2DCauchy__SWIG_0(self, argc, argv);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FTDistribution2DCauchy__SWIG_1(self, argc, argv);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution2DCauchy'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution2DCauchy::FTDistribution2DCauchy(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution2DCauchy::FTDistribution2DCauchy(double,double,double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution2DCauchy_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution2DCauchy *arg1 = (FTDistribution2DCauchy *) 0 ;
@@ -79008,7 +79340,30 @@ SWIGINTERN PyObject *FTDistribution2DCauchy_swiginit(PyObject *SWIGUNUSEDPARM(se
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution2DGauss(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DGauss__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution2DGauss *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution2DGauss" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution2DGauss *)new FTDistribution2DGauss(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution2DGauss, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DGauss__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double arg2 ;
@@ -79019,10 +79374,9 @@ SWIGINTERN PyObject *_wrap_new_FTDistribution2DGauss(PyObject *SWIGUNUSEDPARM(se
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
-  PyObject *swig_obj[3] ;
   FTDistribution2DGauss *result = 0 ;
   
-  if (!SWIG_Python_UnpackTuple(args, "new_FTDistribution2DGauss", 3, 3, swig_obj)) SWIG_fail;
+  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution2DGauss" "', argument " "1"" of type '" "double""'");
@@ -79046,6 +79400,54 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DGauss(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution2DGauss", 0, 3, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution2DGauss__SWIG_0(self, argc, argv);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FTDistribution2DGauss__SWIG_1(self, argc, argv);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution2DGauss'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution2DGauss::FTDistribution2DGauss(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution2DGauss::FTDistribution2DGauss(double,double,double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution2DGauss_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution2DGauss *arg1 = (FTDistribution2DGauss *) 0 ;
@@ -79169,7 +79571,30 @@ SWIGINTERN PyObject *FTDistribution2DGauss_swiginit(PyObject *SWIGUNUSEDPARM(sel
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution2DGate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DGate__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution2DGate *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution2DGate" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution2DGate *)new FTDistribution2DGate(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution2DGate, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DGate__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double arg2 ;
@@ -79180,10 +79605,9 @@ SWIGINTERN PyObject *_wrap_new_FTDistribution2DGate(PyObject *SWIGUNUSEDPARM(sel
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
-  PyObject *swig_obj[3] ;
   FTDistribution2DGate *result = 0 ;
   
-  if (!SWIG_Python_UnpackTuple(args, "new_FTDistribution2DGate", 3, 3, swig_obj)) SWIG_fail;
+  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution2DGate" "', argument " "1"" of type '" "double""'");
@@ -79207,6 +79631,54 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DGate(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution2DGate", 0, 3, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution2DGate__SWIG_0(self, argc, argv);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FTDistribution2DGate__SWIG_1(self, argc, argv);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution2DGate'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution2DGate::FTDistribution2DGate(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution2DGate::FTDistribution2DGate(double,double,double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution2DGate_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution2DGate *arg1 = (FTDistribution2DGate *) 0 ;
@@ -79330,7 +79802,30 @@ SWIGINTERN PyObject *FTDistribution2DGate_swiginit(PyObject *SWIGUNUSEDPARM(self
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution2DCone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DCone__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution2DCone *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution2DCone" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution2DCone *)new FTDistribution2DCone(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution2DCone, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DCone__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double arg2 ;
@@ -79341,10 +79836,9 @@ SWIGINTERN PyObject *_wrap_new_FTDistribution2DCone(PyObject *SWIGUNUSEDPARM(sel
   int ecode2 = 0 ;
   double val3 ;
   int ecode3 = 0 ;
-  PyObject *swig_obj[3] ;
   FTDistribution2DCone *result = 0 ;
   
-  if (!SWIG_Python_UnpackTuple(args, "new_FTDistribution2DCone", 3, 3, swig_obj)) SWIG_fail;
+  if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution2DCone" "', argument " "1"" of type '" "double""'");
@@ -79368,6 +79862,54 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DCone(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[4] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution2DCone", 0, 3, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution2DCone__SWIG_0(self, argc, argv);
+    }
+  }
+  if (argc == 3) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          return _wrap_new_FTDistribution2DCone__SWIG_1(self, argc, argv);
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution2DCone'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution2DCone::FTDistribution2DCone(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution2DCone::FTDistribution2DCone(double,double,double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution2DCone_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution2DCone *arg1 = (FTDistribution2DCone *) 0 ;
@@ -79491,7 +80033,30 @@ SWIGINTERN PyObject *FTDistribution2DCone_swiginit(PyObject *SWIGUNUSEDPARM(self
   return SWIG_Python_InitShadowInstance(args);
 }
 
-SWIGINTERN PyObject *_wrap_new_FTDistribution2DVoigt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DVoigt__SWIG_0(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
+  PyObject *resultobj = 0;
+  std::vector< double,std::allocator< double > > arg1 ;
+  FTDistribution2DVoigt *result = 0 ;
+  
+  if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
+  {
+    std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
+    int res = swig::asptr(swig_obj[0], &ptr);
+    if (!SWIG_IsOK(res) || !ptr) {
+      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in method '" "new_FTDistribution2DVoigt" "', argument " "1"" of type '" "std::vector< double,std::allocator< double > > const""'"); 
+    }
+    arg1 = *ptr;
+    if (SWIG_IsNewObj(res)) delete ptr;
+  }
+  result = (FTDistribution2DVoigt *)new FTDistribution2DVoigt(arg1);
+  resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FTDistribution2DVoigt, SWIG_POINTER_NEW |  0 );
+  return resultobj;
+fail:
+  return NULL;
+}
+
+
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DVoigt__SWIG_1(PyObject *SWIGUNUSEDPARM(self), Py_ssize_t nobjs, PyObject **swig_obj) {
   PyObject *resultobj = 0;
   double arg1 ;
   double arg2 ;
@@ -79505,10 +80070,9 @@ SWIGINTERN PyObject *_wrap_new_FTDistribution2DVoigt(PyObject *SWIGUNUSEDPARM(se
   int ecode3 = 0 ;
   double val4 ;
   int ecode4 = 0 ;
-  PyObject *swig_obj[4] ;
   FTDistribution2DVoigt *result = 0 ;
   
-  if (!SWIG_Python_UnpackTuple(args, "new_FTDistribution2DVoigt", 4, 4, swig_obj)) SWIG_fail;
+  if ((nobjs < 4) || (nobjs > 4)) SWIG_fail;
   ecode1 = SWIG_AsVal_double(swig_obj[0], &val1);
   if (!SWIG_IsOK(ecode1)) {
     SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FTDistribution2DVoigt" "', argument " "1"" of type '" "double""'");
@@ -79537,6 +80101,60 @@ fail:
 }
 
 
+SWIGINTERN PyObject *_wrap_new_FTDistribution2DVoigt(PyObject *self, PyObject *args) {
+  Py_ssize_t argc;
+  PyObject *argv[5] = {
+    0
+  };
+  
+  if (!(argc = SWIG_Python_UnpackTuple(args, "new_FTDistribution2DVoigt", 0, 4, argv))) SWIG_fail;
+  --argc;
+  if (argc == 1) {
+    int _v;
+    int res = swig::asptr(argv[0], (std::vector< double,std::allocator< double > >**)(0));
+    _v = SWIG_CheckState(res);
+    if (_v) {
+      return _wrap_new_FTDistribution2DVoigt__SWIG_0(self, argc, argv);
+    }
+  }
+  if (argc == 4) {
+    int _v;
+    {
+      int res = SWIG_AsVal_double(argv[0], NULL);
+      _v = SWIG_CheckState(res);
+    }
+    if (_v) {
+      {
+        int res = SWIG_AsVal_double(argv[1], NULL);
+        _v = SWIG_CheckState(res);
+      }
+      if (_v) {
+        {
+          int res = SWIG_AsVal_double(argv[2], NULL);
+          _v = SWIG_CheckState(res);
+        }
+        if (_v) {
+          {
+            int res = SWIG_AsVal_double(argv[3], NULL);
+            _v = SWIG_CheckState(res);
+          }
+          if (_v) {
+            return _wrap_new_FTDistribution2DVoigt__SWIG_1(self, argc, argv);
+          }
+        }
+      }
+    }
+  }
+  
+fail:
+  SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'new_FTDistribution2DVoigt'.\n"
+    "  Possible C/C++ prototypes are:\n"
+    "    FTDistribution2DVoigt::FTDistribution2DVoigt(std::vector< double,std::allocator< double > > const)\n"
+    "    FTDistribution2DVoigt::FTDistribution2DVoigt(double,double,double,double)\n");
+  return 0;
+}
+
+
 SWIGINTERN PyObject *_wrap_FTDistribution2DVoigt_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
   PyObject *resultobj = 0;
   FTDistribution2DVoigt *arg1 = (FTDistribution2DVoigt *) 0 ;
@@ -126748,20 +127366,6 @@ static PyMethodDef SwigMethods[] = {
 		"virtual IFTDecayFunction2D* IFTDecayFunction2D::clone() const =0\n"
 		"\n"
 		""},
-	 { "IFTDecayFunction2D_setGamma", _wrap_IFTDecayFunction2D_setGamma, METH_VARARGS, "\n"
-		"IFTDecayFunction2D_setGamma(IFTDecayFunction2D self, double gamma)\n"
-		"void IFTDecayFunction2D::setGamma(double gamma)\n"
-		"\n"
-		"set angle between first lattice vector and X-axis of distribution (both in direct space) \n"
-		"\n"
-		""},
-	 { "IFTDecayFunction2D_gamma", _wrap_IFTDecayFunction2D_gamma, METH_O, "\n"
-		"IFTDecayFunction2D_gamma(IFTDecayFunction2D self) -> double\n"
-		"double IFTDecayFunction2D::gamma() const\n"
-		"\n"
-		"get angle between first lattice vector and X-axis of distribution (both in direct space) \n"
-		"\n"
-		""},
 	 { "IFTDecayFunction2D_decayLengthX", _wrap_IFTDecayFunction2D_decayLengthX, METH_O, "\n"
 		"IFTDecayFunction2D_decayLengthX(IFTDecayFunction2D self) -> double\n"
 		"double IFTDecayFunction2D::decayLengthX() const\n"
@@ -126776,6 +127380,13 @@ static PyMethodDef SwigMethods[] = {
 		"get decay length in distribution's Y-direction \n"
 		"\n"
 		""},
+	 { "IFTDecayFunction2D_gamma", _wrap_IFTDecayFunction2D_gamma, METH_O, "\n"
+		"IFTDecayFunction2D_gamma(IFTDecayFunction2D self) -> double\n"
+		"double IFTDecayFunction2D::gamma() const\n"
+		"\n"
+		"get angle between first lattice vector and X-axis of distribution (both in direct space) \n"
+		"\n"
+		""},
 	 { "IFTDecayFunction2D_evaluate", _wrap_IFTDecayFunction2D_evaluate, METH_VARARGS, "\n"
 		"IFTDecayFunction2D_evaluate(IFTDecayFunction2D self, double qx, double qy) -> double\n"
 		"virtual double IFTDecayFunction2D::evaluate(double qx, double qy) const =0\n"
@@ -126912,11 +127523,6 @@ static PyMethodDef SwigMethods[] = {
 		"Returns Fourier transform of this distribution; is a decay function starting at evaluate(0)=1. \n"
 		"\n"
 		""},
-	 { "IFTDistribution1D_setOmega", _wrap_IFTDistribution1D_setOmega, METH_VARARGS, "\n"
-		"IFTDistribution1D_setOmega(IFTDistribution1D self, double omega)\n"
-		"void IFTDistribution1D::setOmega(double omega)\n"
-		"\n"
-		""},
 	 { "IFTDistribution1D_omega", _wrap_IFTDistribution1D_omega, METH_O, "\n"
 		"IFTDistribution1D_omega(IFTDistribution1D self) -> double\n"
 		"double IFTDistribution1D::omega() const\n"
@@ -126935,7 +127541,8 @@ static PyMethodDef SwigMethods[] = {
 		"\n"
 		""},
 	 { "IFTDistribution1D_swigregister", IFTDistribution1D_swigregister, METH_O, NULL},
-	 { "new_FTDistribution1DCauchy", _wrap_new_FTDistribution1DCauchy, METH_O, "\n"
+	 { "new_FTDistribution1DCauchy", _wrap_new_FTDistribution1DCauchy, METH_VARARGS, "\n"
+		"FTDistribution1DCauchy(vdouble1d_t P)\n"
 		"new_FTDistribution1DCauchy(double omega) -> FTDistribution1DCauchy\n"
 		"FTDistribution1DCauchy::FTDistribution1DCauchy(double omega)\n"
 		"\n"
@@ -126969,7 +127576,8 @@ static PyMethodDef SwigMethods[] = {
 	 { "delete_FTDistribution1DCauchy", _wrap_delete_FTDistribution1DCauchy, METH_O, "delete_FTDistribution1DCauchy(FTDistribution1DCauchy self)"},
 	 { "FTDistribution1DCauchy_swigregister", FTDistribution1DCauchy_swigregister, METH_O, NULL},
 	 { "FTDistribution1DCauchy_swiginit", FTDistribution1DCauchy_swiginit, METH_VARARGS, NULL},
-	 { "new_FTDistribution1DGauss", _wrap_new_FTDistribution1DGauss, METH_O, "\n"
+	 { "new_FTDistribution1DGauss", _wrap_new_FTDistribution1DGauss, METH_VARARGS, "\n"
+		"FTDistribution1DGauss(vdouble1d_t P)\n"
 		"new_FTDistribution1DGauss(double omega) -> FTDistribution1DGauss\n"
 		"FTDistribution1DGauss::FTDistribution1DGauss(double omega)\n"
 		"\n"
@@ -127003,7 +127611,8 @@ static PyMethodDef SwigMethods[] = {
 	 { "delete_FTDistribution1DGauss", _wrap_delete_FTDistribution1DGauss, METH_O, "delete_FTDistribution1DGauss(FTDistribution1DGauss self)"},
 	 { "FTDistribution1DGauss_swigregister", FTDistribution1DGauss_swigregister, METH_O, NULL},
 	 { "FTDistribution1DGauss_swiginit", FTDistribution1DGauss_swiginit, METH_VARARGS, NULL},
-	 { "new_FTDistribution1DGate", _wrap_new_FTDistribution1DGate, METH_O, "\n"
+	 { "new_FTDistribution1DGate", _wrap_new_FTDistribution1DGate, METH_VARARGS, "\n"
+		"FTDistribution1DGate(vdouble1d_t P)\n"
 		"new_FTDistribution1DGate(double omega) -> FTDistribution1DGate\n"
 		"FTDistribution1DGate::FTDistribution1DGate(double omega)\n"
 		"\n"
@@ -127037,7 +127646,8 @@ static PyMethodDef SwigMethods[] = {
 	 { "delete_FTDistribution1DGate", _wrap_delete_FTDistribution1DGate, METH_O, "delete_FTDistribution1DGate(FTDistribution1DGate self)"},
 	 { "FTDistribution1DGate_swigregister", FTDistribution1DGate_swigregister, METH_O, NULL},
 	 { "FTDistribution1DGate_swiginit", FTDistribution1DGate_swiginit, METH_VARARGS, NULL},
-	 { "new_FTDistribution1DTriangle", _wrap_new_FTDistribution1DTriangle, METH_O, "\n"
+	 { "new_FTDistribution1DTriangle", _wrap_new_FTDistribution1DTriangle, METH_VARARGS, "\n"
+		"FTDistribution1DTriangle(vdouble1d_t P)\n"
 		"new_FTDistribution1DTriangle(double omega) -> FTDistribution1DTriangle\n"
 		"FTDistribution1DTriangle::FTDistribution1DTriangle(double omega)\n"
 		"\n"
@@ -127071,7 +127681,8 @@ static PyMethodDef SwigMethods[] = {
 	 { "delete_FTDistribution1DTriangle", _wrap_delete_FTDistribution1DTriangle, METH_O, "delete_FTDistribution1DTriangle(FTDistribution1DTriangle self)"},
 	 { "FTDistribution1DTriangle_swigregister", FTDistribution1DTriangle_swigregister, METH_O, NULL},
 	 { "FTDistribution1DTriangle_swiginit", FTDistribution1DTriangle_swiginit, METH_VARARGS, NULL},
-	 { "new_FTDistribution1DCosine", _wrap_new_FTDistribution1DCosine, METH_O, "\n"
+	 { "new_FTDistribution1DCosine", _wrap_new_FTDistribution1DCosine, METH_VARARGS, "\n"
+		"FTDistribution1DCosine(vdouble1d_t P)\n"
 		"new_FTDistribution1DCosine(double omega) -> FTDistribution1DCosine\n"
 		"FTDistribution1DCosine::FTDistribution1DCosine(double omega)\n"
 		"\n"
@@ -127106,6 +127717,7 @@ static PyMethodDef SwigMethods[] = {
 	 { "FTDistribution1DCosine_swigregister", FTDistribution1DCosine_swigregister, METH_O, NULL},
 	 { "FTDistribution1DCosine_swiginit", FTDistribution1DCosine_swiginit, METH_VARARGS, NULL},
 	 { "new_FTDistribution1DVoigt", _wrap_new_FTDistribution1DVoigt, METH_VARARGS, "\n"
+		"FTDistribution1DVoigt(vdouble1d_t P)\n"
 		"new_FTDistribution1DVoigt(double omega, double eta) -> FTDistribution1DVoigt\n"
 		"FTDistribution1DVoigt::FTDistribution1DVoigt(double omega, double eta)\n"
 		"\n"
@@ -127160,9 +127772,14 @@ static PyMethodDef SwigMethods[] = {
 		"IFTDistribution2D* IFTDistribution2D::clone() const =0\n"
 		"\n"
 		""},
-	 { "IFTDistribution2D_setGamma", _wrap_IFTDistribution2D_setGamma, METH_VARARGS, "\n"
-		"IFTDistribution2D_setGamma(IFTDistribution2D self, double gamma)\n"
-		"void IFTDistribution2D::setGamma(double gamma)\n"
+	 { "IFTDistribution2D_omegaX", _wrap_IFTDistribution2D_omegaX, METH_O, "\n"
+		"IFTDistribution2D_omegaX(IFTDistribution2D self) -> double\n"
+		"double IFTDistribution2D::omegaX() const\n"
+		"\n"
+		""},
+	 { "IFTDistribution2D_omegaY", _wrap_IFTDistribution2D_omegaY, METH_O, "\n"
+		"IFTDistribution2D_omegaY(IFTDistribution2D self) -> double\n"
+		"double IFTDistribution2D::omegaY() const\n"
 		"\n"
 		""},
 	 { "IFTDistribution2D_gamma", _wrap_IFTDistribution2D_gamma, METH_O, "\n"
@@ -127175,16 +127792,6 @@ static PyMethodDef SwigMethods[] = {
 		"double IFTDistribution2D::delta() const\n"
 		"\n"
 		""},
-	 { "IFTDistribution2D_omegaX", _wrap_IFTDistribution2D_omegaX, METH_O, "\n"
-		"IFTDistribution2D_omegaX(IFTDistribution2D self) -> double\n"
-		"double IFTDistribution2D::omegaX() const\n"
-		"\n"
-		""},
-	 { "IFTDistribution2D_omegaY", _wrap_IFTDistribution2D_omegaY, METH_O, "\n"
-		"IFTDistribution2D_omegaY(IFTDistribution2D self) -> double\n"
-		"double IFTDistribution2D::omegaY() const\n"
-		"\n"
-		""},
 	 { "IFTDistribution2D_evaluate", _wrap_IFTDistribution2D_evaluate, METH_VARARGS, "\n"
 		"IFTDistribution2D_evaluate(IFTDistribution2D self, double qx, double qy) -> double\n"
 		"virtual double IFTDistribution2D::evaluate(double qx, double qy) const =0\n"
@@ -127195,6 +127802,7 @@ static PyMethodDef SwigMethods[] = {
 	 { "delete_IFTDistribution2D", _wrap_delete_IFTDistribution2D, METH_O, "delete_IFTDistribution2D(IFTDistribution2D self)"},
 	 { "IFTDistribution2D_swigregister", IFTDistribution2D_swigregister, METH_O, NULL},
 	 { "new_FTDistribution2DCauchy", _wrap_new_FTDistribution2DCauchy, METH_VARARGS, "\n"
+		"FTDistribution2DCauchy(vdouble1d_t P)\n"
 		"new_FTDistribution2DCauchy(double omega_x, double omega_y, double gamma) -> FTDistribution2DCauchy\n"
 		"FTDistribution2DCauchy::FTDistribution2DCauchy(double omega_x, double omega_y, double gamma=0)\n"
 		"\n"
@@ -127222,6 +127830,7 @@ static PyMethodDef SwigMethods[] = {
 	 { "FTDistribution2DCauchy_swigregister", FTDistribution2DCauchy_swigregister, METH_O, NULL},
 	 { "FTDistribution2DCauchy_swiginit", FTDistribution2DCauchy_swiginit, METH_VARARGS, NULL},
 	 { "new_FTDistribution2DGauss", _wrap_new_FTDistribution2DGauss, METH_VARARGS, "\n"
+		"FTDistribution2DGauss(vdouble1d_t P)\n"
 		"new_FTDistribution2DGauss(double omega_x, double omega_y, double gamma) -> FTDistribution2DGauss\n"
 		"FTDistribution2DGauss::FTDistribution2DGauss(double omega_x, double omega_y, double gamma=0)\n"
 		"\n"
@@ -127249,6 +127858,7 @@ static PyMethodDef SwigMethods[] = {
 	 { "FTDistribution2DGauss_swigregister", FTDistribution2DGauss_swigregister, METH_O, NULL},
 	 { "FTDistribution2DGauss_swiginit", FTDistribution2DGauss_swiginit, METH_VARARGS, NULL},
 	 { "new_FTDistribution2DGate", _wrap_new_FTDistribution2DGate, METH_VARARGS, "\n"
+		"FTDistribution2DGate(vdouble1d_t P)\n"
 		"new_FTDistribution2DGate(double omega_x, double omega_y, double gamma) -> FTDistribution2DGate\n"
 		"FTDistribution2DGate::FTDistribution2DGate(double omega_x, double omega_y, double gamma=0)\n"
 		"\n"
@@ -127276,6 +127886,7 @@ static PyMethodDef SwigMethods[] = {
 	 { "FTDistribution2DGate_swigregister", FTDistribution2DGate_swigregister, METH_O, NULL},
 	 { "FTDistribution2DGate_swiginit", FTDistribution2DGate_swiginit, METH_VARARGS, NULL},
 	 { "new_FTDistribution2DCone", _wrap_new_FTDistribution2DCone, METH_VARARGS, "\n"
+		"FTDistribution2DCone(vdouble1d_t P)\n"
 		"new_FTDistribution2DCone(double omega_x, double omega_y, double gamma) -> FTDistribution2DCone\n"
 		"FTDistribution2DCone::FTDistribution2DCone(double omega_x, double omega_y, double gamma=0)\n"
 		"\n"
@@ -127303,6 +127914,7 @@ static PyMethodDef SwigMethods[] = {
 	 { "FTDistribution2DCone_swigregister", FTDistribution2DCone_swigregister, METH_O, NULL},
 	 { "FTDistribution2DCone_swiginit", FTDistribution2DCone_swiginit, METH_VARARGS, NULL},
 	 { "new_FTDistribution2DVoigt", _wrap_new_FTDistribution2DVoigt, METH_VARARGS, "\n"
+		"FTDistribution2DVoigt(vdouble1d_t P)\n"
 		"new_FTDistribution2DVoigt(double omega_x, double omega_y, double gamma, double eta) -> FTDistribution2DVoigt\n"
 		"FTDistribution2DVoigt::FTDistribution2DVoigt(double omega_x, double omega_y, double eta, double gamma=0)\n"
 		"\n"
-- 
GitLab