boutpp-nightly 5.2.1.dev1375__tar.gz → 5.2.1.dev1433__tar.gz

{boutpp_nightly-5.2.1.dev1375 → boutpp_nightly-5.2.1.dev1433}/CMakeLists.txt

@@ -140,6 +140,7 @@ set(BOUT_SOURCES
     ./include/bout/fieldgroup.hxx
     ./include/bout/fieldperp.hxx
     ./include/bout/fv_ops.hxx
+    ./include/bout/fv_ops_impl.hxx
     ./include/bout/generic_factory.hxx
     ./include/bout/globalfield.hxx
     ./include/bout/globalindexer.hxx
@@ -389,6 +390,7 @@ set(BOUT_SOURCES
     ./src/sys/timer.cxx
     ./src/sys/type_name.cxx
     ./src/sys/utils.cxx
+    ./include/bout/git_metadata.hxx
     ${CMAKE_CURRENT_BINARY_DIR}/include/bout/revision.hxx
     ${CMAKE_CURRENT_BINARY_DIR}/include/bout/version.hxx
 )
@@ -511,17 +513,34 @@ else()
 endif()
 set(BOUT_USE_PYTHON ${BOUT_ENABLE_PYTHON})
 
+set_source_files_properties(
+  ${CMAKE_CURRENT_BINARY_DIR}/git_metadata.cxx PROPERTIES GENERATED TRUE
+)
+add_custom_target(
+  bout++-git-metadata
+  COMMAND
+    ${CMAKE_COMMAND} -DOUTPUT_FILE=${CMAKE_CURRENT_BINARY_DIR}/git_metadata.cxx
+    -DSOURCE_DIR=${PROJECT_SOURCE_DIR} -DGIT_EXECUTABLE=${GIT_EXECUTABLE} -P
+    "${CMAKE_CURRENT_LIST_DIR}/cmake/GenerateGitMetadata.cmake"
+  BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/git_metadata.cxx
+  COMMENT "Generating git metadata source"
+)
+
 # Ensure that the compile date/time is up-to-date when any of the sources change
 add_custom_command(
   OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/bout++-time.cxx
   COMMAND ${CMAKE_COMMAND} -P
           "${CMAKE_CURRENT_LIST_DIR}/cmake/GenerateDateTimeFile.cmake"
-  DEPENDS ${BOUT_SOURCES}
+  DEPENDS ${BOUT_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/git_metadata.cxx
   MAIN_DEPENDENCY "${CMAKE_CURRENT_LIST_DIR}/cmake/GenerateDateTimeFile.cmake"
 )
 
-add_library(bout++ ${BOUT_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/bout++-time.cxx)
+add_library(
+  bout++ ${BOUT_SOURCES} ${CMAKE_CURRENT_BINARY_DIR}/bout++-time.cxx
+         ${CMAKE_CURRENT_BINARY_DIR}/git_metadata.cxx
+)
 add_library(bout++::bout++ ALIAS bout++)
+add_dependencies(bout++ bout++-git-metadata)
 target_link_libraries(bout++ PUBLIC MPI::MPI_CXX)
 target_include_directories(
   bout++
@@ -566,6 +585,7 @@ set(BOUT_VERSION_MINOR ${PROJECT_VERSION_MINOR})
 set(BOUT_VERSION_PATCH ${PROJECT_VERSION_PATCH})
 
 # Get the git commit
+find_package(Git QUIET)
 include(GetGitRevisionDescription)
 get_git_head_revision(GIT_REFSPEC BOUT_REVISION)
 if(BOUT_REVISION STREQUAL "GITDIR-NOTFOUND")

{boutpp_nightly-5.2.1.dev1375 → boutpp_nightly-5.2.1.dev1433}/PKG-INFO

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

boutpp_nightly-5.2.1.dev1433/_version.txt

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

boutpp_nightly-5.2.1.dev1433/cmake/GenerateGitMetadata.cmake

@@ -0,0 +1,106 @@
+function(escape_cxx_string input output)
+  set(value "${input}")
+  string(REPLACE "\\" "\\\\" value "${value}")
+  string(REPLACE "\"" "\\\"" value "${value}")
+  string(REPLACE "\r" "" value "${value}")
+  string(REPLACE "\n" "\\n\"\n\"" value "${value}")
+  set(${output}
+      "${value}"
+      PARENT_SCOPE
+  )
+endfunction()
+
+set(git_metadata_available false)
+set(git_dirty false)
+set(git_diff "")
+
+if(NOT DEFINED OUTPUT_FILE)
+  message(FATAL_ERROR "OUTPUT_FILE must be set")
+endif()
+if(NOT DEFINED SOURCE_DIR)
+  message(FATAL_ERROR "SOURCE_DIR must be set")
+endif()
+
+if(NOT DEFINED GIT_EXECUTABLE OR GIT_EXECUTABLE STREQUAL "")
+  find_program(GIT_EXECUTABLE git)
+endif()
+
+if(GIT_EXECUTABLE)
+  execute_process(
+    COMMAND "${GIT_EXECUTABLE}" rev-parse --is-inside-work-tree
+    WORKING_DIRECTORY "${SOURCE_DIR}"
+    RESULT_VARIABLE git_repo_result
+    OUTPUT_VARIABLE git_repo_output
+    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE
+  )
+
+  if(git_repo_result EQUAL 0 AND git_repo_output STREQUAL "true")
+    set(git_metadata_available true)
+
+    execute_process(
+      COMMAND "${GIT_EXECUTABLE}" rev-parse --verify HEAD
+      WORKING_DIRECTORY "${SOURCE_DIR}"
+      RESULT_VARIABLE git_head_result
+      OUTPUT_QUIET ERROR_QUIET
+    )
+
+    if(git_head_result EQUAL 0)
+      execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff --no-ext-diff --binary HEAD --
+        WORKING_DIRECTORY "${SOURCE_DIR}"
+        RESULT_VARIABLE git_diff_result
+        OUTPUT_VARIABLE git_diff
+        ERROR_QUIET
+      )
+      if(NOT git_diff_result EQUAL 0)
+        set(git_diff "")
+      endif()
+    else()
+      execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff --no-ext-diff --binary --cached --
+        WORKING_DIRECTORY "${SOURCE_DIR}"
+        RESULT_VARIABLE git_cached_diff_result
+        OUTPUT_VARIABLE git_cached_diff
+        ERROR_QUIET
+      )
+      if(NOT git_cached_diff_result EQUAL 0)
+        set(git_cached_diff "git diff unavailable")
+      endif()
+
+      execute_process(
+        COMMAND "${GIT_EXECUTABLE}" diff --no-ext-diff --binary --
+        WORKING_DIRECTORY "${SOURCE_DIR}"
+        RESULT_VARIABLE git_worktree_diff_result
+        OUTPUT_VARIABLE git_worktree_diff
+        ERROR_QUIET
+      )
+      if(NOT git_worktree_diff_result EQUAL 0)
+        set(git_worktree_diff "")
+      endif()
+
+      set(git_diff "${git_cached_diff}")
+      if(NOT git_cached_diff STREQUAL "" AND NOT git_worktree_diff STREQUAL "")
+        string(APPEND git_diff "\n")
+      endif()
+      string(APPEND git_diff "${git_worktree_diff}")
+    endif()
+
+    if(NOT git_diff STREQUAL "")
+      set(git_dirty true)
+    endif()
+  endif()
+endif()
+
+escape_cxx_string("${git_diff}" git_diff_escaped)
+
+set(output_tmp "${OUTPUT_FILE}.tmp")
+
+configure_file(
+  "${CMAKE_CURRENT_LIST_DIR}/git_metadata.cxx.in" "${output_tmp}" @ONLY
+)
+
+execute_process(
+  COMMAND "${CMAKE_COMMAND}" -E copy_if_different "${output_tmp}"
+          "${OUTPUT_FILE}"
+)
+execute_process(COMMAND "${CMAKE_COMMAND}" -E rm -f "${output_tmp}")

boutpp_nightly-5.2.1.dev1433/cmake/git_metadata.cxx.in

@@ -0,0 +1,16 @@
+#include "bout/git_metadata.hxx"
+
+namespace bout {
+namespace version {
+namespace {
+constexpr bool git_metadata_available_value = @git_metadata_available@;
+constexpr bool git_dirty_value = @git_dirty@;
+constexpr char git_diff_value[] =
+"@git_diff_escaped@";
+} // namespace
+
+auto git_metadata_available() -> bool { return git_metadata_available_value; }
+auto git_dirty() -> bool { return git_dirty_value; }
+auto git_diff() -> std::string_view { return git_diff_value; }
+} // namespace version
+} // namespace bout

{boutpp_nightly-5.2.1.dev1375 → boutpp_nightly-5.2.1.dev1433}/include/bout/coordinates.hxx

@@ -1,15 +1,8 @@
 /**************************************************************************
  * Describes coordinate systems
  *
- * ChangeLog
- * =========
- *
- * 2014-11-10 Ben Dudson <bd512@york.ac.uk>
- *    * Created by separating metric from Mesh
- *
- *
  **************************************************************************
- * Copyright 2014-2025 BOUT++ contributors
+ * Copyright 2014-2026 BOUT++ contributors
  *
  * Contact: Ben Dudson, dudson2@llnl.gov
  *
@@ -117,101 +110,115 @@ public:
   FieldMetric& g_22_yhigh();
   // Cell Areas
   const FieldMetric& cell_area_xlow() const {
-    if (!_cell_area_xlow.has_value()) {
-      _compute_cell_area_x();
+    if (_cell_area_xlow.has_value()) {
+      return *_cell_area_xlow;
     }
+    _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();
+    if (_cell_area_xhigh.has_value()) {
+      return *_cell_area_xhigh;
     }
+    _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();
+    if (_cell_area_ylow.has_value()) {
+      return *_cell_area_ylow;
     }
+    _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();
+    if (_cell_area_yhigh.has_value()) {
+      return *_cell_area_yhigh;
     }
+    _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();
+    if (_cell_area_zlow.has_value()) {
+      return *_cell_area_zlow;
     }
+    _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();
+    if (_cell_area_zhigh.has_value()) {
+      return *_cell_area_zhigh;
     }
+    _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();
+    if (_cell_area_xlow.has_value()) {
+      return *_cell_area_xlow;
     }
+    _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();
+    if (_cell_area_xhigh.has_value()) {
+      return *_cell_area_xhigh;
     }
+    _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();
+    if (_cell_area_ylow.has_value()) {
+      return *_cell_area_ylow;
     }
+    _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();
+    if (_cell_area_yhigh.has_value()) {
+      return *_cell_area_yhigh;
     }
+    _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();
+    if (_cell_area_zlow.has_value()) {
+      return *_cell_area_zlow;
     }
+    _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();
+    if (_cell_area_zhigh.has_value()) {
+      return *_cell_area_zhigh;
     }
+    _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();
+    if (_cell_volume.has_value()) {
+      return *_cell_volume;
     }
+    _compute_cell_volume();
     ASSERT2(_cell_volume.has_value());
     return *_cell_volume;
   }
   FieldMetric& cell_volume() {
-    if (!_cell_volume.has_value()) {
-      _compute_cell_volume();
+    if (_cell_volume.has_value()) {
+      return *_cell_volume;
     }
+    _compute_cell_volume();
     ASSERT2(_cell_volume.has_value());
     return *_cell_volume;
   }

{boutpp_nightly-5.2.1.dev1375 → boutpp_nightly-5.2.1.dev1433}/include/bout/derivs.hxx

@@ -35,6 +35,7 @@
 #include "bout/vector3d.hxx"
 
 #include "bout/bout_types.hxx"
+#include <type_traits>
 
 ////////// FIRST DERIVATIVES //////////
 
@@ -86,6 +87,13 @@ Field3D DDY(const Field3DParallel& f, CELL_LOC outloc = CELL_DEFAULT,
             const std::string& method = "DEFAULT",
             const std::string& region = "RGN_NOBNDRY");
 
+template <typename E>
+std::enable_if_t<is_expr_field3d_v<E> && !bout::utils::is_Field3D_v<E>, const Field3D>
+DDY(const E& expr, CELL_LOC outloc = CELL_DEFAULT, const std::string& method = "DEFAULT",
+    const std::string& region = "RGN_NOBNDRY") {
+  return DDY(Field3D{expr}, outloc, method, region);
+}
+
 /// Calculate first partial derivative in Y
 ///
 ///   \f$\partial / \partial y\f$

{boutpp_nightly-5.2.1.dev1375 → boutpp_nightly-5.2.1.dev1433}/include/bout/difops.hxx

@@ -1,11 +1,11 @@
 /*!******************************************************************************
  * \file difops.hxx
- * 
+ *
  * Differential operators
  *
  * Changelog:
  *
- * 2009-01 Ben Dudson <bd512@york.ac.uk> 
+ * 2009-01 Ben Dudson <bd512@york.ac.uk>
  *    * Added two optional parameters which can be put in any order
  *      These determine the method to use (DIFF_METHOD)
  *      and CELL_LOC location of the result.
@@ -15,7 +15,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
@@ -30,7 +30,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/>.
- * 
+ *
  *******************************************************************************/
 
 #ifndef BOUT_DIFOPS_H
@@ -81,7 +81,7 @@ Field3D Grad_parP(const Field3D& apar, const Field3D& f);
  * \f[
  *    v\mathbf{b}_0 \cdot \nabla f
  * \f]
- * 
+ *
  *
  * @param[in] v  The velocity in y direction
  * @param[in] f  The scalar field to be differentiated
@@ -175,7 +175,7 @@ inline Field3D Grad2_par2(const Field3D& f, CELL_LOC outloc, DIFF_METHOD method)
 
 /*!
  * Parallel divergence of diffusive flux, K*Grad_par
- * 
+ *
  * \f[
  *    \nabla \cdot ( \mathbf{b}_0 kY (\mathbf{b}_0 \cdot \nabla) f )
  * \f]
@@ -195,12 +195,17 @@ Field3D Div_par_K_Grad_par(const Field3D& kY, const Field2D& f,
 Field3D Div_par_K_Grad_par(const Field3D& kY, const Field3D& f,
                            CELL_LOC outloc = CELL_DEFAULT);
 
+/// Version with energy flow diagnostic
+/// For FCI fields, `flow_ylow` is currently returned as zero.
+Field3D Div_par_K_Grad_par_mod(const Field3D& k, const Field3D& f, Field3D& flow_ylow,
+                               bool bndry_flux = true);
+
 /*!
  * Perpendicular Laplacian operator
  *
  * This version only includes terms in X and Z, dropping
- * derivatives in Y. This is the inverse operation to 
- * the Laplacian inversion class. 
+ * derivatives in Y. This is the inverse operation to
+ * the Laplacian inversion class.
  *
  * For the full perpendicular Laplacian, use Laplace_perp
  */
@@ -212,7 +217,7 @@ FieldPerp Delp2(const FieldPerp& f, CELL_LOC outloc = CELL_DEFAULT, bool useFFT
 /*!
  * Perpendicular Laplacian, keeping y derivatives
  *
- * 
+ *
  */
 Coordinates::FieldMetric
 Laplace_perp(const Field2D& f, CELL_LOC outloc = CELL_DEFAULT,
@@ -246,18 +251,18 @@ Field2D Laplace_perpXY(const Field2D& A, const Field2D& f);
 
 /*!
  * Terms of form b0 x Grad(phi) dot Grad(A)
- * 
+ *
  */
 Coordinates::FieldMetric b0xGrad_dot_Grad(const Field2D& phi, const Field2D& A,
                                           CELL_LOC outloc = CELL_DEFAULT);
 
 /*!
- * Terms of form 
+ * Terms of form
  *
  * \f[
  *   \mathbf{b}_0 \times \nabla \phi \cdot \nabla A
  * \f]
- * 
+ *
  * @param[in] phi The scalar potential
  * @param[in] A   The field being advected
  * @param[in] outloc  The cell location where the result is defined. By default the same as A.
@@ -291,13 +296,13 @@ constexpr BRACKET_METHOD BRACKET_CTU = BRACKET_METHOD::ctu;
  * \f[
  *   [f, g] = (1/B) \mathbf{b}_0 \times \nabla f  \cdot \nabla g
  * \f]
- * 
+ *
  * @param[in] f  The potential
  * @param[in] g  The field being advected
  * @param[in] method   The method to use
  * @param[in] outloc   The cell location where the result is defined. Default is the same as g
  * @param[in] solver   Pointer to the time integration solver
- * 
+ *
  */
 Coordinates::FieldMetric bracket(const Field2D& f, const Field2D& g,
                                  BRACKET_METHOD method = BRACKET_STD,

boutpp_nightly-5.2.1.dev1433/include/bout/fv_ops.hxx

@@ -0,0 +1,170 @@
+/*
+  Finite-volume discretisation methods. Flux-conservative form
+ */
+
+#ifndef BOUT_FV_OPS_H
+#define BOUT_FV_OPS_H
+
+#include "bout/assert.hxx"
+#include "bout/bout_types.hxx"
+#include "bout/build_defines.hxx"
+#include "bout/coordinates.hxx"
+#include "bout/field.hxx"
+#include "bout/field3d.hxx"
+#include "bout/globals.hxx"
+#include "bout/mesh.hxx"
+#include "bout/output_bout_types.hxx" // NOLINT(unused-includes, misc-include-cleaner)
+#include "bout/region.hxx"
+#include "bout/utils.hxx"
+#include "bout/vector2d.hxx"
+
+namespace FV {
+/*!
+ * Div ( a Grad_perp(f) ) -- ∇⊥ ( a ⋅ ∇⊥ f) -- Vorticity
+ */
+Field3D Div_a_Grad_perp(const Field3D& a, const Field3D& f);
+
+[[deprecated("Please use Div_a_Grad_perp instead")]] inline Field3D
+Div_a_Laplace_perp(const Field3D& a, const Field3D& f) {
+  return Div_a_Grad_perp(a, f);
+}
+
+/*!
+   * Divergence of a parallel diffusion Div( k * Grad_par(f) )
+   */
+Field3D Div_par_K_Grad_par(const Field3D& k, const Field3D& f, bool bndry_flux = true);
+
+/*!
+   * 4th-order derivative in Y, using derivatives
+   * on cell boundaries.
+   *
+   * A one-sided 3rd-order derivative, given a value
+   * at a boundary is:
+   *
+   * d3f/dx3 ~= 16/5 f_b - 6 f_0 + 4 f_1 - 6/5 f_2
+   *
+   * where f_b is the value on the boundary; f_0 is the cell
+   * to the left of the boundary; f_1 to the left of f_0 and f_2
+   * to the left of f_1
+   *
+   *    f_2 | f_1 | f_0 |
+   *                   f_b
+   *
+   * NB: Uses to/from FieldAligned coordinates
+   *
+   * No fluxes through domain boundaries
+   */
+Field3D D4DY4(const Field3D& d, const Field3D& f);
+
+/*!
+   * 4th-order dissipation term
+   *
+   *
+   * A one-sided 3rd-order derivative, given a value
+   * at a boundary is:
+   *
+   * d3f/dx3 ~= 16/5 f_b - 6 f_0 + 4 f_1 - 6/5 f_2
+   *
+   * where f_b is the value on the boundary; f_0 is the cell
+   * to the left of the boundary; f_1 to the left of f_0 and f_2
+   * to the left of f_1
+   *
+   *    f_2 | f_1 | f_0 |
+   *                   f_b
+   */
+Field3D D4DY4_Index(const Field3D& f, bool bndry_flux = true);
+
+// Forward declarations of flux limiters
+// If you want to use your own flux limiter, you need to
+// #include <bout/fv_ops_impl.hxx> to instantiate the templates.
+class Upwind;
+class Fromm;
+class MinMod;
+class MC;
+class Superbee;
+class VanAlbada;
+class WENO3;
+
+/*!
+   * Communicate fluxes between processors
+   * Takes values in guard cells, and adds them to cells
+   */
+void communicateFluxes(Field3D& f);
+
+/// Finite volume parallel divergence
+///
+/// Preserves the sum of f*J*dx*dy*dz over the domain
+///
+/// @param[in] f_in   The field being advected.
+///                   This will be reconstructed at cell faces
+///                   using the given CellEdges method
+/// @param[in] v_in   The advection velocity.
+///                   This will be interpolated to cell boundaries
+///                   using linear interpolation
+/// @param[in] wave_speed_in  Local maximum speed of all waves in the system at each
+//                            point in space
+/// @param[in] fixflux     Fix the flux at the boundary to be the value at the
+///                        midpoint (for boundary conditions)
+///
+/// NB: Uses to/from FieldAligned coordinates
+template <typename CellEdges = MC>
+Field3D Div_par(const Field3D& f_in, const Field3D& v_in, const Field3D& wave_speed_in,
+                bool fixflux = true);
+
+/*!
+   * Div ( n * v )  -- Magnetic drifts
+   *
+   * This uses the expression
+   *
+   * Div( A ) = 1/J * d/di ( J * A^i )
+   *
+   * Hence the input vector should be contravariant
+   *
+   * Note: Uses to/from FieldAligned
+   *
+   */
+template <typename CellEdges = MC>
+Field3D Div_f_v(const Field3D& n_in, const Vector3D& v, bool bndry_flux);
+
+/*!
+   * X-Z Finite Volume diffusion operator
+   */
+Field3D Div_Perp_Lap(const Field3D& a, const Field3D& f, CELL_LOC outloc = CELL_DEFAULT);
+
+/// Finite volume parallel divergence
+///
+/// NOTE: Modified version, applies limiter to velocity and field
+///       Performs better (smaller overshoots) than Div_par
+///
+/// Preserves the sum of f*J*dx*dy*dz over the domain
+///
+/// @param[in] f_in   The field being advected.
+///                   This will be reconstructed at cell faces
+///                   using the given CellEdges method
+/// @param[in] v_in   The advection velocity.
+///                   This will be interpolated to cell boundaries
+///                   using linear interpolation
+/// @param[in] wave_speed_in  Local maximum speed of all waves in the system at each
+//                            point in space
+/// @param[in] fixflux     Fix the flux at the boundary to be the value at the
+///                        midpoint (for boundary conditions)
+///
+/// @param[out] flow_ylow    Flow at the lower Y cell boundary
+///                          Already includes area factor * flux
+///                          For FCI fields this diagnostic is currently set to zero.
+template <typename CellEdges = MC>
+Field3D Div_par_mod(const Field3D& f_in, const Field3D& v_in,
+                    const Field3D& wave_speed_in, Field3D& flow_ylow,
+                    bool fixflux = true);
+
+/// This operator calculates Div_par(f v v)
+/// It is used primarily (only?) in the parallel momentum equation.
+///
+/// This operator is used rather than Div(f fv) so that the values of
+/// f and v are consistent with other advection equations: The product
+/// fv is not interpolated to cell boundaries.
+template <typename CellEdges = MC>
+Field3D Div_par_fvv(const Field3D& f_in, const Field3D& v_in,
+                    const Field3D& wave_speed_in, bool fixflux = true);
+} // namespace FV
+#endif // BOUT_FV_OPS_H