diff --git a/Base/Axis/FrameUtil.cpp b/Base/Axis/FrameUtil.cpp
index 07c85e2bad6dc945735773e9b999b6c023830495..42852fdf1f19911a0c0dda015b5cadd3c8139f57 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 97fd635a616113984df60ab45159e85d4f355d64..f149cd32f0b101b275716d850906669d323f862e 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 1202ba9e618ac13bd9b7892035e444a53a9b91db..ae5eeb753e94d1b9d05213cb5b3f219acf4744fc 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 e8bade0dadf627d39170a7917a53dfd03179823a..71f9bbebd54097ea97897de8e84695680ed7e1c4 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 76ecb4b619c600904abd4da7b38de6612361d239..339e0157655b9800dcdd39bedb57580bc14828d5 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 184d6584c710efeac7dc532c6cc185d6dbadc2c2..2f7a69fa2808d8a01e9f75728b4af3d88355c9b8 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 80133a7780dd58dcd7e5404d6b0bdb96a20ae740..cc2f6971e56cb657938dc7d788fcf6deff77a3f7 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 610957bbd56d98832edff0f3e2ac03eff2ecc626..dd496f1198aef28783baecc1d8ba30062c0e54c7 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 d98c6d33536788d44ec14afe25c7b2490603f77b..2189a780e4fc4682cefa1b175738672013d44497 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 8ee0725bb05fe4eb3b69ffdcf29e277f08b9ee86..9e338f288952d4d8ed3cdf63fc35f2e4e556a7d3 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 6a3a98fa51be2d3fbc84df32a0fbd126598c0dbd..698f8aac93bd3d09b5d2867a89f9209a16141ef6 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 0ff0513ac79cbf3f1a98e8acb3e628480a6cfc25..183f4aa5379cc802e0fd0909c501f8c8ff3c8453 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 bdb3a9c9cb6ba91666c3df6e5d9a61afd15986c3..61e1368864f7431f9f83ab93c09d53b28bb2db7b 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 3cae554ca0f199e458a8780fcb35c98556363f46..f1056314822ea1b8b12043f381aa8680f7bd52d0 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 cbbbcc47d5a1cef5d9773922a103b3a56bffb577..213d4373dbf4314a0274ebc29ec2e5e206904507 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 63656ba350c18ce23ffc88ed8d96bf211a5f6e04..d23732a91a6dbb668b9f6073f86228a6e6c8b6fd 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 e354b72d479d2a8b6530f0348b1b0dc0bf2571ec..d0864ad4dec8270fe3dbd8ec058f02c3894d7a0b 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 af325d05308da8a7f6ea86fdc3a47453277580c1..84c6c8c0681614ce39eefb7eb1de0cf7d960cd05 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 11ecc60c07a8bf66aeba677f30ea0fca4accea9e..a6b167dd80dbf7590b3a69f0e43ca06137978cf4 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 6dd43aa461ce1d31eeac3793e934d22e6639e50a..57b12a57cb6b72635ddb906329b328db2c3b8cd4 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 72470ef8e5d6bb3848e910e278a39a9d7a974000..f52622670f96218e143b354dcdc1ebc79238bf75 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 81958663d269d970ad0d3cb4e41ff72bc7e4dd19..4a4c723f7211c541defbdedbe9c70289b95c594c 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 aea5a228ffff55e08f3c5e11212528e9b11491f2..c8302b0cfc415964c47be542a041221fd52ff4a1 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 7f70b3384b18db35af7f6c2bc2326c5f3c095c5a..9d8b25abb1af2b8060f95102d6d1d0a9996d91b2 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 066a71f0ed4064daf4ebea254835d1a6c2ad2d01..b9a3c831979d35405012ba9a15950ef719d54101 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 488c411b458cf5ad817aa5df18adb36370784808..5e42c15df473146aed88029bd887c154789a516f 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 efbbc27225f193b6634a71cc47eedad6fa41535d..0f425061b58d60e648fc91974afb4341311c0cde 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 fae10293be558da92484094a29deac121ec8bf15..dc0f534702883eba0ac77ea147d7cb66d5ee3ea3 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 8ef6eb35347372b7315275f7d89e87f81196f757..c84b93d591a03d78117d6d1d81caa3663d33a575 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 5adae3a921d5b584310fa6dced1ed8361a2e05ac..a26d74fce50165cc874b2cc3e502ce911c907c44 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 536f7ac27b37a449159ddebcf94bde3b717d64de..37cf43824607f637d0928d6ed3cb0be53fbd3134 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 fc63c6bbb6b0ea54a26b45bca1852f5196c76dd8..a9752043290c6e2e8bca7241f4dbd8ead9a1feeb 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 66949bdc073a1ba3186679dddbc66c426515dded..ee9d5956b68c47e37a1b3c92874d0d579c4ff985 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 b629033f4ef56d98a9a1f75615533c9eb6fd312f..c31b57b271713e8370ed8f6d70aef63f15b3ca73 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 98ae91f2ee268621ec04ed57c60113bd64fe8133..688399bba55c86257f79ee910ba328c1c3093956 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 249a4e2d57a8aa9df4df789f6136ac26d9b3f199..11b78e91118762629bd7883ff119f86126f1c440 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 306dc0a18b9f3fefe6bdd5cc8b1f5b17d9939891..1b6e8fc67a3c88d2d36b0ada9f5cf5c6772340f8 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 1bf1b287dff52c681b8b925e4c6b470ad359fb1e..7d54ba9e0abe22be72f4e82021e1f09783d91498 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 8866f56fc846d99dc943ca72383a9c59d87f4de6..9d3759d16abd953c03292e534bf345c36b19f7b2 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 ed80585c9ddc25bc5e8f1f5fa30dc67bebd75207..ac0f72105cd67720f79697aa7889210a8eada791 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 d09946367128915f6d651d53625eb1c7be94e9ed..708ecc20ce234e661098d42316c677b0e673d779 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 55088d65de4b640e318365c87eb71cab9fb9bad5..c5f129ca6746e119602734826a070c74e4ca8c5f 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 0fa3c0133056baeaa40a9f13e218492796e7ef47..94dc1ef78359fd3183b8611cbe875f2f36eeddca 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 08fad1dff110835497ce86c37f1bb6bec93a9e22..acc5ef9aad1fa0cf028955975a89346cad9806b7 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 62d66f1543f774817a199f18e3ea42fc5627bb14..9cbe92c59052aa543fb39937dc907dc9af5ab6df 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 ec512bd4d90974be876f709614ded5fb2da72806..30330c84984f952294197f06f269354af94f5179 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 afbf202c6aa1dd885c9650f8750e952af7043b02..0db85eb8a2d86a3c3b969ada2c3455544371531c 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 e40d6a64cc49765b0d8038fe4d2fd1ab054fc696..355df452b35d25affd9bcb7b0b1a046ceea56289 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 15ccd226323988899e840759cc2df055998bc05b..28604de2093500ef18a526607395951a76bb6121 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 a9e5e4ebde2f7d6510665dc23f019736131b26d7..118942c7fe6c3120002c0e1e7cb664717db83ec1 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 28dbe5bdaedc44188215708e914670b42b6a3214..3aaf5600d388c575a298b50219522575779a4f1e 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 4d65eb1a26f9ec983fee11b9135411bdbd88a48a..3af85d7be243fed55abb902f468d1e3d99986f63 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 b8e82850c774dbac23d01e8b5e88381d48138d7d..488817393cd9626be2a6411a70f35aa670bed315 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"},