Apply formatting

Author: ZedThree

CMakeLists.txt

@@ -87,12 +87,12 @@ public:
   CovariantMetricTensor(FieldMetric g11, FieldMetric g22, FieldMetric g33,
                         FieldMetric g12, FieldMetric g13, FieldMetric g23)
       : MetricTensor(std::move(g11), std::move(g22), std::move(g33), std::move(g12),
-                     std::move(g13), std::move(g23)){};
+                     std::move(g13), std::move(g23)) {};
 
   CovariantMetricTensor(const BoutReal g11, const BoutReal g22, const BoutReal g33,
                         const BoutReal g12, const BoutReal g13, const BoutReal g23,
                         Mesh* mesh)
-      : MetricTensor(g11, g22, g33, g12, g13, g23, mesh){};
+      : MetricTensor(g11, g22, g33, g12, g13, g23, mesh) {};
 };
 
 class ContravariantMetricTensor : public MetricTensor {
@@ -101,12 +101,12 @@ public:
   ContravariantMetricTensor(FieldMetric g_11, FieldMetric g_22, FieldMetric g_33,
                             FieldMetric g_12, FieldMetric g_13, FieldMetric g_23)
       : MetricTensor(std::move(g_11), std::move(g_22), std::move(g_33), std::move(g_12),
-                     std::move(g_13), std::move(g_23)){};
+                     std::move(g_13), std::move(g_23)) {};
 
   ContravariantMetricTensor(const BoutReal g_11, const BoutReal g_22, const BoutReal g_33,
                             const BoutReal g_12, const BoutReal g_13, const BoutReal g_23,
                             Mesh* mesh)
-      : MetricTensor(g_11, g_22, g_33, g_12, g_13, g_23, mesh){};
+      : MetricTensor(g_11, g_22, g_33, g_12, g_13, g_23, mesh) {};
 };
 
 #endif //BOUT_METRIC_TENSOR_HXX

include/bout/metric_tensor.hxx

@@ -2171,9 +2171,9 @@ void BoundaryNeumann_NonOrthogonal::apply(Field3D& f) {
           BoutReal delta = bndry->bx * metric->dx(bndry->x, bndry->y, zk)
                            + bndry->by * metric->dy(bndry->x, bndry->y, zk);
 #else
-        BoutReal delta = bndry->bx * metric->dx(bndry->x, bndry->y)
-                         + bndry->by * metric->dy(bndry->x, bndry->y);
-        for (int zk = 0; zk < mesh->LocalNz; zk++) {
+      BoutReal delta = bndry->bx * metric->dx(bndry->x, bndry->y)
+                       + bndry->by * metric->dy(bndry->x, bndry->y);
+      for (int zk = 0; zk < mesh->LocalNz; zk++) {
 #endif
           if (fg) {
             val = fg->generate(Context(bndry, zk, loc, t, mesh));
@@ -2670,8 +2670,8 @@ void BoundaryNeumann_NonOrthogonal::apply(Field3D& f) {
             -1.0 * sqrt(metric->g33(x, y) / metric->g11(x, y)) * metric->dx(x, y);
         for (int jz = 1; jz <= ncz / 2; jz++) {
           BoutReal kwave =
-              jz * 2.0 * PI / metric->zlength(x, y);   // wavenumber in [rad^-1]
-          c0[jz] *= exp(coef * kwave);                 // The decaying solution only
+              jz * 2.0 * PI / metric->zlength(x, y); // wavenumber in [rad^-1]
+          c0[jz] *= exp(coef * kwave);               // The decaying solution only
         }
         // Reverse FFT
         irfft(c0.begin(), mesh->LocalNz, f(x, y));

src/mesh/boundary_standard.cxx

@@ -96,10 +96,15 @@ ChristoffelSymbols::ChristoffelSymbols(Coordinates& coordinates) {
       + 0.5 * g23 * coordinates.DDX(g_22)
       //+ 0.5 *g33*(coordinates.DDY(covariantMetricTensor.Getg31()) + coordinates.DDX(covariantMetricTensor.Getg32()) - coordinates.DDZ(g_12));
       // which equals to
-      + 0.5 * g33 * (coordinates.DDY(g_13)) + coordinates.DDX(g_23) - coordinates.DDZ(g_12);
-  G3_13_m = 0.5 * g13 * coordinates.DDZ(g_11) + 0.5 * g23 * (coordinates.DDZ(g_12) + coordinates.DDX(g_23) - coordinates.DDY(g_13))
-            + 0.5 * g33 * coordinates.DDX(g_33);
-  G3_23_m = 0.5 * g13 * (coordinates.DDZ(g_12) + coordinates.DDY(g_13)) - coordinates.DDX(g_23) + 0.5 * g23 * coordinates.DDZ(g_22)
+      + 0.5 * g33 * (coordinates.DDY(g_13)) + coordinates.DDX(g_23)
+      - coordinates.DDZ(g_12);
+  G3_13_m =
+      0.5 * g13 * coordinates.DDZ(g_11)
+      + 0.5 * g23
+            * (coordinates.DDZ(g_12) + coordinates.DDX(g_23) - coordinates.DDY(g_13))
+      + 0.5 * g33 * coordinates.DDX(g_33);
+  G3_23_m = 0.5 * g13 * (coordinates.DDZ(g_12) + coordinates.DDY(g_13))
+            - coordinates.DDX(g_23) + 0.5 * g23 * coordinates.DDZ(g_22)
             + 0.5 * g33 * coordinates.DDY(g_33);
 
   output_progress.write("\tCommunicating connection terms\n");

src/mesh/christoffel_symbols.cxx

@@ -13,12 +13,12 @@
 #include <bout/sys/timer.hxx>
 #include <bout/utils.hxx>
 
-#include <bout/fft.hxx>
-#include <bout/interpolation.hxx>
-#include <bout/output_bout_types.hxx>
 #include "parallel/fci.hxx"
 #include "parallel/shiftedmetricinterp.hxx"
 #include "bout/derivs.hxx"
+#include <bout/fft.hxx>
+#include <bout/interpolation.hxx>
+#include <bout/output_bout_types.hxx>
 
 #include <bout/bout_types.hxx>
 
@@ -1547,4 +1547,4 @@ void Coordinates::communicateMetricTensor() {
   covariantMetricTensor.communicate();
 }
 
-void Coordinates::communicateDz() { localmesh->communicate(dz_); }
+void Coordinates::communicateDz() { localmesh->communicate(dz_); }

src/mesh/coordinates.cxx

@@ -84,7 +84,7 @@ Field3D Grad_parP(const Field3D& apar, const Field3D& f) {
 
   Field3D result{emptyFrom(f)};
 
-  int const ncz = mesh->LocalNz;
+  const int ncz = mesh->LocalNz;
 
   Coordinates* metric = apar.getCoordinates();
 
@@ -106,15 +106,15 @@ Field3D Grad_parP(const Field3D& apar, const Field3D& f) {
       for (int z = 0; z < ncz; z++) {
         BoutReal by = 1. / sqrt(metric->g_22(x, y, z));
         // Z indices zm and zp
-        int const zm = (z - 1 + ncz) % ncz;
-        int const zp = (z + 1) % ncz;
+        const int zm = (z - 1 + ncz) % ncz;
+        const int zp = (z + 1) % ncz;
 
         // bx = -DDZ(apar)
-        BoutReal const bx = (apar(x, y, zm) - apar(x, y, zp))
+        const BoutReal bx = (apar(x, y, zm) - apar(x, y, zp))
                             / (0.5 * metric->dz(x, y, zm) + metric->dz(x, y, z)
                                + 0.5 * metric->dz(x, y, zp));
         // bz = DDX(f)
-        BoutReal const bz = (apar(x + 1, y, z) - apar(x - 1, y, z))
+        const BoutReal bz = (apar(x + 1, y, z) - apar(x - 1, y, z))
                             / (0.5 * metric->dx(x - 1, y, z) + metric->dx(x, y, z)
                                + 0.5 * metric->dx(x + 1, y, z));
 
@@ -251,19 +251,19 @@ Field3D Div_par(const Field3D& f, const Field3D& v) {
     for (int j = mesh->ystart; j <= mesh->yend; j++) {
       for (int k = mesh->zstart; k <= mesh->zend; k++) {
         // Value of f and v at left cell face
-        BoutReal const fL = 0.5 * (f(i, j, k) + f.ydown()(i, j - 1, k));
-        BoutReal const vL = 0.5 * (v(i, j, k) + v.ydown()(i, j - 1, k));
+        const BoutReal fL = 0.5 * (f(i, j, k) + f.ydown()(i, j - 1, k));
+        const BoutReal vL = 0.5 * (v(i, j, k) + v.ydown()(i, j - 1, k));
 
-        BoutReal const fR = 0.5 * (f(i, j, k) + f.yup()(i, j + 1, k));
-        BoutReal const vR = 0.5 * (v(i, j, k) + v.yup()(i, j + 1, k));
+        const BoutReal fR = 0.5 * (f(i, j, k) + f.yup()(i, j + 1, k));
+        const BoutReal vR = 0.5 * (v(i, j, k) + v.yup()(i, j + 1, k));
 
         // Calculate flux at right boundary (y+1/2)
-        BoutReal const fluxRight =
+        const BoutReal fluxRight =
             fR * vR * (coord->J(i, j, k) + coord->J(i, j + 1, k))
             / (sqrt(coord->g_22(i, j, k)) + sqrt(coord->g_22(i, j + 1, k)));
 
         // Calculate at left boundary (y-1/2)
-        BoutReal const fluxLeft =
+        const BoutReal fluxLeft =
             fL * vL * (coord->J(i, j, k) + coord->J(i, j - 1, k))
             / (sqrt(coord->g_22(i, j, k)) + sqrt(coord->g_22(i, j - 1, k)));
 
@@ -469,12 +469,12 @@ Coordinates::FieldMetric b0xGrad_dot_Grad(const Field2D& phi, const Field2D& A,
   Coordinates* metric = phi.getCoordinates(outloc);
 
   // Calculate phi derivatives
-  Coordinates::FieldMetric const dpdx = DDX(phi, outloc);
-  Coordinates::FieldMetric const dpdy = DDY(phi, outloc);
+  const Coordinates::FieldMetric dpdx = DDX(phi, outloc);
+  const Coordinates::FieldMetric dpdy = DDY(phi, outloc);
 
   // Calculate advection velocity
-  Coordinates::FieldMetric const vx = -metric->g_23() * dpdy;
-  Coordinates::FieldMetric const vy = metric->g_23() * dpdx;
+  const Coordinates::FieldMetric vx = -metric->g_23() * dpdy;
+  const Coordinates::FieldMetric vy = metric->g_23() * dpdx;
 
   // Upwind A using these velocities
   Coordinates::FieldMetric result = VDDX(vx, A, outloc) + VDDY(vy, A, outloc);
@@ -502,12 +502,12 @@ Field3D b0xGrad_dot_Grad(const Field2D& phi, const Field3D& A, CELL_LOC outloc)
   Coordinates* metric = phi.getCoordinates(outloc);
 
   // Calculate phi derivatives
-  Coordinates::FieldMetric const dpdx = DDX(phi, outloc);
-  Coordinates::FieldMetric const dpdy = DDY(phi, outloc);
+  const Coordinates::FieldMetric dpdx = DDX(phi, outloc);
+  const Coordinates::FieldMetric dpdy = DDY(phi, outloc);
 
   // Calculate advection velocity
-  Coordinates::FieldMetric const vx = -metric->g_23() * dpdy;
-  Coordinates::FieldMetric const vy = metric->g_23() * dpdx;
+  const Coordinates::FieldMetric vx = -metric->g_23() * dpdy;
+  const Coordinates::FieldMetric vy = metric->g_23() * dpdx;
   Coordinates::FieldMetric vz = metric->g_12() * dpdy - metric->g_22() * dpdx;
 
   if (mesh->IncIntShear) {
@@ -542,13 +542,13 @@ Field3D b0xGrad_dot_Grad(const Field3D& p, const Field2D& A, CELL_LOC outloc) {
   Coordinates* metric = p.getCoordinates(outloc);
 
   // Calculate phi derivatives
-  Field3D const dpdx = DDX(p, outloc);
-  Field3D const dpdy = DDY(p, outloc);
-  Field3D const dpdz = DDZ(p, outloc);
+  const Field3D dpdx = DDX(p, outloc);
+  const Field3D dpdy = DDY(p, outloc);
+  const Field3D dpdz = DDZ(p, outloc);
 
   // Calculate advection velocity
-  Field3D const vx = metric->g_22() * dpdz - metric->g_23() * dpdy;
-  Field3D const vy = metric->g_23() * dpdx - metric->g_12() * dpdz;
+  const Field3D vx = metric->g_22() * dpdz - metric->g_23() * dpdy;
+  const Field3D vy = metric->g_23() * dpdx - metric->g_12() * dpdz;
 
   // Upwind A using these velocities
 
@@ -579,13 +579,13 @@ Field3D b0xGrad_dot_Grad(const Field3D& phi, const Field3D& A, CELL_LOC outloc)
   Coordinates* metric = phi.getCoordinates(outloc);
 
   // Calculate phi derivatives
-  Field3D const dpdx = DDX(phi, outloc);
-  Field3D const dpdy = DDY(phi, outloc);
-  Field3D const dpdz = DDZ(phi, outloc);
+  const Field3D dpdx = DDX(phi, outloc);
+  const Field3D dpdy = DDY(phi, outloc);
+  const Field3D dpdz = DDZ(phi, outloc);
 
   // Calculate advection velocity
-  Field3D const vx = metric->g_22() * dpdz - metric->g_23() * dpdy;
-  Field3D const vy = metric->g_23() * dpdx - metric->g_12() * dpdz;
+  const Field3D vx = metric->g_22() * dpdz - metric->g_23() * dpdy;
+  const Field3D vy = metric->g_23() * dpdx - metric->g_12() * dpdz;
   Field3D vz = metric->g_12() * dpdy - metric->g_22() * dpdx;
 
   if (mesh->IncIntShear) {
@@ -666,13 +666,13 @@ Field3D bracket(const Field3D& f, const Field2D& g, BRACKET_METHOD method,
     for (int x = mesh->xstart; x <= mesh->xend; x++) {
       for (int y = mesh->ystart; y <= mesh->yend; y++) {
         for (int z = 0; z < ncz; z++) {
-          int const zm = (z - 1 + ncz) % ncz;
-          int const zp = (z + 1) % ncz;
+          const int zm = (z - 1 + ncz) % ncz;
+          const int zp = (z + 1) % ncz;
 
           BoutReal gp, gm;
 
           // Vx = DDZ(f)
-          BoutReal const vx = (f(x, y, zp) - f(x, y, zm)) / (2. * metric->dz(x, y, z));
+          const BoutReal vx = (f(x, y, zp) - f(x, y, zm)) / (2. * metric->dz(x, y, z));
 
           // Set stability condition
           solver->setMaxTimestep(metric->dx(x, y, z) / (fabs(vx) + 1e-16));
@@ -786,19 +786,19 @@ Field3D bracket(const Field3D& f, const Field2D& g, BRACKET_METHOD method,
           // Above is alternative to const int jzmTmp = (jz - 1 + ncz) % ncz;
 
           // J++ = DDZ(f)*DDX(g) - DDX(f)*DDZ(g)
-          BoutReal const Jpp =
+          const BoutReal Jpp =
               ((f(jx, jy, jzp) - f(jx, jy, jzm)) * (g(jx + 1, jy) - g(jx - 1, jy))
                - (f(jx + 1, jy, jz) - f(jx - 1, jy, jz)) * (g(jx, jy) - g(jx, jy)));
 
           // J+x
-          BoutReal const Jpx =
+          const BoutReal Jpx =
               (g(jx + 1, jy) * (f(jx + 1, jy, jzp) - f(jx + 1, jy, jzm))
                - g(jx - 1, jy) * (f(jx - 1, jy, jzp) - f(jx - 1, jy, jzm))
                - g(jx, jy) * (f(jx + 1, jy, jzp) - f(jx - 1, jy, jzp))
                + g(jx, jy) * (f(jx + 1, jy, jzm) - f(jx - 1, jy, jzm)));
 
           // Jx+
-          BoutReal const Jxp = (g(jx + 1, jy) * (f(jx, jy, jzp) - f(jx + 1, jy, jz))
+          const BoutReal Jxp = (g(jx + 1, jy) * (f(jx, jy, jzp) - f(jx + 1, jy, jz))
                                 - g(jx - 1, jy) * (f(jx - 1, jy, jz) - f(jx, jy, jzm))
                                 - g(jx - 1, jy) * (f(jx, jy, jzp) - f(jx - 1, jy, jz))
                                 + g(jx + 1, jy) * (f(jx + 1, jy, jz) - f(jx, jy, jzm)));
@@ -894,20 +894,20 @@ Field3D bracket(const Field3D& f, const Field3D& g, BRACKET_METHOD method,
     }
 
     // Get current timestep
-    BoutReal const dt = solver->getCurrentTimestep();
+    const BoutReal dt = solver->getCurrentTimestep();
 
     FieldPerp vx(mesh), vz(mesh);
     vx.allocate();
     vx.setLocation(outloc);
     vz.allocate();
     vz.setLocation(outloc);
 
-    int const ncz = mesh->LocalNz;
+    const int ncz = mesh->LocalNz;
     for (int y = mesh->ystart; y <= mesh->yend; y++) {
       for (int x = 1; x <= mesh->LocalNx - 2; x++) {
         for (int z = 0; z < mesh->LocalNz; z++) {
-          int const zm = (z - 1 + ncz) % ncz;
-          int const zp = (z + 1) % ncz;
+          const int zm = (z - 1 + ncz) % ncz;
+          const int zp = (z + 1) % ncz;
 
           // Vx = DDZ(f)
           vx(x, z) = (f(x, y, zp) - f(x, y, zm)) / (2. * metric->dz(x, y, z));
@@ -926,8 +926,8 @@ Field3D bracket(const Field3D& f, const Field3D& g, BRACKET_METHOD method,
 
       for (int x = mesh->xstart; x <= mesh->xend; x++) {
         for (int z = 0; z < ncz; z++) {
-          int const zm = (z - 1 + ncz) % ncz;
-          int const zp = (z + 1) % ncz;
+          const int zm = (z - 1 + ncz) % ncz;
+          const int zp = (z + 1) % ncz;
 
           BoutReal gp, gm;
 

src/mesh/difops.cxx

@@ -1,7 +1,7 @@
 #include "bout/metric_tensor.hxx"
 #include "fmt/core.h"
-#include "bout/bout_types.hxx"
 #include "invert3x3.hxx"
+#include "bout/bout_types.hxx"
 #include "bout/boutexception.hxx"
 #include "bout/field2d.hxx"
 #include "bout/mesh.hxx"

src/mesh/metric_tensor.cxx

@@ -1,7 +1,7 @@
-bout_add_integrated_test(test-laplacexy2-hypre
+bout_add_integrated_test(
+  test-laplacexy2-hypre
   SOURCES test-laplacexy.cxx
   REQUIRES BOUT_HAS_HYPRE
   CONFLICTS BOUT_USE_METRIC_3D
-  USE_RUNTEST
-  USE_DATA_BOUT_INP
-  )
+  USE_RUNTEST USE_DATA_BOUT_INP
+)