boutpp-nightly 5.2.1.dev1069__tar.gz → 5.2.1.dev1106__tar.gz

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/PKG-INFO

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

boutpp_nightly-5.2.1.dev1106/_version.txt

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

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/cmake/SetupBOUTThirdParty.cmake

@@ -285,12 +285,8 @@ if(BOUT_USE_ADIOS2)
     find_package(ADIOS2 REQUIRED)
   endif()
 
-  
-  foreach(_adios2_candidate
-    adios2::cxx_mpi
-    adios2::cxx20_mpi
-    adios2::cxx17_mpi
-    adios2::cxx11_mpi
+  foreach(_adios2_candidate adios2::cxx_mpi adios2::cxx20_mpi adios2::cxx17_mpi
+                            adios2::cxx11_mpi
   )
     if(TARGET ${_adios2_candidate})
       set(_adios2_target ${_adios2_candidate})
@@ -299,8 +295,7 @@ if(BOUT_USE_ADIOS2)
   endforeach()
 
   if(NOT DEFINED _adios2_target)
-    message(FATAL_ERROR
-      "Could not find a usable ADIOS2 CXX CMake target. ")
+    message(FATAL_ERROR "Could not find a usable ADIOS2 CXX CMake target. ")
   endif()
   message(STATUS "Using ADIOS2 CMake target: ${_adios2_target}")
 
@@ -358,6 +353,7 @@ cmake_dependent_option(
   BOUT_USE_SUNDIALS "Enable support for SUNDIALS time solvers" OFF
   "NOT BOUT_DOWNLOAD_SUNDIALS" ON
 )
+set(BOUT_HAS_SUNDIALS_MANYVECTOR OFF)
 if(BOUT_USE_SUNDIALS)
   enable_language(C)
   if(BOUT_DOWNLOAD_SUNDIALS)
@@ -411,6 +407,14 @@ if(BOUT_USE_SUNDIALS)
     set(SUNDIALS_ROOT "${SUNDIALS_DIR}")
   endif()
   target_link_libraries(bout++ PUBLIC SUNDIALS::nvecparallel)
+  if(TARGET SUNDIALS::nvecmanyvector)
+    target_link_libraries(bout++ PUBLIC SUNDIALS::nvecmanyvector)
+    set(BOUT_HAS_SUNDIALS_MANYVECTOR ON)
+  else()
+    message(
+      STATUS "SUNDIALS ManyVector support not found; custom N_Vector disabled"
+    )
+  endif()
   target_link_libraries(bout++ PUBLIC SUNDIALS::cvode)
   target_link_libraries(bout++ PUBLIC SUNDIALS::ida)
   target_link_libraries(bout++ PUBLIC SUNDIALS::arkode)

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/cmake_build_defines.hxx.in

@@ -20,6 +20,7 @@
 #cmakedefine01 BOUT_HAS_SCOREP
 #cmakedefine01 BOUT_HAS_SLEPC
 #cmakedefine01 BOUT_HAS_SUNDIALS
+#cmakedefine01 BOUT_HAS_SUNDIALS_MANYVECTOR
 #cmakedefine01 BOUT_HAS_UUID_SYSTEM_GENERATOR
 #cmakedefine01 BOUT_USE_COLOR
 #cmakedefine01 BOUT_USE_OPENMP

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/include/bout/build_config.hxx

@@ -30,6 +30,7 @@ constexpr auto has_uuid_system_generator =
     static_cast<bool>(BOUT_HAS_UUID_SYSTEM_GENERATOR);
 constexpr auto has_slepc = static_cast<bool>(BOUT_HAS_SLEPC);
 constexpr auto has_sundials = static_cast<bool>(BOUT_HAS_SUNDIALS);
+constexpr auto has_sundials_manyvector = static_cast<bool>(BOUT_HAS_SUNDIALS_MANYVECTOR);
 constexpr auto use_backtrace = static_cast<bool>(BOUT_USE_BACKTRACE);
 constexpr auto use_color = static_cast<bool>(BOUT_USE_COLOR);
 constexpr auto use_openmp = static_cast<bool>(BOUT_USE_OPENMP);

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/include/bout/field2d.hxx

@@ -274,6 +274,7 @@ public:
   void applyTDerivBoundary() override;
   void setBoundaryTo(const Field2D& f2d); ///< Copy the boundary region
 
+  void swapData(Field2D& other);
   friend void swap(Field2D& first, Field2D& second) noexcept;
 
   int size() const override { return nx * ny; }

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/include/bout/field3d.hxx

@@ -536,6 +536,7 @@ public:
   void applyParallelBoundary(const std::string& region, const std::string& condition,
                              Field3D* f);
 
+  void swapData(Field3D& other);
   friend void swap(Field3D& first, Field3D& second) noexcept;
 
   int size() const override { return nx * ny * nz; };

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/include/bout/solver.hxx

@@ -50,6 +50,7 @@
 // C function pointer types
 
 class Solver;
+class SundialsNVectorInterface;
 
 /// RHS function pointer
 using rhsfunc = int (*)(BoutReal);
@@ -358,6 +359,8 @@ public:
   int getIterationOffset() const { return iteration_offset; }
 
 protected:
+  friend class SundialsNVectorInterface;
+
   /// Number of command-line arguments
   static int* pargc;
   /// Command-line arguments

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/include/bout/sundials_backports.hxx

@@ -32,10 +32,11 @@
 
 // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 #define SUNDIALS_VERSION_AT_LEAST(major, minor, patch) \
-  ((major) < SUNDIALS_VERSION_MAJOR                      \
-   || ((major) == SUNDIALS_VERSION_MAJOR                 \
-       && ((minor) < SUNDIALS_VERSION_MINOR              \
-           || ((minor) == SUNDIALS_VERSION_MINOR && (patch) <= SUNDIALS_VERSION_PATCH))))
+  ((major) < SUNDIALS_VERSION_MAJOR                    \
+   || ((major) == SUNDIALS_VERSION_MAJOR               \
+       && ((minor) < SUNDIALS_VERSION_MINOR            \
+           || ((minor) == SUNDIALS_VERSION_MINOR       \
+               && (patch) <= SUNDIALS_VERSION_PATCH))))
 #define SUNDIALS_VERSION_LESS_THAN(major, minor, patch) \
   (!SUNDIALS_VERSION_AT_LEAST(major, minor, patch))
 // NOLINTEND(cppcoreguidelines-macro-usage)
@@ -77,13 +78,13 @@ inline sundials::Context createSUNContext([[maybe_unused]] MPI_Comm& comm) {
 #endif
 }
 
-template <typename Func, typename... Args>
-inline decltype(auto) callWithSUNContext(Func f, [[maybe_unused]] sundials::Context& ctx,
+template <typename Func, typename Ctx, typename... Args>
+inline decltype(auto) callWithSUNContext(Func f, [[maybe_unused]] Ctx&& ctx,
                                          Args&&... args) {
 #if SUNDIALS_VERSION_LESS_THAN(6, 0, 0)
   return f(std::forward<Args>(args)...);
 #else
-  return f(std::forward<Args>(args)..., ctx);
+  return f(std::forward<Args>(args)..., std::forward<Ctx>(ctx));
 #endif
 }
 

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/manual/sphinx/user_docs/time_integration.rst

@@ -33,7 +33,7 @@ needed to make the solver available.
 
 .. _tab-solvers:
 .. table:: Available time integration solvers
-	   
+
    +---------------+-----------------------------------------+------------------------+
    | Name          | Description                             | Compile options        |
    +===============+=========================================+========================+
@@ -68,7 +68,7 @@ given in table :numref:`tab-solveropts`.
 
 .. _tab-solveropts:
 .. table:: Time integration solver options
-	   
+
    +--------------------------+--------------------------------------------+-------------------------------------+
    | Option                   | Description                                | Solvers used                        |
    +==========================+============================================+=====================================+
@@ -104,6 +104,9 @@ given in table :numref:`tab-solveropts`.
    +--------------------------+--------------------------------------------+-------------------------------------+
    | diagnose                 | Collect and print additional diagnostics   | cvode, imexbdf2, beuler             |
    +--------------------------+--------------------------------------------+-------------------------------------+
+   | nvector                  | ``N_Vector`` backend for SUNDIALS solvers: | cvode, ida, arkode                  |
+   |                          | ``sundials`` or ``manyvector``             |                                     |
+   +--------------------------+--------------------------------------------+-------------------------------------+
 
 |
 
@@ -111,6 +114,30 @@ The most commonly changed options are the absolute and relative solver
 tolerances, ``atol`` and ``rtol`` which should be varied to check
 convergence.
 
+SUNDIALS ``N_Vector`` backends
+------------------------------
+
+The SUNDIALS-based solvers ``cvode``, ``ida``, and ``arkode`` can select
+the ``N_Vector`` backend at runtime using ``solver:nvector``:
+
+.. code-block:: cfg
+
+    [solver]
+    type = cvode
+    nvector = sundials
+
+Valid values are:
+
+- ``sundials`` uses the standard SUNDIALS parallel ``N_Vector``. This is the
+  default.
+- ``manyvector`` uses the BOUT++ field-backed custom ``N_Vector`` built on top
+  of SUNDIALS ManyVector support.
+
+The ``manyvector`` option is only available when BOUT++ was built with SUNDIALS
+ManyVector support. If ``solver:nvector=manyvector`` is selected in a build
+that does not provide this support, solver initialisation will throw an
+exception.
+
 CVODE
 -----
 

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/src/field/field2d.cxx

@@ -327,6 +327,8 @@ void Field2D::setBoundaryTo(const Field2D& f2d) {
   }
 }
 
+void Field2D::swapData(Field2D& other) { std::swap(data, other.data); }
+
 ////////////// NON-MEMBER OVERLOADED OPERATORS //////////////
 
 // Unary minus

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/src/field/field3d.cxx

@@ -670,6 +670,8 @@ void Field3D::applyParallelBoundary(const std::string& region,
   }
 }
 
+void Field3D::swapData(Field3D& other) { std::swap(data, other.data); }
+
 /***************************************************************
  *               NON-MEMBER OVERLOADED OPERATORS
  ***************************************************************/

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/src/solver/impls/arkode/arkode.cxx

@@ -27,9 +27,9 @@
 
 #if BOUT_HAS_ARKODE
 
+#include "../../sundials_nvector_interface.hxx"
 #include "arkode.hxx"
 
-#include "bout/assert.hxx"
 #include "bout/bout_types.hxx"
 #include "bout/boutcomm.hxx"
 #include "bout/boutexception.hxx"
@@ -41,6 +41,7 @@
 #include "bout/msg_stack.hxx"
 #include "bout/options.hxx"
 #include "bout/output.hxx"
+#include "bout/region.hxx"
 #include "bout/solver.hxx"
 #include "bout/sundials_backports.hxx"
 #include "bout/unused.hxx"
@@ -57,6 +58,7 @@
 #include <algorithm>
 #include <iterator>
 #include <numeric>
+#include <string>
 #include <vector>
 
 // NOLINTBEGIN(readability-identifier-length)
@@ -152,6 +154,9 @@ ArkodeSolver::ArkodeSolver(Options* opts)
       use_jacobian((*options)["use_jacobian"]
                        .doc("Use user-supplied Jacobian function")
                        .withDefault(false)),
+      nvector_type((*options)["nvector"]
+                       .doc("N_Vector backend to use: sundials or manyvector")
+                       .withDefault(NVectorType::Sundials)),
 #if ARKODE_OPTIMAL_PARAMS_SUPPORT
       optimize(
           (*options)["optimize"].doc("Use ARKode optimal parameters").withDefault(false)),
@@ -190,8 +195,10 @@ ArkodeSolver::~ArkodeSolver() {
 int ArkodeSolver::init() {
 
   Solver::init();
+  const auto backend = nvector_backend();
 
   output.write("Initialising SUNDIALS' ARKODE solver\n");
+  backend.ensure_manyvector_available();
 
   // Calculate number of variables (in generic_solver)
   const int local_N = getLocalN();
@@ -206,14 +213,10 @@ int ArkodeSolver::init() {
   output.write("\t3d fields = {:d}, 2d fields = {:d} neq={:d}, local_N={:d}\n", n3Dvars(),
                n2Dvars(), neq, local_N);
 
-  // Allocate memory
-  uvec = callWithSUNContext(N_VNew_Parallel, suncontext, BoutComm::get(), local_N, neq);
-  if (uvec == nullptr) {
-    throw BoutException("SUNDIALS memory allocation failed\n");
-  }
+  output.write("\tUsing {} N_Vector backend\n", backend.backend_name());
 
-  // Put the variables into uvec
-  save_vars(N_VGetArrayPointer(uvec));
+  // Allocate memory
+  uvec = backend.create_state_vector(local_N, neq);
 
   switch (treatment) {
   case Treatment::ImEx:
@@ -565,6 +568,7 @@ int ArkodeSolver::run() {
 
 BoutReal ArkodeSolver::run(BoutReal tout) {
   TRACE("Running solver: solver::run({:e})", tout);
+  const auto backend = nvector_backend();
 
   bout::globals::mpi->MPI_Barrier(BoutComm::get());
 
@@ -599,7 +603,7 @@ BoutReal ArkodeSolver::run(BoutReal tout) {
   }
 
   // Copy variables
-  load_vars(N_VGetArrayPointer(uvec));
+  backend.copy_state_from_vector(uvec);
   // Call rhs function to get extra variables at this time
   run_rhs(simtime);
   // run_diffusive(simtime);
@@ -616,11 +620,13 @@ BoutReal ArkodeSolver::run(BoutReal tout) {
  * Explicit RHS function du = F_E(t, u)
  **************************************************************************/
 
-void ArkodeSolver::rhs_e(BoutReal t, BoutReal* udata, BoutReal* dudata) {
+void ArkodeSolver::rhs_e(BoutReal t, N_Vector u, N_Vector du) {
   TRACE("Running RHS: ArkodeSolver::rhs_e({:e})", t);
+  const auto backend = nvector_backend();
 
   // Load state from udata
-  load_vars(udata);
+  backend.copy_state_from_vector(u);
+  backend.copy_deriv_from_vector(du);
 
   // Get the current timestep
   // Note: ARKodeGetCurrentStep updated too late in older versions
@@ -630,63 +636,69 @@ void ArkodeSolver::rhs_e(BoutReal t, BoutReal* udata, BoutReal* dudata) {
   run_convective(t);
 
   // Save derivatives to dudata
-  save_derivs(dudata);
+  backend.copy_state_to_vector(u);
+  backend.copy_deriv_to_vector(du);
 }
 
 /**************************************************************************
  *   Implicit RHS function du = F_I(t, u)
  **************************************************************************/
 
-void ArkodeSolver::rhs_i(BoutReal t, BoutReal* udata, BoutReal* dudata) {
+void ArkodeSolver::rhs_i(BoutReal t, N_Vector u, N_Vector du) {
   TRACE("Running RHS: ArkodeSolver::rhs_i({:e})", t);
+  const auto backend = nvector_backend();
 
-  load_vars(udata);
+  backend.copy_state_from_vector(u);
+  backend.copy_deriv_from_vector(du);
   ARKodeGetLastStep(arkode_mem, &hcur);
   // Call Implicit RHS function
   run_diffusive(t);
-  save_derivs(dudata);
+  backend.copy_state_to_vector(u);
+  backend.copy_deriv_to_vector(du);
 }
 
 /**************************************************************************
  *   Full  RHS function du = F(t, u)
  **************************************************************************/
-void ArkodeSolver::rhs(BoutReal t, BoutReal* udata, BoutReal* dudata) {
+void ArkodeSolver::rhs(BoutReal t, N_Vector u, N_Vector du) {
   TRACE("Running RHS: ArkodeSolver::rhs({:e})", t);
+  const auto backend = nvector_backend();
 
-  load_vars(udata);
+  backend.copy_state_from_vector(u);
+  backend.copy_deriv_from_vector(du);
   ARKodeGetLastStep(arkode_mem, &hcur);
   // Call Implicit RHS function
   run_rhs(t);
-  save_derivs(dudata);
+  backend.copy_state_to_vector(u);
+  backend.copy_deriv_to_vector(du);
 }
 
 /**************************************************************************
  * Preconditioner function
  **************************************************************************/
 
-void ArkodeSolver::pre(BoutReal t, BoutReal gamma, BoutReal delta, BoutReal* udata,
-                       BoutReal* rvec, BoutReal* zvec) {
+void ArkodeSolver::pre(BoutReal t, BoutReal gamma, BoutReal delta, N_Vector u,
+                       N_Vector rvec, N_Vector zvec) {
   TRACE("Running preconditioner: ArkodeSolver::pre({:e})", t);
+  const auto backend = nvector_backend();
 
   const BoutReal tstart = bout::globals::mpi->MPI_Wtime();
 
   if (!hasPreconditioner()) {
     // Identity (but should never happen)
-    const auto length = N_VGetLocalLength_Parallel(uvec);
-    std::copy(rvec, rvec + length, zvec);
+    N_VScale(1, rvec, zvec);
     return;
   }
 
   // Load state from udata (as with res function)
-  load_vars(udata);
-
-  // Load vector to be inverted into F_vars
-  load_derivs(rvec);
+  backend.copy_state_from_vector(u);
+  backend.copy_deriv_from_vector(rvec);
 
   runPreconditioner(t, gamma, delta);
 
   // Save the solution from F_vars
-  save_derivs(zvec);
+  backend.copy_state_to_vector(u);
+  backend.copy_deriv_to_vector(zvec);
 
   pre_Wtime += bout::globals::mpi->MPI_Wtime() - tstart;
   pre_ncalls++;
@@ -696,24 +708,24 @@ void ArkodeSolver::pre(BoutReal t, BoutReal gamma, BoutReal delta, BoutReal* uda
  * Jacobian-vector multiplication function
  **************************************************************************/
 
-void ArkodeSolver::jac(BoutReal t, BoutReal* ydata, BoutReal* vdata, BoutReal* Jvdata) {
+void ArkodeSolver::jac(BoutReal t, N_Vector y, N_Vector v, N_Vector Jv) {
   TRACE("Running Jacobian: ArkodeSolver::jac({:e})", t);
+  const auto backend = nvector_backend();
 
   if (not hasJacobian()) {
     throw BoutException("No jacobian function supplied!\n");
   }
 
   // Load state from ydate
-  load_vars(ydata);
-
-  // Load vector to be multiplied into F_vars
-  load_derivs(vdata);
+  backend.copy_state_from_vector(y);
+  backend.copy_deriv_from_vector(v);
 
   // Call function
   runJacobian(t);
 
   // Save Jv from vars
-  save_derivs(Jvdata);
+  backend.copy_state_to_vector(y);
+  backend.copy_deriv_to_vector(Jv);
 }
 
 /**************************************************************************
@@ -723,15 +735,11 @@ void ArkodeSolver::jac(BoutReal t, BoutReal* ydata, BoutReal* vdata, BoutReal* J
 // NOLINTBEGIN(readability-identifier-length)
 namespace {
 int arkode_rhs_explicit(BoutReal t, N_Vector u, N_Vector du, void* user_data) {
-
-  BoutReal* udata = N_VGetArrayPointer(u);
-  BoutReal* dudata = N_VGetArrayPointer(du);
-
   auto* s = static_cast<ArkodeSolver*>(user_data);
 
   // Calculate RHS function
   try {
-    s->rhs_e(t, udata, dudata);
+    s->rhs_e(t, u, du);
   } catch (BoutRhsFail& error) {
     return 1;
   }
@@ -739,15 +747,11 @@ int arkode_rhs_explicit(BoutReal t, N_Vector u, N_Vector du, void* user_data) {
 }
 
 int arkode_rhs_implicit(BoutReal t, N_Vector u, N_Vector du, void* user_data) {
-
-  BoutReal* udata = N_VGetArrayPointer(u);
-  BoutReal* dudata = N_VGetArrayPointer(du);
-
   auto* s = static_cast<ArkodeSolver*>(user_data);
 
   // Calculate RHS function
   try {
-    s->rhs_i(t, udata, dudata);
+    s->rhs_i(t, u, du);
   } catch (BoutRhsFail& error) {
     return 1;
   }
@@ -755,15 +759,11 @@ int arkode_rhs_implicit(BoutReal t, N_Vector u, N_Vector du, void* user_data) {
 }
 
 int arkode_rhs(BoutReal t, N_Vector u, N_Vector du, void* user_data) {
-
-  BoutReal* udata = N_VGetArrayPointer(u);
-  BoutReal* dudata = N_VGetArrayPointer(du);
-
   auto* s = static_cast<ArkodeSolver*>(user_data);
 
   // Calculate RHS function
   try {
-    s->rhs(t, udata, dudata);
+    s->rhs(t, u, du);
   } catch (BoutRhsFail& error) {
     return 1;
   }
@@ -779,14 +779,10 @@ int arkode_bbd_rhs(sunindextype UNUSED(Nlocal), BoutReal t, N_Vector u, N_Vector
 /// Preconditioner function
 int arkode_pre(BoutReal t, N_Vector yy, N_Vector UNUSED(yp), N_Vector rvec, N_Vector zvec,
                BoutReal gamma, BoutReal delta, int UNUSED(lr), void* user_data) {
-  BoutReal* udata = N_VGetArrayPointer(yy);
-  BoutReal* rdata = N_VGetArrayPointer(rvec);
-  BoutReal* zdata = N_VGetArrayPointer(zvec);
-
   auto* s = static_cast<ArkodeSolver*>(user_data);
 
   // Calculate residuals
-  s->pre(t, gamma, delta, udata, rdata, zdata);
+  s->pre(t, gamma, delta, yy, rvec, zvec);
 
   return 0;
 }
@@ -794,13 +790,9 @@ int arkode_pre(BoutReal t, N_Vector yy, N_Vector UNUSED(yp), N_Vector rvec, N_Ve
 /// Jacobian-vector multiplication function
 int arkode_jac(N_Vector v, N_Vector Jv, BoutReal t, N_Vector y, N_Vector UNUSED(fy),
                void* user_data, N_Vector UNUSED(tmp)) {
-  BoutReal* ydata = N_VGetArrayPointer(y);   ///< System state
-  BoutReal* vdata = N_VGetArrayPointer(v);   ///< Input vector
-  BoutReal* Jvdata = N_VGetArrayPointer(Jv); ///< Jacobian*vector output
-
   auto* s = static_cast<ArkodeSolver*>(user_data);
 
-  s->jac(t, ydata, vdata, Jvdata);
+  s->jac(t, y, v, Jv);
 
   return 0;
 }

{boutpp_nightly-5.2.1.dev1069 → boutpp_nightly-5.2.1.dev1106}/src/solver/impls/arkode/arkode.hxx

@@ -2,10 +2,8 @@
  * Interface to ARKODE solver
  * NOTE: ARKode is currently in beta testing so use with cautious optimism
  *
- * NOTE: Only one solver can currently be compiled in
- *
  **************************************************************************
- * Copyright 2010-2024 BOUT++ contributors
+ * Copyright 2010-2026 BOUT++ contributors
  *
  * Contact: Ben Dudson, dudson2@llnl.gov
  *
@@ -41,6 +39,7 @@ RegisterUnavailableSolver
 
 #else
 
+#include "../../sundials_nvector_interface.hxx"
 #include "bout/bout_enum_class.hxx"
 #include "bout/bout_types.hxx"
 #include "bout/region.hxx"
@@ -122,12 +121,12 @@ public:
   BoutReal run(BoutReal tout);
 
   // These functions used internally (but need to be public)
-  void rhs_e(BoutReal t, BoutReal* udata, BoutReal* dudata);
-  void rhs_i(BoutReal t, BoutReal* udata, BoutReal* dudata);
-  void rhs(BoutReal t, BoutReal* udata, BoutReal* dudata);
-  void pre(BoutReal t, BoutReal gamma, BoutReal delta, BoutReal* udata, BoutReal* rvec,
-           BoutReal* zvec);
-  void jac(BoutReal t, BoutReal* ydata, BoutReal* vdata, BoutReal* Jvdata);
+  void rhs_e(BoutReal t, N_Vector u, N_Vector du);
+  void rhs_i(BoutReal t, N_Vector u, N_Vector du);
+  void rhs(BoutReal t, N_Vector u, N_Vector du);
+  void pre(BoutReal t, BoutReal gamma, BoutReal delta, N_Vector u, N_Vector rvec,
+           N_Vector zvec);
+  void jac(BoutReal t, N_Vector y, N_Vector v, N_Vector Jv);
 
 private:
   BoutReal hcur; //< Current internal timestep
@@ -181,6 +180,8 @@ private:
   bool rightprec;
   /// Use user-supplied Jacobian function
   bool use_jacobian;
+  /// N_Vector backend to use
+  NVectorType nvector_type;
 #if ARKODE_OPTIMAL_PARAMS_SUPPORT
   /// Use ARKode optimal parameters
   bool optimize;
@@ -200,6 +201,10 @@ private:
                              std::vector<BoutReal>& f2dtols,
                              std::vector<BoutReal>& f3dtols, bool bndry);
 
+  SundialsNVectorInterface nvector_backend() {
+    return SundialsNVectorInterface(*this, suncontext, nvector_type);
+  }
+
   /// SPGMR solver structure
   SUNLinearSolver sun_solver{nullptr};
   /// Solver for implicit stages