boutpp-nightly 5.2.1.dev1111__tar.gz → 5.2.1.dev1147__tar.gz

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/PKG-INFO

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

boutpp_nightly-5.2.1.dev1147/_version.txt

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

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/include/bout/coordinates.hxx

@@ -33,12 +33,14 @@
 #ifndef BOUT_COORDINATES_H
 #define BOUT_COORDINATES_H
 
+#include "bout/assert.hxx"
 #include "bout/field_data.hxx"
 #include <bout/bout_types.hxx>
 #include <bout/build_defines.hxx>
 #include <bout/field2d.hxx>
 #include <bout/field3d.hxx>
 #include <bout/paralleltransform.hxx>
+#include <optional>
 
 #include <array>
 #include <memory>
@@ -107,6 +109,124 @@ public:
   /// Covariant metric tensor
   FieldMetric g_11, g_22, g_33, g_12, g_13, g_23;
 
+  /// get g_22 at the cell faces;
+  const FieldMetric& g_22_ylow() const;
+  const FieldMetric& g_22_yhigh() const;
+  FieldMetric& g_22_ylow();
+  FieldMetric& g_22_yhigh();
+  // Cell Areas
+  const FieldMetric& cell_area_xlow() const {
+    if (!_cell_area_xlow.has_value()) {
+      _compute_cell_area_x();
+    }
+    ASSERT2(_cell_area_xlow.has_value());
+    return *_cell_area_xlow;
+  }
+  const FieldMetric& cell_area_xhigh() const {
+    if (!_cell_area_xhigh.has_value()) {
+      _compute_cell_area_x();
+    }
+    ASSERT2(_cell_area_xhigh.has_value());
+    return *_cell_area_xhigh;
+  }
+  const FieldMetric& cell_area_ylow() const {
+    if (!_cell_area_ylow.has_value()) {
+      _compute_cell_area_y();
+    }
+    ASSERT2(_cell_area_ylow.has_value());
+    return *_cell_area_ylow;
+  }
+  const FieldMetric& cell_area_yhigh() const {
+    if (!_cell_area_yhigh.has_value()) {
+      _compute_cell_area_y();
+    }
+    ASSERT2(_cell_area_yhigh.has_value());
+    return *_cell_area_yhigh;
+  }
+  const FieldMetric& cell_area_zlow() const {
+    if (!_cell_area_zlow.has_value()) {
+      _compute_cell_area_z();
+    }
+    ASSERT2(_cell_area_zlow.has_value());
+    return *_cell_area_zlow;
+  }
+  const FieldMetric& cell_area_zhigh() const {
+    if (!_cell_area_zhigh.has_value()) {
+      _compute_cell_area_z();
+    }
+    ASSERT2(_cell_area_zhigh.has_value());
+    return *_cell_area_zhigh;
+  }
+  FieldMetric& cell_area_xlow() {
+    if (!_cell_area_xlow.has_value()) {
+      _compute_cell_area_x();
+    }
+    ASSERT2(_cell_area_xlow.has_value());
+    return *_cell_area_xlow;
+  }
+  FieldMetric& cell_area_xhigh() {
+    if (!_cell_area_xhigh.has_value()) {
+      _compute_cell_area_x();
+    }
+    ASSERT2(_cell_area_xhigh.has_value());
+    return *_cell_area_xhigh;
+  }
+  FieldMetric& cell_area_ylow() {
+    if (!_cell_area_ylow.has_value()) {
+      _compute_cell_area_y();
+    }
+    ASSERT2(_cell_area_ylow.has_value());
+    return *_cell_area_ylow;
+  }
+  FieldMetric& cell_area_yhigh() {
+    if (!_cell_area_yhigh.has_value()) {
+      _compute_cell_area_y();
+    }
+    ASSERT2(_cell_area_yhigh.has_value());
+    return *_cell_area_yhigh;
+  }
+  FieldMetric& cell_area_zlow() {
+    if (!_cell_area_zlow.has_value()) {
+      _compute_cell_area_z();
+    }
+    ASSERT2(_cell_area_zlow.has_value());
+    return *_cell_area_zlow;
+  }
+  FieldMetric& cell_area_zhigh() {
+    if (!_cell_area_zhigh.has_value()) {
+      _compute_cell_area_z();
+    }
+    ASSERT2(_cell_area_zhigh.has_value());
+    return *_cell_area_zhigh;
+  }
+  // Cell Volume
+  const FieldMetric& cell_volume() const {
+    if (!_cell_volume.has_value()) {
+      _compute_cell_volume();
+    }
+    ASSERT2(_cell_volume.has_value());
+    return *_cell_volume;
+  }
+  FieldMetric& cell_volume() {
+    if (!_cell_volume.has_value()) {
+      _compute_cell_volume();
+    }
+    ASSERT2(_cell_volume.has_value());
+    return *_cell_volume;
+  }
+
+private:
+  mutable std::optional<FieldMetric> _g_22_ylow, _g_22_yhigh;
+  mutable std::optional<FieldMetric> _cell_area_xlow, _cell_area_xhigh;
+  mutable std::optional<FieldMetric> _cell_area_ylow, _cell_area_yhigh;
+  mutable std::optional<FieldMetric> _cell_area_zlow, _cell_area_zhigh;
+  mutable std::optional<FieldMetric> _cell_volume;
+  void _compute_cell_area_x() const;
+  void _compute_cell_area_y() const;
+  void _compute_cell_area_z() const;
+  void _compute_cell_volume() const;
+
+public:
   /// Christoffel symbol of the second kind (connection coefficients)
   FieldMetric G1_11, G1_22, G1_33, G1_12, G1_13, G1_23;
   FieldMetric G2_11, G2_22, G2_33, G2_12, G2_13, G2_23;

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/include/bout/solver.hxx

@@ -454,19 +454,19 @@ protected:
   ///
   /// There are two important things to note about how \p iter is
   /// passed along to each monitor:
-  /// - The solvers all start their iteration numbering from zero, so the
-  ///   initial state is calculated at \p iter = -1
+  /// - The initial state is written at \p iter = 0, and solver output
+  ///   steps are numbered from 1 to NOUT
   /// - Secondly, \p iter is passed along to each monitor *relative to
   ///   that monitor's period*
   ///
   /// In practice, this means that each monitor is called like:
   ///
   ///     monitor->call(solver, simulation_time,
-  ///                   ((iter + 1) / monitor->period) - 1,
+  ///                   iter / monitor->period,
   ///                   NOUT / monitor->period);
   ///
-  /// e.g. for a monitor with period 10, passing \p iter = 9 will
-  /// result in it being called with a value of `(9 + 1)/10 - 1 == 0`
+  /// e.g. for a monitor with period 10, passing \p iter = 10 will
+  /// result in it being called with a value of `10/10 == 1`
   int call_monitors(BoutReal simtime, int iter, int NOUT);
 
   /// Should timesteps be monitored?

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/manual/sphinx/user_docs/time_integration.rst

@@ -1305,7 +1305,9 @@ implement the outputMonitor method of PhysicsModel::
     int outputMonitor(BoutReal simtime, int iter, int nout)
 
 The first input is the current simulation time, the second is the output
-number, and the last is the total number of outputs requested.
+number, and the last is the total number of outputs requested. If an initial
+dump is written, it is output number ``0``. Solver output steps are numbered
+from ``1`` to ``nout``, so ``iter == nout`` indicates the final output.
 This method is called by a monitor object PhysicsModel::modelMonitor, which
 writes the restart files at the same time. You can change the frequency at which
 the monitor is called by calling, in PhysicsModel::init::
@@ -1330,7 +1332,9 @@ returns an int::
 
 The first input is the solver object, the second is the current
 simulation time, the third is the output number, and the last is the
-total number of outputs requested. To get the solver to call this
+total number of outputs requested. As for ``outputMonitor()``, output number
+``0`` is reserved for the initial dump when it is written, and solver output
+steps are numbered from ``1`` to ``NOUT``. To get the solver to call this
 function every output time, define a `MyOutputMonitor` object as a member of your
 PhysicsModel::
 

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/mesh/coordinates.cxx

@@ -7,20 +7,27 @@
 #include "bout/field3d.hxx"
 #include "bout/field_data.hxx"
 #include <bout/assert.hxx>
+#include <bout/bout_types.hxx>
+#include <bout/boutexception.hxx>
 #include <bout/build_defines.hxx>
 #include <bout/constants.hxx>
 #include <bout/coordinates.hxx>
 #include <bout/derivs.hxx>
 #include <bout/fft.hxx>
+#include <bout/field.hxx>
 #include <bout/globals.hxx>
 #include <bout/interpolation.hxx>
 #include <bout/output.hxx>
 #include <bout/output_bout_types.hxx>
+#include <bout/paralleltransform.hxx>
+#include <bout/region.hxx>
 #include <bout/sys/timer.hxx>
 #include <bout/utils.hxx>
 #include <bout/yboundary_regions.hxx>
 
+#include <cmath>
 #include <memory>
+#include <string>
 
 #include "invert3x3.hxx"
 #include "parallel/fci.hxx"
@@ -63,9 +70,8 @@ Field2D interpolateAndExtrapolate(const Field2D& f, CELL_LOC location, bool extr
         // Can use no_extra_interpolate argument to skip the extra interpolation when we
         // want to extrapolate the Christoffel symbol terms which come from derivatives so
         // don't have the extra point set already
-        if ((location == CELL_XLOW) && (bndry->bx > 0)) {
-          extrap_start = 1;
-        } else if ((location == CELL_YLOW) && (bndry->by > 0)) {
+        if (((location == CELL_XLOW) && (bndry->bx > 0))
+            || ((location == CELL_YLOW) && (bndry->by > 0))) {
           extrap_start = 1;
         }
       }
@@ -84,7 +90,7 @@ Field2D interpolateAndExtrapolate(const Field2D& f, CELL_LOC location, bool extr
               (9.
                    * (f(bndry->x - bndry->bx, bndry->y - bndry->by)
                       + f(bndry->x, bndry->y))
-               - f(bndry->x - 2 * bndry->bx, bndry->y - 2 * bndry->by)
+               - f(bndry->x - (2 * bndry->bx), bndry->y - (2 * bndry->by))
                - f(bndry->x + bndry->bx, bndry->y + bndry->by))
               / 16.;
         }
@@ -110,8 +116,8 @@ Field2D interpolateAndExtrapolate(const Field2D& f, CELL_LOC location, bool extr
           }
           // extrapolate into boundary guard cells if there are enough grid points
           for (int i = extrap_start; i < bndry->width; i++) {
-            int xi = bndry->x + i * bndry->bx;
-            int yi = bndry->y + i * bndry->by;
+            const int xi = bndry->x + (i * bndry->bx);
+            const int yi = bndry->y + (i * bndry->by);
             result(xi, yi) = 3.0 * result(xi - bndry->bx, yi - bndry->by)
                              - 3.0 * result(xi - 2 * bndry->bx, yi - 2 * bndry->by)
                              + result(xi - 3 * bndry->bx, yi - 3 * bndry->by);
@@ -501,13 +507,13 @@ Coordinates::Coordinates(Mesh* mesh, Options* options)
       output_warn.write("Not all covariant components of metric tensor found. "
                         "Calculating all from the contravariant tensor\n");
       /// Calculate contravariant metric components if not found
-      if (calcCovariant("RGN_NOCORNERS")) {
+      if (calcCovariant("RGN_NOCORNERS") != 0) {
         throw BoutException("Error in calcCovariant call");
       }
     }
   } else {
     /// Calculate contravariant metric components if not found
-    if (calcCovariant("RGN_NOCORNERS")) {
+    if (calcCovariant("RGN_NOCORNERS") != 0) {
       throw BoutException("Error in calcCovariant call");
     }
   }
@@ -1873,7 +1879,7 @@ Field2D Coordinates::Laplace_perpXY([[maybe_unused]] const Field2D& A,
 
 const Coordinates::FieldMetric& Coordinates::invSg() const {
   if (invSgCache == nullptr) {
-    auto ptr = std::make_unique<FieldMetric>();
+    auto ptr = std::make_unique<Coordinates::FieldMetric>();
     (*ptr) = 1.0 / sqrt(g_22);
     invSgCache = std::move(ptr);
   }
@@ -1893,7 +1899,7 @@ Coordinates::Grad2_par2_DDY_invSg(CELL_LOC outloc, const std::string& method) co
   invSgCache->applyParallelBoundary("parallel_neumann_o2");
 
   // cache
-  auto ptr = std::make_unique<FieldMetric>();
+  auto ptr = std::make_unique<Coordinates::FieldMetric>();
   *ptr = DDY(*invSgCache, outloc, method) * invSg();
   Grad2_par2_DDY_invSgCache[method] = std::move(ptr);
   return *Grad2_par2_DDY_invSgCache[method];
@@ -2003,6 +2009,126 @@ void Coordinates::checkContravariant() {
   }
 }
 
+const Coordinates::FieldMetric& Coordinates::g_22_ylow() const {
+  if (_g_22_ylow.has_value()) {
+    return *_g_22_ylow;
+  }
+  _g_22_ylow.emplace(emptyFrom(g_22));
+  //_g_22_ylow->setLocation(CELL_YLOW);
+  auto* mesh = Bxy.getMesh();
+  if (Bxy.isFci()) {
+    if (mesh->get(_g_22_ylow.value(), "g_22_cell_ylow", 0.0, false) != 0) {
+      throw BoutException("The grid file does not contain `g_22_cell_ylow`.");
+    }
+  } else {
+    ASSERT0(mesh->ystart > 0);
+    BOUT_FOR(i, g_22.getRegion("RGN_NOY")) {
+      _g_22_ylow.value()[i] = SQ(0.5 * (std::sqrt(g_22[i]) + std::sqrt(g_22[i.ym()])));
+    }
+  }
+  return g_22_ylow();
+}
+
+const Coordinates::FieldMetric& Coordinates::g_22_yhigh() const {
+  if (_g_22_yhigh.has_value()) {
+    return *_g_22_yhigh;
+  }
+  _g_22_yhigh.emplace(emptyFrom(g_22));
+  //_g_22_yhigh->setLocation(CELL_YHIGH);
+  auto* mesh = Bxy.getMesh();
+  if (Bxy.isFci()) {
+    if (mesh->get(_g_22_yhigh.value(), "g_22_cell_yhigh", 0.0, false) != 0) {
+      throw BoutException("The grid file does not contain `g_22_cell_yhigh`.");
+    }
+  } else {
+    ASSERT0(mesh->ystart > 0);
+    BOUT_FOR(i, g_22.getRegion("RGN_NOY")) {
+      _g_22_yhigh.value()[i] = SQ(0.5 * (std::sqrt(g_22[i]) + std::sqrt(g_22[i.yp()])));
+    }
+  }
+  return g_22_yhigh();
+}
+
+void Coordinates::_compute_cell_area_x() const {
+  const auto area_centre = sqrt(g_22 * g_33 - SQ(g_23)) * dy * dz;
+  _cell_area_xlow.emplace(emptyFrom(area_centre));
+  _cell_area_xhigh.emplace(emptyFrom(area_centre));
+  // We cannot setLocation, as that would trigger the computation of staggered
+  // metrics.
+  auto* mesh = Bxy.getMesh();
+  ASSERT0(mesh->xstart > 0);
+  BOUT_FOR(i, area_centre.getRegion("RGN_NOX")) {
+    (*_cell_area_xlow)[i] = 0.5 * (area_centre[i] + area_centre[i.xm()]);
+    (*_cell_area_xhigh)[i] = 0.5 * (area_centre[i] + area_centre[i.xp()]);
+  }
+}
+
+void Coordinates::_compute_cell_area_y() const {
+  auto* mesh = Bxy.getMesh();
+  if (g_11.isFci()) {
+    const auto jxz_centre = sqrt(g_11 * g_33 - SQ(g_13));
+    auto jxz_ylow = emptyFrom(jxz_centre);
+    auto jxz_yhigh = emptyFrom(jxz_centre);
+
+    auto By_c = emptyFrom(jxz_centre);
+    auto By_h = emptyFrom(jxz_yhigh);
+    auto By_l = emptyFrom(jxz_ylow);
+    if (mesh->get(By_c, "By", 0.0, false, CELL_CENTRE) != 0) {
+      throw BoutException("The grid file does not contain `By`.");
+    }
+    if (mesh->get(By_l, "By_cell_ylow", 0.0, false) != 0) {
+      throw BoutException("The grid file does not contain `By_cell_ylow`.");
+    }
+    if (mesh->get(By_h, "By_cell_yhigh", 0.0, false) != 0) {
+      throw BoutException("The grid file does not contain `By_cell_yhigh`.");
+    }
+    BOUT_FOR(i, By_c.getRegion("RGN_NOY")) {
+      jxz_ylow[i] = By_c[i] / By_l[i] * jxz_centre[i];
+      jxz_yhigh[i] = By_c[i] / By_h[i] * jxz_centre[i];
+    }
+    ASSERT3(isUniform(dx, true, "RGN_ALL"));
+    ASSERT2(isUniform(dx, false, "RGN_ALL"));
+    ASSERT3(isUniform(dz, true, "RGN_ALL"));
+    ASSERT2(isUniform(dz, false, "RGN_ALL"));
+    _cell_area_ylow.emplace(jxz_ylow * dx * dz);
+    _cell_area_yhigh.emplace(jxz_yhigh * dx * dz);
+  } else {
+    // Field aligned
+    const auto area_centre = sqrt(g_11 * g_33 - SQ(g_13)) * dx * dz;
+    _cell_area_ylow.emplace(emptyFrom(area_centre));
+    _cell_area_yhigh.emplace(emptyFrom(area_centre));
+    // We cannot setLocation, as that would trigger the computation of staggered
+    // metrics.
+    BOUT_FOR(i, mesh->getRegion("RGN_ALL")) {
+      if (i.y() > 0) {
+        (*_cell_area_ylow)[i] = 0.5 * (area_centre[i] + area_centre[i.ym()]);
+      } else {
+        (*_cell_area_ylow)[i] = BoutNaN;
+      }
+      if (i.y() < mesh->LocalNy - 1) {
+        (*_cell_area_yhigh)[i] = 0.5 * (area_centre[i] + area_centre[i.yp()]);
+      } else {
+        (*_cell_area_yhigh)[i] = BoutNaN;
+      }
+    }
+  }
+}
+
+void Coordinates::_compute_cell_area_z() const {
+  const auto area_centre = sqrt(g_11 * g_22 - SQ(g_12)) * dx * dy;
+  _cell_area_zlow.emplace(emptyFrom(area_centre));
+  _cell_area_zhigh.emplace(emptyFrom(area_centre));
+  // We cannot setLocation, as that would trigger the computation of staggered
+  // metrics.
+  //ASSERT0(mesh->zstart > 0);
+  BOUT_FOR(i, area_centre.getRegion("RGN_NOZ")) {
+    (*_cell_area_zlow)[i] = 0.5 * (area_centre[i] + area_centre[i.zm()]);
+    (*_cell_area_zhigh)[i] = 0.5 * (area_centre[i] + area_centre[i.zp()]);
+  }
+}
+
+void Coordinates::_compute_cell_volume() const { _cell_volume.emplace(J * dx * dy * dz); }
+
 std::shared_ptr<YBoundary> Coordinates::makeYBoundary(YBndryType type) const {
   return std::make_shared<YBoundary>(type, localoptions, *localmesh);
 }

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/adams_bashforth/adams_bashforth.cxx

@@ -355,7 +355,7 @@ int AdamsBashforthSolver::run() {
   [[maybe_unused]] int nwasted = 0;
   [[maybe_unused]] int nwasted_following_fail = 0;
 
-  for (int s = 0; s < getNumberOutputSteps(); s++) {
+  for (int s = 1; s <= getNumberOutputSteps(); s++) {
     BoutReal target = simtime + getOutputTimestep();
 
     bool running = true;

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/arkode/arkode.cxx

@@ -513,7 +513,7 @@ int ArkodeSolver::run() {
     throw BoutException("ArkodeSolver not initialised\n");
   }
 
-  for (int i = 0; i < getNumberOutputSteps(); i++) {
+  for (int i = 1; i <= getNumberOutputSteps(); i++) {
 
     /// Run the solver for one output timestep
     simtime = run(simtime + getOutputTimestep());

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/cvode/cvode.cxx

@@ -486,7 +486,7 @@ int CvodeSolver::run() {
     throw BoutException("CvodeSolver not initialised\n");
   }
 
-  for (int i = 0; i < getNumberOutputSteps(); i++) {
+  for (int i = 1; i <= getNumberOutputSteps(); i++) {
 
     /// Run the solver for one output timestep
     simtime = run(simtime + getOutputTimestep());

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/euler/euler.cxx

@@ -66,7 +66,7 @@ int EulerSolver::init() {
 
 int EulerSolver::run() {
 
-  for (int s = 0; s < getNumberOutputSteps(); s++) {
+  for (int s = 1; s <= getNumberOutputSteps(); s++) {
     BoutReal target = simtime + getOutputTimestep();
 
     bool running = true;

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/ida/ida.cxx

@@ -231,7 +231,7 @@ int IdaSolver::run() {
     throw BoutException("IdaSolver not initialised\n");
   }
 
-  for (int i = 0; i < getNumberOutputSteps(); i++) {
+  for (int i = 1; i <= getNumberOutputSteps(); i++) {
 
     /// Run the solver for one output timestep
     simtime = run(simtime + getOutputTimestep());

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/imex-bdf2/imex-bdf2.cxx

@@ -751,7 +751,7 @@ int IMEXBDF2::run() {
 
   int internalCounter = 0; // Cumulative number of successful internal iterations
 
-  for (int s = 0; s < getNumberOutputSteps(); s++) {
+  for (int s = 1; s <= getNumberOutputSteps(); s++) {
     BoutReal cumulativeTime = 0.;
     int counter = 0; // How many iterations in this output step
 

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/petsc/petsc.cxx

@@ -64,10 +64,10 @@
 
 class ColoringStencil {
 private:
-  bool static isInSquare(int const i, int const j, int const n_square) {
+  bool static isInSquare(const int i, const int j, const int n_square) {
     return std::abs(i) <= n_square && std::abs(j) <= n_square;
   }
-  bool static isInCross(int const i, int const j, int const n_cross) {
+  bool static isInCross(const int i, const int j, const int n_cross) {
     if (i == 0) {
       return std::abs(j) <= n_cross;
     }
@@ -76,7 +76,7 @@ private:
     }
     return false;
   }
-  bool static isInTaxi(int const i, int const j, int const n_taxi) {
+  bool static isInTaxi(const int i, const int j, const int n_taxi) {
     return std::abs(i) + std::abs(j) <= n_taxi;
   }
 
@@ -234,7 +234,7 @@ PetscErrorCode PetscMonitor(TS ts, PetscInt UNUSED(step), PetscReal t, Vec X, vo
     s->load_vars(const_cast<BoutReal*>(x));
     PetscCall(VecRestoreArrayRead(interpolatedX, &x));
 
-    if (s->call_monitors(output_time, i++, s->getNumberOutputSteps()) != 0) {
+    if (s->call_monitors(output_time, ++i, s->getNumberOutputSteps()) != 0) {
       PetscFunctionReturn(1);
     }
 
@@ -614,7 +614,7 @@ int PetscSolver::init() {
         n_taxi = 2;
       }
 
-      auto const xy_offsets = ColoringStencil::getOffsets(n_square, n_taxi, n_cross);
+      const auto xy_offsets = ColoringStencil::getOffsets(n_square, n_taxi, n_cross);
       {
         // This is ugly but can't think of a better and robust way to
         // count the non-zeros for some arbitrary stencil
@@ -734,7 +734,7 @@ int PetscSolver::init() {
       // Mark non-zero entries
 
       output_progress.write("Marking non-zero Jacobian entries\n");
-      PetscScalar const val = 1.0;
+      const PetscScalar val = 1.0;
       for (int x = mesh->xstart; x <= mesh->xend; x++) {
         for (int y = mesh->ystart; y <= mesh->yend; y++) {
 
@@ -753,21 +753,21 @@ int PetscSolver::init() {
                 continue;
               }
 
-              int const ind2 = ROUND(index(xi, yi, 0));
+              const int ind2 = ROUND(index(xi, yi, 0));
               if (ind2 < 0) {
                 continue; // A boundary point
               }
 
               // Depends on all variables on this cell
               for (int j = 0; j < n2d; j++) {
-                PetscInt const col = ind2 + j;
+                const PetscInt col = ind2 + j;
                 PetscCall(MatSetValues(Jfd, 1, &row, 1, &col, &val, INSERT_VALUES));
               }
             }
           }
           // 3D fields
           for (int z = mesh->zstart; z <= mesh->zend; z++) {
-            int const ind = ROUND(index(x, y, z));
+            const int ind = ROUND(index(x, y, z));
 
             for (int i = 0; i < n3d; i++) {
               PetscInt row = ind + i;
@@ -777,7 +777,7 @@ int PetscSolver::init() {
 
               // Depends on 2D fields
               for (int j = 0; j < n2d; j++) {
-                PetscInt const col = ind0 + j;
+                const PetscInt col = ind0 + j;
                 PetscCall(MatSetValues(Jfd, 1, &row, 1, &col, &val, INSERT_VALUES));
               }
 
@@ -802,7 +802,7 @@ int PetscSolver::init() {
 
                   // 3D fields on this cell
                   for (int j = 0; j < n3d; j++) {
-                    PetscInt const col = ind2 + j;
+                    const PetscInt col = ind2 + j;
                     int ierr = MatSetValues(Jfd, 1, &row, 1, &col, &val, INSERT_VALUES);
 
                     if (ierr != 0) {

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/power/power.cxx

@@ -45,7 +45,7 @@ int PowerSolver::run() {
   // Make sure that f0 has a norm of 1
   divide(f0, norm(f0));
 
-  for (int s = 0; s < getNumberOutputSteps(); s++) {
+  for (int s = 1; s <= getNumberOutputSteps(); s++) {
 
     load_vars(std::begin(f0));
     run_rhs(curtime);

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/pvode/pvode.cxx

@@ -5,7 +5,7 @@
  * Copyright 2010 B.D.Dudson, S.Farley, M.V.Umansky, X.Q.Xu
  *
  * Contact Ben Dudson, bd512@york.ac.uk
- * 
+ *
  * This file is part of BOUT++.
  *
  * BOUT++ is free software: you can redistribute it and/or modify
@@ -20,7 +20,7 @@
  *
  * You should have received a copy of the GNU Lesser General Public License
  * along with BOUT++.  If not, see <http://www.gnu.org/licenses/>.
- * 
+ *
  **************************************************************************/
 
 #include "bout/build_defines.hxx"
@@ -195,8 +195,8 @@ int PvodeSolver::init() {
   BoutReal* udata = N_VDATA(u);
   save_vars(udata);
 
-  /* Call CVodeMalloc to initialize CVODE: 
-     
+  /* Call CVodeMalloc to initialize CVODE:
+
      neq     is the problem size = number of equations
      f       is the user's right hand side function in y'=f(t,y)
      T0      is the initial time
@@ -294,7 +294,7 @@ int PvodeSolver::run() {
     throw BoutException("PvodeSolver not initialised\n");
   }
 
-  for (int i = 0; i < getNumberOutputSteps(); i++) {
+  for (int i = 1; i <= getNumberOutputSteps(); i++) {
 
     /// Run the solver for one output timestep
     simtime = run(simtime + getOutputTimestep());

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/rk3-ssp/rk3-ssp.cxx

@@ -61,7 +61,7 @@ int RK3SSP::init() {
 
 int RK3SSP::run() {
 
-  for (int s = 0; s < getNumberOutputSteps(); s++) {
+  for (int s = 1; s <= getNumberOutputSteps(); s++) {
     BoutReal target = simtime + getOutputTimestep();
 
     BoutReal dt;

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/rk4/rk4.cxx

@@ -73,7 +73,7 @@ int RK4Solver::init() {
 }
 
 int RK4Solver::run() {
-  for (int s = 0; s < getNumberOutputSteps(); s++) {
+  for (int s = 1; s <= getNumberOutputSteps(); s++) {
     BoutReal target = simtime + getOutputTimestep();
 
     BoutReal dt;

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/rkgeneric/rkgeneric.cxx

@@ -80,7 +80,7 @@ void RKGenericSolver::resetInternalFields() {
 }
 
 int RKGenericSolver::run() {
-  for (int s = 0; s < getNumberOutputSteps(); s++) {
+  for (int s = 1; s <= getNumberOutputSteps(); s++) {
     BoutReal target = simtime + getOutputTimestep();
 
     BoutReal dt;

{boutpp_nightly-5.2.1.dev1111 → boutpp_nightly-5.2.1.dev1147}/src/solver/impls/slepc/slepc.cxx

@@ -579,7 +579,7 @@ void SlepcSolver::monitor(PetscInt its, PetscInt nconv, PetscScalar eigr[],
   static bool first = true;
   if (eigenValOnly && first) {
     first = false;
-    resetIterationCounter();
+    resetIterationCounter(1);
   }
 
   // Temporary eigenvalues, converted from the SLEPc eigenvalues
@@ -701,7 +701,7 @@ void SlepcSolver::analyseResults() {
   output << "Converged eigenvalues :\n"
             "\tIndex\tSlepc eig (mag.)\t\t\tBOUT eig (mag.)\n";
 
-  resetIterationCounter();
+  resetIterationCounter(1);
 
   // Declare and create vectors to store eigenfunctions
   Vec vecReal, vecImag;