From 5871688e22162ce552b3f86f9c28fca7096b8d82 Mon Sep 17 00:00:00 2001
From: "Joachim Wuttke (o)" <j.wuttke@fz-juelich.de>
Date: Mon, 14 Nov 2022 17:50:59 +0100
Subject: [PATCH] resolve overloading of set..Resolution fcts
---
Sim/Scan/AlphaScan.cpp | 24 +-
Sim/Scan/AlphaScan.h | 16 +-
Sim/Scan/QzScan.cpp | 10 +-
Sim/Scan/QzScan.h | 6 +-
Sim/Scan/ScanResolution.cpp | 8 +-
Sim/Scan/ScanResolution.h | 8 +-
Tests/Functional/Suite/MakeSimulations.cpp | 2 +-
Tests/Unit/Sim/ScanResolutionTest.cpp | 8 +-
auto/Wrap/doxygenSim.i | 24 +-
auto/Wrap/libBornAgainSim.py | 118 ++--
auto/Wrap/libBornAgainSim_wrap.cpp | 648 +++++----------------
11 files changed, 271 insertions(+), 601 deletions(-)
diff --git a/Sim/Scan/AlphaScan.cpp b/Sim/Scan/AlphaScan.cpp
index e0a41ac5ba7..263e33fb327 100644
--- a/Sim/Scan/AlphaScan.cpp
+++ b/Sim/Scan/AlphaScan.cpp
@@ -127,11 +127,11 @@ void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution& distr
setWavelengthResolution(*resolution);
}
-void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution& distr,
- const std::vector<double>& rel_dev)
+void AlphaScan::setRelativeWavelengthVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& rel_dev)
{
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanRelativeResolution(distr, rel_dev));
+ ScanResolution::scanRelativeVectorResolution(distr, rel_dev));
setWavelengthResolution(*resolution);
}
@@ -142,11 +142,11 @@ void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution& distr
setWavelengthResolution(*resolution);
}
-void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution& distr,
- const std::vector<double>& std_dev)
+void AlphaScan::setAbsoluteWavelengthVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& std_dev)
{
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanAbsoluteResolution(distr, std_dev));
+ ScanResolution::scanAbsoluteVectorResolution(distr, std_dev));
setWavelengthResolution(*resolution);
}
@@ -162,11 +162,11 @@ void AlphaScan::setRelativeAngularResolution(const IRangedDistribution& distr, d
setAngleResolution(*resolution);
}
-void AlphaScan::setRelativeAngularResolution(const IRangedDistribution& distr,
- const std::vector<double>& rel_dev)
+void AlphaScan::setRelativeAngularVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& rel_dev)
{
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanRelativeResolution(distr, rel_dev));
+ ScanResolution::scanRelativeVectorResolution(distr, rel_dev));
setAngleResolution(*resolution);
}
@@ -177,11 +177,11 @@ void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution& distr, d
setAngleResolution(*resolution);
}
-void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution& distr,
- const std::vector<double>& std_dev)
+void AlphaScan::setAbsoluteAngularVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& std_dev)
{
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanAbsoluteResolution(distr, std_dev));
+ ScanResolution::scanAbsoluteVectorResolution(distr, std_dev));
setAngleResolution(*resolution);
}
diff --git a/Sim/Scan/AlphaScan.h b/Sim/Scan/AlphaScan.h
index 8e311861064..98804d85cb7 100644
--- a/Sim/Scan/AlphaScan.h
+++ b/Sim/Scan/AlphaScan.h
@@ -92,15 +92,15 @@ public:
//! (that is, _rel_dev_ equals standard deviation divided by the mean value).
//! _rel_dev_ can be either single-valued or a numpy array. In the latter case the length of the
//! array should coinside with the length of the inclination angle axis.
- void setRelativeWavelengthResolution(const IRangedDistribution& distr,
- const std::vector<double>& rel_dev);
+ void setRelativeWavelengthVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& rel_dev);
void setAbsoluteWavelengthResolution(const IRangedDistribution& distr, double std_dev);
//! Sets wavelength resolution values via IRangedDistribution and values of standard deviations.
//! _std_dev_ can be either single-valued or a numpy array. In the latter case the length of the
//! array should coinside with the length of the inclination angle axis.
- void setAbsoluteWavelengthResolution(const IRangedDistribution& distr,
- const std::vector<double>& std_dev);
+ void setAbsoluteWavelengthVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& std_dev);
//! Sets angle resolution values via ScanResolution object.
void setAngleResolution(const ScanResolution& resolution);
@@ -110,15 +110,15 @@ public:
//! (that is, _rel_dev_ equals standard deviation divided by the mean value).
//! _rel_dev_ can be either single-valued or a numpy array. In the latter case the length of the
//! array should coinside with the length of the inclination angle axis.
- void setRelativeAngularResolution(const IRangedDistribution& distr,
- const std::vector<double>& rel_dev);
+ void setRelativeAngularVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& rel_dev);
void setAbsoluteAngularResolution(const IRangedDistribution& distr, double std_dev);
//! Sets angular resolution values via IRangedDistribution and values of standard deviations.
//! _std_dev_ can be either single-valued or a numpy array. In the latter case the length of the
//! array should coinside with the length of the inclination angle axis.
- void setAbsoluteAngularResolution(const IRangedDistribution& distr,
- const std::vector<double>& std_dev);
+ void setAbsoluteAngularVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& std_dev);
private:
using DistrOutput = std::vector<std::vector<ParameterSample>>;
diff --git a/Sim/Scan/QzScan.cpp b/Sim/Scan/QzScan.cpp
index 757281d4ccc..8511aa57d5e 100644
--- a/Sim/Scan/QzScan.cpp
+++ b/Sim/Scan/QzScan.cpp
@@ -135,11 +135,11 @@ void QzScan::setRelativeQResolution(const IRangedDistribution& distr, double rel
setQResolution(*resolution);
}
-void QzScan::setRelativeQResolution(const IRangedDistribution& distr,
- const std::vector<double>& rel_dev)
+void QzScan::setRelativeQVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& rel_dev)
{
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanRelativeResolution(distr, rel_dev));
+ ScanResolution::scanRelativeVectorResolution(distr, rel_dev));
setQResolution(*resolution);
}
@@ -150,10 +150,10 @@ void QzScan::setAbsoluteQResolution(const IRangedDistribution& distr, double std
setQResolution(*resolution);
}
-void QzScan::setAbsoluteQResolution(const IRangedDistribution& distr,
+void QzScan::setAbsoluteQVectorResolution(const IRangedDistribution& distr,
const std::vector<double>& std_dev)
{
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanAbsoluteResolution(distr, std_dev));
+ ScanResolution::scanAbsoluteVectorResolution(distr, std_dev));
setQResolution(*resolution);
}
diff --git a/Sim/Scan/QzScan.h b/Sim/Scan/QzScan.h
index 40345cd51e4..007d25208c5 100644
--- a/Sim/Scan/QzScan.h
+++ b/Sim/Scan/QzScan.h
@@ -81,14 +81,14 @@ public:
//! (that is, _rel_dev_ equals standard deviation divided by the mean value).
//! _rel_dev_ can be either single-valued or a numpy array. In the latter case the length of the
//! array should coinside with the length of the qz-axis.
- void setRelativeQResolution(const IRangedDistribution& distr,
- const std::vector<double>& rel_dev);
+ void setRelativeQVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& rel_dev);
void setAbsoluteQResolution(const IRangedDistribution& distr, double std_dev);
//! Sets qz resolution values via IRangedDistribution and values of standard deviations.
//! _std_dev_ can be either single-valued or a numpy array. In the latter case the length of the
//! array should coinside with the length of the qz-axis.
- void setAbsoluteQResolution(const IRangedDistribution& distr,
+ void setAbsoluteQVectorResolution(const IRangedDistribution& distr,
const std::vector<double>& std_dev);
void setOffset(double offset)
diff --git a/Sim/Scan/ScanResolution.cpp b/Sim/Scan/ScanResolution.cpp
index 72c10610ad4..84a0427a944 100644
--- a/Sim/Scan/ScanResolution.cpp
+++ b/Sim/Scan/ScanResolution.cpp
@@ -167,8 +167,8 @@ ScanResolution* ScanResolution::scanRelativeResolution(const IRangedDistribution
return new ScanSingleRelativeResolution(distr, stddev);
}
-ScanResolution* ScanResolution::scanRelativeResolution(const IRangedDistribution& distr,
- const std::vector<double>& stddevs)
+ScanResolution* ScanResolution::scanRelativeVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& stddevs)
{
return new ScanVectorRelativeResolution(distr, stddevs);
}
@@ -179,8 +179,8 @@ ScanResolution* ScanResolution::scanAbsoluteResolution(const IRangedDistribution
return new ScanSingleAbsoluteResolution(distr, stddev);
}
-ScanResolution* ScanResolution::scanAbsoluteResolution(const IRangedDistribution& distr,
- const std::vector<double>& stddevs)
+ScanResolution* ScanResolution::scanAbsoluteVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& stddevs)
{
return new ScanVectorAbsoluteResolution(distr, stddevs);
}
diff --git a/Sim/Scan/ScanResolution.h b/Sim/Scan/ScanResolution.h
index b281dd44431..84e4042dfc8 100644
--- a/Sim/Scan/ScanResolution.h
+++ b/Sim/Scan/ScanResolution.h
@@ -32,11 +32,11 @@ protected:
public:
~ScanResolution() override;
static ScanResolution* scanRelativeResolution(const IRangedDistribution& distr, double stddev);
- static ScanResolution* scanRelativeResolution(const IRangedDistribution& distr,
- const std::vector<double>& stddevs);
+ static ScanResolution* scanRelativeVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& stddevs);
static ScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev);
- static ScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr,
- const std::vector<double>& stddevs);
+ static ScanResolution* scanAbsoluteVectorResolution(const IRangedDistribution& distr,
+ const std::vector<double>& stddevs);
#ifndef SWIG
static ScanResolution* scanEmptyResolution();
diff --git a/Tests/Functional/Suite/MakeSimulations.cpp b/Tests/Functional/Suite/MakeSimulations.cpp
index 0f8da368851..017cf5635dd 100644
--- a/Tests/Functional/Suite/MakeSimulations.cpp
+++ b/Tests/Functional/Suite/MakeSimulations.cpp
@@ -467,7 +467,7 @@ test::makeSimulation::TOFRWithPointwiseResolution(const MultiLayer& sample)
auto qs_vector = qs.binCenters();
std::for_each(qs_vector.begin(), qs_vector.end(),
[&resolutions](double q_val) { resolutions.push_back(0.03 * q_val); });
- scan.setAbsoluteQResolution(RangedDistributionGaussian(20, 2.0), resolutions);
+ scan.setAbsoluteQVectorResolution(RangedDistributionGaussian(20, 2.0), resolutions);
auto result = std::make_unique<SpecularSimulation>(scan, sample);
result->options().setUseAvgMaterials(true);
diff --git a/Tests/Unit/Sim/ScanResolutionTest.cpp b/Tests/Unit/Sim/ScanResolutionTest.cpp
index 28e9301ef03..16f2d1285b9 100644
--- a/Tests/Unit/Sim/ScanResolutionTest.cpp
+++ b/Tests/Unit/Sim/ScanResolutionTest.cpp
@@ -60,10 +60,10 @@ TEST_F(ScanResolutionTest, AbsoluteSingleValued)
TEST_F(ScanResolutionTest, RelativeVectorValued)
{
RangedDistributionGate distr(3, 1.0);
- EXPECT_THROW(ScanResolution::scanRelativeResolution(distr, std::vector<double>()),
+ EXPECT_THROW(ScanResolution::scanRelativeVectorResolution(distr, std::vector<double>()),
std::runtime_error);
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanRelativeResolution(distr, {0.1, 0.2, 0.3}));
+ ScanResolution::scanRelativeVectorResolution(distr, {0.1, 0.2, 0.3}));
std::vector<double> coordinates = {1.0, 2.0, 3.0};
DistrOutput ref_result =
@@ -85,10 +85,10 @@ TEST_F(ScanResolutionTest, RelativeVectorValued)
TEST_F(ScanResolutionTest, AbsoluteVectorValued)
{
RangedDistributionGate distr(3, 1.0);
- EXPECT_THROW(ScanResolution::scanAbsoluteResolution(distr, std::vector<double>()),
+ EXPECT_THROW(ScanResolution::scanAbsoluteVectorResolution(distr, std::vector<double>()),
std::runtime_error);
std::unique_ptr<ScanResolution> resolution(
- ScanResolution::scanAbsoluteResolution(distr, {0.2, 0.3, 0.4}));
+ ScanResolution::scanAbsoluteVectorResolution(distr, {0.2, 0.3, 0.4}));
std::vector<double> coordinates = {1.0, 2.0, 3.0};
DistrOutput ref_result =
diff --git a/auto/Wrap/doxygenSim.i b/auto/Wrap/doxygenSim.i
index 82c2639f235..cfd498e9a94 100644
--- a/auto/Wrap/doxygenSim.i
+++ b/auto/Wrap/doxygenSim.i
@@ -81,16 +81,16 @@ Sets wavelength resolution values via ScanResolution object.
%feature("docstring") AlphaScan::setRelativeWavelengthResolution "void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, double rel_dev)
AlphaScan::setRelativeWavelengthResolution";
-%feature("docstring") AlphaScan::setRelativeWavelengthResolution "void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
-AlphaScan::setRelativeWavelengthResolution
+%feature("docstring") AlphaScan::setRelativeWavelengthVectorResolution "void AlphaScan::setRelativeWavelengthVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+AlphaScan::setRelativeWavelengthVectorResolution
Sets wavelength resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
";
%feature("docstring") AlphaScan::setAbsoluteWavelengthResolution "void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, double std_dev)
AlphaScan::setAbsoluteWavelengthResolution";
-%feature("docstring") AlphaScan::setAbsoluteWavelengthResolution "void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
-AlphaScan::setAbsoluteWavelengthResolution
+%feature("docstring") AlphaScan::setAbsoluteWavelengthVectorResolution "void AlphaScan::setAbsoluteWavelengthVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+AlphaScan::setAbsoluteWavelengthVectorResolution
Sets wavelength resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
";
@@ -102,16 +102,16 @@ Sets angle resolution values via ScanResolution object.
%feature("docstring") AlphaScan::setRelativeAngularResolution "void AlphaScan::setRelativeAngularResolution(const IRangedDistribution &distr, double rel_dev)
AlphaScan::setRelativeAngularResolution";
-%feature("docstring") AlphaScan::setRelativeAngularResolution "void AlphaScan::setRelativeAngularResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
-AlphaScan::setRelativeAngularResolution
+%feature("docstring") AlphaScan::setRelativeAngularVectorResolution "void AlphaScan::setRelativeAngularVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+AlphaScan::setRelativeAngularVectorResolution
Sets angular resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
";
%feature("docstring") AlphaScan::setAbsoluteAngularResolution "void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, double std_dev)
AlphaScan::setAbsoluteAngularResolution";
-%feature("docstring") AlphaScan::setAbsoluteAngularResolution "void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
-AlphaScan::setAbsoluteAngularResolution
+%feature("docstring") AlphaScan::setAbsoluteAngularVectorResolution "void AlphaScan::setAbsoluteAngularVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+AlphaScan::setAbsoluteAngularVectorResolution
Sets angular resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
";
@@ -731,16 +731,16 @@ Sets q resolution values via ScanResolution object.
%feature("docstring") QzScan::setRelativeQResolution "void QzScan::setRelativeQResolution(const IRangedDistribution &distr, double rel_dev)
QzScan::setRelativeQResolution";
-%feature("docstring") QzScan::setRelativeQResolution "void QzScan::setRelativeQResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
-QzScan::setRelativeQResolution
+%feature("docstring") QzScan::setRelativeQVectorResolution "void QzScan::setRelativeQVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+QzScan::setRelativeQVectorResolution
Sets qz resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis.
";
%feature("docstring") QzScan::setAbsoluteQResolution "void QzScan::setAbsoluteQResolution(const IRangedDistribution &distr, double std_dev)
QzScan::setAbsoluteQResolution";
-%feature("docstring") QzScan::setAbsoluteQResolution "void QzScan::setAbsoluteQResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
-QzScan::setAbsoluteQResolution
+%feature("docstring") QzScan::setAbsoluteQVectorResolution "void QzScan::setAbsoluteQVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+QzScan::setAbsoluteQVectorResolution
Sets qz resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis.
";
diff --git a/auto/Wrap/libBornAgainSim.py b/auto/Wrap/libBornAgainSim.py
index 5ad89801a5f..5718d31c3dd 100644
--- a/auto/Wrap/libBornAgainSim.py
+++ b/auto/Wrap/libBornAgainSim.py
@@ -2847,27 +2847,41 @@ class AlphaScan(ISpecularScan):
"""
return _libBornAgainSim.AlphaScan_setWavelengthResolution(self, resolution)
- def setRelativeWavelengthResolution(self, *args):
+ def setRelativeWavelengthResolution(self, distr, rel_dev):
r"""
setRelativeWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, double rel_dev)
- setRelativeWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
- void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+ void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, double rel_dev)
AlphaScan::setRelativeWavelengthResolution
+ """
+ return _libBornAgainSim.AlphaScan_setRelativeWavelengthResolution(self, distr, rel_dev)
+
+ def setRelativeWavelengthVectorResolution(self, distr, rel_dev):
+ r"""
+ setRelativeWavelengthVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
+ void AlphaScan::setRelativeWavelengthVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+ AlphaScan::setRelativeWavelengthVectorResolution
Sets wavelength resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
"""
- return _libBornAgainSim.AlphaScan_setRelativeWavelengthResolution(self, *args)
+ return _libBornAgainSim.AlphaScan_setRelativeWavelengthVectorResolution(self, distr, rel_dev)
- def setAbsoluteWavelengthResolution(self, *args):
+ def setAbsoluteWavelengthResolution(self, distr, std_dev):
r"""
setAbsoluteWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)
- setAbsoluteWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
- void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+ void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, double std_dev)
AlphaScan::setAbsoluteWavelengthResolution
+ """
+ return _libBornAgainSim.AlphaScan_setAbsoluteWavelengthResolution(self, distr, std_dev)
+
+ def setAbsoluteWavelengthVectorResolution(self, distr, std_dev):
+ r"""
+ setAbsoluteWavelengthVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
+ void AlphaScan::setAbsoluteWavelengthVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+ AlphaScan::setAbsoluteWavelengthVectorResolution
Sets wavelength resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
"""
- return _libBornAgainSim.AlphaScan_setAbsoluteWavelengthResolution(self, *args)
+ return _libBornAgainSim.AlphaScan_setAbsoluteWavelengthVectorResolution(self, distr, std_dev)
def setAngleResolution(self, resolution):
r"""
@@ -2879,27 +2893,41 @@ class AlphaScan(ISpecularScan):
"""
return _libBornAgainSim.AlphaScan_setAngleResolution(self, resolution)
- def setRelativeAngularResolution(self, *args):
+ def setRelativeAngularResolution(self, distr, rel_dev):
r"""
setRelativeAngularResolution(AlphaScan self, IRangedDistribution const & distr, double rel_dev)
- setRelativeAngularResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
- void AlphaScan::setRelativeAngularResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+ void AlphaScan::setRelativeAngularResolution(const IRangedDistribution &distr, double rel_dev)
AlphaScan::setRelativeAngularResolution
+ """
+ return _libBornAgainSim.AlphaScan_setRelativeAngularResolution(self, distr, rel_dev)
+
+ def setRelativeAngularVectorResolution(self, distr, rel_dev):
+ r"""
+ setRelativeAngularVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
+ void AlphaScan::setRelativeAngularVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+ AlphaScan::setRelativeAngularVectorResolution
Sets angular resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
"""
- return _libBornAgainSim.AlphaScan_setRelativeAngularResolution(self, *args)
+ return _libBornAgainSim.AlphaScan_setRelativeAngularVectorResolution(self, distr, rel_dev)
- def setAbsoluteAngularResolution(self, *args):
+ def setAbsoluteAngularResolution(self, distr, std_dev):
r"""
setAbsoluteAngularResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)
- setAbsoluteAngularResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
- void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+ void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, double std_dev)
AlphaScan::setAbsoluteAngularResolution
+ """
+ return _libBornAgainSim.AlphaScan_setAbsoluteAngularResolution(self, distr, std_dev)
+
+ def setAbsoluteAngularVectorResolution(self, distr, std_dev):
+ r"""
+ setAbsoluteAngularVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
+ void AlphaScan::setAbsoluteAngularVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+ AlphaScan::setAbsoluteAngularVectorResolution
Sets angular resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis.
"""
- return _libBornAgainSim.AlphaScan_setAbsoluteAngularResolution(self, *args)
+ return _libBornAgainSim.AlphaScan_setAbsoluteAngularVectorResolution(self, distr, std_dev)
# Register AlphaScan in _libBornAgainSim:
_libBornAgainSim.AlphaScan_swigregister(AlphaScan)
@@ -2963,27 +2991,41 @@ class QzScan(ISpecularScan):
"""
return _libBornAgainSim.QzScan_setQResolution(self, resolution)
- def setRelativeQResolution(self, *args):
+ def setRelativeQResolution(self, distr, rel_dev):
r"""
setRelativeQResolution(QzScan self, IRangedDistribution const & distr, double rel_dev)
- setRelativeQResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
- void QzScan::setRelativeQResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+ void QzScan::setRelativeQResolution(const IRangedDistribution &distr, double rel_dev)
QzScan::setRelativeQResolution
+ """
+ return _libBornAgainSim.QzScan_setRelativeQResolution(self, distr, rel_dev)
+
+ def setRelativeQVectorResolution(self, distr, rel_dev):
+ r"""
+ setRelativeQVectorResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)
+ void QzScan::setRelativeQVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)
+ QzScan::setRelativeQVectorResolution
Sets qz resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis.
"""
- return _libBornAgainSim.QzScan_setRelativeQResolution(self, *args)
+ return _libBornAgainSim.QzScan_setRelativeQVectorResolution(self, distr, rel_dev)
- def setAbsoluteQResolution(self, *args):
+ def setAbsoluteQResolution(self, distr, std_dev):
r"""
setAbsoluteQResolution(QzScan self, IRangedDistribution const & distr, double std_dev)
- setAbsoluteQResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
- void QzScan::setAbsoluteQResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+ void QzScan::setAbsoluteQResolution(const IRangedDistribution &distr, double std_dev)
QzScan::setAbsoluteQResolution
+ """
+ return _libBornAgainSim.QzScan_setAbsoluteQResolution(self, distr, std_dev)
+
+ def setAbsoluteQVectorResolution(self, distr, std_dev):
+ r"""
+ setAbsoluteQVectorResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)
+ void QzScan::setAbsoluteQVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)
+ QzScan::setAbsoluteQVectorResolution
Sets qz resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis.
"""
- return _libBornAgainSim.QzScan_setAbsoluteQResolution(self, *args)
+ return _libBornAgainSim.QzScan_setAbsoluteQVectorResolution(self, distr, std_dev)
def setOffset(self, offset):
r"""
@@ -3021,20 +3063,24 @@ class ScanResolution(libBornAgainBase.ICloneable):
__swig_destroy__ = _libBornAgainSim.delete_ScanResolution
@staticmethod
- def scanRelativeResolution(*args):
- r"""
- scanRelativeResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution
- scanRelativeResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution
- """
- return _libBornAgainSim.ScanResolution_scanRelativeResolution(*args)
+ def scanRelativeResolution(distr, stddev):
+ r"""scanRelativeResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution"""
+ return _libBornAgainSim.ScanResolution_scanRelativeResolution(distr, stddev)
@staticmethod
- def scanAbsoluteResolution(*args):
- r"""
- scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution
- scanAbsoluteResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution
- """
- return _libBornAgainSim.ScanResolution_scanAbsoluteResolution(*args)
+ def scanRelativeVectorResolution(distr, stddevs):
+ r"""scanRelativeVectorResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution"""
+ return _libBornAgainSim.ScanResolution_scanRelativeVectorResolution(distr, stddevs)
+
+ @staticmethod
+ def scanAbsoluteResolution(distr, stddev):
+ r"""scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution"""
+ return _libBornAgainSim.ScanResolution_scanAbsoluteResolution(distr, stddev)
+
+ @staticmethod
+ def scanAbsoluteVectorResolution(distr, stddevs):
+ r"""scanAbsoluteVectorResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution"""
+ return _libBornAgainSim.ScanResolution_scanAbsoluteVectorResolution(distr, stddevs)
# Register ScanResolution in _libBornAgainSim:
_libBornAgainSim.ScanResolution_swigregister(ScanResolution)
diff --git a/auto/Wrap/libBornAgainSim_wrap.cpp b/auto/Wrap/libBornAgainSim_wrap.cpp
index 8a398f72625..9c77f480dc8 100644
--- a/auto/Wrap/libBornAgainSim_wrap.cpp
+++ b/auto/Wrap/libBornAgainSim_wrap.cpp
@@ -34308,7 +34308,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeWavelengthResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeWavelengthResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34319,8 +34319,9 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeWavelengthResolution__SWIG_0(PyO
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setRelativeWavelengthResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setRelativeWavelengthResolution" "', argument " "1"" of type '" "AlphaScan *""'");
@@ -34347,7 +34348,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeWavelengthResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeWavelengthVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34357,33 +34358,34 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeWavelengthResolution__SWIG_1(PyO
void *argp2 = 0 ;
int res2 = 0 ;
int res3 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setRelativeWavelengthVectorResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setRelativeWavelengthResolution" "', argument " "1"" of type '" "AlphaScan *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setRelativeWavelengthVectorResolution" "', argument " "1"" of type '" "AlphaScan *""'");
}
arg1 = reinterpret_cast< AlphaScan * >(argp1);
res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setRelativeWavelengthResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setRelativeWavelengthVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeWavelengthResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeWavelengthVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
arg2 = reinterpret_cast< IRangedDistribution * >(argp2);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res3 = swig::asptr(swig_obj[2], &ptr);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setRelativeWavelengthResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setRelativeWavelengthVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeWavelengthResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeWavelengthVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg3 = ptr;
}
- (arg1)->setRelativeWavelengthResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
+ (arg1)->setRelativeWavelengthVectorResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
@@ -34393,61 +34395,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeWavelengthResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[4] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "AlphaScan_setRelativeWavelengthResolution", 0, 3, argv))) SWIG_fail;
- --argc;
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[2], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_AlphaScan_setRelativeWavelengthResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- }
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_AlphaScan_setRelativeWavelengthResolution__SWIG_1(self, argc, argv);
- }
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AlphaScan_setRelativeWavelengthResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " AlphaScan::setRelativeWavelengthResolution(IRangedDistribution const &,double)\n"
- " AlphaScan::setRelativeWavelengthResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteWavelengthResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteWavelengthResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34458,8 +34406,9 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteWavelengthResolution__SWIG_0(PyO
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setAbsoluteWavelengthResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setAbsoluteWavelengthResolution" "', argument " "1"" of type '" "AlphaScan *""'");
@@ -34486,7 +34435,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteWavelengthResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteWavelengthVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34496,33 +34445,34 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteWavelengthResolution__SWIG_1(PyO
void *argp2 = 0 ;
int res2 = 0 ;
int res3 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setAbsoluteWavelengthVectorResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setAbsoluteWavelengthResolution" "', argument " "1"" of type '" "AlphaScan *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setAbsoluteWavelengthVectorResolution" "', argument " "1"" of type '" "AlphaScan *""'");
}
arg1 = reinterpret_cast< AlphaScan * >(argp1);
res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setAbsoluteWavelengthResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setAbsoluteWavelengthVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteWavelengthResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteWavelengthVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
arg2 = reinterpret_cast< IRangedDistribution * >(argp2);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res3 = swig::asptr(swig_obj[2], &ptr);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setAbsoluteWavelengthResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setAbsoluteWavelengthVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteWavelengthResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteWavelengthVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg3 = ptr;
}
- (arg1)->setAbsoluteWavelengthResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
+ (arg1)->setAbsoluteWavelengthVectorResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
@@ -34532,60 +34482,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteWavelengthResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[4] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "AlphaScan_setAbsoluteWavelengthResolution", 0, 3, argv))) SWIG_fail;
- --argc;
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[2], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_AlphaScan_setAbsoluteWavelengthResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- }
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_AlphaScan_setAbsoluteWavelengthResolution__SWIG_1(self, argc, argv);
- }
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AlphaScan_setAbsoluteWavelengthResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " AlphaScan::setAbsoluteWavelengthResolution(IRangedDistribution const &,double)\n"
- " AlphaScan::setAbsoluteWavelengthResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
SWIGINTERN PyObject *_wrap_AlphaScan_setAngleResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
@@ -34618,7 +34514,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeAngularResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeAngularResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34629,8 +34525,9 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeAngularResolution__SWIG_0(PyObje
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setRelativeAngularResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setRelativeAngularResolution" "', argument " "1"" of type '" "AlphaScan *""'");
@@ -34657,7 +34554,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeAngularResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeAngularVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34667,33 +34564,34 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeAngularResolution__SWIG_1(PyObje
void *argp2 = 0 ;
int res2 = 0 ;
int res3 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setRelativeAngularVectorResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setRelativeAngularResolution" "', argument " "1"" of type '" "AlphaScan *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setRelativeAngularVectorResolution" "', argument " "1"" of type '" "AlphaScan *""'");
}
arg1 = reinterpret_cast< AlphaScan * >(argp1);
res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setRelativeAngularResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setRelativeAngularVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeAngularResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeAngularVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
arg2 = reinterpret_cast< IRangedDistribution * >(argp2);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res3 = swig::asptr(swig_obj[2], &ptr);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setRelativeAngularResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setRelativeAngularVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeAngularResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setRelativeAngularVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg3 = ptr;
}
- (arg1)->setRelativeAngularResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
+ (arg1)->setRelativeAngularVectorResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
@@ -34703,61 +34601,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setRelativeAngularResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[4] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "AlphaScan_setRelativeAngularResolution", 0, 3, argv))) SWIG_fail;
- --argc;
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[2], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_AlphaScan_setRelativeAngularResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- }
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_AlphaScan_setRelativeAngularResolution__SWIG_1(self, argc, argv);
- }
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AlphaScan_setRelativeAngularResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " AlphaScan::setRelativeAngularResolution(IRangedDistribution const &,double)\n"
- " AlphaScan::setRelativeAngularResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteAngularResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteAngularResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34768,8 +34612,9 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteAngularResolution__SWIG_0(PyObje
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setAbsoluteAngularResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setAbsoluteAngularResolution" "', argument " "1"" of type '" "AlphaScan *""'");
@@ -34796,7 +34641,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteAngularResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteAngularVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -34806,33 +34651,34 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteAngularResolution__SWIG_1(PyObje
void *argp2 = 0 ;
int res2 = 0 ;
int res3 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "AlphaScan_setAbsoluteAngularVectorResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_AlphaScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setAbsoluteAngularResolution" "', argument " "1"" of type '" "AlphaScan *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setAbsoluteAngularVectorResolution" "', argument " "1"" of type '" "AlphaScan *""'");
}
arg1 = reinterpret_cast< AlphaScan * >(argp1);
res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setAbsoluteAngularResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setAbsoluteAngularVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteAngularResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteAngularVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
arg2 = reinterpret_cast< IRangedDistribution * >(argp2);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res3 = swig::asptr(swig_obj[2], &ptr);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setAbsoluteAngularResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "AlphaScan_setAbsoluteAngularVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteAngularResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "AlphaScan_setAbsoluteAngularVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg3 = ptr;
}
- (arg1)->setAbsoluteAngularResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
+ (arg1)->setAbsoluteAngularVectorResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
@@ -34842,60 +34688,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_AlphaScan_setAbsoluteAngularResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[4] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "AlphaScan_setAbsoluteAngularResolution", 0, 3, argv))) SWIG_fail;
- --argc;
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[2], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_AlphaScan_setAbsoluteAngularResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- }
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_AlphaScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_AlphaScan_setAbsoluteAngularResolution__SWIG_1(self, argc, argv);
- }
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'AlphaScan_setAbsoluteAngularResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " AlphaScan::setAbsoluteAngularResolution(IRangedDistribution const &,double)\n"
- " AlphaScan::setAbsoluteAngularResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
SWIGINTERN PyObject *AlphaScan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
@@ -35171,7 +34963,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_QzScan_setRelativeQResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_QzScan_setRelativeQResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
QzScan *arg1 = (QzScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -35182,8 +34974,9 @@ SWIGINTERN PyObject *_wrap_QzScan_setRelativeQResolution__SWIG_0(PyObject *self,
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "QzScan_setRelativeQResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QzScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QzScan_setRelativeQResolution" "', argument " "1"" of type '" "QzScan *""'");
@@ -35210,7 +35003,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_QzScan_setRelativeQResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_QzScan_setRelativeQVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
QzScan *arg1 = (QzScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -35220,33 +35013,34 @@ SWIGINTERN PyObject *_wrap_QzScan_setRelativeQResolution__SWIG_1(PyObject *self,
void *argp2 = 0 ;
int res2 = 0 ;
int res3 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "QzScan_setRelativeQVectorResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QzScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QzScan_setRelativeQResolution" "', argument " "1"" of type '" "QzScan *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QzScan_setRelativeQVectorResolution" "', argument " "1"" of type '" "QzScan *""'");
}
arg1 = reinterpret_cast< QzScan * >(argp1);
res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QzScan_setRelativeQResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QzScan_setRelativeQVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setRelativeQResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setRelativeQVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
arg2 = reinterpret_cast< IRangedDistribution * >(argp2);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res3 = swig::asptr(swig_obj[2], &ptr);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QzScan_setRelativeQResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QzScan_setRelativeQVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setRelativeQResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setRelativeQVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg3 = ptr;
}
- (arg1)->setRelativeQResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
+ (arg1)->setRelativeQVectorResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
@@ -35256,61 +35050,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_QzScan_setRelativeQResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[4] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "QzScan_setRelativeQResolution", 0, 3, argv))) SWIG_fail;
- --argc;
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_QzScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[2], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_QzScan_setRelativeQResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- }
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_QzScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_QzScan_setRelativeQResolution__SWIG_1(self, argc, argv);
- }
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QzScan_setRelativeQResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " QzScan::setRelativeQResolution(IRangedDistribution const &,double)\n"
- " QzScan::setRelativeQResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_QzScan_setAbsoluteQResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_QzScan_setAbsoluteQResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
QzScan *arg1 = (QzScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -35321,8 +35061,9 @@ SWIGINTERN PyObject *_wrap_QzScan_setAbsoluteQResolution__SWIG_0(PyObject *self,
int res2 = 0 ;
double val3 ;
int ecode3 = 0 ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "QzScan_setAbsoluteQResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QzScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QzScan_setAbsoluteQResolution" "', argument " "1"" of type '" "QzScan *""'");
@@ -35349,7 +35090,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_QzScan_setAbsoluteQResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_QzScan_setAbsoluteQVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
QzScan *arg1 = (QzScan *) 0 ;
IRangedDistribution *arg2 = 0 ;
@@ -35359,33 +35100,34 @@ SWIGINTERN PyObject *_wrap_QzScan_setAbsoluteQResolution__SWIG_1(PyObject *self,
void *argp2 = 0 ;
int res2 = 0 ;
int res3 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[3] ;
- if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "QzScan_setAbsoluteQVectorResolution", 3, 3, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_QzScan, 0 | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QzScan_setAbsoluteQResolution" "', argument " "1"" of type '" "QzScan *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QzScan_setAbsoluteQVectorResolution" "', argument " "1"" of type '" "QzScan *""'");
}
arg1 = reinterpret_cast< QzScan * >(argp1);
res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QzScan_setAbsoluteQResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "QzScan_setAbsoluteQVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
if (!argp2) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setAbsoluteQResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setAbsoluteQVectorResolution" "', argument " "2"" of type '" "IRangedDistribution const &""'");
}
arg2 = reinterpret_cast< IRangedDistribution * >(argp2);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res3 = swig::asptr(swig_obj[2], &ptr);
if (!SWIG_IsOK(res3)) {
- SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QzScan_setAbsoluteQResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "QzScan_setAbsoluteQVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setAbsoluteQResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "QzScan_setAbsoluteQVectorResolution" "', argument " "3"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg3 = ptr;
}
- (arg1)->setAbsoluteQResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
+ (arg1)->setAbsoluteQVectorResolution((IRangedDistribution const &)*arg2,(std::vector< double,std::allocator< double > > const &)*arg3);
resultobj = SWIG_Py_Void();
if (SWIG_IsNewObj(res3)) delete arg3;
return resultobj;
@@ -35395,60 +35137,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_QzScan_setAbsoluteQResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[4] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "QzScan_setAbsoluteQResolution", 0, 3, argv))) SWIG_fail;
- --argc;
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_QzScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[2], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_QzScan_setAbsoluteQResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- }
- if (argc == 3) {
- int _v = 0;
- void *vptr = 0;
- int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_QzScan, 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[2], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_QzScan_setAbsoluteQResolution__SWIG_1(self, argc, argv);
- }
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'QzScan_setAbsoluteQResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " QzScan::setAbsoluteQResolution(IRangedDistribution const &,double)\n"
- " QzScan::setAbsoluteQResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
SWIGINTERN PyObject *_wrap_QzScan_setOffset(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
QzScan *arg1 = (QzScan *) 0 ;
@@ -35534,7 +35222,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_ScanResolution_scanRelativeResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_ScanResolution_scanRelativeResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
IRangedDistribution *arg1 = 0 ;
double arg2 ;
@@ -35542,9 +35230,10 @@ SWIGINTERN PyObject *_wrap_ScanResolution_scanRelativeResolution__SWIG_0(PyObjec
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
ScanResolution *result = 0 ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "ScanResolution_scanRelativeResolution", 2, 2, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScanResolution_scanRelativeResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
@@ -35566,37 +35255,38 @@ fail:
}
-SWIGINTERN PyObject *_wrap_ScanResolution_scanRelativeResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_ScanResolution_scanRelativeVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
IRangedDistribution *arg1 = 0 ;
std::vector< double,std::allocator< double > > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[2] ;
ScanResolution *result = 0 ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "ScanResolution_scanRelativeVectorResolution", 2, 2, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScanResolution_scanRelativeResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScanResolution_scanRelativeVectorResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
}
if (!argp1) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanRelativeResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanRelativeVectorResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
}
arg1 = reinterpret_cast< IRangedDistribution * >(argp1);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res2 = swig::asptr(swig_obj[1], &ptr);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScanResolution_scanRelativeResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScanResolution_scanRelativeVectorResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanRelativeResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanRelativeVectorResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg2 = ptr;
}
- result = (ScanResolution *)ScanResolution::scanRelativeResolution((IRangedDistribution const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScanResolution, SWIG_POINTER_OWN | 0 );
+ result = (ScanResolution *)ScanResolution::scanRelativeVectorResolution((IRangedDistribution const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScanResolution, 0 | 0 );
if (SWIG_IsNewObj(res2)) delete arg2;
return resultobj;
fail:
@@ -35605,51 +35295,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_ScanResolution_scanRelativeResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "ScanResolution_scanRelativeResolution", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v = 0;
- int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_ScanResolution_scanRelativeResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v = 0;
- int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_ScanResolution_scanRelativeResolution__SWIG_1(self, argc, argv);
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScanResolution_scanRelativeResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " ScanResolution::scanRelativeResolution(IRangedDistribution const &,double)\n"
- " ScanResolution::scanRelativeResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
-SWIGINTERN PyObject *_wrap_ScanResolution_scanAbsoluteResolution__SWIG_0(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_ScanResolution_scanAbsoluteResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
IRangedDistribution *arg1 = 0 ;
double arg2 ;
@@ -35657,9 +35303,10 @@ SWIGINTERN PyObject *_wrap_ScanResolution_scanAbsoluteResolution__SWIG_0(PyObjec
int res1 = 0 ;
double val2 ;
int ecode2 = 0 ;
+ PyObject *swig_obj[2] ;
ScanResolution *result = 0 ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "ScanResolution_scanAbsoluteResolution", 2, 2, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScanResolution_scanAbsoluteResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
@@ -35681,37 +35328,38 @@ fail:
}
-SWIGINTERN PyObject *_wrap_ScanResolution_scanAbsoluteResolution__SWIG_1(PyObject *self, Py_ssize_t nobjs, PyObject **swig_obj) {
+SWIGINTERN PyObject *_wrap_ScanResolution_scanAbsoluteVectorResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
IRangedDistribution *arg1 = 0 ;
std::vector< double,std::allocator< double > > *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
int res2 = SWIG_OLDOBJ ;
+ PyObject *swig_obj[2] ;
ScanResolution *result = 0 ;
- if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "ScanResolution_scanAbsoluteVectorResolution", 2, 2, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_IRangedDistribution, 0 | 0);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScanResolution_scanAbsoluteResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScanResolution_scanAbsoluteVectorResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
}
if (!argp1) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanAbsoluteResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanAbsoluteVectorResolution" "', argument " "1"" of type '" "IRangedDistribution const &""'");
}
arg1 = reinterpret_cast< IRangedDistribution * >(argp1);
{
std::vector< double,std::allocator< double > > *ptr = (std::vector< double,std::allocator< double > > *)0;
res2 = swig::asptr(swig_obj[1], &ptr);
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScanResolution_scanAbsoluteResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ScanResolution_scanAbsoluteVectorResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanAbsoluteResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ScanResolution_scanAbsoluteVectorResolution" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg2 = ptr;
}
- result = (ScanResolution *)ScanResolution::scanAbsoluteResolution((IRangedDistribution const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScanResolution, SWIG_POINTER_OWN | 0 );
+ result = (ScanResolution *)ScanResolution::scanAbsoluteVectorResolution((IRangedDistribution const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScanResolution, 0 | 0 );
if (SWIG_IsNewObj(res2)) delete arg2;
return resultobj;
fail:
@@ -35720,50 +35368,6 @@ fail:
}
-SWIGINTERN PyObject *_wrap_ScanResolution_scanAbsoluteResolution(PyObject *self, PyObject *args) {
- Py_ssize_t argc;
- PyObject *argv[3] = {
- 0
- };
-
- if (!(argc = SWIG_Python_UnpackTuple(args, "ScanResolution_scanAbsoluteResolution", 0, 2, argv))) SWIG_fail;
- --argc;
- if (argc == 2) {
- int _v = 0;
- int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- {
- int res = SWIG_AsVal_double(argv[1], NULL);
- _v = SWIG_CheckState(res);
- }
- if (_v) {
- return _wrap_ScanResolution_scanAbsoluteResolution__SWIG_0(self, argc, argv);
- }
- }
- }
- if (argc == 2) {
- int _v = 0;
- int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_IRangedDistribution, SWIG_POINTER_NO_NULL | 0);
- _v = SWIG_CheckState(res);
- if (_v) {
- int res = swig::asptr(argv[1], (std::vector< double,std::allocator< double > >**)(0));
- _v = SWIG_CheckState(res);
- if (_v) {
- return _wrap_ScanResolution_scanAbsoluteResolution__SWIG_1(self, argc, argv);
- }
- }
- }
-
-fail:
- SWIG_Python_RaiseOrModifyTypeError("Wrong number or type of arguments for overloaded function 'ScanResolution_scanAbsoluteResolution'.\n"
- " Possible C/C++ prototypes are:\n"
- " ScanResolution::scanAbsoluteResolution(IRangedDistribution const &,double)\n"
- " ScanResolution::scanAbsoluteResolution(IRangedDistribution const &,std::vector< double,std::allocator< double > > const &)\n");
- return 0;
-}
-
-
SWIGINTERN PyObject *ScanResolution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
@@ -40153,17 +39757,25 @@ static PyMethodDef SwigMethods[] = {
""},
{ "AlphaScan_setRelativeWavelengthResolution", _wrap_AlphaScan_setRelativeWavelengthResolution, METH_VARARGS, "\n"
"AlphaScan_setRelativeWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, double rel_dev)\n"
- "AlphaScan_setRelativeWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)\n"
- "void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)\n"
+ "void AlphaScan::setRelativeWavelengthResolution(const IRangedDistribution &distr, double rel_dev)\n"
"AlphaScan::setRelativeWavelengthResolution\n"
+ ""},
+ { "AlphaScan_setRelativeWavelengthVectorResolution", _wrap_AlphaScan_setRelativeWavelengthVectorResolution, METH_VARARGS, "\n"
+ "AlphaScan_setRelativeWavelengthVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)\n"
+ "void AlphaScan::setRelativeWavelengthVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)\n"
+ "AlphaScan::setRelativeWavelengthVectorResolution\n"
"Sets wavelength resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. \n"
"\n"
""},
{ "AlphaScan_setAbsoluteWavelengthResolution", _wrap_AlphaScan_setAbsoluteWavelengthResolution, METH_VARARGS, "\n"
"AlphaScan_setAbsoluteWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)\n"
- "AlphaScan_setAbsoluteWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)\n"
- "void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)\n"
+ "void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution &distr, double std_dev)\n"
"AlphaScan::setAbsoluteWavelengthResolution\n"
+ ""},
+ { "AlphaScan_setAbsoluteWavelengthVectorResolution", _wrap_AlphaScan_setAbsoluteWavelengthVectorResolution, METH_VARARGS, "\n"
+ "AlphaScan_setAbsoluteWavelengthVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)\n"
+ "void AlphaScan::setAbsoluteWavelengthVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)\n"
+ "AlphaScan::setAbsoluteWavelengthVectorResolution\n"
"Sets wavelength resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. \n"
"\n"
""},
@@ -40176,17 +39788,25 @@ static PyMethodDef SwigMethods[] = {
""},
{ "AlphaScan_setRelativeAngularResolution", _wrap_AlphaScan_setRelativeAngularResolution, METH_VARARGS, "\n"
"AlphaScan_setRelativeAngularResolution(AlphaScan self, IRangedDistribution const & distr, double rel_dev)\n"
- "AlphaScan_setRelativeAngularResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)\n"
- "void AlphaScan::setRelativeAngularResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)\n"
+ "void AlphaScan::setRelativeAngularResolution(const IRangedDistribution &distr, double rel_dev)\n"
"AlphaScan::setRelativeAngularResolution\n"
+ ""},
+ { "AlphaScan_setRelativeAngularVectorResolution", _wrap_AlphaScan_setRelativeAngularVectorResolution, METH_VARARGS, "\n"
+ "AlphaScan_setRelativeAngularVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)\n"
+ "void AlphaScan::setRelativeAngularVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)\n"
+ "AlphaScan::setRelativeAngularVectorResolution\n"
"Sets angular resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. \n"
"\n"
""},
{ "AlphaScan_setAbsoluteAngularResolution", _wrap_AlphaScan_setAbsoluteAngularResolution, METH_VARARGS, "\n"
"AlphaScan_setAbsoluteAngularResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)\n"
- "AlphaScan_setAbsoluteAngularResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)\n"
- "void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)\n"
+ "void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution &distr, double std_dev)\n"
"AlphaScan::setAbsoluteAngularResolution\n"
+ ""},
+ { "AlphaScan_setAbsoluteAngularVectorResolution", _wrap_AlphaScan_setAbsoluteAngularVectorResolution, METH_VARARGS, "\n"
+ "AlphaScan_setAbsoluteAngularVectorResolution(AlphaScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)\n"
+ "void AlphaScan::setAbsoluteAngularVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)\n"
+ "AlphaScan::setAbsoluteAngularVectorResolution\n"
"Sets angular resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the inclination angle axis. \n"
"\n"
""},
@@ -40230,17 +39850,25 @@ static PyMethodDef SwigMethods[] = {
""},
{ "QzScan_setRelativeQResolution", _wrap_QzScan_setRelativeQResolution, METH_VARARGS, "\n"
"QzScan_setRelativeQResolution(QzScan self, IRangedDistribution const & distr, double rel_dev)\n"
- "QzScan_setRelativeQResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)\n"
- "void QzScan::setRelativeQResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)\n"
+ "void QzScan::setRelativeQResolution(const IRangedDistribution &distr, double rel_dev)\n"
"QzScan::setRelativeQResolution\n"
+ ""},
+ { "QzScan_setRelativeQVectorResolution", _wrap_QzScan_setRelativeQVectorResolution, METH_VARARGS, "\n"
+ "QzScan_setRelativeQVectorResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t rel_dev)\n"
+ "void QzScan::setRelativeQVectorResolution(const IRangedDistribution &distr, const std::vector< double > &rel_dev)\n"
+ "QzScan::setRelativeQVectorResolution\n"
"Sets qz resolution values via IRangedDistribution and values of relative deviations (that is, rel_dev equals standard deviation divided by the mean value). rel_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis. \n"
"\n"
""},
{ "QzScan_setAbsoluteQResolution", _wrap_QzScan_setAbsoluteQResolution, METH_VARARGS, "\n"
"QzScan_setAbsoluteQResolution(QzScan self, IRangedDistribution const & distr, double std_dev)\n"
- "QzScan_setAbsoluteQResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)\n"
- "void QzScan::setAbsoluteQResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)\n"
+ "void QzScan::setAbsoluteQResolution(const IRangedDistribution &distr, double std_dev)\n"
"QzScan::setAbsoluteQResolution\n"
+ ""},
+ { "QzScan_setAbsoluteQVectorResolution", _wrap_QzScan_setAbsoluteQVectorResolution, METH_VARARGS, "\n"
+ "QzScan_setAbsoluteQVectorResolution(QzScan self, IRangedDistribution const & distr, vdouble1d_t std_dev)\n"
+ "void QzScan::setAbsoluteQVectorResolution(const IRangedDistribution &distr, const std::vector< double > &std_dev)\n"
+ "QzScan::setAbsoluteQVectorResolution\n"
"Sets qz resolution values via IRangedDistribution and values of standard deviations. std_dev can be either single-valued or a numpy array. In the latter case the length of the array should coinside with the length of the qz-axis. \n"
"\n"
""},
@@ -40261,14 +39889,10 @@ static PyMethodDef SwigMethods[] = {
"ScanResolution::~ScanResolution() override\n"
"ScanResolution::~ScanResolution\n"
""},
- { "ScanResolution_scanRelativeResolution", _wrap_ScanResolution_scanRelativeResolution, METH_VARARGS, "\n"
- "ScanResolution_scanRelativeResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution\n"
- "ScanResolution_scanRelativeResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution\n"
- ""},
- { "ScanResolution_scanAbsoluteResolution", _wrap_ScanResolution_scanAbsoluteResolution, METH_VARARGS, "\n"
- "ScanResolution_scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution\n"
- "ScanResolution_scanAbsoluteResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution\n"
- ""},
+ { "ScanResolution_scanRelativeResolution", _wrap_ScanResolution_scanRelativeResolution, METH_VARARGS, "ScanResolution_scanRelativeResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution"},
+ { "ScanResolution_scanRelativeVectorResolution", _wrap_ScanResolution_scanRelativeVectorResolution, METH_VARARGS, "ScanResolution_scanRelativeVectorResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution"},
+ { "ScanResolution_scanAbsoluteResolution", _wrap_ScanResolution_scanAbsoluteResolution, METH_VARARGS, "ScanResolution_scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution"},
+ { "ScanResolution_scanAbsoluteVectorResolution", _wrap_ScanResolution_scanAbsoluteVectorResolution, METH_VARARGS, "ScanResolution_scanAbsoluteVectorResolution(IRangedDistribution const & distr, vdouble1d_t stddevs) -> ScanResolution"},
{ "ScanResolution_swigregister", ScanResolution_swigregister, METH_O, NULL},
{ "delete_ISimulation", _wrap_delete_ISimulation, METH_O, "\n"
"delete_ISimulation(ISimulation self)\n"
--
GitLab