boutpp-nightly 5.2.1.dev766__tar.gz → 5.2.1.dev961__tar.gz

{boutpp_nightly-5.2.1.dev766 → boutpp_nightly-5.2.1.dev961}/.ci_fedora.sh

@@ -21,10 +21,10 @@ then
 	cmd="sudo docker"
     fi
     test . != ".$2" && mpi="$2" || mpi=openmpi
-    time $cmd pull ghcr.io/dschwoerer/bout-container-base:ci-fedora
+    time $cmd pull ghcr.io/boutproject/bout-container-base:main
     time $cmd create --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \
 	 --shm-size 256M \
-         --name mobydick ghcr.io/dschwoerer/bout-container-base:ci-fedora \
+         --name mobydick ghcr.io/boutproject/bout-container-base:main \
 	     /tmp/BOUT-dev/.ci_fedora.sh $mpi
     time $cmd cp ${TRAVIS_BUILD_DIR:-$(pwd)} mobydick:/tmp/BOUT-dev
     time $cmd start -a mobydick
@@ -52,7 +52,8 @@ test . != ".$1" && mpi="$1" || mpi=openmpi
 	 -DBOUT_UPDATE_GIT_SUBMODULE=OFF \
 	 -DBOUT_USE_SYSTEM_FMT=ON \
 	 -DBOUT_USE_SYSTEM_MPARK_VARIANT=ON \
-	 -DBOUT_USE_SUNDIALS=ON
+	 -DBOUT_USE_SUNDIALS=ON \
+	 -DBOUT_USE_SYSTEM_CPPTRACE=ON
 
     time make -C build build-check -j 2
     time make -C build check

{boutpp_nightly-5.2.1.dev766 → boutpp_nightly-5.2.1.dev961}/.git-blame-ignore-revs

@@ -16,6 +16,7 @@ d1cfb8abd6aa5c76e6c1a4d7ab20929c65f8afc2
 8d5cb39e03c2644715a50684f8cd0318b4e82676
 ec69e8838be2dde140a915e50506f8e1ce3cb534
 f2bc0488a298f136294c523bc5ab4086d090059b
+c59626a0498b0cfd1be46f84f0fa38b4855a43cc
 1b4707187a3a85126338303dc766280b8fb2dc56
 b2e2f3575e68f771be2a4341af5fd14e2870469e
 64e4285ec38569f66d31e589a4610cefd16d8076

{boutpp_nightly-5.2.1.dev766 → boutpp_nightly-5.2.1.dev961}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: boutpp-nightly
-Version: 5.2.1.dev766
+Version: 5.2.1.dev961
 License: 		   GNU LESSER GENERAL PUBLIC LICENSE
                                 Version 3, 29 June 2007
          

boutpp_nightly-5.2.1.dev961/_version.txt

@@ -0,0 +1 @@
+v5.2.1.dev961

{boutpp_nightly-5.2.1.dev766 → boutpp_nightly-5.2.1.dev961}/cmake/BOUT++functions.cmake

@@ -233,8 +233,10 @@ function(bout_add_integrated_or_mms_test BUILD_CHECK_TARGET TESTNAME)
     set(output)
     add_custom_command(
       OUTPUT ${BOUT_TEST_OPTIONS_DOWNLOAD_NAME}
-      COMMAND wget ${BOUT_TEST_OPTIONS_DOWNLOAD} -O
-              ${BOUT_TEST_OPTIONS_DOWNLOAD_NAME} $ENV{BOUT_TEST_DOWNLOAD_FLAGS}
+      COMMAND
+        wget ${BOUT_TEST_OPTIONS_DOWNLOAD} -O ${BOUT_TEST_OPTIONS_DOWNLOAD_NAME}
+        $ENV{BOUT_TEST_DOWNLOAD_FLAGS} || curl ${BOUT_TEST_OPTIONS_DOWNLOAD} -o
+        ${BOUT_TEST_OPTIONS_DOWNLOAD_NAME}
       WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
       COMMENT "Downloading ${BOUT_TEST_OPTIONS_DOWNLOAD_NAME}"
     )

boutpp_nightly-5.2.1.dev961/include/bout/boundary_iterator.hxx

@@ -0,0 +1,229 @@
+#pragma once
+
+#include "bout/assert.hxx"
+#include "bout/bout_types.hxx"
+#include "bout/field2d.hxx"
+#include "bout/field3d.hxx"
+#include "bout/mesh.hxx"
+#include "bout/parallel_boundary_region.hxx"
+#include "bout/region.hxx"
+#include "bout/sys/parallel_stencils.hxx"
+#include "bout/sys/range.hxx"
+#include <algorithm>
+#include <functional>
+
+class BoundaryRegionIter {
+public:
+  virtual ~BoundaryRegionIter() = default;
+  BoundaryRegionIter(int x, int y, int bx, int by, const Mesh& mesh)
+      : _dir(bx + by), _x(x), _y(y), _bx(bx), _by(by), localmesh(&mesh) {
+    ASSERT3(_bx * _by == 0);
+  }
+  bool operator!=(const BoundaryRegionIter& rhs) const { return ind() != rhs.ind(); }
+
+  Ind3D ind() const { return xyz2ind(_x, _y, _z); }
+  BoundaryRegionIter& operator++() {
+    ASSERT3(_z < nz());
+    _z++;
+    if (_z == nz()) {
+      _z = 0;
+      _next();
+    }
+    return *this;
+  }
+
+protected:
+  virtual void _next() = 0;
+
+public:
+  BoundaryRegionIter& operator*() { return *this; }
+
+  void dirichlet_o2(Field3D& f, BoutReal value) const {
+    ynext(f) = bout::parallel_stencil::dirichlet_o2(1, f[ind()], 0.5, value);
+  }
+
+  BoutReal extrapolate_grad_o2(const Field3D& f) const { return f[ind()] - yprev(f); }
+
+  BoutReal extrapolate_sheath_o2(const Field3D& f) const {
+    return (f[ind()] * 3 - yprev(f)) * 0.5;
+  }
+
+  BoutReal extrapolate_next_o2(const Field3D& f) const {
+    return (2 * f[ind()]) - yprev(f);
+  }
+
+  BoutReal
+  extrapolate_next_o2(const std::function<BoutReal(int yoffset, Ind3D ind)>& f) const {
+    return (2 * f(0, ind())) - f(0, ind().yp(-_by).xp(-_bx));
+  }
+
+  BoutReal interpolate_sheath_o2(const Field3D& f) const {
+    return (f[ind()] + ynext(f)) * 0.5;
+  }
+
+  BoutReal
+  interpolate_sheath_o2(const std::function<BoutReal(int yoffset, Ind3D ind)>& f) const {
+    return (f(0, ind()) + f(0, ind().yp(-_by).xp(-_bx))) * 0.5;
+  }
+
+  BoutReal
+  extrapolate_sheath_o2(const std::function<BoutReal(int yoffset, Ind3D ind)>& f) const {
+    return 0.5 * (3 * f(0, ind()) - f(0, ind().yp(-_by).xp(-_bx)));
+  }
+
+  BoutReal extrapolate_sheath_free(const Field3D& f, SheathLimitMode mode) const {
+    const BoutReal fac =
+        bout::parallel_boundary_region::limitFreeScale(yprev(f), ythis(f), mode);
+    const BoutReal val = ythis(f);
+    const BoutReal next = mode == SheathLimitMode::linear_free ? val + fac : val * fac;
+    return 0.5 * (val + next);
+  }
+
+  void set_free(Field3D& f, SheathLimitMode mode) const {
+    const BoutReal fac =
+        bout::parallel_boundary_region::limitFreeScale(yprev(f), ythis(f), mode);
+    BoutReal val = ythis(f);
+    if (mode == SheathLimitMode::linear_free) {
+      for (int i = 1; i <= localmesh->ystart; ++i) {
+        val += fac;
+        f[ind().yp(_by * i).xp(_bx * i)] = val;
+      }
+    } else {
+      for (int i = 1; i <= localmesh->ystart; ++i) {
+        val *= fac;
+        f[ind().yp(_by * i).xp(_bx * i)] = val;
+      }
+    }
+  }
+
+  void limitFree(Field3D& f) const {
+    const BoutReal fac =
+        bout::parallel_boundary_region::limitFreeScale(yprev(f), ythis(f));
+    BoutReal val = ythis(f);
+    for (int i = 1; i <= localmesh->ystart; ++i) {
+      val *= fac;
+      f[ind().yp(_by * i).xp(_bx * i)] = val;
+    }
+  }
+
+  bool is_lower() const {
+    ASSERT2(_bx == 0);
+    return _by == -1;
+  }
+
+  void neumann_o1(Field3D& f, BoutReal grad) const {
+    BoutReal val = ythis(f);
+    for (int i = 1; i <= localmesh->ystart; ++i) {
+      val += grad;
+      f[ind().yp(_by * i).xp(_bx * i)] = val;
+    }
+  }
+
+  void neumann_o2(Field3D& f, BoutReal grad) const {
+    BoutReal val = yprev(f) + grad;
+    for (int i = 1; i <= localmesh->ystart; ++i) {
+      val += grad;
+      f[ind().yp(_by * i).xp(_bx * i)] = val;
+    }
+  }
+
+  void limit_at_least(Field3D& f, BoutReal value) const {
+    ynext(f) = std::max(ynext(f), value);
+  }
+
+  BoutReal& ynext(Field3D& f) const { return f[ind().yp(_by).xp(_bx)]; }
+  const BoutReal& ynext(const Field3D& f) const { return f[ind().yp(_by).xp(_bx)]; }
+  BoutReal& yprev(Field3D& f) const { return f[ind().yp(-_by).xp(-_bx)]; }
+  const BoutReal& yprev(const Field3D& f) const { return f[ind().yp(-_by).xp(-_bx)]; }
+  BoutReal& ythis(Field3D& f) const { return f[ind()]; }
+  const BoutReal& ythis(const Field3D& f) const { return f[ind()]; }
+
+  void setYPrevIfValid(Field3D& f, BoutReal val) const { yprev(f) = val; }
+  void setAll(Field3D& f, const BoutReal val) const {
+    for (int i = -localmesh->ystart; i <= localmesh->ystart; ++i) {
+      f[ind().yp(_by * i).xp(_bx * i)] = val;
+    }
+  }
+
+  static int abs_offset() { return 1; }
+
+  BoutReal& ynext(Field2D& f) const { return f[ind().yp(_by).xp(_bx)]; }
+  const BoutReal& ynext(const Field2D& f) const { return f[ind().yp(_by).xp(_bx)]; }
+  BoutReal& yprev(Field2D& f) const { return f[ind().yp(-_by).xp(-_bx)]; }
+  const BoutReal& yprev(const Field2D& f) const { return f[ind().yp(-_by).xp(-_bx)]; }
+
+  int dir() const { return _dir; }
+
+protected:
+  int x() const { return _x; }
+  int y() const { return _y; }
+  int z() const { return _z; }
+
+  void setx(int x) { _x = x; }
+  void sety(int y) { _y = y; }
+
+private:
+  int _dir;
+
+  int _z{0};
+  int _x;
+  int _y;
+  int _bx;
+  int _by;
+
+  const Mesh* localmesh;
+  int nx() const { return localmesh->LocalNx; }
+  int ny() const { return localmesh->LocalNy; }
+  int nz() const { return localmesh->LocalNz; }
+
+  Ind3D xyz2ind(int x, int y, int z) const {
+    return Ind3D{((x * ny() + y) * nz()) + z, ny(), nz()};
+  }
+};
+
+class BoundaryRegionIterY : public BoundaryRegionIter {
+public:
+  ~BoundaryRegionIterY() override = default;
+  BoundaryRegionIterY(const RangeIterator& r, int y, int dir, bool is_end,
+                      const Mesh& mesh)
+      : BoundaryRegionIter(r.ind, y, 0, dir, mesh), r(r), is_end(is_end) {}
+
+  bool operator!=(const BoundaryRegionIterY& rhs) {
+    ASSERT2(y() == rhs.y());
+    if (is_end) {
+      if (rhs.is_end) {
+        return false;
+      }
+      return !rhs.r.isDone();
+    }
+    if (rhs.is_end) {
+      return !r.isDone();
+    }
+    return x() != rhs.x();
+  }
+
+  void _next() override {
+    ++r;
+    setx(r.ind);
+  }
+
+private:
+  RangeIterator r;
+  bool is_end;
+};
+
+class NewBoundaryRegionY {
+public:
+  NewBoundaryRegionY(const Mesh& mesh, bool lower, const RangeIterator& r)
+      : mesh(&mesh), lower(lower), r(r) {}
+  BoundaryRegionIterY begin(bool begin = true) {
+    return BoundaryRegionIterY(r, lower ? mesh->ystart : mesh->yend, lower ? -1 : +1,
+                               !begin, *mesh);
+  }
+  BoundaryRegionIterY end() { return begin(false); }
+
+private:
+  const Mesh* mesh;
+  bool lower;
+  RangeIterator r;
+};

{boutpp_nightly-5.2.1.dev766 → boutpp_nightly-5.2.1.dev961}/include/bout/boundary_op.hxx

@@ -55,9 +55,7 @@ public:
 
   // Note: All methods must implement clone, except for modifiers (see below)
   virtual BoundaryOp* clone(BoundaryRegion* UNUSED(region),
-                            const std::list<std::string>& UNUSED(args)) {
-    throw BoutException("BoundaryOp::clone not implemented");
-  }
+                            const std::list<std::string>& UNUSED(args)) = 0;
 
   /// Clone using positional args and keywords
   /// If not implemented, check if keywords are passed, then call two-argument version
@@ -88,6 +86,10 @@ public:
   BoundaryModifier() = default;
   BoundaryModifier(BoundaryOp* operation) : BoundaryOp(operation->bndry), op(operation) {}
   virtual BoundaryOp* cloneMod(BoundaryOp* op, const std::list<std::string>& args) = 0;
+  BoundaryOp* clone(BoundaryRegion* UNUSED(region),
+                    const std::list<std::string>& UNUSED(args)) override {
+    throw BoutException("This must not be used!");
+  }
 
 protected:
   BoundaryOp* op{nullptr};

{boutpp_nightly-5.2.1.dev766 → boutpp_nightly-5.2.1.dev961}/include/bout/boundary_region.hxx

@@ -4,6 +4,7 @@ class BoundaryRegion;
 #ifndef BOUT_BNDRY_REGION_H
 #define BOUT_BNDRY_REGION_H
 
+#include <cstdint>
 #include <string>
 #include <utility>
 
@@ -15,16 +16,17 @@ extern Mesh* mesh; ///< Global mesh
 } // namespace bout
 
 /// Location of boundary
-enum class BndryLoc {
-  xin,
-  xout,
-  ydown,
-  yup,
-  all,
-  par_fwd_xin, // Don't include parallel boundaries
-  par_bkwd_xin,
-  par_fwd_xout, // Don't include parallel boundaries
-  par_bkwd_xout
+enum class BndryLoc : std::int8_t {
+  xin = 0,
+  xout = 1,
+  ydown = 2,
+  yup = 3,
+  all = 4,
+  par_fwd_xin = 5, // Don't include parallel boundaries
+  par_bkwd_xin = 6,
+  par_fwd_xout = 7, // Don't include parallel boundaries
+  par_bkwd_xout = 8,
+  invalid = -1
 };
 constexpr BndryLoc BNDRY_XIN = BndryLoc::xin;
 constexpr BndryLoc BNDRY_XOUT = BndryLoc::xout;
@@ -35,6 +37,10 @@ constexpr BndryLoc BNDRY_PAR_FWD_XIN = BndryLoc::par_fwd_xin;
 constexpr BndryLoc BNDRY_PAR_BKWD_XIN = BndryLoc::par_bkwd_xin;
 constexpr BndryLoc BNDRY_PAR_FWD_XOUT = BndryLoc::par_fwd_xout;
 constexpr BndryLoc BNDRY_PAR_BKWD_XOUT = BndryLoc::par_bkwd_xout;
+constexpr BndryLoc BNDRY_INVALID = BndryLoc::invalid;
+
+/// Physical type of y boundary
+enum class YBndryType : std::int8_t { sheath, not_sheath, all };
 
 class BoundaryRegionBase {
 public:
@@ -45,14 +51,17 @@ public:
       : localmesh(passmesh ? passmesh : bout::globals::mesh), label(std::move(name)),
         location(loc) {}
 
-  virtual ~BoundaryRegionBase() = default;
+  virtual ~BoundaryRegionBase();
 
+  virtual BoundaryRegion* getLegacyPointer();
   Mesh* localmesh; ///< Mesh does this boundary region belongs to
 
   std::string label; ///< Label for this boundary region
 
-  BndryLoc location;       ///< Which side of the domain is it on?
-  bool isParallel = false; ///< Is this a parallel boundary?
+  BndryLoc location{BndryLoc::invalid}; ///< Which side of the domain is it on?
+  bool isParallel = false;              ///< Is this a parallel boundary?
+  bool isX = false;
+  bool isY = false;
 
   virtual void first() = 0; ///< Move the region iterator to the start
   virtual void next() = 0;  ///< Get the next element in the loop
@@ -60,6 +69,8 @@ public:
                             ///  X or Y first)
   virtual bool
   isDone() = 0; ///< Returns true if outside domain. Can use this with nested nextX, nextY
+
+  BoundaryRegion* legacy{nullptr};
 };
 
 /// Describes a region of the boundary, and a means of iterating over it
@@ -71,6 +82,7 @@ public:
   BoundaryRegion(std::string name, int xd, int yd, Mesh* passmesh = nullptr)
       : BoundaryRegionBase(name, passmesh), bx(xd), by(yd), width(2) {}
   ~BoundaryRegion() override = default;
+  BoundaryRegion* getLegacyPointer() override { return this; }
 
   int x, y;   ///< Indices of the point in the boundary
   int bx, by; ///< Direction of the boundary [x+bx][y+by] is going outwards