diff --git a/Core/Scan/UnitConverter1D.cpp b/Core/Scan/UnitConverter1D.cpp
index b214b42d4f1b580c80a1f4fe90d5dab65454ffad..7155695e798e70047464139b724613751aaa09bc 100644
--- a/Core/Scan/UnitConverter1D.cpp
+++ b/Core/Scan/UnitConverter1D.cpp
@@ -67,24 +67,24 @@ size_t UnitConverter1D::dimension() const
     return 1u;
 }
 
-double UnitConverter1D::calculateMin(size_t i_axis, Axes::Units units_type) const
+double UnitConverter1D::calculateMin(size_t i_axis, Axes::Units units) const
 {
     ASSERT(i_axis == 0);
-    units_type = substituteDefaultUnits(units_type);
-    if (units_type == Axes::Units::NBINS)
+    units = substituteDefaultUnits(units);
+    if (units == Axes::Units::NBINS)
         return 0.0;
-    auto translator = getTraslatorTo(units_type);
+    auto translator = getTraslatorTo(units);
     return translator(coordinateAxis()->binCenter(0));
 }
 
-double UnitConverter1D::calculateMax(size_t i_axis, Axes::Units units_type) const
+double UnitConverter1D::calculateMax(size_t i_axis, Axes::Units units) const
 {
     ASSERT(i_axis == 0);
-    units_type = substituteDefaultUnits(units_type);
+    units = substituteDefaultUnits(units);
     auto coordinate_axis = coordinateAxis();
-    if (units_type == Axes::Units::NBINS)
+    if (units == Axes::Units::NBINS)
         return static_cast<double>(coordinate_axis->size());
-    auto translator = getTraslatorTo(units_type);
+    auto translator = getTraslatorTo(units);
     return translator(coordinate_axis->binCenter(coordinate_axis->size() - 1));
 }
 
@@ -170,9 +170,9 @@ std::vector<std::map<Axes::Units, std::string>> UnitConverterConvSpec::createNam
     return {AxisNames::specAxis};
 }
 
-std::function<double(double)> UnitConverterConvSpec::getTraslatorFrom(Axes::Units units_type) const
+std::function<double(double)> UnitConverterConvSpec::getTraslatorFrom(Axes::Units units) const
 {
-    switch (units_type) {
+    switch (units) {
     case Axes::Units::RADIANS:
         return [](double value) { return value; };
     case Axes::Units::DEGREES:
@@ -185,9 +185,9 @@ std::function<double(double)> UnitConverterConvSpec::getTraslatorFrom(Axes::Unit
     }
 }
 
-std::function<double(double)> UnitConverterConvSpec::getTraslatorTo(Axes::Units units_type) const
+std::function<double(double)> UnitConverterConvSpec::getTraslatorTo(Axes::Units units) const
 {
-    switch (units_type) {
+    switch (units) {
     case Axes::Units::RADIANS:
         return [](double value) { return value; };
     case Axes::Units::DEGREES:
@@ -249,9 +249,9 @@ std::vector<std::map<Axes::Units, std::string>> UnitConverterQSpec::createNameMa
 }
 
 //! Returns translating functional (inv. nm --> desired units)
-std::function<double(double)> UnitConverterQSpec::getTraslatorTo(Axes::Units units_type) const
+std::function<double(double)> UnitConverterQSpec::getTraslatorTo(Axes::Units units) const
 {
-    switch (units_type) {
+    switch (units) {
     case Axes::Units::QSPACE:
         return [](double value) { return value; };
     case Axes::Units::RQ4:
diff --git a/Core/Scan/UnitConverter1D.h b/Core/Scan/UnitConverter1D.h
index 1c86f80cc6d0671ff2653a1218249af57973a0be..d2257a6a2353d0407fc0244fee40b6c463e75fee 100644
--- a/Core/Scan/UnitConverter1D.h
+++ b/Core/Scan/UnitConverter1D.h
@@ -44,10 +44,10 @@ public:
     size_t dimension() const override;
 
     //! Calculates minimum on-axis value in given units.
-    double calculateMin(size_t i_axis, Axes::Units units_type) const override;
+    double calculateMin(size_t i_axis, Axes::Units units) const override;
 
     //! Calculates maximum on-axis value in given units.
-    double calculateMax(size_t i_axis, Axes::Units units_type) const override;
+    double calculateMax(size_t i_axis, Axes::Units units) const override;
 
     //! Creates axis in converted units.
     std::unique_ptr<IAxis> createConvertedAxis(size_t i_axis, Axes::Units units) const override;
@@ -58,7 +58,7 @@ public:
 
 protected:
     //! Returns translating functional (rads --> output units)
-    virtual std::function<double(double)> getTraslatorTo(Axes::Units units_type) const = 0;
+    virtual std::function<double(double)> getTraslatorTo(Axes::Units units) const = 0;
 
     virtual const IAxis* coordinateAxis() const = 0;
 };
@@ -90,10 +90,10 @@ protected:
     std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
 
     //! Returns translating functional (input units --> rads)
-    std::function<double(double)> getTraslatorFrom(Axes::Units units_type) const;
+    std::function<double(double)> getTraslatorFrom(Axes::Units units) const;
 
     //! Returns translating functional (rads --> desired units)
-    std::function<double(double)> getTraslatorTo(Axes::Units units_type) const override;
+    std::function<double(double)> getTraslatorTo(Axes::Units units) const override;
 
     const IAxis* coordinateAxis() const override { return m_axis.get(); }
 
@@ -125,7 +125,7 @@ protected:
     std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
 
     //! Returns translating functional (inv. nm --> desired units)
-    std::function<double(double)> getTraslatorTo(Axes::Units units_type) const override;
+    std::function<double(double)> getTraslatorTo(Axes::Units units) const override;
 
     const IAxis* coordinateAxis() const override { return m_axis.get(); }
 
diff --git a/Device/Detector/UnitConverter2D.cpp b/Device/Detector/UnitConverter2D.cpp
index 411dead2e0967926c367d5430ef9b53a25f8a36c..4c49d007d89a766e8682407c586b081ace2a6a17 100644
--- a/Device/Detector/UnitConverter2D.cpp
+++ b/Device/Detector/UnitConverter2D.cpp
@@ -54,24 +54,24 @@ void UnitConverterSimple::addAxisData(std::string name, double min, double max,
     m_axis_data_table.emplace_back(AxisData{name, min, max, default_units, nbins});
 }
 
-double UnitConverterSimple::calculateMin(size_t i_axis, Axes::Units units_type) const
+double UnitConverterSimple::calculateMin(size_t i_axis, Axes::Units units) const
 {
     ASSERT(i_axis < dimension());
-    units_type = substituteDefaultUnits(units_type);
+    units = substituteDefaultUnits(units);
     const auto& axis_data = m_axis_data_table[i_axis];
-    if (units_type == Axes::Units::NBINS)
+    if (units == Axes::Units::NBINS)
         return 0.0;
-    return calculateValue(i_axis, units_type, axis_data.min);
+    return calculateValue(i_axis, units, axis_data.min);
 }
 
-double UnitConverterSimple::calculateMax(size_t i_axis, Axes::Units units_type) const
+double UnitConverterSimple::calculateMax(size_t i_axis, Axes::Units units) const
 {
     ASSERT(i_axis < dimension());
-    units_type = substituteDefaultUnits(units_type);
+    units = substituteDefaultUnits(units);
     const auto& axis_data = m_axis_data_table[i_axis];
-    if (units_type == Axes::Units::NBINS)
+    if (units == Axes::Units::NBINS)
         return static_cast<double>(axis_data.nbins);
-    return calculateValue(i_axis, units_type, axis_data.max);
+    return calculateValue(i_axis, units, axis_data.max);
 }
 
 size_t UnitConverterSimple::axisSize(size_t i_axis) const
@@ -166,9 +166,9 @@ SphericalConverter::SphericalConverter(const SphericalConverter& other) : UnitCo
 {
 }
 
-double SphericalConverter::calculateValue(size_t i_axis, Axes::Units units_type, double value) const
+double SphericalConverter::calculateValue(size_t i_axis, Axes::Units units, double value) const
 {
-    switch (units_type) {
+    switch (units) {
     case Axes::Units::RADIANS:
         return value;
     case Axes::Units::DEGREES:
@@ -247,10 +247,10 @@ RectangularConverter::RectangularConverter(const RectangularConverter& other)
 {
 }
 
-double RectangularConverter::calculateValue(size_t i_axis, Axes::Units units_type,
+double RectangularConverter::calculateValue(size_t i_axis, Axes::Units units,
                                             double value) const
 {
-    if (units_type == Axes::Units::MM)
+    if (units == Axes::Units::MM)
         return value;
     const auto k00 = m_detector_pixel->getPosition(0.0, 0.0);
     const auto k01 = m_detector_pixel->getPosition(0.0, 1.0);
@@ -258,7 +258,7 @@ double RectangularConverter::calculateValue(size_t i_axis, Axes::Units units_typ
     const auto& max_pos = i_axis == 0 ? k10 : k01; // position of max along given axis
     const double shift = value - m_axis_data_table[i_axis].min;
     const auto k_f = normalizeToWavelength(k00 + shift * (max_pos - k00).unit());
-    switch (units_type) {
+    switch (units) {
     case Axes::Units::RADIANS:
         return axisAngle(i_axis, k_f);
     case Axes::Units::DEGREES:
@@ -342,9 +342,9 @@ OffSpecularConverter::OffSpecularConverter(const OffSpecularConverter& other)
 {
 }
 
-double OffSpecularConverter::calculateValue(size_t, Axes::Units units_type, double value) const
+double OffSpecularConverter::calculateValue(size_t, Axes::Units units, double value) const
 {
-    switch (units_type) {
+    switch (units) {
     case Axes::Units::RADIANS:
         return value;
     case Axes::Units::DEGREES:
@@ -425,13 +425,13 @@ DepthProbeConverter::DepthProbeConverter(const DepthProbeConverter& other)
 {
 }
 
-double DepthProbeConverter::calculateValue(size_t i_axis, Axes::Units units_type,
+double DepthProbeConverter::calculateValue(size_t i_axis, Axes::Units units,
                                            double value) const
 {
-    checkUnits(units_type);
+    checkUnits(units);
     if (i_axis == 1)
         return value; // unit conversions are not applied to sample position axis
-    switch (units_type) {
+    switch (units) {
     case Axes::Units::DEGREES:
         return Units::rad2deg(value);
     case Axes::Units::QSPACE:
@@ -446,10 +446,10 @@ std::vector<std::map<Axes::Units, std::string>> DepthProbeConverter::createNameM
     return {AxisNames::specAxis, AxisNames::sampleDepthAxis};
 }
 
-void DepthProbeConverter::checkUnits(Axes::Units units_type) const
+void DepthProbeConverter::checkUnits(Axes::Units units) const
 {
     const auto& available_units = availableUnits();
-    if (std::find(available_units.begin(), available_units.end(), units_type)
+    if (std::find(available_units.begin(), available_units.end(), units)
         == available_units.cend())
         throwUnitsError("DepthProbeConverter::checkUnits", available_units);
 }
diff --git a/Device/Detector/UnitConverter2D.h b/Device/Detector/UnitConverter2D.h
index 0e47eb9935c30c00bb1406b4fc3f76c01e4898d5..4231eece938362161fd3bd986c0854864bab8be7 100644
--- a/Device/Detector/UnitConverter2D.h
+++ b/Device/Detector/UnitConverter2D.h
@@ -41,8 +41,8 @@ public:
 
     virtual size_t dimension() const override;
 
-    double calculateMin(size_t i_axis, Axes::Units units_type) const override;
-    double calculateMax(size_t i_axis, Axes::Units units_type) const override;
+    double calculateMin(size_t i_axis, Axes::Units units) const override;
+    double calculateMax(size_t i_axis, Axes::Units units) const override;
     size_t axisSize(size_t i_axis) const override;
 
     //! Returns the list of all available units
@@ -76,7 +76,7 @@ protected:
     double m_phi_i;
 
 private:
-    virtual double calculateValue(size_t i_axis, Axes::Units units_type, double value) const = 0;
+    virtual double calculateValue(size_t i_axis, Axes::Units units, double value) const = 0;
 };
 
 //! IUnitConverter class that handles the unit translations for spherical detectors
@@ -98,7 +98,7 @@ public:
 
 private:
     SphericalConverter(const SphericalConverter& other);
-    double calculateValue(size_t i_axis, Axes::Units units_type, double value) const override;
+    double calculateValue(size_t i_axis, Axes::Units units, double value) const override;
     std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
 };
 
@@ -120,7 +120,7 @@ public:
 
 private:
     RectangularConverter(const RectangularConverter& other);
-    double calculateValue(size_t i_axis, Axes::Units units_type, double value) const override;
+    double calculateValue(size_t i_axis, Axes::Units units, double value) const override;
     std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
     kvector_t normalizeToWavelength(kvector_t vector) const;
     double axisAngle(size_t i_axis, kvector_t k_f) const;
@@ -143,7 +143,7 @@ public:
 
 private:
     OffSpecularConverter(const OffSpecularConverter& other);
-    double calculateValue(size_t i_axis, Axes::Units units_type, double value) const override;
+    double calculateValue(size_t i_axis, Axes::Units units, double value) const override;
     std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
     void addDetectorYAxis(const IDetector2D& detector);
 };
@@ -166,9 +166,9 @@ public:
 
 private:
     DepthProbeConverter(const DepthProbeConverter& other);
-    double calculateValue(size_t, Axes::Units units_type, double value) const override;
+    double calculateValue(size_t, Axes::Units units, double value) const override;
     std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
-    void checkUnits(Axes::Units units_type) const;
+    void checkUnits(Axes::Units units) const;
 };
 
 #endif // BORNAGAIN_DEVICE_DETECTOR_SIMPLEUNITCONVERTERS_H
diff --git a/Device/Unit/IUnitConverter.cpp b/Device/Unit/IUnitConverter.cpp
index c025796e89218193ce581a2839b7f05caa61a3f3..b4805e7d020efd8151f1c86b6293e9ce8fccc5ca 100644
--- a/Device/Unit/IUnitConverter.cpp
+++ b/Device/Unit/IUnitConverter.cpp
@@ -30,7 +30,7 @@ std::unique_ptr<OutputData<double>> IUnitConverter::createOutputData(Axes::Units
     return result;
 }
 
-std::string IUnitConverter::axisName(size_t i_axis, const Axes::Units& units_type) const
+std::string IUnitConverter::axisName(size_t i_axis, const Axes::Units& units) const
 {
     const auto& name_maps = createNameMaps();
     if (name_maps.size() <= i_axis)
@@ -38,7 +38,7 @@ std::string IUnitConverter::axisName(size_t i_axis, const Axes::Units& units_typ
                                  "is smaller or equal to the axis index"
                                  + std::to_string(static_cast<int>(i_axis)));
     const auto& name_map = name_maps[i_axis];
-    const auto& it = name_map.find(substituteDefaultUnits(units_type));
+    const auto& it = name_map.find(substituteDefaultUnits(units));
     if (it == name_map.cend())
         throwUnitsError("IUnitConverter::axisName", availableUnits());
     return it->second;
diff --git a/Device/Unit/IUnitConverter.h b/Device/Unit/IUnitConverter.h
index 72a633f31de614ca45e57e21a4315644f7ced607..3fd0e1740e55fbc30b87d3e4baa9e86ba7b228bf 100644
--- a/Device/Unit/IUnitConverter.h
+++ b/Device/Unit/IUnitConverter.h
@@ -51,11 +51,11 @@ public:
 
     virtual size_t dimension() const = 0;
 
-    virtual double calculateMin(size_t i_axis, Axes::Units units_type) const = 0;
-    virtual double calculateMax(size_t i_axis, Axes::Units units_type) const = 0;
+    virtual double calculateMin(size_t i_axis, Axes::Units units) const = 0;
+    virtual double calculateMax(size_t i_axis, Axes::Units units) const = 0;
     virtual size_t axisSize(size_t i_axis) const = 0;
 
-    std::string axisName(size_t i_axis, const Axes::Units& units_type = Axes::Units::DEFAULT) const;
+    std::string axisName(size_t i_axis, const Axes::Units& units = Axes::Units::DEFAULT) const;
 
     virtual std::vector<Axes::Units> availableUnits() const = 0;
     virtual Axes::Units defaultUnits() const = 0;
diff --git a/auto/Wrap/doxygenCore.i b/auto/Wrap/doxygenCore.i
index 41c715f7ba3436b096fba6c071885274d0ee8285..bc97c0bad6fd1dd830a928e55284c7a58e0149d6 100644
--- a/auto/Wrap/doxygenCore.i
+++ b/auto/Wrap/doxygenCore.i
@@ -2165,12 +2165,12 @@ C++ includes: UnitConverter1D.h
 Returns dimensionality of converted canvas. 
 ";
 
-%feature("docstring")  UnitConverter1D::calculateMin "double UnitConverter1D::calculateMin(size_t i_axis, Axes::Units units_type) const override
+%feature("docstring")  UnitConverter1D::calculateMin "double UnitConverter1D::calculateMin(size_t i_axis, Axes::Units units) const override
 
 Calculates minimum on-axis value in given units. 
 ";
 
-%feature("docstring")  UnitConverter1D::calculateMax "double UnitConverter1D::calculateMax(size_t i_axis, Axes::Units units_type) const override
+%feature("docstring")  UnitConverter1D::calculateMax "double UnitConverter1D::calculateMax(size_t i_axis, Axes::Units units) const override
 
 Calculates maximum on-axis value in given units. 
 ";
@@ -2290,9 +2290,6 @@ C++ includes: VarianceFunctions.h
 ";
 
 
-// File: namespace_0d100.xml
-
-
 // File: namespace_0d15.xml
 
 
@@ -2335,6 +2332,9 @@ C++ includes: VarianceFunctions.h
 // File: namespace_0d94.xml
 
 
+// File: namespace_0d98.xml
+
+
 // File: namespaceExportToPython.xml
 %feature("docstring")  ExportToPython::sampleCode "std::string ExportToPython::sampleCode(const MultiLayer &multilayer)
 ";
@@ -2682,13 +2682,6 @@ GISAS simulation with an extra long wavelength.
 ";
 
 
-// File: namespaceUnitConverterUtils.xml
-%feature("docstring")  UnitConverterUtils::createConverterForGISAS "std::unique_ptr< IUnitConverter > UnitConverterUtils::createConverterForGISAS(const Instrument &instrument)
-
-Helper factory function to use in  GISASSimulation. Depending on the type of detector, returns either RectangularConverter or SphericalConverter. 
-";
-
-
 // File: ComputationStatus_8h.xml
 
 
@@ -2977,12 +2970,6 @@ Helper factory function to use in  GISASSimulation. Depending on the type of det
 // File: StandardSimulations_8h.xml
 
 
-// File: UnitConverterUtils_8cpp.xml
-
-
-// File: UnitConverterUtils_8h.xml
-
-
 // File: DepthProbeComputationTerm_8cpp.xml
 
 
diff --git a/auto/Wrap/doxygenDevice.i b/auto/Wrap/doxygenDevice.i
index ef9fd2fa7afca16cbf8ae7186d5f4ae37b2ace38..e6669fa20fe95af2d6b9b9ed1601155e05ba0619 100644
--- a/auto/Wrap/doxygenDevice.i
+++ b/auto/Wrap/doxygenDevice.i
@@ -1477,16 +1477,16 @@ Returns zero-valued output data array in specified units.
 %feature("docstring")  IUnitConverter::dimension "virtual size_t IUnitConverter::dimension() const =0
 ";
 
-%feature("docstring")  IUnitConverter::calculateMin "virtual double IUnitConverter::calculateMin(size_t i_axis, Axes::Units units_type) const =0
+%feature("docstring")  IUnitConverter::calculateMin "virtual double IUnitConverter::calculateMin(size_t i_axis, Axes::Units units) const =0
 ";
 
-%feature("docstring")  IUnitConverter::calculateMax "virtual double IUnitConverter::calculateMax(size_t i_axis, Axes::Units units_type) const =0
+%feature("docstring")  IUnitConverter::calculateMax "virtual double IUnitConverter::calculateMax(size_t i_axis, Axes::Units units) const =0
 ";
 
 %feature("docstring")  IUnitConverter::axisSize "virtual size_t IUnitConverter::axisSize(size_t i_axis) const =0
 ";
 
-%feature("docstring")  IUnitConverter::axisName "std::string IUnitConverter::axisName(size_t i_axis, const Axes::Units &units_type=Axes::Units::DEFAULT) const
+%feature("docstring")  IUnitConverter::axisName "std::string IUnitConverter::axisName(size_t i_axis, const Axes::Units &units=Axes::Units::DEFAULT) const
 ";
 
 %feature("docstring")  IUnitConverter::availableUnits "virtual std::vector<Axes::Units> IUnitConverter::availableUnits() const =0
@@ -2701,10 +2701,10 @@ C++ includes: UnitConverter2D.h
 %feature("docstring")  UnitConverterSimple::dimension "size_t UnitConverterSimple::dimension() const override
 ";
 
-%feature("docstring")  UnitConverterSimple::calculateMin "double UnitConverterSimple::calculateMin(size_t i_axis, Axes::Units units_type) const override
+%feature("docstring")  UnitConverterSimple::calculateMin "double UnitConverterSimple::calculateMin(size_t i_axis, Axes::Units units) const override
 ";
 
-%feature("docstring")  UnitConverterSimple::calculateMax "double UnitConverterSimple::calculateMax(size_t i_axis, Axes::Units units_type) const override
+%feature("docstring")  UnitConverterSimple::calculateMax "double UnitConverterSimple::calculateMax(size_t i_axis, Axes::Units units) const override
 ";
 
 %feature("docstring")  UnitConverterSimple::axisSize "size_t UnitConverterSimple::axisSize(size_t i_axis) const override