clang-tidy fixes for f3dwy

externalpackages/PVODE/include/pvode/band.h

@@ -138,7 +138,7 @@ typedef struct bandmat_type {
  *                                                                *
  ******************************************************************/
 
-#define PVODE_BAND_ELEM(A, i, j) ((A->data)[j][i - j + (A->smu)])
+#define PVODE_BAND_ELEM(A, i, j) (((A)->data)[j][(i) - (j) + ((A)->smu)])
 
 /******************************************************************
  *                                                                *
@@ -153,7 +153,7 @@ typedef struct bandmat_type {
  *                                                                *
  ******************************************************************/
 
-#define PVODE_BAND_COL(A, j) (((A->data)[j]) + (A->smu))
+#define PVODE_BAND_COL(A, j) ((((A)->data)[j]) + ((A)->smu))
 
 /******************************************************************
  *                                                                *

externalpackages/PVODE/precon/band.h

@@ -153,7 +153,7 @@ typedef struct bandmat_type {
  *                                                                *
  ******************************************************************/
 
-#define PVODE_BAND_COL(A, j) (((A->data)[j]) + (A->smu))
+#define PVODE_BAND_COL(A, j) ((((A)->data)[j]) + ((A)->smu))
 
 /******************************************************************
  *                                                                *

include/bout/boundary_iterator.hxx

@@ -42,7 +42,9 @@ public:
     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 Field3D& f) const {
+    return (2 * f[ind()]) - yprev(f);
+  }
 
   BoutReal
   extrapolate_next_o2(const std::function<BoutReal(int yoffset, Ind3D ind)>& f) const {
@@ -149,7 +151,8 @@ public:
 #endif
 
   const int dir;
-  virtual ~BoundaryRegionIter = default;
+  virtual ~BoundaryRegionIter() = default;
+
 protected:
   int z{0};
   int x;

include/bout/field.hxx

@@ -542,7 +542,7 @@ class Field3DParallel;
     T result{emptyFrom(f)};                                            \
     BOUT_FOR(d, result.getRegion(rgn)) { result[d] = func(f[d]); }     \
     if constexpr (std::is_base_of_v<Field3DParallel, T>) {             \
-      for (size_t i = 0; i < f.numberParallelSlices(); ++i) {	       \
+      for (size_t i = 0; i < f.numberParallelSlices(); ++i) {          \
         result.yup(i) = func(f.yup(i));                                \
         result.ydown(i) = func(f.ydown(i));                            \
       }                                                                \

include/bout/interpolation_xz.hxx

@@ -166,8 +166,8 @@ protected:
 #if HS_USE_PETSC
   PetscLib* petsclib;
   bool isInit{false};
-  Mat petscWeights;
-  Vec rhs, result;
+  Mat petscWeights{};
+  Vec rhs{}, result{};
 #endif
 
 public:

include/bout/options.hxx

@@ -999,7 +999,7 @@ Tensor<BoutReal> Options::as<Tensor<BoutReal>>(const Tensor<BoutReal>& similar_t
 std::string toString(const Options& value);
 
 /// Save the parallel fields
-void saveParallel(Options& opt, const std::string name, const Field3D& tosave);
+void saveParallel(Options& opt, const std::string& name, const Field3D& tosave);
 
 /// Output a stringified \p value to a stream
 ///

src/field/field2d.cxx

@@ -25,8 +25,10 @@
  *
  **************************************************************************/
 
+#include "bout/bout_types.hxx"
 #include "bout/build_config.hxx"
 
+#include "bout/unused.hxx"
 #include <bout/boutcomm.hxx>
 #include <bout/rvec.hxx>
 
@@ -45,6 +47,8 @@
 
 #include <bout/output.hxx>
 #include <cmath>
+#include <cstddef>
+#include <optional>
 
 #include <bout/assert.hxx>
 

src/field/field3d.cxx

@@ -25,12 +25,16 @@
  *
  **************************************************************************/
 
+#include "bout/bout_types.hxx"
 #include "bout/build_config.hxx"
 
 #include <bout/boutcomm.hxx>
 #include <bout/globals.hxx>
 
 #include <cmath>
+#include <cstddef>
+#include <fmt/format.h>
+#include <optional>
 
 #include "bout/parallel_boundary_op.hxx"
 #include "bout/parallel_boundary_region.hxx"
@@ -989,7 +993,7 @@ template Options* Field3D::track<Field2D>(const Field2D&, std::string);
 template Options* Field3D::track<FieldPerp>(const FieldPerp&, std::string);
 
 Options* Field3D::track(const BoutReal& change, std::string operation) {
-  if (tracking and tracking_state) {
+  if ((tracking != nullptr) and (tracking_state != 0)) {
     const std::string outname{fmt::format("track_{:s}_{:d}", selfname, tracking_state++)};
     tracking->set(outname, change, "tracking");
     (*tracking)[outname].setAttributes({

src/field/fieldperp.cxx

@@ -23,10 +23,13 @@
  *
  **************************************************************************/
 
+#include "bout/unused.hxx"
 #include <bout/boutcomm.hxx>
 #include <bout/globals.hxx>
 
 #include <cmath>
+#include <cstddef>
+#include <optional>
 
 #include <bout/boutexception.hxx>
 #include <bout/fieldperp.hxx>

src/field/generated_fieldops.cxx

@@ -1,11 +1,14 @@
 // This file is autogenerated - see gen_fieldops.py
+#include "bout/assert.hxx"
+#include "bout/build_defines.hxx"
 #include <bout/field2d.hxx>
 #include <bout/field3d.hxx>
 #include <bout/globals.hxx>
 #include <bout/interpolation.hxx>
 #include <bout/mesh.hxx>
 #include <bout/region.hxx>
 #include <cstddef>
+#include <fmt/format.h>
 
 // Provide the C++ wrapper for multiplication of Field3D and Field3D
 Field3D operator*(const Field3D& lhs, const Field3D& rhs) {

src/invert/laplace/impls/petsc/petsc_laplace.cxx

@@ -25,11 +25,15 @@
  **************************************************************************/
 
 #include "bout/build_defines.hxx"
+#include <cmath>
+#include <memory>
 
 #if BOUT_HAS_PETSC
 
 #include "petsc_laplace.hxx"
 
+#include <math.h>
+
 #include <bout/assert.hxx>
 #include <bout/boutcomm.hxx>
 #include <bout/mesh.hxx>
@@ -380,7 +384,7 @@ FieldPerp LaplacePetsc::solve(const FieldPerp& b, const FieldPerp& x0,
   if (localmesh->firstX()) {
     for (int x = 0; x < localmesh->xstart; x++) {
       for (int z = 0; z < localmesh->LocalNz; z++) {
-        PetscScalar val; // Value of element to be set in the matrix
+        PetscScalar val = NAN; // Value of element to be set in the matrix
         // If Neumann Boundary Conditions are set.
         if (isInnerBoundaryFlagSet(INVERT_AC_GRAD)) {
           // Set values corresponding to nodes adjacent in x
@@ -814,7 +818,7 @@ FieldPerp LaplacePetsc::solve(const FieldPerp& b, const FieldPerp& x0,
 
     // Call the actual solver
     {
-      Timer timer("petscsolve");
+      const Timer timer("petscsolve");
       KSPSolve(ksp, bs, xs); // Call the solver to solve the system
     }
 
@@ -830,7 +834,7 @@ FieldPerp LaplacePetsc::solve(const FieldPerp& b, const FieldPerp& x0,
   }
     } else {
       timer.reset();
-      PetscErrorCode err = MatMult(MatA, bs, xs);
+      const PetscErrorCode err = MatMult(MatA, bs, xs);
       if (err != PETSC_SUCCESS) {
         throw BoutException("MatMult failed with {:d}", static_cast<int>(err));
       }

src/invert/laplace/invert_laplace.cxx

@@ -263,7 +263,8 @@ Field3D Laplacian::forward(const Field3D& b) {
   ASSERT1(localmesh == b.getMesh());
 
   // Setting the start and end range of the y-slices
-  int ys = localmesh->ystart, ye = localmesh->yend;
+  int ys = localmesh->ystart;
+  int ye = localmesh->yend;
   if (include_yguards && localmesh->hasBndryLowerY()) {
     ys = 0; // Mesh contains a lower boundary
   }

src/mesh/boundary_factory.cxx

@@ -6,6 +6,7 @@
 #include <bout/options.hxx>
 #include <bout/utils.hxx>
 
+#include <array>
 #include <list>
 #include <map>
 #include <string>

src/mesh/boundary_standard.cxx

@@ -1728,7 +1728,7 @@ void BoundaryNeumann_NonOrthogonal::apply(Field3D& f) {
 
   void BoundaryNeumann::apply(Field2D & f) { BoundaryNeumann::apply(f, 0.); }
 
-  void BoundaryNeumann::apply([[maybe_unused]] Field2D & f, BoutReal t) {
+  void BoundaryNeumann::apply([[maybe_unused]] Field2D & f, [[maybe_unused]] BoutReal t) {
     // Set (at 2nd order / 3rd order) the value at the mid-point between
     // the guard cell and the grid cell to be val
     // N.B. First guard cells (closest to the grid) is 2nd order, while

src/mesh/coordinates.cxx

@@ -4,6 +4,7 @@
  * given the contravariant metric tensor terms
  **************************************************************************/
 
+#include "bout/region.hxx"
 #include <bout/assert.hxx>
 #include <bout/constants.hxx>
 #include <bout/coordinates.hxx>
@@ -18,6 +19,7 @@
 #include <bout/output_bout_types.hxx>
 
 #include <bout/globals.hxx>
+#include <vector>
 
 #include "invert3x3.hxx"
 #include "parallel/fci.hxx"
@@ -619,7 +621,7 @@ Coordinates::Coordinates(Mesh* mesh, Options* options)
         maxError = std::max(std::abs(local - 1), maxError);
       }
     }
-    BoutReal allowedError = (*options)["allowedFluxError"].withDefault(1e-6);
+    const BoutReal allowedError = (*options)["allowedFluxError"].withDefault(1e-6);
     if (maxError < allowedError / 100) {
       output_info.write("\tInfo: The maximum flux conservation error is {:e}", maxError);
     } else if (maxError < allowedError) {
@@ -1617,9 +1619,9 @@ Field3D Coordinates::Div_par(const Field3DParallel& f, CELL_LOC outloc,
     return Bxy * Grad_par(f / Bxy_floc, outloc, method);
   }
 
-  auto coords = f.getCoordinates();
+  auto* coords = f.getCoordinates();
   // Need to modify yup and ydown fields
-  Field3D Jg = coords->J / sqrt(coords->g_22.asField3DParallel());
+  const Field3D Jg = coords->J / sqrt(coords->g_22.asField3DParallel());
   return setName(Jg * Grad_par(f / Jg, outloc, method), "Div_par({:s})", f.name);
 }
 

src/mesh/fv_ops.cxx

@@ -1,3 +1,5 @@
+#include "bout/boutexception.hxx"
+#include "bout/difops.hxx"
 #include <bout/fv_ops.hxx>
 #include <bout/globals.hxx>
 #include <bout/msg_stack.hxx>

src/mesh/impls/bout/boutmesh.cxx

@@ -484,8 +484,8 @@ int BoutMesh::load() {
   }
   ASSERT0(MXG >= 0);
 
-  bool meshHasMyg = Mesh::get(MYG, "MYG") == 0;
-  int meshMyg;
+  const bool meshHasMyg = Mesh::get(MYG, "MYG") == 0;
+  int meshMyg = 0;
   if (!meshHasMyg) {
     MYG = 2;
   } else {

src/mesh/interpolation/bilinear_xz.cxx

@@ -20,6 +20,7 @@
  *
  **************************************************************************/
 
+#include "bout/boutexception.hxx"
 #include "bout/globals.hxx"
 #include "bout/interpolation_xz.hxx"
 #include "bout/mesh.hxx"

src/mesh/interpolation/hermite_spline_xz.cxx

@@ -25,7 +25,12 @@
 #include "bout/globals.hxx"
 #include "bout/index_derivs_interface.hxx"
 #include "bout/interpolation_xz.hxx"
+#include "bout/mask.hxx"
+#include "bout/utils.hxx"
 
+#include <algorithm>
+#include <memory>
+#include <string>
 #include <vector>
 
 class IndConverter {
@@ -529,21 +534,21 @@ Field3D XZMonotonicHermiteSplineLegacy::interpolate(const Field3D& f,
   localmesh->communicateXZ(fx);
   // communicate in y, but do not calculate parallel slices
   {
-    auto h = localmesh->sendY(fx);
+    auto* h = localmesh->sendY(fx);
     localmesh->wait(h);
   }
   Field3D fz = bout::derivatives::index::DDZ(f, CELL_DEFAULT, "DEFAULT", "RGN_ALL");
   localmesh->communicateXZ(fz);
   // communicate in y, but do not calculate parallel slices
   {
-    auto h = localmesh->sendY(fz);
+    auto* h = localmesh->sendY(fz);
     localmesh->wait(h);
   }
   Field3D fxz = bout::derivatives::index::DDX(fz, CELL_DEFAULT, "DEFAULT");
   localmesh->communicateXZ(fxz);
   // communicate in y, but do not calculate parallel slices
   {
-    auto h = localmesh->sendY(fxz);
+    auto* h = localmesh->sendY(fxz);
     localmesh->wait(h);
   }
 
@@ -557,24 +562,24 @@ Field3D XZMonotonicHermiteSplineLegacy::interpolate(const Field3D& f,
     const auto icxpzp = iczp.xp();
 
     // Interpolate f in X at Z
-    const BoutReal f_z =
-        f[ic] * h00_x[i] + f[icxp] * h01_x[i] + fx[ic] * h10_x[i] + fx[icxp] * h11_x[i];
+    const BoutReal f_z = (f[ic] * h00_x[i]) + (f[icxp] * h01_x[i]) + (fx[ic] * h10_x[i])
+                         + (fx[icxp] * h11_x[i]);
 
     // Interpolate f in X at Z+1
-    const BoutReal f_zp1 = f[iczp] * h00_x[i] + f[icxpzp] * h01_x[i] + fx[iczp] * h10_x[i]
-                           + fx[icxpzp] * h11_x[i];
+    const BoutReal f_zp1 = (f[iczp] * h00_x[i]) + (f[icxpzp] * h01_x[i])
+                           + (fx[iczp] * h10_x[i]) + (fx[icxpzp] * h11_x[i]);
 
     // Interpolate fz in X at Z
-    const BoutReal fz_z = fz[ic] * h00_x[i] + fz[icxp] * h01_x[i] + fxz[ic] * h10_x[i]
-                          + fxz[icxp] * h11_x[i];
+    const BoutReal fz_z = (fz[ic] * h00_x[i]) + (fz[icxp] * h01_x[i])
+                          + (fxz[ic] * h10_x[i]) + (fxz[icxp] * h11_x[i]);
 
     // Interpolate fz in X at Z+1
-    const BoutReal fz_zp1 = fz[iczp] * h00_x[i] + fz[icxpzp] * h01_x[i]
-                            + fxz[iczp] * h10_x[i] + fxz[icxpzp] * h11_x[i];
+    const BoutReal fz_zp1 = (fz[iczp] * h00_x[i]) + (fz[icxpzp] * h01_x[i])
+                            + (fxz[iczp] * h10_x[i]) + (fxz[icxpzp] * h11_x[i]);
 
     // Interpolate in Z
     BoutReal result =
-        +f_z * h00_z[i] + f_zp1 * h01_z[i] + fz_z * h10_z[i] + fz_zp1 * h11_z[i];
+        (+f_z * h00_z[i]) + (f_zp1 * h01_z[i]) + (fz_z * h10_z[i]) + (fz_zp1 * h11_z[i]);
 
     ASSERT2(std::isfinite(result) || i.x() < localmesh->xstart
             || i.x() > localmesh->xend);
@@ -594,12 +599,8 @@ Field3D XZMonotonicHermiteSplineLegacy::interpolate(const Field3D& f,
     ASSERT2(std::isfinite(localmin) || i.x() < localmesh->xstart
             || i.x() > localmesh->xend);
 
-    if (result > localmax) {
-      result = localmax;
-    }
-    if (result < localmin) {
-      result = localmin;
-    }
+    result = std::min(result, localmax);
+    result = std::max(result, localmin);
 
     f_interp[iyp] = result;
   }

src/mesh/interpolation/lagrange_4pt_xz.cxx

@@ -20,10 +20,12 @@
  *
  **************************************************************************/
 
+#include "bout/boutexception.hxx"
 #include "bout/globals.hxx"
 #include "bout/interpolation_xz.hxx"
 #include "bout/mesh.hxx"
 
+#include <fmt/format.h>
 #include <vector>
 
 XZLagrange4pt::XZLagrange4pt(int y_offset, Mesh* mesh)