Merge branch 'next' of https://github.com/boutproject/BOUT-dev into normalise-metrics

Author: dschwoerer

include/bout/bout_enum_class.hxx

@@ -67,7 +67,7 @@
 /// Create an enum class with toString and <enum name>FromString functions, and an
 /// Options::as<enum> overload to read the enum
 #define BOUT_ENUM_CLASS(enumname, ...)                                         \
-  enum class enumname : std::int8_t { __VA_ARGS__ };                           \
+  enum class enumname : std::uint8_t { __VA_ARGS__ };                          \
                                                                                \
   inline std::string toString(enumname e) {                                    \
                                                                                \
@@ -105,4 +105,48 @@
     return out << toString(e);                                                 \
   }
 
+/// Create an enum class with toString and <enum name>FromString functions, and an
+/// Options::as<enum> overload to read the enum
+#define BOUT_ENUM_CLASS_NS(ns, enumname, ...)                                      \
+  namespace ns {                                                                   \
+  enum class enumname : std::uint8_t { __VA_ARGS__ };                              \
+  }                                                                                \
+                                                                                   \
+  inline std::string toString(ns::enumname e) {                                    \
+                                                                                   \
+    const static std::map<ns::enumname, std::string> toString_map = {              \
+        BOUT_ENUM_CLASS_MAP_ARGS(BOUT_ENUM_CLASS_STR, ns::enumname, __VA_ARGS__)}; \
+    auto found = toString_map.find(e);                                             \
+    if (found == toString_map.end()) {                                             \
+      throw BoutException("Did not find enum {:d}", static_cast<int>(e));          \
+    }                                                                              \
+    return found->second;                                                          \
+  }                                                                                \
+  namespace ns {                                                                   \
+  inline enumname BOUT_MAKE_FROMSTRING_NAME(enumname)(const std::string& s) {      \
+    const static std::map<std::string, enumname> fromString_map = {                \
+        BOUT_ENUM_CLASS_MAP_ARGS(BOUT_STR_ENUM_CLASS, enumname, __VA_ARGS__)};     \
+    auto found = fromString_map.find(s);                                           \
+    if (found == fromString_map.end()) {                                           \
+      std::string valid_values{};                                                  \
+      for (auto const& entry : fromString_map) {                                   \
+        valid_values += std::string(" ") + entry.first;                            \
+      }                                                                            \
+      throw BoutException("Did not find enum {:s}. Valid values: {:s}", s,         \
+                          valid_values);                                           \
+    }                                                                              \
+    return found->second;                                                          \
+  }                                                                                \
+  }                                                                                \
+                                                                                   \
+  template <>                                                                      \
+  inline ns::enumname Options::as<ns::enumname>(const ns::enumname&) const {       \
+    return ns::BOUT_MAKE_FROMSTRING_NAME(enumname)(this->as<std::string>());       \
+  }                                                                                \
+  namespace ns {                                                                   \
+  inline std::ostream& operator<<(std::ostream& out, const enumname& e) {          \
+    return out << toString(e);                                                     \
+  }                                                                                \
+  }
+
 #endif // BOUT_ENUM_CLASS_H

include/bout/difops.hxx

@@ -36,14 +36,15 @@
 #ifndef BOUT_DIFOPS_H
 #define BOUT_DIFOPS_H
 
+#include "bout/bout_enum_class.hxx"
 #include "bout/bout_types.hxx"
+#include "bout/coordinates.hxx"
 #include "bout/field2d.hxx"
 #include "bout/field3d.hxx"
 #include "bout/metric_tensor.hxx"
 
-#include <string>
-
 #include <cstdint>
+#include <string>
 
 class Solver;
 
@@ -200,21 +201,24 @@ Field3D Div_par_K_Grad_par(const Field3DParallel& kY, const Field2D& f,
 Field3D Div_par_K_Grad_par(const Field3DParallel& kY, const Field3DParallel& f,
                            CELL_LOC outloc = CELL_DEFAULT);
 
-namespace bout {
-enum class ConductionMethod : uint8_t {
-  /// Separately averages :math:`K`, :math:`J`, :math:`g_{22}`, and
-  /// :math:`dy` at the face and then multiplies them together.
-  Original,
-  /// Uses the same stencil as ``Original`` but averages :math:`J K`
-  /// together before applying the face gradient.
-  ProductJK,
-  ///  Uses a harmonic average of the half-cell conductances
-  /// :math:`K J / (g_{22} dy)`. This better matches a series-resistance
-  /// interpretation of two adjacent half-cells and can give noticeably
-  /// different results when coefficients or cell sizes vary strongly.
-  Harmonic
-};
-}
+/// enum class bout::ConductionMethod
+/// ---------------------------------
+///
+/// Original:
+/// Separately averages :math:`K`, :math:`J`, :math:`g_{22}`, and
+/// :math:`dy` at the face and then multiplies them together.
+///
+/// ProductJK:
+/// Uses the same stencil as ``Original`` but averages :math:`J K`
+/// together before applying the face gradient.
+///
+/// Harmonic:
+///  Uses a harmonic average of the half-cell conductances
+/// :math:`K J / (g_{22} dy)`. This better matches a series-resistance
+/// interpretation of two adjacent half-cells and can give noticeably
+/// different results when coefficients or cell sizes vary strongly.
+BOUT_ENUM_CLASS_NS(bout, ConductionMethod, Original, ProductJK, Harmonic);
+
 /// Version with energy flow diagnostic
 /// For FCI fields, `flow_ylow` is currently returned as zero.
 Field3D

src/mesh/difops.cxx

@@ -539,7 +539,7 @@ Field3D Div_par_K_Grad_par_mod(const Field3DParallel& Kin, const Field3DParallel
   }
   throw BoutException(
       "Unknown method `{}` - choose from `Original`, `ProductJK` or `Harmonic`.",
-      static_cast<int>(method));
+      toString(method));
 }
 /*******************************************************************************
 * Delp2

tests/unit/include/bout/test_bout_enum_class.cxx

@@ -6,12 +6,25 @@
 #include "bout/output.hxx"
 
 BOUT_ENUM_CLASS(TestEnum, foo, bar);
+BOUT_ENUM_CLASS_NS(bout, TestEnum, foo, bar);
+BOUT_ENUM_CLASS_NS(bout::test, TestEnum, foo, bar);
+
+TEST(BoutEnumClassNS, toString) {
+  EXPECT_EQ(toString(bout::TestEnum::foo), "foo");
+  EXPECT_EQ(toString(bout::TestEnum::bar), "bar");
+}
 
 TEST(BoutEnumClass, toString) {
   EXPECT_EQ(toString(TestEnum::foo), "foo");
   EXPECT_EQ(toString(TestEnum::bar), "bar");
 }
 
+TEST(BoutEnumClassNS, fromString) {
+  EXPECT_EQ(bout::TestEnumFromString("foo"), bout::TestEnum::foo);
+  EXPECT_EQ(bout::TestEnumFromString("bar"), bout::TestEnum::bar);
+  EXPECT_THROW(bout::TestEnumFromString("expect_fail"), BoutException);
+}
+
 TEST(BoutEnumClass, fromString) {
   EXPECT_EQ(TestEnumFromString("foo"), TestEnum::foo);
   EXPECT_EQ(TestEnumFromString("bar"), TestEnum::bar);
@@ -38,10 +51,58 @@ TEST(BoutEnumClass, options) {
   EXPECT_THROW(options["optfail"].as<TestEnum>(), BoutException);
 }
 
+TEST(BoutEnumClassNS, options) {
+  WithQuietOutput quiet_info{output_info};
+
+  Options options;
+
+  auto opt1 = options["opt"].withDefault(bout::TestEnum::foo);
+  EXPECT_EQ(opt1, bout::TestEnum::foo);
+  EXPECT_NE(opt1, bout::TestEnum::bar);
+
+  options["opt"] = "bar";
+
+  auto opt2 = options["opt"].as<bout::TestEnum>();
+  EXPECT_EQ(opt2, bout::TestEnum::bar);
+  EXPECT_NE(opt2, bout::TestEnum::foo);
+
+  options["optfail"] = "expect_fail";
+
+  EXPECT_THROW(options["optfail"].as<bout::TestEnum>(), BoutException);
+}
+
+TEST(BoutEnumClassNS2, options) {
+  WithQuietOutput quiet_info{output_info};
+
+  Options options;
+
+  auto opt1 = options["opt"].withDefault(bout::test::TestEnum::foo);
+  EXPECT_EQ(opt1, bout::test::TestEnum::foo);
+  EXPECT_NE(opt1, bout::test::TestEnum::bar);
+
+  options["opt"] = "bar";
+
+  auto opt2 = options["opt"].as<bout::test::TestEnum>();
+  EXPECT_EQ(opt2, bout::test::TestEnum::bar);
+  EXPECT_NE(opt2, bout::test::TestEnum::foo);
+
+  options["optfail"] = "expect_fail";
+
+  EXPECT_THROW(options["optfail"].as<bout::test::TestEnum>(), BoutException);
+}
+
 TEST(BoutEnumClass, ostream) {
   auto sstream = std::stringstream();
 
   sstream << TestEnum::foo << TestEnum::bar;
 
   EXPECT_EQ(sstream.str(), "foobar");
 }
+
+TEST(BoutEnumClassNS, ostream) {
+  auto sstream = std::stringstream();
+
+  sstream << bout::TestEnum::foo << bout::TestEnum::bar;
+
+  EXPECT_EQ(sstream.str(), "foobar");
+}