Hermes-3 merges

include/bout/options.hxx

@@ -200,9 +200,9 @@ public:
   }
 
   /// The type used to store values
-  using ValueType =
-      bout::utils::variant<bool, int, BoutReal, std::string, Field2D, Field3D, FieldPerp,
-                           Array<BoutReal>, Matrix<BoutReal>, Tensor<BoutReal>>;
+  using ValueType = bout::utils::variant<bool, int, BoutReal, std::string, Field2D,
+                                         Field3D, FieldPerp, Array<BoutReal>, Array<int>,
+                                         Matrix<BoutReal>, Tensor<BoutReal>>;
 
   /// A tree representation with leaves containing ValueType.
   /// Used to construct Options from initializer lists.
@@ -914,6 +914,8 @@ void Options::assign<>(FieldPerp val, std::string source);
 template <>
 void Options::assign<>(Array<BoutReal> val, std::string source);
 template <>
+void Options::assign<>(Array<int> val, std::string source);
+template <>
 void Options::assign<>(Matrix<BoutReal> val, std::string source);
 template <>
 void Options::assign<>(Tensor<BoutReal> val, std::string source);
@@ -942,6 +944,8 @@ FieldPerp Options::as<FieldPerp>(const FieldPerp& similar_to) const;
 template <>
 Array<BoutReal> Options::as<Array<BoutReal>>(const Array<BoutReal>& similar_to) const;
 template <>
+Array<int> Options::as<Array<int>>(const Array<int>& similar_to) const;
+template <>
 Matrix<BoutReal> Options::as<Matrix<BoutReal>>(const Matrix<BoutReal>& similar_to) const;
 template <>
 Tensor<BoutReal> Options::as<Tensor<BoutReal>>(const Tensor<BoutReal>& similar_to) const;

include/bout/utils.hxx

@@ -566,8 +566,8 @@ std::string toString(const T& val) {
 /// where the type may be std::string.
 inline std::string toString(const std::string& val) { return val; }
 
-template <>
-inline std::string toString<>(const Array<BoutReal>& UNUSED(val)) {
+template <typename T>
+inline std::string toString(const Array<T>& UNUSED(val)) {
   return "<Array>";
 }
 

src/mesh/data/gridfromfile.cxx

@@ -138,7 +138,10 @@ struct GetDimensions {
   std::vector<int> operator()([[maybe_unused]] int value) { return {1}; }
   std::vector<int> operator()([[maybe_unused]] BoutReal value) { return {1}; }
   std::vector<int> operator()([[maybe_unused]] const std::string& value) { return {1}; }
-  std::vector<int> operator()(const Array<BoutReal>& array) { return {array.size()}; }
+  template <typename T>
+  std::vector<int> operator()(const Array<T>& array) {
+    return {array.size()};
+  }
   std::vector<int> operator()(const Matrix<BoutReal>& array) {
     const auto shape = array.shape();
     return {std::get<0>(shape), std::get<1>(shape)};
@@ -477,7 +480,26 @@ bool GridFile::get([[maybe_unused]] Mesh* m, [[maybe_unused]] std::vector<int>&
                    [[maybe_unused]] GridDataSource::Direction dir) {
   TRACE("GridFile::get(vector<int>)");
 
-  return false;
+  if (not data.isSet(name)) {
+    return false;
+  }
+
+  const auto full_var = data[name].as<Array<int>>();
+
+  // Check size
+  if (full_var.size() < len + offset) {
+    throw BoutException("{} has length {}. Expected {} elements + {} offset", name,
+                        full_var.size(), len, offset);
+  }
+
+  // Ensure that output variable has the correct size
+  var.resize(len);
+
+  const auto* it = std::begin(full_var);
+  std::advance(it, offset);
+  std::copy_n(it, len, std::begin(var));
+
+  return true;
 }
 
 bool GridFile::get(Mesh* UNUSED(m), std::vector<BoutReal>& var, const std::string& name,

src/mesh/impls/bout/boutmesh.cxx

@@ -2117,6 +2117,35 @@ void BoutMesh::topology() {
     add_target(ny_inner - 1, 0, nx);
   }
 
+  // Additional limiters
+  // Each limiter needs 3 indices: A Y index, start and end X indices
+  int limiter_count = 0;
+  Mesh::get(limiter_count, "limiter_count", 0);
+  if (limiter_count > 0) {
+    std::vector<int> limiter_yinds, limiter_xstarts, limiter_xends;
+    if (!source->get(this, limiter_yinds, "limiter_yinds", limiter_count)) {
+      throw BoutException("Couldn't read limiter_yinds vector of length {} from mesh",
+                          limiter_count);
+    }
+    if (!source->get(this, limiter_xstarts, "limiter_xstarts", limiter_count)) {
+      throw BoutException("Couldn't read limiter_xstarts vector of length {} from mesh",
+                          limiter_count);
+    }
+    if (!source->get(this, limiter_xends, "limiter_xends", limiter_count)) {
+      throw BoutException("Couldn't read limiter_xend vector of length {} from mesh",
+                          limiter_count);
+    }
+
+    for (int i = 0; i < limiter_count; ++i) {
+      int yind = limiter_yinds[i];
+      int xstart = limiter_xstarts[i];
+      int xend = limiter_xends[i];
+      output_info.write("Adding a limiter between y={} and {}. X indices {} to {}\n",
+                        yind, yind + 1, xstart, xend);
+      add_target(yind, xstart, xend);
+    }
+  }
+
   if ((ixseps_inner > 0)
       && (((PE_YIND * MYSUB > jyseps1_1) && (PE_YIND * MYSUB <= jyseps2_1))
           || ((PE_YIND * MYSUB > jyseps1_2) && (PE_YIND * MYSUB <= jyseps2_2)))) {

src/sys/options.cxx

@@ -328,6 +328,10 @@ void Options::assign<>(Array<BoutReal> val, std::string source) {
   _set_no_check(std::move(val), std::move(source));
 }
 template <>
+void Options::assign<>(Array<int> val, std::string source) {
+  _set_no_check(std::move(val), std::move(source));
+}
+template <>
 void Options::assign<>(Matrix<BoutReal> val, std::string source) {
   _set_no_check(std::move(val), std::move(source));
 }
@@ -751,6 +755,32 @@ Array<BoutReal> Options::as<Array<BoutReal>>(const Array<BoutReal>& similar_to)
   return result;
 }
 
+template <>
+Array<int> Options::as<Array<int>>(const Array<int>& similar_to) const {
+  if (is_section) {
+    throw BoutException(_("Option {:s} has no value"), full_name);
+  }
+
+  Array<int> result = bout::utils::visit(
+      ConvertContainer<Array<int>>{
+          fmt::format(_("Value for option {:s} cannot be converted to an Array<int>"),
+                      full_name),
+          similar_to},
+      value);
+
+  // Mark this option as used
+  value_used = true;
+
+  output_info << _("\tOption ") << full_name << " = Array<int>";
+  if (hasAttribute("source")) {
+    // Specify the source of the setting
+    output_info << " (" << bout::utils::variantToString(attributes.at("source")) << ")";
+  }
+  output_info << endl;
+
+  return result;
+}
+
 template <>
 Matrix<BoutReal> Options::as<Matrix<BoutReal>>(const Matrix<BoutReal>& similar_to) const {
   if (is_section) {

src/sys/options/options_netcdf.cxx

@@ -88,6 +88,10 @@ void readGroup(const std::string& filename, const NcGroup& group, Options& resul
         Array<double> value(static_cast<int>(dims[0].getSize()));
         var.getVar(value.begin());
         result[var_name] = value;
+      } else if (var_type == ncInt or var_type == ncShort) {
+        Array<int> value(static_cast<int>(dims[0].getSize()));
+        var.getVar(value.begin());
+        result[var_name] = value;
       } else if ((var_type == ncString) or (var_type == ncChar)) {
         std::string value;
         value.resize(dims[0].getSize());