From 4714bdd97f552d49ddb8df9f8207a86caaed1a5d Mon Sep 17 00:00:00 2001
From: "Joachim Wuttke (o)" <j.wuttke@fz-juelich.de>
Date: Thu, 4 May 2023 16:05:28 +0200
Subject: [PATCH] new factory fct names EquiDivision, EquiScan, ListScan
---
Base/Axis/FrameUtil.cpp | 2 +-
Base/Axis/MakeScale.cpp | 36 +++---
Base/Axis/MakeScale.h | 26 ++---
Base/Axis/Scale.cpp | 10 +-
Base/Pixel/RectangularPixel.cpp | 2 +-
Device/Coord/CoordSystem1D.cpp | 8 +-
Device/Coord/CoordSystem2D.cpp | 4 +-
Device/Data/ArrayUtil.cpp | 8 +-
Device/Data/DataUtil.cpp | 6 +-
Device/Detector/OffspecDetector.cpp | 6 +-
Device/Detector/RectangularDetector.cpp | 4 +-
Device/Detector/SphericalDetector.cpp | 6 +-
Device/IO/DataFormatUtil.cpp | 14 +--
Device/IO/ReadReflectometry.cpp | 2 +-
Device/IO/ReadWriteNicos.cpp | 4 +-
Device/IO/ReadWriteTiff.cpp | 6 +-
Examples/fit/specular/FitSpecularBasics.py | 2 +-
Examples/varia/Depthprobe1.py | 2 +-
Examples/varia/Resonator.py | 2 +-
GUI/Model/Axis/BasicAxisItem.cpp | 4 +-
GUI/Model/Axis/PointwiseAxisItem.cpp | 4 +-
GUI/Model/Beam/GrazingScanItem.cpp | 11 +-
GUI/Model/Beam/GrazingScanItem.h | 4 +-
GUI/Model/Beam/SourceItems.cpp | 4 +-
GUI/Model/Descriptor/AxisProperty.cpp | 2 +-
GUI/Model/Descriptor/AxisProperty.h | 2 +-
GUI/Model/Device/InstrumentItems.cpp | 2 +-
GUI/View/Device/AxisPropertyForm.h | 2 +-
GUI/View/Instrument/AlphaScanEditor.cpp | 2 +-
GUI/View/Loaders/QREDataLoader.cpp | 5 +-
Sim/Export/PyFmt2.cpp | 4 +-
Sim/Scan/AlphaScan.cpp | 4 +-
Sim/Scan/QzScan.cpp | 6 +-
.../Functional/CoreSpecial/CoreIOPathTest.cpp | 2 +-
Tests/SimFactory/MakeSimulations.cpp | 18 +--
Tests/Unit/Device/ArrayUtilsTest.cpp | 6 +-
Tests/Unit/Device/DepthprobeConverterTest.cpp | 6 +-
Tests/Unit/Device/FixedBinAxisTest.cpp | 50 ++++-----
Tests/Unit/Device/IOReaderWriterTest.cpp | 4 +-
.../Device/IntensityDataFunctionsTest.cpp | 12 +-
Tests/Unit/Device/OffspecConverterTest.cpp | 4 +-
Tests/Unit/Device/PointwiseAxisTest.cpp | 40 +++----
Tests/Unit/Device/PowerfieldTest.cpp | 2 +-
Tests/Unit/Device/RegionOfInterestTest.cpp | 6 +-
Tests/Unit/Device/SphericalDetectorTest.cpp | 8 +-
Tests/Unit/GUI/TestRealModel.cpp | 6 +-
Tests/Unit/GUI/Utils.cpp | 4 +-
Tests/Unit/Sim/CoordSystem1DTest.cpp | 12 +-
Tests/Unit/Sim/FittingTestHelper.h | 4 +-
Tests/Unit/Sim/SpecularScanTest.cpp | 6 +-
Tests/Unit/Sim/SpecularSimulationTest.cpp | 4 +-
auto/Wrap/libBornAgainBase.py | 36 +++---
auto/Wrap/libBornAgainBase_wrap.cpp | 104 +++++++++---------
53 files changed, 269 insertions(+), 271 deletions(-)
diff --git a/Base/Axis/FrameUtil.cpp b/Base/Axis/FrameUtil.cpp
index 07c85e2bad6..42852fdf1f1 100644
--- a/Base/Axis/FrameUtil.cpp
+++ b/Base/Axis/FrameUtil.cpp
@@ -26,7 +26,7 @@ size_t FrameUtil::product_size(const std::vector<const Scale*>& axes)
return result;
}
-// For axis FixedBinAxis("axis", 8, -5.0, 3.0) the coordinate x=-4.5 (center of bin #0) will
+// For axis EquiDivision("axis", 8, -5.0, 3.0) the coordinate x=-4.5 (center of bin #0) will
// be converted into 0.5 (which is a bin center expressed in bin fraction coordinates).
// The coordinate -5.0 (outside of axis definition) will be converted to -0.5
// (center of non-existing bin #-1).
diff --git a/Base/Axis/MakeScale.cpp b/Base/Axis/MakeScale.cpp
index 97fd635a616..f149cd32f0b 100644
--- a/Base/Axis/MakeScale.cpp
+++ b/Base/Axis/MakeScale.cpp
@@ -41,64 +41,64 @@ std::vector<Bin1D> bounds2bins(size_t N, double start, double end)
} // namespace
-Scale DiscreteAxis(const std::string& name, const std::vector<double>& points)
+Scale ListScan(const std::string& name, const std::vector<double>& points)
{
return Scale(name, centers2bins(points));
}
-Scale* newDiscreteAxis(const std::string& name, const std::vector<double>& points)
+Scale* newListScan(const std::string& name, const std::vector<double>& points)
{
return new Scale(name, centers2bins(points));
}
-Scale FixedBinAxis(const std::string& name, size_t nbins, double start, double end)
+Scale EquiDivision(const std::string& name, size_t nbins, double start, double end)
{
return Scale(name, bounds2bins(nbins, start, end));
}
-Scale* newFixedBinAxis(const std::string& name, size_t nbins, double start, double end)
+Scale* newEquiDivision(const std::string& name, size_t nbins, double start, double end)
{
return new Scale(name, bounds2bins(nbins, start, end));
}
-std::shared_ptr<Scale> sharedFixedBinAxis(const std::string& name, size_t nbins, double start,
+std::shared_ptr<Scale> sharedEquiDivision(const std::string& name, size_t nbins, double start,
double end)
{
- return std::shared_ptr<Scale>(newFixedBinAxis(name, nbins, start, end));
+ return std::shared_ptr<Scale>(newEquiDivision(name, nbins, start, end));
}
-std::unique_ptr<Scale> uniqueFixedBinAxis(const std::string& name, size_t nbins, double start,
+std::unique_ptr<Scale> uniqueEquiDivision(const std::string& name, size_t nbins, double start,
double end)
{
- return std::unique_ptr<Scale>(newFixedBinAxis(name, nbins, start, end));
+ return std::unique_ptr<Scale>(newEquiDivision(name, nbins, start, end));
}
-Scale FixedScanAxis(const std::string& name, size_t nbins, double scan_start, double scan_end)
+Scale EquiScan(const std::string& name, size_t nbins, double scan_start, double scan_end)
{
if (nbins < 2)
throw std::runtime_error("Cannot create scan axis with less than two points");
const double delta = (scan_end - scan_start) / (nbins - 1);
- return FixedBinAxis(name, nbins, scan_start - delta / 2, scan_end + delta / 2);
+ return EquiDivision(name, nbins, scan_start - delta / 2, scan_end + delta / 2);
}
-Scale* newFixedScanAxis(const std::string& name, size_t nbins, double scan_start, double scan_end)
+Scale* newEquiScan(const std::string& name, size_t nbins, double scan_start, double scan_end)
{
if (nbins < 2)
throw std::runtime_error("Cannot create scan axis with less than two points");
const double delta = (scan_end - scan_start) / (nbins - 1);
- return newFixedBinAxis(name, nbins, scan_start - delta / 2, scan_end + delta / 2);
+ return newEquiDivision(name, nbins, scan_start - delta / 2, scan_end + delta / 2);
}
-std::shared_ptr<Scale> sharedFixedScanAxis(const std::string& name, size_t nbins, double scan_start,
- double scan_end)
+std::shared_ptr<Scale> sharedEquiScan(const std::string& name, size_t nbins, double scan_start,
+ double scan_end)
{
- return std::shared_ptr<Scale>(newFixedBinAxis(name, nbins, scan_start, scan_end));
+ return std::shared_ptr<Scale>(newEquiDivision(name, nbins, scan_start, scan_end));
}
-std::unique_ptr<Scale> uniqueFixedScanAxis(const std::string& name, size_t nbins, double scan_start,
- double scan_end)
+std::unique_ptr<Scale> uniqueEquiScan(const std::string& name, size_t nbins, double scan_start,
+ double scan_end)
{
- return std::unique_ptr<Scale>(newFixedBinAxis(name, nbins, scan_start, scan_end));
+ return std::unique_ptr<Scale>(newEquiDivision(name, nbins, scan_start, scan_end));
}
diff --git a/Base/Axis/MakeScale.h b/Base/Axis/MakeScale.h
index 1202ba9e618..ae5eeb753e9 100644
--- a/Base/Axis/MakeScale.h
+++ b/Base/Axis/MakeScale.h
@@ -20,25 +20,25 @@
class Scale;
-Scale DiscreteAxis(const std::string& name, const std::vector<double>& points);
-Scale* newDiscreteAxis(const std::string& name, const std::vector<double>& points);
+Scale ListScan(const std::string& name, const std::vector<double>& points);
+Scale* newListScan(const std::string& name, const std::vector<double>& points);
//! Returns axis with fixed bin size.
-Scale FixedBinAxis(const std::string& name, size_t nbins, double start, double end);
-Scale* newFixedBinAxis(const std::string& name, size_t nbins, double start, double end);
-std::shared_ptr<Scale> sharedFixedBinAxis(const std::string& name, size_t nbins, double start,
+Scale EquiDivision(const std::string& name, size_t nbins, double start, double end);
+Scale* newEquiDivision(const std::string& name, size_t nbins, double start, double end);
+std::shared_ptr<Scale> sharedEquiDivision(const std::string& name, size_t nbins, double start,
double end);
-std::unique_ptr<Scale> uniqueFixedBinAxis(const std::string& name, size_t nbins, double start,
+std::unique_ptr<Scale> uniqueEquiDivision(const std::string& name, size_t nbins, double start,
double end);
#ifndef SWIG
-//! Returns a FixedBinAxis determined by first and last point in scan.
-Scale FixedScanAxis(const std::string& name, size_t nbins, double scan_start, double scan_end);
-Scale* newFixedScanAxis(const std::string& name, size_t nbins, double scan_start, double scan_end);
-std::shared_ptr<Scale> sharedFixedScanAxis(const std::string& name, size_t nbins, double scan_start,
- double scan_end);
-std::unique_ptr<Scale> uniqueFixedScanAxis(const std::string& name, size_t nbins, double scan_start,
- double scan_end);
+//! Returns a EquiDivision determined by first and last point in scan.
+Scale EquiScan(const std::string& name, size_t nbins, double scan_start, double scan_end);
+Scale* newEquiScan(const std::string& name, size_t nbins, double scan_start, double scan_end);
+std::shared_ptr<Scale> sharedEquiScan(const std::string& name, size_t nbins, double scan_start,
+ double scan_end);
+std::unique_ptr<Scale> uniqueEquiScan(const std::string& name, size_t nbins, double scan_start,
+ double scan_end);
#endif // SWIG
diff --git a/Base/Axis/Scale.cpp b/Base/Axis/Scale.cpp
index e8bade0dadf..71f9bbebd54 100644
--- a/Base/Axis/Scale.cpp
+++ b/Base/Axis/Scale.cpp
@@ -93,7 +93,7 @@ bool Scale::isEquidistantCoverage() const
const size_t N = size();
for (size_t i = 0; i < N; ++i) {
const Bin1D& b = bin(i);
- // exactly replicate the computation of bin bounds in the FixedBinAxis factory function
+ // exactly replicate the computation of bin bounds in the EquiDivision factory function
if (b.lowerBound() != (N - i) * (min() / N) + i * (max() / N)
|| b.upperBound() != (N - i - 1) * (min() / N) + (i + 1) * (max() / N))
return false;
@@ -133,16 +133,16 @@ std::ostream& operator<<(std::ostream& ostr, const Scale& ax)
size_t N = ax.size();
ASSERT(N > 0);
- // Special output for FixedBinAxis:
+ // Special output for EquiDivision:
if (ax.isEquidistantCoverage()) {
- ostr << "FixedBinAxis(\"" << ax.axisName() << "\", " << ax.size() << ", "
+ ostr << "EquiDivision(\"" << ax.axisName() << "\", " << ax.size() << ", "
<< std::setprecision(17) << ax.min() << ", " << ax.max() << ")";
return ostr;
}
- // Special output for DiscreteAxis
+ // Special output for ListScan
if (ax.isDiscrete()) {
- ostr << "DiscreteAxis(\"" << ax.axisName() << "\", "
+ ostr << "ListScan(\"" << ax.axisName() << "\", "
<< ", [" << std::setprecision(17);
for (double v : ax.binCenters())
ostr << v << ",";
diff --git a/Base/Pixel/RectangularPixel.cpp b/Base/Pixel/RectangularPixel.cpp
index 76ecb4b619c..339e0157655 100644
--- a/Base/Pixel/RectangularPixel.cpp
+++ b/Base/Pixel/RectangularPixel.cpp
@@ -83,5 +83,5 @@ Scale* RectangularPixel::createAxis(size_t n) const
const double alpha_f_min = (pi / 2) - R3Util::theta(k00);
const double alpha_f_max = (pi / 2) - R3Util::theta(k01);
- return newFixedBinAxis("alpha_f", alpha_f_min, alpha_f_max, n);
+ return newEquiDivision("alpha_f", alpha_f_min, alpha_f_max, n);
}
diff --git a/Device/Coord/CoordSystem1D.cpp b/Device/Coord/CoordSystem1D.cpp
index 184d6584c71..2f7a69fa280 100644
--- a/Device/Coord/CoordSystem1D.cpp
+++ b/Device/Coord/CoordSystem1D.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Device/Coord/CoordSystem1D.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Base/Util/Assert.h"
#include <cmath>
@@ -56,7 +56,7 @@ Scale* createAxisFrom(const Scale& axis, Coords coords, const std::string& name,
ret.reserve(axis.size());
for (const double value : axis.binCenters())
ret.emplace_back(backTransform(value, coords, wavelength));
- return newDiscreteAxis(name, ret);
+ return newListScan(name, ret);
}
} // namespace
@@ -96,14 +96,14 @@ Scale* CoordSystem1D::convertedAxis(size_t i_axis, Coords units) const
ASSERT(i_axis == 0);
units = substituteDefaultUnits(units);
if (units == Coords::NBINS)
- return newFixedBinAxis(nameOfAxis(0, units), m_axes[0]->size(), calculateMin(0, units),
+ return newEquiDivision(nameOfAxis(0, units), m_axes[0]->size(), calculateMin(0, units),
calculateMax(0, units));
std::function<double(double)> translator = getTraslatorTo(units);
auto coords = m_axes[0]->binCenters();
for (size_t i = 0, size = coords.size(); i < size; ++i)
coords[i] = translator(coords[i]);
- return newDiscreteAxis(nameOfAxis(0, units), coords);
+ return newListScan(nameOfAxis(0, units), coords);
}
diff --git a/Device/Coord/CoordSystem2D.cpp b/Device/Coord/CoordSystem2D.cpp
index 80133a7780d..cc2f6971e56 100644
--- a/Device/Coord/CoordSystem2D.cpp
+++ b/Device/Coord/CoordSystem2D.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Device/Coord/CoordSystem2D.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Base/Pixel/RectangularPixel.h"
#include "Base/Util/Assert.h"
@@ -83,7 +83,7 @@ Scale* CoordSystem2D::convertedAxis(size_t i_axis, Coords units) const
const double max = calculateMax(i_axis, units);
const auto& axis_name = nameOfAxis(i_axis, units);
const auto axis_size = m_axes[i_axis]->size();
- return newFixedBinAxis(axis_name, axis_size, min, max);
+ return newEquiDivision(axis_name, axis_size, min, max);
}
// ************************************************************************************************
diff --git a/Device/Data/ArrayUtil.cpp b/Device/Data/ArrayUtil.cpp
index 610957bbd56..dd496f1198a 100644
--- a/Device/Data/ArrayUtil.cpp
+++ b/Device/Data/ArrayUtil.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Device/Data/ArrayUtil.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Util/Assert.h"
#include "Device/Data/Datafield.h"
#include <stdexcept>
@@ -33,7 +33,7 @@ std::pair<size_t, size_t> DataUtil::Array::getShape(const std::vector<std::vecto
std::unique_ptr<Datafield> DataUtil::Array::createPField1D(const std::vector<double>& vec)
{
const size_t N = vec.size();
- std::vector<const Scale*> axes{newFixedBinAxis("axis0", N, 0.0, (double)N)};
+ std::vector<const Scale*> axes{newEquiDivision("axis0", N, 0.0, (double)N)};
return std::make_unique<Datafield>(std::move(axes), vec);
}
@@ -47,8 +47,8 @@ DataUtil::Array::createPField2D(const std::vector<std::vector<double>>& vec)
ASSERT(nrows > 0);
ASSERT(ncols > 0);
- std::vector<const Scale*> axes{newFixedBinAxis("axis0", ncols, 0.0, (double)ncols),
- newFixedBinAxis("axis1", nrows, 0.0, (double)nrows)};
+ std::vector<const Scale*> axes{newEquiDivision("axis0", ncols, 0.0, (double)ncols),
+ newEquiDivision("axis1", nrows, 0.0, (double)nrows)};
std::vector<double> out(nrows * ncols);
for (size_t row = 0; row < nrows; ++row) {
diff --git a/Device/Data/DataUtil.cpp b/Device/Data/DataUtil.cpp
index d98c6d33536..2189a780e4f 100644
--- a/Device/Data/DataUtil.cpp
+++ b/Device/Data/DataUtil.cpp
@@ -14,8 +14,8 @@
#include "Device/Data/DataUtil.h"
#include "Base/Axis/Frame.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Math/FourierTransform.h"
#include "Base/Util/Assert.h"
#include "Device/Data/ArrayUtil.h"
@@ -106,8 +106,8 @@ DataUtil::Data::vecvecToDatafield(const std::vector<std::vector<double>>& array_
size_t nrows = array_2d.size();
size_t ncols = array_2d[0].size();
- std::vector<const Scale*> axes{newFixedBinAxis("x", nrows, 0.0, double(nrows)),
- newFixedBinAxis("y", ncols, 0.0, double(ncols))};
+ std::vector<const Scale*> axes{newEquiDivision("x", nrows, 0.0, double(nrows)),
+ newEquiDivision("y", ncols, 0.0, double(ncols))};
std::vector<double> out;
out.reserve(nrows * ncols);
for (size_t row = 0; row < nrows; row++) {
diff --git a/Device/Detector/OffspecDetector.cpp b/Device/Detector/OffspecDetector.cpp
index 8ee0725bb05..9e338f28895 100644
--- a/Device/Detector/OffspecDetector.cpp
+++ b/Device/Detector/OffspecDetector.cpp
@@ -13,15 +13,15 @@
// ************************************************************************************************
#include "Device/Detector/OffspecDetector.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Pixel/SphericalPixel.h"
#include "Base/Util/Assert.h"
OffspecDetector::OffspecDetector(size_t n_phi, double phi_min, double phi_max, size_t n_alpha,
double alpha_min, double alpha_max)
- : m_axes{sharedFixedBinAxis("phi_f", n_phi, phi_min, phi_max),
- sharedFixedBinAxis("alpha_f", n_alpha, alpha_min, alpha_max)}
+ : m_axes{sharedEquiDivision("phi_f", n_phi, phi_min, phi_max),
+ sharedEquiDivision("alpha_f", n_alpha, alpha_min, alpha_max)}
{
}
diff --git a/Device/Detector/RectangularDetector.cpp b/Device/Detector/RectangularDetector.cpp
index 6a3a98fa51b..698f8aac93b 100644
--- a/Device/Detector/RectangularDetector.cpp
+++ b/Device/Detector/RectangularDetector.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Device/Detector/RectangularDetector.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Base/Pixel/RectangularPixel.h"
#include "Base/Util/Assert.h"
@@ -39,7 +39,7 @@ RectangularDetector::RectangularDetector(std::array<std::shared_ptr<Scale>, 2> a
RectangularDetector::RectangularDetector(size_t nxbins, double width, size_t nybins, double height)
: RectangularDetector(std::array<std::shared_ptr<Scale>, 2>{
- sharedFixedBinAxis("u", nxbins, 0.0, width), sharedFixedBinAxis("v", nybins, 0.0, height)})
+ sharedEquiDivision("u", nxbins, 0.0, width), sharedEquiDivision("v", nybins, 0.0, height)})
{
}
diff --git a/Device/Detector/SphericalDetector.cpp b/Device/Detector/SphericalDetector.cpp
index 0ff0513ac79..183f4aa5379 100644
--- a/Device/Detector/SphericalDetector.cpp
+++ b/Device/Detector/SphericalDetector.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Device/Detector/SphericalDetector.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Base/Pixel/SphericalPixel.h"
#include "Base/Util/Assert.h"
@@ -33,8 +33,8 @@ SphericalDetector::SphericalDetector(std::array<std::shared_ptr<Scale>, 2> axes)
SphericalDetector::SphericalDetector(size_t n_phi, double phi_min, double phi_max, size_t n_alpha,
double alpha_min, double alpha_max)
: SphericalDetector(std::array<std::shared_ptr<Scale>, 2>{
- sharedFixedBinAxis("phi_f", n_phi, phi_min, phi_max),
- sharedFixedBinAxis("alpha_f", n_alpha, alpha_min, alpha_max)})
+ sharedEquiDivision("phi_f", n_phi, phi_min, phi_max),
+ sharedEquiDivision("alpha_f", n_alpha, alpha_min, alpha_max)})
{
}
diff --git a/Device/IO/DataFormatUtil.cpp b/Device/IO/DataFormatUtil.cpp
index bdb3a9c9cb6..61e1368864f 100644
--- a/Device/IO/DataFormatUtil.cpp
+++ b/Device/IO/DataFormatUtil.cpp
@@ -94,24 +94,24 @@ Scale* DataUtil::Format::createAxis(std::istream& input_stream)
if (!(iss >> type))
throw std::runtime_error("Cannot read axis type from input");
- if (type == "FixedBinAxis") {
+ if (type == "EquiDivision" || type == "FixedBinAxis" /* for compatibility with pre-21 */) {
std::string name;
size_t nbins;
if (!(iss >> name >> nbins))
- throw std::runtime_error("Reading FixedBinAxis: cannot read name or size");
+ throw std::runtime_error("Reading EquiDivision: cannot read name or size");
std::vector<double> boundaries;
DataUtil::Format::readLineOfDoubles(boundaries, iss);
if (boundaries.size() != 2)
- throw std::runtime_error("Reading FixedBinAxis: cannot read start or stop");
- return newFixedBinAxis(name, nbins, boundaries[0], boundaries[1]);
+ throw std::runtime_error("Reading EquiDivision: cannot read start or stop");
+ return newEquiDivision(name, nbins, boundaries[0], boundaries[1]);
- } else if (type == "DiscreteAxis") {
+ } else if (type == "ListScan" || type == "DiscreteAxis" /* for compatibility with pre-21 */) {
std::string name;
if (!(iss >> name))
- throw std::runtime_error("Reading DiscreteAxis: cannot read name");
+ throw std::runtime_error("Reading ListScan: cannot read name");
std::vector<double> coordinates;
DataUtil::Format::readLineOfDoubles(coordinates, iss);
- return newDiscreteAxis(name, coordinates);
+ return newListScan(name, coordinates);
} else
throw std::runtime_error("Unknown axis type '" + type + "'");
diff --git a/Device/IO/ReadReflectometry.cpp b/Device/IO/ReadReflectometry.cpp
index 3cae554ca0f..f1056314822 100644
--- a/Device/IO/ReadReflectometry.cpp
+++ b/Device/IO/ReadReflectometry.cpp
@@ -93,5 +93,5 @@ Datafield* ReadReflectometry::readDatafield(std::istream& inStream)
continue;
eVec.push_back(it->second);
}
- return new Datafield{{newDiscreteAxis("qVector", qVec)}, rVec, eVec};
+ return new Datafield{{newListScan("qVector", qVec)}, rVec, eVec};
}
diff --git a/Device/IO/ReadWriteNicos.cpp b/Device/IO/ReadWriteNicos.cpp
index cbbbcc47d5a..213d4373dbf 100644
--- a/Device/IO/ReadWriteNicos.cpp
+++ b/Device/IO/ReadWriteNicos.cpp
@@ -101,8 +101,8 @@ Datafield* IO::readNicosData(std::istream& input_stream)
if (height == 0)
throw std::runtime_error("Could not find 'DataSizeY' value");
- std::vector<const Scale*> axes{newFixedBinAxis("x", width, 0.0, width),
- newFixedBinAxis("y", height, 0.0, height)};
+ std::vector<const Scale*> axes{newEquiDivision("x", width, 0.0, width),
+ newEquiDivision("y", height, 0.0, height)};
auto result = std::make_unique<Datafield>(std::move(axes));
// -- read data
diff --git a/Device/IO/ReadWriteTiff.cpp b/Device/IO/ReadWriteTiff.cpp
index 63656ba350c..d23732a91a6 100644
--- a/Device/IO/ReadWriteTiff.cpp
+++ b/Device/IO/ReadWriteTiff.cpp
@@ -16,8 +16,8 @@
#include "Device/IO/ReadWriteTiff.h"
#include "Base/Axis/Frame.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Util/Assert.h"
#include "Base/Util/SysUtil.h"
#include "Device/Data/Datafield.h"
@@ -265,8 +265,8 @@ void ReadWriteTiff::close()
void ReadWriteTiff::create_output_data()
{
ASSERT(m_tiff);
- m_data.reset(new Datafield({newFixedBinAxis("x", m_width, 0.0, double(m_width)),
- newFixedBinAxis("y", m_height, 0.0, double(m_height))}));
+ m_data.reset(new Datafield({newEquiDivision("x", m_width, 0.0, double(m_width)),
+ newEquiDivision("y", m_height, 0.0, double(m_height))}));
}
#endif // BA_TIFF_SUPPORT
diff --git a/Examples/fit/specular/FitSpecularBasics.py b/Examples/fit/specular/FitSpecularBasics.py
index e354b72d479..d0864ad4dec 100755
--- a/Examples/fit/specular/FitSpecularBasics.py
+++ b/Examples/fit/specular/FitSpecularBasics.py
@@ -92,7 +92,7 @@ def get_simulation(params):
Create and return specular simulation with its instrument defined
"""
wavelength = 1.54*ba.angstrom # beam wavelength
- scan = ba.AlphaScan(ba.DiscreteAxis("", get_real_data_axis()))
+ scan = ba.AlphaScan(ba.ListScan("", get_real_data_axis()))
scan.setWavelength(wavelength)
sample = get_sample(params)
diff --git a/Examples/varia/Depthprobe1.py b/Examples/varia/Depthprobe1.py
index af325d05308..84c6c8c0681 100755
--- a/Examples/varia/Depthprobe1.py
+++ b/Examples/varia/Depthprobe1.py
@@ -28,7 +28,7 @@ def get_simulation(sample, flags):
scan = ba.AlphaScan(n, 0*deg, 1*deg)
scan.setWavelength(0.3*nm)
- z_axis = ba.FixedBinAxis("z", n, -130*nm, 30*nm)
+ z_axis = ba.EquiDivision("z", n, -130*nm, 30*nm)
simulation = ba.DepthprobeSimulation(scan, sample, z_axis, flags)
return simulation
diff --git a/Examples/varia/Resonator.py b/Examples/varia/Resonator.py
index 11ecc60c07a..a6b167dd80d 100755
--- a/Examples/varia/Resonator.py
+++ b/Examples/varia/Resonator.py
@@ -73,7 +73,7 @@ def get_simulation(sample):
footprint = ba.FootprintSquare(0.01)
scan.setFootprint(footprint)
- z_axis = ba.FixedBinAxis("z", nz, z_min, z_max)
+ z_axis = ba.EquiDivision("z", nz, z_min, z_max)
simulation = ba.DepthprobeSimulation(scan, sample, z_axis)
alpha_distr = ba.DistributionGaussian(0, d_ang, 25, 3.)
diff --git a/GUI/Model/Axis/BasicAxisItem.cpp b/GUI/Model/Axis/BasicAxisItem.cpp
index 6dd43aa461c..57b12a57cb6 100644
--- a/GUI/Model/Axis/BasicAxisItem.cpp
+++ b/GUI/Model/Axis/BasicAxisItem.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "GUI/Model/Axis/BasicAxisItem.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "GUI/Support/XML/UtilXML.h"
namespace {
@@ -90,7 +90,7 @@ void BasicAxisItem::setTitle(const QString& title)
std::unique_ptr<Scale> BasicAxisItem::itemToRegularAxis(double scale) const
{
- return uniqueFixedBinAxis(title().toStdString(), binCount(), min() * scale, max() * scale);
+ return uniqueEquiDivision(title().toStdString(), binCount(), min() * scale, max() * scale);
}
std::unique_ptr<Scale> BasicAxisItem::itemToAxis(double scale,
diff --git a/GUI/Model/Axis/PointwiseAxisItem.cpp b/GUI/Model/Axis/PointwiseAxisItem.cpp
index 72470ef8e5d..f52622670f9 100644
--- a/GUI/Model/Axis/PointwiseAxisItem.cpp
+++ b/GUI/Model/Axis/PointwiseAxisItem.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "GUI/Model/Axis/PointwiseAxisItem.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Device/Coord/ICoordSystem.h"
#include "Device/Data/Datafield.h"
#include "Device/IO/ReadWriteINT.h"
@@ -66,7 +66,7 @@ std::unique_ptr<Scale> PointwiseAxisItem::itemToAxis(double scale,
for (double& e : centers)
e *= scale;
- return std::unique_ptr<Scale>(newDiscreteAxis(converted_axis.axisName(), std::move(centers)));
+ return std::unique_ptr<Scale>(newListScan(converted_axis.axisName(), std::move(centers)));
}
QByteArray PointwiseAxisItem::serializeBinaryData() const
diff --git a/GUI/Model/Beam/GrazingScanItem.cpp b/GUI/Model/Beam/GrazingScanItem.cpp
index 81958663d26..4a4c723f721 100644
--- a/GUI/Model/Beam/GrazingScanItem.cpp
+++ b/GUI/Model/Beam/GrazingScanItem.cpp
@@ -25,7 +25,7 @@ namespace {
namespace Tag {
const QString UniformAxis("UniformAxis");
-const QString DiscreteAxis("DiscreteAxis");
+const QString ListScan("ListScan");
const QString BeamInclinationDistribution("BeamInclinationDistribution");
const QString IsUniformAxis("IsUniformAxis");
const QString BaseData("BaseData");
@@ -98,7 +98,7 @@ void GrazingScanItem::writeTo(QXmlStreamWriter* w) const
// pointwise axis
if (m_pointwiseAlphaAxis) {
- w->writeStartElement(Tag::DiscreteAxis);
+ w->writeStartElement(Tag::ListScan);
m_pointwiseAlphaAxis->writeTo(w);
w->writeEndElement();
}
@@ -131,7 +131,7 @@ void GrazingScanItem::readFrom(QXmlStreamReader* r)
XML::gotoEndElementOfTag(r, tag);
// pointwise axis
- } else if (tag == Tag::DiscreteAxis) {
+ } else if (tag == Tag::ListScan) {
m_pointwiseAlphaAxis = std::make_unique<PointwiseAxisItem>();
setAxisPresentationDefaults(m_pointwiseAlphaAxis.get());
m_pointwiseAlphaAxis->readFrom(r);
@@ -177,7 +177,7 @@ void GrazingScanItem::selectUniformAxis()
m_currentAxisIsUniformAxis = true;
}
-void GrazingScanItem::selectDiscreteAxis()
+void GrazingScanItem::selectListScan()
{
ASSERT(pointwiseAlphaAxisDefined());
m_currentAxisIsUniformAxis = false;
@@ -188,8 +188,7 @@ void GrazingScanItem::initUniformAxis(const Scale& axis)
m_uniformAlphaAxis->setBinCount(static_cast<int>(axis.size()));
}
-void GrazingScanItem::initDiscreteAxis(const Scale& axis, QString units,
- const ICoordSystem& converter)
+void GrazingScanItem::initListScan(const Scale& axis, QString units, const ICoordSystem& converter)
{
if (!m_pointwiseAlphaAxis) {
m_pointwiseAlphaAxis.reset(new PointwiseAxisItem());
diff --git a/GUI/Model/Beam/GrazingScanItem.h b/GUI/Model/Beam/GrazingScanItem.h
index aea5a228fff..c8302b0cfc4 100644
--- a/GUI/Model/Beam/GrazingScanItem.h
+++ b/GUI/Model/Beam/GrazingScanItem.h
@@ -56,10 +56,10 @@ public:
bool uniformAlphaAxisSelected() const;
void selectUniformAxis();
- void selectDiscreteAxis();
+ void selectListScan();
void initUniformAxis(const Scale& axis);
- void initDiscreteAxis(const Scale& axis, QString units, const ICoordSystem& converter);
+ void initListScan(const Scale& axis, QString units, const ICoordSystem& converter);
private:
std::unique_ptr<BasicAxisItem> m_uniformAlphaAxis;
diff --git a/GUI/Model/Beam/SourceItems.cpp b/GUI/Model/Beam/SourceItems.cpp
index 7f70b3384b1..9d8b25abb1a 100644
--- a/GUI/Model/Beam/SourceItems.cpp
+++ b/GUI/Model/Beam/SourceItems.cpp
@@ -353,8 +353,8 @@ void ScanItem::updateToData(const Scale& axis, QString units, const ICoordSystem
grazingScanItem()->initUniformAxis(axis);
grazingScanItem()->selectUniformAxis();
} else {
- grazingScanItem()->initDiscreteAxis(axis, units, converter);
- grazingScanItem()->selectDiscreteAxis();
+ grazingScanItem()->initListScan(axis, units, converter);
+ grazingScanItem()->selectListScan();
}
}
diff --git a/GUI/Model/Descriptor/AxisProperty.cpp b/GUI/Model/Descriptor/AxisProperty.cpp
index 066a71f0ed4..b9a3c831979 100644
--- a/GUI/Model/Descriptor/AxisProperty.cpp
+++ b/GUI/Model/Descriptor/AxisProperty.cpp
@@ -47,7 +47,7 @@ void AxisProperty::initMax(const QString& label, const QString& tooltip, double
std::unique_ptr<Scale> AxisProperty::createAxis(double scaleFactor) const
{
- return uniqueFixedBinAxis(std::string(), m_nbins, m_min * scaleFactor, m_max * scaleFactor);
+ return uniqueEquiDivision(std::string(), m_nbins, m_min * scaleFactor, m_max * scaleFactor);
}
void AxisProperty::writeTo(QXmlStreamWriter* w) const
diff --git a/GUI/Model/Descriptor/AxisProperty.h b/GUI/Model/Descriptor/AxisProperty.h
index 488c411b458..5e42c15df47 100644
--- a/GUI/Model/Descriptor/AxisProperty.h
+++ b/GUI/Model/Descriptor/AxisProperty.h
@@ -19,7 +19,7 @@
#include "GUI/Model/Descriptor/DoubleProperty.h"
#include <memory>
-//! Holds values which can be used to describe a FixedBinAxis.
+//! Holds values which can be used to describe a EquiDivision.
//!
//! Use this as a member in your class to
//! * reduce dependency to axis items and axis classes
diff --git a/GUI/Model/Device/InstrumentItems.cpp b/GUI/Model/Device/InstrumentItems.cpp
index efbbc27225f..0f425061b58 100644
--- a/GUI/Model/Device/InstrumentItems.cpp
+++ b/GUI/Model/Device/InstrumentItems.cpp
@@ -426,7 +426,7 @@ std::unique_ptr<const ICoordSystem> SpecularInstrumentItem::createCoordSystem()
*pointwise_axis->axis(), native_units);
}
- Scale axis = FixedBinAxis(axis_item->title().toStdString(), axis_item->binCount(),
+ Scale axis = EquiDivision(axis_item->title().toStdString(), axis_item->binCount(),
axis_item->min(), axis_item->max());
return std::make_unique<AngularReflectometryCoords>(scanItem()->wavelength(), axis,
diff --git a/GUI/View/Device/AxisPropertyForm.h b/GUI/View/Device/AxisPropertyForm.h
index fae10293be5..dc0f5347028 100644
--- a/GUI/View/Device/AxisPropertyForm.h
+++ b/GUI/View/Device/AxisPropertyForm.h
@@ -23,7 +23,7 @@ class DoubleSpinBox;
//! Use this to edit an AxisProperty.
//!
-//! An AxisProperty handles values for a FixedBinAxis. The values will be already written into the
+//! An AxisProperty handles values for a EquiDivision. The values will be already written into the
//! data element. For each change of values, a signal will be emitted. Use this e.g. to update
//! dependent values or to set the document to modified.
class AxisPropertyForm : public QGroupBox {
diff --git a/GUI/View/Instrument/AlphaScanEditor.cpp b/GUI/View/Instrument/AlphaScanEditor.cpp
index 8ef6eb35347..c84b93d591a 100644
--- a/GUI/View/Instrument/AlphaScanEditor.cpp
+++ b/GUI/View/Instrument/AlphaScanEditor.cpp
@@ -87,7 +87,7 @@ void AlphaScanEditor::onAxisTypeSelected(int index)
m_item->selectUniformAxis();
emit dataChanged();
} else if (index == 1 && !m_item->pointwiseAlphaAxisSelected()) {
- m_item->selectDiscreteAxis();
+ m_item->selectListScan();
emit dataChanged();
}
diff --git a/GUI/View/Loaders/QREDataLoader.cpp b/GUI/View/Loaders/QREDataLoader.cpp
index 5adae3a921d..a26d74fce50 100644
--- a/GUI/View/Loaders/QREDataLoader.cpp
+++ b/GUI/View/Loaders/QREDataLoader.cpp
@@ -253,7 +253,7 @@ void QREDataLoader::processContents()
m_importResult.importSettings = m_importSettings;
- // -- make a few checks (mainly for fulfilling DiscreteAxis::sanityCheck())
+ // -- make a few checks (mainly for fulfilling ListScan::sanityCheck())
if (m_importResult.validCalculatedLines < 2)
m_importResult.error = "At least two full rows must exist";
@@ -558,8 +558,7 @@ void QREDataLoader::datafieldFromParsingResult(RealItem* item) const
for (auto lineNr : lineNumbers)
eVec.push_back(m_importResult.eValues[lineNr]);
- auto* oData =
- new Datafield({newDiscreteAxis("qVector", qVec)}, rVec, eVec); // eVec can be empty
+ auto* oData = new Datafield({newListScan("qVector", qVec)}, rVec, eVec); // eVec can be empty
// -- Replacement of item->setImportData(std::move(data));
item->initNativeData();
diff --git a/Sim/Export/PyFmt2.cpp b/Sim/Export/PyFmt2.cpp
index 536f7ac27b3..37cf4382460 100644
--- a/Sim/Export/PyFmt2.cpp
+++ b/Sim/Export/PyFmt2.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Sim/Export/PyFmt2.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Base/Py/PyFmt.h"
#include "Base/Util/Algorithms.h"
@@ -94,7 +94,7 @@ std::string Py::Fmt2::printAxis(const Scale* a, const std::string& unit)
{
std::ostringstream result;
if (a->isEquidistantCoverage())
- result << "ba.FixedBinAxis(" << Py::Fmt::printString(a->axisName()) << ", " << a->size()
+ result << "ba.EquiDivision(" << Py::Fmt::printString(a->axisName()) << ", " << a->size()
<< ", " << Py::Fmt::printValue(a->min(), unit) << ", "
<< Py::Fmt::printValue(a->max(), unit) << ")";
else if (a->isDiscrete()) {
diff --git a/Sim/Scan/AlphaScan.cpp b/Sim/Scan/AlphaScan.cpp
index fc63c6bbb6b..a9752043290 100644
--- a/Sim/Scan/AlphaScan.cpp
+++ b/Sim/Scan/AlphaScan.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Sim/Scan/AlphaScan.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Device/Beam/IFootprintFactor.h"
#include "Device/Coord/CoordSystem1D.h"
#include "Device/Pol/PolFilter.h"
@@ -50,7 +50,7 @@ AlphaScan::AlphaScan(const Scale& alpha_axis)
}
AlphaScan::AlphaScan(int nbins, double alpha_i_min, double alpha_i_max)
- : AlphaScan(FixedScanAxis("alpha_i", nbins, alpha_i_min, alpha_i_max))
+ : AlphaScan(EquiScan("alpha_i", nbins, alpha_i_min, alpha_i_max))
{
}
diff --git a/Sim/Scan/QzScan.cpp b/Sim/Scan/QzScan.cpp
index 66949bdc073..ee9d5956b68 100644
--- a/Sim/Scan/QzScan.cpp
+++ b/Sim/Scan/QzScan.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Sim/Scan/QzScan.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Util/Assert.h"
#include "Device/Coord/CoordSystem1D.h"
#include "Device/Pol/PolFilter.h"
@@ -37,7 +37,7 @@ QzScan::QzScan(Scale* qs_nm)
}
QzScan::QzScan(std::vector<double> qs_nm)
- : QzScan(newDiscreteAxis("qs", std::move(qs_nm)))
+ : QzScan(newListScan("qs", std::move(qs_nm)))
{
}
@@ -47,7 +47,7 @@ QzScan::QzScan(const Scale& qs_nm)
}
QzScan::QzScan(int nbins, double qz_min, double qz_max)
- : QzScan(newFixedScanAxis("qs", nbins, qz_min, qz_max))
+ : QzScan(newEquiScan("qs", nbins, qz_min, qz_max))
{
}
diff --git a/Tests/Functional/CoreSpecial/CoreIOPathTest.cpp b/Tests/Functional/CoreSpecial/CoreIOPathTest.cpp
index b629033f4ef..c31b57b2717 100644
--- a/Tests/Functional/CoreSpecial/CoreIOPathTest.cpp
+++ b/Tests/Functional/CoreSpecial/CoreIOPathTest.cpp
@@ -27,7 +27,7 @@ namespace {
std::unique_ptr<Datafield> createTestData()
{
- std::unique_ptr<Datafield> result(new Datafield{{newFixedBinAxis("x", 10, 0.0, 10.0)}});
+ std::unique_ptr<Datafield> result(new Datafield{{newEquiDivision("x", 10, 0.0, 10.0)}});
for (size_t i = 0; i < result->size(); ++i)
(*result)[i] = static_cast<double>(i);
return result;
diff --git a/Tests/SimFactory/MakeSimulations.cpp b/Tests/SimFactory/MakeSimulations.cpp
index 98ae91f2ee2..688399bba55 100644
--- a/Tests/SimFactory/MakeSimulations.cpp
+++ b/Tests/SimFactory/MakeSimulations.cpp
@@ -13,8 +13,8 @@
// ************************************************************************************************
#include "Tests/SimFactory/MakeSimulations.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Device/Beam/Beam.h"
#include "Device/Beam/FootprintGauss.h"
@@ -331,14 +331,14 @@ IBeamScan* test::makeSimulation::BasicSpecularScan(bool vsQ)
const double max_angle = 5 * deg;
if (vsQ) {
- Scale angle_axis = FixedBinAxis("axis", number_of_bins, min_angle, max_angle);
+ Scale angle_axis = EquiDivision("axis", number_of_bins, min_angle, max_angle);
auto angles = angle_axis.binCenters();
std::vector<double> qs(angle_axis.size(), 0.0);
for (size_t i = 0, size = qs.size(); i < size; ++i)
qs[i] = 4.0 * pi * std::sin(angles[i]) / wavelength;
return new QzScan(qs);
}
- auto* result = new AlphaScan(FixedBinAxis("axis", number_of_bins, min_angle, max_angle));
+ auto* result = new AlphaScan(EquiDivision("axis", number_of_bins, min_angle, max_angle));
result->setWavelength(wavelength);
return result;
}
@@ -373,7 +373,7 @@ test::makeSimulation::SpecularWithGaussianBeam(const MultiLayer& sample)
const double min_angle = 0;
const double max_angle = 5 * deg;
auto gaussian_ff = std::make_unique<FootprintGauss>(1.0);
- AlphaScan scan(FixedBinAxis("axis", number_of_bins, min_angle, max_angle));
+ AlphaScan scan(EquiDivision("axis", number_of_bins, min_angle, max_angle));
scan.setWavelength(wavelength);
scan.setFootprint(gaussian_ff.get());
@@ -388,7 +388,7 @@ test::makeSimulation::SpecularWithSquareBeam(const MultiLayer& sample)
const double min_angle = 0;
const double max_angle = 5 * deg;
auto square_ff = std::make_unique<FootprintSquare>(1.0);
- AlphaScan scan(FixedBinAxis("axis", number_of_bins, min_angle, max_angle));
+ AlphaScan scan(EquiDivision("axis", number_of_bins, min_angle, max_angle));
scan.setWavelength(wavelength);
scan.setFootprint(square_ff.get());
@@ -405,7 +405,7 @@ test::makeSimulation::SpecularDivergentBeam(const MultiLayer& sample)
const double max_angle = 5 * deg;
const double wavelength_stddev = 0.1 * angstrom;
const double alpha_stddev = 0.1 * deg;
- AlphaScan scan(FixedBinAxis("axis", number_of_bins, min_angle, max_angle));
+ AlphaScan scan(EquiDivision("axis", number_of_bins, min_angle, max_angle));
DistributionGaussian wavelength_distr(wavelength, wavelength_stddev, n_integration_points, 2.);
DistributionGaussian alpha_distr(0, alpha_stddev, n_integration_points, 2.);
@@ -419,7 +419,7 @@ test::makeSimulation::SpecularDivergentBeam(const MultiLayer& sample)
std::unique_ptr<SpecularSimulation>
test::makeSimulation::TOFRWithRelativeResolution(const MultiLayer& sample)
{
- Scale qs = FixedBinAxis("axis", 500, 0.0, 1.0);
+ Scale qs = EquiDivision("axis", 500, 0.0, 1.0);
QzScan scan(qs);
scan.setRelativeQResolution(DistributionGaussian(0., 1., 20, 2.0), 0.03);
@@ -431,7 +431,7 @@ test::makeSimulation::TOFRWithRelativeResolution(const MultiLayer& sample)
std::unique_ptr<SpecularSimulation>
test::makeSimulation::TOFRWithPointwiseResolution(const MultiLayer& sample)
{
- Scale qs = FixedBinAxis("axis", 500, 0.0, 1.0);
+ Scale qs = EquiDivision("axis", 500, 0.0, 1.0);
QzScan scan(qs);
std::vector<double> resolutions;
@@ -456,7 +456,7 @@ test::makeSimulation::BasicDepthprobe(const MultiLayer& sample)
AlphaScan scan(20, 0.025 * deg, 0.975 * deg);
scan.setWavelength(1.);
- Scale zaxis = FixedBinAxis("z", 20, -100., +100.);
+ Scale zaxis = EquiDivision("z", 20, -100., +100.);
return std::make_unique<DepthprobeSimulation>(scan, sample, zaxis);
}
diff --git a/Tests/Unit/Device/ArrayUtilsTest.cpp b/Tests/Unit/Device/ArrayUtilsTest.cpp
index 249a4e2d57a..11b78e91118 100644
--- a/Tests/Unit/Device/ArrayUtilsTest.cpp
+++ b/Tests/Unit/Device/ArrayUtilsTest.cpp
@@ -1,5 +1,5 @@
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Device/Data/ArrayUtil.h"
#include "Device/Data/Datafield.h"
#include "Tests/GTestWrapper/google_test.h"
@@ -20,7 +20,7 @@ TEST(ArrayUtilsTest, DatafieldFromVector1D)
TEST(ArrayUtilsTest, DatafieldToVector1D)
{
const std::vector<double> expected = {10.0, 20.0, 30.0, 40.0};
- Datafield data({newFixedBinAxis("axis0", 4, 10.0, 20.0)});
+ Datafield data({newEquiDivision("axis0", 4, 10.0, 20.0)});
data.setVector(expected);
auto vec = DataUtil::Array::createVector1D(data);
@@ -53,7 +53,7 @@ TEST(ArrayUtilsTest, DatafieldFromVector2D)
TEST(ArrayUtilsTest, DatafieldToVector2D)
{
Datafield data(
- {newFixedBinAxis("axis0", 4, 10.0, 20.0), newFixedBinAxis("axis1", 3, 30.0, 40.0)});
+ {newEquiDivision("axis0", 4, 10.0, 20.0), newEquiDivision("axis1", 3, 30.0, 40.0)});
const std::vector<double> values = {8.0, 4.0, 0.0, 9.0, 5.0, 1.0,
10.0, 6.0, 2.0, 11.0, 7.0, 3.0};
diff --git a/Tests/Unit/Device/DepthprobeConverterTest.cpp b/Tests/Unit/Device/DepthprobeConverterTest.cpp
index 306dc0a18b9..1b6e8fc67a3 100644
--- a/Tests/Unit/Device/DepthprobeConverterTest.cpp
+++ b/Tests/Unit/Device/DepthprobeConverterTest.cpp
@@ -1,5 +1,5 @@
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Device/Coord/CoordSystem2D.h"
#include "Tests/GTestWrapper/google_test.h"
@@ -24,8 +24,8 @@ protected:
};
DepthprobeCoordsTest::DepthprobeCoordsTest()
- : m_axes({newFixedBinAxis("Angles", m_nbins, m_alpha_start, m_alpha_end), // angles in radians
- newFixedBinAxis("Positions", m_nbins, m_z_start, m_z_end)}) // z positions in nm
+ : m_axes({newEquiDivision("Angles", m_nbins, m_alpha_start, m_alpha_end), // angles in radians
+ newEquiDivision("Positions", m_nbins, m_z_start, m_z_end)}) // z positions in nm
{
}
diff --git a/Tests/Unit/Device/FixedBinAxisTest.cpp b/Tests/Unit/Device/FixedBinAxisTest.cpp
index 1bf1b287dff..7d54ba9e0ab 100644
--- a/Tests/Unit/Device/FixedBinAxisTest.cpp
+++ b/Tests/Unit/Device/FixedBinAxisTest.cpp
@@ -1,12 +1,12 @@
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Device/IO/DataFormatUtil.h"
#include "Tests/GTestWrapper/google_test.h"
#include <iostream>
-TEST(FixedBinAxisTest, IndexedAccessor)
+TEST(EquiDivisionTest, IndexedAccessor)
{
- Scale a1 = FixedBinAxis("length", 100, 0.0, 10.0);
+ Scale a1 = EquiDivision("length", 100, 0.0, 10.0);
EXPECT_EQ(100u, a1.size());
EXPECT_EQ(0.0, a1.min());
EXPECT_EQ(10.0, a1.max());
@@ -15,25 +15,25 @@ TEST(FixedBinAxisTest, IndexedAccessor)
EXPECT_DOUBLE_EQ(6.55, a1.binCenter(65));
EXPECT_DOUBLE_EQ(9.95, a1.binCenter(99));
- Scale a2 = FixedBinAxis("name", 3, -1.5, 1.5);
+ Scale a2 = EquiDivision("name", 3, -1.5, 1.5);
EXPECT_DOUBLE_EQ(-1.0, a2.binCenter(0));
EXPECT_DOUBLE_EQ(0.0, a2.binCenter(1));
EXPECT_DOUBLE_EQ(1.0, a2.binCenter(2));
EXPECT_THROW(a2.binCenter(3), std::out_of_range);
}
-TEST(FixedBinAxisTest, VectorOfUnitLength)
+TEST(EquiDivisionTest, VectorOfUnitLength)
{
- Scale axis = FixedBinAxis("name", 1, 1.0, 2.0);
+ Scale axis = EquiDivision("name", 1, 1.0, 2.0);
EXPECT_EQ(1u, axis.size());
EXPECT_EQ(double(1.0), axis.min());
EXPECT_EQ(double(2.0), axis.max());
EXPECT_EQ(1.5, axis.binCenter(0));
}
-TEST(FixedBinAxisTest, FindClosestIndex)
+TEST(EquiDivisionTest, FindClosestIndex)
{
- Scale v1 = FixedBinAxis("name", 2, 0.0, 1.0);
+ Scale v1 = EquiDivision("name", 2, 0.0, 1.0);
EXPECT_EQ(size_t(2), v1.size());
EXPECT_EQ(size_t(0), v1.closestIndex(0.0));
EXPECT_EQ(size_t(0), v1.closestIndex(0.25));
@@ -42,7 +42,7 @@ TEST(FixedBinAxisTest, FindClosestIndex)
// EXPECT_THROW( v1.closestIndex(1.0), std::runtime_error);
EXPECT_EQ(size_t(1), v1.closestIndex(1.0));
- Scale v2 = FixedBinAxis("name", 3, -1.5, 1.5);
+ Scale v2 = EquiDivision("name", 3, -1.5, 1.5);
EXPECT_EQ(size_t(0), v2.closestIndex(-1.5));
EXPECT_EQ(size_t(0), v2.closestIndex(-1.0));
EXPECT_EQ(size_t(1), v2.closestIndex(-0.5));
@@ -53,9 +53,9 @@ TEST(FixedBinAxisTest, FindClosestIndex)
EXPECT_EQ(size_t(2), v2.closestIndex(1.5));
}
-TEST(FixedBinAxisTest, CheckBin)
+TEST(EquiDivisionTest, CheckBin)
{
- Scale axis = FixedBinAxis("name", 20, 0, 10);
+ Scale axis = EquiDivision("name", 20, 0, 10);
Bin1D bin0 = axis.bin(0);
EXPECT_DOUBLE_EQ(0.25, bin0.center());
@@ -81,38 +81,38 @@ TEST(FixedBinAxisTest, CheckBin)
EXPECT_THROW(axis.bin(20), std::out_of_range);
- Scale axis2 = FixedBinAxis("name", 3, -1, 2.0);
+ Scale axis2 = EquiDivision("name", 3, -1, 2.0);
EXPECT_DOUBLE_EQ(-0.5, axis2.bin(0).center());
EXPECT_DOUBLE_EQ(0.5, axis2.bin(1).center());
EXPECT_DOUBLE_EQ(1.5, axis2.bin(2).center());
}
-TEST(FixedBinAxisTest, CheckEquality)
+TEST(EquiDivisionTest, CheckEquality)
{
- Scale b1 = FixedBinAxis("axis", 99, -1.01, 3.3);
- Scale b2 = FixedBinAxis("axis", 99, -1.01, 3.3);
+ Scale b1 = EquiDivision("axis", 99, -1.01, 3.3);
+ Scale b2 = EquiDivision("axis", 99, -1.01, 3.3);
EXPECT_TRUE(b1 == b2);
- Scale b3 = FixedBinAxis("axissss", 99, -1.01, 3.3);
- Scale b4 = FixedBinAxis("axis", 99, -1.0, 3.3);
- Scale b5 = FixedBinAxis("axis", 99, -1.01, 3.29);
- Scale b6 = FixedBinAxis("axiss", 98, -1.01, 3.3);
+ Scale b3 = EquiDivision("axissss", 99, -1.01, 3.3);
+ Scale b4 = EquiDivision("axis", 99, -1.0, 3.3);
+ Scale b5 = EquiDivision("axis", 99, -1.01, 3.29);
+ Scale b6 = EquiDivision("axiss", 98, -1.01, 3.3);
EXPECT_FALSE(b1 == b3);
EXPECT_FALSE(b1 == b4);
EXPECT_FALSE(b1 == b5);
EXPECT_FALSE(b1 == b6);
}
-TEST(FixedBinAxisTest, CheckClone)
+TEST(EquiDivisionTest, CheckClone)
{
- Scale a1 = FixedBinAxis("axis", 99, -1.2, 5.4);
+ Scale a1 = EquiDivision("axis", 99, -1.2, 5.4);
Scale* clone = a1.clone();
EXPECT_TRUE(a1 == *clone);
delete clone;
}
-TEST(FixedBinAxisTest, IOStream)
+TEST(EquiDivisionTest, IOStream)
{
- Scale axis = FixedBinAxis("name", 99, -1.2, 5.4);
+ Scale axis = EquiDivision("name", 99, -1.2, 5.4);
std::ostringstream oss;
oss << axis;
@@ -122,9 +122,9 @@ TEST(FixedBinAxisTest, IOStream)
EXPECT_TRUE(axis == *result);
}
-TEST(FixedBinAxisTest, BinCenters)
+TEST(EquiDivisionTest, BinCenters)
{
- Scale axis = FixedBinAxis("name", 3, -1.5, 1.5);
+ Scale axis = EquiDivision("name", 3, -1.5, 1.5);
std::vector<double> centers = axis.binCenters();
EXPECT_EQ(size_t(3), centers.size());
EXPECT_DOUBLE_EQ(-1.0, centers[0]);
diff --git a/Tests/Unit/Device/IOReaderWriterTest.cpp b/Tests/Unit/Device/IOReaderWriterTest.cpp
index 8866f56fc84..9d3759d16ab 100644
--- a/Tests/Unit/Device/IOReaderWriterTest.cpp
+++ b/Tests/Unit/Device/IOReaderWriterTest.cpp
@@ -1,5 +1,5 @@
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Device/Data/Datafield.h"
#include "Device/IO/ReadWriteINT.h"
#include "Device/IO/ReadWriteNumpyTXT.h"
@@ -14,7 +14,7 @@ protected:
m_model_data[i] = static_cast<double>(i);
}
- Datafield m_model_data{{newFixedBinAxis("x", 5, 1.0, 5.0), newFixedBinAxis("y", 10, 6.0, 7.0)}};
+ Datafield m_model_data{{newEquiDivision("x", 5, 1.0, 5.0), newEquiDivision("y", 10, 6.0, 7.0)}};
};
diff --git a/Tests/Unit/Device/IntensityDataFunctionsTest.cpp b/Tests/Unit/Device/IntensityDataFunctionsTest.cpp
index ed80585c9dd..ac0f72105cd 100644
--- a/Tests/Unit/Device/IntensityDataFunctionsTest.cpp
+++ b/Tests/Unit/Device/IntensityDataFunctionsTest.cpp
@@ -1,7 +1,7 @@
#include "Base/Axis/Frame.h"
#include "Base/Axis/FrameUtil.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Device/Data/DataUtil.h"
#include "Device/Data/Datafield.h"
#include "Tests/GTestWrapper/google_test.h"
@@ -9,7 +9,7 @@
TEST(DataUtilTest, createRearrangedDataSet)
{
Datafield input_data{
- {newFixedBinAxis("axis0", 2, 1.0, 2.0), newFixedBinAxis("axis1", 3, 3.0, 4.0)}};
+ {newEquiDivision("axis0", 2, 1.0, 2.0), newEquiDivision("axis1", 3, 3.0, 4.0)}};
input_data.setVector(std::vector<double>{1.0, 2.0, 3.0, 4.0, 5.0, 6.0});
std::unique_ptr<Datafield> output_data = DataUtil::Data::createRearrangedDataSet(input_data, 5);
@@ -51,7 +51,7 @@ TEST(DataUtilTest, createRearrangedDataSet)
TEST(DataUtilTest, coordinateToFromBinf)
{
- Scale axis = FixedBinAxis("axis", 8, -5.0, 3.0);
+ Scale axis = EquiDivision("axis", 8, -5.0, 3.0);
EXPECT_EQ(0.5, FrameUtil::coordinateToBinf(-4.5, axis));
EXPECT_EQ(-4.5, FrameUtil::coordinateFromBinf(0.5, axis));
@@ -73,9 +73,9 @@ TEST(DataUtilTest, coordinateToFromBinf)
TEST(DataUtilTest, datafieldToFromBinf)
{
- Frame data1({newFixedBinAxis("axis0", 8, -5.0, 3.0), newFixedBinAxis("axis1", 3, 2.0, 5.0)});
+ Frame data1({newEquiDivision("axis0", 8, -5.0, 3.0), newEquiDivision("axis1", 3, 2.0, 5.0)});
Frame data2(
- {newFixedBinAxis("axis0", 8, -10.0, 70.0), newFixedBinAxis("axis1", 3, -10.0, 20.0)});
+ {newEquiDivision("axis0", 8, -10.0, 70.0), newEquiDivision("axis1", 3, -10.0, 20.0)});
double x(-4.5), y(2.5);
FrameUtil::coordinatesToBinf(x, y, data1);
@@ -94,7 +94,7 @@ TEST(DataUtilTest, datafieldToFromBinf)
TEST(DataUtilTest, create2DArrayfromDatafield)
{
Datafield out_data{
- {newFixedBinAxis("axis0", 2, 1.0, 2.0), newFixedBinAxis("axis1", 3, 3.0, 4.0)}};
+ {newEquiDivision("axis0", 2, 1.0, 2.0), newEquiDivision("axis1", 3, 3.0, 4.0)}};
EXPECT_EQ(6u, out_data.size());
EXPECT_EQ(2u, out_data.axis(0).size()); // no. of rows
diff --git a/Tests/Unit/Device/OffspecConverterTest.cpp b/Tests/Unit/Device/OffspecConverterTest.cpp
index d0994636712..708ecc20ce2 100644
--- a/Tests/Unit/Device/OffspecConverterTest.cpp
+++ b/Tests/Unit/Device/OffspecConverterTest.cpp
@@ -1,5 +1,5 @@
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Device/Beam/Beam.h"
#include "Device/Coord/CoordSystem2D.h"
@@ -18,7 +18,7 @@ public:
protected:
SphericalDetector m_detector{100, 0.0, 5.0 * Units::deg, 70, -2.0 * Units::deg, 1.5};
- Scale m_alpha_i_axis = FixedBinAxis("alpha_i", 51, 0.0, 7.0 * Units::deg);
+ Scale m_alpha_i_axis = EquiDivision("alpha_i", 51, 0.0, 7.0 * Units::deg);
Beam m_beam{1, 1.0, 1.0 * Units::deg};
};
diff --git a/Tests/Unit/Device/PointwiseAxisTest.cpp b/Tests/Unit/Device/PointwiseAxisTest.cpp
index 55088d65de4..c5f129ca674 100644
--- a/Tests/Unit/Device/PointwiseAxisTest.cpp
+++ b/Tests/Unit/Device/PointwiseAxisTest.cpp
@@ -1,24 +1,24 @@
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Device/IO/DataFormatUtil.h"
#include "Tests/GTestWrapper/google_test.h"
#include <iostream>
TEST(PointwiseAxisTest, Construction)
{
- EXPECT_THROW(DiscreteAxis("length", std::vector<double>{1.0, 0.0}), std::runtime_error);
- EXPECT_THROW(DiscreteAxis("length", std::vector<double>{0.0, 1.0, 0.5}), std::runtime_error);
- EXPECT_THROW(DiscreteAxis("length", std::vector<double>{0.0, 1.0, 1.0}), std::runtime_error);
- Scale a1 = DiscreteAxis("length", std::vector<double>{0.0, 1.0});
+ EXPECT_THROW(ListScan("length", std::vector<double>{1.0, 0.0}), std::runtime_error);
+ EXPECT_THROW(ListScan("length", std::vector<double>{0.0, 1.0, 0.5}), std::runtime_error);
+ EXPECT_THROW(ListScan("length", std::vector<double>{0.0, 1.0, 1.0}), std::runtime_error);
+ Scale a1 = ListScan("length", std::vector<double>{0.0, 1.0});
std::vector<double> coordinates{0.0, 1.0};
- Scale a2 = DiscreteAxis("length", coordinates);
+ Scale a2 = ListScan("length", coordinates);
EXPECT_TRUE(a1 == a2);
}
TEST(PointwiseAxisTest, BasicProperties)
{
std::vector<double> coordinates{0.0, 1.0, 4.0, 8.0};
- Scale a1 = DiscreteAxis("length", coordinates);
+ Scale a1 = ListScan("length", coordinates);
EXPECT_EQ(4u, a1.size());
EXPECT_EQ(0.0, a1.min());
EXPECT_EQ(8.0, a1.max());
@@ -37,7 +37,7 @@ TEST(PointwiseAxisTest, BasicProperties)
TEST(PointwiseAxisTest, FindClosestIndex)
{
- Scale v1 = DiscreteAxis("name", std::vector<double>{0.0, 1.0, 4.0, 8.0});
+ Scale v1 = ListScan("name", std::vector<double>{0.0, 1.0, 4.0, 8.0});
EXPECT_EQ(4u, v1.size());
EXPECT_EQ(v1.closestIndex(-1.0), 0u);
EXPECT_EQ(v1.closestIndex(0.0), 0u);
@@ -49,7 +49,7 @@ TEST(PointwiseAxisTest, FindClosestIndex)
EXPECT_EQ(3u, v1.closestIndex(8.0));
EXPECT_EQ(3u, v1.closestIndex(11.0));
- Scale v2 = DiscreteAxis("name", std::vector<double>{-2.0, -1.0});
+ Scale v2 = ListScan("name", std::vector<double>{-2.0, -1.0});
EXPECT_EQ(2u, v2.size());
EXPECT_EQ(v2.closestIndex(-3.0), 0u);
EXPECT_EQ(v2.closestIndex(-2.0), 0u);
@@ -61,12 +61,12 @@ TEST(PointwiseAxisTest, FindClosestIndex)
TEST(PointwiseAxisTest, CheckEquality)
{
- Scale b1 = DiscreteAxis("axis", std::vector<double>{1.0, 2.0, 5.0});
- Scale b2 = DiscreteAxis("axis", std::vector<double>{1.0, 2.0, 5.0});
+ Scale b1 = ListScan("axis", std::vector<double>{1.0, 2.0, 5.0});
+ Scale b2 = ListScan("axis", std::vector<double>{1.0, 2.0, 5.0});
EXPECT_TRUE(b1 == b2);
- Scale b3 = DiscreteAxis("axissss", std::vector<double>{1.0, 2.0, 5.0});
- Scale b4 = DiscreteAxis("axis", std::vector<double>{1.0, 2.0, 6.0});
- Scale b6 = DiscreteAxis("axiss", std::vector<double>{1.5, 2.0, 5.0});
+ Scale b3 = ListScan("axissss", std::vector<double>{1.0, 2.0, 5.0});
+ Scale b4 = ListScan("axis", std::vector<double>{1.0, 2.0, 6.0});
+ Scale b6 = ListScan("axiss", std::vector<double>{1.5, 2.0, 5.0});
EXPECT_FALSE(b1 == b3);
EXPECT_FALSE(b1 == b4);
EXPECT_FALSE(b1 == b6);
@@ -74,14 +74,14 @@ TEST(PointwiseAxisTest, CheckEquality)
TEST(PointwiseAxisTest, CheckClone)
{
- Scale a1 = DiscreteAxis("axis", std::vector<double>{1.0, 2.0, 5.0});
+ Scale a1 = ListScan("axis", std::vector<double>{1.0, 2.0, 5.0});
Scale* clone = a1.clone();
EXPECT_TRUE(a1 == *clone);
}
TEST(PointwiseAxisTest, IOStream)
{
- Scale axis = DiscreteAxis("name", std::vector<double>{1.0, 2.0, 5.0});
+ Scale axis = ListScan("name", std::vector<double>{1.0, 2.0, 5.0});
std::ostringstream oss;
oss << axis;
@@ -93,7 +93,7 @@ TEST(PointwiseAxisTest, IOStream)
TEST(PointwiseAxisTest, ClippedAxis)
{
- Scale axis = DiscreteAxis("name", std::vector<double>{1.0, 2.0, 2.5, 2.7, 5.0});
+ Scale axis = ListScan("name", std::vector<double>{1.0, 2.0, 2.5, 2.7, 5.0});
Scale clip1 = axis.clipped(0.99, 5.1);
EXPECT_TRUE(clip1 == axis);
@@ -111,15 +111,15 @@ TEST(PointwiseAxisTest, ClippedAxis)
EXPECT_THROW(axis.clipped(5.0, 1.0), std::runtime_error);
}
-TEST(PointwiseAxisTest, FixedBinAxisComparisonWithMask)
+TEST(PointwiseAxisTest, EquiDivisionComparisonWithMask)
{
- Scale axis = FixedBinAxis("reference", 10, 0.0, 10.0);
+ Scale axis = EquiDivision("reference", 10, 0.0, 10.0);
const std::vector<size_t> mask{0u, 2u, 3u, 4u, 7u, 8u, 9u};
std::vector<double> coordinates;
for (auto index : mask)
coordinates.push_back(axis.binCenter(index));
- Scale pointwise_axis = DiscreteAxis("pointwise", coordinates);
+ Scale pointwise_axis = ListScan("pointwise", coordinates);
// comparing on-axis values
for (size_t i = 0; i < mask.size(); ++i)
diff --git a/Tests/Unit/Device/PowerfieldTest.cpp b/Tests/Unit/Device/PowerfieldTest.cpp
index 0fa3c013305..94dc1ef7835 100644
--- a/Tests/Unit/Device/PowerfieldTest.cpp
+++ b/Tests/Unit/Device/PowerfieldTest.cpp
@@ -8,7 +8,7 @@
class DatafieldTest : public ::testing::Test {
protected:
DatafieldTest()
- : db_data{{newFixedBinAxis("angle", 20, 0.0, 0.1), newFixedBinAxis("length", 10, 0.0, 0.5)}}
+ : db_data{{newEquiDivision("angle", 20, 0.0, 0.1), newEquiDivision("length", 10, 0.0, 0.5)}}
{
for (size_t i = 0; i < 200; ++i)
db_data[i] = (double)i;
diff --git a/Tests/Unit/Device/RegionOfInterestTest.cpp b/Tests/Unit/Device/RegionOfInterestTest.cpp
index 08fad1dff11..acc5ef9aad1 100644
--- a/Tests/Unit/Device/RegionOfInterestTest.cpp
+++ b/Tests/Unit/Device/RegionOfInterestTest.cpp
@@ -8,7 +8,7 @@
TEST(RegionOfInterestTest, constructor)
{
SphericalDetector detector(std::array<std::shared_ptr<Scale>, 2>{
- sharedFixedBinAxis("axis0", 8, -3.0, 5.0), sharedFixedBinAxis("axis1", 4, 0.0, 4.0)});
+ sharedEquiDivision("axis0", 8, -3.0, 5.0), sharedEquiDivision("axis1", 4, 0.0, 4.0)});
// creating region of interest
double xlow(-1.9), ylow(1.1), xup(2.9), yup(2.85);
@@ -34,7 +34,7 @@ TEST(RegionOfInterestTest, constructor)
TEST(RegionOfInterestTest, largeArea)
{
SphericalDetector detector(std::array<std::shared_ptr<Scale>, 2>{
- sharedFixedBinAxis("axis0", 8, -3.0, 5.0), sharedFixedBinAxis("axis1", 4, 0.0, 4.0)});
+ sharedEquiDivision("axis0", 8, -3.0, 5.0), sharedEquiDivision("axis1", 4, 0.0, 4.0)});
// creating region of interest
double xlow(-3.9), ylow(-1.1), xup(6.9), yup(5.85);
@@ -56,7 +56,7 @@ TEST(RegionOfInterestTest, largeArea)
TEST(RegionOfInterestTest, clone)
{
SphericalDetector detector(std::array<std::shared_ptr<Scale>, 2>{
- sharedFixedBinAxis("axis0", 8, -3.0, 5.0), sharedFixedBinAxis("axis1", 4, 0.0, 4.0)});
+ sharedEquiDivision("axis0", 8, -3.0, 5.0), sharedEquiDivision("axis1", 4, 0.0, 4.0)});
// creating region of interest
double xlow(-1.9), ylow(1.1), xup(2.9), yup(2.85);
diff --git a/Tests/Unit/Device/SphericalDetectorTest.cpp b/Tests/Unit/Device/SphericalDetectorTest.cpp
index 62d66f1543f..9cbe92c5905 100644
--- a/Tests/Unit/Device/SphericalDetectorTest.cpp
+++ b/Tests/Unit/Device/SphericalDetectorTest.cpp
@@ -1,6 +1,6 @@
#include "Device/Detector/SphericalDetector.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Device/Beam/Beam.h"
#include "Device/Detector/SimulationAreaIterator.h"
@@ -15,8 +15,8 @@
// Construction of the detector with axes.
TEST(SphericalDetectorTest, constructionWithAxes)
{
- auto axis0 = sharedFixedBinAxis("axis0", 10, 0.0, 10.0);
- auto axis1 = sharedFixedBinAxis("axis1", 20, 0.0, 20.0);
+ auto axis0 = sharedEquiDivision("axis0", 10, 0.0, 10.0);
+ auto axis1 = sharedEquiDivision("axis1", 20, 0.0, 20.0);
SphericalDetector detector(std::array<std::shared_ptr<Scale>, 2>{axis0, axis1});
// checking dimension and axes
@@ -58,7 +58,7 @@ TEST(SphericalDetectorTest, createDetectorMap)
TEST(SphericalDetectorTest, regionOfInterest)
{
SphericalDetector detector(std::array<std::shared_ptr<Scale>, 2>{
- sharedFixedBinAxis("axis0", 8, -3.0, 5.0), sharedFixedBinAxis("axis1", 4, 0.0, 4.0)});
+ sharedEquiDivision("axis0", 8, -3.0, 5.0), sharedEquiDivision("axis1", 4, 0.0, 4.0)});
// creating region of interest
double xlow(-2.0), ylow(1.0), xup(4.0), yup(3.0);
diff --git a/Tests/Unit/GUI/TestRealModel.cpp b/Tests/Unit/GUI/TestRealModel.cpp
index ec512bd4d90..30330c84984 100644
--- a/Tests/Unit/GUI/TestRealModel.cpp
+++ b/Tests/Unit/GUI/TestRealModel.cpp
@@ -32,7 +32,7 @@ TEST(TestRealModel, RealItemWithNativeData)
EXPECT_EQ(realModel.dataItems().size(), 1);
// import 1D data with importer
- Datafield data1D({newFixedBinAxis("x", 10, 0.0, 3.0)});
+ Datafield data1D({newEquiDivision("x", 10, 0.0, 3.0)});
ImportDataInfo import_data_1D(std::unique_ptr<Datafield>(data1D.clone()), "nbins");
realItem1D->setImportData(std::move(import_data_1D));
@@ -45,7 +45,7 @@ TEST(TestRealModel, RealItemWithNativeData)
EXPECT_EQ(realModel.dataItems().size(), 3);
// import 2D data with importer
- Datafield data2D({newFixedBinAxis("x", 10, 0.0, 1.0), newFixedBinAxis("y", 10, -1.0, 1.0)});
+ Datafield data2D({newEquiDivision("x", 10, 0.0, 1.0), newEquiDivision("y", 10, -1.0, 1.0)});
ImportDataInfo import_data_2D(std::unique_ptr<Datafield>(data2D.clone()), "nbins");
realItem2D->setImportData(std::move(import_data_2D));
@@ -80,7 +80,7 @@ TEST(TestRealModel, removeNativeData)
EXPECT_EQ(item->nativeDataItem()->c_field(), nullptr);
// set datafield
- auto* oData = new Datafield{{newDiscreteAxis("qVector", std::vector<double>({1, 2}))}};
+ auto* oData = new Datafield{{newListScan("qVector", std::vector<double>({1, 2}))}};
oData->setVector(std::vector<double>({3, 4}));
item->nativeDataItem()->setDatafield(oData); // takes ownership of odata
EXPECT_TRUE(item->hasNativeData());
diff --git a/Tests/Unit/GUI/Utils.cpp b/Tests/Unit/GUI/Utils.cpp
index afbf202c6aa..0db85eb8a2d 100644
--- a/Tests/Unit/GUI/Utils.cpp
+++ b/Tests/Unit/GUI/Utils.cpp
@@ -42,9 +42,9 @@ void UTest::GUI::create_dir(const QString& dir_name)
std::unique_ptr<Datafield> UTest::GUI::createData(double value, DIM n_dim)
{
std::vector<const Scale*> axes;
- axes.emplace_back(newFixedBinAxis("x", nxsize, -1.0, 1.0));
+ axes.emplace_back(newEquiDivision("x", nxsize, -1.0, 1.0));
if (n_dim == DIM::D2)
- axes.emplace_back(newFixedBinAxis("y", nysize, 0.0, 2.0));
+ axes.emplace_back(newEquiDivision("y", nysize, 0.0, 2.0));
std::unique_ptr<Datafield> result(new Datafield(std::move(axes)));
result->setAllTo(value);
diff --git a/Tests/Unit/Sim/CoordSystem1DTest.cpp b/Tests/Unit/Sim/CoordSystem1DTest.cpp
index e40d6a64cc4..355df452b35 100644
--- a/Tests/Unit/Sim/CoordSystem1DTest.cpp
+++ b/Tests/Unit/Sim/CoordSystem1DTest.cpp
@@ -1,6 +1,6 @@
#include "Device/Coord/CoordSystem1D.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Sim/Scan/QzScan.h"
#include "Tests/GTestWrapper/google_test.h"
@@ -16,8 +16,8 @@ public:
protected:
void checkConventionalConverter(const CoordSystem1D& test_object);
void checkQSpecConverter(const CoordSystem1D& test_object);
- Scale m_axis = FixedBinAxis("Angles", 5, 0.5, 1.0);
- Scale m_q_axis = FixedBinAxis("Q values", 5, 0.0, 1.0);
+ Scale m_axis = EquiDivision("Angles", 5, 0.5, 1.0);
+ Scale m_q_axis = EquiDivision("Q values", 5, 0.0, 1.0);
QzScan m_qscan{m_q_axis};
double m_wavelength{1.};
};
@@ -110,7 +110,7 @@ TEST_F(CoordSystem1DTest, Exceptions)
EXPECT_FAILED_ASSERT(converter.convertedAxis(0, Coords::MM));
EXPECT_FAILED_ASSERT(converter.convertedAxis(1, Coords::UNDEFINED));
- Scale axis = FixedBinAxis("Angles", 100, 0.0, (2 * pi));
+ Scale axis = EquiDivision("Angles", 100, 0.0, (2 * pi));
EXPECT_FAILED_ASSERT(AngularReflectometryCoords converter2(m_wavelength, axis));
WavenumberReflectometryCoords converter2(m_qscan.coordinateAxis()->clone());
@@ -141,7 +141,7 @@ TEST_F(CoordSystem1DTest, Clone)
TEST_F(CoordSystem1DTest, NonDefaultUnitsInInput)
{
- Scale axis = DiscreteAxis("x", std::vector<double>{0.0, 0.5, 1.0});
+ Scale axis = ListScan("x", std::vector<double>{0.0, 0.5, 1.0});
{
AngularReflectometryCoords converter(m_wavelength, axis, Coords::DEGREES);
@@ -154,7 +154,7 @@ TEST_F(CoordSystem1DTest, NonDefaultUnitsInInput)
auto values = axis.binCenters();
std::for_each(values.begin(), values.end(), [this](double& value) { value = getQ(value); });
- Scale q_axis = DiscreteAxis("q", values);
+ Scale q_axis = ListScan("q", values);
{
AngularReflectometryCoords converter(m_wavelength, q_axis, Coords::QSPACE);
auto out = converter.convertedAxis(0, Coords::RADIANS);
diff --git a/Tests/Unit/Sim/FittingTestHelper.h b/Tests/Unit/Sim/FittingTestHelper.h
index 15ccd226323..28604de2093 100644
--- a/Tests/Unit/Sim/FittingTestHelper.h
+++ b/Tests/Unit/Sim/FittingTestHelper.h
@@ -51,8 +51,8 @@ public:
std::unique_ptr<Datafield> createTestData(double value)
{
std::unique_ptr<Datafield> result(
- new Datafield({newFixedBinAxis("phi_f", m_nx, m_xmin, m_xmax),
- newFixedBinAxis("alpha_f", m_ny, m_ymin, m_ymax)}));
+ new Datafield({newEquiDivision("phi_f", m_nx, m_xmin, m_xmax),
+ newEquiDivision("alpha_f", m_ny, m_ymin, m_ymax)}));
result->setAllTo(value);
return result;
}
diff --git a/Tests/Unit/Sim/SpecularScanTest.cpp b/Tests/Unit/Sim/SpecularScanTest.cpp
index a9e5e4ebde2..118942c7fe6 100644
--- a/Tests/Unit/Sim/SpecularScanTest.cpp
+++ b/Tests/Unit/Sim/SpecularScanTest.cpp
@@ -1,5 +1,5 @@
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Param/Distrib/Distributions.h"
#include "Param/Distrib/ParameterSample.h"
#include "Resample/Element/SpecularElement.h"
@@ -16,11 +16,11 @@ TEST(SpecularScanTest, AngularScanInit)
EXPECT_EQ(scan.nScan(), axis.size());
};
- const Scale pointwise_axis = DiscreteAxis("inc_angles", std::vector<double>{0.1, 0.2, 0.3});
+ const Scale pointwise_axis = ListScan("inc_angles", std::vector<double>{0.1, 0.2, 0.3});
AlphaScan scan(pointwise_axis);
check(scan, pointwise_axis);
- const Scale fixed_axis = FixedBinAxis("inc_angles", 3, 0.1, 0.3);
+ const Scale fixed_axis = EquiDivision("inc_angles", 3, 0.1, 0.3);
AlphaScan scan3(fixed_axis);
check(scan3, fixed_axis);
}
diff --git a/Tests/Unit/Sim/SpecularSimulationTest.cpp b/Tests/Unit/Sim/SpecularSimulationTest.cpp
index 28dbe5bdaed..3aaf5600d38 100644
--- a/Tests/Unit/Sim/SpecularSimulationTest.cpp
+++ b/Tests/Unit/Sim/SpecularSimulationTest.cpp
@@ -1,6 +1,6 @@
#include "Sim/Simulation/SpecularSimulation.h"
-#include "Base/Axis/Scale.h"
#include "Base/Axis/MakeScale.h"
+#include "Base/Axis/Scale.h"
#include "Base/Const/Units.h"
#include "Device/Beam/Beam.h"
#include "Device/Data/Datafield.h"
@@ -45,7 +45,7 @@ SpecularSimulationTest::SpecularSimulationTest()
std::unique_ptr<SpecularSimulation> SpecularSimulationTest::defaultSimulation()
{
- AlphaScan scan(FixedBinAxis("axis", 10, 0.0 * Units::deg, 2.0 * Units::deg));
+ AlphaScan scan(EquiDivision("axis", 10, 0.0 * Units::deg, 2.0 * Units::deg));
scan.setWavelength(1.0);
return std::make_unique<SpecularSimulation>(scan, sample);
}
diff --git a/auto/Wrap/libBornAgainBase.py b/auto/Wrap/libBornAgainBase.py
index 4d65eb1a26f..3af85d7be24 100644
--- a/auto/Wrap/libBornAgainBase.py
+++ b/auto/Wrap/libBornAgainBase.py
@@ -1937,29 +1937,29 @@ class Scale(object):
# Register Scale in _libBornAgainBase:
_libBornAgainBase.Scale_swigregister(Scale)
-def DiscreteAxis(name, points):
- r"""DiscreteAxis(std::string const & name, vdouble1d_t points) -> Scale"""
- return _libBornAgainBase.DiscreteAxis(name, points)
+def ListScan(name, points):
+ r"""ListScan(std::string const & name, vdouble1d_t points) -> Scale"""
+ return _libBornAgainBase.ListScan(name, points)
-def newDiscreteAxis(name, points):
- r"""newDiscreteAxis(std::string const & name, vdouble1d_t points) -> Scale"""
- return _libBornAgainBase.newDiscreteAxis(name, points)
+def newListScan(name, points):
+ r"""newListScan(std::string const & name, vdouble1d_t points) -> Scale"""
+ return _libBornAgainBase.newListScan(name, points)
-def FixedBinAxis(name, nbins, start, end):
- r"""FixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> Scale"""
- return _libBornAgainBase.FixedBinAxis(name, nbins, start, end)
+def EquiDivision(name, nbins, start, end):
+ r"""EquiDivision(std::string const & name, size_t nbins, double start, double end) -> Scale"""
+ return _libBornAgainBase.EquiDivision(name, nbins, start, end)
-def newFixedBinAxis(name, nbins, start, end):
- r"""newFixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> Scale"""
- return _libBornAgainBase.newFixedBinAxis(name, nbins, start, end)
+def newEquiDivision(name, nbins, start, end):
+ r"""newEquiDivision(std::string const & name, size_t nbins, double start, double end) -> Scale"""
+ return _libBornAgainBase.newEquiDivision(name, nbins, start, end)
-def sharedFixedBinAxis(name, nbins, start, end):
- r"""sharedFixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> std::shared_ptr< Scale >"""
- return _libBornAgainBase.sharedFixedBinAxis(name, nbins, start, end)
+def sharedEquiDivision(name, nbins, start, end):
+ r"""sharedEquiDivision(std::string const & name, size_t nbins, double start, double end) -> std::shared_ptr< Scale >"""
+ return _libBornAgainBase.sharedEquiDivision(name, nbins, start, end)
-def uniqueFixedBinAxis(name, nbins, start, end):
- r"""uniqueFixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> std::unique_ptr< Scale >"""
- return _libBornAgainBase.uniqueFixedBinAxis(name, nbins, start, end)
+def uniqueEquiDivision(name, nbins, start, end):
+ r"""uniqueEquiDivision(std::string const & name, size_t nbins, double start, double end) -> std::unique_ptr< Scale >"""
+ return _libBornAgainBase.uniqueEquiDivision(name, nbins, start, end)
class Frame(ICloneable):
r"""Proxy of C++ Frame class."""
diff --git a/auto/Wrap/libBornAgainBase_wrap.cpp b/auto/Wrap/libBornAgainBase_wrap.cpp
index b8e82850c77..488817393cd 100644
--- a/auto/Wrap/libBornAgainBase_wrap.cpp
+++ b/auto/Wrap/libBornAgainBase_wrap.cpp
@@ -25941,7 +25941,7 @@ SWIGINTERN PyObject *Scale_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *ar
return SWIG_Python_InitShadowInstance(args);
}
-SWIGINTERN PyObject *_wrap_DiscreteAxis(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_ListScan(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
std::string *arg1 = 0 ;
std::vector< double,std::allocator< double > > *arg2 = 0 ;
@@ -25950,15 +25950,15 @@ SWIGINTERN PyObject *_wrap_DiscreteAxis(PyObject *self, PyObject *args) {
PyObject *swig_obj[2] ;
SwigValueWrapper< Scale > result;
- if (!SWIG_Python_UnpackTuple(args, "DiscreteAxis", 2, 2, swig_obj)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "ListScan", 2, 2, swig_obj)) SWIG_fail;
{
std::string *ptr = (std::string *)0;
res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DiscreteAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ListScan" "', argument " "1"" of type '" "std::string const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListScan" "', argument " "1"" of type '" "std::string const &""'");
}
arg1 = ptr;
}
@@ -25966,14 +25966,14 @@ SWIGINTERN PyObject *_wrap_DiscreteAxis(PyObject *self, PyObject *args) {
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 '" "DiscreteAxis" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ListScan" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DiscreteAxis" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ListScan" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg2 = ptr;
}
- result = DiscreteAxis((std::string const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
+ result = ListScan((std::string const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
resultobj = SWIG_NewPointerObj((new Scale(result)), SWIGTYPE_p_Scale, SWIG_POINTER_OWN | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
if (SWIG_IsNewObj(res2)) delete arg2;
@@ -25985,7 +25985,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_newDiscreteAxis(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_newListScan(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
std::string *arg1 = 0 ;
std::vector< double,std::allocator< double > > *arg2 = 0 ;
@@ -25994,15 +25994,15 @@ SWIGINTERN PyObject *_wrap_newDiscreteAxis(PyObject *self, PyObject *args) {
PyObject *swig_obj[2] ;
Scale *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "newDiscreteAxis", 2, 2, swig_obj)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "newListScan", 2, 2, swig_obj)) SWIG_fail;
{
std::string *ptr = (std::string *)0;
res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "newDiscreteAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "newListScan" "', argument " "1"" of type '" "std::string const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "newDiscreteAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "newListScan" "', argument " "1"" of type '" "std::string const &""'");
}
arg1 = ptr;
}
@@ -26010,14 +26010,14 @@ SWIGINTERN PyObject *_wrap_newDiscreteAxis(PyObject *self, PyObject *args) {
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 '" "newDiscreteAxis" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "newListScan" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "newDiscreteAxis" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "newListScan" "', argument " "2"" of type '" "std::vector< double,std::allocator< double > > const &""'");
}
arg2 = ptr;
}
- result = (Scale *)newDiscreteAxis((std::string const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
+ result = (Scale *)newListScan((std::string const &)*arg1,(std::vector< double,std::allocator< double > > const &)*arg2);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Scale, 0 | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
if (SWIG_IsNewObj(res2)) delete arg2;
@@ -26029,7 +26029,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_FixedBinAxis(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_EquiDivision(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
std::string *arg1 = 0 ;
size_t arg2 ;
@@ -26045,34 +26045,34 @@ SWIGINTERN PyObject *_wrap_FixedBinAxis(PyObject *self, PyObject *args) {
PyObject *swig_obj[4] ;
SwigValueWrapper< Scale > result;
- if (!SWIG_Python_UnpackTuple(args, "FixedBinAxis", 4, 4, swig_obj)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "EquiDivision", 4, 4, swig_obj)) SWIG_fail;
{
std::string *ptr = (std::string *)0;
res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
arg1 = ptr;
}
ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FixedBinAxis" "', argument " "2"" of type '" "size_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EquiDivision" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FixedBinAxis" "', argument " "3"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EquiDivision" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "FixedBinAxis" "', argument " "4"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EquiDivision" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
- result = FixedBinAxis((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
+ result = EquiDivision((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
resultobj = SWIG_NewPointerObj((new Scale(result)), SWIGTYPE_p_Scale, SWIG_POINTER_OWN | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
@@ -26082,7 +26082,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_newFixedBinAxis(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_newEquiDivision(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
std::string *arg1 = 0 ;
size_t arg2 ;
@@ -26098,34 +26098,34 @@ SWIGINTERN PyObject *_wrap_newFixedBinAxis(PyObject *self, PyObject *args) {
PyObject *swig_obj[4] ;
Scale *result = 0 ;
- if (!SWIG_Python_UnpackTuple(args, "newFixedBinAxis", 4, 4, swig_obj)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "newEquiDivision", 4, 4, swig_obj)) SWIG_fail;
{
std::string *ptr = (std::string *)0;
res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "newFixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "newEquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "newFixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "newEquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
arg1 = ptr;
}
ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "newFixedBinAxis" "', argument " "2"" of type '" "size_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "newEquiDivision" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "newFixedBinAxis" "', argument " "3"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "newEquiDivision" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "newFixedBinAxis" "', argument " "4"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "newEquiDivision" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
- result = (Scale *)newFixedBinAxis((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
+ result = (Scale *)newEquiDivision((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Scale, 0 | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
@@ -26135,7 +26135,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_sharedFixedBinAxis(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_sharedEquiDivision(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
std::string *arg1 = 0 ;
size_t arg2 ;
@@ -26151,34 +26151,34 @@ SWIGINTERN PyObject *_wrap_sharedFixedBinAxis(PyObject *self, PyObject *args) {
PyObject *swig_obj[4] ;
SwigValueWrapper< std::shared_ptr< Scale > > result;
- if (!SWIG_Python_UnpackTuple(args, "sharedFixedBinAxis", 4, 4, swig_obj)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "sharedEquiDivision", 4, 4, swig_obj)) SWIG_fail;
{
std::string *ptr = (std::string *)0;
res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sharedFixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "sharedEquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sharedFixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "sharedEquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
arg1 = ptr;
}
ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sharedFixedBinAxis" "', argument " "2"" of type '" "size_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "sharedEquiDivision" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sharedFixedBinAxis" "', argument " "3"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "sharedEquiDivision" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sharedFixedBinAxis" "', argument " "4"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "sharedEquiDivision" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
- result = sharedFixedBinAxis((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
+ result = sharedEquiDivision((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
resultobj = SWIG_NewPointerObj((new std::shared_ptr< Scale >(result)), SWIGTYPE_p_std__shared_ptrT_Scale_t, SWIG_POINTER_OWN | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
@@ -26188,7 +26188,7 @@ fail:
}
-SWIGINTERN PyObject *_wrap_uniqueFixedBinAxis(PyObject *self, PyObject *args) {
+SWIGINTERN PyObject *_wrap_uniqueEquiDivision(PyObject *self, PyObject *args) {
PyObject *resultobj = 0;
std::string *arg1 = 0 ;
size_t arg2 ;
@@ -26204,34 +26204,34 @@ SWIGINTERN PyObject *_wrap_uniqueFixedBinAxis(PyObject *self, PyObject *args) {
PyObject *swig_obj[4] ;
SwigValueWrapper< std::unique_ptr< Scale > > result;
- if (!SWIG_Python_UnpackTuple(args, "uniqueFixedBinAxis", 4, 4, swig_obj)) SWIG_fail;
+ if (!SWIG_Python_UnpackTuple(args, "uniqueEquiDivision", 4, 4, swig_obj)) SWIG_fail;
{
std::string *ptr = (std::string *)0;
res1 = SWIG_AsPtr_std_string(swig_obj[0], &ptr);
if (!SWIG_IsOK(res1)) {
- SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uniqueFixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "uniqueEquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
if (!ptr) {
- SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uniqueFixedBinAxis" "', argument " "1"" of type '" "std::string const &""'");
+ SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "uniqueEquiDivision" "', argument " "1"" of type '" "std::string const &""'");
}
arg1 = ptr;
}
ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
if (!SWIG_IsOK(ecode2)) {
- SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "uniqueFixedBinAxis" "', argument " "2"" of type '" "size_t""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "uniqueEquiDivision" "', argument " "2"" of type '" "size_t""'");
}
arg2 = static_cast< size_t >(val2);
ecode3 = SWIG_AsVal_double(swig_obj[2], &val3);
if (!SWIG_IsOK(ecode3)) {
- SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "uniqueFixedBinAxis" "', argument " "3"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "uniqueEquiDivision" "', argument " "3"" of type '" "double""'");
}
arg3 = static_cast< double >(val3);
ecode4 = SWIG_AsVal_double(swig_obj[3], &val4);
if (!SWIG_IsOK(ecode4)) {
- SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "uniqueFixedBinAxis" "', argument " "4"" of type '" "double""'");
+ SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "uniqueEquiDivision" "', argument " "4"" of type '" "double""'");
}
arg4 = static_cast< double >(val4);
- result = uniqueFixedBinAxis((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
+ result = uniqueEquiDivision((std::string const &)*arg1,SWIG_STD_MOVE(arg2),arg3,arg4);
resultobj = SWIG_NewPointerObj((new std::unique_ptr< Scale >(result)), SWIGTYPE_p_std__unique_ptrT_Scale_t, SWIG_POINTER_OWN | 0 );
if (SWIG_IsNewObj(res1)) delete arg1;
return resultobj;
@@ -28720,12 +28720,12 @@ static PyMethodDef SwigMethods[] = {
{ "delete_Scale", _wrap_delete_Scale, METH_O, "delete_Scale(Scale self)"},
{ "Scale_swigregister", Scale_swigregister, METH_O, NULL},
{ "Scale_swiginit", Scale_swiginit, METH_VARARGS, NULL},
- { "DiscreteAxis", _wrap_DiscreteAxis, METH_VARARGS, "DiscreteAxis(std::string const & name, vdouble1d_t points) -> Scale"},
- { "newDiscreteAxis", _wrap_newDiscreteAxis, METH_VARARGS, "newDiscreteAxis(std::string const & name, vdouble1d_t points) -> Scale"},
- { "FixedBinAxis", _wrap_FixedBinAxis, METH_VARARGS, "FixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> Scale"},
- { "newFixedBinAxis", _wrap_newFixedBinAxis, METH_VARARGS, "newFixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> Scale"},
- { "sharedFixedBinAxis", _wrap_sharedFixedBinAxis, METH_VARARGS, "sharedFixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> std::shared_ptr< Scale >"},
- { "uniqueFixedBinAxis", _wrap_uniqueFixedBinAxis, METH_VARARGS, "uniqueFixedBinAxis(std::string const & name, size_t nbins, double start, double end) -> std::unique_ptr< Scale >"},
+ { "ListScan", _wrap_ListScan, METH_VARARGS, "ListScan(std::string const & name, vdouble1d_t points) -> Scale"},
+ { "newListScan", _wrap_newListScan, METH_VARARGS, "newListScan(std::string const & name, vdouble1d_t points) -> Scale"},
+ { "EquiDivision", _wrap_EquiDivision, METH_VARARGS, "EquiDivision(std::string const & name, size_t nbins, double start, double end) -> Scale"},
+ { "newEquiDivision", _wrap_newEquiDivision, METH_VARARGS, "newEquiDivision(std::string const & name, size_t nbins, double start, double end) -> Scale"},
+ { "sharedEquiDivision", _wrap_sharedEquiDivision, METH_VARARGS, "sharedEquiDivision(std::string const & name, size_t nbins, double start, double end) -> std::shared_ptr< Scale >"},
+ { "uniqueEquiDivision", _wrap_uniqueEquiDivision, METH_VARARGS, "uniqueEquiDivision(std::string const & name, size_t nbins, double start, double end) -> std::unique_ptr< Scale >"},
{ "new_Frame", _wrap_new_Frame, METH_O, "new_Frame(std::vector< Scale const *,std::allocator< Scale const * > > && axes) -> Frame"},
{ "delete_Frame", _wrap_delete_Frame, METH_O, "delete_Frame(Frame self)"},
{ "Frame_clone", _wrap_Frame_clone, METH_O, "Frame_clone(Frame self) -> Frame"},
--
GitLab