boutpp-nightly 6.0.0.dev1925__tar.gz → 6.0.0.dev1968__tar.gz

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/PKG-INFO

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

boutpp_nightly-6.0.0.dev1968/_version.txt

@@ -0,0 +1 @@
+v6.0.0.dev1968

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/include/bout/coordinates.hxx

@@ -46,6 +46,7 @@
 
 class Mesh;
 class YBoundary;
+struct MetricNormaliser;
 
 /*!
  * Represents a coordinate system, and associated operators
@@ -159,8 +160,6 @@ public:
   /// 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()) {
@@ -375,10 +374,16 @@ public:
   void setMetricTensor(const ContravariantMetricTensor& contravariant_metric_tensor,
                        const CovariantMetricTensor& covariant_metric_tensor);
 
+  void setMetricTensorJB(const ContravariantMetricTensor& contravariant_metric_tensor,
+                         const CovariantMetricTensor& covariant_metric_tensor,
+                         const FieldMetric& J, const FieldMetric& Bxy);
+
   void communicateMetricTensor();
 
   void communicateDz();
 
+  void normaliseMetric(const MetricNormaliser& norm);
+
   ///< Coordinate system Jacobian, so volume of cell is J*dx*dy*dz
   const FieldMetric& J() const;
 
@@ -548,4 +553,24 @@ namespace bout {
 std::string parallelSliceFieldName(std::string_view field, int offset);
 }
 
+/// Represents a way to normalise the coordinate system
+/// If a component returns nothing, no normalisation is performed.
+/// Coordinate values are divided by the respective component from
+/// MetricNormaliser, with the exception of the contravariant metric
+/// tensor, which is multiplied by the normalisation factor.
+struct MetricNormaliser {
+  std::optional<BoutReal> g = std::nullopt;
+  std::optional<BoutReal> g11 = std::nullopt;
+  std::optional<BoutReal> g22 = std::nullopt;
+  std::optional<BoutReal> g33 = std::nullopt;
+  std::optional<BoutReal> g12 = std::nullopt;
+  std::optional<BoutReal> g13 = std::nullopt;
+  std::optional<BoutReal> g23 = std::nullopt;
+  std::optional<BoutReal> dx = std::nullopt;
+  std::optional<BoutReal> dy = std::nullopt;
+  std::optional<BoutReal> dz = std::nullopt;
+  std::optional<BoutReal> J = std::nullopt;
+  std::optional<BoutReal> Bxy = std::nullopt;
+};
+
 #endif // BOUT_COORDINATES_H

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/include/bout/metric_tensor.hxx

@@ -17,6 +17,7 @@ using FieldMetric = Field2D;
 } // namespace bout
 
 class Coordinates;
+struct MetricNormaliser;
 
 class MetricTensor {
 public:
@@ -77,6 +78,9 @@ public:
 
   void communicate();
 
+  template <class F>
+  void normaliseMetric(const MetricNormaliser& norm, const F& op);
+
 private:
   FieldMetric g11_m, g22_m, g33_m, g12_m, g13_m, g23_m;
 };
@@ -90,6 +94,8 @@ public:
 
   auto inverse(const std::string& region = "RGN_ALL", bool communicate = true)
       -> ContravariantMetricTensor;
+
+  void normaliseMetric(const MetricNormaliser& norm);
 };
 
 class ContravariantMetricTensor : public MetricTensor {
@@ -98,6 +104,8 @@ public:
 
   auto inverse(const std::string& region = "RGN_ALL", bool communicate = true)
       -> CovariantMetricTensor;
+
+  void normaliseMetric(const MetricNormaliser& norm);
 };
 
 #endif //BOUT_METRIC_TENSOR_HXX

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/include/bout/petsc_preconditioner.hxx

@@ -10,8 +10,18 @@
 #ifndef BOUT_PETSC_PRECONDITIONER_H
 #define BOUT_PETSC_PRECONDITIONER_H
 
+#include "bout/bout_enum_class.hxx"
 #include "bout/build_defines.hxx"
 
+BOUT_ENUM_CLASS_NS(bout, PetscMatrixExportFormat, binary, ascii);
+
+BOUT_ENUM_CLASS_NS(
+    bout, JacobianExportKind,
+    system, ///< Jacobian of the full nonlinear system solved by the solver
+    scaled, ///< Jacobian after solver-coordinate transforms such as variable scaling
+    rhs     ///< Jacobian of the raw model RHS in physical variables
+);
+
 #if BOUT_HAS_PETSC
 
 #include "bout/petsc_interface.hxx"
@@ -22,6 +32,8 @@
 #include <petscmat.h>
 #include <petscvec.h>
 
+#include <string>
+
 class Options;
 class Field3D;
 
@@ -73,6 +85,20 @@ public:
   Mat jacobian() const { return Jfd; }
   MatFDColoring coloring() const { return fdcoloring; }
 
+  /// Save an arbitrary PETSc matrix to disk using ``MatView``.
+  ///
+  /// This is a low-level utility used by solver-specific diagnostic code. It only
+  /// writes the matrix itself in PETSc binary or ASCII format; companion metadata
+  /// such as variable names and index mapping must be written separately by the
+  /// calling solver.
+  static PetscErrorCode saveMatrix(
+      Mat matrix, const std::string& filename,
+      bout::PetscMatrixExportFormat format = bout::PetscMatrixExportFormat::binary);
+  /// Save the internally owned coloring Jacobian matrix ``Jfd``.
+  PetscErrorCode saveMatrix(
+      const std::string& filename,
+      bout::PetscMatrixExportFormat format = bout::PetscMatrixExportFormat::binary) const;
+
   void reset();
 
 private:
@@ -86,6 +112,9 @@ private:
 // unconditionally in PETSc-enabled compilation units.
 class PetscPreconditioner {
 public:
+  void saveMatrix(const std::string& UNUSED(filename),
+                  bout::PetscMatrixExportFormat UNUSED(format) =
+                      bout::PetscMatrixExportFormat::binary) const {}
   void reset() {}
 };
 

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/include/bout/solver.hxx

@@ -1,20 +1,10 @@
 /**************************************************************************
  * Base class for all solvers. Specifies required interface functions
  *
- * Changelog:
- *
- * 2009-08 Ben Dudson, Sean Farley
- *    * Major overhaul, and changed API. Trying to make consistent
- *      interface to PETSc and SUNDIALS solvers
- *
- * 2013-08 Ben Dudson
- *    * Added OO-style API, to allow multiple physics models to coexist
- *      For now both APIs are supported
- *
  **************************************************************************
- * Copyright 2010 B.D.Dudson, S.Farley, M.V.Umansky, X.Q.Xu
+ * Copyright 2010 - 2026 BOUT++ contributors
  *
- * Contact: Ben Dudson, bd512@york.ac.uk
+ * Contact: Ben Dudson, dudson2@llnl.gov
  *
  * This file is part of BOUT++.
  *
@@ -38,12 +28,14 @@
 
 #include "bout/build_defines.hxx"
 
+#include "bout/bout_enum_class.hxx"
 #include "bout/bout_types.hxx"
 #include "bout/boutexception.hxx"
 #include "bout/globals.hxx"
 #include "bout/mesh.hxx"
 #include "bout/monitor.hxx"
 #include "bout/options.hxx"
+#include "bout/petsc_preconditioner.hxx"
 #include "bout/region.hxx"
 
 #include <algorithm>
@@ -368,6 +360,35 @@ public:
 protected:
   friend class SundialsNVectorInterface;
 
+  /// Per-variable metadata written alongside Jacobian diagnostics.
+  ///
+  /// ``offset`` gives the variable position within the per-cell ordering used by
+  /// the PETSc matrix. The full row/column mapping is reconstructed by combining
+  /// these records with ``jacobian_index_base`` from the dump files.
+  struct JacobianVariableMetadata {
+    int offset{0};
+    std::string name;
+    std::string location;
+    bool evolve_bndry{false};
+    bool constraint{false};
+    std::string description;
+  };
+
+  /// Top-level JSON description of a saved Jacobian.
+  ///
+  /// This metadata is intentionally compact: per-variable properties are stored
+  /// once here, while per-cell offsets are reconstructed from
+  /// ``jacobian_index_base`` in the output data files.
+  struct JacobianMetadata {
+    int format_version{1};
+    std::string solver_name;
+    int n2d{0};
+    int n3d{0};
+    std::vector<JacobianVariableMetadata> variables_2d;
+    std::vector<JacobianVariableMetadata> variables_3d;
+    std::string ordering;
+  };
+
   /// Number of command-line arguments
   static int* pargc;
   /// Command-line arguments
@@ -587,8 +608,34 @@ protected:
   void save_derivs(BoutReal* dudata);
   void set_id(BoutReal* udata);
 
-  /// Returns a Field3D containing the global indices
+  /// Returns a Field3D containing the global indices for each locally-owned DOF.
   Field3D globalIndex(int localStart);
+  /// Returns the base global index for the Jacobian ordering in each cell.
+  ///
+  /// Combined with the variable metadata JSON written by
+  /// ``writeJacobianMetadataJson()``, this allows PETSc matrix rows/columns to be
+  /// mapped back to variable names and ``(x, y, z)`` coordinates in Python.
+  Field3D jacobianIndexBase(int localStart = 0);
+  /// Return compact metadata for all evolved ``Field2D`` variables.
+  std::vector<JacobianVariableMetadata> getJacobianMetadata2D() const;
+  /// Return compact metadata for all evolved ``Field3D`` variables.
+  std::vector<JacobianVariableMetadata> getJacobianMetadata3D() const;
+  /// Build the complete Jacobian metadata record for JSON export.
+  JacobianMetadata getJacobianMetadata(const std::string& solver_name) const;
+  /// Write Jacobian metadata as JSON on rank 0.
+  ///
+  /// The JSON file is solver-independent; solver-specific matrix files and the
+  /// ``jacobian_index_base`` output together provide the remaining information
+  /// needed to reconstruct a labeled Jacobian in post-processing.
+  void writeJacobianMetadataJson(const std::string& filename,
+                                 const std::string& solver_name) const;
+
+  /// Writes the Jacobian metadata on first call
+  void writeOnceJacobianMetadata(const std::string& solver_name);
+
+#if BOUT_HAS_PETSC
+  void writeJacobianMatrix(bout::JacobianExportKind kind, Mat jacobian);
+#endif
 
   /// Maximum internal timestep
   BoutReal max_dt{-1.0};
@@ -653,6 +700,21 @@ private:
   std::string run_restart_from = "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy";
   /// Save `run_id` and `run_restart_from` every output
   bool save_repeat_run_id{false};
+  /// Write ``jacobian_index_base`` to the dump files for Jacobian diagnostics.
+  bool save_jacobian_index_base{false};
+  /// Has the Jacobian metadata file been written?
+  bool jacobian_metadata_written{false};
+  /// Running counter appended to successive Jacobian saves
+  int jacobian_export_counter{0};
+  /// Prefix for matrix files and ``*_metadata.json``
+  std::string jacobian_export_prefix;
+  /// PETSc ``MatView`` format: binary or ascii
+  bout::PetscMatrixExportFormat jacobian_export_format;
+
+  /// Return the matrix filename including the extension for the selected format.
+  std::string getJacobianMatrixFilename(const std::string& jacobian_export_prefix,
+                                        bout::JacobianExportKind kind,
+                                        bout::PetscMatrixExportFormat format);
 
   /// Current iteration (output time-step) number
   int iteration{0};

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/include/bout/tokamak_coordinates.hxx

@@ -45,6 +45,9 @@ TokamakCoordinates set_tokamak_coordinates(Mesh& mesh, BoutReal Lbar = 1.0,
                                            BoutReal Bbar = 1.0, bool no_shear = false,
                                            BoutReal shear_factor = 1.0);
 
+MetricNormaliser TokamakOrFCIMetricNormaliser(const Mesh* mesh, BoutReal Bnorm,
+                                              BoutReal rho_s0);
+
 } // namespace bout
 
 #endif //BOUT_TOKAMAK_COORDINATES_HXX

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/manual/sphinx/user_docs/time_integration.rst

@@ -107,6 +107,19 @@ given in table :numref:`tab-solveropts`.
    +--------------------------+--------------------------------------------+-------------------------------------+
    | diagnose                 | Collect and print additional diagnostics   | cvode, imexbdf2, beuler             |
    +--------------------------+--------------------------------------------+-------------------------------------+
+   | save\_jacobian           | Save PETSc Jacobian diagnostics            | cvode, beuler / snes                |
+   +--------------------------+--------------------------------------------+-------------------------------------+
+   | jacobian\_export\_kind   | Which Jacobian to save                     | cvode, beuler / snes                |
+   +--------------------------+--------------------------------------------+-------------------------------------+
+   | jacobian\_export\_trigger | When to save Jacobians                    | cvode                               |
+   +--------------------------+--------------------------------------------+-------------------------------------+
+   | jacobian\_export\_prefix | Prefix for Jacobian matrix files           | cvode, beuler / snes                |
+   +--------------------------+--------------------------------------------+-------------------------------------+
+   | jacobian\_export\_format | PETSc output format for Jacobians          | cvode, beuler / snes                |
+   +--------------------------+--------------------------------------------+-------------------------------------+
+   | save\_jacobian\_index\_base | Write the per-cell Jacobian base index  | cvode, beuler / snes                |
+   |                          | field used to reconstruct saved Jacobians  |                                     |
+   +--------------------------+--------------------------------------------+-------------------------------------+
    | nvector                  | ``N_Vector`` backend for SUNDIALS solvers: | cvode, ida, arkode                  |
    |                          | ``sundials`` or ``manyvector``             |                                     |
    +--------------------------+--------------------------------------------+-------------------------------------+
@@ -223,6 +236,68 @@ nonlinear solvers:
 The linear solver type can be set using the ``linear_solver`` option.
 Valid choices include ``gmres`` (the default), ``fgmres``, ``tfqmr``, ``bcgs``.
 
+CVODE Jacobian diagnostics
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+CVODE can also save PETSc finite-difference Jacobians for post-processing,
+using the same metadata format as the SNES Jacobian diagnostics.
+
+The shared options are:
+
+- ``save_jacobian = true`` to enable exports
+- ``jacobian_export_kind = system`` or ``rhs``
+- ``jacobian_export_prefix`` to choose the output filename prefix
+- ``jacobian_export_format = binary`` or ``ascii``
+- ``save_jacobian_index_base = true`` to save the per-cell index-base field
+
+CVODE adds one extra option:
+
+- ``jacobian_export_trigger = linear_setup`` exports whenever CVODE rebuilds
+  linear solver data.
+- ``jacobian_export_trigger = output`` exports once per solver output timestep.
+
+The supported combinations are:
+
+- ``jacobian_export_kind = system`` requires
+  ``jacobian_export_trigger = linear_setup`` and
+  ``cvode_precon_method = petsc``.
+- ``jacobian_export_kind = rhs`` with
+  ``jacobian_export_trigger = output`` works without PETSc preconditioning and is
+  the easiest way to inspect the model Jacobian.
+- ``jacobian_export_kind = rhs`` with
+  ``jacobian_export_trigger = linear_setup`` is also supported on the PETSc
+  preconditioner path.
+- ``jacobian_export_kind = scaled`` is not currently supported in CVODE because
+  the solver does not yet apply a separate scaling transform.
+
+For example, to save the raw RHS Jacobian once per output timestep:
+
+.. code-block:: ini
+
+   [solver]
+   type = cvode
+   save_jacobian = true
+   save_jacobian_index_base = true
+   jacobian_export_kind = rhs
+   jacobian_export_trigger = output
+
+To save the linearised CVODE system Jacobian whenever the PETSc
+preconditioner is rebuilt:
+
+.. code-block:: ini
+
+   [solver]
+   type = cvode
+   cvode_precon_method = petsc
+   save_jacobian = true
+   save_jacobian_index_base = true
+   jacobian_export_kind = system
+   jacobian_export_trigger = linear_setup
+
+As with the SNES Jacobian export, the output files are written into
+``datadir`` and can be inspected using
+``tests/integrated/jacobian_tools/read_jacobian.py``.
+
 IMEX-BDF2
 ---------
 
@@ -775,6 +850,71 @@ Setting ``solver:force_symmetric_coloring = true``, will make sure
 that the jacobian colouring matrix is symmetric.  This will often
 include a few extra non-zeros that the stencil will miss otherwise
 
+Saving Jacobians for diagnostics
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The SNES solver can save PETSc Jacobian matrices for post-processing.
+This is useful for checking sparsity structure, understanding variable
+coupling, and diagnosing whether solver scaling is helping.
+
+Enable this with:
+
+.. code-block:: ini
+
+   [solver]
+   type = snes
+   save_jacobian = true
+   save_jacobian_index_base = true
+
+By default this writes the Jacobian of the nonlinear system actually
+solved by SNES. Three Jacobian definitions are available:
+
+- ``system``: the Jacobian of the full nonlinear system solved by SNES,
+  including timestep terms and any solver-specific rearrangement.
+- ``scaled``: the Jacobian after solver-coordinate transforms such as
+  variable scaling or ``asinh`` variables.
+- ``rhs``: the Jacobian of the bare model ``rhs()`` in physical variables.
+
+For example, to save the raw RHS Jacobian instead of the system Jacobian:
+
+.. code-block:: bash
+
+   ./your_model solver:save_jacobian=true \
+                solver:save_jacobian_index_base=true \
+                solver:jacobian_export_kind=rhs
+
+To save an ASCII matrix with a custom filename prefix:
+
+.. code-block:: ini
+
+   [solver]
+   save_jacobian = true
+   save_jacobian_index_base = true
+   jacobian_export_kind = scaled
+   jacobian_export_format = ascii
+   jacobian_export_prefix = jacobian_scaled_debug
+
+The Jacobian files are written into ``datadir``:
+
+- ``<prefix>_<kind>_<counter>.dat`` or ``.txt``: PETSc matrix written by
+  ``MatView``.
+- ``jacobian_metadata.json``: compact JSON metadata describing the ordering
+  of 2D and 3D evolved variables.
+- ``jacobian_index_base`` in the normal BOUT++ dump files: the per-cell base
+  global index needed to expand the compact JSON metadata into one row/column
+  label per degree of freedom.
+
+The JSON metadata stores per-variable information once, including name,
+location, ``evolve_bndry``, and ``constraint`` flags. Row and column labels
+for individual matrix entries are reconstructed by combining this JSON with
+``jacobian_index_base`` and the mesh shape.
+
+For now, an example Python reader is provided in
+``tests/integrated/jacobian_tools/read_jacobian.py``. It can load
+the PETSc matrix into dense NumPy form, keep it sparse, optionally create
+Pandas views, and extract variable-to-variable blocks such as ``df/dg``.
+This helper is intended to move into a Python package later, likely xBOUT.
+
 
 Variable Scaling
 ~~~~~~~~~~~~~~~~
@@ -878,12 +1018,24 @@ Summary of solver options
 +---------------------------+---------------+----------------------------------------------------+
 | diagnose                  | false         | Print diagnostic information every iteration       |
 +---------------------------+---------------+----------------------------------------------------+
+| save_jacobian             | false         | Save Jacobian matrices for diagnostics             |
++---------------------------+---------------+----------------------------------------------------+
+| jacobian_export_kind      | system        | Which Jacobian to save: ``system``, ``scaled``,    |
+|                           |               | or ``rhs``                                         |
++---------------------------+---------------+----------------------------------------------------+
+| jacobian_export_prefix    | jacobian      | Prefix for Jacobian matrix files                   |
++---------------------------+---------------+----------------------------------------------------+
+| jacobian_export_format    | binary        | Matrix file format written by PETSc ``MatView``    |
++---------------------------+---------------+----------------------------------------------------+
 | stencil:cross             | 0             | If ``matrix_free=false`` and ``use_coloring=true`` |
 | stencil:square            | 0             | Set the size and shape of the Jacobian coloring    |
 | stencil:taxi              | 2             | stencil.                                           |
 +---------------------------+---------------+----------------------------------------------------+
 | force_symmetric_coloring  | false         | Ensure that the Jacobian coloring is symmetric     |
 +---------------------------+---------------+----------------------------------------------------+
+| save_jacobian_index_base  | false         | Write ``jacobian_index_base`` to the dump files    |
+|                           |               | so saved Jacobians can be reconstructed            |
++---------------------------+---------------+----------------------------------------------------+
 
 The predictor is linear extrapolation from the last two timesteps. It seems to be
 effective, but can be disabled by setting ``predictor = false``.

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/src/mesh/coordinates.cxx

@@ -823,6 +823,7 @@ Coordinates::FieldMetric Coordinates::recalculateJacobian() const {
 }
 
 Coordinates::FieldMetric Coordinates::recalculateBxy() const {
+  ASSERT2(not J().isFci());
   return sqrt(g_22()) / J();
 }
 
@@ -1268,6 +1269,16 @@ void Coordinates::setMetricTensor(
   setJ(recalculateJacobian());
   setBxy(recalculateBxy());
 }
+void Coordinates::setMetricTensorJB(
+    const ContravariantMetricTensor& contravariant_metric_tensor,
+    const CovariantMetricTensor& covariant_metric_tensor, const FieldMetric& J,
+    const FieldMetric& Bxy) {
+  contravariantMetricTensor = contravariant_metric_tensor;
+  covariantMetricTensor = covariant_metric_tensor;
+  setJ(J);
+  setBxy(Bxy);
+  invalidateMetricCaches();
+}
 
 void Coordinates::communicateMetricTensor() {
   contravariantMetricTensor.communicate();
@@ -1277,6 +1288,58 @@ void Coordinates::communicateMetricTensor() {
 void Coordinates::communicateDz() { localmesh->communicate(dz_); }
 
 void Coordinates::splitBxyParallelSlices() {
-  Bxy_.splitParallelSlices();
-  Bxy_.yup() = Bxy_.ydown() = Bxy_;
+  if (not Bxy_.hasParallelSlices()) {
+    auto copy = Bxy_;
+    Bxy_.splitParallelSlices();
+    Bxy_.yup() = Bxy_.ydown() = copy;
+  }
+}
+
+void Coordinates::normaliseMetric(const MetricNormaliser& norm) {
+  covariantMetricTensor.normaliseMetric(norm);
+  contravariantMetricTensor.normaliseMetric(norm);
+
+#if BOUT_USE_METRIC_3D
+  using FieldMetricParallel = Field3DParallel;
+#else
+  using FieldMetricParallel = Field2D;
+#endif
+
+  if (norm.J.has_value()) {
+    if (J().hasParallelSlices()) {
+      setJ(FieldMetricParallel{J() / *norm.J});
+    } else {
+      setJ(J() / *norm.J);
+    }
+  }
+  if (norm.Bxy.has_value()) {
+    if (Bxy().hasParallelSlices()) {
+      setBxy(FieldMetricParallel{Bxy() / *norm.Bxy});
+    } else {
+      setBxy(Bxy() / *norm.Bxy);
+    }
+  }
+  if (norm.dx.has_value()) {
+    setDx(dx() / *norm.dx);
+  }
+  if (norm.dy.has_value()) {
+    setDy(dy() / *norm.dy);
+  }
+  if (norm.dz.has_value()) {
+    setDz(dz() / *norm.dz);
+  }
+  invalidateMetricCaches();
+  if (norm.g.has_value() or norm.g22.has_value()) {
+    if (Bxy().isFci()) {
+      // No we compute g_22_* - they must not be cleared. If they get
+      // cleared, they will be recomputed, but not normalised!
+      auto g22 = norm.g.has_value() ? norm.g.value() : norm.g22.value();
+      g_22_ylow();
+      g_22_yhigh();
+      ASSERT2(_g_22_ylow.has_value());
+      (*_g_22_ylow) /= g22;
+      ASSERT2(_g_22_yhigh.has_value());
+      (*_g_22_yhigh) /= g22;
+    }
+  }
 }

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/src/mesh/difops.cxx

@@ -757,10 +757,13 @@ Field3D Laplace(const Field3D& f, CELL_LOC outloc,
  * Inverse of Laplacian operator in LaplaceXY solver
  *******************************************************************************/
 
-Field2D Laplace_perpXY(const Field2D& A, const Field2D& f) {
 #if BOUT_USE_METRIC_3D
+Field2D Laplace_perpXY([[maybe_unused]] const Field2D& A,
+                       [[maybe_unused]] const Field2D& f) {
   throw BoutException("Coordinates::Laplace_perpXY for 3D metric not implemented");
+}
 #else
+Field2D Laplace_perpXY(const Field2D& A, const Field2D& f) {
   const auto& coords = *f.getCoordinates();
 
   Field2D result;
@@ -816,8 +819,8 @@ Field2D Laplace_perpXY(const Field2D& A, const Field2D& f) {
   }
 
   return result;
-#endif
 }
+#endif
 
 /*******************************************************************************
 * b0xGrad_dot_Grad

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/src/mesh/metric_tensor.cxx

@@ -149,6 +149,48 @@ auto ContravariantMetricTensor::inverse(const std::string& region, bool communic
   return result;
 }
 
+template <class F>
+void MetricTensor::normaliseMetric(const MetricNormaliser& norm, const F& op) {
+  if (norm.g.has_value()) {
+    op(g11_m, norm.g);
+    op(g22_m, norm.g);
+    op(g33_m, norm.g);
+    op(g12_m, norm.g);
+    op(g13_m, norm.g);
+    op(g23_m, norm.g);
+  } else {
+    op(g11_m, norm.g11);
+    op(g22_m, norm.g22);
+    op(g33_m, norm.g33);
+    op(g12_m, norm.g12);
+    op(g13_m, norm.g13);
+    op(g23_m, norm.g23);
+  }
+}
+
+void ContravariantMetricTensor::normaliseMetric(const MetricNormaliser& norm) {
+  MetricTensor::normaliseMetric(norm, [](FieldMetric& f, auto fac) {
+    if (fac.has_value()) {
+      if (f.hasParallelSlices()) {
+        f.asField3DParallel() *= fac.value();
+      } else {
+        f *= fac.value();
+      }
+    }
+  });
+}
+void CovariantMetricTensor::normaliseMetric(const MetricNormaliser& norm) {
+  MetricTensor::normaliseMetric(norm, [](FieldMetric& f, auto fac) {
+    if (fac.has_value()) {
+      if (f.hasParallelSlices()) {
+        f.asField3DParallel() /= fac.value();
+      } else {
+        f /= fac.value();
+      }
+    }
+  });
+}
+
 void MetricTensor::communicate() {
   g11_m.getMesh()->communicate_no_slices(g11_m, g22_m, g33_m, g12_m, g13_m, g23_m);
 }

{boutpp_nightly-6.0.0.dev1925 → boutpp_nightly-6.0.0.dev1968}/src/mesh/tokamak_coordinates.cxx

@@ -75,4 +75,21 @@ TokamakCoordinates set_tokamak_coordinates(Mesh& mesh, BoutReal Lbar, BoutReal B
 
   return {Rxy, Zxy, Bpxy, Btxy, Bxy, hthe, I, I_unnormalised};
 }
+
+MetricNormaliser TokamakOrFCIMetricNormaliser(const Mesh* mesh, BoutReal Bnorm,
+                                              BoutReal rho_s0) {
+  if (mesh->isFci()) {
+    return {.g{SQ(rho_s0)}, .J{rho_s0 * rho_s0 * rho_s0}, .Bxy{Bnorm}};
+  }
+  return {.g11{1 / SQ(Bnorm * rho_s0)},
+          .g22{SQ(rho_s0)},
+          .g33{SQ(rho_s0)},
+          .g12{1 / Bnorm},
+          .g13{1 / Bnorm},
+          .g23{SQ(rho_s0)},
+          .dx{rho_s0 * rho_s0 * Bnorm},
+          .J{rho_s0 / Bnorm},
+          .Bxy{Bnorm}};
+}
+
 } // namespace bout