boutpp-nightly 5.2.1.dev738__tar.gz → 5.2.1.dev741__tar.gz

{boutpp_nightly-5.2.1.dev738 → boutpp_nightly-5.2.1.dev741}/CMakeLists.txt

@@ -204,6 +204,7 @@ set(BOUT_SOURCES
     ./include/bout/sys/uuid.h
     ./include/bout/sys/variant.hxx
     ./include/bout/template_combinations.hxx
+    ./include/bout/tokamak_coordinates.hxx
     ./include/bout/traits.hxx
     ./include/bout/unused.hxx
     ./include/bout/utils.hxx
@@ -309,6 +310,7 @@ set(BOUT_SOURCES
     ./src/mesh/parallel_boundary_op.cxx
     ./src/mesh/parallel_boundary_region.cxx
     ./src/mesh/surfaceiter.cxx
+    ./src/mesh/tokamak_coordinates.cxx
     ./src/physics/gyro_average.cxx
     ./src/physics/physicsmodel.cxx
     ./src/physics/smoothing.cxx

{boutpp_nightly-5.2.1.dev738 → boutpp_nightly-5.2.1.dev741}/PKG-INFO

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

boutpp_nightly-5.2.1.dev741/_version.txt

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

{boutpp_nightly-5.2.1.dev738 → boutpp_nightly-5.2.1.dev741}/examples/6field-simple/elm_6f.cxx

@@ -16,6 +16,7 @@
 #include "bout/msg_stack.hxx"
 #include "bout/physicsmodel.hxx"
 #include "bout/sourcex.hxx"
+#include "bout/tokamak_coordinates.hxx"
 
 #include <cmath>
 
@@ -235,9 +236,7 @@ class Elm_6f : public PhysicsModel {
   int damp_width;        // Width of inner damped region
   BoutReal damp_t_const; // Timescale of damping
 
-  // Metric coefficients
-  Field2D Rxy, Bpxy, Btxy, B0, hthe;
-  Field2D I;         // Shear factor
+  Field2D B0;        // Magnetic field
   BoutReal LnLambda; // ln(Lambda)
 
   /// Ion mass
@@ -374,38 +373,10 @@ protected:
   int init(bool restarting) override {
     bool noshear;
 
-    // Get the metric tensor
-    Coordinates* coord = mesh->getCoordinates();
-
     output.write("Solving high-beta flute reduced equations\n");
     output.write("\tFile    : {:s}\n", __FILE__);
     output.write("\tCompiled: {:s} at {:s}\n", __DATE__, __TIME__);
 
-    //////////////////////////////////////////////////////////////
-    // Load data from the grid
-
-    // Load 2D profiles
-    mesh->get(J0, "Jpar0");    // A / m^2
-    mesh->get(P0, "pressure"); // Pascals
-
-    // Load curvature term
-    b0xcv.covariant = false;  // Read contravariant components
-    mesh->get(b0xcv, "bxcv"); // mixed units x: T y: m^-2 z: m^-2
-
-    // Load metrics
-    if (mesh->get(Rxy, "Rxy")) { // m
-      output_error.write("Error: Cannot read Rxy from grid\n");
-      return 1;
-    }
-    if (mesh->get(Bpxy, "Bpxy")) { // T
-      output_error.write("Error: Cannot read Bpxy from grid\n");
-      return 1;
-    }
-    mesh->get(Btxy, "Btxy"); // T
-    mesh->get(B0, "Bxy");    // T
-    mesh->get(hthe, "hthe"); // m
-    mesh->get(I, "sinty");   // m^-2 T^-1
-
     //////////////////////////////////////////////////////////////
     // Read parameters from the options file
     //
@@ -681,19 +652,43 @@ protected:
     phi_curv = options["phi_curv"].doc("Compressional ExB terms").withDefault(true);
     g = options["gamma"].doc("Ratio of specific heats").withDefault(5.0 / 3.0);
 
-    if (!include_curvature) {
-      b0xcv = 0.0;
-    }
+    //////////////////////////////////////////////////////////////
+    // Load data from the grid
 
-    if (!include_jpar0) {
-      J0 = 0.0;
-    }
+    // Load 2D profiles
+    mesh->get(P0, "pressure"); // Pascals
 
-    if (noshear) {
-      if (include_curvature) {
+    // Typical magnetic field
+    mesh->get(Bbar, "bmag", 1.0);
+    // Typical length scale
+    mesh->get(Lbar, "rmag", 1.0);
+
+    // Read, normalise, and set coordinates
+    const auto tokamak_coords =
+        bout::set_tokamak_coordinates(*mesh, Lbar, Bbar, noshear or mesh->IncIntShear);
+    const auto& Rxy = tokamak_coords.Rxy;
+    const auto& Bpxy = tokamak_coords.Bpxy;
+    const auto& Btxy = tokamak_coords.Btxy;
+    const auto& hthe = tokamak_coords.hthe;
+    const auto& I = tokamak_coords.I_unnormalised;
+    // Needed in rhs too
+    B0 = tokamak_coords.Bxy;
+
+    if (include_curvature) {
+      // Load curvature term
+      b0xcv.covariant = false;  // Read contravariant components
+      mesh->get(b0xcv, "bxcv"); // mixed units x: T y: m^-2 z: m^-2
+      if (noshear) {
         b0xcv.z += I * b0xcv.x;
       }
-      I = 0.0;
+    } else {
+      b0xcv = 0.0;
+    }
+
+    if (include_jpar0) {
+      mesh->get(J0, "Jpar0"); // A / m^2
+    } else {
+      J0 = 0.0;
     }
 
     //////////////////////////////////////////////////////////////
@@ -701,26 +696,17 @@ protected:
 
     if (mesh->IncIntShear) {
       // BOUT-06 style, using d/dx = d/dpsi + I * d/dz
-      coord->IntShiftTorsion = I;
-
+      mesh->getCoordinates()->IntShiftTorsion = I;
     } else {
       // Dimits style, using local coordinate system
       if (include_curvature) {
         b0xcv.z += I * b0xcv.x;
       }
-      I = 0.0; // I disappears from metric
     }
 
     //////////////////////////////////////////////////////////////
     // NORMALISE QUANTITIES
 
-    if (mesh->get(Bbar, "bmag")) { // Typical magnetic field
-      Bbar = 1.0;
-    }
-    if (mesh->get(Lbar, "rmag")) { // Typical length scale
-      Lbar = 1.0;
-    }
-
     if (mesh->get(Tibar, "Ti_x")) { // Typical ion temperature scale
       Tibar = 1.0;
     }
@@ -858,14 +844,6 @@ protected:
     b0xcv.y *= Lbar * Lbar;
     b0xcv.z *= Lbar * Lbar;
 
-    Rxy /= Lbar;
-    Bpxy /= Bbar;
-    Btxy /= Bbar;
-    B0 /= Bbar;
-    hthe /= Lbar;
-    coord->dx /= Lbar * Lbar * Bbar;
-    I *= Lbar * Lbar * Bbar;
-
     if ((!T0_fake_prof) && n0_fake_prof) {
       N0 = N0tanh(n0_height * Nbar, n0_ave * Nbar, n0_width, n0_center, n0_bottom_x);
 
@@ -1045,27 +1023,6 @@ protected:
       dump.add(eta, "eta", 0);
     }
 
-    /**************** CALCULATE METRICS ******************/
-
-    coord->g11 = SQ(Rxy * Bpxy);
-    coord->g22 = 1.0 / SQ(hthe);
-    coord->g33 = SQ(I) * coord->g11 + SQ(B0) / coord->g11;
-    coord->g12 = 0.0;
-    coord->g13 = -I * coord->g11;
-    coord->g23 = -Btxy / (hthe * Bpxy * Rxy);
-
-    coord->J = hthe / Bpxy;
-    coord->Bxy = B0;
-
-    coord->g_11 = 1.0 / coord->g11 + SQ(I * Rxy);
-    coord->g_22 = SQ(B0 * hthe / Bpxy);
-    coord->g_33 = Rxy * Rxy;
-    coord->g_12 = Btxy * hthe * I * Rxy / Bpxy;
-    coord->g_13 = I * Rxy * Rxy;
-    coord->g_23 = Btxy * hthe * Rxy / Bpxy;
-
-    coord->geometry(); // Calculate quantities from metric tensor
-
     // Set B field vector
 
     B0vec.covariant = false;

{boutpp_nightly-5.2.1.dev738 → boutpp_nightly-5.2.1.dev741}/examples/conducting-wall-mode/cwm.cxx

@@ -4,12 +4,14 @@
  * Mode discoverd by H.L. Berk et. al. 1993
  * Model version in the code created by M. Umansky and J. Myra.
  *******************************************************************************/
-#include <bout/physicsmodel.hxx>
 
 #include <bout/derivs.hxx>
 #include <bout/initialprofiles.hxx>
 #include <bout/interpolation.hxx>
 #include <bout/invert_laplace.hxx>
+#include <bout/physicsmodel.hxx>
+#include <bout/tokamak_coordinates.hxx>
+#include <bout/utils.hxx>
 
 class CWM : public PhysicsModel {
 private:
@@ -28,9 +30,6 @@ private:
   // Phi boundary conditions
   Field3D dphi_bc_ydown, dphi_bc_yup;
 
-  // Metric coefficients
-  Field2D Rxy, Bpxy, Btxy, hthe, Zxy;
-
   // parameters
   BoutReal Te_x, Ni_x, Vi_x, bmag, rho_s, fmei, AA, ZZ;
   BoutReal lambda_ei;
@@ -54,8 +53,6 @@ private:
   std::unique_ptr<Laplacian> phiSolver{nullptr};
 
   int init(bool UNUSED(restarting)) override {
-    Field2D I; // Shear factor
-
     /************* LOAD DATA FROM GRID FILE ****************/
 
     // Load 2D profiles (set to zero if not found)
@@ -63,11 +60,6 @@ private:
 
     coord = mesh->getCoordinates();
 
-    // Load metrics
-    GRID_LOAD(Rxy, Zxy, Bpxy, Btxy, hthe);
-    mesh->get(coord->dx, "dpsi");
-    mesh->get(I, "sinty");
-
     // Load normalisation values
     GRID_LOAD(Te_x, Ni_x, bmag);
 
@@ -93,13 +85,11 @@ private:
 
     /************* SHIFTED RADIAL COORDINATES ************/
     // Check type of parallel transform
-    std::string ptstr =
-        Options::root()["mesh"]["paralleltransform"]["type"].withDefault<std::string>(
-            "identity");
+    const auto ptstr =
+        Options::root()["mesh"]["paralleltransform"]["type"].withDefault("identity");
 
-    if (lowercase(ptstr) == "shifted") {
-      ShearFactor = 0.0; // I disappears from metric
-    }
+    // I disappears from metric
+    const bool noshear = (lowercase(ptstr) == "shifted");
 
     /************** CALCULATE PARAMETERS *****************/
 
@@ -132,39 +122,19 @@ private:
     Ni0 /= Ni_x / 1.0e14;
     Te0 /= Te_x;
 
-    // Normalise geometry
-    Rxy /= rho_s;
-    hthe /= rho_s;
-    I *= rho_s * rho_s * (bmag / 1e4) * ShearFactor;
-    coord->dx /= rho_s * rho_s * (bmag / 1e4);
-
-    // Normalise magnetic field
-    Bpxy /= (bmag / 1.e4);
-    Btxy /= (bmag / 1.e4);
-    coord->Bxy /= (bmag / 1.e4);
-
     // Set nu
     nu = nu_hat * Ni0 / pow(Te0, 1.5);
 
     /**************** CALCULATE METRICS ******************/
 
-    coord->g11 = SQ(Rxy * Bpxy);
-    coord->g22 = 1.0 / SQ(hthe);
-    coord->g33 = SQ(I) * coord->g11 + SQ(coord->Bxy) / coord->g11;
-    coord->g12 = 0.0;
-    coord->g13 = -I * coord->g11;
-    coord->g23 = -Btxy / (hthe * Bpxy * Rxy);
-
-    coord->J = hthe / Bpxy;
-
-    coord->g_11 = 1.0 / coord->g11 + SQ(I * Rxy);
-    coord->g_22 = SQ(coord->Bxy * hthe / Bpxy);
-    coord->g_33 = Rxy * Rxy;
-    coord->g_12 = Btxy * hthe * I * Rxy / Bpxy;
-    coord->g_13 = I * Rxy * Rxy;
-    coord->g_23 = Btxy * hthe * Rxy / Bpxy;
-
-    coord->geometry();
+    // Read, normalise, and set coordinates
+    const auto tokamak_coords =
+        bout::set_tokamak_coordinates(*mesh, rho_s, bmag / 1e4, noshear);
+    auto Rxy = tokamak_coords.Rxy;
+    auto Zxy = tokamak_coords.Zxy;
+    auto Bpxy = tokamak_coords.Bpxy;
+    auto Btxy = tokamak_coords.Btxy;
+    auto hthe = tokamak_coords.hthe;
 
     /**************** SET EVOLVING VARIABLES *************/
 

{boutpp_nightly-5.2.1.dev738 → boutpp_nightly-5.2.1.dev741}/examples/constraints/alfven-wave/alfven.cxx

@@ -1,8 +1,9 @@
-
 #include <bout/field_factory.hxx>
 #include <bout/invert/laplacexz.hxx>
 #include <bout/invert_laplace.hxx>
 #include <bout/physicsmodel.hxx>
+#include <bout/tokamak_coordinates.hxx>
+#include <bout/utils.hxx>
 
 /// Fundamental constants
 const BoutReal PI = 3.14159265;
@@ -129,12 +130,12 @@ protected:
   }
 
   /*!
-   * Preconditioner. This inverts the operator (1 - gamma*J) 
+   * Preconditioner. This inverts the operator (1 - gamma*J)
    * where J is the Jacobian of the system
    *
    * The system state at time t is stored as usual
    * whilst the vector to be inverted is in ddt(f)
-   * 
+   *
    * Inputs
    * ------
    *
@@ -146,7 +147,7 @@ protected:
    *
    * Output
    * ------
-   * 
+   *
    * ddt(f) = Result of the inversion
    */
   int precon(BoutReal, BoutReal, BoutReal) {
@@ -159,65 +160,14 @@ protected:
   }
 
   void LoadMetric(BoutReal Lnorm, BoutReal Bnorm) {
-    // Load metric coefficients from the mesh
-    Field2D Rxy, Bpxy, Btxy, hthe, sinty;
-    GRID_LOAD5(Rxy, Bpxy, Btxy, hthe, sinty); // Load metrics
-
-    // Get the coordinates object
-    Coordinates* coord = mesh->getCoordinates();
-
-    // Checking for dpsi and qinty used in BOUT grids
-    Field2D dx;
-    if (!mesh->get(dx, "dpsi")) {
-      output << "\tUsing dpsi as the x grid spacing\n";
-      coord->dx = dx; // Only use dpsi if found
-    } else {
-      // dx will have been read already from the grid
-      output << "\tUsing dx as the x grid spacing\n";
-    }
-
-    Rxy /= Lnorm;
-    hthe /= Lnorm;
-    sinty *= SQ(Lnorm) * Bnorm;
-    coord->dx /= SQ(Lnorm) * Bnorm;
-
-    Bpxy /= Bnorm;
-    Btxy /= Bnorm;
-    coord->Bxy /= Bnorm;
-
     // Check type of parallel transform
-    std::string ptstr =
+    const auto ptstr =
         Options::root()["mesh"]["paralleltransform"]["type"].withDefault("identity");
 
-    if (lowercase(ptstr) == "shifted") {
-      // Using shifted metric method
-      sinty = 0.0; // I disappears from metric
-    }
-
-    BoutReal sbp = 1.0; // Sign of Bp
-    if (min(Bpxy, true) < 0.0) {
-      sbp = -1.0;
-    }
-
-    // Calculate metric components
-
-    coord->g11 = SQ(Rxy * Bpxy);
-    coord->g22 = 1.0 / SQ(hthe);
-    coord->g33 = SQ(sinty) * coord->g11 + SQ(coord->Bxy) / coord->g11;
-    coord->g12 = 0.0;
-    coord->g13 = -sinty * coord->g11;
-    coord->g23 = -sbp * Btxy / (hthe * Bpxy * Rxy);
-
-    coord->J = hthe / Bpxy;
-
-    coord->g_11 = 1.0 / coord->g11 + SQ(sinty * Rxy);
-    coord->g_22 = SQ(coord->Bxy * hthe / Bpxy);
-    coord->g_33 = Rxy * Rxy;
-    coord->g_12 = sbp * Btxy * hthe * sinty * Rxy / Bpxy;
-    coord->g_13 = sinty * Rxy * Rxy;
-    coord->g_23 = sbp * Btxy * hthe * Rxy / Bpxy;
-
-    coord->geometry();
+    // I disappears from metric
+    const bool noshear = (lowercase(ptstr) == "shifted");
+    // Read, normalise, and set coordinates
+    bout::set_tokamak_coordinates(*mesh, Lnorm, Bnorm, noshear);
   }
 };
 

{boutpp_nightly-5.2.1.dev738 → boutpp_nightly-5.2.1.dev741}/examples/dalf3/dalf3.cxx

@@ -1,6 +1,6 @@
 /****************************************************************
  * DALF3 model
- * 
+ *
  * Four-field model for electron pressure, vorticity, A|| and
  * parallel velocity
  *
@@ -18,17 +18,18 @@
  *
  ****************************************************************/
 
-#include <bout/physicsmodel.hxx>
-
+#include <bout/constants.hxx>
 #include <bout/interpolation.hxx>
 #include <bout/invert/laplacexy.hxx>
 #include <bout/invert_laplace.hxx>
+#include <bout/physicsmodel.hxx>
+#include <bout/tokamak_coordinates.hxx>
 #include <bout/utils.hxx>
+
+#include <algorithm>
 #include <math.h>
 #include <memory>
 
-#include <bout/constants.hxx>
-
 // Constants
 const BoutReal MU0 = 4.0e-7 * PI;
 const BoutReal Charge = SI::qe;   // electron charge e (C)
@@ -97,22 +98,9 @@ protected:
     b0xcv.covariant = false;  // Read contravariant components
     mesh->get(b0xcv, "bxcv"); // mixed units x: T y: m^-2 z: m^-2
 
-    // Metric coefficients
-    Field2D Rxy, Bpxy, Btxy, hthe;
-    Field2D I; // Shear factor
-
-    if (mesh->get(Rxy, "Rxy")) { // m
-      output_error.write("Error: Cannot read Rxy from grid\n");
-      return 1;
-    }
-    if (mesh->get(Bpxy, "Bpxy")) { // T
-      output_error.write("Error: Cannot read Bpxy from grid\n");
-      return 1;
-    }
-    mesh->get(Btxy, "Btxy"); // T
-    mesh->get(B0, "Bxy");    // T
-    mesh->get(hthe, "hthe"); // m
-    mesh->get(I, "sinty");   // m^-2 T^-1
+    // We need to load this in, despite using `set_tokamak_coordinates`, because
+    // the both length and B normalisation depend on it
+    mesh->get(B0, "Bxy"); // T
 
     //////////////////////////////////////////////////////////////
     // Options
@@ -163,20 +151,6 @@ protected:
       return 1;
     }
 
-    Coordinates* coord = mesh->getCoordinates();
-
-    // SHIFTED RADIAL COORDINATES
-
-    // Check type of parallel transform
-    std::string ptstr =
-        Options::root()["mesh"]["paralleltransform"]["type"].withDefault("identity");
-
-    if (lowercase(ptstr) == "shifted") {
-      // Dimits style, using local coordinate system
-      b0xcv.z += I * b0xcv.x;
-      I = 0.0; // I disappears from metric
-    }
-
     ///////////////////////////////////////////////////
     // Normalisation
 
@@ -212,9 +186,7 @@ protected:
     } else {
       eta = 0.51 * 1.03e-4 * 20. * pow(Te0, -1.5);
     }
-    if (mul_resist < 0.0) {
-      mul_resist = 0.0;
-    }
+    mul_resist = std::max(mul_resist, 0.0);
     eta *= mul_resist;
 
     // Plasma quantities
@@ -228,41 +200,31 @@ protected:
     hyper_viscosity /= wci * SQ(SQ(rho_s));
     viscosity_par /= wci * SQ(rho_s);
 
-    b0xcv.x /= Bnorm;
-    b0xcv.y *= rho_s * rho_s;
-    b0xcv.z *= rho_s * rho_s;
-
-    // Metrics
-    Rxy /= rho_s;
-    hthe /= rho_s;
-    I *= rho_s * rho_s * Bnorm;
-    Bpxy /= Bnorm;
-    Btxy /= Bnorm;
-    B0 /= Bnorm;
-
-    coord->dx /= rho_s * rho_s * Bnorm;
-
     ///////////////////////////////////////////////////
     // CALCULATE METRICS
 
-    coord->g11 = SQ(Rxy * Bpxy);
-    coord->g22 = 1.0 / SQ(hthe);
-    coord->g33 = SQ(I) * coord->g11 + SQ(B0) / coord->g11;
-    coord->g12 = 0.0;
-    coord->g13 = -I * coord->g11;
-    coord->g23 = -Btxy / (hthe * Bpxy * Rxy);
+    // Check type of parallel transform
+    const auto ptstr =
+        Options::root()["mesh"]["paralleltransform"]["type"].withDefault("identity");
 
-    coord->J = hthe / Bpxy;
-    coord->Bxy = B0;
+    // I disappears from metric
+    const bool noshear = (lowercase(ptstr) == "shifted");
 
-    coord->g_11 = 1.0 / coord->g11 + SQ(I * Rxy);
-    coord->g_22 = SQ(B0 * hthe / Bpxy);
-    coord->g_33 = Rxy * Rxy;
-    coord->g_12 = Btxy * hthe * I * Rxy / Bpxy;
-    coord->g_13 = I * Rxy * Rxy;
-    coord->g_23 = Btxy * hthe * Rxy / Bpxy;
+    // Read, normalise, and set coordinates
+    const auto tokamak_coords =
+        bout::set_tokamak_coordinates(*mesh, rho_s, Bnorm, noshear);
+    // Use normalised B0
+    B0 = tokamak_coords.Bxy;
 
-    coord->geometry(); // Calculate quantities from metric tensor
+    // SHIFTED RADIAL COORDINATES
+    if (noshear) {
+      // Dimits style, using local coordinate system
+      b0xcv.z += tokamak_coords.I_unnormalised * b0xcv.x;
+    }
+
+    b0xcv.x /= Bnorm;
+    b0xcv.y *= rho_s * rho_s;
+    b0xcv.z *= rho_s * rho_s;
 
     SOLVE_FOR3(Vort, Pe, Vpar);
     comms.add(Vort, Pe, Vpar);