diff --git a/Core/Export/SimulationToPython.cpp b/Core/Export/SimulationToPython.cpp
index 5a37f9069122f645e8e1f874fac26904a7b7f2f8..4be30125996d8ce70545c8aeb2d2d58f0ed5a5a0 100644
--- a/Core/Export/SimulationToPython.cpp
+++ b/Core/Export/SimulationToPython.cpp
@@ -43,9 +43,9 @@ namespace {
//! Returns a function that converts a coordinate to a Python code snippet with appropiate unit
std::function<std::string(double)> printFunc(const IDetector* detector)
{
- if (detector->defaultAxesUnits() == Axes::Units::MM)
+ if (detector->defaultAxesUnits() == Axes::Coords::MM)
return pyfmt::printDouble;
- if (detector->defaultAxesUnits() == Axes::Units::RADIANS)
+ if (detector->defaultAxesUnits() == Axes::Coords::RADIANS)
return pyfmt::printDegrees;
throw std::runtime_error("SimulationToPython::defineMasks() -> Error. Unknown detector units.");
}
diff --git a/Core/Fitting/ObjectiveMetric.cpp b/Core/Fitting/ObjectiveMetric.cpp
index 583ecc45d071a7db0cbd99ea0c15ee716126fb9e..83d95c71038952ce4cfe5b0aac02a926c3557752 100644
--- a/Core/Fitting/ObjectiveMetric.cpp
+++ b/Core/Fitting/ObjectiveMetric.cpp
@@ -232,8 +232,8 @@ double RQ4Metric::compute(const SimDataPair& data_pair, bool use_weights) const
return Chi2Metric::compute(data_pair, use_weights);
// fetching data in RQ4 form
- auto sim_data = data_pair.simulationResult().data(Axes::Units::RQ4);
- auto exp_data = data_pair.experimentalData().data(Axes::Units::RQ4);
+ auto sim_data = data_pair.simulationResult().data(Axes::Coords::RQ4);
+ auto exp_data = data_pair.experimentalData().data(Axes::Coords::RQ4);
return computeFromArrays(sim_data->getRawDataVector(), exp_data->getRawDataVector(),
data_pair.user_weights_array());
diff --git a/Core/Scan/UnitConverter1D.cpp b/Core/Scan/CoordSystem1D.cpp
similarity index 83%
rename from Core/Scan/UnitConverter1D.cpp
rename to Core/Scan/CoordSystem1D.cpp
index 4ad367c62baf888fe18d3096cf2d5caccf1a8f69..dab4c5a8d479e0f519e58fbbddb0bf1440d3dccf 100644
--- a/Core/Scan/UnitConverter1D.cpp
+++ b/Core/Scan/CoordSystem1D.cpp
@@ -2,7 +2,7 @@
//
// BornAgain: simulate and fit reflection and scattering
//
-//! @file Core/Scan/UnitConverter1D.cpp
+//! @file Core/Scan/CoordSystem1D.cpp
//! @brief Implements CoordSystem1D class and derived classes.
//!
//! @homepage http://www.bornagainproject.org
@@ -69,40 +69,40 @@ size_t CoordSystem1D::axisSize(size_t i_axis) const
return coordinateAxis()->size();
}
-double CoordSystem1D::calculateMin(size_t i_axis, Axes::Units units) const
+double CoordSystem1D::calculateMin(size_t i_axis, Axes::Coords units) const
{
ASSERT(i_axis == 0);
units = substituteDefaultUnits(units);
- if (units == Axes::Units::NBINS)
+ if (units == Axes::Coords::NBINS)
return 0.0;
auto translator = getTraslatorTo(units);
return translator(coordinateAxis()->binCenter(0));
}
-double CoordSystem1D::calculateMax(size_t i_axis, Axes::Units units) const
+double CoordSystem1D::calculateMax(size_t i_axis, Axes::Coords units) const
{
ASSERT(i_axis == 0);
units = substituteDefaultUnits(units);
const IAxis *const coordinate_axis = coordinateAxis();
- if (units == Axes::Units::NBINS)
+ if (units == Axes::Coords::NBINS)
return static_cast<double>(coordinate_axis->size());
auto translator = getTraslatorTo(units);
return translator(coordinate_axis->binCenter(coordinate_axis->size() - 1));
}
std::unique_ptr<const IAxis> CoordSystem1D::createConvertedAxis(size_t i_axis,
- Axes::Units units) const
+ Axes::Coords units) const
{
ASSERT(i_axis == 0);
units = substituteDefaultUnits(units);
- if (units == Axes::Units::NBINS)
+ if (units == Axes::Coords::NBINS)
return std::make_unique<FixedBinAxis>(axisName(0, units), coordinateAxis()->size(),
calculateMin(0, units), calculateMax(0, units));
return createTranslatedAxis(*coordinateAxis(), getTraslatorTo(units), axisName(0, units));
}
std::unique_ptr<OutputData<double>>
-CoordSystem1D::createConvertedData(const OutputData<double>& data, Axes::Units units) const
+CoordSystem1D::createConvertedData(const OutputData<double>& data, Axes::Coords units) const
{
ASSERT(data.rank() == 1);
@@ -110,7 +110,7 @@ CoordSystem1D::createConvertedData(const OutputData<double>& data, Axes::Units u
auto q_axis = createConvertedAxis(0, units);
result->addAxis(*q_axis);
- if (units != Axes::Units::RQ4) {
+ if (units != Axes::Coords::RQ4) {
result->setRawDataVector(data.getRawDataVector());
return result;
}
@@ -126,7 +126,7 @@ CoordSystem1D::createConvertedData(const OutputData<double>& data, Axes::Units u
// ************************************************************************************************
AngularReflectometryConverter::AngularReflectometryConverter(const Beam& beam, const IAxis& axis,
- Axes::Units axis_units)
+ Axes::Coords axis_units)
: m_wavelength(beam.wavelength())
, m_axis(createTranslatedAxis(axis, getTraslatorFrom(axis_units), axisName(0, axis_units)))
@@ -147,10 +147,10 @@ AngularReflectometryConverter* AngularReflectometryConverter::clone() const
return new AngularReflectometryConverter(*this);
}
-std::vector<Axes::Units> AngularReflectometryConverter::availableUnits() const
+std::vector<Axes::Coords> AngularReflectometryConverter::availableUnits() const
{
- return {Axes::Units::NBINS, Axes::Units::RADIANS, Axes::Units::DEGREES, Axes::Units::QSPACE,
- Axes::Units::RQ4};
+ return {Axes::Coords::NBINS, Axes::Coords::RADIANS, Axes::Coords::DEGREES, Axes::Coords::QSPACE,
+ Axes::Coords::RQ4};
}
AngularReflectometryConverter::AngularReflectometryConverter(
@@ -159,38 +159,38 @@ AngularReflectometryConverter::AngularReflectometryConverter(
{
}
-std::vector<std::map<Axes::Units, std::string>>
+std::vector<std::map<Axes::Coords, std::string>>
AngularReflectometryConverter::createNameMaps() const
{
return {AxisNames::specAxis};
}
std::function<double(double)>
-AngularReflectometryConverter::getTraslatorFrom(Axes::Units units) const
+AngularReflectometryConverter::getTraslatorFrom(Axes::Coords units) const
{
switch (units) {
- case Axes::Units::RADIANS:
+ case Axes::Coords::RADIANS:
return [](double value) { return value; };
- case Axes::Units::DEGREES:
+ case Axes::Coords::DEGREES:
return [](double value) { return Units::deg2rad(value); };
- case Axes::Units::QSPACE:
+ case Axes::Coords::QSPACE:
return [this](double value) { return getInvQ(m_wavelength, value); };
default:
throwUnitsError("AngularReflectometryConverter::getTraslatorFrom",
- {Axes::Units::RADIANS, Axes::Units::DEGREES, Axes::Units::QSPACE});
+ {Axes::Coords::RADIANS, Axes::Coords::DEGREES, Axes::Coords::QSPACE});
}
}
-std::function<double(double)> AngularReflectometryConverter::getTraslatorTo(Axes::Units units) const
+std::function<double(double)> AngularReflectometryConverter::getTraslatorTo(Axes::Coords units) const
{
switch (units) {
- case Axes::Units::RADIANS:
+ case Axes::Coords::RADIANS:
return [](double value) { return value; };
- case Axes::Units::DEGREES:
+ case Axes::Coords::DEGREES:
return [](double value) { return Units::rad2deg(value); };
- case Axes::Units::QSPACE:
+ case Axes::Coords::QSPACE:
return [wl = m_wavelength](double value) { return getQ(wl, value); };
- case Axes::Units::RQ4:
+ case Axes::Coords::RQ4:
return [wl = m_wavelength](double value) { return getQ(wl, value); };
default:
throwUnitsError("AngularReflectometryConverter::getTraslatorTo", availableUnits());
@@ -215,9 +215,9 @@ WavenumberReflectometryConverter* WavenumberReflectometryConverter::clone() cons
}
//! Returns the list of all available units
-std::vector<Axes::Units> WavenumberReflectometryConverter::availableUnits() const
+std::vector<Axes::Coords> WavenumberReflectometryConverter::availableUnits() const
{
- return {Axes::Units::NBINS, Axes::Units::QSPACE, Axes::Units::RQ4};
+ return {Axes::Coords::NBINS, Axes::Coords::QSPACE, Axes::Coords::RQ4};
}
WavenumberReflectometryConverter::WavenumberReflectometryConverter(
@@ -227,7 +227,7 @@ WavenumberReflectometryConverter::WavenumberReflectometryConverter(
}
//! Creates name map for axis in various units
-std::vector<std::map<Axes::Units, std::string>>
+std::vector<std::map<Axes::Coords, std::string>>
WavenumberReflectometryConverter::createNameMaps() const
{
return {AxisNames::specAxisQ};
@@ -235,12 +235,12 @@ WavenumberReflectometryConverter::createNameMaps() const
//! Returns translating functional (inv. nm --> desired units)
std::function<double(double)>
-WavenumberReflectometryConverter::getTraslatorTo(Axes::Units units) const
+WavenumberReflectometryConverter::getTraslatorTo(Axes::Coords units) const
{
switch (units) {
- case Axes::Units::QSPACE:
+ case Axes::Coords::QSPACE:
return [](double value) { return value; };
- case Axes::Units::RQ4:
+ case Axes::Coords::RQ4:
return [](double value) { return value; };
default:
throwUnitsError("WavenumberReflectometryConverter::getTraslatorTo", availableUnits());
diff --git a/Core/Scan/UnitConverter1D.h b/Core/Scan/CoordSystem1D.h
similarity index 74%
rename from Core/Scan/UnitConverter1D.h
rename to Core/Scan/CoordSystem1D.h
index d4c6ca96778093a4be6197aba4f3c80c7a5271cd..c32570c8163245b3f2862d6fe7e17adbebbef38e 100644
--- a/Core/Scan/UnitConverter1D.h
+++ b/Core/Scan/CoordSystem1D.h
@@ -2,7 +2,7 @@
//
// BornAgain: simulate and fit reflection and scattering
//
-//! @file Core/Scan/UnitConverter1D.h
+//! @file Core/Scan/CoordSystem1D.h
//! @brief Defines CoordSystem1D class and derived classes.
//!
//! @homepage http://www.bornagainproject.org
@@ -17,8 +17,8 @@
#endif
#ifndef USER_API
-#ifndef BORNAGAIN_CORE_SCAN_UNITCONVERTER1D_H
-#define BORNAGAIN_CORE_SCAN_UNITCONVERTER1D_H
+#ifndef BORNAGAIN_CORE_SCAN_COORDSYSTEM1D_H
+#define BORNAGAIN_CORE_SCAN_COORDSYSTEM1D_H
#include "Device/Unit/ICoordSystem.h"
@@ -49,22 +49,22 @@ public:
size_t axisSize(size_t i_axis) const override;
//! Calculates minimum on-axis value in given units.
- double calculateMin(size_t i_axis, Axes::Units units) const override;
+ double calculateMin(size_t i_axis, Axes::Coords units) const override;
//! Calculates maximum on-axis value in given units.
- double calculateMax(size_t i_axis, Axes::Units units) const override;
+ double calculateMax(size_t i_axis, Axes::Coords units) const override;
//! Creates axis in converted units.
std::unique_ptr<const IAxis> createConvertedAxis(size_t i_axis,
- Axes::Units units) const override;
+ Axes::Coords units) const override;
//! Creates OutputData array in converter units.
std::unique_ptr<OutputData<double>> createConvertedData(const OutputData<double>& data,
- Axes::Units units) const override;
+ Axes::Coords units) const override;
protected:
//! Returns translating functional (rads --> output units)
- virtual std::function<double(double)> getTraslatorTo(Axes::Units units) const = 0;
+ virtual std::function<double(double)> getTraslatorTo(Axes::Coords units) const = 0;
virtual const IAxis* coordinateAxis() const = 0;
};
@@ -75,30 +75,30 @@ class AngularReflectometryConverter : public CoordSystem1D {
public:
//! Constructs the object for unit conversion.
AngularReflectometryConverter(const Beam& beam, const IAxis& axis,
- Axes::Units axis_units = Axes::Units::RADIANS);
+ Axes::Coords axis_units = Axes::Coords::RADIANS);
AngularReflectometryConverter(const AngularSpecScan& handler);
~AngularReflectometryConverter() override;
AngularReflectometryConverter* clone() const override;
//! Returns the list of all available units
- std::vector<Axes::Units> availableUnits() const override;
+ std::vector<Axes::Coords> availableUnits() const override;
//! Returns default units to convert to.
- Axes::Units defaultUnits() const override { return Axes::Units::DEGREES; }
+ Axes::Coords defaultUnits() const override { return Axes::Coords::DEGREES; }
private:
AngularReflectometryConverter(const AngularReflectometryConverter& other);
//! Creates name map for axis in various units
- std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
+ std::vector<std::map<Axes::Coords, std::string>> createNameMaps() const override;
//! Returns translating functional (input units --> rads)
- std::function<double(double)> getTraslatorFrom(Axes::Units units) const;
+ std::function<double(double)> getTraslatorFrom(Axes::Coords units) const;
//! Returns translating functional (rads --> desired units)
- std::function<double(double)> getTraslatorTo(Axes::Units units) const override;
+ std::function<double(double)> getTraslatorTo(Axes::Coords units) const override;
const IAxis* coordinateAxis() const override { return m_axis.get(); }
@@ -116,24 +116,24 @@ public:
WavenumberReflectometryConverter* clone() const override;
//! Returns the list of all available units
- std::vector<Axes::Units> availableUnits() const override;
+ std::vector<Axes::Coords> availableUnits() const override;
//! Returns default units to convert to.
- Axes::Units defaultUnits() const override { return Axes::Units::QSPACE; }
+ Axes::Coords defaultUnits() const override { return Axes::Coords::QSPACE; }
private:
WavenumberReflectometryConverter(const WavenumberReflectometryConverter& other);
//! Creates name map for axis in various units
- std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
+ std::vector<std::map<Axes::Coords, std::string>> createNameMaps() const override;
//! Returns translating functional (inv. nm --> desired units)
- std::function<double(double)> getTraslatorTo(Axes::Units units) const override;
+ std::function<double(double)> getTraslatorTo(Axes::Coords units) const override;
const IAxis* coordinateAxis() const override { return m_axis.get(); }
std::unique_ptr<const IAxis> m_axis; //!< qz values (in inv. nm).
};
-#endif // BORNAGAIN_CORE_SCAN_UNITCONVERTER1D_H
+#endif // BORNAGAIN_CORE_SCAN_COORDSYSTEM1D_H
#endif // USER_API
diff --git a/Device/Detector/IDetector.h b/Device/Detector/IDetector.h
index c6b71924ae2200af10a404b68e88a35b436c5a85..d383f4536f2159447968d66d305f0d89fb508565 100644
--- a/Device/Detector/IDetector.h
+++ b/Device/Detector/IDetector.h
@@ -95,7 +95,7 @@ public:
createDetectorIntensity(const std::vector<SimulationElement>& elements) const;
//! Return default axes units
- virtual Axes::Units defaultAxesUnits() const = 0;
+ virtual Axes::Coords defaultAxesUnits() const = 0;
//! Returns number of simulation elements.
size_t numberOfSimulationElements() const;
diff --git a/Device/Detector/RectangularDetector.h b/Device/Detector/RectangularDetector.h
index f0207732788d306efc8f1d0ff342eba42d633a45..51b684dbf7a48e4ff428e187016363246086630e 100644
--- a/Device/Detector/RectangularDetector.h
+++ b/Device/Detector/RectangularDetector.h
@@ -73,7 +73,7 @@ public:
EDetectorArrangement getDetectorArrangment() const;
//! return default axes units
- virtual Axes::Units defaultAxesUnits() const override { return Axes::Units::MM; }
+ virtual Axes::Coords defaultAxesUnits() const override { return Axes::Coords::MM; }
RectangularPixel* regionOfInterestPixel() const;
diff --git a/Device/Detector/SpecularDetector1D.h b/Device/Detector/SpecularDetector1D.h
index 90fecfb6cdeb7911ae5cdee8b336b62b0acb8114..ee03814f36b92836f7d6f4e0a27eee848e3b214d 100644
--- a/Device/Detector/SpecularDetector1D.h
+++ b/Device/Detector/SpecularDetector1D.h
@@ -49,7 +49,7 @@ public:
void setAxis(const IAxis& axis);
//! Return default axes units
- virtual Axes::Units defaultAxesUnits() const override { return Axes::Units::RADIANS; }
+ virtual Axes::Coords defaultAxesUnits() const override { return Axes::Coords::RADIANS; }
protected:
diff --git a/Device/Detector/SphericalDetector.h b/Device/Detector/SphericalDetector.h
index 6d0fab8bdd2a19eb1fb4da6ca49998599512469b..926f1153660f962dc3ad4bffa560f34c545d5f0d 100644
--- a/Device/Detector/SphericalDetector.h
+++ b/Device/Detector/SphericalDetector.h
@@ -53,7 +53,7 @@ public:
~SphericalDetector() override {}
//! return default axes units
- virtual Axes::Units defaultAxesUnits() const override { return Axes::Units::RADIANS; }
+ virtual Axes::Coords defaultAxesUnits() const override { return Axes::Coords::RADIANS; }
protected:
//! Creates an IPixel for the given OutputData object and index
diff --git a/Device/Histo/SimulationResult.cpp b/Device/Histo/SimulationResult.cpp
index 680d89eaa604a7791457c008b93974347933c634..8ae2c27f5ff011cab2f0d9b4737e3fb3cb9e3deb 100644
--- a/Device/Histo/SimulationResult.cpp
+++ b/Device/Histo/SimulationResult.cpp
@@ -54,7 +54,7 @@ SimulationResult& SimulationResult::operator=(SimulationResult&& other)
return *this;
}
-std::unique_ptr<OutputData<double>> SimulationResult::data(Axes::Units units) const
+std::unique_ptr<OutputData<double>> SimulationResult::data(Axes::Coords units) const
{
if (!m_data)
throw std::runtime_error(
@@ -62,7 +62,7 @@ std::unique_ptr<OutputData<double>> SimulationResult::data(Axes::Units units) co
return m_unit_converter->createConvertedData(*m_data, units);
}
-Histogram2D* SimulationResult::histogram2d(Axes::Units units) const
+Histogram2D* SimulationResult::histogram2d(Axes::Coords units) const
{
if (m_data->rank() != 2 || m_unit_converter->dimension() != 2)
throw std::runtime_error("Error in SimulationResult::histogram2d: "
@@ -72,7 +72,7 @@ Histogram2D* SimulationResult::histogram2d(Axes::Units units) const
return new Histogram2D(*P_data);
}
-std::vector<AxisInfo> SimulationResult::axisInfo(Axes::Units units) const
+std::vector<AxisInfo> SimulationResult::axisInfo(Axes::Coords units) const
{
if (!m_unit_converter)
return {};
@@ -121,7 +121,7 @@ double SimulationResult::max() const
}
#ifdef BORNAGAIN_PYTHON
-PyObject* SimulationResult::array(Axes::Units units) const
+PyObject* SimulationResult::array(Axes::Coords units) const
{
if (!m_data || !m_unit_converter)
throw std::runtime_error(
@@ -130,12 +130,12 @@ PyObject* SimulationResult::array(Axes::Units units) const
}
#endif
-std::vector<double> SimulationResult::convertedBinCenters(Axes::Units units) const
+std::vector<double> SimulationResult::convertedBinCenters(Axes::Coords units) const
{
return convertedBinCenters(0, units);
}
-std::vector<double> SimulationResult::convertedBinCenters(size_t i_axis, Axes::Units units) const
+std::vector<double> SimulationResult::convertedBinCenters(size_t i_axis, Axes::Coords units) const
{
if (i_axis >= m_unit_converter->dimension())
throw std::runtime_error(
diff --git a/Device/Histo/SimulationResult.h b/Device/Histo/SimulationResult.h
index 71791a457963424d287729bd383d33020abef244..cb95d59a250c51b188f3af7f6cc0fcd4efdfedf7 100644
--- a/Device/Histo/SimulationResult.h
+++ b/Device/Histo/SimulationResult.h
@@ -49,13 +49,13 @@ public:
SimulationResult& operator=(SimulationResult&& other);
#ifndef SWIG
- std::unique_ptr<OutputData<double>> data(Axes::Units units = Axes::Units::UNDEFINED) const;
+ std::unique_ptr<OutputData<double>> data(Axes::Coords units = Axes::Coords::UNDEFINED) const;
#endif
- Histogram2D* histogram2d(Axes::Units units = Axes::Units::UNDEFINED) const;
+ Histogram2D* histogram2d(Axes::Coords units = Axes::Coords::UNDEFINED) const;
//! Provide AxisInfo for each axis and the given units
- std::vector<AxisInfo> axisInfo(Axes::Units units = Axes::Units::UNDEFINED) const;
+ std::vector<AxisInfo> axisInfo(Axes::Coords units = Axes::Coords::UNDEFINED) const;
//! Returns underlying unit converter
const ICoordSystem& converter() const;
@@ -69,15 +69,15 @@ public:
//! returns intensity data as Python numpy array
#ifdef BORNAGAIN_PYTHON
- PyObject* array(Axes::Units units = Axes::Units::UNDEFINED) const;
+ PyObject* array(Axes::Coords units = Axes::Coords::UNDEFINED) const;
#endif
- std::vector<double> convertedBinCenters(Axes::Units units = Axes::Units::UNDEFINED) const;
+ std::vector<double> convertedBinCenters(Axes::Coords units = Axes::Coords::UNDEFINED) const;
//! Returns axis coordinates as a numpy array. With no parameters given
//! returns coordinates of x-axis in default units.
std::vector<double> convertedBinCenters(size_t i_axis,
- Axes::Units units = Axes::Units::UNDEFINED) const;
+ Axes::Coords units = Axes::Coords::UNDEFINED) const;
private:
void checkDimensions() const;
diff --git a/Device/Instrument/UnitConverter2D.cpp b/Device/Instrument/CoordSystem2D.cpp
similarity index 86%
rename from Device/Instrument/UnitConverter2D.cpp
rename to Device/Instrument/CoordSystem2D.cpp
index 0df50fa6b15fde82a135d26b4d4fccae9eb0b5cc..19c25ccee374c98f6efaaaa1b4fb4705e85e255f 100644
--- a/Device/Instrument/UnitConverter2D.cpp
+++ b/Device/Instrument/CoordSystem2D.cpp
@@ -2,7 +2,7 @@
//
// BornAgain: simulate and fit reflection and scattering
//
-//! @file Device/Instrument/UnitConverter2D.cpp
+//! @file Device/Instrument/CoordSystem2D.cpp
//! @brief Implements ICoordSystem classes.
//!
//! @homepage http://www.bornagainproject.org
@@ -64,27 +64,27 @@ CoordSystem2D::CoordSystem2D(const CoordSystem2D& other)
}
void CoordSystem2D::addAxisData(std::string name, double min, double max,
- Axes::Units default_units, size_t nbins)
+ Axes::Coords default_units, size_t nbins)
{
m_axis_data_table.emplace_back(AxisData{name, min, max, default_units, nbins});
}
-double CoordSystem2D::calculateMin(size_t i_axis, Axes::Units units) const
+double CoordSystem2D::calculateMin(size_t i_axis, Axes::Coords units) const
{
ASSERT(i_axis < dimension());
units = substituteDefaultUnits(units);
const auto& axis_data = m_axis_data_table[i_axis];
- if (units == Axes::Units::NBINS)
+ if (units == Axes::Coords::NBINS)
return 0.0;
return calculateValue(i_axis, units, axis_data.min);
}
-double CoordSystem2D::calculateMax(size_t i_axis, Axes::Units units) const
+double CoordSystem2D::calculateMax(size_t i_axis, Axes::Coords units) const
{
ASSERT(i_axis < dimension());
units = substituteDefaultUnits(units);
const auto& axis_data = m_axis_data_table[i_axis];
- if (units == Axes::Units::NBINS)
+ if (units == Axes::Coords::NBINS)
return static_cast<double>(axis_data.nbins);
return calculateValue(i_axis, units, axis_data.max);
}
@@ -95,13 +95,13 @@ size_t CoordSystem2D::axisSize(size_t i_axis) const
return m_axis_data_table[i_axis].nbins;
}
-std::vector<Axes::Units> CoordSystem2D::availableUnits() const
+std::vector<Axes::Coords> CoordSystem2D::availableUnits() const
{
- return {Axes::Units::NBINS, Axes::Units::RADIANS, Axes::Units::DEGREES};
+ return {Axes::Coords::NBINS, Axes::Coords::RADIANS, Axes::Coords::DEGREES};
}
std::unique_ptr<const IAxis> CoordSystem2D::createConvertedAxis(size_t i_axis,
- Axes::Units units) const
+ Axes::Coords units) const
{
const double min = calculateMin(i_axis, units);
const double max = calculateMax(i_axis, units);
@@ -160,21 +160,21 @@ SphericalConverter* SphericalConverter::clone() const
return new SphericalConverter(*this);
}
-std::vector<Axes::Units> SphericalConverter::availableUnits() const
+std::vector<Axes::Coords> SphericalConverter::availableUnits() const
{
auto result = CoordSystem2D::availableUnits();
- result.push_back(Axes::Units::QSPACE);
+ result.push_back(Axes::Coords::QSPACE);
return result;
}
-double SphericalConverter::calculateValue(size_t i_axis, Axes::Units units, double value) const
+double SphericalConverter::calculateValue(size_t i_axis, Axes::Coords units, double value) const
{
switch (units) {
- case Axes::Units::RADIANS:
+ case Axes::Coords::RADIANS:
return value;
- case Axes::Units::DEGREES:
+ case Axes::Coords::DEGREES:
return Units::rad2deg(value);
- case Axes::Units::QSPACE: {
+ case Axes::Coords::QSPACE: {
const auto k_i = vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i);
if (i_axis == 0) {
const auto k_f = vecOfLambdaAlphaPhi(m_wavelength, 0.0, value);
@@ -187,7 +187,7 @@ double SphericalConverter::calculateValue(size_t i_axis, Axes::Units units, doub
"incorrect axis index: "
+ std::to_string(static_cast<int>(i_axis)));
}
- case Axes::Units::QXQY: {
+ case Axes::Coords::QXQY: {
const auto k_i = vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i);
if (i_axis == 0) {
const auto k_f = vecOfLambdaAlphaPhi(m_wavelength, 0.0, value);
@@ -205,7 +205,7 @@ double SphericalConverter::calculateValue(size_t i_axis, Axes::Units units, doub
}
}
-std::vector<std::map<Axes::Units, std::string>> SphericalConverter::createNameMaps() const
+std::vector<std::map<Axes::Coords, std::string>> SphericalConverter::createNameMaps() const
{
return {AxisNames::sphericalAxis0, AxisNames::sphericalAxis1};
}
@@ -236,18 +236,18 @@ RectangularConverter* RectangularConverter::clone() const
return new RectangularConverter(*this);
}
-std::vector<Axes::Units> RectangularConverter::availableUnits() const
+std::vector<Axes::Coords> RectangularConverter::availableUnits() const
{
auto result = CoordSystem2D::availableUnits();
- result.push_back(Axes::Units::QSPACE);
- result.push_back(Axes::Units::MM);
+ result.push_back(Axes::Coords::QSPACE);
+ result.push_back(Axes::Coords::MM);
return result;
}
-double RectangularConverter::calculateValue(size_t i_axis, Axes::Units units, double value) const
+double RectangularConverter::calculateValue(size_t i_axis, Axes::Coords units, double value) const
{
ASSERT(m_wavelength>0);
- if (units == Axes::Units::MM)
+ if (units == Axes::Coords::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,18 +258,18 @@ double RectangularConverter::calculateValue(size_t i_axis, Axes::Units units, do
const kvector_t k_f = out_dir.unit() * M_TWOPI / m_wavelength;
switch (units) {
- case Axes::Units::RADIANS:
+ case Axes::Coords::RADIANS:
return axisAngle(i_axis, k_f);
- case Axes::Units::DEGREES:
+ case Axes::Coords::DEGREES:
return Units::rad2deg(axisAngle(i_axis, k_f));
- case Axes::Units::QSPACE: {
+ case Axes::Coords::QSPACE: {
const auto k_i = vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i);
if (i_axis == 0)
return (k_i - k_f).y();
if (i_axis == 1)
return (k_f - k_i).z();
}
- case Axes::Units::QXQY: {
+ case Axes::Coords::QXQY: {
const auto k_i = vecOfLambdaAlphaPhi(m_wavelength, m_alpha_i, m_phi_i);
if (i_axis == 0)
return (k_i - k_f).y();
@@ -282,7 +282,7 @@ double RectangularConverter::calculateValue(size_t i_axis, Axes::Units units, do
ASSERT(0);
}
-std::vector<std::map<Axes::Units, std::string>> RectangularConverter::createNameMaps() const
+std::vector<std::map<Axes::Coords, std::string>> RectangularConverter::createNameMaps() const
{
return {AxisNames::rectangularAxis0, AxisNames::rectangularAxis1};
}
@@ -314,24 +314,24 @@ OffSpecularConverter* OffSpecularConverter::clone() const
return new OffSpecularConverter(*this);
}
-Axes::Units OffSpecularConverter::defaultUnits() const
+Axes::Coords OffSpecularConverter::defaultUnits() const
{
- return Axes::Units::DEGREES;
+ return Axes::Coords::DEGREES;
}
-double OffSpecularConverter::calculateValue(size_t, Axes::Units units, double value) const
+double OffSpecularConverter::calculateValue(size_t, Axes::Coords units, double value) const
{
switch (units) {
- case Axes::Units::RADIANS:
+ case Axes::Coords::RADIANS:
return value;
- case Axes::Units::DEGREES:
+ case Axes::Coords::DEGREES:
return Units::rad2deg(value);
default:
throwUnitsError("OffSpecularConverter::calculateValue", availableUnits());
}
}
-std::vector<std::map<Axes::Units, std::string>> OffSpecularConverter::createNameMaps() const
+std::vector<std::map<Axes::Coords, std::string>> OffSpecularConverter::createNameMaps() const
{
return {AxisNames::offSpecularAxis0, AxisNames::offSpecularAxis1};
}
@@ -393,14 +393,14 @@ DepthProbeConverter* DepthProbeConverter::clone() const
return new DepthProbeConverter(*this);
}
-std::vector<Axes::Units> DepthProbeConverter::availableUnits() const
+std::vector<Axes::Coords> DepthProbeConverter::availableUnits() const
{
auto result = CoordSystem2D::availableUnits();
- result.push_back(Axes::Units::QSPACE);
+ result.push_back(Axes::Coords::QSPACE);
return result;
}
-double DepthProbeConverter::calculateValue(size_t i_axis, Axes::Units units, double value) const
+double DepthProbeConverter::calculateValue(size_t i_axis, Axes::Coords units, double value) const
{
const auto& available_units = availableUnits();
if (std::find(available_units.begin(), available_units.end(), units) == available_units.cend())
@@ -409,16 +409,16 @@ double DepthProbeConverter::calculateValue(size_t i_axis, Axes::Units units, dou
if (i_axis == 1)
return value; // unit conversions are not applied to sample position axis
switch (units) {
- case Axes::Units::DEGREES:
+ case Axes::Coords::DEGREES:
return Units::rad2deg(value);
- case Axes::Units::QSPACE:
+ case Axes::Coords::QSPACE:
return getQ(m_wavelength, value);
default:
return value;
}
}
-std::vector<std::map<Axes::Units, std::string>> DepthProbeConverter::createNameMaps() const
+std::vector<std::map<Axes::Coords, std::string>> DepthProbeConverter::createNameMaps() const
{
return {AxisNames::specAxis, AxisNames::sampleDepthAxis};
}
diff --git a/Device/Instrument/UnitConverter2D.h b/Device/Instrument/CoordSystem2D.h
similarity index 71%
rename from Device/Instrument/UnitConverter2D.h
rename to Device/Instrument/CoordSystem2D.h
index ccdb250cc54e3b4ccdc46f3e71b531af16fb5da9..0e4caa5ab25560546042805d1fb8d71c775493e6 100644
--- a/Device/Instrument/UnitConverter2D.h
+++ b/Device/Instrument/CoordSystem2D.h
@@ -2,7 +2,7 @@
//
// BornAgain: simulate and fit reflection and scattering
//
-//! @file Device/Instrument/UnitConverter2D.h
+//! @file Device/Instrument/CoordSystem2D.h
//! @brief Defines interface CoordSystem2D and its subclasses.
//!
//! @homepage http://www.bornagainproject.org
@@ -17,8 +17,8 @@
#endif
#ifndef USER_API
-#ifndef BORNAGAIN_DEVICE_INSTRUMENT_UNITCONVERTER2D_H
-#define BORNAGAIN_DEVICE_INSTRUMENT_UNITCONVERTER2D_H
+#ifndef BORNAGAIN_DEVICE_INSTRUMENT_COORDSYSTEM2D_H
+#define BORNAGAIN_DEVICE_INSTRUMENT_COORDSYSTEM2D_H
#include "Base/Vector/Vectors3D.h"
#include "Device/Unit/ICoordSystem.h"
@@ -41,16 +41,16 @@ public:
virtual size_t dimension() const override { return m_axis_data_table.size(); }
- double calculateMin(size_t i_axis, Axes::Units units) const override;
- double calculateMax(size_t i_axis, Axes::Units units) const override;
+ double calculateMin(size_t i_axis, Axes::Coords units) const override;
+ double calculateMax(size_t i_axis, Axes::Coords units) const override;
size_t axisSize(size_t i_axis) const override;
//! Returns list of units that are available for all 2D detectors.
//! Further units may be added by child classes.
- std::vector<Axes::Units> availableUnits() const override;
+ std::vector<Axes::Coords> availableUnits() const override;
std::unique_ptr<const IAxis> createConvertedAxis(size_t i_axis,
- Axes::Units units) const override;
+ Axes::Coords units) const override;
//! Helper factory function to use in GISASSimulation. Depending on the type of detector,
//! returns either RectangularConverter or SphericalConverter.
@@ -60,14 +60,14 @@ protected:
CoordSystem2D(const CoordSystem2D& other);
void addDetectorAxis(const IDetector& detector, size_t i_axis);
- void addAxisData(std::string name, double min, double max, Axes::Units default_units,
+ void addAxisData(std::string name, double min, double max, Axes::Coords default_units,
size_t nbins);
#ifndef SWIG
struct AxisData {
std::string name;
double min, max;
- Axes::Units default_units;
+ Axes::Coords default_units;
size_t nbins;
};
std::vector<AxisData> m_axis_data_table;
@@ -77,7 +77,7 @@ protected:
double m_phi_i;
private:
- virtual double calculateValue(size_t i_axis, Axes::Units units, double value) const = 0;
+ virtual double calculateValue(size_t i_axis, Axes::Coords units, double value) const = 0;
};
@@ -94,14 +94,14 @@ public:
SphericalConverter* clone() const override;
//! Returns the list of all available units
- std::vector<Axes::Units> availableUnits() const override;
+ std::vector<Axes::Coords> availableUnits() const override;
- Axes::Units defaultUnits() const override { return Axes::Units::DEGREES; }
+ Axes::Coords defaultUnits() const override { return Axes::Coords::DEGREES; }
private:
SphericalConverter(const SphericalConverter& other); //!< used by clone()
- double calculateValue(size_t i_axis, Axes::Units units, double value) const override;
- std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
+ double calculateValue(size_t i_axis, Axes::Coords units, double value) const override;
+ std::vector<std::map<Axes::Coords, std::string>> createNameMaps() const override;
};
@@ -118,14 +118,14 @@ public:
RectangularConverter* clone() const override;
//! Returns the list of all available units
- std::vector<Axes::Units> availableUnits() const override;
+ std::vector<Axes::Coords> availableUnits() const override;
- Axes::Units defaultUnits() const override { return Axes::Units::MM; }
+ Axes::Coords defaultUnits() const override { return Axes::Coords::MM; }
private:
RectangularConverter(const RectangularConverter& other); //!< used by clone()
- double calculateValue(size_t i_axis, Axes::Units units, double value) const override;
- std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
+ double calculateValue(size_t i_axis, Axes::Coords units, double value) const override;
+ std::vector<std::map<Axes::Coords, std::string>> createNameMaps() const override;
std::unique_ptr<RectangularPixel> m_detector_pixel;
};
@@ -144,12 +144,12 @@ public:
OffSpecularConverter* clone() const override;
- Axes::Units defaultUnits() const override;
+ Axes::Coords defaultUnits() const override;
private:
OffSpecularConverter(const OffSpecularConverter& other); //!< used by clone()
- double calculateValue(size_t i_axis, Axes::Units units, double value) const override;
- std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
+ double calculateValue(size_t i_axis, Axes::Coords units, double value) const override;
+ std::vector<std::map<Axes::Coords, std::string>> createNameMaps() const override;
void addDetectorYAxis(const IDetector2D& detector);
};
@@ -168,15 +168,15 @@ public:
DepthProbeConverter* clone() const override;
//! Returns the list of all available units
- std::vector<Axes::Units> availableUnits() const override;
+ std::vector<Axes::Coords> availableUnits() const override;
- Axes::Units defaultUnits() const override { return Axes::Units::DEGREES; }
+ Axes::Coords defaultUnits() const override { return Axes::Coords::DEGREES; }
private:
DepthProbeConverter(const DepthProbeConverter& other); //!< used by clone()
- double calculateValue(size_t, Axes::Units units, double value) const override;
- std::vector<std::map<Axes::Units, std::string>> createNameMaps() const override;
+ double calculateValue(size_t, Axes::Coords units, double value) const override;
+ std::vector<std::map<Axes::Coords, std::string>> createNameMaps() const override;
};
-#endif // BORNAGAIN_DEVICE_INSTRUMENT_UNITCONVERTER2D_H
+#endif // BORNAGAIN_DEVICE_INSTRUMENT_COORDSYSTEM2D_H
#endif // USER_API
diff --git a/Device/Unit/AxisNames.cpp b/Device/Unit/AxisNames.cpp
index 17a0c53eecb04061012193e593aeddd12316e2d5..fdcb9ac747bddd2a42418d5cfb87f9d82e21a7e2 100644
--- a/Device/Unit/AxisNames.cpp
+++ b/Device/Unit/AxisNames.cpp
@@ -18,51 +18,51 @@
namespace AxisNames {
// For spherical detectors in GISAS simulations
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> sphericalAxis0 = {
- {Axes::Units::NBINS, "X [nbins]"},
- {Axes::Units::RADIANS, "phi_f [rad]"},
- {Axes::Units::DEGREES, "phi_f [deg]"},
- {Axes::Units::QSPACE, "Qy [1/nm]"},
- {Axes::Units::QXQY, "Qx [1/nm]"}};
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> sphericalAxis1 = {
- {Axes::Units::NBINS, "Y [nbins]"},
- {Axes::Units::RADIANS, "alpha_f [rad]"},
- {Axes::Units::DEGREES, "alpha_f [deg]"},
- {Axes::Units::QSPACE, "Qz [1/nm]"},
- {Axes::Units::QXQY, "Qy [1/nm]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> sphericalAxis0 = {
+ {Axes::Coords::NBINS, "X [nbins]"},
+ {Axes::Coords::RADIANS, "phi_f [rad]"},
+ {Axes::Coords::DEGREES, "phi_f [deg]"},
+ {Axes::Coords::QSPACE, "Qy [1/nm]"},
+ {Axes::Coords::QXQY, "Qx [1/nm]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> sphericalAxis1 = {
+ {Axes::Coords::NBINS, "Y [nbins]"},
+ {Axes::Coords::RADIANS, "alpha_f [rad]"},
+ {Axes::Coords::DEGREES, "alpha_f [deg]"},
+ {Axes::Coords::QSPACE, "Qz [1/nm]"},
+ {Axes::Coords::QXQY, "Qy [1/nm]"}};
// For rectangular detectors in GISAS simulations
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> rectangularAxis0 = {
- {Axes::Units::NBINS, "X [nbins]"}, {Axes::Units::RADIANS, "phi_f [rad]"},
- {Axes::Units::DEGREES, "phi_f [deg]"}, {Axes::Units::MM, "X [mm]"},
- {Axes::Units::QSPACE, "Qy [1/nm]"}, {Axes::Units::QXQY, "Qx [1/nm]"}};
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> rectangularAxis1 = {
- {Axes::Units::NBINS, "Y [nbins]"}, {Axes::Units::RADIANS, "alpha_f [rad]"},
- {Axes::Units::DEGREES, "alpha_f [deg]"}, {Axes::Units::MM, "Y [mm]"},
- {Axes::Units::QSPACE, "Qz [1/nm]"}, {Axes::Units::QXQY, "Qy [1/nm]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> rectangularAxis0 = {
+ {Axes::Coords::NBINS, "X [nbins]"}, {Axes::Coords::RADIANS, "phi_f [rad]"},
+ {Axes::Coords::DEGREES, "phi_f [deg]"}, {Axes::Coords::MM, "X [mm]"},
+ {Axes::Coords::QSPACE, "Qy [1/nm]"}, {Axes::Coords::QXQY, "Qx [1/nm]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> rectangularAxis1 = {
+ {Axes::Coords::NBINS, "Y [nbins]"}, {Axes::Coords::RADIANS, "alpha_f [rad]"},
+ {Axes::Coords::DEGREES, "alpha_f [deg]"}, {Axes::Coords::MM, "Y [mm]"},
+ {Axes::Coords::QSPACE, "Qz [1/nm]"}, {Axes::Coords::QXQY, "Qy [1/nm]"}};
// For off-specular simulations (both spherical and rectangular detectors)
// Currently 'mm' is not supported for the y-axis
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> offSpecularAxis0 = {
- {Axes::Units::NBINS, "X [nbins]"},
- {Axes::Units::RADIANS, "alpha_i [rad]"},
- {Axes::Units::DEGREES, "alpha_i [deg]"}};
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> offSpecularAxis1 = {
- {Axes::Units::NBINS, "Y [nbins]"},
- {Axes::Units::RADIANS, "alpha_f [rad]"},
- {Axes::Units::DEGREES, "alpha_f [deg]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> offSpecularAxis0 = {
+ {Axes::Coords::NBINS, "X [nbins]"},
+ {Axes::Coords::RADIANS, "alpha_i [rad]"},
+ {Axes::Coords::DEGREES, "alpha_i [deg]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> offSpecularAxis1 = {
+ {Axes::Coords::NBINS, "Y [nbins]"},
+ {Axes::Coords::RADIANS, "alpha_f [rad]"},
+ {Axes::Coords::DEGREES, "alpha_f [deg]"}};
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> specAxis = {
- {Axes::Units::NBINS, "X [nbins]"},
- {Axes::Units::RADIANS, "alpha_i [rad]"},
- {Axes::Units::DEGREES, "alpha_i [deg]"},
- {Axes::Units::QSPACE, "Q [1/nm]"},
- {Axes::Units::RQ4, "Q [1/nm]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> specAxis = {
+ {Axes::Coords::NBINS, "X [nbins]"},
+ {Axes::Coords::RADIANS, "alpha_i [rad]"},
+ {Axes::Coords::DEGREES, "alpha_i [deg]"},
+ {Axes::Coords::QSPACE, "Q [1/nm]"},
+ {Axes::Coords::RQ4, "Q [1/nm]"}};
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> specAxisQ = {
- {Axes::Units::NBINS, "X [nbins]"},
- {Axes::Units::QSPACE, "Q [1/nm]"},
- {Axes::Units::RQ4, "Q [1/nm]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> specAxisQ = {
+ {Axes::Coords::NBINS, "X [nbins]"},
+ {Axes::Coords::QSPACE, "Q [1/nm]"},
+ {Axes::Coords::RQ4, "Q [1/nm]"}};
// corner case: axis corresponding to the position
// across sample is accepts only bins and nanometers,
@@ -71,10 +71,10 @@ BA_DEVICE_API_ const std::map<Axes::Units, std::string> specAxisQ = {
// For this reason depth axis map returns always
// nanometers except for bins.
-BA_DEVICE_API_ const std::map<Axes::Units, std::string> sampleDepthAxis = {
- {Axes::Units::NBINS, "Y [nbins]"},
- {Axes::Units::RADIANS, "Position [nm]"},
- {Axes::Units::DEGREES, "Position [nm]"},
- {Axes::Units::QSPACE, "Position [nm]"}};
+BA_DEVICE_API_ const std::map<Axes::Coords, std::string> sampleDepthAxis = {
+ {Axes::Coords::NBINS, "Y [nbins]"},
+ {Axes::Coords::RADIANS, "Position [nm]"},
+ {Axes::Coords::DEGREES, "Position [nm]"},
+ {Axes::Coords::QSPACE, "Position [nm]"}};
} // namespace AxisNames
diff --git a/Device/Unit/AxisNames.h b/Device/Unit/AxisNames.h
index 06f0f370277eb1287cde757aab630803042d2e24..65ffc939af151c9ea25ee9f352320c79150f22db 100644
--- a/Device/Unit/AxisNames.h
+++ b/Device/Unit/AxisNames.h
@@ -25,28 +25,28 @@
#include <map>
#include <string>
-const std::map<Axes::Units, const char*> axisUnitLabel = {{Axes::Units::UNDEFINED, "undefined"},
- {Axes::Units::NBINS, "bin"},
- {Axes::Units::RADIANS, "rad"},
- {Axes::Units::DEGREES, "deg"},
- {Axes::Units::MM, "mm"},
- {Axes::Units::QSPACE, "1/nm"},
- {Axes::Units::QXQY, "1/nm"},
- {Axes::Units::RQ4, "nm^-4?"}};
+const std::map<Axes::Coords, const char*> axisUnitLabel = {{Axes::Coords::UNDEFINED, "undefined"},
+ {Axes::Coords::NBINS, "bin"},
+ {Axes::Coords::RADIANS, "rad"},
+ {Axes::Coords::DEGREES, "deg"},
+ {Axes::Coords::MM, "mm"},
+ {Axes::Coords::QSPACE, "1/nm"},
+ {Axes::Coords::QXQY, "1/nm"},
+ {Axes::Coords::RQ4, "nm^-4?"}};
//! Contains const maps that give the right axis names for different detector types and units
//! @ingroup detector
namespace AxisNames {
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> sphericalAxis0;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> sphericalAxis1;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> rectangularAxis0;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> rectangularAxis1;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> offSpecularAxis0;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> offSpecularAxis1;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> specAxis;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> specAxisQ;
-extern BA_DEVICE_API_ const std::map<Axes::Units, std::string> sampleDepthAxis;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> sphericalAxis0;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> sphericalAxis1;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> rectangularAxis0;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> rectangularAxis1;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> offSpecularAxis0;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> offSpecularAxis1;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> specAxis;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> specAxisQ;
+extern BA_DEVICE_API_ const std::map<Axes::Coords, std::string> sampleDepthAxis;
} // namespace AxisNames
#endif // BORNAGAIN_DEVICE_UNIT_AXISNAMES_H
diff --git a/Device/Unit/IUnitConverter.cpp b/Device/Unit/ICoordSystem.cpp
similarity index 80%
rename from Device/Unit/IUnitConverter.cpp
rename to Device/Unit/ICoordSystem.cpp
index 9f5eaf63c8c72d532942900aabed2e86df5da78c..732025f220d3086d68695c817a8147fbcffa08f8 100644
--- a/Device/Unit/IUnitConverter.cpp
+++ b/Device/Unit/ICoordSystem.cpp
@@ -2,7 +2,7 @@
//
// BornAgain: simulate and fit reflection and scattering
//
-//! @file Device/Unit/IUnitConverter.cpp
+//! @file Device/Unit/ICoordSystem.cpp
//! @brief Implements ICoordSystem class.
//!
//! @homepage http://www.bornagainproject.org
@@ -19,7 +19,7 @@
ICoordSystem::~ICoordSystem() = default;
-std::unique_ptr<OutputData<double>> ICoordSystem::createOutputData(Axes::Units units) const
+std::unique_ptr<OutputData<double>> ICoordSystem::createOutputData(Axes::Coords units) const
{
std::unique_ptr<OutputData<double>> result = std::make_unique<OutputData<double>>();
for (size_t i = 0; i < dimension(); ++i)
@@ -28,18 +28,18 @@ std::unique_ptr<OutputData<double>> ICoordSystem::createOutputData(Axes::Units u
return result;
}
-std::string ICoordSystem::axisName(size_t i_axis, const Axes::Units units) const
+std::string ICoordSystem::axisName(size_t i_axis, const Axes::Coords units) const
{
const auto& name_maps = createNameMaps();
ASSERT(i_axis < name_maps.size());
const auto& name_map = name_maps[i_axis];
- const auto& it = name_map.find(units == Axes::Units::UNDEFINED ? defaultUnits() : units);
+ const auto& it = name_map.find(units == Axes::Coords::UNDEFINED ? defaultUnits() : units);
ASSERT(it != name_map.cend());
return it->second;
}
std::unique_ptr<OutputData<double>>
-ICoordSystem::createConvertedData(const OutputData<double>& data, Axes::Units units) const
+ICoordSystem::createConvertedData(const OutputData<double>& data, Axes::Coords units) const
{
std::unique_ptr<OutputData<double>> result(new OutputData<double>);
for (size_t i = 0; i < data.rank(); ++i)
@@ -48,7 +48,7 @@ ICoordSystem::createConvertedData(const OutputData<double>& data, Axes::Units un
return result;
}
-void ICoordSystem::throwUnitsError(std::string method, std::vector<Axes::Units> available) const
+void ICoordSystem::throwUnitsError(std::string method, std::vector<Axes::Coords> available) const
{
std::stringstream ss;
ss << "Unit type error in " << method
@@ -59,7 +59,7 @@ void ICoordSystem::throwUnitsError(std::string method, std::vector<Axes::Units>
throw std::runtime_error(ss.str());
}
-Axes::Units ICoordSystem::substituteDefaultUnits(Axes::Units units) const
+Axes::Coords ICoordSystem::substituteDefaultUnits(Axes::Coords units) const
{
- return units == Axes::Units::UNDEFINED ? defaultUnits() : units;
+ return units == Axes::Coords::UNDEFINED ? defaultUnits() : units;
}
diff --git a/Device/Unit/IUnitConverter.h b/Device/Unit/ICoordSystem.h
similarity index 68%
rename from Device/Unit/IUnitConverter.h
rename to Device/Unit/ICoordSystem.h
index 528deef5ec03be6f3b4fbc62d8ca608edc5783f4..19d695596c83cbff5d12e7e4e00a5cf9dc5798c1 100644
--- a/Device/Unit/IUnitConverter.h
+++ b/Device/Unit/ICoordSystem.h
@@ -2,7 +2,7 @@
//
// BornAgain: simulate and fit reflection and scattering
//
-//! @file Device/Unit/IUnitConverter.h
+//! @file Device/Unit/ICoordSystem.h
//! @brief Defines interface ICoordSystem and possible axis units.
//!
//! @homepage http://www.bornagainproject.org
@@ -17,8 +17,8 @@
#endif
#ifndef USER_API
-#ifndef BORNAGAIN_DEVICE_UNIT_IUNITCONVERTER_H
-#define BORNAGAIN_DEVICE_UNIT_IUNITCONVERTER_H
+#ifndef BORNAGAIN_DEVICE_UNIT_ICOORDSYSTEM_H
+#define BORNAGAIN_DEVICE_UNIT_ICOORDSYSTEM_H
#include "Base/Types/ICloneable.h"
#include "Device/Unit/Axes.h"
@@ -46,37 +46,37 @@ public:
virtual ICoordSystem* clone() const = 0;
//! Returns zero-valued output data array in specified units
- std::unique_ptr<OutputData<double>> createOutputData(Axes::Units units) const;
+ std::unique_ptr<OutputData<double>> createOutputData(Axes::Coords units) const;
virtual size_t dimension() 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 double calculateMin(size_t i_axis, Axes::Coords units) const = 0;
+ virtual double calculateMax(size_t i_axis, Axes::Coords units) const = 0;
virtual size_t axisSize(size_t i_axis) const = 0;
- std::string axisName(size_t i_axis, const Axes::Units units = Axes::Units::UNDEFINED) const;
+ std::string axisName(size_t i_axis, const Axes::Coords units = Axes::Coords::UNDEFINED) const;
- virtual std::vector<Axes::Units> availableUnits() const = 0;
- virtual Axes::Units defaultUnits() const = 0;
+ virtual std::vector<Axes::Coords> availableUnits() const = 0;
+ virtual Axes::Coords defaultUnits() const = 0;
#ifndef SWIG
virtual std::unique_ptr<const IAxis> createConvertedAxis(size_t i_axis,
- Axes::Units units) const = 0;
+ Axes::Coords units) const = 0;
//! Creates OutputData array in converter units.
virtual std::unique_ptr<OutputData<double>> createConvertedData(const OutputData<double>& data,
- Axes::Units units) const;
+ Axes::Coords units) const;
#endif // SWIG
protected:
- Axes::Units substituteDefaultUnits(Axes::Units units) const;
+ Axes::Coords substituteDefaultUnits(Axes::Coords units) const;
#ifndef SWIG
- [[noreturn]] void throwUnitsError(std::string method, std::vector<Axes::Units> available) const;
+ [[noreturn]] void throwUnitsError(std::string method, std::vector<Axes::Coords> available) const;
#endif // SWIG
private:
- virtual std::vector<std::map<Axes::Units, std::string>> createNameMaps() const = 0;
+ virtual std::vector<std::map<Axes::Coords, std::string>> createNameMaps() const = 0;
};
-#endif // BORNAGAIN_DEVICE_UNIT_IUNITCONVERTER_H
+#endif // BORNAGAIN_DEVICE_UNIT_ICOORDSYSTEM_H
#endif // USER_API
diff --git a/GUI/coregui/DataLoaders/AutomaticDataLoader1D.cpp b/GUI/coregui/DataLoaders/AutomaticDataLoader1D.cpp
index 30351dc77abb03b4ad017407167d9492ac764302..fa894cc5ab8ffaabe75e716927b001aebf4f4f23 100644
--- a/GUI/coregui/DataLoaders/AutomaticDataLoader1D.cpp
+++ b/GUI/coregui/DataLoaders/AutomaticDataLoader1D.cpp
@@ -92,7 +92,7 @@ void AutomaticDataLoader1D::processContents()
std::stringstream str(m_fileContent.constData());
auto oData = OutputDataReadReflectometry().readOutputData(str);
- ImportDataInfo importInfo(std::move(*oData), Axes::Units::QSPACE);
+ ImportDataInfo importInfo(std::move(*oData), Axes::Coords::QSPACE);
m_item->setImportData(std::move(importInfo));
m_error.clear();
} catch (std::runtime_error& ex) {
diff --git a/GUI/coregui/DataLoaders/QREDataLoader.cpp b/GUI/coregui/DataLoaders/QREDataLoader.cpp
index 6a6ed28972c9cc84a0338dc6844c0599ff6dd4e6..e36ac3c3e53ec7eeb8adc29add5afe11d4c006c5 100644
--- a/GUI/coregui/DataLoaders/QREDataLoader.cpp
+++ b/GUI/coregui/DataLoaders/QREDataLoader.cpp
@@ -551,7 +551,7 @@ void QREDataLoader::createOutputDataFromParsingResult(RealDataItem* item) const
// -- Replacement of item->setImportData(std::move(data));
item->initNativeData();
- QString units_name = JobItemUtils::nameFromAxesUnits(Axes::Units::QSPACE);
+ QString units_name = JobItemUtils::nameFromAxesUnits(Axes::Coords::QSPACE);
// -- Replacement of specularItem->reset(std::move(data));
SpecularDataItem* specularItem = item->specularDataItem();
@@ -561,7 +561,7 @@ void QREDataLoader::createOutputDataFromParsingResult(RealDataItem* item) const
specularItem->getItem(SpecularDataItem::P_AXES_UNITS)->setVisible(true);
auto label_map = AxisNames::specAxis;
- const auto xAxisTitle = QString::fromStdString(label_map[Axes::Units::QSPACE]);
+ const auto xAxisTitle = QString::fromStdString(label_map[Axes::Coords::QSPACE]);
const auto yAxisTitle = "Signal [a.u.]"; // taken from ImportDataInfo::axisLabel
specularItem->setXaxisTitle(xAxisTitle);
diff --git a/GUI/coregui/Models/DataViewUtils.cpp b/GUI/coregui/Models/DataViewUtils.cpp
index ddbbd3c1d5bd03cd1fa0643474ba7ab072c77610..ce55c8732147d4df610cc5f1dd050c2ef143b348 100644
--- a/GUI/coregui/Models/DataViewUtils.cpp
+++ b/GUI/coregui/Models/DataViewUtils.cpp
@@ -32,7 +32,7 @@ std::unique_ptr<ICoordSystem> getConverter(Data1DViewItem* view_item)
return job_item->instrumentItem()->createCoordSystem();
}
-Axes::Units selectedUnits(Data1DViewItem* view_item)
+Axes::Coords selectedUnits(Data1DViewItem* view_item)
{
auto current_unit_name =
view_item->getItemValue(Data1DViewItem::P_AXES_UNITS).value<ComboProperty>().getValue();
diff --git a/GUI/coregui/Models/InstrumentItems.cpp b/GUI/coregui/Models/InstrumentItems.cpp
index a1ef4d0340ef058e39cf0020520e50deb3ebbd1e..8491d1697dff476c6387d3cada0cc8451519ceaf 100644
--- a/GUI/coregui/Models/InstrumentItems.cpp
+++ b/GUI/coregui/Models/InstrumentItems.cpp
@@ -209,12 +209,12 @@ std::unique_ptr<ICoordSystem> SpecularInstrumentItem::createCoordSystem() const
if (auto pointwise_axis = dynamic_cast<PointwiseAxisItem*>(axis_item)) {
if (!pointwise_axis->containsNonXMLData()) // workaround for loading project
return nullptr;
- Axes::Units native_units = JobItemUtils::axesUnitsFromName(pointwise_axis->getUnitsLabel());
+ Axes::Coords native_units = JobItemUtils::axesUnitsFromName(pointwise_axis->getUnitsLabel());
return std::make_unique<AngularReflectometryConverter>(
instrument->beam(), *pointwise_axis->axis(), native_units);
} else
return std::make_unique<AngularReflectometryConverter>(
- instrument->beam(), *axis_item->createAxis(1.0), Axes::Units::DEGREES);
+ instrument->beam(), *axis_item->createAxis(1.0), Axes::Coords::DEGREES);
}
QString SpecularInstrumentItem::defaultName() const
diff --git a/GUI/coregui/Models/JobItemUtils.cpp b/GUI/coregui/Models/JobItemUtils.cpp
index c6f3282c926385501c5ae2e0622e5e2b1fe2b5dc..420d1fcfc093f8b37dab8f4ad65b69301d0d6f37 100644
--- a/GUI/coregui/Models/JobItemUtils.cpp
+++ b/GUI/coregui/Models/JobItemUtils.cpp
@@ -25,20 +25,20 @@
namespace {
-const std::map<QString, Axes::Units> units_from_names{{"nbins", Axes::Units::NBINS},
- {"Radians", Axes::Units::RADIANS},
- {"Degrees", Axes::Units::DEGREES},
- {"mm", Axes::Units::MM},
- {"q-space", Axes::Units::QSPACE}};
-
-const std::map<Axes::Units, QString> names_from_units{{Axes::Units::NBINS, "nbins"},
- {Axes::Units::RADIANS, "Radians"},
- {Axes::Units::MM, "mm"},
- {Axes::Units::QSPACE, "q-space"},
- {Axes::Units::DEGREES, "Degrees"}};
+const std::map<QString, Axes::Coords> units_from_names{{"nbins", Axes::Coords::NBINS},
+ {"Radians", Axes::Coords::RADIANS},
+ {"Degrees", Axes::Coords::DEGREES},
+ {"mm", Axes::Coords::MM},
+ {"q-space", Axes::Coords::QSPACE}};
+
+const std::map<Axes::Coords, QString> names_from_units{{Axes::Coords::NBINS, "nbins"},
+ {Axes::Coords::RADIANS, "Radians"},
+ {Axes::Coords::MM, "mm"},
+ {Axes::Coords::QSPACE, "q-space"},
+ {Axes::Coords::DEGREES, "Degrees"}};
//! Updates axes' titles
-void updateAxesTitle(DataItem* intensityItem, const ICoordSystem& converter, Axes::Units units)
+void updateAxesTitle(DataItem* intensityItem, const ICoordSystem& converter, Axes::Coords units)
{
intensityItem->setXaxisTitle(QString::fromStdString(converter.axisName(0, units)));
if (converter.dimension() > 1)
@@ -65,7 +65,7 @@ void JobItemUtils::updateDataAxes(DataItem* intensityItem, const InstrumentItem*
if (!intensityItem->getOutputData())
return;
- Axes::Units requested_units = axesUnitsFromName(intensityItem->selectedAxesUnits());
+ Axes::Coords requested_units = axesUnitsFromName(intensityItem->selectedAxesUnits());
const auto converter = instrumentItem->createCoordSystem();
auto newData = converter->createOutputData(requested_units);
@@ -78,7 +78,7 @@ void JobItemUtils::updateDataAxes(DataItem* intensityItem, const InstrumentItem*
//! Correspondence of domain detector axes types to their GUI counterpart.
-QString JobItemUtils::nameFromAxesUnits(Axes::Units units)
+QString JobItemUtils::nameFromAxesUnits(Axes::Coords units)
{
const auto it = names_from_units.find(units);
if (it == names_from_units.end())
@@ -88,7 +88,7 @@ QString JobItemUtils::nameFromAxesUnits(Axes::Units units)
//! Correspondence of GUI axes units names to their domain counterpart.
-Axes::Units JobItemUtils::axesUnitsFromName(const QString& name)
+Axes::Coords JobItemUtils::axesUnitsFromName(const QString& name)
{
return units_from_names.at(name);
}
diff --git a/GUI/coregui/Models/JobItemUtils.h b/GUI/coregui/Models/JobItemUtils.h
index 949c7be21b7f920accbf837de78b31c5b82dc7ac..6eb6f060bd7a6e366bf34089aecbb5a608234a5b 100644
--- a/GUI/coregui/Models/JobItemUtils.h
+++ b/GUI/coregui/Models/JobItemUtils.h
@@ -34,10 +34,10 @@ namespace JobItemUtils {
void updateDataAxes(DataItem* intensityItem, const InstrumentItem* instrumentItem);
//! returns axes units names from their domain counterpart
-QString nameFromAxesUnits(Axes::Units units);
+QString nameFromAxesUnits(Axes::Coords units);
//! returns domain axes units type from their GUI name
-Axes::Units axesUnitsFromName(const QString& name);
+Axes::Coords axesUnitsFromName(const QString& name);
void setIntensityItemAxesUnits(DataItem* intensityItem, const InstrumentItem* instrumentItem);
diff --git a/GUI/coregui/Models/PointwiseAxisItem.cpp b/GUI/coregui/Models/PointwiseAxisItem.cpp
index 27f02d6a780df5f120de639ad434f19d91c4dac0..646d707fb93924481eea01482a11d93d355d4c82 100644
--- a/GUI/coregui/Models/PointwiseAxisItem.cpp
+++ b/GUI/coregui/Models/PointwiseAxisItem.cpp
@@ -76,7 +76,7 @@ std::unique_ptr<IAxis> PointwiseAxisItem::createAxis(double scale) const
return nullptr;
const auto converter = m_instrument->createCoordSystem();
- const auto converted_axis = converter->createConvertedAxis(0, Axes::Units::DEGREES);
+ const auto converted_axis = converter->createConvertedAxis(0, Axes::Coords::DEGREES);
// applying scaling
std::vector<double> centers = converted_axis->binCenters();
@@ -147,8 +147,8 @@ void PointwiseAxisItem::updateIndicators()
return;
const auto converter = m_instrument->createCoordSystem();
- setLowerBound(converter->calculateMin(0, Axes::Units::DEGREES));
- setUpperBound(converter->calculateMax(0, Axes::Units::DEGREES));
+ setLowerBound(converter->calculateMin(0, Axes::Coords::DEGREES));
+ setUpperBound(converter->calculateMax(0, Axes::Coords::DEGREES));
setBinCount(static_cast<int>(m_axis->size()));
emitDataChanged();
diff --git a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.cpp b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.cpp
index 2f68a9a26ff9cab897291f70288056019a3c98b2..bf652ba20a58f46d450cd372f2f47472d97567de 100644
--- a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.cpp
@@ -66,7 +66,7 @@ void CsvIntensityColumn::resetColumn(int colNum, double multiplier, csv::DataCol
/*Csv Coordinate Column*/
// Constructors:
-CsvCoordinateColumn::CsvCoordinateColumn() : CsvIntensityColumn(), m_units(Axes::Units::NBINS) {}
+CsvCoordinateColumn::CsvCoordinateColumn() : CsvIntensityColumn(), m_units(Axes::Coords::NBINS) {}
CsvCoordinateColumn::CsvCoordinateColumn(const CsvCoordinateColumn& toCopy)
: CsvIntensityColumn(toCopy), m_units(toCopy.units())
@@ -74,13 +74,13 @@ CsvCoordinateColumn::CsvCoordinateColumn(const CsvCoordinateColumn& toCopy)
}
CsvCoordinateColumn::CsvCoordinateColumn(int colNum, double multiplier, csv::DataColumn values,
- Axes::Units units)
+ Axes::Coords units)
: CsvIntensityColumn(colNum, multiplier, values), m_units(units)
{
}
-Axes::Units CsvCoordinateColumn::units() const
+Axes::Coords CsvCoordinateColumn::units() const
{
return m_units;
}
@@ -90,7 +90,7 @@ void CsvCoordinateColumn::setName(csv::ColumnType const name)
m_name = name;
}
void CsvCoordinateColumn::resetColumn(int colNum, double multiplier, csv::DataColumn values,
- Axes::Units units, csv::ColumnType name)
+ Axes::Coords units, csv::ColumnType name)
{
CsvIntensityColumn::resetColumn(colNum, multiplier, values);
m_units = units;
diff --git a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.h b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.h
index 4b610e9478733f0fe9ea9fd23635ddf668020be7..e651115820897aefe36c72da0b8976e3307772bf 100644
--- a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.h
+++ b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvDataColumn.h
@@ -47,20 +47,20 @@ public:
// Constructors:
CsvCoordinateColumn();
CsvCoordinateColumn(const CsvCoordinateColumn& toCopy);
- CsvCoordinateColumn(int colNum, double multiplier, csv::DataColumn values, Axes::Units units);
+ CsvCoordinateColumn(int colNum, double multiplier, csv::DataColumn values, Axes::Coords units);
// Getters:
- Axes::Units units() const;
+ Axes::Coords units() const;
csv::ColumnType name() const { return m_name; }
// Setters:
void setName(csv::ColumnType const name);
void resetColumn(int colNum = -1, double multiplier = 1., csv::DataColumn values = {},
- Axes::Units units = Axes::Units::NBINS,
+ Axes::Coords units = Axes::Coords::NBINS,
csv::ColumnType name = csv::_intensity_);
private:
- Axes::Units m_units;
+ Axes::Coords m_units;
csv::ColumnType m_name;
};
diff --git a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.cpp b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.cpp
index 25f6fe5b98f51d588f65ed93f18f638a006a6f99..a72c6ba34edabbf84d31974b0faa4be6508b61a7 100644
--- a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.cpp
@@ -39,7 +39,7 @@ CsvImportAssistant::CsvImportAssistant(const QString& file, const bool useGUI, Q
, m_coordinateMultiplier(1.0)
, m_firstRow(-1)
, m_lastRow(-1)
- , m_units(Axes::Units::NBINS)
+ , m_units(Axes::Coords::NBINS)
, m_dataAvailable(false)
{
if (!loadCsvFile()) {
@@ -51,7 +51,7 @@ CsvImportAssistant::CsvImportAssistant(const QString& file, const bool useGUI, Q
} else {
m_intensityColNum = 0;
m_coordinateColNum = -1;
- m_units = Axes::Units::NBINS;
+ m_units = Axes::Coords::NBINS;
m_firstRow = 0;
m_lastRow = int(m_csvFile->NumberOfRows() - 1);
m_dataAvailable = true;
@@ -95,7 +95,7 @@ void CsvImportAssistant::setIntensityColumn(int iCol, double multiplier)
m_intensityColNum = iCol - 1;
m_intensityMultiplier = multiplier;
}
-void CsvImportAssistant::setCoordinateColumn(int iCol, Axes::Units units, double multiplier)
+void CsvImportAssistant::setCoordinateColumn(int iCol, Axes::Coords units, double multiplier)
{
m_coordinateColNum = iCol - 1;
m_units = units;
@@ -384,6 +384,6 @@ void CsvImportAssistant::resetSelection()
m_coordinateColNum = -1;
m_firstRow = -1;
m_lastRow = -1;
- m_units = Axes::Units::NBINS;
+ m_units = Axes::Coords::NBINS;
m_dataAvailable = false;
}
diff --git a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.h b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.h
index ccdc78149060768f3f7a7c52570887e0b578f620..231069f14057b8f5f73bce7a211472ee56eb6f9a 100644
--- a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.h
+++ b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportAssistant.h
@@ -33,7 +33,7 @@ public:
, m_coordinateMultiplier(1.)
, m_firstRow(-1)
, m_lastRow(-1)
- , m_units(Axes::Units::NBINS)
+ , m_units(Axes::Coords::NBINS)
{
}
@@ -43,7 +43,7 @@ public:
double m_coordinateMultiplier;
int m_firstRow;
int m_lastRow;
- Axes::Units m_units;
+ Axes::Coords m_units;
bool availableData() { return m_intensityColNum > -1; }
};
@@ -55,7 +55,7 @@ public:
CsvImportAssistant(const QString& file, const bool useGUI = false, QWidget* parent = nullptr);
static void showErrorMessage(std::string message);
void setIntensityColumn(int iCol, double multiplier = 1.0);
- void setCoordinateColumn(int iCol, Axes::Units units, double multiplier = 1.0);
+ void setCoordinateColumn(int iCol, Axes::Coords units, double multiplier = 1.0);
void setFirstRow(int iRow);
void setLastRow(int iRow);
size_t columnCount() { return m_csvArray[0].size(); }
@@ -84,7 +84,7 @@ private:
int m_firstRow;
int m_lastRow;
std::set<int> m_rowsToDiscard;
- Axes::Units m_units;
+ Axes::Coords m_units;
bool m_dataAvailable;
};
#endif // BORNAGAIN_GUI_COREGUI_VIEWS_IMPORTDATAWIDGETS_CSVIMPORTASSISTANT_CSVIMPORTASSISTANT_H
diff --git a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportTable.cpp b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportTable.cpp
index ad1e1bf7b6a7e665c0f196b5d2f893c822b9c79d..a28be408a6e46f1390389d25a998e76853989a89 100644
--- a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportTable.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/CsvImportTable.cpp
@@ -168,14 +168,14 @@ QString CsvImportData::columnLabel(CsvImportData::DATA_TYPE type) const
QList<QString> CsvImportData::availableCoordinateUnits() const
{
if (column(Coordinate) < 0)
- return {axisUnitLabel.at(Axes::Units::NBINS)};
+ return {axisUnitLabel.at(Axes::Coords::NBINS)};
auto coordinate_type = m_selected_cols.at(Coordinate).name();
if (coordinate_type == csv::_q_)
- return {axisUnitLabel.at(Axes::Units::QSPACE)};
+ return {axisUnitLabel.at(Axes::Coords::QSPACE)};
else if (coordinate_type == csv::_theta_)
- return {{axisUnitLabel.at(Axes::Units::DEGREES)}, {axisUnitLabel.at(Axes::Units::RADIANS)}};
- return {axisUnitLabel.at(Axes::Units::NBINS)};
+ return {{axisUnitLabel.at(Axes::Coords::DEGREES)}, {axisUnitLabel.at(Axes::Coords::RADIANS)}};
+ return {axisUnitLabel.at(Axes::Coords::NBINS)};
}
size_t CsvImportData::nCols() const
diff --git a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.cpp b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.cpp
index 9f77e942b7c64ecb0e64a4238f22652ce0581c96..d7fb7ad8292abdb615d0730cef529a8867cc54b3 100644
--- a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.cpp
@@ -143,7 +143,7 @@ void DataSelector::updateSelection()
m_coordinateUnitsComboBox->setEnabled(true);
} else {
m_coordinateUnitsComboBox->clear();
- m_coordinateUnitsComboBox->addItem(axisUnitLabel.at(Axes::Units::NBINS));
+ m_coordinateUnitsComboBox->addItem(axisUnitLabel.at(Axes::Coords::NBINS));
}
}
@@ -227,14 +227,14 @@ size_t DataSelector::maxLines() const
return size_t(m_lastDataRowSpinBox->maximum());
}
-Axes::Units DataSelector::units() const
+Axes::Coords DataSelector::units() const
{
for (int i = 0; i < csv::UnitsLabels.size(); i++) {
- const Axes::Units u = static_cast<Axes::Units>(i);
+ const Axes::Coords u = static_cast<Axes::Coords>(i);
if (m_coordinateUnitsComboBox->currentText() == QString(axisUnitLabel.at(u)))
return u;
}
- return Axes::Units::NBINS; // default
+ return Axes::Coords::NBINS; // default
}
char DataSelector::separator() const
@@ -327,7 +327,7 @@ QBoxLayout* DataSelector::createLayout()
m_coordinateUnitsComboBox = new QComboBox();
m_coordinateUnitsComboBox->setMaximumWidth(70);
m_coordinateUnitsComboBox->setMinimumWidth(70);
- m_coordinateUnitsComboBox->addItem(axisUnitLabel.at(Axes::Units::NBINS));
+ m_coordinateUnitsComboBox->addItem(axisUnitLabel.at(Axes::Coords::NBINS));
auto layout = new QVBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
diff --git a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.h b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.h
index 49fcbcd3682d40a2f6506cdf1a3c3996596bc3d6..2cefcad940fb9506858d84adb11dd71d6ba9880f 100644
--- a/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.h
+++ b/GUI/coregui/Views/ImportDataWidgets/CsvImportAssistant/DataSelector.h
@@ -40,7 +40,7 @@ public:
double intensityMultiplier() const { return m_tableWidget->intensityMultiplier(); }
double coordinateMultiplier() const { return m_tableWidget->coordinateMultiplier(); }
std::set<int> rowsToDiscard() const { return m_tableWidget->rowsToDiscard(); }
- Axes::Units units() const;
+ Axes::Coords units() const;
void setDataArray(csv::DataArray csvArray)
{
m_data = std::move(csvArray);
diff --git a/GUI/coregui/Views/ImportDataWidgets/ImportDataUtils.cpp b/GUI/coregui/Views/ImportDataWidgets/ImportDataUtils.cpp
index 09233b697186fcccbf235b7ad8e75957d8f034a9..719e849113e3c1be3df29eeed89fb766834d1da3 100644
--- a/GUI/coregui/Views/ImportDataWidgets/ImportDataUtils.cpp
+++ b/GUI/coregui/Views/ImportDataWidgets/ImportDataUtils.cpp
@@ -93,7 +93,7 @@ QString ImportDataUtils::Import1dData(RealDataItem* realDataItem,
|| DataFormatUtils::isIntFile(fileNameStdString)
|| DataFormatUtils::isTiffFile(fileNameStdString)) {
try {
- ImportDataInfo info(ImportKnownData(fileName), Axes::Units::QSPACE);
+ ImportDataInfo info(ImportKnownData(fileName), Axes::Coords::QSPACE);
if (info) {
realDataItem->setImportData(std::move(info));
return QString();
diff --git a/GUI/coregui/utils/ImportDataInfo.cpp b/GUI/coregui/utils/ImportDataInfo.cpp
index 11e0f748dd529df76e739a6669dd368144814bcf..979e2eb62ae6b49e109db391dc6e0b37ceee9953 100644
--- a/GUI/coregui/utils/ImportDataInfo.cpp
+++ b/GUI/coregui/utils/ImportDataInfo.cpp
@@ -19,17 +19,17 @@
#include "GUI/coregui/utils/GUIHelpers.h"
namespace {
-std::vector<Axes::Units> specularUnits()
+std::vector<Axes::Coords> specularUnits()
{
- std::vector<Axes::Units> result;
+ std::vector<Axes::Coords> result;
for (auto& pair : AxisNames::specAxis)
result.push_back(pair.first);
return result;
}
// map: data rank --> available units
-std::map<size_t, std::vector<Axes::Units>> available_units = {{1u, specularUnits()},
- {2u, {Axes::Units::NBINS}}};
+std::map<size_t, std::vector<Axes::Coords>> available_units = {{1u, specularUnits()},
+ {2u, {Axes::Coords::NBINS}}};
} // namespace
ImportDataInfo::ImportDataInfo(ImportDataInfo&& other)
@@ -37,8 +37,8 @@ ImportDataInfo::ImportDataInfo(ImportDataInfo&& other)
{
}
-ImportDataInfo::ImportDataInfo(std::unique_ptr<OutputData<double>> data, Axes::Units units)
- : m_data(units == Axes::Units::NBINS && data ? ImportDataUtils::binifyAxes(*data)
+ImportDataInfo::ImportDataInfo(std::unique_ptr<OutputData<double>> data, Axes::Coords units)
+ : m_data(units == Axes::Coords::NBINS && data ? ImportDataUtils::binifyAxes(*data)
: std::move(data))
, m_units(units)
{
@@ -51,7 +51,7 @@ ImportDataInfo::ImportDataInfo(std::unique_ptr<OutputData<double>> data, const Q
checkValidity();
}
-ImportDataInfo::ImportDataInfo(OutputData<double>&& data, Axes::Units units)
+ImportDataInfo::ImportDataInfo(OutputData<double>&& data, Axes::Coords units)
: ImportDataInfo(std::unique_ptr<OutputData<double>>(new OutputData<double>(std::move(data))),
units)
{
diff --git a/GUI/coregui/utils/ImportDataInfo.h b/GUI/coregui/utils/ImportDataInfo.h
index c7cf58952b07be3ffee4c33c2e6a72b06f798701..6649eb07f8cff06cd920f74b81d3e300178b73bc 100644
--- a/GUI/coregui/utils/ImportDataInfo.h
+++ b/GUI/coregui/utils/ImportDataInfo.h
@@ -27,8 +27,8 @@ class ImportDataInfo {
public:
ImportDataInfo() = delete;
ImportDataInfo(ImportDataInfo&& other);
- ImportDataInfo(std::unique_ptr<OutputData<double>> data, Axes::Units units);
- ImportDataInfo(OutputData<double>&& data, Axes::Units units);
+ ImportDataInfo(std::unique_ptr<OutputData<double>> data, Axes::Coords units);
+ ImportDataInfo(OutputData<double>&& data, Axes::Coords units);
ImportDataInfo(std::unique_ptr<OutputData<double>> data, const QString& units);
~ImportDataInfo();
@@ -49,7 +49,7 @@ private:
private:
std::unique_ptr<OutputData<double>> m_data;
- Axes::Units m_units;
+ Axes::Coords m_units;
};
#endif // BORNAGAIN_GUI_COREGUI_UTILS_IMPORTDATAINFO_H
diff --git a/Tests/UnitTests/Core/Axes/UnitConverter1DTest.cpp b/Tests/UnitTests/Core/Axes/CoordSystem1DTest.cpp
similarity index 68%
rename from Tests/UnitTests/Core/Axes/UnitConverter1DTest.cpp
rename to Tests/UnitTests/Core/Axes/CoordSystem1DTest.cpp
index ec66f3fb1cc7d61686525d7725f98df1e4132b42..405598d0a93dd37cc478eb4cea45357ea215a884 100644
--- a/Tests/UnitTests/Core/Axes/UnitConverter1DTest.cpp
+++ b/Tests/UnitTests/Core/Axes/CoordSystem1DTest.cpp
@@ -34,59 +34,59 @@ CoordSystem1DTest::CoordSystem1DTest()
void CoordSystem1DTest::checkConventionalConverter(const CoordSystem1D& test_object)
{
double expected_min = m_axis.binCenter(0);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::UNDEFINED), Units::rad2deg(expected_min),
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::UNDEFINED), Units::rad2deg(expected_min),
Units::rad2deg(expected_min) * 1e-10);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::NBINS), 0.0, 1e-10);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::RADIANS), expected_min,
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::NBINS), 0.0, 1e-10);
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::RADIANS), expected_min,
expected_min * 1e-10);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::DEGREES), Units::rad2deg(expected_min),
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::DEGREES), Units::rad2deg(expected_min),
Units::rad2deg(expected_min) * 1e-10);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::QSPACE), getQ(expected_min),
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::QSPACE), getQ(expected_min),
getQ(expected_min) * 1e-10);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::RQ4), getQ(expected_min),
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::RQ4), getQ(expected_min),
getQ(expected_min) * 1e-10);
double expected_max = m_axis.binCenters().back();
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::UNDEFINED), Units::rad2deg(expected_max),
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::UNDEFINED), Units::rad2deg(expected_max),
Units::rad2deg(expected_max) * 1e-10);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::NBINS), static_cast<double>(m_axis.size()),
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::NBINS), static_cast<double>(m_axis.size()),
1e-10);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::RADIANS), expected_max,
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::RADIANS), expected_max,
expected_max * 1e-10);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::DEGREES), Units::rad2deg(expected_max),
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::DEGREES), Units::rad2deg(expected_max),
Units::rad2deg(expected_max) * 1e-10);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::QSPACE), getQ(expected_max),
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::QSPACE), getQ(expected_max),
getQ(expected_max) * 1e-10);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::RQ4), getQ(expected_max),
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::RQ4), getQ(expected_max),
getQ(expected_max) * 1e-10);
// DEFAULT
- auto axis_default = test_object.createConvertedAxis(0, Axes::Units::UNDEFINED);
+ auto axis_default = test_object.createConvertedAxis(0, Axes::Coords::UNDEFINED);
EXPECT_TRUE(dynamic_cast<const PointwiseAxis*>(axis_default.get()));
EXPECT_EQ(axis_default->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_default->lowerBound(), test_object.calculateMin(0, Axes::Units::UNDEFINED));
- EXPECT_EQ(axis_default->upperBound(), test_object.calculateMax(0, Axes::Units::UNDEFINED));
+ EXPECT_EQ(axis_default->lowerBound(), test_object.calculateMin(0, Axes::Coords::UNDEFINED));
+ EXPECT_EQ(axis_default->upperBound(), test_object.calculateMax(0, Axes::Coords::UNDEFINED));
// QSPACE
- auto axis_qspace = test_object.createConvertedAxis(0, Axes::Units::QSPACE);
+ auto axis_qspace = test_object.createConvertedAxis(0, Axes::Coords::QSPACE);
EXPECT_TRUE(dynamic_cast<const PointwiseAxis*>(axis_qspace.get()));
EXPECT_EQ(axis_qspace->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_qspace->lowerBound(), test_object.calculateMin(0, Axes::Units::QSPACE));
- EXPECT_EQ(axis_qspace->upperBound(), test_object.calculateMax(0, Axes::Units::QSPACE));
+ EXPECT_EQ(axis_qspace->lowerBound(), test_object.calculateMin(0, Axes::Coords::QSPACE));
+ EXPECT_EQ(axis_qspace->upperBound(), test_object.calculateMax(0, Axes::Coords::QSPACE));
// NBINS
- auto axis_nbins = test_object.createConvertedAxis(0, Axes::Units::NBINS);
+ auto axis_nbins = test_object.createConvertedAxis(0, Axes::Coords::NBINS);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis_nbins.get()));
EXPECT_EQ(axis_nbins->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_nbins->lowerBound(), test_object.calculateMin(0, Axes::Units::NBINS));
- EXPECT_EQ(axis_nbins->upperBound(), test_object.calculateMax(0, Axes::Units::NBINS));
+ EXPECT_EQ(axis_nbins->lowerBound(), test_object.calculateMin(0, Axes::Coords::NBINS));
+ EXPECT_EQ(axis_nbins->upperBound(), test_object.calculateMax(0, Axes::Coords::NBINS));
// RQ4
- auto axis_rq4 = test_object.createConvertedAxis(0, Axes::Units::RQ4);
+ auto axis_rq4 = test_object.createConvertedAxis(0, Axes::Coords::RQ4);
EXPECT_TRUE(dynamic_cast<const PointwiseAxis*>(axis_rq4.get()));
EXPECT_EQ(axis_rq4->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_rq4->lowerBound(), test_object.calculateMin(0, Axes::Units::RQ4));
- EXPECT_EQ(axis_rq4->upperBound(), test_object.calculateMax(0, Axes::Units::RQ4));
+ EXPECT_EQ(axis_rq4->lowerBound(), test_object.calculateMin(0, Axes::Coords::RQ4));
+ EXPECT_EQ(axis_rq4->upperBound(), test_object.calculateMax(0, Axes::Coords::RQ4));
EXPECT_TRUE(*axis_rq4 == *axis_qspace);
OutputData<double> fake_data;
@@ -95,13 +95,13 @@ void CoordSystem1DTest::checkConventionalConverter(const CoordSystem1D& test_obj
fake_data.setRawDataVector(raw_fake);
// NBINS
- auto data_nbins = test_object.createConvertedData(fake_data, Axes::Units::NBINS);
+ auto data_nbins = test_object.createConvertedData(fake_data, Axes::Coords::NBINS);
EXPECT_EQ(data_nbins->axis(0), *axis_nbins);
EXPECT_EQ(data_nbins->getAllocatedSize(), axis_nbins->size());
EXPECT_EQ(raw_fake, data_nbins->getRawDataVector());
// RQ4
- auto data_rq4 = test_object.createConvertedData(fake_data, Axes::Units::RQ4);
+ auto data_rq4 = test_object.createConvertedData(fake_data, Axes::Coords::RQ4);
EXPECT_EQ(data_rq4->axis(0), *axis_rq4);
auto raw_data_rq4 = data_rq4->getRawDataVector();
EXPECT_EQ(raw_data_rq4.size(), raw_fake.size());
@@ -115,46 +115,46 @@ void CoordSystem1DTest::checkConventionalConverter(const CoordSystem1D& test_obj
void CoordSystem1DTest::checkQSpecConverter(const CoordSystem1D& test_object)
{
double expected_min = m_q_axis.binCenter(0);
- EXPECT_EQ(test_object.calculateMin(0, Axes::Units::UNDEFINED), expected_min);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::NBINS), 0.0, 1e-10);
- EXPECT_EQ(test_object.calculateMin(0, Axes::Units::QSPACE), expected_min);
- EXPECT_EQ(test_object.calculateMin(0, Axes::Units::RQ4), expected_min);
+ EXPECT_EQ(test_object.calculateMin(0, Axes::Coords::UNDEFINED), expected_min);
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::NBINS), 0.0, 1e-10);
+ EXPECT_EQ(test_object.calculateMin(0, Axes::Coords::QSPACE), expected_min);
+ EXPECT_EQ(test_object.calculateMin(0, Axes::Coords::RQ4), expected_min);
double expected_max = m_q_axis.binCenters().back();
- EXPECT_EQ(test_object.calculateMax(0, Axes::Units::UNDEFINED), expected_max);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::NBINS),
+ EXPECT_EQ(test_object.calculateMax(0, Axes::Coords::UNDEFINED), expected_max);
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::NBINS),
static_cast<double>(m_q_axis.size()), 1e-10);
- EXPECT_EQ(test_object.calculateMax(0, Axes::Units::QSPACE), expected_max);
- EXPECT_EQ(test_object.calculateMax(0, Axes::Units::RQ4), expected_max);
+ EXPECT_EQ(test_object.calculateMax(0, Axes::Coords::QSPACE), expected_max);
+ EXPECT_EQ(test_object.calculateMax(0, Axes::Coords::RQ4), expected_max);
// DEFAULT
- auto axis_default = test_object.createConvertedAxis(0, Axes::Units::UNDEFINED);
+ auto axis_default = test_object.createConvertedAxis(0, Axes::Coords::UNDEFINED);
EXPECT_TRUE(dynamic_cast<const PointwiseAxis*>(axis_default.get()));
EXPECT_EQ(axis_default->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_default->lowerBound(), test_object.calculateMin(0, Axes::Units::UNDEFINED));
- EXPECT_EQ(axis_default->upperBound(), test_object.calculateMax(0, Axes::Units::UNDEFINED));
+ EXPECT_EQ(axis_default->lowerBound(), test_object.calculateMin(0, Axes::Coords::UNDEFINED));
+ EXPECT_EQ(axis_default->upperBound(), test_object.calculateMax(0, Axes::Coords::UNDEFINED));
// QSPACE
- auto axis_qspace = test_object.createConvertedAxis(0, Axes::Units::QSPACE);
+ auto axis_qspace = test_object.createConvertedAxis(0, Axes::Coords::QSPACE);
EXPECT_TRUE(dynamic_cast<const PointwiseAxis*>(axis_qspace.get()));
EXPECT_EQ(axis_qspace->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_qspace->lowerBound(), test_object.calculateMin(0, Axes::Units::QSPACE));
- EXPECT_EQ(axis_qspace->upperBound(), test_object.calculateMax(0, Axes::Units::QSPACE));
+ EXPECT_EQ(axis_qspace->lowerBound(), test_object.calculateMin(0, Axes::Coords::QSPACE));
+ EXPECT_EQ(axis_qspace->upperBound(), test_object.calculateMax(0, Axes::Coords::QSPACE));
EXPECT_EQ(*axis_default, *axis_qspace);
// NBINS
- auto axis_nbins = test_object.createConvertedAxis(0, Axes::Units::NBINS);
+ auto axis_nbins = test_object.createConvertedAxis(0, Axes::Coords::NBINS);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis_nbins.get()));
EXPECT_EQ(axis_nbins->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_nbins->lowerBound(), test_object.calculateMin(0, Axes::Units::NBINS));
- EXPECT_EQ(axis_nbins->upperBound(), test_object.calculateMax(0, Axes::Units::NBINS));
+ EXPECT_EQ(axis_nbins->lowerBound(), test_object.calculateMin(0, Axes::Coords::NBINS));
+ EXPECT_EQ(axis_nbins->upperBound(), test_object.calculateMax(0, Axes::Coords::NBINS));
// RQ4
- auto axis_rq4 = test_object.createConvertedAxis(0, Axes::Units::RQ4);
+ auto axis_rq4 = test_object.createConvertedAxis(0, Axes::Coords::RQ4);
EXPECT_TRUE(dynamic_cast<const PointwiseAxis*>(axis_rq4.get()));
EXPECT_EQ(axis_rq4->size(), test_object.axisSize(0));
- EXPECT_EQ(axis_rq4->lowerBound(), test_object.calculateMin(0, Axes::Units::RQ4));
- EXPECT_EQ(axis_rq4->upperBound(), test_object.calculateMax(0, Axes::Units::RQ4));
+ EXPECT_EQ(axis_rq4->lowerBound(), test_object.calculateMin(0, Axes::Coords::RQ4));
+ EXPECT_EQ(axis_rq4->upperBound(), test_object.calculateMax(0, Axes::Coords::RQ4));
EXPECT_TRUE(*axis_rq4 == *axis_qspace);
OutputData<double> fake_data;
@@ -163,13 +163,13 @@ void CoordSystem1DTest::checkQSpecConverter(const CoordSystem1D& test_object)
fake_data.setRawDataVector(raw_fake);
// NBINS
- auto data_nbins = test_object.createConvertedData(fake_data, Axes::Units::NBINS);
+ auto data_nbins = test_object.createConvertedData(fake_data, Axes::Coords::NBINS);
EXPECT_EQ(data_nbins->axis(0), *axis_nbins);
EXPECT_EQ(data_nbins->getAllocatedSize(), axis_nbins->size());
EXPECT_EQ(raw_fake, data_nbins->getRawDataVector());
// RQ4
- auto data_rq4 = test_object.createConvertedData(fake_data, Axes::Units::RQ4);
+ auto data_rq4 = test_object.createConvertedData(fake_data, Axes::Coords::RQ4);
EXPECT_EQ(data_rq4->axis(0), *axis_rq4);
auto raw_data_rq4 = data_rq4->getRawDataVector();
EXPECT_EQ(raw_data_rq4.size(), raw_fake.size());
@@ -190,32 +190,32 @@ TEST_F(CoordSystem1DTest, Exceptions)
{
AngularReflectometryConverter converter(m_beam, m_axis);
- EXPECT_THROW(converter.calculateMin(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.calculateMin(1, Axes::Units::RADIANS), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(1, Axes::Coords::RADIANS), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(1, Axes::Units::RADIANS), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(1, Axes::Coords::RADIANS), std::runtime_error);
- EXPECT_THROW(converter.createConvertedAxis(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.createConvertedAxis(1, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(1, Axes::Coords::UNDEFINED), std::runtime_error);
FixedBinAxis axis("Angles", 100, 0.0, 2.0 * M_PI);
EXPECT_THROW(AngularReflectometryConverter converter2(m_beam, axis), std::runtime_error);
WavenumberReflectometryConverter converter2(m_qscan);
// wrong units
- EXPECT_THROW(converter2.calculateMin(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter2.calculateMin(0, Axes::Units::RADIANS), std::runtime_error);
- EXPECT_THROW(converter2.calculateMin(0, Axes::Units::DEGREES), std::runtime_error);
- EXPECT_THROW(converter2.calculateMax(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter2.calculateMax(0, Axes::Units::RADIANS), std::runtime_error);
- EXPECT_THROW(converter2.calculateMax(0, Axes::Units::DEGREES), std::runtime_error);
- EXPECT_THROW(converter2.createConvertedAxis(0, Axes::Units::MM), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMin(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMin(0, Axes::Coords::RADIANS), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMin(0, Axes::Coords::DEGREES), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMax(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMax(0, Axes::Coords::RADIANS), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMax(0, Axes::Coords::DEGREES), std::runtime_error);
+ EXPECT_THROW(converter2.createConvertedAxis(0, Axes::Coords::MM), std::runtime_error);
// wrong axis index
- EXPECT_THROW(converter2.calculateMin(1, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(converter2.calculateMax(1, Axes::Units::RQ4), std::runtime_error);
- EXPECT_THROW(converter2.createConvertedAxis(1, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMin(1, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(converter2.calculateMax(1, Axes::Coords::RQ4), std::runtime_error);
+ EXPECT_THROW(converter2.createConvertedAxis(1, Axes::Coords::UNDEFINED), std::runtime_error);
}
TEST_F(CoordSystem1DTest, Clone)
@@ -233,11 +233,11 @@ TEST_F(CoordSystem1DTest, NonDefaultUnitsInInput)
{
PointwiseAxis axis("x", std::vector<double>{0.0, 0.5, 1.0});
- EXPECT_THROW(AngularReflectometryConverter(m_beam, axis, Axes::Units::NBINS),
+ EXPECT_THROW(AngularReflectometryConverter(m_beam, axis, Axes::Coords::NBINS),
std::runtime_error);
- AngularReflectometryConverter converter(m_beam, axis, Axes::Units::DEGREES);
- auto axis_deg_output = converter.createConvertedAxis(0, Axes::Units::DEGREES);
+ AngularReflectometryConverter converter(m_beam, axis, Axes::Coords::DEGREES);
+ auto axis_deg_output = converter.createConvertedAxis(0, Axes::Coords::DEGREES);
EXPECT_TRUE(axis.size() == axis_deg_output->size());
EXPECT_DOUBLE_EQ(axis[0], (*axis_deg_output)[0]);
EXPECT_DOUBLE_EQ(axis[1], (*axis_deg_output)[1]);
@@ -246,13 +246,13 @@ TEST_F(CoordSystem1DTest, NonDefaultUnitsInInput)
auto values = axis.binCenters();
std::for_each(values.begin(), values.end(), [this](double& value) { value = getQ(value); });
PointwiseAxis q_axis("q", values);
- AngularReflectometryConverter converter2(m_beam, q_axis, Axes::Units::QSPACE);
- auto axis_rad_output = converter2.createConvertedAxis(0, Axes::Units::RADIANS);
+ AngularReflectometryConverter converter2(m_beam, q_axis, Axes::Coords::QSPACE);
+ auto axis_rad_output = converter2.createConvertedAxis(0, Axes::Coords::RADIANS);
EXPECT_TRUE(axis.size() == axis_rad_output->size());
EXPECT_DOUBLE_EQ(axis[0], (*axis_rad_output)[0]);
EXPECT_DOUBLE_EQ(axis[1], (*axis_rad_output)[1]);
EXPECT_DOUBLE_EQ(axis[2], (*axis_rad_output)[2]);
- EXPECT_THROW(AngularReflectometryConverter(m_beam, q_axis, Axes::Units::RQ4),
+ EXPECT_THROW(AngularReflectometryConverter(m_beam, q_axis, Axes::Coords::RQ4),
std::runtime_error);
}
diff --git a/Tests/UnitTests/Core/Core/DepthProbeConverterTest.cpp b/Tests/UnitTests/Core/Core/DepthProbeConverterTest.cpp
index d047688e677d83e4ab88e589761b2114adddffa9..cf92a8018d1a563ccc2424e87795c7f49378b0d7 100644
--- a/Tests/UnitTests/Core/Core/DepthProbeConverterTest.cpp
+++ b/Tests/UnitTests/Core/Core/DepthProbeConverterTest.cpp
@@ -10,8 +10,8 @@ protected:
DepthProbeConverterTest();
void checkMainFunctionality(const DepthProbeConverter& test_object);
- void checkAlphaAxis(Axes::Units units, const DepthProbeConverter& test_object);
- void checkZAxis(Axes::Units units, const DepthProbeConverter& test_object);
+ void checkAlphaAxis(Axes::Coords units, const DepthProbeConverter& test_object);
+ void checkZAxis(Axes::Coords units, const DepthProbeConverter& test_object);
const double m_alpha_start = 0.5; // first axis value in rads
const double m_alpha_end = 1.0; // last axis value in rads
const double m_z_start = -30.0;
@@ -33,39 +33,39 @@ void DepthProbeConverterTest::checkMainFunctionality(const DepthProbeConverter&
{
EXPECT_EQ(test_object.dimension(), 2u);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::UNDEFINED), 2.8647889757e+1,
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::UNDEFINED), 2.8647889757e+1,
2.8647889757e+1 * 1e-10);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::DEGREES), 2.8647889757e+1,
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::DEGREES), 2.8647889757e+1,
2.8647889757e+1 * 1e-10);
- EXPECT_NEAR(test_object.calculateMin(0, Axes::Units::QSPACE), 6.0246390001,
+ EXPECT_NEAR(test_object.calculateMin(0, Axes::Coords::QSPACE), 6.0246390001,
6.0246390001 * 1e-10);
- EXPECT_EQ(test_object.calculateMin(0, Axes::Units::RADIANS), m_alpha_start);
- EXPECT_EQ(test_object.calculateMin(0, Axes::Units::NBINS), 0.0);
+ EXPECT_EQ(test_object.calculateMin(0, Axes::Coords::RADIANS), m_alpha_start);
+ EXPECT_EQ(test_object.calculateMin(0, Axes::Coords::NBINS), 0.0);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::UNDEFINED), 5.7295779513e+1,
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::UNDEFINED), 5.7295779513e+1,
5.7295779513e+1 * 1e-10);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::DEGREES), 5.7295779513e+1,
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::DEGREES), 5.7295779513e+1,
5.7295779513e+1 * 1e-10);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::QSPACE), 1.0574236256e+1,
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::QSPACE), 1.0574236256e+1,
1.0574236256e+1 * 1e-10);
- EXPECT_EQ(test_object.calculateMax(0, Axes::Units::RADIANS), m_alpha_end);
+ EXPECT_EQ(test_object.calculateMax(0, Axes::Coords::RADIANS), m_alpha_end);
const double n_bins = static_cast<double>(m_nbins);
- EXPECT_NEAR(test_object.calculateMax(0, Axes::Units::NBINS), n_bins, n_bins * 1e-10);
-
- checkAlphaAxis(Axes::Units::UNDEFINED, test_object);
- checkAlphaAxis(Axes::Units::DEGREES, test_object);
- checkAlphaAxis(Axes::Units::RADIANS, test_object);
- checkAlphaAxis(Axes::Units::QSPACE, test_object);
- checkAlphaAxis(Axes::Units::NBINS, test_object);
-
- checkZAxis(Axes::Units::UNDEFINED, test_object);
- checkZAxis(Axes::Units::DEGREES, test_object);
- checkZAxis(Axes::Units::RADIANS, test_object);
- checkZAxis(Axes::Units::QSPACE, test_object);
- checkZAxis(Axes::Units::NBINS, test_object);
+ EXPECT_NEAR(test_object.calculateMax(0, Axes::Coords::NBINS), n_bins, n_bins * 1e-10);
+
+ checkAlphaAxis(Axes::Coords::UNDEFINED, test_object);
+ checkAlphaAxis(Axes::Coords::DEGREES, test_object);
+ checkAlphaAxis(Axes::Coords::RADIANS, test_object);
+ checkAlphaAxis(Axes::Coords::QSPACE, test_object);
+ checkAlphaAxis(Axes::Coords::NBINS, test_object);
+
+ checkZAxis(Axes::Coords::UNDEFINED, test_object);
+ checkZAxis(Axes::Coords::DEGREES, test_object);
+ checkZAxis(Axes::Coords::RADIANS, test_object);
+ checkZAxis(Axes::Coords::QSPACE, test_object);
+ checkZAxis(Axes::Coords::NBINS, test_object);
}
-void DepthProbeConverterTest::checkAlphaAxis(Axes::Units units,
+void DepthProbeConverterTest::checkAlphaAxis(Axes::Coords units,
const DepthProbeConverter& test_object)
{
auto axis = test_object.createConvertedAxis(0, units);
@@ -76,7 +76,7 @@ void DepthProbeConverterTest::checkAlphaAxis(Axes::Units units,
EXPECT_EQ(axis->upperBound(), test_object.calculateMax(0, units));
}
-void DepthProbeConverterTest::checkZAxis(Axes::Units units, const DepthProbeConverter& test_object)
+void DepthProbeConverterTest::checkZAxis(Axes::Coords units, const DepthProbeConverter& test_object)
{
auto axis = test_object.createConvertedAxis(1, units);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis.get()));
@@ -84,11 +84,11 @@ void DepthProbeConverterTest::checkZAxis(Axes::Units units, const DepthProbeConv
EXPECT_EQ(axis->size(), m_nbins);
EXPECT_EQ(axis->lowerBound(), test_object.calculateMin(1, units));
- const double test_min = units == Axes::Units::NBINS ? 0 : m_z_start;
+ const double test_min = units == Axes::Coords::NBINS ? 0 : m_z_start;
EXPECT_NEAR(axis->lowerBound(), test_min, std::abs(test_min) * 1e-10);
EXPECT_EQ(axis->upperBound(), test_object.calculateMax(1, units));
- const double test_max = units == Axes::Units::NBINS ? m_nbins : m_z_end;
+ const double test_max = units == Axes::Coords::NBINS ? m_nbins : m_z_end;
EXPECT_NEAR(axis->upperBound(), test_max, std::abs(test_max) * 1e-10);
}
@@ -102,21 +102,21 @@ TEST_F(DepthProbeConverterTest, DepthProbeConverterExceptions)
{
DepthProbeConverter converter(m_beam, m_inclination_axis, m_z_axis);
- EXPECT_THROW(converter.axisName(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.axisName(1, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.axisName(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.axisName(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.axisName(1, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.axisName(2, Axes::Coords::UNDEFINED), std::runtime_error);
- EXPECT_THROW(converter.calculateMin(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.calculateMin(1, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.calculateMin(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(1, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(2, Axes::Coords::UNDEFINED), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(1, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(2, Axes::Units::RADIANS), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(1, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(2, Axes::Coords::RADIANS), std::runtime_error);
- EXPECT_THROW(converter.createConvertedAxis(0, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.createConvertedAxis(1, Axes::Units::MM), std::runtime_error);
- EXPECT_THROW(converter.createConvertedAxis(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(0, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(1, Axes::Coords::MM), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(2, Axes::Coords::UNDEFINED), std::runtime_error);
}
TEST_F(DepthProbeConverterTest, DepthProbeConverterClone)
diff --git a/Tests/UnitTests/Core/Fresnel/DepthProbeSimulationTest.cpp b/Tests/UnitTests/Core/Fresnel/DepthProbeSimulationTest.cpp
index 98b651d38d0de0da604bf34ae377e6b3c810251b..48eb00b72d5d913525097cc9a7d34dc7f6b1cc6e 100644
--- a/Tests/UnitTests/Core/Fresnel/DepthProbeSimulationTest.cpp
+++ b/Tests/UnitTests/Core/Fresnel/DepthProbeSimulationTest.cpp
@@ -146,7 +146,7 @@ TEST_F(DepthProbeSimulationTest, ResultAquisition)
sim->runSimulation();
SimulationResult sim_result = sim->result();
- EXPECT_THROW(sim_result.histogram2d(Axes::Units::MM), std::runtime_error);
+ EXPECT_THROW(sim_result.histogram2d(Axes::Coords::MM), std::runtime_error);
const std::unique_ptr<Histogram2D> depth_map(sim_result.histogram2d());
EXPECT_EQ(10u * 12u, depth_map->getTotalNumberOfBins());
@@ -156,7 +156,7 @@ TEST_F(DepthProbeSimulationTest, ResultAquisition)
EXPECT_EQ(-30.0, depth_map->yAxis().lowerBound());
EXPECT_EQ(10.0, depth_map->yAxis().upperBound());
- EXPECT_THROW(sim_result.data(Axes::Units::MM), std::runtime_error);
+ EXPECT_THROW(sim_result.data(Axes::Coords::MM), std::runtime_error);
const auto output = sim_result.data();
EXPECT_EQ(depth_map->getTotalNumberOfBins(), output->getAllocatedSize());
diff --git a/Tests/UnitTests/Core/Fresnel/SpecularSimulationTest.cpp b/Tests/UnitTests/Core/Fresnel/SpecularSimulationTest.cpp
index d7edb3ac569f3bc32e8e6666b7438a188c077b31..bcbc8696880c4a7c792ef65d7fbac83883769d96 100644
--- a/Tests/UnitTests/Core/Fresnel/SpecularSimulationTest.cpp
+++ b/Tests/UnitTests/Core/Fresnel/SpecularSimulationTest.cpp
@@ -208,9 +208,9 @@ TEST_F(SpecularSimulationTest, ConstructSimulation)
EXPECT_EQ(data->getAllocatedSize(), 10u);
EXPECT_EQ(data->rank(), 1u);
- EXPECT_NEAR(0.1 * Units::deg, sim_result.convertedBinCenters(Axes::Units::RADIANS).front(),
+ EXPECT_NEAR(0.1 * Units::deg, sim_result.convertedBinCenters(Axes::Coords::RADIANS).front(),
Units::deg * 1e-11);
- EXPECT_NEAR(1.9 * Units::deg, sim_result.convertedBinCenters(Axes::Units::RADIANS).back(),
+ EXPECT_NEAR(1.9 * Units::deg, sim_result.convertedBinCenters(Axes::Coords::RADIANS).back(),
Units::deg * 1e-10);
}
diff --git a/Tests/UnitTests/Core/Instrument/OffSpecularConverterTest.cpp b/Tests/UnitTests/Core/Instrument/OffSpecularConverterTest.cpp
index d48c0d5cf4692508bc8bb37117be01ef83ecc5fa..6f768aa41e98d64afa964c1d7be8b4592619473b 100644
--- a/Tests/UnitTests/Core/Instrument/OffSpecularConverterTest.cpp
+++ b/Tests/UnitTests/Core/Instrument/OffSpecularConverterTest.cpp
@@ -27,51 +27,51 @@ TEST_F(OffSpecularConverterTest, OffSpecularConverter)
EXPECT_EQ(converter.dimension(), 2u);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::UNDEFINED), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::RADIANS), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::DEGREES), 0.0);
- EXPECT_THROW(converter.calculateMin(0, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(converter.calculateMin(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::UNDEFINED), 7.0);
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::NBINS), 51.0);
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::RADIANS), Units::deg2rad(7.0));
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::DEGREES), 7.0);
- EXPECT_THROW(converter.calculateMax(0, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::UNDEFINED), -2.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::RADIANS), Units::deg2rad(-2.0));
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::DEGREES), -2.0);
- EXPECT_THROW(converter.calculateMin(1, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(converter.calculateMin(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::UNDEFINED), Units::rad2deg(1.5));
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::NBINS), 70.0);
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::RADIANS), 1.5);
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::DEGREES), Units::rad2deg(1.5));
- EXPECT_THROW(converter.calculateMax(1, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_THROW(converter.calculateMin(2, Axes::Units::UNDEFINED), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(2, Axes::Units::UNDEFINED), std::runtime_error);
-
- auto axis = converter.createConvertedAxis(0, Axes::Units::UNDEFINED);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::UNDEFINED), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::RADIANS), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::DEGREES), 0.0);
+ EXPECT_THROW(converter.calculateMin(0, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::UNDEFINED), 7.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::NBINS), 51.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::RADIANS), Units::deg2rad(7.0));
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::DEGREES), 7.0);
+ EXPECT_THROW(converter.calculateMax(0, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::UNDEFINED), -2.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::RADIANS), Units::deg2rad(-2.0));
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::DEGREES), -2.0);
+ EXPECT_THROW(converter.calculateMin(1, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::UNDEFINED), Units::rad2deg(1.5));
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::NBINS), 70.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::RADIANS), 1.5);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::DEGREES), Units::rad2deg(1.5));
+ EXPECT_THROW(converter.calculateMax(1, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_THROW(converter.calculateMin(2, Axes::Coords::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(2, Axes::Coords::UNDEFINED), std::runtime_error);
+
+ auto axis = converter.createConvertedAxis(0, Axes::Coords::UNDEFINED);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis.get()));
EXPECT_EQ(axis->size(), converter.axisSize(0));
- EXPECT_EQ(axis->lowerBound(), converter.calculateMin(0, Axes::Units::UNDEFINED));
- EXPECT_EQ(axis->upperBound(), converter.calculateMax(0, Axes::Units::UNDEFINED));
+ EXPECT_EQ(axis->lowerBound(), converter.calculateMin(0, Axes::Coords::UNDEFINED));
+ EXPECT_EQ(axis->upperBound(), converter.calculateMax(0, Axes::Coords::UNDEFINED));
- auto axis2 = converter.createConvertedAxis(1, Axes::Units::RADIANS);
+ auto axis2 = converter.createConvertedAxis(1, Axes::Coords::RADIANS);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis2.get()));
EXPECT_EQ(axis2->size(), converter.axisSize(1));
- EXPECT_EQ(axis2->lowerBound(), converter.calculateMin(1, Axes::Units::RADIANS));
- EXPECT_EQ(axis2->upperBound(), converter.calculateMax(1, Axes::Units::RADIANS));
+ EXPECT_EQ(axis2->lowerBound(), converter.calculateMin(1, Axes::Coords::RADIANS));
+ EXPECT_EQ(axis2->upperBound(), converter.calculateMax(1, Axes::Coords::RADIANS));
- EXPECT_THROW(converter.createConvertedAxis(2, Axes::Units::UNDEFINED), std::runtime_error);
- EXPECT_THROW(converter.createConvertedAxis(1, Axes::Units::QSPACE), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(2, Axes::Coords::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(1, Axes::Coords::QSPACE), std::runtime_error);
}
TEST_F(OffSpecularConverterTest, OffSpecularConverterClone)
@@ -81,34 +81,34 @@ TEST_F(OffSpecularConverterTest, OffSpecularConverterClone)
EXPECT_EQ(P_clone->dimension(), 2u);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::UNDEFINED), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::RADIANS), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::DEGREES), 0.0);
- EXPECT_THROW(P_clone->calculateMin(0, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(P_clone->calculateMin(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::UNDEFINED), 7.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::NBINS), 51.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::RADIANS), Units::deg2rad(7.0));
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::DEGREES), 7.0);
- EXPECT_THROW(P_clone->calculateMax(0, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(P_clone->calculateMax(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::UNDEFINED), -2.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::RADIANS), Units::deg2rad(-2.0));
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::DEGREES), -2.0);
- EXPECT_THROW(P_clone->calculateMin(1, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(P_clone->calculateMin(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::UNDEFINED), Units::rad2deg(1.5));
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::NBINS), 70.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::RADIANS), 1.5);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::DEGREES), Units::rad2deg(1.5));
- EXPECT_THROW(P_clone->calculateMax(1, Axes::Units::QSPACE), std::runtime_error);
- EXPECT_THROW(P_clone->calculateMax(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_THROW(P_clone->calculateMin(2, Axes::Units::UNDEFINED), std::runtime_error);
- EXPECT_THROW(P_clone->calculateMax(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::UNDEFINED), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::RADIANS), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::DEGREES), 0.0);
+ EXPECT_THROW(P_clone->calculateMin(0, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMin(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::UNDEFINED), 7.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::NBINS), 51.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::RADIANS), Units::deg2rad(7.0));
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::DEGREES), 7.0);
+ EXPECT_THROW(P_clone->calculateMax(0, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMax(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::UNDEFINED), -2.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::RADIANS), Units::deg2rad(-2.0));
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::DEGREES), -2.0);
+ EXPECT_THROW(P_clone->calculateMin(1, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMin(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::UNDEFINED), Units::rad2deg(1.5));
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::NBINS), 70.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::RADIANS), 1.5);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::DEGREES), Units::rad2deg(1.5));
+ EXPECT_THROW(P_clone->calculateMax(1, Axes::Coords::QSPACE), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMax(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_THROW(P_clone->calculateMin(2, Axes::Coords::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMax(2, Axes::Coords::UNDEFINED), std::runtime_error);
}
diff --git a/Tests/UnitTests/Core/Instrument/RectangularConverterTest.cpp b/Tests/UnitTests/Core/Instrument/RectangularConverterTest.cpp
index 3de23032278c38b1a0d1db5c28e26be70268f97e..4028d89d8e4de2f47eb07468118021ff95f0b09a 100644
--- a/Tests/UnitTests/Core/Instrument/RectangularConverterTest.cpp
+++ b/Tests/UnitTests/Core/Instrument/RectangularConverterTest.cpp
@@ -44,56 +44,56 @@ TEST_F(RectangularConverterTest, RectangularConverter)
EXPECT_EQ(converter.dimension(), 2u);
- EXPECT_NEAR(converter.calculateMin(0, Axes::Units::UNDEFINED), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(0, Axes::Units::NBINS), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(0, Axes::Units::MM), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(0, Axes::Units::RADIANS), -m_phi, m_phi * 1e-10);
- EXPECT_NEAR(converter.calculateMin(0, Axes::Units::DEGREES), Units::rad2deg(-m_phi),
+ EXPECT_NEAR(converter.calculateMin(0, Axes::Coords::UNDEFINED), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(0, Axes::Coords::NBINS), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(0, Axes::Coords::MM), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(0, Axes::Coords::RADIANS), -m_phi, m_phi * 1e-10);
+ EXPECT_NEAR(converter.calculateMin(0, Axes::Coords::DEGREES), Units::rad2deg(-m_phi),
Units::rad2deg(m_phi) * 1e-10);
- EXPECT_NEAR(converter.calculateMin(0, Axes::Units::QSPACE), -m_kfy, m_kfy * 1e-10);
+ EXPECT_NEAR(converter.calculateMin(0, Axes::Coords::QSPACE), -m_kfy, m_kfy * 1e-10);
- EXPECT_NEAR(converter.calculateMax(0, Axes::Units::UNDEFINED), det_width, det_width * 1e-10);
- EXPECT_NEAR(converter.calculateMax(0, Axes::Units::NBINS), static_cast<double>(det_nx),
+ EXPECT_NEAR(converter.calculateMax(0, Axes::Coords::UNDEFINED), det_width, det_width * 1e-10);
+ EXPECT_NEAR(converter.calculateMax(0, Axes::Coords::NBINS), static_cast<double>(det_nx),
det_nx * 1e-10);
- EXPECT_NEAR(converter.calculateMax(0, Axes::Units::MM), det_width, det_width * 1e-10);
- EXPECT_NEAR(converter.calculateMax(0, Axes::Units::RADIANS), m_phi, m_phi * 1e-10);
- EXPECT_NEAR(converter.calculateMax(0, Axes::Units::DEGREES), Units::rad2deg(m_phi),
+ EXPECT_NEAR(converter.calculateMax(0, Axes::Coords::MM), det_width, det_width * 1e-10);
+ EXPECT_NEAR(converter.calculateMax(0, Axes::Coords::RADIANS), m_phi, m_phi * 1e-10);
+ EXPECT_NEAR(converter.calculateMax(0, Axes::Coords::DEGREES), Units::rad2deg(m_phi),
Units::rad2deg(m_phi) * 1e-10);
- EXPECT_NEAR(converter.calculateMax(0, Axes::Units::QSPACE), m_kfy, m_kfy * 1e-10);
+ EXPECT_NEAR(converter.calculateMax(0, Axes::Coords::QSPACE), m_kfy, m_kfy * 1e-10);
- EXPECT_NEAR(converter.calculateMin(1, Axes::Units::UNDEFINED), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(1, Axes::Units::NBINS), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(1, Axes::Units::MM), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(1, Axes::Units::RADIANS), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(1, Axes::Units::DEGREES), 0.0, 1e-12);
- EXPECT_NEAR(converter.calculateMin(1, Axes::Units::QSPACE), -m_kiz, std::abs(m_kiz) * 1e-10);
+ EXPECT_NEAR(converter.calculateMin(1, Axes::Coords::UNDEFINED), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(1, Axes::Coords::NBINS), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(1, Axes::Coords::MM), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(1, Axes::Coords::RADIANS), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(1, Axes::Coords::DEGREES), 0.0, 1e-12);
+ EXPECT_NEAR(converter.calculateMin(1, Axes::Coords::QSPACE), -m_kiz, std::abs(m_kiz) * 1e-10);
- EXPECT_NEAR(converter.calculateMax(1, Axes::Units::UNDEFINED), det_height, det_height * 1e-10);
- EXPECT_NEAR(converter.calculateMax(1, Axes::Units::NBINS), static_cast<double>(det_ny),
+ EXPECT_NEAR(converter.calculateMax(1, Axes::Coords::UNDEFINED), det_height, det_height * 1e-10);
+ EXPECT_NEAR(converter.calculateMax(1, Axes::Coords::NBINS), static_cast<double>(det_ny),
det_ny * 1e-10);
- EXPECT_NEAR(converter.calculateMax(1, Axes::Units::MM), det_height, det_height * 1e-10);
- EXPECT_NEAR(converter.calculateMax(1, Axes::Units::RADIANS), m_alpha, m_alpha * 1e-10);
- EXPECT_NEAR(converter.calculateMax(1, Axes::Units::DEGREES), Units::rad2deg(m_alpha),
+ EXPECT_NEAR(converter.calculateMax(1, Axes::Coords::MM), det_height, det_height * 1e-10);
+ EXPECT_NEAR(converter.calculateMax(1, Axes::Coords::RADIANS), m_alpha, m_alpha * 1e-10);
+ EXPECT_NEAR(converter.calculateMax(1, Axes::Coords::DEGREES), Units::rad2deg(m_alpha),
Units::rad2deg(m_alpha) * 1e-10);
- EXPECT_NEAR(converter.calculateMax(1, Axes::Units::QSPACE), m_kfz - m_kiz,
+ EXPECT_NEAR(converter.calculateMax(1, Axes::Coords::QSPACE), m_kfz - m_kiz,
std::abs(m_kfz - m_kiz) * 1e-10);
- EXPECT_THROW(converter.calculateMin(2, Axes::Units::UNDEFINED), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.calculateMin(2, Axes::Coords::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(2, Axes::Coords::UNDEFINED), std::runtime_error);
- auto axis = converter.createConvertedAxis(0, Axes::Units::UNDEFINED);
+ auto axis = converter.createConvertedAxis(0, Axes::Coords::UNDEFINED);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis.get()));
EXPECT_EQ(axis->size(), converter.axisSize(0));
- EXPECT_EQ(axis->lowerBound(), converter.calculateMin(0, Axes::Units::UNDEFINED));
- EXPECT_EQ(axis->upperBound(), converter.calculateMax(0, Axes::Units::UNDEFINED));
+ EXPECT_EQ(axis->lowerBound(), converter.calculateMin(0, Axes::Coords::UNDEFINED));
+ EXPECT_EQ(axis->upperBound(), converter.calculateMax(0, Axes::Coords::UNDEFINED));
- auto axis2 = converter.createConvertedAxis(1, Axes::Units::QSPACE);
+ auto axis2 = converter.createConvertedAxis(1, Axes::Coords::QSPACE);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis2.get()));
EXPECT_EQ(axis2->size(), converter.axisSize(1));
- EXPECT_EQ(axis2->lowerBound(), converter.calculateMin(1, Axes::Units::QSPACE));
- EXPECT_EQ(axis2->upperBound(), converter.calculateMax(1, Axes::Units::QSPACE));
+ EXPECT_EQ(axis2->lowerBound(), converter.calculateMin(1, Axes::Coords::QSPACE));
+ EXPECT_EQ(axis2->upperBound(), converter.calculateMax(1, Axes::Coords::QSPACE));
- EXPECT_THROW(converter.createConvertedAxis(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(2, Axes::Coords::UNDEFINED), std::runtime_error);
}
TEST_F(RectangularConverterTest, RectangularConverterClone)
@@ -103,42 +103,42 @@ TEST_F(RectangularConverterTest, RectangularConverterClone)
EXPECT_EQ(P_clone->dimension(), 2u);
- EXPECT_NEAR(P_clone->calculateMin(0, Axes::Units::UNDEFINED), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(0, Axes::Units::NBINS), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(0, Axes::Units::MM), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(0, Axes::Units::RADIANS), -m_phi, m_phi * 1e-10);
- EXPECT_NEAR(P_clone->calculateMin(0, Axes::Units::DEGREES), Units::rad2deg(-m_phi),
+ EXPECT_NEAR(P_clone->calculateMin(0, Axes::Coords::UNDEFINED), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(0, Axes::Coords::NBINS), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(0, Axes::Coords::MM), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(0, Axes::Coords::RADIANS), -m_phi, m_phi * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMin(0, Axes::Coords::DEGREES), Units::rad2deg(-m_phi),
Units::rad2deg(m_phi) * 1e-10);
- EXPECT_NEAR(P_clone->calculateMin(0, Axes::Units::QSPACE), -m_kfy, m_kfy * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMin(0, Axes::Coords::QSPACE), -m_kfy, m_kfy * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(0, Axes::Units::UNDEFINED), det_width, det_width * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(0, Axes::Units::NBINS), static_cast<double>(det_nx),
+ EXPECT_NEAR(P_clone->calculateMax(0, Axes::Coords::UNDEFINED), det_width, det_width * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMax(0, Axes::Coords::NBINS), static_cast<double>(det_nx),
det_nx * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(0, Axes::Units::MM), det_width, det_width * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(0, Axes::Units::RADIANS), m_phi, m_phi * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(0, Axes::Units::DEGREES), Units::rad2deg(m_phi),
+ EXPECT_NEAR(P_clone->calculateMax(0, Axes::Coords::MM), det_width, det_width * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMax(0, Axes::Coords::RADIANS), m_phi, m_phi * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMax(0, Axes::Coords::DEGREES), Units::rad2deg(m_phi),
Units::rad2deg(m_phi) * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(0, Axes::Units::QSPACE), m_kfy, m_kfy * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMax(0, Axes::Coords::QSPACE), m_kfy, m_kfy * 1e-10);
- EXPECT_NEAR(P_clone->calculateMin(1, Axes::Units::UNDEFINED), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(1, Axes::Units::NBINS), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(1, Axes::Units::MM), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(1, Axes::Units::RADIANS), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(1, Axes::Units::DEGREES), 0.0, 1e-12);
- EXPECT_NEAR(P_clone->calculateMin(1, Axes::Units::QSPACE), -m_kiz, std::abs(m_kiz) * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMin(1, Axes::Coords::UNDEFINED), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(1, Axes::Coords::NBINS), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(1, Axes::Coords::MM), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(1, Axes::Coords::RADIANS), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(1, Axes::Coords::DEGREES), 0.0, 1e-12);
+ EXPECT_NEAR(P_clone->calculateMin(1, Axes::Coords::QSPACE), -m_kiz, std::abs(m_kiz) * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(1, Axes::Units::UNDEFINED), det_height, det_height * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(1, Axes::Units::NBINS), static_cast<double>(det_ny),
+ EXPECT_NEAR(P_clone->calculateMax(1, Axes::Coords::UNDEFINED), det_height, det_height * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMax(1, Axes::Coords::NBINS), static_cast<double>(det_ny),
det_ny * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(1, Axes::Units::MM), det_height, det_height * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(1, Axes::Units::RADIANS), m_alpha, m_alpha * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(1, Axes::Units::DEGREES), Units::rad2deg(m_alpha),
+ EXPECT_NEAR(P_clone->calculateMax(1, Axes::Coords::MM), det_height, det_height * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMax(1, Axes::Coords::RADIANS), m_alpha, m_alpha * 1e-10);
+ EXPECT_NEAR(P_clone->calculateMax(1, Axes::Coords::DEGREES), Units::rad2deg(m_alpha),
Units::rad2deg(m_alpha) * 1e-10);
- EXPECT_NEAR(P_clone->calculateMax(1, Axes::Units::QSPACE), m_kfz - m_kiz,
+ EXPECT_NEAR(P_clone->calculateMax(1, Axes::Coords::QSPACE), m_kfz - m_kiz,
std::abs(m_kfz - m_kiz) * 1e-10);
- EXPECT_THROW(P_clone->calculateMin(2, Axes::Units::UNDEFINED), std::runtime_error);
- EXPECT_THROW(P_clone->calculateMax(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMin(2, Axes::Coords::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMax(2, Axes::Coords::UNDEFINED), std::runtime_error);
}
TEST_F(RectangularConverterTest, RectangularConverterWithROI)
@@ -151,13 +151,13 @@ TEST_F(RectangularConverterTest, RectangularConverterWithROI)
m_detector.setRegionOfInterest(roi_xmin, roi_ymin, roi_xmax, roi_ymax);
RectangularConverter converter(m_detector, m_beam);
- EXPECT_EQ(converter.calculateMin(0, Axes::Units::UNDEFINED), 100);
- EXPECT_EQ(converter.calculateMax(0, Axes::Units::UNDEFINED), 152);
- EXPECT_EQ(converter.calculateMin(1, Axes::Units::UNDEFINED), 50);
- EXPECT_EQ(converter.calculateMax(1, Axes::Units::UNDEFINED), 102);
+ EXPECT_EQ(converter.calculateMin(0, Axes::Coords::UNDEFINED), 100);
+ EXPECT_EQ(converter.calculateMax(0, Axes::Coords::UNDEFINED), 152);
+ EXPECT_EQ(converter.calculateMin(1, Axes::Coords::UNDEFINED), 50);
+ EXPECT_EQ(converter.calculateMax(1, Axes::Coords::UNDEFINED), 102);
- EXPECT_NEAR(converter.calculateMin(0, Axes::Units::DEGREES), 0.0, 1e-10);
- EXPECT_NEAR(converter.calculateMax(0, Axes::Units::DEGREES), 2.97669946811, 1e-10);
- EXPECT_NEAR(converter.calculateMin(1, Axes::Units::DEGREES), 2.86240522611, 1e-10);
- EXPECT_NEAR(converter.calculateMax(1, Axes::Units::DEGREES), 5.82402751615, 1e-10);
+ EXPECT_NEAR(converter.calculateMin(0, Axes::Coords::DEGREES), 0.0, 1e-10);
+ EXPECT_NEAR(converter.calculateMax(0, Axes::Coords::DEGREES), 2.97669946811, 1e-10);
+ EXPECT_NEAR(converter.calculateMin(1, Axes::Coords::DEGREES), 2.86240522611, 1e-10);
+ EXPECT_NEAR(converter.calculateMax(1, Axes::Coords::DEGREES), 5.82402751615, 1e-10);
}
diff --git a/Tests/UnitTests/Core/Instrument/SphericalConverterTest.cpp b/Tests/UnitTests/Core/Instrument/SphericalConverterTest.cpp
index 790e925b28f6227d2ad784989351a414aff8906c..6986971be51e63b3abbd3a2dd39e4e06206b4b69 100644
--- a/Tests/UnitTests/Core/Instrument/SphericalConverterTest.cpp
+++ b/Tests/UnitTests/Core/Instrument/SphericalConverterTest.cpp
@@ -32,50 +32,50 @@ TEST_F(SphericalConverterTest, SphericalConverter)
EXPECT_EQ(converter.dimension(), 2u);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::UNDEFINED), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::RADIANS), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::DEGREES), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Units::QSPACE), 0.0);
- EXPECT_THROW(converter.calculateMin(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::UNDEFINED), 5.0);
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::NBINS), 100.0);
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::RADIANS), Units::deg2rad(5.0));
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::DEGREES), 5.0);
- EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Units::QSPACE), m_kfy);
- EXPECT_THROW(converter.calculateMax(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::UNDEFINED), -2.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::RADIANS), Units::deg2rad(-2.0));
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::DEGREES), -2.0);
- EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Units::QSPACE), m_kfz1 - m_kiz);
- EXPECT_THROW(converter.calculateMin(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::UNDEFINED), Units::rad2deg(1.5));
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::NBINS), 70.0);
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::RADIANS), 1.5);
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::DEGREES), Units::rad2deg(1.5));
- EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Units::QSPACE), m_kfz2 - m_kiz);
- EXPECT_THROW(converter.calculateMax(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_THROW(converter.calculateMin(2, Axes::Units::UNDEFINED), std::runtime_error);
- EXPECT_THROW(converter.calculateMax(2, Axes::Units::UNDEFINED), std::runtime_error);
-
- auto axis = converter.createConvertedAxis(0, Axes::Units::UNDEFINED);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::UNDEFINED), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::RADIANS), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::DEGREES), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(0, Axes::Coords::QSPACE), 0.0);
+ EXPECT_THROW(converter.calculateMin(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::UNDEFINED), 5.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::NBINS), 100.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::RADIANS), Units::deg2rad(5.0));
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::DEGREES), 5.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(0, Axes::Coords::QSPACE), m_kfy);
+ EXPECT_THROW(converter.calculateMax(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::UNDEFINED), -2.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::RADIANS), Units::deg2rad(-2.0));
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::DEGREES), -2.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMin(1, Axes::Coords::QSPACE), m_kfz1 - m_kiz);
+ EXPECT_THROW(converter.calculateMin(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::UNDEFINED), Units::rad2deg(1.5));
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::NBINS), 70.0);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::RADIANS), 1.5);
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::DEGREES), Units::rad2deg(1.5));
+ EXPECT_DOUBLE_EQ(converter.calculateMax(1, Axes::Coords::QSPACE), m_kfz2 - m_kiz);
+ EXPECT_THROW(converter.calculateMax(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_THROW(converter.calculateMin(2, Axes::Coords::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.calculateMax(2, Axes::Coords::UNDEFINED), std::runtime_error);
+
+ auto axis = converter.createConvertedAxis(0, Axes::Coords::UNDEFINED);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis.get()));
EXPECT_EQ(axis->size(), converter.axisSize(0));
- EXPECT_EQ(axis->lowerBound(), converter.calculateMin(0, Axes::Units::UNDEFINED));
- EXPECT_EQ(axis->upperBound(), converter.calculateMax(0, Axes::Units::UNDEFINED));
+ EXPECT_EQ(axis->lowerBound(), converter.calculateMin(0, Axes::Coords::UNDEFINED));
+ EXPECT_EQ(axis->upperBound(), converter.calculateMax(0, Axes::Coords::UNDEFINED));
- auto axis2 = converter.createConvertedAxis(1, Axes::Units::QSPACE);
+ auto axis2 = converter.createConvertedAxis(1, Axes::Coords::QSPACE);
EXPECT_TRUE(dynamic_cast<const FixedBinAxis*>(axis2.get()));
EXPECT_EQ(axis2->size(), converter.axisSize(1));
- EXPECT_EQ(axis2->lowerBound(), converter.calculateMin(1, Axes::Units::QSPACE));
- EXPECT_EQ(axis2->upperBound(), converter.calculateMax(1, Axes::Units::QSPACE));
+ EXPECT_EQ(axis2->lowerBound(), converter.calculateMin(1, Axes::Coords::QSPACE));
+ EXPECT_EQ(axis2->upperBound(), converter.calculateMax(1, Axes::Coords::QSPACE));
- EXPECT_THROW(converter.createConvertedAxis(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(converter.createConvertedAxis(2, Axes::Coords::UNDEFINED), std::runtime_error);
}
TEST_F(SphericalConverterTest, SphericalConverterClone)
@@ -85,34 +85,34 @@ TEST_F(SphericalConverterTest, SphericalConverterClone)
EXPECT_EQ(P_clone->dimension(), 2u);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::UNDEFINED), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::RADIANS), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::DEGREES), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Units::QSPACE), 0.0);
- EXPECT_THROW(P_clone->calculateMin(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::UNDEFINED), 5.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::NBINS), 100.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::RADIANS), Units::deg2rad(5.0));
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::DEGREES), 5.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Units::QSPACE), m_kfy);
- EXPECT_THROW(P_clone->calculateMax(0, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::UNDEFINED), -2.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::NBINS), 0.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::RADIANS), Units::deg2rad(-2.0));
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::DEGREES), -2.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Units::QSPACE), m_kfz1 - m_kiz);
- EXPECT_THROW(P_clone->calculateMin(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::UNDEFINED), Units::rad2deg(1.5));
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::NBINS), 70.0);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::RADIANS), 1.5);
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::DEGREES), Units::rad2deg(1.5));
- EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Units::QSPACE), m_kfz2 - m_kiz);
- EXPECT_THROW(P_clone->calculateMax(1, Axes::Units::MM), std::runtime_error);
-
- EXPECT_THROW(P_clone->calculateMin(2, Axes::Units::UNDEFINED), std::runtime_error);
- EXPECT_THROW(P_clone->calculateMax(2, Axes::Units::UNDEFINED), std::runtime_error);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::UNDEFINED), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::RADIANS), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::DEGREES), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(0, Axes::Coords::QSPACE), 0.0);
+ EXPECT_THROW(P_clone->calculateMin(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::UNDEFINED), 5.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::NBINS), 100.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::RADIANS), Units::deg2rad(5.0));
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::DEGREES), 5.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(0, Axes::Coords::QSPACE), m_kfy);
+ EXPECT_THROW(P_clone->calculateMax(0, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::UNDEFINED), -2.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::NBINS), 0.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::RADIANS), Units::deg2rad(-2.0));
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::DEGREES), -2.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMin(1, Axes::Coords::QSPACE), m_kfz1 - m_kiz);
+ EXPECT_THROW(P_clone->calculateMin(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::UNDEFINED), Units::rad2deg(1.5));
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::NBINS), 70.0);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::RADIANS), 1.5);
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::DEGREES), Units::rad2deg(1.5));
+ EXPECT_DOUBLE_EQ(P_clone->calculateMax(1, Axes::Coords::QSPACE), m_kfz2 - m_kiz);
+ EXPECT_THROW(P_clone->calculateMax(1, Axes::Coords::MM), std::runtime_error);
+
+ EXPECT_THROW(P_clone->calculateMin(2, Axes::Coords::UNDEFINED), std::runtime_error);
+ EXPECT_THROW(P_clone->calculateMax(2, Axes::Coords::UNDEFINED), std::runtime_error);
}
diff --git a/Tests/UnitTests/Core/Instrument/SphericalDetectorTest.cpp b/Tests/UnitTests/Core/Instrument/SphericalDetectorTest.cpp
index c2e885652cb06277e13211545b08d43940602b65..72b5b90a593046c85e92ca7b2159b72780c854d2 100644
--- a/Tests/UnitTests/Core/Instrument/SphericalDetectorTest.cpp
+++ b/Tests/UnitTests/Core/Instrument/SphericalDetectorTest.cpp
@@ -20,7 +20,7 @@ TEST_F(SphericalDetectorTest, initialState)
// checking size
EXPECT_EQ(0u, detector.dimension());
- EXPECT_EQ(Axes::Units::RADIANS, detector.defaultAxesUnits());
+ EXPECT_EQ(Axes::Coords::RADIANS, detector.defaultAxesUnits());
// masks
EXPECT_FALSE(detector.detectorMask()->hasMasks());
diff --git a/Wrap/Swig/libBornAgainDevice.i b/Wrap/Swig/libBornAgainDevice.i
index 6e1beacd20bad1f20f75111ed35b7ea39bcd3129..245a312a5bb2d91bf2777f10487117d3fea1b520 100644
--- a/Wrap/Swig/libBornAgainDevice.i
+++ b/Wrap/Swig/libBornAgainDevice.i
@@ -69,7 +69,7 @@
%newobject ScanResolution::scanRelativeResolution;
%newobject ScanResolution::scanAbsoluteResolution;
-%newobject SimulationResult::histogram2d(Axes::Units units_type = Axes::Units::UNDEFINED) const;
+%newobject SimulationResult::histogram2d(Axes::Coords units_type = Axes::Coords::UNDEFINED) const;
%newobject IntensityDataIOFactory::readOutputData(const std::string& file_name);
%newobject IntensityDataIOFactory::readIntensityData(const std::string& file_name);