diff --git a/GUI/Model/FromCore/ItemizeSimulation.cpp b/GUI/Model/FromCore/ItemizeSimulation.cpp
index 2063d46aa2d2ca20eeda8a4b5f218628da1d273f..54afb3b82f1004b9d0d9148ce2d90bff3284a469 100644
--- a/GUI/Model/FromCore/ItemizeSimulation.cpp
+++ b/GUI/Model/FromCore/ItemizeSimulation.cpp
@@ -450,14 +450,14 @@ SpecularInstrumentItem* createSpecularInstrumentItem(const SpecularSimulation& s
if (!alphaScan)
return result;
- if (const IScanResolution* resolution = alphaScan->wavelengthResolution())
+ if (const ScanResolution* resolution = alphaScan->wavelengthResolution())
if (const IRangedDistribution* rdis = resolution->rdistribution()) {
double mean = alphaScan->wavelength();
double std_dev = resolution->stdDevs(mean, 1).front();
addRangedDistributionToItem(beam_item->wavelengthItem(), *rdis, mean, std_dev);
}
- if (const IScanResolution* resolution = alphaScan->angleResolution())
+ if (const ScanResolution* resolution = alphaScan->angleResolution())
if (const IRangedDistribution* rdis = resolution->rdistribution()) {
double std_dev = resolution->stdDevs(0.0, 1).front();
addRangedDistributionToItem(beam_item->inclinationAngleItem(), *rdis, 0, std_dev);
diff --git a/GUI/Model/ToCore/SimulationToCore.cpp b/GUI/Model/ToCore/SimulationToCore.cpp
index d98306058f6f5a9735c0f06887c9ff9292235287..f1e2d9feacc871a6a91d1da251dcec9e984b4e6c 100644
--- a/GUI/Model/ToCore/SimulationToCore.cpp
+++ b/GUI/Model/ToCore/SimulationToCore.cpp
@@ -71,7 +71,7 @@ void addBackgroundToSimulation(const InstrumentItem& item, ISimulation& simulati
simulation.setBackground(*background);
}
-std::unique_ptr<IScanResolution> createIScanResolution(const BeamDistributionItem* item)
+std::unique_ptr<ScanResolution> createScanResolution(const BeamDistributionItem* item)
{
if (!item)
return nullptr;
@@ -86,7 +86,7 @@ std::unique_ptr<IScanResolution> createIScanResolution(const BeamDistributionIte
return nullptr;
const double deviation = distr_item->deviation(scale);
- return std::unique_ptr<IScanResolution>(scanAbsoluteResolution(*ranged_distr, deviation));
+ return std::unique_ptr<ScanResolution>(scanAbsoluteResolution(*ranged_distr, deviation));
}
void setSimulationOptions(ISimulation* simulation, const SimulationOptionsItem& item)
@@ -134,8 +134,8 @@ SpecularSimulation* createSpecularSimulation(std::unique_ptr<MultiLayer> sample,
AlphaScan scan(beam_item->wavelength(), *axis_item->createAxis(Units::deg));
scan.setFootprintFactor(footprint_item->createFootprint().get());
- scan.setWavelengthResolution(createIScanResolution(beam_item->wavelengthItem()).get());
- scan.setAngleResolution(createIScanResolution(beam_item->inclinationAngleItem()).get());
+ scan.setWavelengthResolution(createScanResolution(beam_item->wavelengthItem()).get());
+ scan.setAngleResolution(createScanResolution(beam_item->inclinationAngleItem()).get());
auto* result = new SpecularSimulation(scan, *sample);
// result->beam().setIntensity(beam_item->intensity());
diff --git a/Sim/Export/SimulationToPython.cpp b/Sim/Export/SimulationToPython.cpp
index 630c443018533788db5bc7ba601e4b8820271f5e..01a339fbf5ae4049ed7865b347239963b805e616 100644
--- a/Sim/Export/SimulationToPython.cpp
+++ b/Sim/Export/SimulationToPython.cpp
@@ -81,7 +81,7 @@ std::string defineFootprintFactor(const IFootprintFactor& foot)
return result.str();
}
-std::string defineIScanResolution(const IScanResolution& sresol)
+std::string defineScanResolution(const ScanResolution& sresol)
{
std::ostringstream result;
result << Py::Fmt2::printRangedDistribution(*sresol.rdistribution()) << "\n"
@@ -105,11 +105,11 @@ std::string defineAlphaScan(const AlphaScan& scan)
result << indent() << "scan.setFootprintFactor(footprint)\n";
}
if (const auto* r = scan.angleResolution(); r && r->rdistribution()) {
- result << defineIScanResolution(*r) << "\n";
+ result << defineScanResolution(*r) << "\n";
result << indent() << "scan.setAngleResolution(resolution)\n";
}
if (const auto* r = scan.wavelengthResolution(); r && r->rdistribution()) {
- result << defineIScanResolution(*r) << "\n";
+ result << defineScanResolution(*r) << "\n";
result << indent() << "scan.setWavelengthResolution(resolution)\n";
}
return result.str();
@@ -123,7 +123,7 @@ std::string defineQzScan(const QzScan& scan)
// TODO correct unit would be 1/nm
result << indent() << "scan = ba.QzScan(axis)";
- if (const IScanResolution* sresol = scan.resolution()) {
+ if (const ScanResolution* sresol = scan.resolution()) {
result << "\n";
result << Py::Fmt2::printRangedDistribution(*sresol->rdistribution()) << "\n";
const std::vector<double>& widths = scan.resolution_widths();
diff --git a/Sim/Scan/AlphaScan.cpp b/Sim/Scan/AlphaScan.cpp
index 164e03e3443dfde369b118caabd73335b1a14f62..fb06d9a3e76716bb691af4b1b747fd1bea155716 100644
--- a/Sim/Scan/AlphaScan.cpp
+++ b/Sim/Scan/AlphaScan.cpp
@@ -26,12 +26,12 @@
namespace {
-size_t nResolSamples(const IScanResolution* resol)
+size_t nResolSamples(const ScanResolution* resol)
{
return resol ? resol->nSamples() : 1L;
}
-std::vector<ParameterSample> drawResolution(const IScanResolution* resol, double mean)
+std::vector<ParameterSample> drawResolution(const ScanResolution* resol, double mean)
{
if (resol)
return resol->resolutionSamples(mean);
@@ -104,25 +104,25 @@ void AlphaScan::setFootprintFactor(const IFootprintFactor* f_factor)
m_footprint.reset(f_factor ? f_factor->clone() : nullptr);
}
-void AlphaScan::setWavelengthResolution(const IScanResolution* resolution)
+void AlphaScan::setWavelengthResolution(const ScanResolution* resolution)
{
m_lambda_distrib.reset(resolution ? resolution->clone() : nullptr);
}
void AlphaScan::setAbsoluteWavelengthResolution(const IRangedDistribution& distr, double std_dev)
{
- std::unique_ptr<IScanResolution> resolution(scanAbsoluteResolution(distr, std_dev));
+ std::unique_ptr<ScanResolution> resolution(scanAbsoluteResolution(distr, std_dev));
setWavelengthResolution(resolution.get());
}
-void AlphaScan::setAngleResolution(const IScanResolution* resolution)
+void AlphaScan::setAngleResolution(const ScanResolution* resolution)
{
m_alpha_distrib.reset(resolution ? resolution->clone() : nullptr);
}
void AlphaScan::setAbsoluteAngularResolution(const IRangedDistribution& distr, double std_dev)
{
- std::unique_ptr<IScanResolution> resolution(scanAbsoluteResolution(distr, std_dev));
+ std::unique_ptr<ScanResolution> resolution(scanAbsoluteResolution(distr, std_dev));
setAngleResolution(resolution.get());
}
diff --git a/Sim/Scan/AlphaScan.h b/Sim/Scan/AlphaScan.h
index 99d2fc66a63d02038c1a7090468640a6e39a4fbf..3be4e0138478b78fb8df563d09640385f809d265 100644
--- a/Sim/Scan/AlphaScan.h
+++ b/Sim/Scan/AlphaScan.h
@@ -20,7 +20,7 @@
class ParameterSample;
class IRangedDistribution;
-class IScanResolution;
+class ScanResolution;
//! Scan type with inclination angles as coordinate values and a unique wavelength.
//! Features footprint correction.
@@ -39,13 +39,13 @@ public:
//! Sets footprint correction factor
void setFootprintFactor(const IFootprintFactor* f_factor);
- //! Sets wavelength resolution values via IScanResolution object.
- void setWavelengthResolution(const IScanResolution* resolution);
+ //! Sets wavelength resolution values via ScanResolution object.
+ void setWavelengthResolution(const ScanResolution* resolution);
void setAbsoluteWavelengthResolution(const IRangedDistribution& distr, double std_dev);
- //! Sets angle resolution values via IScanResolution object.
- void setAngleResolution(const IScanResolution* resolution);
+ //! Sets angle resolution values via ScanResolution object.
+ void setAngleResolution(const ScanResolution* resolution);
void setAbsoluteAngularResolution(const IRangedDistribution& distr, double std_dev);
@@ -65,11 +65,11 @@ public:
CoordSystem1D* scanCoordSystem() const override;
// TODO: remove these getters after transition to the new resolution machinery is finished
- const IScanResolution* wavelengthResolution() const
+ const ScanResolution* wavelengthResolution() const
{
return m_lambda_distrib.get();
}
- const IScanResolution* angleResolution() const
+ const ScanResolution* angleResolution() const
{
return m_alpha_distrib.get();
}
@@ -81,8 +81,8 @@ private:
std::unique_ptr<IFootprintFactor> m_footprint;
- std::unique_ptr<IScanResolution> m_lambda_distrib;
- std::unique_ptr<IScanResolution> m_alpha_distrib;
+ std::unique_ptr<ScanResolution> m_lambda_distrib;
+ std::unique_ptr<ScanResolution> m_alpha_distrib;
#endif // SWIG
};
diff --git a/Sim/Scan/QzScan.h b/Sim/Scan/QzScan.h
index 2cc8220ea1d666ef443a8b07e2a747193f7975a4..08d12f078e9abb7591563459c7814e50842c135e 100644
--- a/Sim/Scan/QzScan.h
+++ b/Sim/Scan/QzScan.h
@@ -20,7 +20,7 @@
class ParameterSample;
class IRangedDistribution;
-class IScanResolution;
+class ScanResolution;
//! Scan type with z-components of scattering vector as coordinate values.
//! Wavelength and incident angles are not accessible separately.
@@ -53,7 +53,7 @@ public:
void setOffset(double offset) { m_offset = offset; }
#ifndef SWIG
- const IScanResolution* resolution() const
+ const ScanResolution* resolution() const
{
return m_resolution.get();
}
@@ -77,7 +77,7 @@ public:
private:
QzScan(IAxis* qs_nm);
- std::unique_ptr<IScanResolution> m_resolution;
+ std::unique_ptr<ScanResolution> m_resolution;
std::vector<double> m_resol_width;
bool m_relative_resolution{false};
double m_offset = 0.;
diff --git a/Sim/Scan/ScanResolution.cpp b/Sim/Scan/ScanResolution.cpp
index 02e64a079806dfcc558bfe5210cee2c0f8980463..5ded93d9ebe76e0873e38186d5b4dd991f1d30a0 100644
--- a/Sim/Scan/ScanResolution.cpp
+++ b/Sim/Scan/ScanResolution.cpp
@@ -17,36 +17,36 @@
#include "Param/Distrib/ParameterSample.h"
#include "Param/Distrib/RangedDistributions.h"
-IScanResolution::IScanResolution(const IRangedDistribution& distr, double stddev)
+ScanResolution::ScanResolution(const IRangedDistribution& distr, double stddev)
: m_distr(distr.clone())
, m_stddev(stddev)
{
}
-IScanResolution::~IScanResolution() = default;
+ScanResolution::~ScanResolution() = default;
-IScanResolution* IScanResolution::clone() const
+ScanResolution* ScanResolution::clone() const
{
- return new IScanResolution(*rdistribution(), m_stddev);
+ return new ScanResolution(*rdistribution(), m_stddev);
}
-std::vector<ParameterSample> IScanResolution::resolutionSamples(double mean) const
+std::vector<ParameterSample> ScanResolution::resolutionSamples(double mean) const
{
return rdistribution()->generateSamples(mean, m_stddev);
}
-std::vector<double> IScanResolution::stdDevs(double, size_t n_times) const
+std::vector<double> ScanResolution::stdDevs(double, size_t n_times) const
{
return std::vector<double>(n_times, m_stddev);
}
-std::vector<double> IScanResolution::stdDevs(const std::vector<double>& mean) const
+std::vector<double> ScanResolution::stdDevs(const std::vector<double>& mean) const
{
ASSERT(!mean.empty());
return std::vector<double>(mean.size(), m_stddev);
}
-size_t IScanResolution::nSamples() const
+size_t ScanResolution::nSamples() const
{
if (m_distr)
return m_distr->nSamples();
@@ -57,7 +57,7 @@ size_t IScanResolution::nSamples() const
// Factory functions
// ************************************************************************************************
-IScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev)
+ScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev)
{
- return new IScanResolution(distr, stddev);
+ return new ScanResolution(distr, stddev);
}
diff --git a/Sim/Scan/ScanResolution.h b/Sim/Scan/ScanResolution.h
index c6568b8a424931744da68e31dfa80591b9ff0c22..9927581d4d433f963ae255102acb302c8ee06d3b 100644
--- a/Sim/Scan/ScanResolution.h
+++ b/Sim/Scan/ScanResolution.h
@@ -26,13 +26,13 @@ class ParameterSample;
//! Abstract base class for reflectivity resolution functions.
//! Child classes have local scope only (declared and implemented in ScanResolution.cpp);
//! they can only be created through the factory functions declared below.
-class IScanResolution : public ICloneable {
+class ScanResolution : public ICloneable {
public:
- IScanResolution(const IRangedDistribution& distr, double stddev);
- ~IScanResolution() override;
+ ScanResolution(const IRangedDistribution& distr, double stddev);
+ ~ScanResolution() override;
#ifndef SWIG
- IScanResolution* clone() const override;
+ ScanResolution* clone() const override;
const IRangedDistribution* rdistribution() const
{
return m_distr.get();
@@ -61,6 +61,6 @@ protected:
};
-IScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev);
+ScanResolution* scanAbsoluteResolution(const IRangedDistribution& distr, double stddev);
#endif // BORNAGAIN_SIM_SCAN_SCANRESOLUTION_H
diff --git a/Tests/SimFactory/MakeSimulations.cpp b/Tests/SimFactory/MakeSimulations.cpp
index 6a385d0f330b923533c5d679856049c408f9ae05..5b8433c1f4069533b1e52a04d12bdcd9a30eae31 100644
--- a/Tests/SimFactory/MakeSimulations.cpp
+++ b/Tests/SimFactory/MakeSimulations.cpp
@@ -420,10 +420,10 @@ test::makeSimulation::SpecularDivergentBeam(const MultiLayer& sample)
AlphaScan scan(wavelength, FixedBinAxis("axis", number_of_bins, min_angle, max_angle));
RangedDistributionGaussian wl_distr(n_integration_points, /*sigma_factor = */ 2.0);
- std::unique_ptr<IScanResolution> wl_res(scanAbsoluteResolution(wl_distr, wl_stddev));
+ std::unique_ptr<ScanResolution> wl_res(scanAbsoluteResolution(wl_distr, wl_stddev));
RangedDistributionGaussian alpha_distr(n_integration_points, /*sigma_factor = */ 2.0);
- std::unique_ptr<IScanResolution> ang_res(scanAbsoluteResolution(alpha_distr, ang_stddev));
+ std::unique_ptr<ScanResolution> ang_res(scanAbsoluteResolution(alpha_distr, ang_stddev));
scan.setWavelengthResolution(wl_res.get());
scan.setAngleResolution(ang_res.get());
diff --git a/auto/Wrap/libBornAgainSim.py b/auto/Wrap/libBornAgainSim.py
index 9156e1c6071c68af21fea33174bd5b9f9f31d8b9..d5ca7f68c9b436ad2195ca7a77b70ea491f85fd7 100644
--- a/auto/Wrap/libBornAgainSim.py
+++ b/auto/Wrap/libBornAgainSim.py
@@ -2569,7 +2569,7 @@ class AlphaScan(ISpecularScan):
return _libBornAgainSim.AlphaScan_setFootprintFactor(self, f_factor)
def setWavelengthResolution(self, resolution):
- r"""setWavelengthResolution(AlphaScan self, IScanResolution resolution)"""
+ r"""setWavelengthResolution(AlphaScan self, ScanResolution resolution)"""
return _libBornAgainSim.AlphaScan_setWavelengthResolution(self, resolution)
def setAbsoluteWavelengthResolution(self, distr, std_dev):
@@ -2577,7 +2577,7 @@ class AlphaScan(ISpecularScan):
return _libBornAgainSim.AlphaScan_setAbsoluteWavelengthResolution(self, distr, std_dev)
def setAngleResolution(self, resolution):
- r"""setAngleResolution(AlphaScan self, IScanResolution resolution)"""
+ r"""setAngleResolution(AlphaScan self, ScanResolution resolution)"""
return _libBornAgainSim.AlphaScan_setAngleResolution(self, resolution)
def setAbsoluteAngularResolution(self, distr, std_dev):
@@ -2627,21 +2627,21 @@ class QzScan(ISpecularScan):
# Register QzScan in _libBornAgainSim:
_libBornAgainSim.QzScan_swigregister(QzScan)
-class IScanResolution(libBornAgainBase.ICloneable):
- r"""Proxy of C++ IScanResolution class."""
+class ScanResolution(libBornAgainBase.ICloneable):
+ r"""Proxy of C++ ScanResolution class."""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
- __swig_destroy__ = _libBornAgainSim.delete_IScanResolution
+ __swig_destroy__ = _libBornAgainSim.delete_ScanResolution
-# Register IScanResolution in _libBornAgainSim:
-_libBornAgainSim.IScanResolution_swigregister(IScanResolution)
+# Register ScanResolution in _libBornAgainSim:
+_libBornAgainSim.ScanResolution_swigregister(ScanResolution)
def scanAbsoluteResolution(distr, stddev):
- r"""scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> IScanResolution"""
+ r"""scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution"""
return _libBornAgainSim.scanAbsoluteResolution(distr, stddev)
class ISimulation(libBornAgainParam.INode):
r"""Proxy of C++ ISimulation class."""
diff --git a/auto/Wrap/libBornAgainSim_wrap.cpp b/auto/Wrap/libBornAgainSim_wrap.cpp
index 70c6be243c5acbb047801ace3c6c07ae8e4c4f14..500f4d210ccce3ed02015e53a8ceca4d63df0b17 100644
--- a/auto/Wrap/libBornAgainSim_wrap.cpp
+++ b/auto/Wrap/libBornAgainSim_wrap.cpp
@@ -3403,23 +3403,23 @@ namespace Swig {
#define SWIGTYPE_p_INode swig_types[14]
#define SWIGTYPE_p_IRangedDistribution swig_types[15]
#define SWIGTYPE_p_ISampleNode swig_types[16]
-#define SWIGTYPE_p_IScanResolution swig_types[17]
-#define SWIGTYPE_p_IShape2D swig_types[18]
-#define SWIGTYPE_p_ISimulation swig_types[19]
-#define SWIGTYPE_p_ISpecularScan swig_types[20]
-#define SWIGTYPE_p_IVarianceFunction swig_types[21]
-#define SWIGTYPE_p_IntensityFunctionLog swig_types[22]
-#define SWIGTYPE_p_IntensityFunctionSqrt swig_types[23]
-#define SWIGTYPE_p_IterationInfo swig_types[24]
-#define SWIGTYPE_p_MultiLayer swig_types[25]
-#define SWIGTYPE_p_OffspecSimulation swig_types[26]
-#define SWIGTYPE_p_ParameterDistribution swig_types[27]
-#define SWIGTYPE_p_PoissonBackground swig_types[28]
-#define SWIGTYPE_p_PyBuilderCallback swig_types[29]
-#define SWIGTYPE_p_PyObserverCallback swig_types[30]
-#define SWIGTYPE_p_QzScan swig_types[31]
-#define SWIGTYPE_p_RealLimits swig_types[32]
-#define SWIGTYPE_p_Rotation3DT_double_t swig_types[33]
+#define SWIGTYPE_p_IShape2D swig_types[17]
+#define SWIGTYPE_p_ISimulation swig_types[18]
+#define SWIGTYPE_p_ISpecularScan swig_types[19]
+#define SWIGTYPE_p_IVarianceFunction swig_types[20]
+#define SWIGTYPE_p_IntensityFunctionLog swig_types[21]
+#define SWIGTYPE_p_IntensityFunctionSqrt swig_types[22]
+#define SWIGTYPE_p_IterationInfo swig_types[23]
+#define SWIGTYPE_p_MultiLayer swig_types[24]
+#define SWIGTYPE_p_OffspecSimulation swig_types[25]
+#define SWIGTYPE_p_ParameterDistribution swig_types[26]
+#define SWIGTYPE_p_PoissonBackground swig_types[27]
+#define SWIGTYPE_p_PyBuilderCallback swig_types[28]
+#define SWIGTYPE_p_PyObserverCallback swig_types[29]
+#define SWIGTYPE_p_QzScan swig_types[30]
+#define SWIGTYPE_p_RealLimits swig_types[31]
+#define SWIGTYPE_p_Rotation3DT_double_t swig_types[32]
+#define SWIGTYPE_p_ScanResolution swig_types[33]
#define SWIGTYPE_p_ScatteringSimulation swig_types[34]
#define SWIGTYPE_p_SimulationOptions swig_types[35]
#define SWIGTYPE_p_SimulationResult swig_types[36]
@@ -32256,7 +32256,7 @@ fail:
SWIGINTERN PyObject *_wrap_AlphaScan_setWavelengthResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
- IScanResolution *arg2 = (IScanResolution *) 0 ;
+ ScanResolution *arg2 = (ScanResolution *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
@@ -32269,12 +32269,12 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setWavelengthResolution(PyObject *self, PyO
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setWavelengthResolution" "', argument " "1"" of type '" "AlphaScan *""'");
}
arg1 = reinterpret_cast< AlphaScan * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IScanResolution, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScanResolution, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setWavelengthResolution" "', argument " "2"" of type '" "IScanResolution const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setWavelengthResolution" "', argument " "2"" of type '" "ScanResolution const *""'");
}
- arg2 = reinterpret_cast< IScanResolution * >(argp2);
- (arg1)->setWavelengthResolution((IScanResolution const *)arg2);
+ arg2 = reinterpret_cast< ScanResolution * >(argp2);
+ (arg1)->setWavelengthResolution((ScanResolution const *)arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -32325,7 +32325,7 @@ fail:
SWIGINTERN PyObject *_wrap_AlphaScan_setAngleResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
AlphaScan *arg1 = (AlphaScan *) 0 ;
- IScanResolution *arg2 = (IScanResolution *) 0 ;
+ ScanResolution *arg2 = (ScanResolution *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
@@ -32338,12 +32338,12 @@ SWIGINTERN PyObject *_wrap_AlphaScan_setAngleResolution(PyObject *self, PyObject
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AlphaScan_setAngleResolution" "', argument " "1"" of type '" "AlphaScan *""'");
}
arg1 = reinterpret_cast< AlphaScan * >(argp1);
- res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_IScanResolution, 0 | 0 );
+ res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_ScanResolution, 0 | 0 );
if (!SWIG_IsOK(res2)) {
- SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setAngleResolution" "', argument " "2"" of type '" "IScanResolution const *""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "AlphaScan_setAngleResolution" "', argument " "2"" of type '" "ScanResolution const *""'");
}
- arg2 = reinterpret_cast< IScanResolution * >(argp2);
- (arg1)->setAngleResolution((IScanResolution const *)arg2);
+ arg2 = reinterpret_cast< ScanResolution * >(argp2);
+ (arg1)->setAngleResolution((ScanResolution const *)arg2);
resultobj = SWIG_Py_Void();
return resultobj;
fail:
@@ -32784,20 +32784,20 @@ SWIGINTERN PyObject *QzScan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *a
return SWIG_Python_InitShadowInstance(args);
}
-SWIGINTERN PyObject *_wrap_delete_IScanResolution(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_delete_ScanResolution(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
- IScanResolution *arg1 = (IScanResolution *) 0 ;
+ ScanResolution *arg1 = (ScanResolution *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
- res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_IScanResolution, SWIG_POINTER_DISOWN | 0 );
+ res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_ScanResolution, SWIG_POINTER_DISOWN | 0 );
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_IScanResolution" "', argument " "1"" of type '" "IScanResolution *""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_ScanResolution" "', argument " "1"" of type '" "ScanResolution *""'");
}
- arg1 = reinterpret_cast< IScanResolution * >(argp1);
+ arg1 = reinterpret_cast< ScanResolution * >(argp1);
delete arg1;
resultobj = SWIG_Py_Void();
return resultobj;
@@ -32806,10 +32806,10 @@ fail:
}
-SWIGINTERN PyObject *IScanResolution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
+SWIGINTERN PyObject *ScanResolution_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *obj;
if (!SWIG_Python_UnpackTuple(args, "swigregister", 1, 1, &obj)) return NULL;
- SWIG_TypeNewClientData(SWIGTYPE_p_IScanResolution, SWIG_NewClientData(obj));
+ SWIG_TypeNewClientData(SWIGTYPE_p_ScanResolution, SWIG_NewClientData(obj));
return SWIG_Py_Void();
}
@@ -32822,7 +32822,7 @@ SWIGINTERN PyObject *_wrap_scanAbsoluteResolution(PyObject *self, PyObject *args
double val2 ;
int ecode2 = 0 ;
PyObject *swig_obj[2] ;
- IScanResolution *result = 0 ;
+ ScanResolution *result = 0 ;
if (!SWIG_Python_UnpackTuple(args, "scanAbsoluteResolution", 2, 2, swig_obj)) SWIG_fail;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_IRangedDistribution, 0 | 0);
@@ -32838,8 +32838,8 @@ SWIGINTERN PyObject *_wrap_scanAbsoluteResolution(PyObject *self, PyObject *args
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scanAbsoluteResolution" "', argument " "2"" of type '" "double""'");
}
arg2 = static_cast< double >(val2);
- result = (IScanResolution *)scanAbsoluteResolution((IRangedDistribution const &)*arg1,arg2);
- resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_IScanResolution, 0 | 0 );
+ result = (ScanResolution *)scanAbsoluteResolution((IRangedDistribution const &)*arg1,arg2);
+ resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_ScanResolution, 0 | 0 );
return resultobj;
fail:
return NULL;
@@ -36744,9 +36744,9 @@ static PyMethodDef SwigMethods[] = {
{ "delete_AlphaScan", _wrap_delete_AlphaScan, METH_O, "delete_AlphaScan(AlphaScan self)"},
{ "AlphaScan_clone", _wrap_AlphaScan_clone, METH_O, "AlphaScan_clone(AlphaScan self) -> AlphaScan"},
{ "AlphaScan_setFootprintFactor", _wrap_AlphaScan_setFootprintFactor, METH_VARARGS, "AlphaScan_setFootprintFactor(AlphaScan self, IFootprintFactor const * f_factor)"},
- { "AlphaScan_setWavelengthResolution", _wrap_AlphaScan_setWavelengthResolution, METH_VARARGS, "AlphaScan_setWavelengthResolution(AlphaScan self, IScanResolution resolution)"},
+ { "AlphaScan_setWavelengthResolution", _wrap_AlphaScan_setWavelengthResolution, METH_VARARGS, "AlphaScan_setWavelengthResolution(AlphaScan self, ScanResolution resolution)"},
{ "AlphaScan_setAbsoluteWavelengthResolution", _wrap_AlphaScan_setAbsoluteWavelengthResolution, METH_VARARGS, "AlphaScan_setAbsoluteWavelengthResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)"},
- { "AlphaScan_setAngleResolution", _wrap_AlphaScan_setAngleResolution, METH_VARARGS, "AlphaScan_setAngleResolution(AlphaScan self, IScanResolution resolution)"},
+ { "AlphaScan_setAngleResolution", _wrap_AlphaScan_setAngleResolution, METH_VARARGS, "AlphaScan_setAngleResolution(AlphaScan self, ScanResolution resolution)"},
{ "AlphaScan_setAbsoluteAngularResolution", _wrap_AlphaScan_setAbsoluteAngularResolution, METH_VARARGS, "AlphaScan_setAbsoluteAngularResolution(AlphaScan self, IRangedDistribution const & distr, double std_dev)"},
{ "AlphaScan_swigregister", AlphaScan_swigregister, METH_O, NULL},
{ "AlphaScan_swiginit", AlphaScan_swiginit, METH_VARARGS, NULL},
@@ -36764,9 +36764,9 @@ static PyMethodDef SwigMethods[] = {
{ "QzScan_setOffset", _wrap_QzScan_setOffset, METH_VARARGS, "QzScan_setOffset(QzScan self, double offset)"},
{ "QzScan_swigregister", QzScan_swigregister, METH_O, NULL},
{ "QzScan_swiginit", QzScan_swiginit, METH_VARARGS, NULL},
- { "delete_IScanResolution", _wrap_delete_IScanResolution, METH_O, "delete_IScanResolution(IScanResolution self)"},
- { "IScanResolution_swigregister", IScanResolution_swigregister, METH_O, NULL},
- { "scanAbsoluteResolution", _wrap_scanAbsoluteResolution, METH_VARARGS, "scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> IScanResolution"},
+ { "delete_ScanResolution", _wrap_delete_ScanResolution, METH_O, "delete_ScanResolution(ScanResolution self)"},
+ { "ScanResolution_swigregister", ScanResolution_swigregister, METH_O, NULL},
+ { "scanAbsoluteResolution", _wrap_scanAbsoluteResolution, METH_VARARGS, "scanAbsoluteResolution(IRangedDistribution const & distr, double stddev) -> ScanResolution"},
{ "delete_ISimulation", _wrap_delete_ISimulation, METH_O, "delete_ISimulation(ISimulation self)"},
{ "ISimulation_setBackground", _wrap_ISimulation_setBackground, METH_VARARGS, "ISimulation_setBackground(ISimulation self, IBackground bg)"},
{ "ISimulation_addParameterDistribution", _wrap_ISimulation_addParameterDistribution, METH_VARARGS, "\n"
@@ -36920,9 +36920,6 @@ static void *_p_IChiSquaredModuleTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(ne
static void *_p_ISampleNodeTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((ICloneable *) ((ISampleNode *) x));
}
-static void *_p_IScanResolutionTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
- return (void *)((ICloneable *) ((IScanResolution *) x));
-}
static void *_p_ISpecularScanTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((ICloneable *) ((ISpecularScan *) x));
}
@@ -36932,6 +36929,9 @@ static void *_p_PoissonBackgroundTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(ne
static void *_p_QzScanTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((ICloneable *) (ISpecularScan *) ((QzScan *) x));
}
+static void *_p_ScanResolutionTo_p_ICloneable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
+ return (void *)((ICloneable *) ((ScanResolution *) x));
+}
static void *_p_IntensityFunctionLogTo_p_IIntensityFunction(void *x, int *SWIGUNUSEDPARM(newmemory)) {
return (void *)((IIntensityFunction *) ((IntensityFunctionLog *) x));
}
@@ -37006,7 +37006,6 @@ static swig_type_info _swigt__p_IFootprintFactor = {"_p_IFootprintFactor", "IFoo
static swig_type_info _swigt__p_IIntensityFunction = {"_p_IIntensityFunction", "IIntensityFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_INode = {"_p_INode", "std::vector< INode const * >::value_type|INode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IRangedDistribution = {"_p_IRangedDistribution", "IRangedDistribution *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_IScanResolution = {"_p_IScanResolution", "IScanResolution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_IShape2D = {"_p_IShape2D", "IShape2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ISimulation = {"_p_ISimulation", "ISimulation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ISpecularScan = {"_p_ISpecularScan", "ISpecularScan *", 0, 0, (void*)0, 0};
@@ -37023,6 +37022,7 @@ static swig_type_info _swigt__p_PyObserverCallback = {"_p_PyObserverCallback", "
static swig_type_info _swigt__p_QzScan = {"_p_QzScan", "QzScan *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_RealLimits = {"_p_RealLimits", "RealLimits *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Rotation3DT_double_t = {"_p_Rotation3DT_double_t", "RotMatrix *|Rotation3D< double > *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_ScanResolution = {"_p_ScanResolution", "ScanResolution *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_ScatteringSimulation = {"_p_ScatteringSimulation", "ScatteringSimulation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SimulationOptions = {"_p_SimulationOptions", "SimulationOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_SimulationResult = {"_p_SimulationResult", "SimulationResult *", 0, 0, (void*)0, 0};
@@ -37099,7 +37099,6 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_INode,
&_swigt__p_IRangedDistribution,
&_swigt__p_ISampleNode,
- &_swigt__p_IScanResolution,
&_swigt__p_IShape2D,
&_swigt__p_ISimulation,
&_swigt__p_ISpecularScan,
@@ -37116,6 +37115,7 @@ static swig_type_info *swig_type_initial[] = {
&_swigt__p_QzScan,
&_swigt__p_RealLimits,
&_swigt__p_Rotation3DT_double_t,
+ &_swigt__p_ScanResolution,
&_swigt__p_ScatteringSimulation,
&_swigt__p_SimulationOptions,
&_swigt__p_SimulationResult,
@@ -37185,14 +37185,13 @@ static swig_cast_info _swigc__p_IAxis[] = { {&_swigt__p_IAxis, 0, 0, 0},{0, 0,
static swig_cast_info _swigc__p_IBackground[] = { {&_swigt__p_IBackground, 0, 0, 0}, {&_swigt__p_ConstantBackground, _p_ConstantBackgroundTo_p_IBackground, 0, 0}, {&_swigt__p_PoissonBackground, _p_PoissonBackgroundTo_p_IBackground, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IChiSquaredModule[] = { {&_swigt__p_IChiSquaredModule, 0, 0, 0}, {&_swigt__p_ChiSquaredModule, _p_ChiSquaredModuleTo_p_IChiSquaredModule, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ISampleNode[] = {{&_swigt__p_ISampleNode, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_ICloneable[] = { {&_swigt__p_ICloneable, 0, 0, 0}, {&_swigt__p_AlphaScan, _p_AlphaScanTo_p_ICloneable, 0, 0}, {&_swigt__p_ChiSquaredModule, _p_ChiSquaredModuleTo_p_ICloneable, 0, 0}, {&_swigt__p_ConstantBackground, _p_ConstantBackgroundTo_p_ICloneable, 0, 0}, {&_swigt__p_IBackground, _p_IBackgroundTo_p_ICloneable, 0, 0}, {&_swigt__p_IChiSquaredModule, _p_IChiSquaredModuleTo_p_ICloneable, 0, 0}, {&_swigt__p_ISampleNode, _p_ISampleNodeTo_p_ICloneable, 0, 0}, {&_swigt__p_IScanResolution, _p_IScanResolutionTo_p_ICloneable, 0, 0}, {&_swigt__p_ISpecularScan, _p_ISpecularScanTo_p_ICloneable, 0, 0}, {&_swigt__p_PoissonBackground, _p_PoissonBackgroundTo_p_ICloneable, 0, 0}, {&_swigt__p_QzScan, _p_QzScanTo_p_ICloneable, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ICloneable[] = { {&_swigt__p_ICloneable, 0, 0, 0}, {&_swigt__p_AlphaScan, _p_AlphaScanTo_p_ICloneable, 0, 0}, {&_swigt__p_ChiSquaredModule, _p_ChiSquaredModuleTo_p_ICloneable, 0, 0}, {&_swigt__p_ConstantBackground, _p_ConstantBackgroundTo_p_ICloneable, 0, 0}, {&_swigt__p_IBackground, _p_IBackgroundTo_p_ICloneable, 0, 0}, {&_swigt__p_IChiSquaredModule, _p_IChiSquaredModuleTo_p_ICloneable, 0, 0}, {&_swigt__p_ISampleNode, _p_ISampleNodeTo_p_ICloneable, 0, 0}, {&_swigt__p_ISpecularScan, _p_ISpecularScanTo_p_ICloneable, 0, 0}, {&_swigt__p_PoissonBackground, _p_PoissonBackgroundTo_p_ICloneable, 0, 0}, {&_swigt__p_QzScan, _p_QzScanTo_p_ICloneable, 0, 0}, {&_swigt__p_ScanResolution, _p_ScanResolutionTo_p_ICloneable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IDetector[] = { {&_swigt__p_IDetector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IDistribution1D[] = { {&_swigt__p_IDistribution1D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IFootprintFactor[] = { {&_swigt__p_IFootprintFactor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IIntensityFunction[] = { {&_swigt__p_IIntensityFunction, 0, 0, 0}, {&_swigt__p_IntensityFunctionLog, _p_IntensityFunctionLogTo_p_IIntensityFunction, 0, 0}, {&_swigt__p_IntensityFunctionSqrt, _p_IntensityFunctionSqrtTo_p_IIntensityFunction, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_INode[] = { {&_swigt__p_INode, 0, 0, 0}, {&_swigt__p_ConstantBackground, _p_ConstantBackgroundTo_p_INode, 0, 0}, {&_swigt__p_DepthprobeSimulation, _p_DepthprobeSimulationTo_p_INode, 0, 0}, {&_swigt__p_IBackground, _p_IBackgroundTo_p_INode, 0, 0}, {&_swigt__p_ISampleNode, _p_ISampleNodeTo_p_INode, 0, 0}, {&_swigt__p_ISimulation, _p_ISimulationTo_p_INode, 0, 0}, {&_swigt__p_OffspecSimulation, _p_OffspecSimulationTo_p_INode, 0, 0}, {&_swigt__p_PoissonBackground, _p_PoissonBackgroundTo_p_INode, 0, 0}, {&_swigt__p_ScatteringSimulation, _p_ScatteringSimulationTo_p_INode, 0, 0}, {&_swigt__p_SpecularSimulation, _p_SpecularSimulationTo_p_INode, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IRangedDistribution[] = { {&_swigt__p_IRangedDistribution, 0, 0, 0},{0, 0, 0, 0}};
-static swig_cast_info _swigc__p_IScanResolution[] = { {&_swigt__p_IScanResolution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_IShape2D[] = { {&_swigt__p_IShape2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ISimulation[] = { {&_swigt__p_ISimulation, 0, 0, 0}, {&_swigt__p_DepthprobeSimulation, _p_DepthprobeSimulationTo_p_ISimulation, 0, 0}, {&_swigt__p_OffspecSimulation, _p_OffspecSimulationTo_p_ISimulation, 0, 0}, {&_swigt__p_ScatteringSimulation, _p_ScatteringSimulationTo_p_ISimulation, 0, 0}, {&_swigt__p_SpecularSimulation, _p_SpecularSimulationTo_p_ISimulation, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ISpecularScan[] = { {&_swigt__p_ISpecularScan, 0, 0, 0}, {&_swigt__p_AlphaScan, _p_AlphaScanTo_p_ISpecularScan, 0, 0}, {&_swigt__p_QzScan, _p_QzScanTo_p_ISpecularScan, 0, 0},{0, 0, 0, 0}};
@@ -37209,6 +37208,7 @@ static swig_cast_info _swigc__p_PyObserverCallback[] = { {&_swigt__p_PyObserver
static swig_cast_info _swigc__p_QzScan[] = { {&_swigt__p_QzScan, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_RealLimits[] = { {&_swigt__p_RealLimits, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Rotation3DT_double_t[] = { {&_swigt__p_Rotation3DT_double_t, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_ScanResolution[] = { {&_swigt__p_ScanResolution, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_ScatteringSimulation[] = { {&_swigt__p_ScatteringSimulation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SimulationOptions[] = { {&_swigt__p_SimulationOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_SimulationResult[] = { {&_swigt__p_SimulationResult, 0, 0, 0},{0, 0, 0, 0}};
@@ -37285,7 +37285,6 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_INode,
_swigc__p_IRangedDistribution,
_swigc__p_ISampleNode,
- _swigc__p_IScanResolution,
_swigc__p_IShape2D,
_swigc__p_ISimulation,
_swigc__p_ISpecularScan,
@@ -37302,6 +37301,7 @@ static swig_cast_info *swig_cast_initial[] = {
_swigc__p_QzScan,
_swigc__p_RealLimits,
_swigc__p_Rotation3DT_double_t,
+ _swigc__p_ScanResolution,
_swigc__p_ScatteringSimulation,
_swigc__p_SimulationOptions,
_swigc__p_SimulationResult,