docs(version): v0.7.6rc3 -> v0.7.6rc3.1

this version uses the target workaround which we use for the SUNDIALS suite to get meson to recognize it as position indepenednt code to CppAD

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = GridFire
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = v0.7.4_rc2
+PROJECT_NUMBER         = v0.7.5rc3
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewers a

build-check/FC/meson.build

@@ -1,5 +1,10 @@
 if get_option('build_fortran')
-  add_languages('fortran', native: true)
+  found_fortran = add_languages('fortran')
+    if not found_fortran
+      error('Fortran compiler not found, but build_fortran option is enabled.')
+    else
+        message('Fortran compiler found.')
+    endif
   message('Found FORTRAN compiler: ' + meson.get_compiler('fortran').get_id())
   message('Fortran standard set to: ' + get_option('fortran_std'))
   message('Building fortran module (gridfire_mod.mod)')

build-config/cppad/meson.build

@@ -1,26 +1,36 @@
-#cppad_inc = include_directories('include', is_system: true)
-#cppad_dep = declare_dependency(
-#  include_directories: cppad_inc,
-#)
-#
-#message('Registering CppAD headers for installation...')
-#install_subdir('include/cppad', install_dir: get_option('includedir'))
-#message('Done registering CppAD headers for installation!')
-#
-
-
 cppad_cmake_options = cmake.subproject_options()
 
 cppad_cmake_options.add_cmake_defines({
     'cppad_static_lib': 'true',
     'cpp_mas_num_threads': '10',
     'cppad_debug_and_release': 'false',
-    'include_doc': 'false'
+    'include_doc': 'false',
+    'CMAKE_POSITION_INDEPENDENT_CODE': true
 })
 
+cppad_cmake_options.set_install(false)
+
 cppad_sp = cmake.subproject(
     'cppad',
     options: cppad_cmake_options,
 )
 
-cppad_dep = cppad_sp.dependency('cppad_lib').as_system()
+cppad_target = cppad_sp.target('cppad_lib')
+cppad_objs = [cppad_target.extract_all_objects(recursive: true)]
+cppad_incs = cppad_sp.include_directories('cppad_lib')
+
+empty_cppad_file = configure_file(output: 'cppad_dummy_ar.cpp', command: ['echo'], capture: true)
+
+libcppad_static = static_library(
+  'cppad-static',
+  empty_cppad_file,
+  objects: cppad_objs,
+  include_directories: cppad_incs,
+  pic: true,
+  install: false
+)
+
+cppad_dep = declare_dependency(
+  link_with: libcppad_static,
+  include_directories: cppad_incs
+)

build-config/python/meson.build

@@ -7,10 +7,10 @@ if meson.is_cross_build() and host_machine.system() == 'darwin'
   py_inc_dir = include_directories('../../cross/python_includes/python-' + py_ver + '/include/python' + py_ver)
   py_dep = declare_dependency(include_directories: py_inc_dir)
   py_module_prefix = ''
-  py_module_suffic = 'so'
+  py_module_suffix = 'so'
   meson.override_dependency('python3', py_dep)
 else
   py_dep = py_installation.dependency()
   py_module_prefix = ''
-  py_module_suffic = 'so'
+  py_module_suffix = 'so'
 endif

build-config/sundials/cvode/meson.build

@@ -7,7 +7,8 @@ cvode_cmake_options.add_cmake_defines({
     'BUILD_SHARED_LIBS' : 'OFF',
     'BUILD_STATIC_LIBS' : 'ON',
     'EXAMPLES_ENABLE_C' : 'OFF',
-    'CMAKE_POSITION_INDEPENDENT_CODE': true
+    'CMAKE_POSITION_INDEPENDENT_CODE': true,
+    'CMAKE_PLATFORM_NO_VERSIONED_SONAME': 'ON'
 
 })
 
@@ -16,6 +17,8 @@ cvode_cmake_options.add_cmake_defines({
     'CMAKE_INSTALL_INCLUDEDIR': get_option('includedir')
 })
 
+cvode_cmake_options.set_install(false)
+
 if meson.is_cross_build() and host_machine.system() == 'emscripten'
   cvode_cmake_options.add_cmake_defines({
       'CMAKE_C_FLAGS': '-s MEMORY64=1 -s ALLOW_MEMORY_GROWTH=1',

build-config/sundials/kinsol/meson.build

@@ -8,7 +8,8 @@ kinsol_cmake_options.add_cmake_defines({
     'BUILD_SHARED_LIBS' : 'OFF',
     'BUILD_STATIC_LIBS' : 'ON',
     'EXAMPLES_ENABLE_C' : 'OFF',
-    'CMAKE_POSITION_INDEPENDENT_CODE': true
+    'CMAKE_POSITION_INDEPENDENT_CODE': true,
+    'CMAKE_PLATFORM_NO_VERSIONED_SONAME': 'ON'
 })
 
 kinsol_cmake_options.add_cmake_defines({
@@ -16,6 +17,8 @@ kinsol_cmake_options.add_cmake_defines({
     'CMAKE_INSTALL_INCLUDEDIR': get_option('includedir')
 })
 
+kinsol_cmake_options.set_install(false)
+
 kinsol_sp = cmake.subproject(
     'kinsol',
     options: kinsol_cmake_options,

build-python/meson.build

@@ -28,6 +28,8 @@ if get_option('build_python')
           meson.project_source_root() + '/src/python/policy/bindings.cpp',
           meson.project_source_root() + '/src/python/policy/trampoline/py_policy.cpp',
           meson.project_source_root() + '/src/python/utils/bindings.cpp',
+          meson.project_source_root() + '/src/python/config/bindings.cpp',
+          meson.project_source_root() + '/src/python/engine/scratchpads/bindings.cpp',
       ]
 
 
@@ -56,6 +58,7 @@ if get_option('build_python')
       files(
           meson.project_source_root() + '/src/python/gridfire/__init__.py',
           meson.project_source_root() + '/stubs/gridfire/_gridfire/__init__.pyi',
+          meson.project_source_root() + '/stubs/gridfire/_gridfire/config.pyi',
           meson.project_source_root() + '/stubs/gridfire/_gridfire/exceptions.pyi',
           meson.project_source_root() + '/stubs/gridfire/_gridfire/partition.pyi',
           meson.project_source_root() + '/stubs/gridfire/_gridfire/reaction.pyi',
@@ -72,6 +75,7 @@ if get_option('build_python')
       files(
           meson.project_source_root() + '/stubs/gridfire/_gridfire/engine/__init__.pyi',
           meson.project_source_root() + '/stubs/gridfire/_gridfire/engine/diagnostics.pyi',
+          meson.project_source_root() + '/stubs/gridfire/_gridfire/engine/scratchpads.pyi'
       ),
       subdir: 'gridfire/engine',
   )

meson.build

@@ -18,7 +18,7 @@
 #   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 #
 # *********************************************************************** #
-project('GridFire', ['c', 'cpp'], version: 'v0.7.4_rc2', default_options: ['cpp_std=c++23'], meson_version: '>=1.5.0')
+project('GridFire', ['c', 'cpp'], version: 'v0.7.6rc3.1', default_options: ['cpp_std=c++23'], meson_version: '>=1.5.0')
 
 # Start by running the code which validates the build environment
 subdir('build-check')

pip_install_mac_patch.sh

@@ -56,7 +56,7 @@ echo "Site packages: $SITE_PACKAGES"
 echo ""
 
 echo -e "${GREEN}Step 2: Installing fourdst with pip...${NC}"
-$PYTHON_BIN -m pip install . -v
+$PYTHON_BIN -m pip install . -v --no-build-isolation
 
 if [ $? -ne 0 ]; then
     echo -e "${RED}Error: pip install failed${NC}"

pyproject.toml

@@ -1,14 +1,14 @@
 [build-system]
 requires = [
     "meson-python>=0.15.0", # Use a recent version
-    "meson>=1.6.0",        # Specify your Meson version requirement
+    "meson==1.9.1",        # Specify your Meson version requirement
     "pybind11>=2.10"       # pybind11 headers needed at build time
 ]
 build-backend = "mesonpy"
 
 [project]
 name = "gridfire"  # Choose your Python package name
-version = "0.7.4_rc2" # Your project's version
+version = "v0.7.5rc3" # Your project's version
 description = "Python interface to the GridFire nuclear network code"
 readme = "README.md"
 license = { file = "LICENSE.txt" } # Reference your license file [cite: 2]
@@ -22,4 +22,4 @@ maintainers = [
 ]
 
 [tool.meson-python.args]
-setup = ['-Dpkg-config=false']
+setup = ['-Dpkg_config=false', '-Dbuildtype=release', '-Dopenmp_support=true', '-Dasan=false', '-Dlog_level=error', '-Dbuild_tests=false', '-Dbuild_c_api=false', '-Dbuild_examples=false', '-Dbuild_benchmarks=false', '-Dbuild_tools=false', '-Dplugin_support=false', '-Duse_mimalloc=false', '-Dbuild_python=true']

src/extern/fortran/gridfire_mod.f90

@@ -2,6 +2,14 @@ module gridfire_mod
     use iso_c_binding
     implicit none
 
+    type, public :: GF_TYPE
+        integer(c_int) :: value
+    end type GF_TYPE
+
+    type(GF_TYPE), parameter, public :: &
+            SINGLE_ZONE   = GF_TYPE(1001), &
+            MULTI_ZONE    = GF_TYPE(1002)
+
     enum, bind (C)
         enumerator :: FDSSE_NON_4DSTAR_ERROR = -102
         enumerator :: FDSSE_UNKNOWN_ERROR = -101
@@ -50,24 +58,46 @@ module gridfire_mod
         enumerator :: GF_DEBUG_ERRROR = 30
 
         enumerator :: GF_GRIDFIRE_ERROR = 31
+        enumerator :: GF_UNINITIALIZED_INPUT_MEMORY_ERROR = 32
+        enumerator :: GF_UNINITIALIZED_OUTPUT_MEMORY_ERROR = 33
+
+        enumerator :: GF_INVALD_NUM_SPECIES = 34
+        enumerator :: GF_INVALID_TIMESTEPS = 35
+        enumerator :: GF_UNKNONWN_FREE_TYPE = 36
+
+        enumerator :: GF_INVALID_TYPE = 37
+
+        enumerator :: GF_SINGLE_ZONE = 1001
+        enumerator :: GF_MULTI_ZONE = 1002
     end enum
 
     interface
         ! void* gf_init()
-        function gf_init() bind(C, name="gf_init")
-            import :: c_ptr
+        function gf_init(ctx_type) bind(C, name="gf_init")
+            import :: c_ptr, c_int
             type(c_ptr) :: gf_init
+            integer(c_int), value :: ctx_type
         end function gf_init
 
-        ! void gf_free(void* gf)
-        subroutine gf_free(gf) bind(C, name="gf_free")
-            import :: c_ptr
-            type(c_ptr), value :: gf
-        end subroutine gf_free
+        ! int gf_free(void* gf)
+        function gf_free(ctx_type, ptr) result(c_res) bind(C, name="gf_free")
+            import :: c_ptr, c_int
+            type(c_ptr), value :: ptr
+            integer(c_int), value :: ctx_type
+            integer(c_int) :: c_res
+        end function gf_free
+
+        function gf_set_num_zones(ctx_type, ptr, num_zones) result(c_res) bind(C, name="gf_set_num_zones")
+            import :: c_ptr, c_int, c_size_t
+            type(c_ptr), value :: ptr
+            integer(c_int), value :: ctx_type
+            integer(c_size_t), value :: num_zones
+            integer(c_int) :: c_res
+        end function gf_set_num_zones
 
         ! char* gf_get_last_error_message(void* ptr);
         function gf_get_last_error_message(ptr) result(c_msg) bind(C, name="gf_get_last_error_message")
-            import
+            import :: c_ptr, c_int
             type(c_ptr), value :: ptr
             type(c_ptr) :: c_msg
         end function
@@ -102,49 +132,116 @@ module gridfire_mod
         end function
 
         ! int gf_evolve(...)
-        function gf_evolve(ptr, Y_in, num_species, T, rho, dt, Y_out, energy_out, dEps_dT, dEps_dRho, specific_neutrino_loss, specific_neutrino_flux, mass_lost) result(ierr) &
+        function gf_evolve_c_scalar(ctx_type, ptr, Y_in, num_species, T, rho, tMax, dt0, &
+                Y_out, energy, dedt, dedrho, &
+                nue_loss, nu_flux, mass_lost) result(ierr) &
                 bind(C, name="gf_evolve")
-            import
+            import :: c_ptr, c_int, c_double, c_size_t
             type(c_ptr), value :: ptr
-            real(c_double), dimension(*), intent(in) :: Y_in
+            integer(c_int), value :: ctx_type
             integer(c_size_t), value :: num_species
-            real(c_double), value :: T, rho, dt
+
+            ! Arrays
+            real(c_double), dimension(*), intent(in) :: Y_in
             real(c_double), dimension(*), intent(out) :: Y_out
-            real(c_double), intent(out) :: energy_out, dEps_dT, dEps_dRho, specific_neutrino_loss, specific_neutrino_flux, mass_lost
+
+            ! Scalars (Passed by Reference -> matches void*)
+            real(c_double), intent(in) :: T, rho
+            real(c_double), intent(out) :: energy, dedt, dedrho, nue_loss, nu_flux, mass_lost
+
+            ! Scalars (Passed by Value)
+            real(c_double), value :: tMax, dt0
+
+            integer(c_int) :: ierr
+        end function
+
+        ! 2. Interface for Multi Zone (Arrays)
+        function gf_evolve_c_array(ctx_type, ptr, Y_in, num_species, T, rho, tMax, dt0, &
+                Y_out, energy, dedt, dedrho, &
+                nue_loss, nu_flux, mass_lost) result(ierr) &
+                bind(C, name="gf_evolve")
+            import :: c_ptr, c_int, c_double, c_size_t
+            type(c_ptr), value :: ptr
+            integer(c_int), value :: ctx_type
+            integer(c_size_t), value :: num_species
+
+            ! All Arrays (dimension(*))
+            real(c_double), dimension(*), intent(in) :: Y_in
+            real(c_double), dimension(*), intent(in) :: T, rho
+
+            real(c_double), dimension(*), intent(out) :: Y_out
+            real(c_double), dimension(*), intent(out) :: energy, dedt, dedrho, nue_loss, nu_flux, mass_lost
+
+            ! Scalars (Passed by Value)
+            real(c_double), value :: tMax, dt0
+
             integer(c_int) :: ierr
         end function
     end interface
 
     type :: GridFire
         type(c_ptr) :: ctx = c_null_ptr
+        integer(c_int) :: ctx_type = SINGLE_ZONE%value
         integer(c_size_t) :: num_species = 0
+        integer(c_size_t) :: num_zones = 1
     contains
         procedure :: gff_init
         procedure :: gff_free
-        procedure :: register_species
-        procedure :: setup_policy
-        procedure :: setup_solver
-        procedure :: evolve
-        procedure :: get_last_error
+        procedure :: gff_register_species
+        procedure :: gff_setup_policy
+        procedure :: gff_setup_solver
+        procedure :: gff_get_last_error
+
+        procedure :: gff_evolve_single
+        procedure :: gff_evolve_multi
+
+        generic :: gff_evolve => gff_evolve_single, gff_evolve_multi
     end type GridFire
 
     contains
-        subroutine gff_init(self)
+        subroutine gff_init(self, type, zones)
             class(GridFire), intent(out) :: self
+            type(GF_TYPE), intent(in)    :: type
+            integer(c_size_t), intent(in), optional :: zones
+            integer(c_int) :: ierr
 
-            self%ctx = gf_init()
+            if (type%value==1002) then
+                if (.not. present(zones)) then
+                    print *, "GridFire Error: Multi-zone type requires number of zones to be specficied in the GridFire init method (i.e. GridFire(MULTI_ZONE, 10) for 10 zones)."
+                    error stop
+                end if
+
+                self%num_zones = zones
+            end if
+
+            self%ctx_type = type%value
+
+            self%ctx = gf_init(self%ctx_type)
+
+            if (type%value==1002) then
+                ierr = gf_set_num_zones(self%ctx_type, self%ctx, self%num_zones)
+                if (ierr /= GF_SUCCESS .AND. ierr /= FDSSE_SUCCESS) then
+                    print *, "GridFire Multi-Zone Error: ", self%gff_get_last_error()
+                    error stop
+                end if
+            end if
         end subroutine gff_init
 
         subroutine gff_free(self)
             class(GridFire), intent(inout) :: self
+            integer(c_int) :: ierr
 
             if (c_associated(self%ctx)) then
-                call gf_free(self%ctx)
+                ierr = gf_free(self%ctx_type, self%ctx)
+                if (ierr /= GF_SUCCESS .AND. ierr /= FDSSE_SUCCESS) then
+                    print *, "GridFire Free Error: ", self%gff_get_last_error()
+                    error stop
+                end if
                 self%ctx = c_null_ptr
             end if
         end subroutine gff_free
 
-        function get_last_error(self) result(msg)
+        function gff_get_last_error(self) result(msg)
             class(GridFire), intent(in) :: self
             character(len=:), allocatable :: msg
             type(c_ptr) :: c_msg_ptr
@@ -169,9 +266,9 @@ module gridfire_mod
             do i = 1, len_str
                 msg(i+10:i+10) = char_ptr(i)
             end do
-        end function get_last_error
+        end function gff_get_last_error
 
-        subroutine register_species(self, species_list)
+        subroutine gff_register_species(self, species_list)
             class(GridFire), intent(inout) :: self
             character(len=*), dimension(:), intent(in) :: species_list
 
@@ -179,7 +276,6 @@ module gridfire_mod
             character(kind=c_char, len=:), allocatable, target :: temp_strs(:)
             integer :: i, n, ierr
 
-            print *, "Registering ", size(species_list), " species."
             n = size(species_list)
             self%num_species = int(n, c_size_t)
 
@@ -191,17 +287,14 @@ module gridfire_mod
                 c_ptrs(i) = c_loc(temp_strs(i))
             end do
 
-            print *, "Calling gf_register_species..."
             ierr = gf_register_species(self%ctx, int(n, c_int), c_ptrs)
-            print *, "gf_register_species returned with code: ", ierr
-
             if (ierr /= GF_SUCCESS .AND. ierr /= FDSSE_SUCCESS) then
-                print *, "GridFire: ", self%get_last_error()
+                print *, "GridFire: ", self%gff_get_last_error()
                 error stop
             end if
-        end subroutine register_species
+        end subroutine gff_register_species
 
-        subroutine setup_policy(self, policy_name, abundances)
+        subroutine gff_setup_policy(self, policy_name, abundances)
             class(GridFire), intent(in) :: self
             character(len=*), intent(in) :: policy_name
             real(c_double), dimension(:), intent(in) :: abundances
@@ -218,41 +311,59 @@ module gridfire_mod
                     self%num_species)
 
             if (ierr /= GF_SUCCESS .AND. ierr /= FDSSE_SUCCESS) then
-                print *, "GridFire Policy Error: ", self%get_last_error()
+                print *, "GridFire Policy Error: ", self%gff_get_last_error()
                 error stop
             end if
-        end subroutine setup_policy
+        end subroutine gff_setup_policy
 
-        subroutine setup_solver(self, solver_name)
+        subroutine gff_setup_solver(self, solver_name)
             class(GridFire), intent(in) :: self
             character(len=*), intent(in) :: solver_name
             integer(c_int) :: ierr
 
             ierr = gf_construct_solver_from_engine(self%ctx, trim(solver_name) // c_null_char)
             if (ierr /= GF_SUCCESS .AND. ierr /= FDSSE_SUCCESS) then
-                print *, "GridFire Solver Error: ", self%get_last_error()
+                print *, "GridFire Solver Error: ", self%gff_get_last_error()
                 error stop
             end if
-        end subroutine setup_solver
+        end subroutine gff_setup_solver
 
-        subroutine evolve(self, Y_in, T, rho, dt, Y_out, energy, dedt, dedrho, nu_e_loss, nu_flux, mass_lost, ierr)
+        subroutine gff_evolve_single(self, Y_in, T, rho, tMax, dt0, Y_out, energy, dedt, dedrho, nu_e_loss, nu_flux, mass_lost, ierr)
             class(GridFire), intent(in) :: self
             real(c_double), dimension(:), intent(in) :: Y_in
-            real(c_double), value :: T, rho, dt
+            real(c_double), intent(in) :: T, rho
+            real(c_double), value :: tMax, dt0
+
             real(c_double), dimension(:), intent(out) :: Y_out
             real(c_double), intent(out) :: energy, dedt, dedrho, nu_e_loss, nu_flux, mass_lost
             integer, intent(out) :: ierr
             integer(c_int) :: c_ierr
 
-            c_ierr = gf_evolve(self%ctx, &
+            c_ierr = gf_evolve_c_scalar(self%ctx_type, self%ctx, &
                     Y_in, self%num_species, &
-                    T, rho, dt, &
+                    T, rho, tMax, dt0, &
                     Y_out, &
                     energy, dedt, dedrho, nu_e_loss, nu_flux, mass_lost)
-
             ierr = int(c_ierr)
-            if (ierr /= GF_SUCCESS .AND. ierr /= FDSSE_SUCCESS) then
-                print *, "GridFire Evolve Error: ", self%get_last_error()
-            end if
-        end subroutine evolve
+        end subroutine gff_evolve_single
+
+        subroutine gff_evolve_multi(self, Y_in, T, rho, tMax, dt0, Y_out, energy, dedt, dedrho, nu_e_loss, nu_flux, mass_lost, ierr)
+            class(GridFire), intent(in) :: self
+            real(c_double), dimension(:,:), intent(in) :: Y_in
+            real(c_double), dimension(:), intent(in) :: T, rho
+            real(c_double), value :: tMax, dt0
+
+            real(c_double), dimension(:,:), intent(out) :: Y_out
+            real(c_double), dimension(:), intent(out) :: energy, dedt, dedrho, nu_e_loss, nu_flux, mass_lost
+            integer, intent(out) :: ierr
+            integer(c_int) :: c_ierr
+
+            c_ierr = gf_evolve_c_array(self%ctx_type, self%ctx, &
+                    Y_in, self%num_species, &
+                    T, rho, tMax, dt0, &
+                    Y_out, &
+                    energy, dedt, dedrho, nu_e_loss, nu_flux, mass_lost)
+            ierr = int(c_ierr)
+        end subroutine gff_evolve_multi
+
 end module gridfire_mod

src/extern/include/gridfire/extern/gridfire_extern.h

@@ -7,8 +7,8 @@
 extern "C" {
 #endif
     enum GF_TYPE {
-        SINGLE_ZONE = 0,
-        MULTI_ZONE = 1
+        SINGLE_ZONE = 1001,
+        MULTI_ZONE = 1002
     };
 
 

src/extern/lib/gridfire_extern.cpp

@@ -222,6 +222,21 @@ extern "C" {
         void* mass_lost
     ) {
 
+        printf("In C Starting gf_evolve with type %d\n", type);
+        printf("In C num_species: %zu, tMax: %e, dt0: %e\n", num_species, tMax, dt0);
+        printf("In C Y_in ptr: %p, T ptr: %p, rho ptr: %p\n", Y_in, T, rho);
+        // values
+        printf("In C Y_in first 5 values: ");
+        const auto* Y_in_ptr = static_cast<const double*>(Y_in);
+        for (size_t i = 0; i < std::min(num_species, size_t(5)); ++i) {
+            printf("%e ", Y_in_ptr[i]);
+        }
+        printf("\n");
+        printf("In C T value: %e\n", *(static_cast<const double*>(T)));
+        printf("In C rho value: %e\n", *(static_cast<const double*>(rho)));
+        printf("In C tMax value: %e\n", tMax);
+        printf("In C dt0 value: %e\n", dt0);
+
         if (!ptr || !Y_in || !T || !rho) {
             return GF_UNINITIALIZED_INPUT_MEMORY_ERROR;
         }
@@ -252,6 +267,8 @@ extern "C" {
                 auto* specific_neutrino_flux_local = static_cast<double*>(specific_neutrino_flux);
                 auto* mass_lost_local = static_cast<double*>(mass_lost);
 
+                printf("Evolving single zone with T = %e, rho = %e for tMax = %e and dt0 = %e\n", *T_ptr, *rho_ptr, tMax, dt0);
+
                 return execute_guarded(ctx, [&]() {
                     return ctx->evolve(
                         static_cast<const double*>(Y_in),
@@ -283,12 +300,7 @@ extern "C" {
                 auto* specific_neutrino_flux_local = static_cast<double*>(specific_neutrino_flux);
                 auto* mass_lost_local = static_cast<double*>(mass_lost);
 
-                // for (size_t i = 0; i < ctx->get_zones(); ++i) {
-                //     if (!Y_out_local[i]) {
-                //         std::cerr << "Uninitialized memory for Y_out at zone " << i << std::endl;
-                //         return GF_UNINITIALIZED_OUTPUT_MEMORY_ERROR;
-                //     }
-                // }
+                printf("Evolving multi zone for tMax = %e and dt0 = %e\n", tMax, dt0);
 
                 return execute_guarded(ctx, [&]() {
                     return ctx->evolve(

src/include/gridfire/config/config.h

@@ -8,34 +8,8 @@ namespace gridfire::config {
         double relTol = 1.0e-5;
     };
 
-
-    struct SpectralSolverConfig {
-        struct Trigger {
-            double timestepCollapseRatio = 0.5;
-            size_t maxConvergenceFailures = 2;
-            double relativeFailureRate = 0.5;
-            size_t windowSize = 10;
-        };
-        struct MonitorFunctionConfig {
-            double structure_weight = 1.0;
-            double abundance_weight = 10.0;
-            double alpha = 0.2;
-            double beta = 0.8;
-        };
-        struct BasisConfig {
-            size_t num_elements = 50;
-        };
-        double absTol = 1.0e-8;
-        double relTol = 1.0e-5;
-        size_t degree = 3;
-        MonitorFunctionConfig monitorFunction;
-        BasisConfig basis;
-        Trigger trigger;
-    };
-
     struct SolverConfig {
         CVODESolverConfig cvode;
-        SpectralSolverConfig spectral;
     };
 
     struct AdaptiveEngineViewConfig {
@@ -57,5 +31,4 @@ namespace gridfire::config {
     };
 
 
-
 }

src/include/gridfire/engine/views/engine_defined.h

@@ -359,7 +359,6 @@ namespace gridfire::engine {
 
 
     private:
-        using LogManager = LogManager;
         Config<config::GridFireConfig> m_config;
 
         quill::Logger* m_logger = LogManager::getInstance().getLogger("log");
@@ -367,4 +366,4 @@ namespace gridfire::engine {
         ///< Parser for the network file.
         const io::NetworkFileParser& m_parser;
     };
-}
+}

src/include/gridfire/policy/policy_abstract.h

@@ -25,6 +25,7 @@
 #include <set>
 
 #include "gridfire/engine/types/engine_types.h"
+#include "gridfire/engine/scratchpads/blob.h"
 
 
 namespace gridfire::policy {

src/include/gridfire/solver/strategies/GridSolver.h

@@ -20,6 +20,9 @@ namespace gridfire::solver {
         void set_callback(const std::function<void(const TimestepContextBase&)> &callback);
         void set_callback(const std::function<void(const TimestepContextBase&)> &callback, size_t zone_idx);
 
+        void clear_callback();
+        void clear_callback(size_t zone_idx);
+
         void set_stdout_logging(bool enable) override;
         void set_detailed_logging(bool enable) override;
 

src/lib/solver/strategies/GridSolver.cpp

@@ -28,6 +28,19 @@ namespace gridfire::solver {
         timestep_callbacks[zone_idx] = callback;
     }
 
+    void GridSolverContext::clear_callback() {
+        for (auto &cb : timestep_callbacks) {
+            cb = nullptr;
+        }
+    }
+
+    void GridSolverContext::clear_callback(const size_t zone_idx) {
+        if (zone_idx >= timestep_callbacks.size()) {
+            throw exceptions::SolverError("GridSolverContext::clear_callback: zone_idx out of range.");
+        }
+        timestep_callbacks[zone_idx] = nullptr;
+    }
+
     void GridSolverContext::set_stdout_logging(const bool enable) {
         zone_stdout_logging = enable;
     }

src/meson.build

@@ -58,12 +58,21 @@ if get_option('openmp_support')
 endif
 
 # Define the libnetwork library so it can be linked against by other parts of the build system
-libgridfire = library('gridfire',
-    gridfire_sources,
-    include_directories: include_directories('include'),
-    dependencies: gridfire_build_dependencies,
-    objects: [cvode_objs, kinsol_objs],
-    install : true)
+if get_option('build_python')
+    libgridfire = static_library('gridfire',
+        gridfire_sources,
+        include_directories: include_directories('include'),
+        dependencies: gridfire_build_dependencies,
+        objects: [cvode_objs, kinsol_objs],
+        install : false)
+else
+    libgridfire = library('gridfire',
+                          gridfire_sources,
+                          include_directories: include_directories('include'),
+                          dependencies: gridfire_build_dependencies,
+                          objects: [cvode_objs, kinsol_objs],
+                          install : true)
+endif
 
 gridfire_dep = declare_dependency(
     include_directories: include_directories('include'),

src/python/bindings.cpp

@@ -4,6 +4,7 @@
 #include "types/bindings.h"
 #include "partition/bindings.h"
 #include "engine/bindings.h"
+#include "engine/scratchpads/bindings.h"
 #include "exceptions/bindings.h"
 #include "io/bindings.h"
 #include "reaction/bindings.h"
@@ -11,6 +12,7 @@
 #include "solver/bindings.h"
 #include "utils/bindings.h"
 #include "policy/bindings.h"
+#include "config/bindings.h"
 
 PYBIND11_MODULE(_gridfire, m) {
     m.doc() = "Python bindings for the fourdst utility modules which are a part of the 4D-STAR project.";
@@ -20,6 +22,9 @@ PYBIND11_MODULE(_gridfire, m) {
     pybind11::module::import("fourdst.config");
     pybind11::module::import("fourdst.atomic");
 
+    auto configMod  = m.def_submodule("config", "GridFire configuration bindings");
+    register_config_bindings(configMod);
+
     auto typeMod  = m.def_submodule("type", "GridFire type bindings");
     register_type_bindings(typeMod);
 
@@ -39,6 +44,12 @@ PYBIND11_MODULE(_gridfire, m) {
     register_exception_bindings(exceptionMod);
 
     auto engineMod  = m.def_submodule("engine", "Engine and Engine View bindings");
+    auto scratchpadMod = engineMod.def_submodule("scratchpads", "Engine ScratchPad bindings");
+
+    register_scratchpad_types_bindings(scratchpadMod);
+    register_scratchpad_bindings(scratchpadMod);
+    register_state_blob_bindings(scratchpadMod);
+
     register_engine_bindings(engineMod);
 
     auto solverMod  = m.def_submodule("solver", "GridFire numerical solver bindings");

src/python/config/bindings.cpp

@@ -0,0 +1,34 @@
+#include "bindings.h"
+
+#include "gridfire/config/config.h"
+#include <pybind11/pybind11.h>
+
+namespace py = pybind11;
+
+void register_config_bindings(pybind11::module &m) {
+    py::class_<gridfire::config::CVODESolverConfig>(m, "CVODESolverConfig")
+        .def(py::init<>())
+        .def_readwrite("absTol", &gridfire::config::CVODESolverConfig::absTol)
+        .def_readwrite("relTol", &gridfire::config::CVODESolverConfig::relTol);
+
+    py::class_<gridfire::config::SolverConfig>(m, "SolverConfig")
+        .def(py::init<>())
+        .def_readwrite("cvode", &gridfire::config::SolverConfig::cvode);
+
+    py::class_<gridfire::config::AdaptiveEngineViewConfig>(m, "AdaptiveEngineViewConfig")
+        .def(py::init<>())
+        .def_readwrite("relativeCullingThreshold", &gridfire::config::AdaptiveEngineViewConfig::relativeCullingThreshold);
+
+    py::class_<gridfire::config::EngineViewConfig>(m, "EngineViewConfig")
+        .def(py::init<>())
+        .def_readwrite("adaptiveEngineView", &gridfire::config::EngineViewConfig::adaptiveEngineView);
+
+    py::class_<gridfire::config::EngineConfig>(m, "EngineConfig")
+        .def(py::init<>())
+        .def_readwrite("views", &gridfire::config::EngineConfig::views);
+
+    py::class_<gridfire::config::GridFireConfig>(m, "GridFireConfig")
+        .def(py::init<>())
+        .def_readwrite("solver", &gridfire::config::GridFireConfig::solver)
+        .def_readwrite("engine", &gridfire::config::GridFireConfig::engine);
+}

src/python/config/bindings.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+void register_config_bindings(pybind11::module &m);

src/python/engine/bindings.cpp

@@ -12,6 +12,7 @@
 
 
 namespace py = pybind11;
+namespace sp = gridfire::engine::scratch;
 
 namespace {
     template <typename T>
@@ -23,16 +24,18 @@ namespace {
             "calculateRHSAndEnergy",
             [](
                 const gridfire::engine::DynamicEngine& self,
+                sp::StateBlob& ctx,
                 const fourdst::composition::Composition& comp,
                 const double T9,
                 const double rho
             ) {
-                auto result = self.calculateRHSAndEnergy(comp, T9, rho);
+                auto result = self.calculateRHSAndEnergy(ctx, comp, T9, rho, false);
                 if (!result.has_value()) {
                     throw gridfire::exceptions::EngineError(std::format("calculateRHSAndEnergy returned a potentially recoverable error {}", gridfire::engine::EngineStatus_to_string(result.error())));
                 }
                 return result.value();
             },
+            py::arg("ctx"),
             py::arg("comp"),
             py::arg("T9"),
             py::arg("rho"),
@@ -40,6 +43,7 @@ namespace {
         )
         .def("calculateEpsDerivatives",
             &gridfire::engine::DynamicEngine::calculateEpsDerivatives,
+            py::arg("ctx"),
             py::arg("comp"),
             py::arg("T9"),
             py::arg("rho"),
@@ -47,11 +51,13 @@ namespace {
         )
         .def("generateJacobianMatrix",
             [](const gridfire::engine::DynamicEngine& self,
+               sp::StateBlob& ctx,
                const fourdst::composition::Composition& comp,
                const double T9,
                const double rho) -> gridfire::engine::NetworkJacobian {
-                return self.generateJacobianMatrix(comp, T9, rho);
+                return self.generateJacobianMatrix(ctx, comp, T9, rho);
             },
+            py::arg("ctx"),
             py::arg("comp"),
             py::arg("T9"),
             py::arg("rho"),
@@ -59,12 +65,14 @@ namespace {
         )
         .def("generateJacobianMatrix",
             [](const gridfire::engine::DynamicEngine& self,
+               sp::StateBlob& ctx,
                const fourdst::composition::Composition& comp,
                const double T9,
                const double rho,
                const std::vector<fourdst::atomic::Species>& activeSpecies) -> gridfire::engine::NetworkJacobian {
-                return self.generateJacobianMatrix(comp, T9, rho, activeSpecies);
+                return self.generateJacobianMatrix(ctx, comp, T9, rho, activeSpecies);
             },
+            py::arg("ctx"),
             py::arg("comp"),
             py::arg("T9"),
             py::arg("rho"),
@@ -73,31 +81,32 @@ namespace {
         )
         .def("generateJacobianMatrix",
             [](const gridfire::engine::DynamicEngine& self,
+               sp::StateBlob& ctx,
                const fourdst::composition::Composition& comp,
                const double T9,
                const double rho,
                const gridfire::engine::SparsityPattern& sparsityPattern) -> gridfire::engine::NetworkJacobian {
-                return self.generateJacobianMatrix(comp, T9, rho, sparsityPattern);
+                return self.generateJacobianMatrix(ctx, comp, T9, rho, sparsityPattern);
             },
+            py::arg("ctx"),
             py::arg("comp"),
             py::arg("T9"),
             py::arg("rho"),
             py::arg("sparsityPattern"),
             "Generate the jacobian matrix for the given sparsity pattern"
         )
-        .def("generateStoichiometryMatrix",
-            &T::generateStoichiometryMatrix
-        )
         .def("calculateMolarReactionFlow",
             [](
                 const gridfire::engine::DynamicEngine& self,
+                sp::StateBlob& ctx,
                 const gridfire::reaction::Reaction& reaction,
                 const fourdst::composition::Composition& comp,
                 const double T9,
                 const double rho
             ) -> double {
-                return self.calculateMolarReactionFlow(reaction, comp, T9, rho);
+                return self.calculateMolarReactionFlow(ctx, reaction, comp, T9, rho);
             },
+            py::arg("ctx"),
             py::arg("reaction"),
             py::arg("comp"),
             py::arg("T9"),
@@ -110,28 +119,21 @@ namespace {
         .def("getNetworkReactions", &T::getNetworkReactions,
             "Get the set of logical reactions in the network."
         )
-        .def ("setNetworkReactions", &T::setNetworkReactions,
-            py::arg("reactions"),
-            "Set the network reactions to a new set of reactions."
-        )
-        .def("getStoichiometryMatrixEntry", &T::getStoichiometryMatrixEntry,
-            py::arg("species"),
-            py::arg("reaction"),
-            "Get an entry from the stoichiometry matrix."
-        )
         .def("getSpeciesTimescales",
             [](
                 const gridfire::engine::DynamicEngine& self,
+                sp::StateBlob& ctx,
                 const fourdst::composition::Composition& comp,
                 const double T9,
                 const double rho
             ) -> std::unordered_map<fourdst::atomic::Species, double> {
-                const auto result = self.getSpeciesTimescales(comp, T9, rho);
+                const auto result = self.getSpeciesTimescales(ctx, comp, T9, rho);
                 if (!result.has_value()) {
                     throw gridfire::exceptions::EngineError(std::format("getSpeciesTimescales has returned a potentially recoverable error {}", gridfire::engine::EngineStatus_to_string(result.error())));
                 }
                 return result.value();
             },
+            py::arg("ctx"),
             py::arg("comp"),
             py::arg("T9"),
             py::arg("rho"),
@@ -140,67 +142,48 @@ namespace {
         .def("getSpeciesDestructionTimescales",
             [](
                 const gridfire::engine::DynamicEngine& self,
+                sp::StateBlob& ctx,
                 const fourdst::composition::Composition& comp,
                 const double T9,
                 const double rho
             ) -> std::unordered_map<fourdst::atomic::Species, double> {
-                const auto result = self.getSpeciesDestructionTimescales(comp, T9, rho);
+                const auto result = self.getSpeciesDestructionTimescales(ctx, comp, T9, rho);
                 if (!result.has_value()) {
                     throw gridfire::exceptions::EngineError(std::format("getSpeciesDestructionTimescales has returned a potentially recoverable error {}", gridfire::engine::EngineStatus_to_string(result.error())));
                 }
                 return result.value();
             },
+            py::arg("ctx"),
             py::arg("comp"),
             py::arg("T9"),
             py::arg("rho"),
             "Get the destruction timescales for each species in the network."
         )
-        .def("update",
-            &T::update,
+        .def("project",
+            &T::project,
+            py::arg("ctx"),
             py::arg("netIn"),
             "Update the engine state based on the provided NetIn object."
         )
-        .def("setScreeningModel",
-            &T::setScreeningModel,
-            py::arg("screeningModel"),
-            "Set the screening model for the engine."
-        )
         .def("getScreeningModel",
             &T::getScreeningModel,
             "Get the current screening model of the engine."
         )
         .def("getSpeciesIndex",
             &T::getSpeciesIndex,
+            py::arg("ctx"),
             py::arg("species"),
             "Get the index of a species in the network."
         )
-        .def("mapNetInToMolarAbundanceVector",
-            &T::mapNetInToMolarAbundanceVector,
-            py::arg("netIn"),
-            "Map a NetIn object to a vector of molar abundances."
-        )
         .def("primeEngine",
             &T::primeEngine,
+            py::arg("ctx"),
             py::arg("netIn"),
             "Prime the engine with a NetIn object to prepare for calculations."
         )
-        .def("getDepth",
-            &T::getDepth,
-            "Get the current build depth of the engine."
-        )
-        .def("rebuild",
-            &T::rebuild,
-            py::arg("composition"),
-            py::arg("depth") = gridfire::engine::NetworkBuildDepth::Full,
-            "Rebuild the engine with a new composition and build depth."
-        )
-        .def("isStale",
-            &T::isStale,
-            py::arg("netIn"),
-            "Check if the engine is stale based on the provided NetIn object."
-        )
         .def("collectComposition",
             &T::collectComposition,
+            py::arg("ctx"),
             py::arg("composition"),
             py::arg("T9"),
             py::arg("rho"),
@@ -208,6 +191,7 @@ namespace {
         )
         .def("getSpeciesStatus",
             &T::getSpeciesStatus,
+            py::arg("ctx"),
             py::arg("species"),
             "Get the status of a species in the network."
         );
@@ -253,6 +237,7 @@ void register_engine_diagnostic_bindings(pybind11::module &m) {
     auto diagnostics = m.def_submodule("diagnostics", "A submodule for engine diagnostics");
     diagnostics.def("report_limiting_species",
         &gridfire::engine::diagnostics::report_limiting_species,
+        py::arg("ctx"),
         py::arg("engine"),
         py::arg("Y_full"),
         py::arg("E_full"),
@@ -264,6 +249,7 @@ void register_engine_diagnostic_bindings(pybind11::module &m) {
 
     diagnostics.def("inspect_species_balance",
         &gridfire::engine::diagnostics::inspect_species_balance,
+        py::arg("ctx"),
         py::arg("engine"),
         py::arg("species_name"),
         py::arg("comp"),
@@ -274,6 +260,7 @@ void register_engine_diagnostic_bindings(pybind11::module &m) {
 
     diagnostics.def("inspect_jacobian_stiffness",
         &gridfire::engine::diagnostics::inspect_jacobian_stiffness,
+        py::arg("ctx"),
         py::arg("engine"),
         py::arg("comp"),
         py::arg("T9"),
@@ -311,6 +298,7 @@ void register_engine_construction_bindings(pybind11::module &m) {
 void register_engine_priming_bindings(pybind11::module &m) {
     m.def("primeNetwork",
         &gridfire::engine::primeNetwork,
+        py::arg("ctx"),
         py::arg("netIn"),
         py::arg("engine"),
         py::arg("ignoredReactionTypes") = std::nullopt,
@@ -456,19 +444,16 @@ void con_stype_register_graph_engine_bindings(const pybind11::module &m) {
         py::arg("reactions"),
         "Initialize GraphEngine with a set of reactions."
     );
-    py_graph_engine_bindings.def_static("getNetReactionStoichiometry",
-        &gridfire::engine::GraphEngine::getNetReactionStoichiometry,
-        py::arg("reaction"),
-        "Get the net stoichiometry for a given reaction."
-    );
     py_graph_engine_bindings.def("getSpeciesTimescales",
         [](const gridfire::engine::GraphEngine& self,
+           sp::StateBlob& ctx,
            const fourdst::composition::Composition& composition,
            const double T9,
            const double rho,
            const gridfire::reaction::ReactionSet& activeReactions) {
-            return self.getSpeciesTimescales(composition, T9, rho, activeReactions);
+            return self.getSpeciesTimescales(ctx, composition, T9, rho, activeReactions);
         },
+        py::arg("ctx"),
         py::arg("composition"),
         py::arg("T9"),
         py::arg("rho"),
@@ -476,12 +461,14 @@ void con_stype_register_graph_engine_bindings(const pybind11::module &m) {
     );
     py_graph_engine_bindings.def("getSpeciesDestructionTimescales",
         [](const gridfire::engine::GraphEngine& self,
+           sp::StateBlob& ctx,
            const fourdst::composition::Composition& composition,
            const double T9,
            const double rho,
            const gridfire::reaction::ReactionSet& activeReactions) {
-            return self.getSpeciesDestructionTimescales(composition, T9, rho, activeReactions);
+            return self.getSpeciesDestructionTimescales(ctx, composition, T9, rho, activeReactions);
         },
+        py::arg("ctx"),
         py::arg("composition"),
         py::arg("T9"),
         py::arg("rho"),
@@ -489,24 +476,22 @@ void con_stype_register_graph_engine_bindings(const pybind11::module &m) {
     );
     py_graph_engine_bindings.def("involvesSpecies",
         &gridfire::engine::GraphEngine::involvesSpecies,
+        py::arg("ctx"),
         py::arg("species"),
         "Check if a given species is involved in the network."
     );
     py_graph_engine_bindings.def("exportToDot",
         &gridfire::engine::GraphEngine::exportToDot,
+        py::arg("ctx"),
         py::arg("filename"),
         "Export the network to a DOT file for visualization."
     );
     py_graph_engine_bindings.def("exportToCSV",
         &gridfire::engine::GraphEngine::exportToCSV,
+        py::arg("ctx"),
         py::arg("filename"),
         "Export the network to a CSV file for analysis."
     );
-    py_graph_engine_bindings.def("setPrecomputation",
-        &gridfire::engine::GraphEngine::setPrecomputation,
-        py::arg("precompute"),
-        "Enable or disable precomputation for the engine."
-    );
     py_graph_engine_bindings.def("isPrecomputationEnabled",
         &gridfire::engine::GraphEngine::isPrecomputationEnabled,
         "Check if precomputation is enabled for the engine."
@@ -544,11 +529,6 @@ void con_stype_register_graph_engine_bindings(const pybind11::module &m) {
         &gridfire::engine::GraphEngine::isUsingReverseReactions,
         "Check if the engine is using reverse reactions."
     );
-    py_graph_engine_bindings.def("setUseReverseReactions",
-        &gridfire::engine::GraphEngine::setUseReverseReactions,
-        py::arg("useReverse"),
-        "Enable or disable the use of reverse reactions in the engine."
-    );
 
     // Register the general dynamic engine bindings
     registerDynamicEngineDefs<gridfire::engine::GraphEngine, gridfire::engine::DynamicEngine>(py_graph_engine_bindings);
@@ -587,11 +567,13 @@ void register_engine_view_bindings(const pybind11::module &m) {
     registerDynamicEngineDefs<gridfire::engine::FileDefinedEngineView, gridfire::engine::DefinedEngineView>(py_file_defined_engine_view_bindings);
 
     auto py_priming_engine_view_bindings = py::class_<gridfire::engine::NetworkPrimingEngineView, gridfire::engine::DefinedEngineView>(m, "NetworkPrimingEngineView");
-    py_priming_engine_view_bindings.def(py::init<const std::string&, gridfire::engine::GraphEngine&>(),
+    py_priming_engine_view_bindings.def(py::init<sp::StateBlob&, const std::string&, gridfire::engine::GraphEngine&>(),
+        py::arg("ctx"),
         py::arg("primingSymbol"),
         py::arg("baseEngine"),
         "Construct a priming engine view with a priming symbol and a base engine.");
-    py_priming_engine_view_bindings.def(py::init<const fourdst::atomic::Species&, gridfire::engine::GraphEngine&>(),
+    py_priming_engine_view_bindings.def(py::init<sp::StateBlob&, const fourdst::atomic::Species&, gridfire::engine::GraphEngine&>(),
+        py::arg("ctx"),
         py::arg("primingSpecies"),
         py::arg("baseEngine"),
         "Construct a priming engine view with a priming species and a base engine.");
@@ -622,15 +604,12 @@ void register_engine_view_bindings(const pybind11::module &m) {
     );
     py_multiscale_engine_view_bindings.def("partitionNetwork",
         &gridfire::engine::MultiscalePartitioningEngineView::partitionNetwork,
+        py::arg("ctx"),
         py::arg("netIn"),
         "Partition the network based on species timescales and connectivity.");
-    py_multiscale_engine_view_bindings.def("partitionNetwork",
-        py::overload_cast<const gridfire::NetIn&>(&gridfire::engine::MultiscalePartitioningEngineView::partitionNetwork),
-        py::arg("netIn"),
-        "Partition the network based on a NetIn object."
-    );
     py_multiscale_engine_view_bindings.def("exportToDot",
     &gridfire::engine::MultiscalePartitioningEngineView::exportToDot,
+        py::arg("ctx"),
         py::arg("filename"),
         py::arg("comp"),
         py::arg("T9"),
@@ -661,7 +640,16 @@ void register_engine_view_bindings(const pybind11::module &m) {
         "Check if a given species is involved in the network's dynamic set."
     );
     py_multiscale_engine_view_bindings.def("getNormalizedEquilibratedComposition",
-        &gridfire::engine::MultiscalePartitioningEngineView::getNormalizedEquilibratedComposition,
+        [](
+            const gridfire::engine::MultiscalePartitioningEngineView&  self,
+            sp::StateBlob& ctx,
+            const fourdst::composition::Composition& comp,
+            const double T9,
+            const double rho
+        ) {
+            return self.getNormalizedEquilibratedComposition(ctx, comp, T9, rho, false);
+        },
+        py::arg("ctx"),
         py::arg("comp"),
         py::arg("T9"),
         py::arg("rho"),

src/python/engine/meson.build

@@ -1,21 +0,0 @@
-subdir('trampoline')
-
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-message('⏳ Python bindings for GridFire Engine are being registered...')
-shared_module('py_gf_engine',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)
-message('✅ Python bindings for GridFire Engine registered successfully!')

src/python/engine/scratchpads/bindings.cpp

@@ -0,0 +1,152 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h> // Needed for vectors, maps, sets, strings
+#include <pybind11/stl_bind.h> // Needed for binding std::vector, std::map etc. if needed directly
+
+#include "gridfire/engine/scratchpads/scratchpads.h"
+
+#include "bindings.h"
+
+namespace py = pybind11;
+namespace sp = gridfire::engine::scratch;
+
+template<typename... ScratchPadTypes>
+void build_state_getter(py::module& m) {
+
+}
+
+void register_scratchpad_types_bindings(pybind11::module &m) {
+    py::enum_<sp::ScratchPadType>(m, "ScratchPadType")
+        .value("GRAPH_ENGINE_SCRATCHPAD", sp::ScratchPadType::GRAPH_ENGINE_SCRATCHPAD)
+        .value("MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD", sp::ScratchPadType::MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD)
+        .value("ADAPTIVE_ENGINE_VIEW_SCRATCHPAD", sp::ScratchPadType::ADAPTIVE_ENGINE_VIEW_SCRATCHPAD)
+        .value("DEFINED_ENGINE_VIEW_SCRATCHPAD", sp::ScratchPadType::DEFINED_ENGINE_VIEW_SCRATCHPAD)
+        .export_values();
+}
+
+void register_scratchpad_bindings(pybind11::module_ &m) {
+    py::enum_<sp::GraphEngineScratchPad::ADFunRegistrationResult>(m, "ADFunRegistrationResult")
+        .value("SUCCESS", sp::GraphEngineScratchPad::ADFunRegistrationResult::SUCCESS)
+        .value("ALREADY_REGISTERED", sp::GraphEngineScratchPad::ADFunRegistrationResult::ALREADY_REGISTERED)
+        .export_values();
+
+    py::class_<sp::GraphEngineScratchPad>(m, "GraphEngineScratchPad")
+        .def(py::init<>())
+        .def("initialize", &sp::GraphEngineScratchPad::initialize, py::arg("engine"))
+        .def("clone", &sp::GraphEngineScratchPad::clone)
+        .def("is_initialized", &sp::GraphEngineScratchPad::is_initialized)
+        .def_readonly("most_recent_rhs_calculation", &sp::GraphEngineScratchPad::most_recent_rhs_calculation)
+        .def_readonly("local_abundance_cache", &sp::GraphEngineScratchPad::local_abundance_cache)
+        .def_readonly("has_initialized", &sp::GraphEngineScratchPad::has_initialized)
+        .def_readonly("stepDerivativesCache", &sp::GraphEngineScratchPad::stepDerivativesCache)
+        .def_readonly_static("ID", &sp::GraphEngineScratchPad::ID)
+        .def("__repr__", [](const sp::GraphEngineScratchPad &self) {
+            return std::format("{}", self);
+        });
+
+    py::class_<sp::MultiscalePartitioningEngineViewScratchPad>(m, "MultiscalePartitioningEngineViewScratchPad")
+        .def(py::init<>())
+        .def("initialize", &sp::MultiscalePartitioningEngineViewScratchPad::initialize)
+        .def("clone", &sp::MultiscalePartitioningEngineViewScratchPad::clone)
+        .def("is_initialized", &sp::MultiscalePartitioningEngineViewScratchPad::is_initialized)
+        .def_readonly("qse_groups", &sp::MultiscalePartitioningEngineViewScratchPad::qse_groups)
+        .def_readonly("dynamic_species", &sp::MultiscalePartitioningEngineViewScratchPad::dynamic_species)
+        .def_readonly("algebraic_species", &sp::MultiscalePartitioningEngineViewScratchPad::algebraic_species)
+        .def_readonly("composition_cache", &sp::MultiscalePartitioningEngineViewScratchPad::composition_cache)
+        .def_readonly("has_initialized", &sp::MultiscalePartitioningEngineViewScratchPad::has_initialized)
+        .def_readonly_static("ID", &sp::MultiscalePartitioningEngineViewScratchPad::ID)
+        .def("__repr__", [](const sp::MultiscalePartitioningEngineViewScratchPad &self) {
+            return std::format("{}", self);
+        });
+
+    py::class_<sp::AdaptiveEngineViewScratchPad>(m, "AdaptiveEngineViewScratchPad")
+        .def(py::init<>())
+        .def("initialize", &sp::AdaptiveEngineViewScratchPad::initialize)
+        .def("clone", &sp::AdaptiveEngineViewScratchPad::clone)
+        .def("is_initialized", &sp::AdaptiveEngineViewScratchPad::is_initialized)
+        .def_readonly("active_species", &sp::AdaptiveEngineViewScratchPad::active_species)
+        .def_readonly("active_reactions", &sp::AdaptiveEngineViewScratchPad::active_reactions)
+        .def_readonly("has_initialized", &sp::AdaptiveEngineViewScratchPad::has_initialized)
+        .def_readonly_static("ID", &sp::AdaptiveEngineViewScratchPad::ID)
+        .def("__repr__", [](const sp::AdaptiveEngineViewScratchPad &self) {
+            return std::format("{}", self);
+        });
+
+    py::class_<sp::DefinedEngineViewScratchPad>(m, "DefinedEngineViewScratchPad")
+        .def(py::init<>())
+        .def("clone", &sp::DefinedEngineViewScratchPad::clone)
+        .def("is_initialized", &sp::DefinedEngineViewScratchPad::is_initialized)
+        .def_readonly("active_species", &sp::DefinedEngineViewScratchPad::active_species)
+        .def_readonly("active_reactions", &sp::DefinedEngineViewScratchPad::active_reactions)
+        .def_readonly("species_index_map", &sp::DefinedEngineViewScratchPad::species_index_map)
+        .def_readonly("reaction_index_map", &sp::DefinedEngineViewScratchPad::reaction_index_map)
+        .def_readonly("has_initialized", &sp::DefinedEngineViewScratchPad::has_initialized)
+        .def_readonly_static("ID", &sp::DefinedEngineViewScratchPad::ID)
+        .def("__repr__", [](const sp::DefinedEngineViewScratchPad &self) {
+            return std::format("{}", self);
+        });
+}
+
+void register_state_blob_bindings(pybind11::module_ &m) {
+    py::enum_<sp::StateBlob::Error>(m, "StateBlobError")
+        .value("SCRATCHPAD_OUT_OF_BOUNDS", sp::StateBlob::Error::SCRATCHPAD_OUT_OF_BOUNDS)
+        .value("SCRATCHPAD_NOT_FOUND", sp::StateBlob::Error::SCRATCHPAD_NOT_FOUND)
+        .value("SCRATCHPAD_BAD_CAST", sp::StateBlob::Error::SCRATCHPAD_BAD_CAST)
+        .value("SCRATCHPAD_NOT_INITIALIZED", sp::StateBlob::Error::SCRATCHPAD_NOT_INITIALIZED)
+        .value("SCRATCHPAD_TYPE_COLLISION", sp::StateBlob::Error::SCRATCHPAD_TYPE_COLLISION)
+        .value("SCRATCHPAD_UNKNOWN_ERROR", sp::StateBlob::Error::SCRATCHPAD_UNKNOWN_ERROR)
+        .export_values();
+
+    py::class_<sp::StateBlob>(m, "StateBlob")
+        .def(py::init<>())
+        .def("enroll", [](sp::StateBlob &self, const sp::ScratchPadType type) {
+            switch (type) {
+                case sp::ScratchPadType::GRAPH_ENGINE_SCRATCHPAD:
+                    self.enroll<sp::GraphEngineScratchPad>();
+                    break;
+                case sp::ScratchPadType::MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD:
+                    self.enroll<sp::MultiscalePartitioningEngineViewScratchPad>();
+                    break;
+                case sp::ScratchPadType::ADAPTIVE_ENGINE_VIEW_SCRATCHPAD:
+                    self.enroll<sp::AdaptiveEngineViewScratchPad>();
+                    break;
+                case sp::ScratchPadType::DEFINED_ENGINE_VIEW_SCRATCHPAD:
+                    self.enroll<sp::DefinedEngineViewScratchPad>();
+                    break;
+                default:
+                    throw std::invalid_argument("Unknown ScratchPadType for enrollment.");
+            }
+        })
+    .def("get", [](const sp::StateBlob &self, const sp::ScratchPadType type) {
+            auto result = self.get(type);
+            if (!result.has_value()) {
+                throw std::runtime_error("Error retrieving scratchpad: " + sp::StateBlob::error_to_string(result.error()));
+            }
+            return result.value();
+        },
+        pybind11::return_value_policy::reference_internal
+    )
+    .def("clone_structure", &sp::StateBlob::clone_structure)
+    .def("get_registered_scratchpads", &sp::StateBlob::get_registered_scratchpads)
+    .def("get_status", [](const sp::StateBlob &self, const sp::ScratchPadType type) -> sp::StateBlob::ScratchPadStatus {
+            switch (type) {
+                case sp::ScratchPadType::GRAPH_ENGINE_SCRATCHPAD:
+                    return self.get_status<sp::GraphEngineScratchPad>();
+                case sp::ScratchPadType::MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD:
+                    return self.get_status<sp::MultiscalePartitioningEngineViewScratchPad>();
+                case sp::ScratchPadType::ADAPTIVE_ENGINE_VIEW_SCRATCHPAD:
+                    return self.get_status<sp::AdaptiveEngineViewScratchPad>();
+                case sp::ScratchPadType::DEFINED_ENGINE_VIEW_SCRATCHPAD:
+                    return self.get_status<sp::DefinedEngineViewScratchPad>();
+                default:
+                    throw std::invalid_argument("Unknown ScratchPadType for status retrieval.");
+            }
+    })
+    .def("get_status_map", &sp::StateBlob::get_status_map)
+    .def_static("error_to_string", &sp::StateBlob::error_to_string)
+    .def("__repr__", [](const sp::StateBlob &self) {
+        return std::format("{}", self);
+    });
+}
+
+
+

src/python/engine/scratchpads/bindings.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <pybind11/pybind11.h>
+
+void register_scratchpad_types_bindings(pybind11::module_& m);
+void register_scratchpad_bindings(pybind11::module_& m);
+void register_state_blob_bindings(pybind11::module_& m);

src/python/engine/trampoline/meson.build

@@ -1,21 +0,0 @@
-gf_engine_trampoline_sources = files('py_engine.cpp')
-
-gf_engine_trapoline_dependencies = [
-    gridfire_dep,
-    pybind11_dep,
-    python3_dep,
-]
-
-gf_engine_trampoline_lib = static_library(
-    'engine_trampolines',
-    gf_engine_trampoline_sources,
-    include_directories: include_directories('.'),
-    dependencies: gf_engine_trapoline_dependencies,
-    install: false,
-)
-
-gr_engine_trampoline_dep = declare_dependency(
-    link_with: gf_engine_trampoline_lib,
-    include_directories: ('.'),
-    dependencies: gf_engine_trapoline_dependencies,
-)

src/python/engine/trampoline/py_engine.cpp

@@ -13,36 +13,29 @@
 
 namespace py = pybind11;
 
-const std::vector<fourdst::atomic::Species>& PyEngine::getNetworkSpecies() const {
-    /*
-     * Acquire the GIL (Global Interpreter Lock) for thread safety
-     * with the Python interpreter.
-     */
-    py::gil_scoped_acquire gil;
-
-    /*
-     * get_override() looks for a Python method that overrides this C++ one.
-     */
-
-    if (const py::function override = py::get_override(this, "getNetworkSpecies")) {
-        const py::object result = override();
-        m_species_cache = result.cast<std::vector<fourdst::atomic::Species>>();
-        return m_species_cache;
-    }
-
-    py::pybind11_fail("Tried to call pure virtual function \"DynamicEngine::getNetworkSpecies\"");
+const std::vector<fourdst::atomic::Species>& PyEngine::getNetworkSpecies(
+    gridfire::engine::scratch::StateBlob& ctx
+) const {
+    PYBIND11_OVERRIDE_PURE(
+        const std::vector<fourdst::atomic::Species>&,
+        gridfire::engine::Engine,
+        getNetworkSpecies,
+        ctx
+    );
 }
 
 std::expected<gridfire::engine::StepDerivatives<double>, gridfire::engine::EngineStatus> PyEngine::calculateRHSAndEnergy(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     double T9,
-    double rho
+    double rho,
+    bool trust
 ) const {
     PYBIND11_OVERRIDE_PURE(
         PYBIND11_TYPE(std::expected<gridfire::engine::StepDerivatives<double>, gridfire::engine::EngineStatus>),
         gridfire::engine::Engine,
         calculateRHSAndEnergy,
-        comp, T9, rho
+        ctx, comp, T9, rho, trust
     );
 }
 
@@ -50,41 +43,35 @@ std::expected<gridfire::engine::StepDerivatives<double>, gridfire::engine::Engin
 /// PyDynamicEngine Implementation ///
 /////////////////////////////////////
 
-const std::vector<fourdst::atomic::Species>& PyDynamicEngine::getNetworkSpecies() const {
-    /*
-     * Acquire the GIL (Global Interpreter Lock) for thread safety
-     * with the Python interpreter.
-     */
-    py::gil_scoped_acquire gil;
-
-    /*
-     * get_override() looks for a Python method that overrides this C++ one.
-     */
-
-    if (const py::function override = py::get_override(this, "getNetworkSpecies")) {
-        const py::object result = override();
-        m_species_cache = result.cast<std::vector<fourdst::atomic::Species>>();
-        return m_species_cache;
-    }
-
-    py::pybind11_fail("Tried to call pure virtual function \"DynamicEngine::getNetworkSpecies\"");
+const std::vector<fourdst::atomic::Species>& PyDynamicEngine::getNetworkSpecies(
+    gridfire::engine::scratch::StateBlob& ctx
+) const {
+        PYBIND11_OVERRIDE_PURE(
+        const std::vector<fourdst::atomic::Species>&,
+        gridfire::engine::DynamicEngine,
+        getNetworkSpecies,
+        ctx
+    );
 }
 
 
 std::expected<gridfire::engine::StepDerivatives<double>, gridfire::engine::EngineStatus> PyDynamicEngine::calculateRHSAndEnergy(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     double T9,
-    double rho
+    double rho,
+    bool trust
 ) const {
     PYBIND11_OVERRIDE_PURE(
         PYBIND11_TYPE(std::expected<gridfire::engine::StepDerivatives<double>, gridfire::engine::EngineStatus>),
         gridfire::engine::DynamicEngine,
         calculateRHSAndEnergy,
-        comp, T9, rho
+        ctx, comp, T9, rho, trust
     );
 }
 
 gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract& comp,
     double T9,
     double rho
@@ -100,6 +87,7 @@ gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
 }
 
 gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     const double T9,
     const double rho,
@@ -109,6 +97,7 @@ gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
         gridfire::engine::NetworkJacobian,
         gridfire::engine::DynamicEngine,
         generateJacobianMatrix,
+        ctx,
         comp,
         T9,
         rho,
@@ -117,6 +106,7 @@ gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
 }
 
 gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     double T9,
     double rho,
@@ -126,6 +116,7 @@ gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
         gridfire::engine::NetworkJacobian,
         gridfire::engine::DynamicEngine,
         generateJacobianMatrix,
+        ctx,
         comp,
         T9,
         rho,
@@ -133,28 +124,8 @@ gridfire::engine::NetworkJacobian PyDynamicEngine::generateJacobianMatrix(
     );
 }
 
-void PyDynamicEngine::generateStoichiometryMatrix() {
-    PYBIND11_OVERRIDE_PURE(
-        void,
-        gridfire::engine::DynamicEngine,
-        generateStoichiometryMatrix
-    );
-}
-
-int PyDynamicEngine::getStoichiometryMatrixEntry(
-    const fourdst::atomic::Species& species,
-    const gridfire::reaction::Reaction& reaction
-) const {
-    PYBIND11_OVERRIDE_PURE(
-        int,
-        gridfire::engine::DynamicEngine,
-        getStoichiometryMatrixEntry,
-        species,
-        reaction
-    );
-}
-
 double PyDynamicEngine::calculateMolarReactionFlow(
+    gridfire::engine::scratch::StateBlob& ctx,
     const gridfire::reaction::Reaction &reaction,
     const fourdst::composition::CompositionAbstract &comp,
     double T9,
@@ -164,6 +135,7 @@ double PyDynamicEngine::calculateMolarReactionFlow(
         double,
         gridfire::engine::DynamicEngine,
         calculateMolarReactionFlow,
+        ctx,
         reaction,
         comp,
         T9,
@@ -171,24 +143,19 @@ double PyDynamicEngine::calculateMolarReactionFlow(
     );
 }
 
-const gridfire::reaction::ReactionSet& PyDynamicEngine::getNetworkReactions() const {
+const gridfire::reaction::ReactionSet& PyDynamicEngine::getNetworkReactions(
+    gridfire::engine::scratch::StateBlob& ctx
+) const {
     PYBIND11_OVERRIDE_PURE(
         const gridfire::reaction::ReactionSet&,
         gridfire::engine::DynamicEngine,
-        getNetworkReactions
-    );
-}
-
-void PyDynamicEngine::setNetworkReactions(const gridfire::reaction::ReactionSet& reactions) {
-    PYBIND11_OVERRIDE_PURE(
-        void,
-        gridfire::engine::DynamicEngine,
-        setNetworkReactions,
-        reactions
+        getNetworkReactions,
+        ctx
     );
 }
 
 std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::engine::EngineStatus> PyDynamicEngine::getSpeciesTimescales(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     double T9,
     double rho
@@ -197,6 +164,7 @@ std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::en
         PYBIND11_TYPE(std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::engine::EngineStatus>),
         gridfire::engine::DynamicEngine,
         getSpeciesTimescales,
+        ctx,
         comp,
         T9,
         rho
@@ -204,6 +172,7 @@ std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::en
 }
 
 std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::engine::EngineStatus> PyDynamicEngine::getSpeciesDestructionTimescales(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     double T9,
     double rho
@@ -212,80 +181,71 @@ std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::en
         PYBIND11_TYPE(std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::engine::EngineStatus>),
         gridfire::engine::DynamicEngine,
         getSpeciesDestructionTimescales,
-        comp, T9, rho
+        ctx, comp, T9, rho
     );
 }
 
-fourdst::composition::Composition PyDynamicEngine::update(const gridfire::NetIn &netIn) {
+fourdst::composition::Composition PyDynamicEngine::project(
+    gridfire::engine::scratch::StateBlob& ctx,
+    const gridfire::NetIn &netIn
+) const {
     PYBIND11_OVERRIDE_PURE(
         fourdst::composition::Composition,
         gridfire::engine::DynamicEngine,
-        update,
+        project,
+        ctx,
         netIn
     );
 }
 
-bool PyDynamicEngine::isStale(const gridfire::NetIn &netIn) {
-    PYBIND11_OVERRIDE_PURE(
-        bool,
-        gridfire::engine::DynamicEngine,
-        isStale,
-        netIn
-    );
-}
-
-void PyDynamicEngine::setScreeningModel(gridfire::screening::ScreeningType model) {
-    PYBIND11_OVERRIDE_PURE(
-        void,
-        gridfire::engine::DynamicEngine,
-        setScreeningModel,
-        model
-    );
-}
-
-gridfire::screening::ScreeningType PyDynamicEngine::getScreeningModel() const {
+gridfire::screening::ScreeningType PyDynamicEngine::getScreeningModel(
+    gridfire::engine::scratch::StateBlob& ctx
+) const {
     PYBIND11_OVERRIDE_PURE(
         gridfire::screening::ScreeningType,
         gridfire::engine::DynamicEngine,
-        getScreeningModel
+        getScreeningModel,
+        ctx
     );
 }
 
-size_t PyDynamicEngine::getSpeciesIndex(const fourdst::atomic::Species &species) const {
+size_t PyDynamicEngine::getSpeciesIndex(
+    gridfire::engine::scratch::StateBlob& ctx,
+    const fourdst::atomic::Species &species
+) const {
     PYBIND11_OVERRIDE_PURE(
         int,
         gridfire::engine::DynamicEngine,
         getSpeciesIndex,
+        ctx,
         species
     );
 }
 
-std::vector<double> PyDynamicEngine::mapNetInToMolarAbundanceVector(const gridfire::NetIn &netIn) const {
-    PYBIND11_OVERRIDE_PURE(
-        std::vector<double>,
-        gridfire::engine::DynamicEngine,
-        mapNetInToMolarAbundanceVector,
-        netIn
-    );
-}
-
-gridfire::engine::PrimingReport PyDynamicEngine::primeEngine(const gridfire::NetIn &netIn) {
+gridfire::engine::PrimingReport PyDynamicEngine::primeEngine(
+    gridfire::engine::scratch::StateBlob& ctx,
+    const gridfire::NetIn &netIn
+) const {
     PYBIND11_OVERRIDE_PURE(
         gridfire::engine::PrimingReport,
         gridfire::engine::DynamicEngine,
         primeEngine,
+        ctx,
         netIn
     );
 }
 
 gridfire::engine::EnergyDerivatives PyDynamicEngine::calculateEpsDerivatives(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     const double T9,
-    const double rho) const {
+    const double rho
+) const {
     PYBIND11_OVERRIDE_PURE(
         gridfire::engine::EnergyDerivatives,
         gridfire::engine::DynamicEngine,
         calculateEpsDerivatives,
+        ctx,
         comp,
         T9,
         rho
@@ -293,6 +253,7 @@ gridfire::engine::EnergyDerivatives PyDynamicEngine::calculateEpsDerivatives(
 }
 
 fourdst::composition::Composition PyDynamicEngine::collectComposition(
+    gridfire::engine::scratch::StateBlob& ctx,
     const fourdst::composition::CompositionAbstract &comp,
     const double T9,
     const double rho
@@ -301,21 +262,37 @@ fourdst::composition::Composition PyDynamicEngine::collectComposition(
         fourdst::composition::Composition,
         gridfire::engine::DynamicEngine,
         collectComposition,
+        ctx,
         comp,
         T9,
         rho
     );
 }
 
-gridfire::engine::SpeciesStatus PyDynamicEngine::getSpeciesStatus(const fourdst::atomic::Species &species) const {
+gridfire::engine::SpeciesStatus PyDynamicEngine::getSpeciesStatus(
+    gridfire::engine::scratch::StateBlob& ctx,
+    const fourdst::atomic::Species &species
+) const {
     PYBIND11_OVERRIDE_PURE(
         gridfire::engine::SpeciesStatus,
         gridfire::engine::DynamicEngine,
         getSpeciesStatus,
+        ctx,
         species
     );
 }
 
+std::optional<gridfire::engine::StepDerivatives<double>> PyDynamicEngine::getMostRecentRHSCalculation(
+    gridfire::engine::scratch::StateBlob &ctx
+) const {
+    PYBIND11_OVERRIDE_PURE(
+        PYBIND11_TYPE(std::optional<gridfire::engine::StepDerivatives<double>>),
+        gridfire::engine::DynamicEngine,
+        getMostRecentRHSCalculation,
+        ctx
+    );
+}
+
 const gridfire::engine::Engine& PyEngineView::getBaseEngine() const {
     PYBIND11_OVERRIDE_PURE(
         const gridfire::engine::Engine&,

src/python/engine/trampoline/py_engine.h

@@ -10,12 +10,16 @@
 
 class PyEngine final : public gridfire::engine::Engine {
 public:
-    const std::vector<fourdst::atomic::Species>& getNetworkSpecies() const override;
+    const std::vector<fourdst::atomic::Species>& getNetworkSpecies(
+        gridfire::engine::scratch::StateBlob& ctx
+    ) const override;
 
     std::expected<gridfire::engine::StepDerivatives<double>, gridfire::engine::EngineStatus> calculateRHSAndEnergy(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
-        double rho
+        double rho,
+        bool trust
     ) const override;
 private:
     mutable std::vector<fourdst::atomic::Species> m_species_cache;
@@ -23,21 +27,27 @@ private:
 
 class PyDynamicEngine final : public gridfire::engine::DynamicEngine {
 public:
-    const std::vector<fourdst::atomic::Species>& getNetworkSpecies() const override;
+    const std::vector<fourdst::atomic::Species>& getNetworkSpecies(
+        gridfire::engine::scratch::StateBlob& ctx
+    ) const override;
 
     std::expected<gridfire::engine::StepDerivatives<double>, gridfire::engine::EngineStatus> calculateRHSAndEnergy(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
-        double rho
+        double rho,
+        bool trust
     ) const override;
 
     gridfire::engine::NetworkJacobian generateJacobianMatrix(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract& comp,
         double T9,
         double rho
     ) const override;
 
     gridfire::engine::NetworkJacobian generateJacobianMatrix(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
         double rho,
@@ -45,96 +55,81 @@ public:
     ) const override;
 
     gridfire::engine::NetworkJacobian generateJacobianMatrix(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract& comp,
         double T9,
         double rho,
         const gridfire::engine::SparsityPattern &sparsityPattern
     ) const override;
 
-    void generateStoichiometryMatrix() override;
-
-    int getStoichiometryMatrixEntry(
-        const fourdst::atomic::Species& species,
-        const gridfire::reaction::Reaction& reaction
-    ) const override;
-
     double calculateMolarReactionFlow(
+        gridfire::engine::scratch::StateBlob& ctx,
         const gridfire::reaction::Reaction &reaction,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
         double rho
     ) const override;
 
-    const gridfire::reaction::ReactionSet& getNetworkReactions() const override;
-
-    void setNetworkReactions(
-        const gridfire::reaction::ReactionSet& reactions
-    ) override;
+    const gridfire::reaction::ReactionSet& getNetworkReactions(
+        gridfire::engine::scratch::StateBlob& ctx
+    ) const override;
 
     std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::engine::EngineStatus> getSpeciesTimescales(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
         double rho
     ) const override;
 
     std::expected<std::unordered_map<fourdst::atomic::Species, double>, gridfire::engine::EngineStatus> getSpeciesDestructionTimescales(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
         double rho
     ) const override;
 
-    fourdst::composition::Composition update(
+    fourdst::composition::Composition project(
+        gridfire::engine::scratch::StateBlob& ctx,
         const gridfire::NetIn &netIn
-    ) override;
+    ) const override;
 
-    bool isStale(
-        const gridfire::NetIn &netIn
-    ) override;
-
-    void setScreeningModel(
-        gridfire::screening::ScreeningType model
-    ) override;
-
-    gridfire::screening::ScreeningType getScreeningModel() const override;
+    gridfire::screening::ScreeningType getScreeningModel(
+        gridfire::engine::scratch::StateBlob& ctx
+    ) const override;
 
     size_t getSpeciesIndex(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::atomic::Species &species
     ) const override;
 
-    std::vector<double> mapNetInToMolarAbundanceVector(
+    gridfire::engine::PrimingReport primeEngine(
+        gridfire::engine::scratch::StateBlob& ctx,
         const gridfire::NetIn &netIn
     ) const override;
 
-    gridfire::engine::PrimingReport primeEngine(
-        const gridfire::NetIn &netIn
-    ) override;
-
-    gridfire::engine::BuildDepthType getDepth() const override {
-        throw std::logic_error("Network depth not supported by this engine.");
-    }
-    void rebuild(
-        const fourdst::composition::CompositionAbstract &comp,
-        gridfire::engine::BuildDepthType depth
-    ) override {
-        throw std::logic_error("Setting network depth not supported by this engine.");
-    }
-
     [[nodiscard]] gridfire::engine::EnergyDerivatives calculateEpsDerivatives(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
         double rho
     ) const override;
 
     fourdst::composition::Composition collectComposition(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::composition::CompositionAbstract &comp,
         double T9,
         double rho
     ) const override;
 
     gridfire::engine::SpeciesStatus getSpeciesStatus(
+        gridfire::engine::scratch::StateBlob& ctx,
         const fourdst::atomic::Species &species
     ) const override;
 
+    std::optional<gridfire::engine::StepDerivatives<double>> getMostRecentRHSCalculation(
+        gridfire::engine::scratch::StateBlob &ctx
+    ) const override;
+
 private:
     mutable std::vector<fourdst::atomic::Species> m_species_cache;
 };

src/python/exceptions/bindings.cpp

@@ -2,6 +2,8 @@
 
 #include "bindings.h"
 
+#include "gridfire/exceptions/error_scratchpad.h"
+
 namespace py = pybind11;
 
 #include "gridfire/exceptions/exceptions.h"
@@ -44,4 +46,6 @@ void register_exception_bindings(const py::module &m) {
     py::register_exception<gridfire::exceptions::CVODESolverFailureError>(m, "CVODESolverFailureError", m.attr("SUNDIALSError"));
     py::register_exception<gridfire::exceptions::KINSolSolverFailureError>(m, "KINSolSolverFailureError", m.attr("SUNDIALSError"));
 
+    py::register_exception<gridfire::exceptions::ScratchPadError>(m, "ScratchPadError", m.attr("GridFireError"));
+
 }

src/python/exceptions/meson.build

@@ -1,17 +0,0 @@
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_exceptions',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/gridfire/__init__.py

@@ -1,7 +1,7 @@
 from ._gridfire import *
 import sys
 
-from ._gridfire import type, utils, engine, solver, exceptions, partition, reaction, screening, io, policy
+from ._gridfire import type, utils, engine, solver, exceptions, partition, reaction, screening, io, policy, config
 
 sys.modules['gridfire.type'] = type
 sys.modules['gridfire.utils'] = utils
@@ -13,8 +13,61 @@ sys.modules['gridfire.reaction'] = reaction
 sys.modules['gridfire.screening'] = screening
 sys.modules['gridfire.policy'] = policy
 sys.modules['gridfire.io'] = io
+sys.modules['gridfire.config'] = config
 
-__all__ = ['type', 'utils', 'engine', 'solver', 'exceptions', 'partition', 'reaction', 'screening', 'io', 'policy']
+__all__ = ['type', 'utils', 'engine', 'solver', 'exceptions', 'partition', 'reaction', 'screening', 'io', 'policy', 'config']
 
-__version__ = "v0.7.4_rc2"
+import importlib.metadata
 
+try:
+    _meta = importlib.metadata.metadata('gridfire')
+    __version__ = _meta['Version']
+    __author__ = _meta['Author']
+    __license__ = _meta['License']
+    __email__ = _meta['Author-email']
+    __url__ = _meta['Home-page'] or _meta.get('Project-URL', '').split(',')[0].split(' ')[-1].strip()
+    __description__ = _meta['Summary']
+except importlib.metadata.PackageNotFoundError :
+    __version__ = 'unknown - Package not installed'
+    __author__ = 'Emily M. Boudreaux'
+    __license__ = 'GNU General Public License v3.0'
+    __email__ = 'emily.boudreaux@dartmouth.edu'
+    __url__ = 'https://github.com/4D-STAR/GridFire'
+
+def gf_metadata():
+    return {
+        'version': __version__,
+        'author': __author__,
+        'license': __license__,
+        'email': __email__,
+        'url': __url__,
+        'description': __description__
+    }
+
+def gf_version():
+    return __version__
+
+def gf_author():
+    return __author__
+
+def gf_license():
+    return __license__
+
+def gf_email():
+    return __email__
+
+def gf_url():
+    return __url__
+
+def gf_description():
+    return __description__
+
+def gf_collaboration():
+    return "4D-STAR Collaboration"
+
+def gf_credits():
+    return [
+        "Emily M. Boudreaux - Lead Developer",
+        "Aaron Dotter - Co-Developer",
+        "4D-STAR Collaboration - Contributors"
+    ]

src/python/io/meson.build

@@ -1,17 +0,0 @@
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_io',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/io/trampoline/meson.build

@@ -1,21 +0,0 @@
-gf_io_trampoline_sources = files('py_io.cpp')
-
-gf_io_trapoline_dependencies = [
-    gridfire_dep,
-    pybind11_dep,
-    python3_dep,
-]
-
-gf_io_trampoline_lib = static_library(
-    'io_trampolines',
-    gf_io_trampoline_sources,
-    include_directories: include_directories('.'),
-    dependencies: gf_io_trapoline_dependencies,
-    install: false,
-)
-
-gr_io_trampoline_dep = declare_dependency(
-    link_with: gf_io_trampoline_lib,
-    include_directories: ('.'),
-    dependencies: gf_io_trapoline_dependencies,
-)

src/python/meson.build

@@ -1,10 +0,0 @@
-subdir('types')
-subdir('utils')
-subdir('exceptions')
-subdir('io')
-subdir('partition')
-subdir('reaction')
-subdir('screening')
-subdir('engine')
-subdir('policy')
-subdir('solver')

src/python/partition/meson.build

@@ -1,19 +0,0 @@
-subdir('trampoline')
-
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_partition',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/partition/trampoline/meson.build

@@ -1,21 +0,0 @@
-gf_partition_trampoline_sources = files('py_partition.cpp')
-
-gf_partition_trapoline_dependencies = [
-    gridfire_dep,
-    pybind11_dep,
-    python3_dep,
-]
-
-gf_partition_trampoline_lib = static_library(
-    'partition_trampolines',
-    gf_partition_trampoline_sources,
-    include_directories: include_directories('.'),
-    dependencies: gf_partition_trapoline_dependencies,
-    install: false,
-)
-
-gr_partition_trampoline_dep = declare_dependency(
-    link_with: gf_partition_trampoline_lib,
-    include_directories: ('.'),
-    dependencies: gf_partition_trapoline_dependencies,
-)

src/python/policy/bindings.cpp

@@ -8,7 +8,6 @@
 
 #include "gridfire/policy/policy.h"
 
-PYBIND11_DECLARE_HOLDER_TYPE(T, std::unique_ptr<T>, true) // Declare unique_ptr as a holder type for pybind11
 
 namespace py = pybind11;
 
@@ -103,9 +102,30 @@ namespace {
         .def(
             "construct",
             &T::construct,
-            py::return_value_policy::reference,
             "Construct the network according to the policy."
 
+        )
+        .def(
+            "get_engine_stack",
+            [](const T &self) {
+                const auto& stack = self.get_engine_stack();
+                std::vector<gridfire::engine::DynamicEngine*> engine_ptrs;
+                engine_ptrs.reserve(stack.size());
+                for (const auto& engine_uptr : stack) {
+                    engine_ptrs.push_back(engine_uptr.get());
+                }
+
+                return engine_ptrs;
+            },
+            py::return_value_policy::reference_internal
+        )
+        .def(
+            "get_stack_scratch_blob",
+            &T::get_stack_scratch_blob
+        )
+        .def(
+            "get_partition_function",
+            &T::get_partition_function
         );
     }
 }
@@ -215,6 +235,26 @@ void register_network_policy_bindings(pybind11::module &m) {
         .value("INITIALIZED_VERIFIED", gridfire::policy::NetworkPolicyStatus::INITIALIZED_VERIFIED)
         .export_values();
 
+    m.def("network_policy_status_to_string",
+        &gridfire::policy::NetworkPolicyStatusToString,
+        py::arg("status"),
+        "Convert a NetworkPolicyStatus enum value to its string representation."
+    );
+
+    py::class_<gridfire::policy::ConstructionResults>(m, "ConstructionResults")
+        .def_property_readonly("engine",
+            [](const gridfire::policy::ConstructionResults &self) -> const gridfire::engine::DynamicEngine& {
+                return self.engine;
+            },
+            py::return_value_policy::reference
+        )
+        .def_property_readonly("scratch_blob",
+            [](const gridfire::policy::ConstructionResults &self) {
+                return self.scratch_blob.get();
+            },
+            py::return_value_policy::reference_internal
+        );
+
     py::class_<gridfire::policy::NetworkPolicy, PyNetworkPolicy> py_networkPolicy(m, "NetworkPolicy");
     py::class_<gridfire::policy::MainSequencePolicy, gridfire::policy::NetworkPolicy> py_mainSeqPolicy(m, "MainSequencePolicy");
     py_mainSeqPolicy.def(

src/python/policy/meson.build

@@ -1,19 +0,0 @@
-# Define the library
-subdir('trampoline')
-
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_policy',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/policy/trampoline/meson.build

@@ -1,21 +0,0 @@
-gf_policy_trampoline_sources = files('py_policy.cpp')
-
-gf_policy_trapoline_dependencies = [
-    gridfire_dep,
-    pybind11_dep,
-    python3_dep,
-]
-
-gf_policy_trampoline_lib = static_library(
-    'policy_trampolines',
-    gf_policy_trampoline_sources,
-    include_directories: include_directories('.'),
-    dependencies: gf_policy_trapoline_dependencies,
-    install: false,
-)
-
-gr_policy_trampoline_dep = declare_dependency(
-    link_with: gf_policy_trampoline_lib,
-    include_directories: ('.'),
-    dependencies: gf_policy_trapoline_dependencies,
-)

src/python/policy/trampoline/py_policy.cpp

@@ -39,9 +39,9 @@ const gridfire::reaction::ReactionSet& PyNetworkPolicy::get_seed_reactions() con
     );
 }
 
-gridfire::engine::DynamicEngine& PyNetworkPolicy::construct() {
+gridfire::policy::ConstructionResults PyNetworkPolicy::construct() {
     PYBIND11_OVERRIDE_PURE(
-        gridfire::engine::DynamicEngine&,
+        gridfire::policy::ConstructionResults,
         gridfire::policy::NetworkPolicy,
         construct
     );
@@ -79,6 +79,14 @@ const std::unique_ptr<gridfire::partition::PartitionFunction>& PyNetworkPolicy::
     );
 }
 
+std::unique_ptr<gridfire::engine::scratch::StateBlob> PyNetworkPolicy::get_stack_scratch_blob() const {
+    PYBIND11_OVERRIDE_PURE(
+        std::unique_ptr<gridfire::engine::scratch::StateBlob>,
+        gridfire::policy::NetworkPolicy,
+        get_stack_scratch_blob
+    );
+}
+
 const gridfire::reaction::ReactionSet &PyReactionChainPolicy::get_reactions() const {
     PYBIND11_OVERRIDE_PURE(
         const gridfire::reaction::ReactionSet &,

src/python/policy/trampoline/py_policy.h

@@ -13,7 +13,7 @@ public:
 
     [[nodiscard]] const gridfire::reaction::ReactionSet& get_seed_reactions() const override;
 
-    [[nodiscard]] gridfire::engine::DynamicEngine& construct() override;
+    [[nodiscard]] gridfire::policy::ConstructionResults construct() override;
 
     [[nodiscard]] gridfire::policy::NetworkPolicyStatus get_status() const override;
 
@@ -22,6 +22,8 @@ public:
     [[nodiscard]] std::vector<gridfire::engine::EngineTypes> get_engine_types_stack() const override;
 
     [[nodiscard]] const std::unique_ptr<gridfire::partition::PartitionFunction>& get_partition_function() const override;
+
+    [[nodiscard]] std::unique_ptr<gridfire::engine::scratch::StateBlob> get_stack_scratch_blob() const override;
 };
 
 class PyReactionChainPolicy final : public gridfire::policy::ReactionChainPolicy {

src/python/reaction/meson.build

@@ -1,17 +0,0 @@
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_reaction',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/screening/meson.build

@@ -1,19 +0,0 @@
-subdir('trampoline')
-
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_screening',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/screening/trampoline/meson.build

@@ -1,21 +0,0 @@
-gf_screening_trampoline_sources = files('py_screening.cpp')
-
-gf_screening_trapoline_dependencies = [
-    gridfire_dep,
-    pybind11_dep,
-    python3_dep,
-]
-
-gf_screening_trampoline_lib = static_library(
-    'screening_trampolines',
-    gf_screening_trampoline_sources,
-    include_directories: include_directories('.'),
-    dependencies: gf_screening_trapoline_dependencies,
-    install: false,
-)
-
-gr_screening_trampoline_dep = declare_dependency(
-    link_with: gf_screening_trampoline_lib,
-    include_directories: ('.'),
-    dependencies: gf_screening_trapoline_dependencies,
-)

src/python/solver/bindings.cpp

@@ -7,125 +7,226 @@
 
 #include "bindings.h"
 
-#include "gridfire/solver/strategies/CVODE_solver_strategy.h"
+#include "gridfire/solver/strategies/PointSolver.h"
+#include "gridfire/engine/scratchpads/blob.h"
 #include "trampoline/py_solver.h"
 
 namespace py = pybind11;
 
 
 void register_solver_bindings(const py::module &m) {
-    auto py_solver_context_base = py::class_<gridfire::solver::SolverContextBase>(m, "SolverContextBase");
-
-    auto py_cvode_timestep_context = py::class_<gridfire::solver::CVODESolverStrategy::TimestepContext, gridfire::solver::SolverContextBase>(m, "CVODETimestepContext");
-    py_cvode_timestep_context.def_readonly("t", &gridfire::solver::CVODESolverStrategy::TimestepContext::t);
+    auto py_cvode_timestep_context = py::class_<gridfire::solver::PointSolverTimestepContext>(m, "PointSolverTimestepContext");
+    py_cvode_timestep_context.def_readonly("t", &gridfire::solver::PointSolverTimestepContext::t);
     py_cvode_timestep_context.def_property_readonly(
         "state",
-        [](const gridfire::solver::CVODESolverStrategy::TimestepContext& self) -> std::vector<double> {
+        [](const gridfire::solver::PointSolverTimestepContext& self) -> std::vector<double> {
             const sunrealtype* nvec_data = N_VGetArrayPointer(self.state);
             const sunindextype length = N_VGetLength(self.state);
-            return std::vector<double>(nvec_data, nvec_data + length);
+            return {nvec_data, nvec_data + length};
         }
     );
-    py_cvode_timestep_context.def_readonly("dt", &gridfire::solver::CVODESolverStrategy::TimestepContext::dt);
-    py_cvode_timestep_context.def_readonly("last_step_time", &gridfire::solver::CVODESolverStrategy::TimestepContext::last_step_time);
-    py_cvode_timestep_context.def_readonly("T9", &gridfire::solver::CVODESolverStrategy::TimestepContext::T9);
-    py_cvode_timestep_context.def_readonly("rho", &gridfire::solver::CVODESolverStrategy::TimestepContext::rho);
-    py_cvode_timestep_context.def_readonly("num_steps", &gridfire::solver::CVODESolverStrategy::TimestepContext::num_steps);
-    py_cvode_timestep_context.def_readonly("currentConvergenceFailures", &gridfire::solver::CVODESolverStrategy::TimestepContext::currentConvergenceFailures);
-    py_cvode_timestep_context.def_readonly("currentNonlinearIterations", &gridfire::solver::CVODESolverStrategy::TimestepContext::currentNonlinearIterations);
+    py_cvode_timestep_context.def_readonly("dt", &gridfire::solver::PointSolverTimestepContext::dt);
+    py_cvode_timestep_context.def_readonly("last_step_time", &gridfire::solver::PointSolverTimestepContext::last_step_time);
+    py_cvode_timestep_context.def_readonly("T9", &gridfire::solver::PointSolverTimestepContext::T9);
+    py_cvode_timestep_context.def_readonly("rho", &gridfire::solver::PointSolverTimestepContext::rho);
+    py_cvode_timestep_context.def_readonly("num_steps", &gridfire::solver::PointSolverTimestepContext::num_steps);
+    py_cvode_timestep_context.def_readonly("currentConvergenceFailures", &gridfire::solver::PointSolverTimestepContext::currentConvergenceFailures);
+    py_cvode_timestep_context.def_readonly("currentNonlinearIterations", &gridfire::solver::PointSolverTimestepContext::currentNonlinearIterations);
     py_cvode_timestep_context.def_property_readonly(
         "engine",
-        [](const gridfire::solver::CVODESolverStrategy::TimestepContext& self) -> const gridfire::engine::DynamicEngine& {
+        [](const gridfire::solver::PointSolverTimestepContext& self) -> const gridfire::engine::DynamicEngine& {
             return self.engine;
         }
     );
     py_cvode_timestep_context.def_property_readonly(
         "networkSpecies",
-        [](const gridfire::solver::CVODESolverStrategy::TimestepContext& self) -> std::vector<fourdst::atomic::Species> {
+        [](const gridfire::solver::PointSolverTimestepContext& self) -> std::vector<fourdst::atomic::Species> {
             return self.networkSpecies;
         }
     );
+    py_cvode_timestep_context.def_property_readonly(
+        "state_ctx",
+        [](const gridfire::solver::PointSolverTimestepContext& self) {
+            return &(self.state_ctx);
+        },
+        py::return_value_policy::reference_internal
+    );
 
-    auto py_dynamic_network_solver_strategy = py::class_<gridfire::solver::DynamicNetworkSolverStrategy, PyDynamicNetworkSolverStrategy>(m, "DynamicNetworkSolverStrategy");
-    py_dynamic_network_solver_strategy.def(
+
+    auto py_solver_context_base = py::class_<gridfire::solver::SolverContextBase>(m, "SolverContextBase");
+    auto py_point_solver_context = py::class_<gridfire::solver::PointSolverContext, gridfire::solver::SolverContextBase>(m, "PointSolverContext");
+
+    py_point_solver_context
+        .def_readonly(
+            "sun_ctx", &gridfire::solver::PointSolverContext::sun_ctx
+        )
+        .def_readonly(
+            "cvode_mem", &gridfire::solver::PointSolverContext::cvode_mem
+        )
+        .def_readonly(
+            "Y", &gridfire::solver::PointSolverContext::Y
+        )
+        .def_readonly(
+            "YErr",  &gridfire::solver::PointSolverContext::YErr
+        )
+        .def_readonly(
+            "J", &gridfire::solver::PointSolverContext::J
+        )
+        .def_readonly(
+            "LS", &gridfire::solver::PointSolverContext::LS
+        )
+        .def_property_readonly(
+            "engine_ctx",
+            [](const gridfire::solver::PointSolverContext& self) -> gridfire::engine::scratch::StateBlob& {
+                return *(self.engine_ctx);
+            },
+            py::return_value_policy::reference
+        )
+        .def_readonly(
+            "num_steps", &gridfire::solver::PointSolverContext::num_steps
+        )
+        .def_property(
+            "abs_tol",
+            [](const gridfire::solver::PointSolverContext& self) -> double {
+                return self.abs_tol.value();
+            },
+            [](gridfire::solver::PointSolverContext& self, double abs_tol) -> void {
+                self.abs_tol = abs_tol;
+            }
+        )
+        .def_property(
+            "rel_tol",
+            [](const gridfire::solver::PointSolverContext& self) -> double {
+                return self.rel_tol.value();
+            },
+            [](gridfire::solver::PointSolverContext& self, double rel_tol) -> void {
+                self.rel_tol = rel_tol;
+            }
+        )
+        .def_property(
+            "stdout_logging",
+            [](const gridfire::solver::PointSolverContext& self) -> bool {
+                return self.stdout_logging;
+            },
+            [](gridfire::solver::PointSolverContext& self, const bool enable) -> void {
+                self.stdout_logging = enable;
+            }
+        )
+        .def_property(
+            "detailed_logging",
+            [](const gridfire::solver::PointSolverContext& self) -> bool {
+                return self.detailed_step_logging;
+            },
+            [](gridfire::solver::PointSolverContext& self, const bool enable) -> void {
+                self.detailed_step_logging = enable;
+            }
+        )
+        .def_property(
+            "callback",
+            [](const gridfire::solver::PointSolverContext& self) -> std::optional<std::function<void(const gridfire::solver::PointSolverTimestepContext&)>> {
+                return self.callback;
+            },
+            [](gridfire::solver::PointSolverContext& self, const std::optional<std::function<void(const gridfire::solver::PointSolverTimestepContext&)>>& cb) {
+                self.callback = cb;
+            }
+        )
+        .def("reset_all", &gridfire::solver::PointSolverContext::reset_all)
+        .def("reset_user", &gridfire::solver::PointSolverContext::reset_user)
+        .def("reset_cvode", &gridfire::solver::PointSolverContext::reset_cvode)
+        .def("clear_context", &gridfire::solver::PointSolverContext::clear_context)
+        .def("init_context", &gridfire::solver::PointSolverContext::init_context)
+        .def("has_context", &gridfire::solver::PointSolverContext::has_context)
+        .def("init", &gridfire::solver::PointSolverContext::init)
+        .def(py::init<const gridfire::engine::scratch::StateBlob&>(), py::arg("engine_ctx"));
+
+
+
+    auto py_single_zone_dynamic_network_solver = py::class_<gridfire::solver::SingleZoneDynamicNetworkSolver, PySingleZoneDynamicNetworkSolver>(m, "SingleZoneDynamicNetworkSolver");
+    py_single_zone_dynamic_network_solver.def(
         "evaluate",
-        &gridfire::solver::DynamicNetworkSolverStrategy::evaluate,
+        &gridfire::solver::SingleZoneDynamicNetworkSolver::evaluate,
+        py::arg("solver_ctx"),
         py::arg("netIn"),
-        "evaluate the dynamic engine using the dynamic engine class"
+        "evaluate the dynamic engine using the dynamic engine class for a single zone"
+    );
+    auto py_multi_zone_dynamic_network_solver = py::class_<gridfire::solver::MultiZoneDynamicNetworkSolver, PyMultiZoneDynamicNetworkSolver>(m, "MultiZoneDynamicNetworkSolver");
+    py_multi_zone_dynamic_network_solver.def(
+        "evaluate",
+        &gridfire::solver::MultiZoneDynamicNetworkSolver::evaluate,
+        py::arg("solver_ctx"),
+        py::arg("netIns"),
+        "evaluate the dynamic engine using the dynamic engine class for multiple zones (using openmp if available)"
     );
 
+    auto py_point_solver = py::class_<gridfire::solver::PointSolver, gridfire::solver::SingleZoneDynamicNetworkSolver>(m, "PointSolver");
 
-    py_dynamic_network_solver_strategy.def(
-        "describe_callback_context",
-        &gridfire::solver::DynamicNetworkSolverStrategy::describe_callback_context,
-        "Get a structure representing what data is in the callback context in a human readable format"
-    );
-
-    auto py_cvode_solver_strategy = py::class_<gridfire::solver::CVODESolverStrategy, gridfire::solver::DynamicNetworkSolverStrategy>(m, "CVODESolverStrategy");
-
-    py_cvode_solver_strategy.def(
+    py_point_solver.def(
         py::init<gridfire::engine::DynamicEngine&>(),
         py::arg("engine"),
-        "Initialize the CVODESolverStrategy object."
+        "Initialize the PointSolver object."
     );
 
-    py_cvode_solver_strategy.def(
+    py_point_solver.def(
         "evaluate",
-        py::overload_cast<const gridfire::NetIn&, bool>(&gridfire::solver::CVODESolverStrategy::evaluate),
+        py::overload_cast<gridfire::solver::SolverContextBase&, const gridfire::NetIn&, bool, bool>(&gridfire::solver::PointSolver::evaluate, py::const_),
+        py::arg("solver_ctx"),
         py::arg("netIn"),
         py::arg("display_trigger") = false,
+        py::arg("force_reinitialization") = false,
         "evaluate the dynamic engine using the dynamic engine class"
     );
 
-    py_cvode_solver_strategy.def(
-        "get_stdout_logging_enabled",
-        &gridfire::solver::CVODESolverStrategy::get_stdout_logging_enabled,
-        "Check if solver logging to standard output is enabled."
+    auto py_grid_solver_context = py::class_<gridfire::solver::GridSolverContext, gridfire::solver::SolverContextBase>(m, "GridSolverContext");
+    py_grid_solver_context.def(py::init<const gridfire::engine::scratch::StateBlob&>(), py::arg("ctx_template"));
+    py_grid_solver_context.def("init", &gridfire::solver::GridSolverContext::init);
+    py_grid_solver_context.def("reset", &gridfire::solver::GridSolverContext::reset);
+    py_grid_solver_context.def("set_callback", py::overload_cast<const std::function<void(const gridfire::solver::TimestepContextBase&)>&>(&gridfire::solver::GridSolverContext::set_callback) , py::arg("callback"));
+    py_grid_solver_context.def("set_callback", py::overload_cast<const std::function<void(const gridfire::solver::TimestepContextBase&)>&, size_t>(&gridfire::solver::GridSolverContext::set_callback) , py::arg("callback"), py::arg("zone_idx"));
+    py_grid_solver_context.def("clear_callback", py::overload_cast<>(&gridfire::solver::GridSolverContext::clear_callback));
+    py_grid_solver_context.def("clear_callback", py::overload_cast<size_t>(&gridfire::solver::GridSolverContext::clear_callback), py::arg("zone_idx"));
+    py_grid_solver_context.def_property(
+        "stdout_logging",
+        [](const gridfire::solver::GridSolverContext& self) -> bool {
+            return self.zone_stdout_logging;
+        },
+        [](gridfire::solver::GridSolverContext& self, const bool enable) -> void {
+            self.zone_stdout_logging = enable;
+        }
+    )
+    .def_property(
+        "detailed_logging",
+        [](const gridfire::solver::GridSolverContext& self) -> bool {
+            return self.zone_detailed_logging;
+        },
+        [](gridfire::solver::GridSolverContext& self, const bool enable) -> void {
+            self.zone_detailed_logging = enable;
+        }
+    )
+    .def_property(
+        "zone_completion_logging",
+        [](const gridfire::solver::GridSolverContext& self) -> bool {
+            return self.zone_completion_logging;
+        },
+        [](gridfire::solver::GridSolverContext& self, const bool enable) -> void {
+            self.zone_completion_logging = enable;
+        }
     );
 
-    py_cvode_solver_strategy.def(
-        "set_stdout_logging_enabled",
-        &gridfire::solver::CVODESolverStrategy::set_stdout_logging_enabled,
-        py::arg("logging_enabled"),
-        "Enable logging to standard output."
+    auto py_grid_solver = py::class_<gridfire::solver::GridSolver, gridfire::solver::MultiZoneDynamicNetworkSolver>(m, "GridSolver");
+    py_grid_solver.def(
+        py::init<const gridfire::engine::DynamicEngine&, const gridfire::solver::SingleZoneDynamicNetworkSolver&>(),
+        py::arg("engine"),
+        py::arg("solver"),
+        "Initialize the GridSolver object."
     );
 
-    py_cvode_solver_strategy.def(
-        "set_absTol",
-        &gridfire::solver::CVODESolverStrategy::set_absTol,
-        py::arg("absTol"),
-        "Set the absolute tolerance for the CVODE solver."
+    py_grid_solver.def(
+        "evaluate",
+        &gridfire::solver::GridSolver::evaluate,
+        py::arg("solver_ctx"),
+        py::arg("netIns"),
+        "evaluate the dynamic engine using the dynamic engine class"
     );
 
-    py_cvode_solver_strategy.def(
-        "set_relTol",
-        &gridfire::solver::CVODESolverStrategy::set_relTol,
-        py::arg("relTol"),
-        "Set the relative tolerance for the CVODE solver."
-    );
-
-    py_cvode_solver_strategy.def(
-        "get_absTol",
-        &gridfire::solver::CVODESolverStrategy::get_absTol,
-        "Get the absolute tolerance for the CVODE solver."
-    );
-
-    py_cvode_solver_strategy.def(
-        "get_relTol",
-        &gridfire::solver::CVODESolverStrategy::get_relTol,
-        "Get the relative tolerance for the CVODE solver."
-    );
-
-    py_cvode_solver_strategy.def(
-    "set_callback",
-    [](
-        gridfire::solver::CVODESolverStrategy& self,
-        std::function<void(const gridfire::solver::CVODESolverStrategy::TimestepContext&)> cb
-    ) {
-        self.set_callback(std::any(cb));
-    },
-    py::arg("cb"),
-    "Set a callback function which will run at the end of every successful timestep"
-    );
 }
 

src/python/solver/meson.build

@@ -1,17 +0,0 @@
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_solver',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/solver/trampoline/meson.build

@@ -1,21 +0,0 @@
-gf_solver_trampoline_sources = files('py_solver.cpp')
-
-gf_solver_trapoline_dependencies = [
-    gridfire_dep,
-    pybind11_dep,
-    python3_dep,
-]
-
-gf_solver_trampoline_lib = static_library(
-    'solver_trampolines',
-    gf_solver_trampoline_sources,
-    include_directories: include_directories('.'),
-    dependencies: gf_solver_trapoline_dependencies,
-    install: false,
-)
-
-gr_solver_trampoline_dep = declare_dependency(
-    link_with: gf_solver_trampoline_lib,
-    include_directories: ('.'),
-    dependencies: gf_solver_trapoline_dependencies,
-)

src/python/solver/trampoline/py_solver.cpp

@@ -13,38 +13,63 @@
 
 namespace py = pybind11;
 
-gridfire::NetOut PyDynamicNetworkSolverStrategy::evaluate(const gridfire::NetIn &netIn) {
+gridfire::NetOut PySingleZoneDynamicNetworkSolver::evaluate(
+    gridfire::solver::SolverContextBase &solver_ctx,
+    const gridfire::NetIn &netIn
+) const {
     PYBIND11_OVERRIDE_PURE(
-        gridfire::NetOut,  // Return type
-        gridfire::solver::DynamicNetworkSolverStrategy,  // Base class
-        evaluate,  // Method name
-        netIn  // Arguments
+        gridfire::NetOut,
+        gridfire::solver::SingleZoneDynamicNetworkSolver,
+        evaluate,
+        solver_ctx,
+        netIn
     );
 }
 
-void PyDynamicNetworkSolverStrategy::set_callback(const std::any &callback) {
+std::vector<gridfire::NetOut> PyMultiZoneDynamicNetworkSolver::evaluate(
+    gridfire::solver::SolverContextBase &solver_ctx,
+    const std::vector<gridfire::NetIn> &netIns
+) const {
     PYBIND11_OVERRIDE_PURE(
-        void,
-        gridfire::solver::DynamicNetworkSolverStrategy,  // Base class
-        set_callback,  // Method name
-        callback  // Arguments
+        std::vector<gridfire::NetOut>,
+        gridfire::solver::MultiZoneDynamicNetworkSolver,
+        evaluate,
+        solver_ctx,
+        netIns
     );
 }
 
-std::vector<std::tuple<std::string, std::string>> PyDynamicNetworkSolverStrategy::describe_callback_context() const {
-    using DescriptionVector = std::vector<std::tuple<std::string, std::string>>;
+std::vector<std::tuple<std::string, std::string>> PyTimestepContextBase::describe() const {
+    using ReturnType = std::vector<std::tuple<std::string, std::string>>;
     PYBIND11_OVERRIDE_PURE(
-        DescriptionVector,  // Return type
-        gridfire::solver::DynamicNetworkSolverStrategy,  // Base class
-        describe_callback_context  // Method name
-    );
-}
-
-std::vector<std::tuple<std::string, std::string>> PySolverContextBase::describe() const {
-    using DescriptionVector = std::vector<std::tuple<std::string, std::string>>;
-    PYBIND11_OVERRIDE_PURE(
-        DescriptionVector,
-        gridfire::solver::SolverContextBase,
+        ReturnType,
+        gridfire::solver::TimestepContextBase,
         describe
     );
 }
+
+void PySolverContextBase::init() {
+    PYBIND11_OVERRIDE_PURE(
+        void,
+        gridfire::solver::SolverContextBase,
+        init
+    );
+}
+
+void PySolverContextBase::set_stdout_logging(bool enable) {
+    PYBIND11_OVERRIDE_PURE(
+        void,
+        gridfire::solver::SolverContextBase,
+        set_stdout_logging,
+        enable
+    );
+}
+
+void PySolverContextBase::set_detailed_logging(bool enable) {
+    PYBIND11_OVERRIDE_PURE(
+        void,
+        gridfire::solver::SolverContextBase,
+        set_detailed_logging,
+        enable
+    );
+}

src/python/solver/trampoline/py_solver.h

@@ -7,14 +7,37 @@
 #include <string>
 #include <any>
 
-class PyDynamicNetworkSolverStrategy final : public gridfire::solver::DynamicNetworkSolverStrategy {
-    explicit PyDynamicNetworkSolverStrategy(gridfire::engine::DynamicEngine &engine) : gridfire::solver::DynamicNetworkSolverStrategy(engine) {}
-    gridfire::NetOut evaluate(const gridfire::NetIn &netIn) override;
-    void set_callback(const std::any &callback) override;
-    [[nodiscard]] std::vector<std::tuple<std::string, std::string>> describe_callback_context() const override;
+class PySingleZoneDynamicNetworkSolver final : public gridfire::solver::SingleZoneDynamicNetworkSolver {
+public:
+    explicit PySingleZoneDynamicNetworkSolver(const gridfire::engine::DynamicEngine &engine) : gridfire::solver::SingleZoneDynamicNetworkSolver(engine) {}
+
+    gridfire::NetOut evaluate(
+        gridfire::solver::SolverContextBase &solver_ctx,
+        const gridfire::NetIn &netIn
+    ) const override;
+};
+
+class PyMultiZoneDynamicNetworkSolver final : public gridfire::solver::MultiZoneDynamicNetworkSolver {
+public:
+    explicit PyMultiZoneDynamicNetworkSolver(
+        const gridfire::engine::DynamicEngine &engine,
+        const gridfire::solver::SingleZoneDynamicNetworkSolver &local_solver
+    ) : gridfire::solver::MultiZoneDynamicNetworkSolver(engine, local_solver) {}
+
+    std::vector<gridfire::NetOut> evaluate(
+        gridfire::solver::SolverContextBase &solver_ctx,
+        const std::vector<gridfire::NetIn> &netIns
+    ) const override;
+};
+
+class PyTimestepContextBase final : public gridfire::solver::TimestepContextBase {
+public:
+    [[nodiscard]] std::vector<std::tuple<std::string, std::string>> describe() const override;
 };
 
 class PySolverContextBase final : public gridfire::solver::SolverContextBase {
 public:
-    [[nodiscard]] std::vector<std::tuple<std::string, std::string>> describe() const override;
-};
+    void init() override;
+    void set_stdout_logging(bool enable) override;
+    void set_detailed_logging(bool enable) override;
+};

src/python/types/meson.build

@@ -1,17 +0,0 @@
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_types',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

src/python/utils/bindings.cpp

@@ -12,6 +12,7 @@ namespace py = pybind11;
 void register_utils_bindings(py::module &m) {
     m.def("formatNuclearTimescaleLogString",
           &gridfire::utils::formatNuclearTimescaleLogString,
+          py::arg("ctx"),
           py::arg("engine"),
           py::arg("Y"),
           py::arg("T9"),

src/python/utils/meson.build

@@ -1,17 +0,0 @@
-# Define the library
-bindings_sources = files('bindings.cpp')
-bindings_headers = files('bindings.h')
-
-dependencies = [
-    gridfire_dep,
-    python3_dep,
-    pybind11_dep,
-]
-
-shared_module('py_gf_utils',
-              bindings_sources,
-              cpp_args: ['-fvisibility=default'],
-              install : true,
-              dependencies: dependencies,
-              include_directories: include_directories('.')
-)

stubs/gridfire/_gridfire/__init__.pyi

@@ -2,6 +2,7 @@
 Python bindings for the fourdst utility modules which are a part of the 4D-STAR project.
 """
 from __future__ import annotations
+from . import config
 from . import engine
 from . import exceptions
 from . import io
@@ -12,4 +13,4 @@ from . import screening
 from . import solver
 from . import type
 from . import utils
-__all__: list[str] = ['engine', 'exceptions', 'io', 'partition', 'policy', 'reaction', 'screening', 'solver', 'type', 'utils']
+__all__: list[str] = ['config', 'engine', 'exceptions', 'io', 'partition', 'policy', 'reaction', 'screening', 'solver', 'type', 'utils']

stubs/gridfire/_gridfire/config.pyi

@@ -0,0 +1,47 @@
+"""
+GridFire configuration bindings
+"""
+from __future__ import annotations
+import typing
+__all__: list[str] = ['AdaptiveEngineViewConfig', 'CVODESolverConfig', 'EngineConfig', 'EngineViewConfig', 'GridFireConfig', 'SolverConfig']
+class AdaptiveEngineViewConfig:
+    def __init__(self) -> None:
+        ...
+    @property
+    def relativeCullingThreshold(self) -> float:
+        ...
+    @relativeCullingThreshold.setter
+    def relativeCullingThreshold(self, arg0: typing.SupportsFloat) -> None:
+        ...
+class CVODESolverConfig:
+    def __init__(self) -> None:
+        ...
+    @property
+    def absTol(self) -> float:
+        ...
+    @absTol.setter
+    def absTol(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def relTol(self) -> float:
+        ...
+    @relTol.setter
+    def relTol(self, arg0: typing.SupportsFloat) -> None:
+        ...
+class EngineConfig:
+    views: EngineViewConfig
+    def __init__(self) -> None:
+        ...
+class EngineViewConfig:
+    adaptiveEngineView: AdaptiveEngineViewConfig
+    def __init__(self) -> None:
+        ...
+class GridFireConfig:
+    engine: EngineConfig
+    solver: SolverConfig
+    def __init__(self) -> None:
+        ...
+class SolverConfig:
+    cvode: CVODESolverConfig
+    def __init__(self) -> None:
+        ...

stubs/gridfire/_gridfire/engine/__init__.pyi

@@ -14,110 +14,81 @@ import numpy
 import numpy.typing
 import typing
 from . import diagnostics
-__all__: list[str] = ['ACTIVE', 'ADAPTIVE_ENGINE_VIEW', 'AdaptiveEngineView', 'BuildDepthType', 'DEFAULT', 'DEFINED_ENGINE_VIEW', 'DefinedEngineView', 'DynamicEngine', 'EQUILIBRIUM', 'Engine', 'EngineTypes', 'FILE_DEFINED_ENGINE_VIEW', 'FULL_SUCCESS', 'FifthOrder', 'FileDefinedEngineView', 'FourthOrder', 'Full', 'GRAPH_ENGINE', 'GraphEngine', 'INACTIVE_FLOW', 'MAX_ITERATIONS_REACHED', 'MULTISCALE_PARTITIONING_ENGINE_VIEW', 'MultiscalePartitioningEngineView', 'NONE', 'NOT_PRESENT', 'NO_SPECIES_TO_PRIME', 'NetworkBuildDepth', 'NetworkConstructionFlags', 'NetworkJacobian', 'NetworkPrimingEngineView', 'PRIMING_ENGINE_VIEW', 'PrimingReport', 'PrimingReportStatus', 'REACLIB', 'REACLIB_STRONG', 'REACLIB_WEAK', 'SecondOrder', 'Shallow', 'SparsityPattern', 'SpeciesStatus', 'StepDerivatives', 'ThirdOrder', 'WRL_BETA_MINUS', 'WRL_BETA_PLUS', 'WRL_ELECTRON_CAPTURE', 'WRL_POSITRON_CAPTURE', 'WRL_WEAK', 'build_nuclear_network', 'diagnostics', 'primeNetwork', 'regularize_jacobian']
+from . import scratchpads
+__all__: list[str] = ['ACTIVE', 'ADAPTIVE_ENGINE_VIEW', 'AdaptiveEngineView', 'BuildDepthType', 'DEFAULT', 'DEFINED_ENGINE_VIEW', 'DefinedEngineView', 'DynamicEngine', 'EQUILIBRIUM', 'Engine', 'EngineTypes', 'FILE_DEFINED_ENGINE_VIEW', 'FULL_SUCCESS', 'FifthOrder', 'FileDefinedEngineView', 'FourthOrder', 'Full', 'GRAPH_ENGINE', 'GraphEngine', 'INACTIVE_FLOW', 'MAX_ITERATIONS_REACHED', 'MULTISCALE_PARTITIONING_ENGINE_VIEW', 'MultiscalePartitioningEngineView', 'NONE', 'NOT_PRESENT', 'NO_SPECIES_TO_PRIME', 'NetworkBuildDepth', 'NetworkConstructionFlags', 'NetworkJacobian', 'NetworkPrimingEngineView', 'PRIMING_ENGINE_VIEW', 'PrimingReport', 'PrimingReportStatus', 'REACLIB', 'REACLIB_STRONG', 'REACLIB_WEAK', 'SecondOrder', 'Shallow', 'SparsityPattern', 'SpeciesStatus', 'StepDerivatives', 'ThirdOrder', 'WRL_BETA_MINUS', 'WRL_BETA_PLUS', 'WRL_ELECTRON_CAPTURE', 'WRL_POSITRON_CAPTURE', 'WRL_WEAK', 'build_nuclear_network', 'diagnostics', 'primeNetwork', 'regularize_jacobian', 'scratchpads']
 class AdaptiveEngineView(DynamicEngine):
     def __init__(self, baseEngine: DynamicEngine) -> None:
         """
         Construct an adaptive engine view with a base engine.
         """
-    def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
         """
         Calculate deps/dT and deps/drho
         """
-    def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
         """
         Calculate the molar reaction flow for a given reaction.
         """
-    def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
         """
         Calculate the right-hand side (dY/dt) and energy generation rate.
         """
-    def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
         """
         Recursively collect composition from current engine and any sub engines if they exist.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
         """
         Generate the Jacobian matrix for the current state.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
         """
         Generate the jacobian matrix only for the subset of the matrix representing the active species.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
         """
         Generate the jacobian matrix for the given sparsity pattern
         """
-    def generateStoichiometryMatrix(self) -> None:
-        ...
     def getBaseEngine(self) -> DynamicEngine:
         """
         Get the base engine associated with this adaptive engine view.
         """
-    def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
-        """
-        Get the current build depth of the engine.
-        """
-    def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
         """
         Get the set of logical reactions in the network.
         """
-    def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of species in the network.
         """
-    def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
         """
         Get the current screening model of the engine.
         """
-    def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the destruction timescales for each species in the network.
         """
-    def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
         """
         Get the index of a species in the network.
         """
-    def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
         """
         Get the status of a species in the network.
         """
-    def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the timescales for each species in the network.
         """
-    def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
-        """
-        Get an entry from the stoichiometry matrix.
-        """
-    def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
-        """
-        Check if the engine is stale based on the provided NetIn object.
-        """
-    def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
-        """
-        Map a NetIn object to a vector of molar abundances.
-        """
-    def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
         """
         Prime the engine with a NetIn object to prepare for calculations.
         """
-    def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
-        """
-        Rebuild the engine with a new composition and build depth.
-        """
-    def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
-        """
-        Set the network reactions to a new set of reactions.
-        """
-    def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
-        """
-        Set the screening model for the engine.
-        """
-    def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
         """
         Update the engine state based on the provided NetIn object.
         """
@@ -128,104 +99,74 @@ class DefinedEngineView(DynamicEngine):
         """
         Construct a defined engine view with a list of tracked reactions and a base engine.
         """
-    def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
         """
         Calculate deps/dT and deps/drho
         """
-    def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
         """
         Calculate the molar reaction flow for a given reaction.
         """
-    def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
         """
         Calculate the right-hand side (dY/dt) and energy generation rate.
         """
-    def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
         """
         Recursively collect composition from current engine and any sub engines if they exist.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
         """
         Generate the Jacobian matrix for the current state.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
         """
         Generate the jacobian matrix only for the subset of the matrix representing the active species.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
         """
         Generate the jacobian matrix for the given sparsity pattern
         """
-    def generateStoichiometryMatrix(self) -> None:
-        ...
     def getBaseEngine(self) -> DynamicEngine:
         """
         Get the base engine associated with this defined engine view.
         """
-    def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
-        """
-        Get the current build depth of the engine.
-        """
-    def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
         """
         Get the set of logical reactions in the network.
         """
-    def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of species in the network.
         """
-    def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
         """
         Get the current screening model of the engine.
         """
-    def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the destruction timescales for each species in the network.
         """
-    def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
         """
         Get the index of a species in the network.
         """
-    def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
         """
         Get the status of a species in the network.
         """
-    def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the timescales for each species in the network.
         """
-    def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
-        """
-        Get an entry from the stoichiometry matrix.
-        """
-    def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
-        """
-        Check if the engine is stale based on the provided NetIn object.
-        """
-    def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
-        """
-        Map a NetIn object to a vector of molar abundances.
-        """
-    def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
         """
         Prime the engine with a NetIn object to prepare for calculations.
         """
-    def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
-        """
-        Rebuild the engine with a new composition and build depth.
-        """
-    def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
-        """
-        Set the network reactions to a new set of reactions.
-        """
-    def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
-        """
-        Set the screening model for the engine.
-        """
-    def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
         """
         Update the engine state based on the provided NetIn object.
         """
@@ -293,56 +234,50 @@ class FileDefinedEngineView(DefinedEngineView):
         """
         Construct a defined engine view from a file and a base engine.
         """
-    def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
         """
         Calculate deps/dT and deps/drho
         """
-    def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
         """
         Calculate the molar reaction flow for a given reaction.
         """
-    def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
         """
         Calculate the right-hand side (dY/dt) and energy generation rate.
         """
-    def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
         """
         Recursively collect composition from current engine and any sub engines if they exist.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
         """
         Generate the Jacobian matrix for the current state.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
         """
         Generate the jacobian matrix only for the subset of the matrix representing the active species.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
         """
         Generate the jacobian matrix for the given sparsity pattern
         """
-    def generateStoichiometryMatrix(self) -> None:
-        ...
     def getBaseEngine(self) -> DynamicEngine:
         """
         Get the base engine associated with this file defined engine view.
         """
-    def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
-        """
-        Get the current build depth of the engine.
-        """
     def getNetworkFile(self) -> str:
         """
         Get the network file associated with this defined engine view.
         """
-    def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
         """
         Get the set of logical reactions in the network.
         """
-    def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of species in the network.
         """
@@ -350,64 +285,35 @@ class FileDefinedEngineView(DefinedEngineView):
         """
         Get the parser used for this defined engine view.
         """
-    def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
         """
         Get the current screening model of the engine.
         """
-    def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the destruction timescales for each species in the network.
         """
-    def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
         """
         Get the index of a species in the network.
         """
-    def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
         """
         Get the status of a species in the network.
         """
-    def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the timescales for each species in the network.
         """
-    def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
-        """
-        Get an entry from the stoichiometry matrix.
-        """
-    def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
-        """
-        Check if the engine is stale based on the provided NetIn object.
-        """
-    def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
-        """
-        Map a NetIn object to a vector of molar abundances.
-        """
-    def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
         """
         Prime the engine with a NetIn object to prepare for calculations.
         """
-    def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
-        """
-        Rebuild the engine with a new composition and build depth.
-        """
-    def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
-        """
-        Set the network reactions to a new set of reactions.
-        """
-    def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
-        """
-        Set the screening model for the engine.
-        """
-    def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
         """
         Update the engine state based on the provided NetIn object.
         """
 class GraphEngine(DynamicEngine):
-    @staticmethod
-    def getNetReactionStoichiometry(reaction: ...) -> dict[fourdst._phys.atomic.Species, int]:
-        """
-        Get the net stoichiometry for a given reaction.
-        """
     @typing.overload
     def __init__(self, composition: fourdst._phys.composition.Composition, depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
         """
@@ -423,15 +329,15 @@ class GraphEngine(DynamicEngine):
         """
         Initialize GraphEngine with a set of reactions.
         """
-    def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
         """
         Calculate deps/dT and deps/drho
         """
-    def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
         """
         Calculate the molar reaction flow for a given reaction.
         """
-    def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
         """
         Calculate the right-hand side (dY/dt) and energy generation rate.
         """
@@ -447,128 +353,90 @@ class GraphEngine(DynamicEngine):
         """
         Calculate the derivative of the reverse rate for a two-body reaction at a specific temperature.
         """
-    def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
         """
         Recursively collect composition from current engine and any sub engines if they exist.
         """
-    def exportToCSV(self, filename: str) -> None:
+    def exportToCSV(self, ctx: scratchpads.StateBlob, filename: str) -> None:
         """
         Export the network to a CSV file for analysis.
         """
-    def exportToDot(self, filename: str) -> None:
+    def exportToDot(self, ctx: scratchpads.StateBlob, filename: str) -> None:
         """
         Export the network to a DOT file for visualization.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
         """
         Generate the Jacobian matrix for the current state.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
         """
         Generate the jacobian matrix only for the subset of the matrix representing the active species.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
         """
         Generate the jacobian matrix for the given sparsity pattern
         """
-    def generateStoichiometryMatrix(self) -> None:
-        ...
-    def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
-        """
-        Get the current build depth of the engine.
-        """
-    def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
         """
         Get the set of logical reactions in the network.
         """
-    def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of species in the network.
         """
-    def getPartitionFunction(self) -> gridfire._gridfire.partition.PartitionFunction:
+    def getPartitionFunction(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.partition.PartitionFunction:
         """
         Get the partition function used by the engine.
         """
-    def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
         """
         Get the current screening model of the engine.
         """
     @typing.overload
-    def getSpeciesDestructionTimescales(self, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
+    def getSpeciesDestructionTimescales(self, ctx: scratchpads.StateBlob, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
         ...
     @typing.overload
-    def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the destruction timescales for each species in the network.
         """
-    def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
         """
         Get the index of a species in the network.
         """
-    def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
         """
         Get the status of a species in the network.
         """
     @typing.overload
-    def getSpeciesTimescales(self, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
+    def getSpeciesTimescales(self, ctx: scratchpads.StateBlob, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
         ...
     @typing.overload
-    def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the timescales for each species in the network.
         """
-    def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
-        """
-        Get an entry from the stoichiometry matrix.
-        """
-    def involvesSpecies(self, species: fourdst._phys.atomic.Species) -> bool:
+    def involvesSpecies(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
         """
         Check if a given species is involved in the network.
         """
-    def isPrecomputationEnabled(self) -> bool:
+    def isPrecomputationEnabled(self, arg0: scratchpads.StateBlob) -> bool:
         """
         Check if precomputation is enabled for the engine.
         """
-    def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
-        """
-        Check if the engine is stale based on the provided NetIn object.
-        """
-    def isUsingReverseReactions(self) -> bool:
+    def isUsingReverseReactions(self, arg0: scratchpads.StateBlob) -> bool:
         """
         Check if the engine is using reverse reactions.
         """
-    def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
-        """
-        Map a NetIn object to a vector of molar abundances.
-        """
-    def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
         """
         Prime the engine with a NetIn object to prepare for calculations.
         """
-    def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
-        """
-        Rebuild the engine with a new composition and build depth.
-        """
-    def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
-        """
-        Set the network reactions to a new set of reactions.
-        """
-    def setPrecomputation(self, precompute: bool) -> None:
-        """
-        Enable or disable precomputation for the engine.
-        """
-    def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
-        """
-        Set the screening model for the engine.
-        """
-    def setUseReverseReactions(self, useReverse: bool) -> None:
-        """
-        Enable or disable the use of reverse reactions in the engine.
-        """
-    def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
         """
         Update the engine state based on the provided NetIn object.
         """
@@ -577,142 +445,106 @@ class MultiscalePartitioningEngineView(DynamicEngine):
         """
         Construct a multiscale partitioning engine view with a base engine.
         """
-    def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
         """
         Calculate deps/dT and deps/drho
         """
-    def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
         """
         Calculate the molar reaction flow for a given reaction.
         """
-    def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
         """
         Calculate the right-hand side (dY/dt) and energy generation rate.
         """
-    def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
         """
         Recursively collect composition from current engine and any sub engines if they exist.
         """
-    def exportToDot(self, filename: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> None:
+    def exportToDot(self, ctx: scratchpads.StateBlob, filename: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> None:
         """
         Export the network to a DOT file for visualization.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
         """
         Generate the Jacobian matrix for the current state.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
         """
         Generate the jacobian matrix only for the subset of the matrix representing the active species.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
         """
         Generate the jacobian matrix for the given sparsity pattern
         """
-    def generateStoichiometryMatrix(self) -> None:
-        ...
     def getBaseEngine(self) -> DynamicEngine:
         """
         Get the base engine associated with this multiscale partitioning engine view.
         """
-    def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
-        """
-        Get the current build depth of the engine.
-        """
-    def getDynamicSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getDynamicSpecies(self: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of dynamic species in the network.
         """
-    def getFastSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getFastSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of fast species in the network.
         """
-    def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
         """
         Get the set of logical reactions in the network.
         """
-    def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of species in the network.
         """
-    def getNormalizedEquilibratedComposition(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+    def getNormalizedEquilibratedComposition(self, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
         """
         Get the normalized equilibrated composition for the algebraic species.
         """
-    def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
         """
         Get the current screening model of the engine.
         """
-    def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the destruction timescales for each species in the network.
         """
-    def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
         """
         Get the index of a species in the network.
         """
-    def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
         """
         Get the status of a species in the network.
         """
-    def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the timescales for each species in the network.
         """
-    def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
-        """
-        Get an entry from the stoichiometry matrix.
-        """
-    def involvesSpecies(self, species: fourdst._phys.atomic.Species) -> bool:
+    def involvesSpecies(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
         """
         Check if a given species is involved in the network (in either the algebraic or dynamic set).
         """
-    def involvesSpeciesInDynamic(self, species: fourdst._phys.atomic.Species) -> bool:
+    def involvesSpeciesInDynamic(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
         """
         Check if a given species is involved in the network's dynamic set.
         """
-    def involvesSpeciesInQSE(self, species: fourdst._phys.atomic.Species) -> bool:
+    def involvesSpeciesInQSE(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
         """
         Check if a given species is involved in the network's algebraic set.
         """
-    def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
-        """
-        Check if the engine is stale based on the provided NetIn object.
-        """
-    def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
-        """
-        Map a NetIn object to a vector of molar abundances.
-        """
-    @typing.overload
-    def partitionNetwork(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+    def partitionNetwork(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
         """
         Partition the network based on species timescales and connectivity.
         """
-    @typing.overload
-    def partitionNetwork(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
-        """
-        Partition the network based on a NetIn object.
-        """
-    def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
         """
         Prime the engine with a NetIn object to prepare for calculations.
         """
-    def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
-        """
-        Rebuild the engine with a new composition and build depth.
-        """
-    def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
-        """
-        Set the network reactions to a new set of reactions.
-        """
-    def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
-        """
-        Set the screening model for the engine.
-        """
-    def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
         """
         Update the engine state based on the provided NetIn object.
         """
@@ -893,113 +725,83 @@ class NetworkJacobian:
         """
 class NetworkPrimingEngineView(DefinedEngineView):
     @typing.overload
-    def __init__(self, primingSymbol: str, baseEngine: GraphEngine) -> None:
+    def __init__(self, ctx: scratchpads.StateBlob, primingSymbol: str, baseEngine: GraphEngine) -> None:
         """
         Construct a priming engine view with a priming symbol and a base engine.
         """
     @typing.overload
-    def __init__(self, primingSpecies: fourdst._phys.atomic.Species, baseEngine: GraphEngine) -> None:
+    def __init__(self, ctx: scratchpads.StateBlob, primingSpecies: fourdst._phys.atomic.Species, baseEngine: GraphEngine) -> None:
         """
         Construct a priming engine view with a priming species and a base engine.
         """
-    def calculateEpsDerivatives(self, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
         """
         Calculate deps/dT and deps/drho
         """
-    def calculateMolarReactionFlow(self: DynamicEngine, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
         """
         Calculate the molar reaction flow for a given reaction.
         """
-    def calculateRHSAndEnergy(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
         """
         Calculate the right-hand side (dY/dt) and energy generation rate.
         """
-    def collectComposition(self, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
         """
         Recursively collect composition from current engine and any sub engines if they exist.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
         """
         Generate the Jacobian matrix for the current state.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
         """
         Generate the jacobian matrix only for the subset of the matrix representing the active species.
         """
     @typing.overload
-    def generateJacobianMatrix(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
         """
         Generate the jacobian matrix for the given sparsity pattern
         """
-    def generateStoichiometryMatrix(self) -> None:
-        ...
     def getBaseEngine(self) -> DynamicEngine:
         """
         Get the base engine associated with this priming engine view.
         """
-    def getDepth(self) -> gridfire._gridfire.engine.NetworkBuildDepth | int:
-        """
-        Get the current build depth of the engine.
-        """
-    def getNetworkReactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
         """
         Get the set of logical reactions in the network.
         """
-    def getNetworkSpecies(self) -> list[fourdst._phys.atomic.Species]:
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
         """
         Get the list of species in the network.
         """
-    def getScreeningModel(self) -> gridfire._gridfire.screening.ScreeningType:
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
         """
         Get the current screening model of the engine.
         """
-    def getSpeciesDestructionTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the destruction timescales for each species in the network.
         """
-    def getSpeciesIndex(self, species: fourdst._phys.atomic.Species) -> int:
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
         """
         Get the index of a species in the network.
         """
-    def getSpeciesStatus(self, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
         """
         Get the status of a species in the network.
         """
-    def getSpeciesTimescales(self: DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
         """
         Get the timescales for each species in the network.
         """
-    def getStoichiometryMatrixEntry(self, species: fourdst._phys.atomic.Species, reaction: ...) -> int:
-        """
-        Get an entry from the stoichiometry matrix.
-        """
-    def isStale(self, netIn: gridfire._gridfire.type.NetIn) -> bool:
-        """
-        Check if the engine is stale based on the provided NetIn object.
-        """
-    def mapNetInToMolarAbundanceVector(self, netIn: gridfire._gridfire.type.NetIn) -> list[float]:
-        """
-        Map a NetIn object to a vector of molar abundances.
-        """
-    def primeEngine(self, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
         """
         Prime the engine with a NetIn object to prepare for calculations.
         """
-    def rebuild(self, composition: ..., depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
-        """
-        Rebuild the engine with a new composition and build depth.
-        """
-    def setNetworkReactions(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
-        """
-        Set the network reactions to a new set of reactions.
-        """
-    def setScreeningModel(self, screeningModel: gridfire._gridfire.screening.ScreeningType) -> None:
-        """
-        Set the screening model for the engine.
-        """
-    def update(self, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
         """
         Update the engine state based on the provided NetIn object.
         """
@@ -1131,7 +933,7 @@ def build_nuclear_network(composition: ..., weakInterpolator: ..., maxLayers: gr
     """
     Build a nuclear network from a composition using all archived reaction data.
     """
-def primeNetwork(netIn: gridfire._gridfire.type.NetIn, engine: ..., ignoredReactionTypes: collections.abc.Sequence[...] | None = None) -> PrimingReport:
+def primeNetwork(ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn, engine: ..., ignoredReactionTypes: collections.abc.Sequence[...] | None = None) -> PrimingReport:
     """
     Prime a network with a short timescale ignition
     """

stubs/gridfire/_gridfire/engine/diagnostics.pyi

@@ -5,11 +5,12 @@ from __future__ import annotations
 import collections.abc
 import fourdst._phys.composition
 import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
 import typing
 __all__: list[str] = ['inspect_jacobian_stiffness', 'inspect_species_balance', 'report_limiting_species']
-def inspect_jacobian_stiffness(engine: gridfire._gridfire.engine.DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
+def inspect_jacobian_stiffness(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
     ...
-def inspect_species_balance(engine: gridfire._gridfire.engine.DynamicEngine, species_name: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
+def inspect_species_balance(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, species_name: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
     ...
-def report_limiting_species(engine: gridfire._gridfire.engine.DynamicEngine, Y_full: collections.abc.Sequence[typing.SupportsFloat], E_full: collections.abc.Sequence[typing.SupportsFloat], relTol: typing.SupportsFloat, absTol: typing.SupportsFloat, top_n: typing.SupportsInt, json: bool) -> ... | None:
+def report_limiting_species(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, Y_full: collections.abc.Sequence[typing.SupportsFloat], E_full: collections.abc.Sequence[typing.SupportsFloat], relTol: typing.SupportsFloat, absTol: typing.SupportsFloat, top_n: typing.SupportsInt, json: bool) -> ... | None:
     ...

stubs/gridfire/_gridfire/engine/scratchpads.pyi

@@ -0,0 +1,267 @@
+"""
+Engine ScratchPad bindings
+"""
+from __future__ import annotations
+import fourdst._phys.atomic
+import fourdst._phys.composition
+import gridfire._gridfire.reaction
+import typing
+__all__: list[str] = ['ADAPTIVE_ENGINE_VIEW_SCRATCHPAD', 'ADFunRegistrationResult', 'ALREADY_REGISTERED', 'AdaptiveEngineViewScratchPad', 'DEFINED_ENGINE_VIEW_SCRATCHPAD', 'DefinedEngineViewScratchPad', 'GRAPH_ENGINE_SCRATCHPAD', 'GraphEngineScratchPad', 'MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD', 'MultiscalePartitioningEngineViewScratchPad', 'SCRATCHPAD_BAD_CAST', 'SCRATCHPAD_NOT_FOUND', 'SCRATCHPAD_NOT_INITIALIZED', 'SCRATCHPAD_OUT_OF_BOUNDS', 'SCRATCHPAD_TYPE_COLLISION', 'SCRATCHPAD_UNKNOWN_ERROR', 'SUCCESS', 'ScratchPadType', 'StateBlob', 'StateBlobError']
+class ADFunRegistrationResult:
+    """
+    Members:
+    
+      SUCCESS
+    
+      ALREADY_REGISTERED
+    """
+    ALREADY_REGISTERED: typing.ClassVar[ADFunRegistrationResult]  # value = <ADFunRegistrationResult.ALREADY_REGISTERED: 1>
+    SUCCESS: typing.ClassVar[ADFunRegistrationResult]  # value = <ADFunRegistrationResult.SUCCESS: 0>
+    __members__: typing.ClassVar[dict[str, ADFunRegistrationResult]]  # value = {'SUCCESS': <ADFunRegistrationResult.SUCCESS: 0>, 'ALREADY_REGISTERED': <ADFunRegistrationResult.ALREADY_REGISTERED: 1>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class AdaptiveEngineViewScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def initialize(self, arg0: ...) -> None:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def active_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        ...
+    @property
+    def active_species(self) -> list[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+class DefinedEngineViewScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def active_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        ...
+    @property
+    def active_species(self) -> set[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+    @property
+    def reaction_index_map(self) -> list[int]:
+        ...
+    @property
+    def species_index_map(self) -> list[int]:
+        ...
+class GraphEngineScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def initialize(self, engine: ...) -> None:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+    @property
+    def local_abundance_cache(self) -> list[float]:
+        ...
+    @property
+    def most_recent_rhs_calculation(self) -> ... | None:
+        ...
+    @property
+    def stepDerivativesCache(self) -> dict[int, ...]:
+        ...
+class MultiscalePartitioningEngineViewScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def initialize(self) -> None:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def algebraic_species(self) -> list[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def composition_cache(self) -> dict[int, fourdst._phys.composition.Composition]:
+        ...
+    @property
+    def dynamic_species(self) -> list[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+    @property
+    def qse_groups(self) -> list[...]:
+        ...
+class ScratchPadType:
+    """
+    Members:
+    
+      GRAPH_ENGINE_SCRATCHPAD
+    
+      MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD
+    
+      ADAPTIVE_ENGINE_VIEW_SCRATCHPAD
+    
+      DEFINED_ENGINE_VIEW_SCRATCHPAD
+    """
+    ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
+    DEFINED_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
+    GRAPH_ENGINE_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
+    MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
+    __members__: typing.ClassVar[dict[str, ScratchPadType]]  # value = {'GRAPH_ENGINE_SCRATCHPAD': <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>, 'MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>, 'ADAPTIVE_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>, 'DEFINED_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class StateBlob:
+    @staticmethod
+    def error_to_string(arg0: StateBlobError) -> str:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone_structure(self) -> StateBlob:
+        ...
+    def enroll(self, arg0: ScratchPadType) -> None:
+        ...
+    def get(self, arg0: ScratchPadType) -> ...:
+        ...
+    def get_registered_scratchpads(self) -> set[ScratchPadType]:
+        ...
+    def get_status(self, arg0: ScratchPadType) -> ...:
+        ...
+    def get_status_map(self) -> dict[ScratchPadType, ...]:
+        ...
+class StateBlobError:
+    """
+    Members:
+    
+      SCRATCHPAD_OUT_OF_BOUNDS
+    
+      SCRATCHPAD_NOT_FOUND
+    
+      SCRATCHPAD_BAD_CAST
+    
+      SCRATCHPAD_NOT_INITIALIZED
+    
+      SCRATCHPAD_TYPE_COLLISION
+    
+      SCRATCHPAD_UNKNOWN_ERROR
+    """
+    SCRATCHPAD_BAD_CAST: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_BAD_CAST: 1>
+    SCRATCHPAD_NOT_FOUND: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>
+    SCRATCHPAD_NOT_INITIALIZED: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>
+    SCRATCHPAD_OUT_OF_BOUNDS: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>
+    SCRATCHPAD_TYPE_COLLISION: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>
+    SCRATCHPAD_UNKNOWN_ERROR: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>
+    __members__: typing.ClassVar[dict[str, StateBlobError]]  # value = {'SCRATCHPAD_OUT_OF_BOUNDS': <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>, 'SCRATCHPAD_NOT_FOUND': <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>, 'SCRATCHPAD_BAD_CAST': <StateBlobError.SCRATCHPAD_BAD_CAST: 1>, 'SCRATCHPAD_NOT_INITIALIZED': <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>, 'SCRATCHPAD_TYPE_COLLISION': <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>, 'SCRATCHPAD_UNKNOWN_ERROR': <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
+ALREADY_REGISTERED: ADFunRegistrationResult  # value = <ADFunRegistrationResult.ALREADY_REGISTERED: 1>
+DEFINED_ENGINE_VIEW_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
+GRAPH_ENGINE_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
+MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
+SCRATCHPAD_BAD_CAST: StateBlobError  # value = <StateBlobError.SCRATCHPAD_BAD_CAST: 1>
+SCRATCHPAD_NOT_FOUND: StateBlobError  # value = <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>
+SCRATCHPAD_NOT_INITIALIZED: StateBlobError  # value = <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>
+SCRATCHPAD_OUT_OF_BOUNDS: StateBlobError  # value = <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>
+SCRATCHPAD_TYPE_COLLISION: StateBlobError  # value = <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>
+SCRATCHPAD_UNKNOWN_ERROR: StateBlobError  # value = <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>
+SUCCESS: ADFunRegistrationResult  # value = <ADFunRegistrationResult.SUCCESS: 0>

stubs/gridfire/_gridfire/exceptions.pyi

@@ -2,7 +2,7 @@
 GridFire exceptions bindings
 """
 from __future__ import annotations
-__all__: list[str] = ['BadCollectionError', 'BadRHSEngineError', 'CVODESolverFailureError', 'DebugException', 'EngineError', 'FailedToPartitionEngineError', 'GridFireError', 'HashingError', 'IllConditionedJacobianError', 'InvalidQSESolutionError', 'JacobianError', 'KINSolSolverFailureError', 'MissingBaseReactionError', 'MissingKeyReactionError', 'MissingSeedSpeciesError', 'NetworkResizedError', 'PolicyError', 'ReactionError', 'ReactionParsingError', 'SUNDIALSError', 'SingularJacobianError', 'SolverError', 'StaleJacobianError', 'UnableToSetNetworkReactionsError', 'UninitializedJacobianError', 'UnknownJacobianError', 'UtilityError']
+__all__: list[str] = ['BadCollectionError', 'BadRHSEngineError', 'CVODESolverFailureError', 'DebugException', 'EngineError', 'FailedToPartitionEngineError', 'GridFireError', 'HashingError', 'IllConditionedJacobianError', 'InvalidQSESolutionError', 'JacobianError', 'KINSolSolverFailureError', 'MissingBaseReactionError', 'MissingKeyReactionError', 'MissingSeedSpeciesError', 'NetworkResizedError', 'PolicyError', 'ReactionError', 'ReactionParsingError', 'SUNDIALSError', 'ScratchPadError', 'SingularJacobianError', 'SolverError', 'StaleJacobianError', 'UnableToSetNetworkReactionsError', 'UninitializedJacobianError', 'UnknownJacobianError', 'UtilityError']
 class BadCollectionError(EngineError):
     pass
 class BadRHSEngineError(EngineError):
@@ -43,6 +43,8 @@ class ReactionParsingError(ReactionError):
     pass
 class SUNDIALSError(SolverError):
     pass
+class ScratchPadError(GridFireError):
+    pass
 class SingularJacobianError(SolverError):
     pass
 class SolverError(GridFireError):

stubs/gridfire/_gridfire/policy.pyi

@@ -6,9 +6,11 @@ import collections.abc
 import fourdst._phys.atomic
 import fourdst._phys.composition
 import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
+import gridfire._gridfire.partition
 import gridfire._gridfire.reaction
 import typing
-__all__: list[str] = ['CNOChainPolicy', 'CNOIChainPolicy', 'CNOIIChainPolicy', 'CNOIIIChainPolicy', 'CNOIVChainPolicy', 'HotCNOChainPolicy', 'HotCNOIChainPolicy', 'HotCNOIIChainPolicy', 'HotCNOIIIChainPolicy', 'INITIALIZED_UNVERIFIED', 'INITIALIZED_VERIFIED', 'MISSING_KEY_REACTION', 'MISSING_KEY_SPECIES', 'MainSequencePolicy', 'MainSequenceReactionChainPolicy', 'MultiReactionChainPolicy', 'NetworkPolicy', 'NetworkPolicyStatus', 'ProtonProtonChainPolicy', 'ProtonProtonIChainPolicy', 'ProtonProtonIIChainPolicy', 'ProtonProtonIIIChainPolicy', 'ReactionChainPolicy', 'TemperatureDependentChainPolicy', 'TripleAlphaChainPolicy', 'UNINITIALIZED']
+__all__: list[str] = ['CNOChainPolicy', 'CNOIChainPolicy', 'CNOIIChainPolicy', 'CNOIIIChainPolicy', 'CNOIVChainPolicy', 'ConstructionResults', 'HotCNOChainPolicy', 'HotCNOIChainPolicy', 'HotCNOIIChainPolicy', 'HotCNOIIIChainPolicy', 'INITIALIZED_UNVERIFIED', 'INITIALIZED_VERIFIED', 'MISSING_KEY_REACTION', 'MISSING_KEY_SPECIES', 'MainSequencePolicy', 'MainSequenceReactionChainPolicy', 'MultiReactionChainPolicy', 'NetworkPolicy', 'NetworkPolicyStatus', 'ProtonProtonChainPolicy', 'ProtonProtonIChainPolicy', 'ProtonProtonIIChainPolicy', 'ProtonProtonIIIChainPolicy', 'ReactionChainPolicy', 'TemperatureDependentChainPolicy', 'TripleAlphaChainPolicy', 'UNINITIALIZED', 'network_policy_status_to_string']
 class CNOChainPolicy(MultiReactionChainPolicy):
     def __eq__(self, other: ReactionChainPolicy) -> bool:
         """
@@ -224,6 +226,13 @@ class CNOIVChainPolicy(TemperatureDependentChainPolicy):
         """
         Get the name of the reaction chain policy.
         """
+class ConstructionResults:
+    @property
+    def engine(self) -> gridfire._gridfire.engine.DynamicEngine:
+        ...
+    @property
+    def scratch_blob(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
 class HotCNOChainPolicy(MultiReactionChainPolicy):
     def __eq__(self, other: ReactionChainPolicy) -> bool:
         """
@@ -407,14 +416,18 @@ class MainSequencePolicy(NetworkPolicy):
         """
         Construct MainSequencePolicy from seed species and mass fractions.
         """
-    def construct(self) -> gridfire._gridfire.engine.DynamicEngine:
+    def construct(self) -> ConstructionResults:
         """
         Construct the network according to the policy.
         """
+    def get_engine_stack(self) -> list[gridfire._gridfire.engine.DynamicEngine]:
+        ...
     def get_engine_types_stack(self) -> list[gridfire._gridfire.engine.EngineTypes]:
         """
         Get the types of engines in the stack constructed by the network policy.
         """
+    def get_partition_function(self) -> gridfire._gridfire.partition.PartitionFunction:
+        ...
     def get_seed_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
         """
         Get the set of seed reactions required by the network policy.
@@ -423,6 +436,8 @@ class MainSequencePolicy(NetworkPolicy):
         """
         Get the set of seed species required by the network policy.
         """
+    def get_stack_scratch_blob(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
     def get_status(self) -> NetworkPolicyStatus:
         """
         Get the current status of the network policy.
@@ -743,6 +758,10 @@ class TripleAlphaChainPolicy(TemperatureDependentChainPolicy):
         """
         Get the name of the reaction chain policy.
         """
+def network_policy_status_to_string(status: NetworkPolicyStatus) -> str:
+    """
+    Convert a NetworkPolicyStatus enum value to its string representation.
+    """
 INITIALIZED_UNVERIFIED: NetworkPolicyStatus  # value = <NetworkPolicyStatus.INITIALIZED_UNVERIFIED: 1>
 INITIALIZED_VERIFIED: NetworkPolicyStatus  # value = <NetworkPolicyStatus.INITIALIZED_VERIFIED: 4>
 MISSING_KEY_REACTION: NetworkPolicyStatus  # value = <NetworkPolicyStatus.MISSING_KEY_REACTION: 2>

stubs/gridfire/_gridfire/solver.pyi

@@ -5,47 +5,113 @@ from __future__ import annotations
 import collections.abc
 import fourdst._phys.atomic
 import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
 import gridfire._gridfire.type
+import types
 import typing
-__all__: list[str] = ['CVODESolverStrategy', 'CVODETimestepContext', 'DynamicNetworkSolverStrategy', 'SolverContextBase']
-class CVODESolverStrategy(DynamicNetworkSolverStrategy):
-    def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine) -> None:
+__all__: list[str] = ['GridSolver', 'GridSolverContext', 'MultiZoneDynamicNetworkSolver', 'PointSolver', 'PointSolverContext', 'PointSolverTimestepContext', 'SingleZoneDynamicNetworkSolver', 'SolverContextBase']
+class GridSolver(MultiZoneDynamicNetworkSolver):
+    def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine, solver: SingleZoneDynamicNetworkSolver) -> None:
         """
-        Initialize the CVODESolverStrategy object.
+        Initialize the GridSolver object.
         """
-    def evaluate(self, netIn: gridfire._gridfire.type.NetIn, display_trigger: bool = False) -> gridfire._gridfire.type.NetOut:
+    def evaluate(self, solver_ctx: SolverContextBase, netIns: collections.abc.Sequence[gridfire._gridfire.type.NetIn]) -> list[gridfire._gridfire.type.NetOut]:
         """
         evaluate the dynamic engine using the dynamic engine class
         """
-    def get_absTol(self) -> float:
+class GridSolverContext(SolverContextBase):
+    detailed_logging: bool
+    stdout_logging: bool
+    zone_completion_logging: bool
+    def __init__(self, ctx_template: gridfire._gridfire.engine.scratchpads.StateBlob) -> None:
+        ...
+    @typing.overload
+    def clear_callback(self) -> None:
+        ...
+    @typing.overload
+    def clear_callback(self, zone_idx: typing.SupportsInt) -> None:
+        ...
+    def init(self) -> None:
+        ...
+    def reset(self) -> None:
+        ...
+    @typing.overload
+    def set_callback(self, callback: collections.abc.Callable[[...], None]) -> None:
+        ...
+    @typing.overload
+    def set_callback(self, callback: collections.abc.Callable[[...], None], zone_idx: typing.SupportsInt) -> None:
+        ...
+class MultiZoneDynamicNetworkSolver:
+    def evaluate(self, solver_ctx: SolverContextBase, netIns: collections.abc.Sequence[gridfire._gridfire.type.NetIn]) -> list[gridfire._gridfire.type.NetOut]:
         """
-        Get the absolute tolerance for the CVODE solver.
+        evaluate the dynamic engine using the dynamic engine class for multiple zones (using openmp if available)
         """
-    def get_relTol(self) -> float:
+class PointSolver(SingleZoneDynamicNetworkSolver):
+    def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine) -> None:
         """
-        Get the relative tolerance for the CVODE solver.
+        Initialize the PointSolver object.
         """
-    def get_stdout_logging_enabled(self) -> bool:
+    def evaluate(self, solver_ctx: SolverContextBase, netIn: gridfire._gridfire.type.NetIn, display_trigger: bool = False, force_reinitialization: bool = False) -> gridfire._gridfire.type.NetOut:
         """
-        Check if solver logging to standard output is enabled.
+        evaluate the dynamic engine using the dynamic engine class
         """
-    def set_absTol(self, absTol: typing.SupportsFloat) -> None:
-        """
-        Set the absolute tolerance for the CVODE solver.
-        """
-    def set_callback(self, cb: collections.abc.Callable[[CVODETimestepContext], None]) -> None:
-        """
-        Set a callback function which will run at the end of every successful timestep
-        """
-    def set_relTol(self, relTol: typing.SupportsFloat) -> None:
-        """
-        Set the relative tolerance for the CVODE solver.
-        """
-    def set_stdout_logging_enabled(self, logging_enabled: bool) -> None:
-        """
-        Enable logging to standard output.
-        """
-class CVODETimestepContext(SolverContextBase):
+class PointSolverContext:
+    callback: collections.abc.Callable[[PointSolverTimestepContext], None] | None
+    detailed_logging: bool
+    stdout_logging: bool
+    def __init__(self, engine_ctx: gridfire._gridfire.engine.scratchpads.StateBlob) -> None:
+        ...
+    def clear_context(self) -> None:
+        ...
+    def has_context(self) -> bool:
+        ...
+    def init(self) -> None:
+        ...
+    def init_context(self) -> None:
+        ...
+    def reset_all(self) -> None:
+        ...
+    def reset_cvode(self) -> None:
+        ...
+    def reset_user(self) -> None:
+        ...
+    @property
+    def J(self) -> _generic_SUNMatrix:
+        ...
+    @property
+    def LS(self) -> _generic_SUNLinearSolver:
+        ...
+    @property
+    def Y(self) -> _generic_N_Vector:
+        ...
+    @property
+    def YErr(self) -> _generic_N_Vector:
+        ...
+    @property
+    def abs_tol(self) -> float:
+        ...
+    @abs_tol.setter
+    def abs_tol(self, arg1: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def cvode_mem(self) -> types.CapsuleType:
+        ...
+    @property
+    def engine_ctx(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
+    @property
+    def num_steps(self) -> int:
+        ...
+    @property
+    def rel_tol(self) -> float:
+        ...
+    @rel_tol.setter
+    def rel_tol(self, arg1: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def sun_ctx(self) -> SUNContext_:
+        ...
+class PointSolverTimestepContext:
     @property
     def T9(self) -> float:
         ...
@@ -77,16 +143,15 @@ class CVODETimestepContext(SolverContextBase):
     def state(self) -> list[float]:
         ...
     @property
+    def state_ctx(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
+    @property
     def t(self) -> float:
         ...
-class DynamicNetworkSolverStrategy:
-    def describe_callback_context(self) -> list[tuple[str, str]]:
+class SingleZoneDynamicNetworkSolver:
+    def evaluate(self, solver_ctx: SolverContextBase, netIn: gridfire._gridfire.type.NetIn) -> gridfire._gridfire.type.NetOut:
         """
-        Get a structure representing what data is in the callback context in a human readable format
-        """
-    def evaluate(self, netIn: gridfire._gridfire.type.NetIn) -> gridfire._gridfire.type.NetOut:
-        """
-        evaluate the dynamic engine using the dynamic engine class
+        evaluate the dynamic engine using the dynamic engine class for a single zone
         """
 class SolverContextBase:
     pass

stubs/gridfire/_gridfire/type.pyi

@@ -59,3 +59,9 @@ class NetOut:
     @property
     def num_steps(self) -> int:
         ...
+    @property
+    def specific_neutrino_energy_loss(self) -> float:
+        ...
+    @property
+    def specific_neutrino_flux(self) -> float:
+        ...

stubs/gridfire/_gridfire/utils/__init__.pyi

@@ -4,10 +4,11 @@ GridFire utility method bindings
 from __future__ import annotations
 import fourdst._phys.composition
 import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
 import typing
 from . import hashing
 __all__: list[str] = ['formatNuclearTimescaleLogString', 'hash_atomic', 'hash_reaction', 'hashing']
-def formatNuclearTimescaleLogString(engine: gridfire._gridfire.engine.DynamicEngine, Y: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> str:
+def formatNuclearTimescaleLogString(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, Y: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> str:
     """
     Format a string for logging nuclear timescales based on temperature, density, and energy generation rate.
     """

stubs/gridfiregridfire/_gridfire/__init__.pyi

@@ -0,0 +1,16 @@
+"""
+Python bindings for the fourdst utility modules which are a part of the 4D-STAR project.
+"""
+from __future__ import annotations
+from . import config
+from . import engine
+from . import exceptions
+from . import io
+from . import partition
+from . import policy
+from . import reaction
+from . import screening
+from . import solver
+from . import type
+from . import utils
+__all__: list[str] = ['config', 'engine', 'exceptions', 'io', 'partition', 'policy', 'reaction', 'screening', 'solver', 'type', 'utils']

stubs/gridfiregridfire/_gridfire/config.pyi

@@ -0,0 +1,47 @@
+"""
+GridFire configuration bindings
+"""
+from __future__ import annotations
+import typing
+__all__: list[str] = ['AdaptiveEngineViewConfig', 'CVODESolverConfig', 'EngineConfig', 'EngineViewConfig', 'GridFireConfig', 'SolverConfig']
+class AdaptiveEngineViewConfig:
+    def __init__(self) -> None:
+        ...
+    @property
+    def relativeCullingThreshold(self) -> float:
+        ...
+    @relativeCullingThreshold.setter
+    def relativeCullingThreshold(self, arg0: typing.SupportsFloat) -> None:
+        ...
+class CVODESolverConfig:
+    def __init__(self) -> None:
+        ...
+    @property
+    def absTol(self) -> float:
+        ...
+    @absTol.setter
+    def absTol(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def relTol(self) -> float:
+        ...
+    @relTol.setter
+    def relTol(self, arg0: typing.SupportsFloat) -> None:
+        ...
+class EngineConfig:
+    views: EngineViewConfig
+    def __init__(self) -> None:
+        ...
+class EngineViewConfig:
+    adaptiveEngineView: AdaptiveEngineViewConfig
+    def __init__(self) -> None:
+        ...
+class GridFireConfig:
+    engine: EngineConfig
+    solver: SolverConfig
+    def __init__(self) -> None:
+        ...
+class SolverConfig:
+    cvode: CVODESolverConfig
+    def __init__(self) -> None:
+        ...

stubs/gridfiregridfire/_gridfire/engine/__init__.pyi

@@ -0,0 +1,972 @@
+"""
+Engine and Engine View bindings
+"""
+from __future__ import annotations
+import collections.abc
+import fourdst._phys.atomic
+import fourdst._phys.composition
+import gridfire._gridfire.io
+import gridfire._gridfire.partition
+import gridfire._gridfire.reaction
+import gridfire._gridfire.screening
+import gridfire._gridfire.type
+import numpy
+import numpy.typing
+import typing
+from . import diagnostics
+from . import scratchpads
+__all__: list[str] = ['ACTIVE', 'ADAPTIVE_ENGINE_VIEW', 'AdaptiveEngineView', 'BuildDepthType', 'DEFAULT', 'DEFINED_ENGINE_VIEW', 'DefinedEngineView', 'DynamicEngine', 'EQUILIBRIUM', 'Engine', 'EngineTypes', 'FILE_DEFINED_ENGINE_VIEW', 'FULL_SUCCESS', 'FifthOrder', 'FileDefinedEngineView', 'FourthOrder', 'Full', 'GRAPH_ENGINE', 'GraphEngine', 'INACTIVE_FLOW', 'MAX_ITERATIONS_REACHED', 'MULTISCALE_PARTITIONING_ENGINE_VIEW', 'MultiscalePartitioningEngineView', 'NONE', 'NOT_PRESENT', 'NO_SPECIES_TO_PRIME', 'NetworkBuildDepth', 'NetworkConstructionFlags', 'NetworkJacobian', 'NetworkPrimingEngineView', 'PRIMING_ENGINE_VIEW', 'PrimingReport', 'PrimingReportStatus', 'REACLIB', 'REACLIB_STRONG', 'REACLIB_WEAK', 'SecondOrder', 'Shallow', 'SparsityPattern', 'SpeciesStatus', 'StepDerivatives', 'ThirdOrder', 'WRL_BETA_MINUS', 'WRL_BETA_PLUS', 'WRL_ELECTRON_CAPTURE', 'WRL_POSITRON_CAPTURE', 'WRL_WEAK', 'build_nuclear_network', 'diagnostics', 'primeNetwork', 'regularize_jacobian', 'scratchpads']
+class AdaptiveEngineView(DynamicEngine):
+    def __init__(self, baseEngine: DynamicEngine) -> None:
+        """
+        Construct an adaptive engine view with a base engine.
+        """
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+        """
+        Calculate deps/dT and deps/drho
+        """
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+        """
+        Calculate the molar reaction flow for a given reaction.
+        """
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+        """
+        Calculate the right-hand side (dY/dt) and energy generation rate.
+        """
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+        """
+        Recursively collect composition from current engine and any sub engines if they exist.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+        """
+        Generate the Jacobian matrix for the current state.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix only for the subset of the matrix representing the active species.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix for the given sparsity pattern
+        """
+    def getBaseEngine(self) -> DynamicEngine:
+        """
+        Get the base engine associated with this adaptive engine view.
+        """
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the set of logical reactions in the network.
+        """
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of species in the network.
+        """
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
+        """
+        Get the current screening model of the engine.
+        """
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the destruction timescales for each species in the network.
+        """
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
+        """
+        Get the index of a species in the network.
+        """
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+        """
+        Get the status of a species in the network.
+        """
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the timescales for each species in the network.
+        """
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+        """
+        Prime the engine with a NetIn object to prepare for calculations.
+        """
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+        """
+        Update the engine state based on the provided NetIn object.
+        """
+class BuildDepthType:
+    pass
+class DefinedEngineView(DynamicEngine):
+    def __init__(self, peNames: collections.abc.Sequence[str], baseEngine: GraphEngine) -> None:
+        """
+        Construct a defined engine view with a list of tracked reactions and a base engine.
+        """
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+        """
+        Calculate deps/dT and deps/drho
+        """
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+        """
+        Calculate the molar reaction flow for a given reaction.
+        """
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+        """
+        Calculate the right-hand side (dY/dt) and energy generation rate.
+        """
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+        """
+        Recursively collect composition from current engine and any sub engines if they exist.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+        """
+        Generate the Jacobian matrix for the current state.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix only for the subset of the matrix representing the active species.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix for the given sparsity pattern
+        """
+    def getBaseEngine(self) -> DynamicEngine:
+        """
+        Get the base engine associated with this defined engine view.
+        """
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the set of logical reactions in the network.
+        """
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of species in the network.
+        """
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
+        """
+        Get the current screening model of the engine.
+        """
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the destruction timescales for each species in the network.
+        """
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
+        """
+        Get the index of a species in the network.
+        """
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+        """
+        Get the status of a species in the network.
+        """
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the timescales for each species in the network.
+        """
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+        """
+        Prime the engine with a NetIn object to prepare for calculations.
+        """
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+        """
+        Update the engine state based on the provided NetIn object.
+        """
+class DynamicEngine:
+    pass
+class Engine:
+    pass
+class EngineTypes:
+    """
+    Members:
+    
+      GRAPH_ENGINE : The standard graph-based engine.
+    
+      ADAPTIVE_ENGINE_VIEW : An engine that adapts based on certain criteria.
+    
+      MULTISCALE_PARTITIONING_ENGINE_VIEW : An engine that partitions the system at multiple scales.
+    
+      PRIMING_ENGINE_VIEW : An engine that uses a priming strategy for simulations.
+    
+      DEFINED_ENGINE_VIEW : An engine defined by user specifications.
+    
+      FILE_DEFINED_ENGINE_VIEW : An engine defined through external files.
+    """
+    ADAPTIVE_ENGINE_VIEW: typing.ClassVar[EngineTypes]  # value = <EngineTypes.ADAPTIVE_ENGINE_VIEW: 1>
+    DEFINED_ENGINE_VIEW: typing.ClassVar[EngineTypes]  # value = <EngineTypes.DEFINED_ENGINE_VIEW: 4>
+    FILE_DEFINED_ENGINE_VIEW: typing.ClassVar[EngineTypes]  # value = <EngineTypes.FILE_DEFINED_ENGINE_VIEW: 5>
+    GRAPH_ENGINE: typing.ClassVar[EngineTypes]  # value = <EngineTypes.GRAPH_ENGINE: 0>
+    MULTISCALE_PARTITIONING_ENGINE_VIEW: typing.ClassVar[EngineTypes]  # value = <EngineTypes.MULTISCALE_PARTITIONING_ENGINE_VIEW: 2>
+    PRIMING_ENGINE_VIEW: typing.ClassVar[EngineTypes]  # value = <EngineTypes.PRIMING_ENGINE_VIEW: 3>
+    __members__: typing.ClassVar[dict[str, EngineTypes]]  # value = {'GRAPH_ENGINE': <EngineTypes.GRAPH_ENGINE: 0>, 'ADAPTIVE_ENGINE_VIEW': <EngineTypes.ADAPTIVE_ENGINE_VIEW: 1>, 'MULTISCALE_PARTITIONING_ENGINE_VIEW': <EngineTypes.MULTISCALE_PARTITIONING_ENGINE_VIEW: 2>, 'PRIMING_ENGINE_VIEW': <EngineTypes.PRIMING_ENGINE_VIEW: 3>, 'DEFINED_ENGINE_VIEW': <EngineTypes.DEFINED_ENGINE_VIEW: 4>, 'FILE_DEFINED_ENGINE_VIEW': <EngineTypes.FILE_DEFINED_ENGINE_VIEW: 5>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        """
+        String representation of the EngineTypes.
+        """
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class FileDefinedEngineView(DefinedEngineView):
+    def __init__(self, baseEngine: GraphEngine, fileName: str, parser: gridfire._gridfire.io.NetworkFileParser) -> None:
+        """
+        Construct a defined engine view from a file and a base engine.
+        """
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+        """
+        Calculate deps/dT and deps/drho
+        """
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+        """
+        Calculate the molar reaction flow for a given reaction.
+        """
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+        """
+        Calculate the right-hand side (dY/dt) and energy generation rate.
+        """
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+        """
+        Recursively collect composition from current engine and any sub engines if they exist.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+        """
+        Generate the Jacobian matrix for the current state.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix only for the subset of the matrix representing the active species.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix for the given sparsity pattern
+        """
+    def getBaseEngine(self) -> DynamicEngine:
+        """
+        Get the base engine associated with this file defined engine view.
+        """
+    def getNetworkFile(self) -> str:
+        """
+        Get the network file associated with this defined engine view.
+        """
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the set of logical reactions in the network.
+        """
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of species in the network.
+        """
+    def getParser(self) -> gridfire._gridfire.io.NetworkFileParser:
+        """
+        Get the parser used for this defined engine view.
+        """
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
+        """
+        Get the current screening model of the engine.
+        """
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the destruction timescales for each species in the network.
+        """
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
+        """
+        Get the index of a species in the network.
+        """
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+        """
+        Get the status of a species in the network.
+        """
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the timescales for each species in the network.
+        """
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+        """
+        Prime the engine with a NetIn object to prepare for calculations.
+        """
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+        """
+        Update the engine state based on the provided NetIn object.
+        """
+class GraphEngine(DynamicEngine):
+    @typing.overload
+    def __init__(self, composition: fourdst._phys.composition.Composition, depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
+        """
+        Initialize GraphEngine with a composition and build depth.
+        """
+    @typing.overload
+    def __init__(self, composition: fourdst._phys.composition.Composition, partitionFunction: gridfire._gridfire.partition.PartitionFunction, depth: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ...) -> None:
+        """
+        Initialize GraphEngine with a composition, partition function and build depth.
+        """
+    @typing.overload
+    def __init__(self, reactions: gridfire._gridfire.reaction.ReactionSet) -> None:
+        """
+        Initialize GraphEngine with a set of reactions.
+        """
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+        """
+        Calculate deps/dT and deps/drho
+        """
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+        """
+        Calculate the molar reaction flow for a given reaction.
+        """
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+        """
+        Calculate the right-hand side (dY/dt) and energy generation rate.
+        """
+    def calculateReverseRate(self, reaction: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat, composition: ...) -> float:
+        """
+        Calculate the reverse rate for a given reaction at a specific temperature, density, and composition.
+        """
+    def calculateReverseRateTwoBody(self, reaction: ..., T9: typing.SupportsFloat, forwardRate: typing.SupportsFloat, expFactor: typing.SupportsFloat) -> float:
+        """
+        Calculate the reverse rate for a two-body reaction at a specific temperature.
+        """
+    def calculateReverseRateTwoBodyDerivative(self, reaction: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat, composition: fourdst._phys.composition.Composition, reverseRate: typing.SupportsFloat) -> float:
+        """
+        Calculate the derivative of the reverse rate for a two-body reaction at a specific temperature.
+        """
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+        """
+        Recursively collect composition from current engine and any sub engines if they exist.
+        """
+    def exportToCSV(self, ctx: scratchpads.StateBlob, filename: str) -> None:
+        """
+        Export the network to a CSV file for analysis.
+        """
+    def exportToDot(self, ctx: scratchpads.StateBlob, filename: str) -> None:
+        """
+        Export the network to a DOT file for visualization.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+        """
+        Generate the Jacobian matrix for the current state.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix only for the subset of the matrix representing the active species.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix for the given sparsity pattern
+        """
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the set of logical reactions in the network.
+        """
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of species in the network.
+        """
+    def getPartitionFunction(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.partition.PartitionFunction:
+        """
+        Get the partition function used by the engine.
+        """
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
+        """
+        Get the current screening model of the engine.
+        """
+    @typing.overload
+    def getSpeciesDestructionTimescales(self, ctx: scratchpads.StateBlob, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
+        ...
+    @typing.overload
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the destruction timescales for each species in the network.
+        """
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
+        """
+        Get the index of a species in the network.
+        """
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+        """
+        Get the status of a species in the network.
+        """
+    @typing.overload
+    def getSpeciesTimescales(self, ctx: scratchpads.StateBlob, composition: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeReactions: gridfire._gridfire.reaction.ReactionSet) -> ...:
+        ...
+    @typing.overload
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the timescales for each species in the network.
+        """
+    def involvesSpecies(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if a given species is involved in the network.
+        """
+    def isPrecomputationEnabled(self, arg0: scratchpads.StateBlob) -> bool:
+        """
+        Check if precomputation is enabled for the engine.
+        """
+    def isUsingReverseReactions(self, arg0: scratchpads.StateBlob) -> bool:
+        """
+        Check if the engine is using reverse reactions.
+        """
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+        """
+        Prime the engine with a NetIn object to prepare for calculations.
+        """
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+        """
+        Update the engine state based on the provided NetIn object.
+        """
+class MultiscalePartitioningEngineView(DynamicEngine):
+    def __init__(self, baseEngine: GraphEngine) -> None:
+        """
+        Construct a multiscale partitioning engine view with a base engine.
+        """
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+        """
+        Calculate deps/dT and deps/drho
+        """
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+        """
+        Calculate the molar reaction flow for a given reaction.
+        """
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+        """
+        Calculate the right-hand side (dY/dt) and energy generation rate.
+        """
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+        """
+        Recursively collect composition from current engine and any sub engines if they exist.
+        """
+    def exportToDot(self, ctx: scratchpads.StateBlob, filename: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> None:
+        """
+        Export the network to a DOT file for visualization.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+        """
+        Generate the Jacobian matrix for the current state.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix only for the subset of the matrix representing the active species.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix for the given sparsity pattern
+        """
+    def getBaseEngine(self) -> DynamicEngine:
+        """
+        Get the base engine associated with this multiscale partitioning engine view.
+        """
+    def getDynamicSpecies(self: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of dynamic species in the network.
+        """
+    def getFastSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of fast species in the network.
+        """
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the set of logical reactions in the network.
+        """
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of species in the network.
+        """
+    def getNormalizedEquilibratedComposition(self, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+        """
+        Get the normalized equilibrated composition for the algebraic species.
+        """
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
+        """
+        Get the current screening model of the engine.
+        """
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the destruction timescales for each species in the network.
+        """
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
+        """
+        Get the index of a species in the network.
+        """
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+        """
+        Get the status of a species in the network.
+        """
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the timescales for each species in the network.
+        """
+    def involvesSpecies(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if a given species is involved in the network (in either the algebraic or dynamic set).
+        """
+    def involvesSpeciesInDynamic(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if a given species is involved in the network's dynamic set.
+        """
+    def involvesSpeciesInQSE(self: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if a given species is involved in the network's algebraic set.
+        """
+    def partitionNetwork(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+        """
+        Partition the network based on species timescales and connectivity.
+        """
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+        """
+        Prime the engine with a NetIn object to prepare for calculations.
+        """
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+        """
+        Update the engine state based on the provided NetIn object.
+        """
+class NetworkBuildDepth:
+    """
+    Members:
+    
+      Full : Full network build depth
+    
+      Shallow : Shallow network build depth
+    
+      SecondOrder : Second order network build depth
+    
+      ThirdOrder : Third order network build depth
+    
+      FourthOrder : Fourth order network build depth
+    
+      FifthOrder : Fifth order network build depth
+    """
+    FifthOrder: typing.ClassVar[NetworkBuildDepth]  # value = <NetworkBuildDepth.FifthOrder: 5>
+    FourthOrder: typing.ClassVar[NetworkBuildDepth]  # value = <NetworkBuildDepth.FourthOrder: 4>
+    Full: typing.ClassVar[NetworkBuildDepth]  # value = <NetworkBuildDepth.Full: -1>
+    SecondOrder: typing.ClassVar[NetworkBuildDepth]  # value = <NetworkBuildDepth.SecondOrder: 2>
+    Shallow: typing.ClassVar[NetworkBuildDepth]  # value = <NetworkBuildDepth.Shallow: 1>
+    ThirdOrder: typing.ClassVar[NetworkBuildDepth]  # value = <NetworkBuildDepth.ThirdOrder: 3>
+    __members__: typing.ClassVar[dict[str, NetworkBuildDepth]]  # value = {'Full': <NetworkBuildDepth.Full: -1>, 'Shallow': <NetworkBuildDepth.Shallow: 1>, 'SecondOrder': <NetworkBuildDepth.SecondOrder: 2>, 'ThirdOrder': <NetworkBuildDepth.ThirdOrder: 3>, 'FourthOrder': <NetworkBuildDepth.FourthOrder: 4>, 'FifthOrder': <NetworkBuildDepth.FifthOrder: 5>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class NetworkConstructionFlags:
+    """
+    Members:
+    
+      NONE : No special construction flags.
+    
+      REACLIB_STRONG : Include strong reactions from reaclib.
+    
+      WRL_BETA_MINUS : Include beta-minus decay reactions from weak rate library.
+    
+      WRL_BETA_PLUS : Include beta-plus decay reactions from weak rate library.
+    
+      WRL_ELECTRON_CAPTURE : Include electron capture reactions from weak rate library.
+    
+      WRL_POSITRON_CAPTURE : Include positron capture reactions from weak rate library.
+    
+      REACLIB_WEAK : Include weak reactions from reaclib.
+    
+      WRL_WEAK : Include all weak reactions from weak rate library.
+    
+      REACLIB : Include all reactions from reaclib.
+    
+      DEFAULT : Default construction flags (Reaclib strong and weak).
+    """
+    DEFAULT: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.REACLIB: 33>
+    NONE: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.NONE: 0>
+    REACLIB: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.REACLIB: 33>
+    REACLIB_STRONG: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.REACLIB_STRONG: 1>
+    REACLIB_WEAK: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.REACLIB_WEAK: 32>
+    WRL_BETA_MINUS: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.WRL_BETA_MINUS: 2>
+    WRL_BETA_PLUS: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.WRL_BETA_PLUS: 4>
+    WRL_ELECTRON_CAPTURE: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.WRL_ELECTRON_CAPTURE: 8>
+    WRL_POSITRON_CAPTURE: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.WRL_POSITRON_CAPTURE: 16>
+    WRL_WEAK: typing.ClassVar[NetworkConstructionFlags]  # value = <NetworkConstructionFlags.WRL_WEAK: 30>
+    __members__: typing.ClassVar[dict[str, NetworkConstructionFlags]]  # value = {'NONE': <NetworkConstructionFlags.NONE: 0>, 'REACLIB_STRONG': <NetworkConstructionFlags.REACLIB_STRONG: 1>, 'WRL_BETA_MINUS': <NetworkConstructionFlags.WRL_BETA_MINUS: 2>, 'WRL_BETA_PLUS': <NetworkConstructionFlags.WRL_BETA_PLUS: 4>, 'WRL_ELECTRON_CAPTURE': <NetworkConstructionFlags.WRL_ELECTRON_CAPTURE: 8>, 'WRL_POSITRON_CAPTURE': <NetworkConstructionFlags.WRL_POSITRON_CAPTURE: 16>, 'REACLIB_WEAK': <NetworkConstructionFlags.REACLIB_WEAK: 32>, 'WRL_WEAK': <NetworkConstructionFlags.WRL_WEAK: 30>, 'REACLIB': <NetworkConstructionFlags.REACLIB: 33>, 'DEFAULT': <NetworkConstructionFlags.REACLIB: 33>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class NetworkJacobian:
+    @typing.overload
+    def __getitem__(self, key: tuple[fourdst._phys.atomic.Species, fourdst._phys.atomic.Species]) -> float:
+        """
+        Get an entry from the Jacobian matrix using species identifiers.
+        """
+    @typing.overload
+    def __getitem__(self, key: tuple[typing.SupportsInt, typing.SupportsInt]) -> float:
+        """
+        Get an entry from the Jacobian matrix using indices.
+        """
+    @typing.overload
+    def __setitem__(self, key: tuple[fourdst._phys.atomic.Species, fourdst._phys.atomic.Species], value: typing.SupportsFloat) -> None:
+        """
+        Set an entry in the Jacobian matrix using species identifiers.
+        """
+    @typing.overload
+    def __setitem__(self, key: tuple[typing.SupportsInt, typing.SupportsInt], value: typing.SupportsFloat) -> None:
+        """
+        Set an entry in the Jacobian matrix using indices.
+        """
+    def data(self) -> ...:
+        """
+        Get the underlying sparse matrix data.
+        """
+    def infs(self) -> list[tuple[tuple[fourdst._phys.atomic.Species, fourdst._phys.atomic.Species], float]]:
+        """
+        Get all infinite entries in the Jacobian matrix.
+        """
+    def mapping(self) -> dict[fourdst._phys.atomic.Species, int]:
+        """
+        Get the species-to-index mapping.
+        """
+    def nans(self) -> list[tuple[tuple[fourdst._phys.atomic.Species, fourdst._phys.atomic.Species], float]]:
+        """
+        Get all NaN entries in the Jacobian matrix.
+        """
+    def nnz(self) -> int:
+        """
+        Get the number of non-zero entries in the Jacobian matrix.
+        """
+    def rank(self) -> int:
+        """
+        Get the rank of the Jacobian matrix.
+        """
+    def shape(self) -> tuple[int, int]:
+        """
+        Get the shape of the Jacobian matrix as (rows, columns).
+        """
+    def singular(self) -> bool:
+        """
+        Check if the Jacobian matrix is singular.
+        """
+    def to_csv(self, filename: str) -> None:
+        """
+        Export the Jacobian matrix to a CSV file.
+        """
+    def to_numpy(self) -> numpy.typing.NDArray[numpy.float64]:
+        """
+        Convert the Jacobian matrix to a NumPy array.
+        """
+class NetworkPrimingEngineView(DefinedEngineView):
+    @typing.overload
+    def __init__(self, ctx: scratchpads.StateBlob, primingSymbol: str, baseEngine: GraphEngine) -> None:
+        """
+        Construct a priming engine view with a priming symbol and a base engine.
+        """
+    @typing.overload
+    def __init__(self, ctx: scratchpads.StateBlob, primingSpecies: fourdst._phys.atomic.Species, baseEngine: GraphEngine) -> None:
+        """
+        Construct a priming engine view with a priming species and a base engine.
+        """
+    def calculateEpsDerivatives(self, ctx: scratchpads.StateBlob, comp: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> ...:
+        """
+        Calculate deps/dT and deps/drho
+        """
+    def calculateMolarReactionFlow(self: DynamicEngine, ctx: scratchpads.StateBlob, reaction: ..., comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> float:
+        """
+        Calculate the molar reaction flow for a given reaction.
+        """
+    def calculateRHSAndEnergy(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> StepDerivatives:
+        """
+        Calculate the right-hand side (dY/dt) and energy generation rate.
+        """
+    def collectComposition(self, ctx: scratchpads.StateBlob, composition: ..., T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> fourdst._phys.composition.Composition:
+        """
+        Recursively collect composition from current engine and any sub engines if they exist.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> NetworkJacobian:
+        """
+        Generate the Jacobian matrix for the current state.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, activeSpecies: collections.abc.Sequence[fourdst._phys.atomic.Species]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix only for the subset of the matrix representing the active species.
+        """
+    @typing.overload
+    def generateJacobianMatrix(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, sparsityPattern: collections.abc.Sequence[tuple[typing.SupportsInt, typing.SupportsInt]]) -> NetworkJacobian:
+        """
+        Generate the jacobian matrix for the given sparsity pattern
+        """
+    def getBaseEngine(self) -> DynamicEngine:
+        """
+        Get the base engine associated with this priming engine view.
+        """
+    def getNetworkReactions(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the set of logical reactions in the network.
+        """
+    def getNetworkSpecies(self, arg0: scratchpads.StateBlob) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get the list of species in the network.
+        """
+    def getScreeningModel(self, arg0: scratchpads.StateBlob) -> gridfire._gridfire.screening.ScreeningType:
+        """
+        Get the current screening model of the engine.
+        """
+    def getSpeciesDestructionTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the destruction timescales for each species in the network.
+        """
+    def getSpeciesIndex(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> int:
+        """
+        Get the index of a species in the network.
+        """
+    def getSpeciesStatus(self, ctx: scratchpads.StateBlob, species: fourdst._phys.atomic.Species) -> SpeciesStatus:
+        """
+        Get the status of a species in the network.
+        """
+    def getSpeciesTimescales(self: DynamicEngine, ctx: scratchpads.StateBlob, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        Get the timescales for each species in the network.
+        """
+    def primeEngine(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> PrimingReport:
+        """
+        Prime the engine with a NetIn object to prepare for calculations.
+        """
+    def project(self, ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn) -> fourdst._phys.composition.Composition:
+        """
+        Update the engine state based on the provided NetIn object.
+        """
+class PrimingReport:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def primedComposition(self) -> fourdst._phys.composition.Composition:
+        """
+        The composition after priming.
+        """
+    @property
+    def status(self) -> PrimingReportStatus:
+        """
+        Status message from the priming process.
+        """
+    @property
+    def success(self) -> bool:
+        """
+        Indicates if the priming was successful.
+        """
+class PrimingReportStatus:
+    """
+    Members:
+    
+      FULL_SUCCESS : Priming was full successful.
+    
+      NO_SPECIES_TO_PRIME : Solver Failed to converge during priming.
+    
+      MAX_ITERATIONS_REACHED : Engine has already been primed.
+    """
+    FULL_SUCCESS: typing.ClassVar[PrimingReportStatus]  # value = <PrimingReportStatus.FULL_SUCCESS: 0>
+    MAX_ITERATIONS_REACHED: typing.ClassVar[PrimingReportStatus]  # value = <PrimingReportStatus.MAX_ITERATIONS_REACHED: 1>
+    NO_SPECIES_TO_PRIME: typing.ClassVar[PrimingReportStatus]  # value = <PrimingReportStatus.NO_SPECIES_TO_PRIME: 2>
+    __members__: typing.ClassVar[dict[str, PrimingReportStatus]]  # value = {'FULL_SUCCESS': <PrimingReportStatus.FULL_SUCCESS: 0>, 'NO_SPECIES_TO_PRIME': <PrimingReportStatus.NO_SPECIES_TO_PRIME: 2>, 'MAX_ITERATIONS_REACHED': <PrimingReportStatus.MAX_ITERATIONS_REACHED: 1>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        """
+        String representation of the PrimingReport.
+        """
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class SparsityPattern:
+    pass
+class SpeciesStatus:
+    """
+    Members:
+    
+      ACTIVE : Species is active in the network.
+    
+      EQUILIBRIUM : Species is in equilibrium.
+    
+      INACTIVE_FLOW : Species is inactive due to flow.
+    
+      NOT_PRESENT : Species is not present in the network.
+    """
+    ACTIVE: typing.ClassVar[SpeciesStatus]  # value = <SpeciesStatus.ACTIVE: 0>
+    EQUILIBRIUM: typing.ClassVar[SpeciesStatus]  # value = <SpeciesStatus.EQUILIBRIUM: 1>
+    INACTIVE_FLOW: typing.ClassVar[SpeciesStatus]  # value = <SpeciesStatus.INACTIVE_FLOW: 2>
+    NOT_PRESENT: typing.ClassVar[SpeciesStatus]  # value = <SpeciesStatus.NOT_PRESENT: 3>
+    __members__: typing.ClassVar[dict[str, SpeciesStatus]]  # value = {'ACTIVE': <SpeciesStatus.ACTIVE: 0>, 'EQUILIBRIUM': <SpeciesStatus.EQUILIBRIUM: 1>, 'INACTIVE_FLOW': <SpeciesStatus.INACTIVE_FLOW: 2>, 'NOT_PRESENT': <SpeciesStatus.NOT_PRESENT: 3>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class StepDerivatives:
+    @property
+    def dYdt(self) -> dict[fourdst._phys.atomic.Species, float]:
+        """
+        The right-hand side (dY/dt) of the ODE system.
+        """
+    @property
+    def energy(self) -> float:
+        """
+        The energy generation rate.
+        """
+def build_nuclear_network(composition: ..., weakInterpolator: ..., maxLayers: gridfire._gridfire.engine.NetworkBuildDepth | typing.SupportsInt = ..., ReactionTypes: NetworkConstructionFlags = ...) -> gridfire._gridfire.reaction.ReactionSet:
+    """
+    Build a nuclear network from a composition using all archived reaction data.
+    """
+def primeNetwork(ctx: scratchpads.StateBlob, netIn: gridfire._gridfire.type.NetIn, engine: ..., ignoredReactionTypes: collections.abc.Sequence[...] | None = None) -> PrimingReport:
+    """
+    Prime a network with a short timescale ignition
+    """
+def regularize_jacobian(jacobian: NetworkJacobian, composition: fourdst._phys.composition.Composition) -> NetworkJacobian:
+    """
+    regularize_jacobian
+    """
+ACTIVE: SpeciesStatus  # value = <SpeciesStatus.ACTIVE: 0>
+ADAPTIVE_ENGINE_VIEW: EngineTypes  # value = <EngineTypes.ADAPTIVE_ENGINE_VIEW: 1>
+DEFAULT: NetworkConstructionFlags  # value = <NetworkConstructionFlags.REACLIB: 33>
+DEFINED_ENGINE_VIEW: EngineTypes  # value = <EngineTypes.DEFINED_ENGINE_VIEW: 4>
+EQUILIBRIUM: SpeciesStatus  # value = <SpeciesStatus.EQUILIBRIUM: 1>
+FILE_DEFINED_ENGINE_VIEW: EngineTypes  # value = <EngineTypes.FILE_DEFINED_ENGINE_VIEW: 5>
+FULL_SUCCESS: PrimingReportStatus  # value = <PrimingReportStatus.FULL_SUCCESS: 0>
+FifthOrder: NetworkBuildDepth  # value = <NetworkBuildDepth.FifthOrder: 5>
+FourthOrder: NetworkBuildDepth  # value = <NetworkBuildDepth.FourthOrder: 4>
+Full: NetworkBuildDepth  # value = <NetworkBuildDepth.Full: -1>
+GRAPH_ENGINE: EngineTypes  # value = <EngineTypes.GRAPH_ENGINE: 0>
+INACTIVE_FLOW: SpeciesStatus  # value = <SpeciesStatus.INACTIVE_FLOW: 2>
+MAX_ITERATIONS_REACHED: PrimingReportStatus  # value = <PrimingReportStatus.MAX_ITERATIONS_REACHED: 1>
+MULTISCALE_PARTITIONING_ENGINE_VIEW: EngineTypes  # value = <EngineTypes.MULTISCALE_PARTITIONING_ENGINE_VIEW: 2>
+NONE: NetworkConstructionFlags  # value = <NetworkConstructionFlags.NONE: 0>
+NOT_PRESENT: SpeciesStatus  # value = <SpeciesStatus.NOT_PRESENT: 3>
+NO_SPECIES_TO_PRIME: PrimingReportStatus  # value = <PrimingReportStatus.NO_SPECIES_TO_PRIME: 2>
+PRIMING_ENGINE_VIEW: EngineTypes  # value = <EngineTypes.PRIMING_ENGINE_VIEW: 3>
+REACLIB: NetworkConstructionFlags  # value = <NetworkConstructionFlags.REACLIB: 33>
+REACLIB_STRONG: NetworkConstructionFlags  # value = <NetworkConstructionFlags.REACLIB_STRONG: 1>
+REACLIB_WEAK: NetworkConstructionFlags  # value = <NetworkConstructionFlags.REACLIB_WEAK: 32>
+SecondOrder: NetworkBuildDepth  # value = <NetworkBuildDepth.SecondOrder: 2>
+Shallow: NetworkBuildDepth  # value = <NetworkBuildDepth.Shallow: 1>
+ThirdOrder: NetworkBuildDepth  # value = <NetworkBuildDepth.ThirdOrder: 3>
+WRL_BETA_MINUS: NetworkConstructionFlags  # value = <NetworkConstructionFlags.WRL_BETA_MINUS: 2>
+WRL_BETA_PLUS: NetworkConstructionFlags  # value = <NetworkConstructionFlags.WRL_BETA_PLUS: 4>
+WRL_ELECTRON_CAPTURE: NetworkConstructionFlags  # value = <NetworkConstructionFlags.WRL_ELECTRON_CAPTURE: 8>
+WRL_POSITRON_CAPTURE: NetworkConstructionFlags  # value = <NetworkConstructionFlags.WRL_POSITRON_CAPTURE: 16>
+WRL_WEAK: NetworkConstructionFlags  # value = <NetworkConstructionFlags.WRL_WEAK: 30>

stubs/gridfiregridfire/_gridfire/engine/diagnostics.pyi

@@ -0,0 +1,16 @@
+"""
+A submodule for engine diagnostics
+"""
+from __future__ import annotations
+import collections.abc
+import fourdst._phys.composition
+import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
+import typing
+__all__: list[str] = ['inspect_jacobian_stiffness', 'inspect_species_balance', 'report_limiting_species']
+def inspect_jacobian_stiffness(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
+    ...
+def inspect_species_balance(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, species_name: str, comp: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat, json: bool) -> ... | None:
+    ...
+def report_limiting_species(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, Y_full: collections.abc.Sequence[typing.SupportsFloat], E_full: collections.abc.Sequence[typing.SupportsFloat], relTol: typing.SupportsFloat, absTol: typing.SupportsFloat, top_n: typing.SupportsInt, json: bool) -> ... | None:
+    ...

stubs/gridfiregridfire/_gridfire/engine/scratchpads.pyi

@@ -0,0 +1,267 @@
+"""
+Engine ScratchPad bindings
+"""
+from __future__ import annotations
+import fourdst._phys.atomic
+import fourdst._phys.composition
+import gridfire._gridfire.reaction
+import typing
+__all__: list[str] = ['ADAPTIVE_ENGINE_VIEW_SCRATCHPAD', 'ADFunRegistrationResult', 'ALREADY_REGISTERED', 'AdaptiveEngineViewScratchPad', 'DEFINED_ENGINE_VIEW_SCRATCHPAD', 'DefinedEngineViewScratchPad', 'GRAPH_ENGINE_SCRATCHPAD', 'GraphEngineScratchPad', 'MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD', 'MultiscalePartitioningEngineViewScratchPad', 'SCRATCHPAD_BAD_CAST', 'SCRATCHPAD_NOT_FOUND', 'SCRATCHPAD_NOT_INITIALIZED', 'SCRATCHPAD_OUT_OF_BOUNDS', 'SCRATCHPAD_TYPE_COLLISION', 'SCRATCHPAD_UNKNOWN_ERROR', 'SUCCESS', 'ScratchPadType', 'StateBlob', 'StateBlobError']
+class ADFunRegistrationResult:
+    """
+    Members:
+    
+      SUCCESS
+    
+      ALREADY_REGISTERED
+    """
+    ALREADY_REGISTERED: typing.ClassVar[ADFunRegistrationResult]  # value = <ADFunRegistrationResult.ALREADY_REGISTERED: 1>
+    SUCCESS: typing.ClassVar[ADFunRegistrationResult]  # value = <ADFunRegistrationResult.SUCCESS: 0>
+    __members__: typing.ClassVar[dict[str, ADFunRegistrationResult]]  # value = {'SUCCESS': <ADFunRegistrationResult.SUCCESS: 0>, 'ALREADY_REGISTERED': <ADFunRegistrationResult.ALREADY_REGISTERED: 1>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class AdaptiveEngineViewScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def initialize(self, arg0: ...) -> None:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def active_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        ...
+    @property
+    def active_species(self) -> list[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+class DefinedEngineViewScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def active_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        ...
+    @property
+    def active_species(self) -> set[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+    @property
+    def reaction_index_map(self) -> list[int]:
+        ...
+    @property
+    def species_index_map(self) -> list[int]:
+        ...
+class GraphEngineScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def initialize(self, engine: ...) -> None:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+    @property
+    def local_abundance_cache(self) -> list[float]:
+        ...
+    @property
+    def most_recent_rhs_calculation(self) -> ... | None:
+        ...
+    @property
+    def stepDerivativesCache(self) -> dict[int, ...]:
+        ...
+class MultiscalePartitioningEngineViewScratchPad:
+    ID: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone(self) -> ...:
+        ...
+    def initialize(self) -> None:
+        ...
+    def is_initialized(self) -> bool:
+        ...
+    @property
+    def algebraic_species(self) -> list[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def composition_cache(self) -> dict[int, fourdst._phys.composition.Composition]:
+        ...
+    @property
+    def dynamic_species(self) -> list[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def has_initialized(self) -> bool:
+        ...
+    @property
+    def qse_groups(self) -> list[...]:
+        ...
+class ScratchPadType:
+    """
+    Members:
+    
+      GRAPH_ENGINE_SCRATCHPAD
+    
+      MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD
+    
+      ADAPTIVE_ENGINE_VIEW_SCRATCHPAD
+    
+      DEFINED_ENGINE_VIEW_SCRATCHPAD
+    """
+    ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
+    DEFINED_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
+    GRAPH_ENGINE_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
+    MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: typing.ClassVar[ScratchPadType]  # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
+    __members__: typing.ClassVar[dict[str, ScratchPadType]]  # value = {'GRAPH_ENGINE_SCRATCHPAD': <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>, 'MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>, 'ADAPTIVE_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>, 'DEFINED_ENGINE_VIEW_SCRATCHPAD': <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class StateBlob:
+    @staticmethod
+    def error_to_string(arg0: StateBlobError) -> str:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def clone_structure(self) -> StateBlob:
+        ...
+    def enroll(self, arg0: ScratchPadType) -> None:
+        ...
+    def get(self, arg0: ScratchPadType) -> ...:
+        ...
+    def get_registered_scratchpads(self) -> set[ScratchPadType]:
+        ...
+    def get_status(self, arg0: ScratchPadType) -> ...:
+        ...
+    def get_status_map(self) -> dict[ScratchPadType, ...]:
+        ...
+class StateBlobError:
+    """
+    Members:
+    
+      SCRATCHPAD_OUT_OF_BOUNDS
+    
+      SCRATCHPAD_NOT_FOUND
+    
+      SCRATCHPAD_BAD_CAST
+    
+      SCRATCHPAD_NOT_INITIALIZED
+    
+      SCRATCHPAD_TYPE_COLLISION
+    
+      SCRATCHPAD_UNKNOWN_ERROR
+    """
+    SCRATCHPAD_BAD_CAST: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_BAD_CAST: 1>
+    SCRATCHPAD_NOT_FOUND: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>
+    SCRATCHPAD_NOT_INITIALIZED: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>
+    SCRATCHPAD_OUT_OF_BOUNDS: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>
+    SCRATCHPAD_TYPE_COLLISION: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>
+    SCRATCHPAD_UNKNOWN_ERROR: typing.ClassVar[StateBlobError]  # value = <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>
+    __members__: typing.ClassVar[dict[str, StateBlobError]]  # value = {'SCRATCHPAD_OUT_OF_BOUNDS': <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>, 'SCRATCHPAD_NOT_FOUND': <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>, 'SCRATCHPAD_BAD_CAST': <StateBlobError.SCRATCHPAD_BAD_CAST: 1>, 'SCRATCHPAD_NOT_INITIALIZED': <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>, 'SCRATCHPAD_TYPE_COLLISION': <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>, 'SCRATCHPAD_UNKNOWN_ERROR': <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.ADAPTIVE_ENGINE_VIEW_SCRATCHPAD: 2>
+ALREADY_REGISTERED: ADFunRegistrationResult  # value = <ADFunRegistrationResult.ALREADY_REGISTERED: 1>
+DEFINED_ENGINE_VIEW_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.DEFINED_ENGINE_VIEW_SCRATCHPAD: 3>
+GRAPH_ENGINE_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.GRAPH_ENGINE_SCRATCHPAD: 0>
+MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: ScratchPadType  # value = <ScratchPadType.MULTISCALE_PARTITIONING_ENGINE_VIEW_SCRATCHPAD: 1>
+SCRATCHPAD_BAD_CAST: StateBlobError  # value = <StateBlobError.SCRATCHPAD_BAD_CAST: 1>
+SCRATCHPAD_NOT_FOUND: StateBlobError  # value = <StateBlobError.SCRATCHPAD_NOT_FOUND: 0>
+SCRATCHPAD_NOT_INITIALIZED: StateBlobError  # value = <StateBlobError.SCRATCHPAD_NOT_INITIALIZED: 2>
+SCRATCHPAD_OUT_OF_BOUNDS: StateBlobError  # value = <StateBlobError.SCRATCHPAD_OUT_OF_BOUNDS: 4>
+SCRATCHPAD_TYPE_COLLISION: StateBlobError  # value = <StateBlobError.SCRATCHPAD_TYPE_COLLISION: 3>
+SCRATCHPAD_UNKNOWN_ERROR: StateBlobError  # value = <StateBlobError.SCRATCHPAD_UNKNOWN_ERROR: 5>
+SUCCESS: ADFunRegistrationResult  # value = <ADFunRegistrationResult.SUCCESS: 0>

stubs/gridfiregridfire/_gridfire/exceptions.pyi

@@ -0,0 +1,61 @@
+"""
+GridFire exceptions bindings
+"""
+from __future__ import annotations
+__all__: list[str] = ['BadCollectionError', 'BadRHSEngineError', 'CVODESolverFailureError', 'DebugException', 'EngineError', 'FailedToPartitionEngineError', 'GridFireError', 'HashingError', 'IllConditionedJacobianError', 'InvalidQSESolutionError', 'JacobianError', 'KINSolSolverFailureError', 'MissingBaseReactionError', 'MissingKeyReactionError', 'MissingSeedSpeciesError', 'NetworkResizedError', 'PolicyError', 'ReactionError', 'ReactionParsingError', 'SUNDIALSError', 'ScratchPadError', 'SingularJacobianError', 'SolverError', 'StaleJacobianError', 'UnableToSetNetworkReactionsError', 'UninitializedJacobianError', 'UnknownJacobianError', 'UtilityError']
+class BadCollectionError(EngineError):
+    pass
+class BadRHSEngineError(EngineError):
+    pass
+class CVODESolverFailureError(SUNDIALSError):
+    pass
+class DebugException(GridFireError):
+    pass
+class EngineError(GridFireError):
+    pass
+class FailedToPartitionEngineError(EngineError):
+    pass
+class GridFireError(Exception):
+    pass
+class HashingError(UtilityError):
+    pass
+class IllConditionedJacobianError(SolverError):
+    pass
+class InvalidQSESolutionError(EngineError):
+    pass
+class JacobianError(EngineError):
+    pass
+class KINSolSolverFailureError(SUNDIALSError):
+    pass
+class MissingBaseReactionError(PolicyError):
+    pass
+class MissingKeyReactionError(PolicyError):
+    pass
+class MissingSeedSpeciesError(PolicyError):
+    pass
+class NetworkResizedError(EngineError):
+    pass
+class PolicyError(GridFireError):
+    pass
+class ReactionError(GridFireError):
+    pass
+class ReactionParsingError(ReactionError):
+    pass
+class SUNDIALSError(SolverError):
+    pass
+class ScratchPadError(GridFireError):
+    pass
+class SingularJacobianError(SolverError):
+    pass
+class SolverError(GridFireError):
+    pass
+class StaleJacobianError(JacobianError):
+    pass
+class UnableToSetNetworkReactionsError(EngineError):
+    pass
+class UninitializedJacobianError(JacobianError):
+    pass
+class UnknownJacobianError(JacobianError):
+    pass
+class UtilityError(GridFireError):
+    pass

stubs/gridfiregridfire/_gridfire/io.pyi

@@ -0,0 +1,14 @@
+"""
+GridFire io bindings
+"""
+from __future__ import annotations
+__all__: list[str] = ['NetworkFileParser', 'ParsedNetworkData', 'SimpleReactionListFileParser']
+class NetworkFileParser:
+    pass
+class ParsedNetworkData:
+    pass
+class SimpleReactionListFileParser(NetworkFileParser):
+    def parse(self, filename: str) -> ParsedNetworkData:
+        """
+        Parse a simple reaction list file and return a ParsedNetworkData object.
+        """

stubs/gridfiregridfire/_gridfire/partition.pyi

@@ -0,0 +1,142 @@
+"""
+GridFire partition function bindings
+"""
+from __future__ import annotations
+import collections.abc
+import typing
+__all__: list[str] = ['BasePartitionType', 'CompositePartitionFunction', 'GroundState', 'GroundStatePartitionFunction', 'PartitionFunction', 'RauscherThielemann', 'RauscherThielemannPartitionDataRecord', 'RauscherThielemannPartitionFunction', 'basePartitionTypeToString', 'stringToBasePartitionType']
+class BasePartitionType:
+    """
+    Members:
+    
+      RauscherThielemann
+    
+      GroundState
+    """
+    GroundState: typing.ClassVar[BasePartitionType]  # value = <BasePartitionType.GroundState: 1>
+    RauscherThielemann: typing.ClassVar[BasePartitionType]  # value = <BasePartitionType.RauscherThielemann: 0>
+    __members__: typing.ClassVar[dict[str, BasePartitionType]]  # value = {'RauscherThielemann': <BasePartitionType.RauscherThielemann: 0>, 'GroundState': <BasePartitionType.GroundState: 1>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class CompositePartitionFunction:
+    @typing.overload
+    def __init__(self, partitionFunctions: collections.abc.Sequence[BasePartitionType]) -> None:
+        """
+        Create a composite partition function from a list of base partition types.
+        """
+    @typing.overload
+    def __init__(self, arg0: CompositePartitionFunction) -> None:
+        """
+        Copy constructor for CompositePartitionFunction.
+        """
+    def evaluate(self, z: typing.SupportsInt, a: typing.SupportsInt, T9: typing.SupportsFloat) -> float:
+        """
+        Evaluate the composite partition function for given Z, A, and T9.
+        """
+    def evaluateDerivative(self, z: typing.SupportsInt, a: typing.SupportsInt, T9: typing.SupportsFloat) -> float:
+        """
+        Evaluate the derivative of the composite partition function for given Z, A, and T9.
+        """
+    def get_type(self) -> str:
+        """
+        Get the type of the partition function (should return 'Composite').
+        """
+    def supports(self, z: typing.SupportsInt, a: typing.SupportsInt) -> bool:
+        """
+        Check if the composite partition function supports given Z and A.
+        """
+class GroundStatePartitionFunction(PartitionFunction):
+    def __init__(self) -> None:
+        ...
+    def evaluate(self, z: typing.SupportsInt, a: typing.SupportsInt, T9: typing.SupportsFloat) -> float:
+        """
+        Evaluate the ground state partition function for given Z, A, and T9.
+        """
+    def evaluateDerivative(self, z: typing.SupportsInt, a: typing.SupportsInt, T9: typing.SupportsFloat) -> float:
+        """
+        Evaluate the derivative of the ground state partition function for given Z, A, and T9.
+        """
+    def get_type(self) -> str:
+        """
+        Get the type of the partition function (should return 'GroundState').
+        """
+    def supports(self, z: typing.SupportsInt, a: typing.SupportsInt) -> bool:
+        """
+        Check if the ground state partition function supports given Z and A.
+        """
+class PartitionFunction:
+    pass
+class RauscherThielemannPartitionDataRecord:
+    @property
+    def a(self) -> int:
+        """
+        Mass number
+        """
+    @property
+    def ground_state_spin(self) -> float:
+        """
+        Ground state spin
+        """
+    @property
+    def normalized_g_values(self) -> float:
+        """
+        Normalized g-values for the first 24 energy levels
+        """
+    @property
+    def z(self) -> int:
+        """
+        Atomic number
+        """
+class RauscherThielemannPartitionFunction(PartitionFunction):
+    def __init__(self) -> None:
+        ...
+    def evaluate(self, z: typing.SupportsInt, a: typing.SupportsInt, T9: typing.SupportsFloat) -> float:
+        """
+        Evaluate the Rauscher-Thielemann partition function for given Z, A, and T9.
+        """
+    def evaluateDerivative(self, z: typing.SupportsInt, a: typing.SupportsInt, T9: typing.SupportsFloat) -> float:
+        """
+        Evaluate the derivative of the Rauscher-Thielemann partition function for given Z, A, and T9.
+        """
+    def get_type(self) -> str:
+        """
+        Get the type of the partition function (should return 'RauscherThielemann').
+        """
+    def supports(self, z: typing.SupportsInt, a: typing.SupportsInt) -> bool:
+        """
+        Check if the Rauscher-Thielemann partition function supports given Z and A.
+        """
+def basePartitionTypeToString(type: BasePartitionType) -> str:
+    """
+    Convert BasePartitionType to string.
+    """
+def stringToBasePartitionType(typeStr: str) -> BasePartitionType:
+    """
+    Convert string to BasePartitionType.
+    """
+GroundState: BasePartitionType  # value = <BasePartitionType.GroundState: 1>
+RauscherThielemann: BasePartitionType  # value = <BasePartitionType.RauscherThielemann: 0>

stubs/gridfiregridfire/_gridfire/policy.pyi

@@ -0,0 +1,769 @@
+"""
+GridFire network policy bindings
+"""
+from __future__ import annotations
+import collections.abc
+import fourdst._phys.atomic
+import fourdst._phys.composition
+import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
+import gridfire._gridfire.partition
+import gridfire._gridfire.reaction
+import typing
+__all__: list[str] = ['CNOChainPolicy', 'CNOIChainPolicy', 'CNOIIChainPolicy', 'CNOIIIChainPolicy', 'CNOIVChainPolicy', 'ConstructionResults', 'HotCNOChainPolicy', 'HotCNOIChainPolicy', 'HotCNOIIChainPolicy', 'HotCNOIIIChainPolicy', 'INITIALIZED_UNVERIFIED', 'INITIALIZED_VERIFIED', 'MISSING_KEY_REACTION', 'MISSING_KEY_SPECIES', 'MainSequencePolicy', 'MainSequenceReactionChainPolicy', 'MultiReactionChainPolicy', 'NetworkPolicy', 'NetworkPolicyStatus', 'ProtonProtonChainPolicy', 'ProtonProtonIChainPolicy', 'ProtonProtonIIChainPolicy', 'ProtonProtonIIIChainPolicy', 'ReactionChainPolicy', 'TemperatureDependentChainPolicy', 'TripleAlphaChainPolicy', 'UNINITIALIZED', 'network_policy_status_to_string']
+class CNOChainPolicy(MultiReactionChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class CNOIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class CNOIIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class CNOIIIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class CNOIVChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class ConstructionResults:
+    @property
+    def engine(self) -> gridfire._gridfire.engine.DynamicEngine:
+        ...
+    @property
+    def scratch_blob(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
+class HotCNOChainPolicy(MultiReactionChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class HotCNOIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class HotCNOIIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class HotCNOIIIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class MainSequencePolicy(NetworkPolicy):
+    @typing.overload
+    def __init__(self, composition: fourdst._phys.composition.Composition) -> None:
+        """
+        Construct MainSequencePolicy from an existing composition.
+        """
+    @typing.overload
+    def __init__(self, seed_species: collections.abc.Sequence[fourdst._phys.atomic.Species], mass_fractions: collections.abc.Sequence[typing.SupportsFloat]) -> None:
+        """
+        Construct MainSequencePolicy from seed species and mass fractions.
+        """
+    def construct(self) -> ConstructionResults:
+        """
+        Construct the network according to the policy.
+        """
+    def get_engine_stack(self) -> list[gridfire._gridfire.engine.DynamicEngine]:
+        ...
+    def get_engine_types_stack(self) -> list[gridfire._gridfire.engine.EngineTypes]:
+        """
+        Get the types of engines in the stack constructed by the network policy.
+        """
+    def get_partition_function(self) -> gridfire._gridfire.partition.PartitionFunction:
+        ...
+    def get_seed_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the set of seed reactions required by the network policy.
+        """
+    def get_seed_species(self) -> set[fourdst._phys.atomic.Species]:
+        """
+        Get the set of seed species required by the network policy.
+        """
+    def get_stack_scratch_blob(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
+    def get_status(self) -> NetworkPolicyStatus:
+        """
+        Get the current status of the network policy.
+        """
+    def name(self) -> str:
+        """
+        Get the name of the network policy.
+        """
+class MainSequenceReactionChainPolicy(MultiReactionChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class MultiReactionChainPolicy(ReactionChainPolicy):
+    pass
+class NetworkPolicy:
+    pass
+class NetworkPolicyStatus:
+    """
+    Members:
+    
+      UNINITIALIZED
+    
+      INITIALIZED_UNVERIFIED
+    
+      MISSING_KEY_REACTION
+    
+      MISSING_KEY_SPECIES
+    
+      INITIALIZED_VERIFIED
+    """
+    INITIALIZED_UNVERIFIED: typing.ClassVar[NetworkPolicyStatus]  # value = <NetworkPolicyStatus.INITIALIZED_UNVERIFIED: 1>
+    INITIALIZED_VERIFIED: typing.ClassVar[NetworkPolicyStatus]  # value = <NetworkPolicyStatus.INITIALIZED_VERIFIED: 4>
+    MISSING_KEY_REACTION: typing.ClassVar[NetworkPolicyStatus]  # value = <NetworkPolicyStatus.MISSING_KEY_REACTION: 2>
+    MISSING_KEY_SPECIES: typing.ClassVar[NetworkPolicyStatus]  # value = <NetworkPolicyStatus.MISSING_KEY_SPECIES: 3>
+    UNINITIALIZED: typing.ClassVar[NetworkPolicyStatus]  # value = <NetworkPolicyStatus.UNINITIALIZED: 0>
+    __members__: typing.ClassVar[dict[str, NetworkPolicyStatus]]  # value = {'UNINITIALIZED': <NetworkPolicyStatus.UNINITIALIZED: 0>, 'INITIALIZED_UNVERIFIED': <NetworkPolicyStatus.INITIALIZED_UNVERIFIED: 1>, 'MISSING_KEY_REACTION': <NetworkPolicyStatus.MISSING_KEY_REACTION: 2>, 'MISSING_KEY_SPECIES': <NetworkPolicyStatus.MISSING_KEY_SPECIES: 3>, 'INITIALIZED_VERIFIED': <NetworkPolicyStatus.INITIALIZED_VERIFIED: 4>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class ProtonProtonChainPolicy(MultiReactionChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class ProtonProtonIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class ProtonProtonIIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class ProtonProtonIIIChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+class ReactionChainPolicy:
+    pass
+class TemperatureDependentChainPolicy(ReactionChainPolicy):
+    pass
+class TripleAlphaChainPolicy(TemperatureDependentChainPolicy):
+    def __eq__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check equality with another ReactionChainPolicy.
+        """
+    def __hash__(self) -> int:
+        ...
+    def __init__(self) -> None:
+        ...
+    def __ne__(self, other: ReactionChainPolicy) -> bool:
+        """
+        Check inequality with another ReactionChainPolicy.
+        """
+    def __repr__(self) -> str:
+        ...
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the reaction chain contains a reaction with the given ID.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the reaction chain contains the given reaction.
+        """
+    def get_reactions(self) -> gridfire._gridfire.reaction.ReactionSet:
+        """
+        Get the ReactionSet representing this reaction chain.
+        """
+    def hash(self, seed: typing.SupportsInt) -> int:
+        """
+        Compute a hash value for the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+    @typing.overload
+    def name(self) -> str:
+        """
+        Get the name of the reaction chain policy.
+        """
+def network_policy_status_to_string(status: NetworkPolicyStatus) -> str:
+    """
+    Convert a NetworkPolicyStatus enum value to its string representation.
+    """
+INITIALIZED_UNVERIFIED: NetworkPolicyStatus  # value = <NetworkPolicyStatus.INITIALIZED_UNVERIFIED: 1>
+INITIALIZED_VERIFIED: NetworkPolicyStatus  # value = <NetworkPolicyStatus.INITIALIZED_VERIFIED: 4>
+MISSING_KEY_REACTION: NetworkPolicyStatus  # value = <NetworkPolicyStatus.MISSING_KEY_REACTION: 2>
+MISSING_KEY_SPECIES: NetworkPolicyStatus  # value = <NetworkPolicyStatus.MISSING_KEY_SPECIES: 3>
+UNINITIALIZED: NetworkPolicyStatus  # value = <NetworkPolicyStatus.UNINITIALIZED: 0>

stubs/gridfiregridfire/_gridfire/reaction.pyi

@@ -0,0 +1,249 @@
+"""
+GridFire reaction bindings
+"""
+from __future__ import annotations
+import collections.abc
+import fourdst._phys.atomic
+import fourdst._phys.composition
+import typing
+__all__: list[str] = ['LogicalReaclibReaction', 'RateCoefficientSet', 'ReaclibReaction', 'ReactionSet', 'get_all_reactions', 'packReactionSet']
+class LogicalReaclibReaction(ReaclibReaction):
+    @typing.overload
+    def __init__(self, reactions: collections.abc.Sequence[ReaclibReaction]) -> None:
+        """
+        Construct a LogicalReaclibReaction from a vector of ReaclibReaction objects.
+        """
+    @typing.overload
+    def __init__(self, reactions: collections.abc.Sequence[ReaclibReaction], is_reverse: bool) -> None:
+        """
+        Construct a LogicalReaclibReaction from a vector of ReaclibReaction objects.
+        """
+    def __len__(self) -> int:
+        """
+        Overload len() to return the number of source rates.
+        """
+    def add_reaction(self, reaction: ReaclibReaction) -> None:
+        """
+        Add another Reaction source to this logical reaction.
+        """
+    def calculate_forward_rate_log_derivative(self, T9: typing.SupportsFloat, rho: typing.SupportsFloat, Ye: typing.SupportsFloat, mue: typing.SupportsFloat, Composition: fourdst._phys.composition.Composition) -> float:
+        """
+        Calculate the forward rate log derivative at a given temperature T9 (in units of 10^9 K).
+        """
+    def calculate_rate(self, T9: typing.SupportsFloat, rho: typing.SupportsFloat, Ye: typing.SupportsFloat, mue: typing.SupportsFloat, Y: collections.abc.Sequence[typing.SupportsFloat], index_to_species_map: collections.abc.Mapping[typing.SupportsInt, fourdst._phys.atomic.Species]) -> float:
+        """
+        Calculate the reaction rate at a given temperature T9 (in units of 10^9 K). Note that for a reaclib reaction only T9 is actually used, all other parameters are there for interface compatibility.
+        """
+    def size(self) -> int:
+        """
+        Get the number of source rates contributing to this logical reaction.
+        """
+    def sources(self) -> list[str]:
+        """
+        Get the list of source labels for the aggregated rates.
+        """
+class RateCoefficientSet:
+    def __init__(self, a0: typing.SupportsFloat, a1: typing.SupportsFloat, a2: typing.SupportsFloat, a3: typing.SupportsFloat, a4: typing.SupportsFloat, a5: typing.SupportsFloat, a6: typing.SupportsFloat) -> None:
+        """
+        Construct a RateCoefficientSet with the given parameters.
+        """
+class ReaclibReaction:
+    __hash__: typing.ClassVar[None] = None
+    def __eq__(self, arg0: ReaclibReaction) -> bool:
+        """
+        Equality operator for reactions based on their IDs.
+        """
+    def __init__(self, id: str, peName: str, chapter: typing.SupportsInt, reactants: collections.abc.Sequence[fourdst._phys.atomic.Species], products: collections.abc.Sequence[fourdst._phys.atomic.Species], qValue: typing.SupportsFloat, label: str, sets: RateCoefficientSet, reverse: bool = False) -> None:
+        """
+        Construct a Reaction with the given parameters.
+        """
+    def __neq__(self, arg0: ReaclibReaction) -> bool:
+        """
+        Inequality operator for reactions based on their IDs.
+        """
+    def __repr__(self) -> str:
+        ...
+    def all_species(self) -> set[fourdst._phys.atomic.Species]:
+        """
+        Get all species involved in the reaction (both reactants and products) as a set.
+        """
+    def calculate_rate(self, T9: typing.SupportsFloat, rho: typing.SupportsFloat, Y: collections.abc.Sequence[typing.SupportsFloat]) -> float:
+        """
+        Calculate the reaction rate at a given temperature T9 (in units of 10^9 K).
+        """
+    def chapter(self) -> int:
+        """
+        Get the REACLIB chapter number defining the reaction structure.
+        """
+    def contains(self, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if the reaction contains a specific species.
+        """
+    def contains_product(self, arg0: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if the reaction contains a specific product species.
+        """
+    def contains_reactant(self, arg0: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if the reaction contains a specific reactant species.
+        """
+    def excess_energy(self) -> float:
+        """
+        Calculate the excess energy from the mass difference of reactants and products.
+        """
+    def hash(self, seed: typing.SupportsInt = 0) -> int:
+        """
+        Compute a hash for the reaction based on its ID.
+        """
+    def id(self) -> str:
+        """
+        Get the unique identifier of the reaction.
+        """
+    def is_reverse(self) -> bool:
+        """
+        Check if this is a reverse reaction rate.
+        """
+    def num_species(self) -> int:
+        """
+        Count the number of species in the reaction.
+        """
+    def peName(self) -> str:
+        """
+        Get the reaction name in (projectile, ejectile) notation (e.g., 'p(p,g)d').
+        """
+    def product_species(self) -> set[fourdst._phys.atomic.Species]:
+        """
+        Get the product species of the reaction as a set.
+        """
+    def products(self) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get a list of product species in the reaction.
+        """
+    def qValue(self) -> float:
+        """
+        Get the Q-value of the reaction in MeV.
+        """
+    def rateCoefficients(self) -> RateCoefficientSet:
+        """
+        get the set of rate coefficients.
+        """
+    def reactant_species(self) -> set[fourdst._phys.atomic.Species]:
+        """
+        Get the reactant species of the reaction as a set.
+        """
+    def reactants(self) -> list[fourdst._phys.atomic.Species]:
+        """
+        Get a list of reactant species in the reaction.
+        """
+    def sourceLabel(self) -> str:
+        """
+        Get the source label for the rate data (e.g., 'wc12w', 'st08').
+        """
+    @typing.overload
+    def stoichiometry(self, species: fourdst._phys.atomic.Species) -> int:
+        """
+        Get the stoichiometry of the reaction as a map from species to their coefficients.
+        """
+    @typing.overload
+    def stoichiometry(self) -> dict[fourdst._phys.atomic.Species, int]:
+        """
+        Get the stoichiometry of the reaction as a map from species to their coefficients.
+        """
+class ReactionSet:
+    __hash__: typing.ClassVar[None] = None
+    @staticmethod
+    def from_clones(reactions: collections.abc.Sequence[...]) -> ReactionSet:
+        """
+        Create a ReactionSet that takes ownership of the reactions by cloning the input reactions.
+        """
+    def __eq__(self, LogicalReactionSet: ReactionSet) -> bool:
+        """
+        Equality operator for LogicalReactionSets based on their contents.
+        """
+    def __getitem__(self, index: typing.SupportsInt) -> ...:
+        """
+        Get a LogicalReaclibReaction by index.
+        """
+    def __getitem___(self, id: str) -> ...:
+        """
+        Get a LogicalReaclibReaction by its ID.
+        """
+    @typing.overload
+    def __init__(self, reactions: collections.abc.Sequence[...]) -> None:
+        """
+        Construct a LogicalReactionSet from a vector of LogicalReaclibReaction objects.
+        """
+    @typing.overload
+    def __init__(self) -> None:
+        """
+        Default constructor for an empty LogicalReactionSet.
+        """
+    @typing.overload
+    def __init__(self, other: ReactionSet) -> None:
+        """
+        Copy constructor for LogicalReactionSet.
+        """
+    def __len__(self) -> int:
+        """
+        Overload len() to return the number of LogicalReactions.
+        """
+    def __ne__(self, LogicalReactionSet: ReactionSet) -> bool:
+        """
+        Inequality operator for LogicalReactionSets based on their contents.
+        """
+    def __repr__(self) -> str:
+        ...
+    def add_reaction(self, reaction: ...) -> None:
+        """
+        Add a LogicalReaclibReaction to the set.
+        """
+    def clear(self) -> None:
+        """
+        Remove all LogicalReactions from the set.
+        """
+    @typing.overload
+    def contains(self, id: str) -> bool:
+        """
+        Check if the set contains a specific LogicalReaclibReaction.
+        """
+    @typing.overload
+    def contains(self, reaction: ...) -> bool:
+        """
+        Check if the set contains a specific Reaction.
+        """
+    def contains_product(self, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if any reaction in the set has the species as a product.
+        """
+    def contains_reactant(self, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if any reaction in the set has the species as a reactant.
+        """
+    def contains_species(self, species: fourdst._phys.atomic.Species) -> bool:
+        """
+        Check if any reaction in the set involves the given species.
+        """
+    def getReactionSetSpecies(self) -> set[fourdst._phys.atomic.Species]:
+        """
+        Get all species involved in the reactions of the set as a set of Species objects.
+        """
+    def hash(self, seed: typing.SupportsInt = 0) -> int:
+        """
+        Compute a hash for the LogicalReactionSet based on its contents.
+        """
+    def remove_reaction(self, reaction: ...) -> None:
+        """
+        Remove a LogicalReaclibReaction from the set.
+        """
+    def size(self) -> int:
+        """
+        Get the number of LogicalReactions in the set.
+        """
+def get_all_reactions() -> ReactionSet:
+    """
+    Get all reactions from the REACLIB database.
+    """
+def packReactionSet(reactionSet: ReactionSet) -> ReactionSet:
+    """
+    Convert a ReactionSet to a LogicalReactionSet by aggregating reactions with the same peName.
+    """

stubs/gridfiregridfire/_gridfire/screening.pyi

@@ -0,0 +1,68 @@
+"""
+GridFire plasma screening bindings
+"""
+from __future__ import annotations
+import collections.abc
+import fourdst._phys.atomic
+import gridfire._gridfire.reaction
+import typing
+__all__: list[str] = ['BARE', 'BareScreeningModel', 'ScreeningModel', 'ScreeningType', 'WEAK', 'WeakScreeningModel', 'selectScreeningModel']
+class BareScreeningModel:
+    def __init__(self) -> None:
+        ...
+    def calculateScreeningFactors(self, reactions: gridfire._gridfire.reaction.ReactionSet, species: collections.abc.Sequence[fourdst._phys.atomic.Species], Y: collections.abc.Sequence[typing.SupportsFloat], T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> list[float]:
+        """
+        Calculate the bare plasma screening factors. This always returns 1.0 (bare)
+        """
+class ScreeningModel:
+    pass
+class ScreeningType:
+    """
+    Members:
+    
+      BARE
+    
+      WEAK
+    """
+    BARE: typing.ClassVar[ScreeningType]  # value = <ScreeningType.BARE: 0>
+    WEAK: typing.ClassVar[ScreeningType]  # value = <ScreeningType.WEAK: 1>
+    __members__: typing.ClassVar[dict[str, ScreeningType]]  # value = {'BARE': <ScreeningType.BARE: 0>, 'WEAK': <ScreeningType.WEAK: 1>}
+    def __eq__(self, other: typing.Any) -> bool:
+        ...
+    def __getstate__(self) -> int:
+        ...
+    def __hash__(self) -> int:
+        ...
+    def __index__(self) -> int:
+        ...
+    def __init__(self, value: typing.SupportsInt) -> None:
+        ...
+    def __int__(self) -> int:
+        ...
+    def __ne__(self, other: typing.Any) -> bool:
+        ...
+    def __repr__(self) -> str:
+        ...
+    def __setstate__(self, state: typing.SupportsInt) -> None:
+        ...
+    def __str__(self) -> str:
+        ...
+    @property
+    def name(self) -> str:
+        ...
+    @property
+    def value(self) -> int:
+        ...
+class WeakScreeningModel:
+    def __init__(self) -> None:
+        ...
+    def calculateScreeningFactors(self, reactions: gridfire._gridfire.reaction.ReactionSet, species: collections.abc.Sequence[fourdst._phys.atomic.Species], Y: collections.abc.Sequence[typing.SupportsFloat], T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> list[float]:
+        """
+        Calculate the weak plasma screening factors using the Salpeter (1954) model.
+        """
+def selectScreeningModel(type: ScreeningType) -> ScreeningModel:
+    """
+    Select a screening model based on the specified type. Returns a pointer to the selected model.
+    """
+BARE: ScreeningType  # value = <ScreeningType.BARE: 0>
+WEAK: ScreeningType  # value = <ScreeningType.WEAK: 1>

stubs/gridfiregridfire/_gridfire/solver.pyi

@@ -0,0 +1,157 @@
+"""
+GridFire numerical solver bindings
+"""
+from __future__ import annotations
+import collections.abc
+import fourdst._phys.atomic
+import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
+import gridfire._gridfire.type
+import types
+import typing
+__all__: list[str] = ['GridSolver', 'GridSolverContext', 'MultiZoneDynamicNetworkSolver', 'PointSolver', 'PointSolverContext', 'PointSolverTimestepContext', 'SingleZoneDynamicNetworkSolver', 'SolverContextBase']
+class GridSolver(MultiZoneDynamicNetworkSolver):
+    def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine, solver: SingleZoneDynamicNetworkSolver) -> None:
+        """
+        Initialize the GridSolver object.
+        """
+    def evaluate(self, solver_ctx: SolverContextBase, netIns: collections.abc.Sequence[gridfire._gridfire.type.NetIn]) -> list[gridfire._gridfire.type.NetOut]:
+        """
+        evaluate the dynamic engine using the dynamic engine class
+        """
+class GridSolverContext(SolverContextBase):
+    detailed_logging: bool
+    stdout_logging: bool
+    zone_completion_logging: bool
+    def __init__(self, ctx_template: gridfire._gridfire.engine.scratchpads.StateBlob) -> None:
+        ...
+    @typing.overload
+    def clear_callback(self) -> None:
+        ...
+    @typing.overload
+    def clear_callback(self, zone_idx: typing.SupportsInt) -> None:
+        ...
+    def init(self) -> None:
+        ...
+    def reset(self) -> None:
+        ...
+    @typing.overload
+    def set_callback(self, callback: collections.abc.Callable[[...], None]) -> None:
+        ...
+    @typing.overload
+    def set_callback(self, callback: collections.abc.Callable[[...], None], zone_idx: typing.SupportsInt) -> None:
+        ...
+class MultiZoneDynamicNetworkSolver:
+    def evaluate(self, solver_ctx: SolverContextBase, netIns: collections.abc.Sequence[gridfire._gridfire.type.NetIn]) -> list[gridfire._gridfire.type.NetOut]:
+        """
+        evaluate the dynamic engine using the dynamic engine class for multiple zones (using openmp if available)
+        """
+class PointSolver(SingleZoneDynamicNetworkSolver):
+    def __init__(self, engine: gridfire._gridfire.engine.DynamicEngine) -> None:
+        """
+        Initialize the PointSolver object.
+        """
+    def evaluate(self, solver_ctx: SolverContextBase, netIn: gridfire._gridfire.type.NetIn, display_trigger: bool = False, force_reinitialization: bool = False) -> gridfire._gridfire.type.NetOut:
+        """
+        evaluate the dynamic engine using the dynamic engine class
+        """
+class PointSolverContext:
+    callback: collections.abc.Callable[[PointSolverTimestepContext], None] | None
+    detailed_logging: bool
+    stdout_logging: bool
+    def __init__(self, engine_ctx: gridfire._gridfire.engine.scratchpads.StateBlob) -> None:
+        ...
+    def clear_context(self) -> None:
+        ...
+    def has_context(self) -> bool:
+        ...
+    def init(self) -> None:
+        ...
+    def init_context(self) -> None:
+        ...
+    def reset_all(self) -> None:
+        ...
+    def reset_cvode(self) -> None:
+        ...
+    def reset_user(self) -> None:
+        ...
+    @property
+    def J(self) -> _generic_SUNMatrix:
+        ...
+    @property
+    def LS(self) -> _generic_SUNLinearSolver:
+        ...
+    @property
+    def Y(self) -> _generic_N_Vector:
+        ...
+    @property
+    def YErr(self) -> _generic_N_Vector:
+        ...
+    @property
+    def abs_tol(self) -> float:
+        ...
+    @abs_tol.setter
+    def abs_tol(self, arg1: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def cvode_mem(self) -> types.CapsuleType:
+        ...
+    @property
+    def engine_ctx(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
+    @property
+    def num_steps(self) -> int:
+        ...
+    @property
+    def rel_tol(self) -> float:
+        ...
+    @rel_tol.setter
+    def rel_tol(self, arg1: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def sun_ctx(self) -> SUNContext_:
+        ...
+class PointSolverTimestepContext:
+    @property
+    def T9(self) -> float:
+        ...
+    @property
+    def currentConvergenceFailures(self) -> int:
+        ...
+    @property
+    def currentNonlinearIterations(self) -> int:
+        ...
+    @property
+    def dt(self) -> float:
+        ...
+    @property
+    def engine(self) -> gridfire._gridfire.engine.DynamicEngine:
+        ...
+    @property
+    def last_step_time(self) -> float:
+        ...
+    @property
+    def networkSpecies(self) -> list[fourdst._phys.atomic.Species]:
+        ...
+    @property
+    def num_steps(self) -> int:
+        ...
+    @property
+    def rho(self) -> float:
+        ...
+    @property
+    def state(self) -> list[float]:
+        ...
+    @property
+    def state_ctx(self) -> gridfire._gridfire.engine.scratchpads.StateBlob:
+        ...
+    @property
+    def t(self) -> float:
+        ...
+class SingleZoneDynamicNetworkSolver:
+    def evaluate(self, solver_ctx: SolverContextBase, netIn: gridfire._gridfire.type.NetIn) -> gridfire._gridfire.type.NetOut:
+        """
+        evaluate the dynamic engine using the dynamic engine class for a single zone
+        """
+class SolverContextBase:
+    pass

stubs/gridfiregridfire/_gridfire/type.pyi

@@ -0,0 +1,67 @@
+"""
+GridFire type bindings
+"""
+from __future__ import annotations
+import fourdst._phys.composition
+import typing
+__all__: list[str] = ['NetIn', 'NetOut']
+class NetIn:
+    composition: fourdst._phys.composition.Composition
+    def __init__(self) -> None:
+        ...
+    def __repr__(self) -> str:
+        ...
+    @property
+    def density(self) -> float:
+        ...
+    @density.setter
+    def density(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def dt0(self) -> float:
+        ...
+    @dt0.setter
+    def dt0(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def energy(self) -> float:
+        ...
+    @energy.setter
+    def energy(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def tMax(self) -> float:
+        ...
+    @tMax.setter
+    def tMax(self, arg0: typing.SupportsFloat) -> None:
+        ...
+    @property
+    def temperature(self) -> float:
+        ...
+    @temperature.setter
+    def temperature(self, arg0: typing.SupportsFloat) -> None:
+        ...
+class NetOut:
+    def __repr__(self) -> str:
+        ...
+    @property
+    def composition(self) -> fourdst._phys.composition.Composition:
+        ...
+    @property
+    def dEps_dRho(self) -> float:
+        ...
+    @property
+    def dEps_dT(self) -> float:
+        ...
+    @property
+    def energy(self) -> float:
+        ...
+    @property
+    def num_steps(self) -> int:
+        ...
+    @property
+    def specific_neutrino_energy_loss(self) -> float:
+        ...
+    @property
+    def specific_neutrino_flux(self) -> float:
+        ...

stubs/gridfiregridfire/_gridfire/utils/__init__.pyi

@@ -0,0 +1,18 @@
+"""
+GridFire utility method bindings
+"""
+from __future__ import annotations
+import fourdst._phys.composition
+import gridfire._gridfire.engine
+import gridfire._gridfire.engine.scratchpads
+import typing
+from . import hashing
+__all__: list[str] = ['formatNuclearTimescaleLogString', 'hash_atomic', 'hash_reaction', 'hashing']
+def formatNuclearTimescaleLogString(ctx: gridfire._gridfire.engine.scratchpads.StateBlob, engine: gridfire._gridfire.engine.DynamicEngine, Y: fourdst._phys.composition.Composition, T9: typing.SupportsFloat, rho: typing.SupportsFloat) -> str:
+    """
+    Format a string for logging nuclear timescales based on temperature, density, and energy generation rate.
+    """
+def hash_atomic(a: typing.SupportsInt, z: typing.SupportsInt) -> int:
+    ...
+def hash_reaction(reaction: ...) -> int:
+    ...

stubs/gridfiregridfire/_gridfire/utils/hashing/__init__.pyi

@@ -0,0 +1,6 @@
+"""
+module for gridfire hashing functions
+"""
+from __future__ import annotations
+from . import reaction
+__all__: list[str] = ['reaction']

stubs/gridfiregridfire/_gridfire/utils/hashing/reaction.pyi

@@ -0,0 +1,12 @@
+"""
+utility module for hashing gridfire reaction functions
+"""
+from __future__ import annotations
+import typing
+__all__: list[str] = ['mix_species', 'multiset_combine', 'splitmix64']
+def mix_species(a: typing.SupportsInt, z: typing.SupportsInt) -> int:
+    ...
+def multiset_combine(acc: typing.SupportsInt, x: typing.SupportsInt) -> int:
+    ...
+def splitmix64(x: typing.SupportsInt) -> int:
+    ...

subprojects/fourdst.wrap

@@ -1,4 +1,4 @@
 [wrap-git]
 url = https://github.com/4D-STAR/fourdst
-revision = v0.9.17
+revision = v0.9.19
 depth = 1

tests/extern/C/gridfire_evolve_multi.c

@@ -55,9 +55,11 @@ int main() {
     double Rhos[ZONES];
 
     for (size_t zone = 0; zone < ZONES; zone++) {
-        Temps[zone] = 1.0e7;
+        Temps[zone] = 1.0e7 + (double)zone * 1.0e5;  // From 10 million K to 20 million K
         Rhos[zone] = 1.5e2;
+        printf("Zone %zu - Temp: %e K, Rho: %e g/cm^3\n", zone, Temps[zone], Rhos[zone]);
     }
+    return 0;
 
     printf(" Registering species...");
     int ret = gf_register_species(ctx, NUM_SPECIES, species_names);

tests/extern/C/gridfire_evolve_single.c

@@ -50,7 +50,7 @@ int main() {
     double specific_neutrino_flux;
     double mass_lost;
 
-    const double T_in = 1.5e7; // Temperature in K
+    const double T_in = 1e7; // Temperature in K
     const double rho_in = 1.5e2; // Density in g/cm^3
 
     ret = gf_evolve(

tests/extern/fortran/gridfire_evolve_multi.f90

@@ -0,0 +1,131 @@
+program main_multi
+    use iso_c_binding
+    use gridfire_mod
+    implicit none
+
+    ! --- Constants ---
+    integer, parameter :: NUM_SPECIES = 8
+    integer, parameter :: ZONES = 100
+
+    type(GridFire) :: net
+    integer(c_int) :: ierr
+    integer :: i, z
+
+    ! --- 1. Define Species ---
+    character(len=5), dimension(NUM_SPECIES) :: species_names = [ &
+            "H-1  ", &
+            "He-3 ", &
+            "He-4 ", &
+            "C-12 ", &
+            "N-14 ", &
+            "O-16 ", &
+            "Ne-20", &
+            "Mg-24"  &
+    ]
+
+    ! Initial Mass Fractions
+    ! Standard solar-ish composition template
+    real(c_double), dimension(NUM_SPECIES) :: abundance_root = [ &
+            0.702616602672027d0,     &
+                    9.74791583949078d-06,  &
+                    0.06895512307276903d0,   &
+                    0.00025d0,               &
+                    7.855418029399437d-05, &
+                    0.0006014411598306529d0, &
+                    8.103062886768109d-05, &
+                    2.151340851063217d-05  &
+            ]
+
+    ! --- Multi-Zone Arrays ---
+    ! Fortran is Column-Major. To match C's Row-Major [ZONES][SPECIES],
+    ! we dimension as (SPECIES, ZONES) so that Species are contiguous for each Zone.
+    real(c_double), dimension(NUM_SPECIES, ZONES) :: Y_in, Y_out
+
+    ! Thermodynamic Conditions Arrays
+    real(c_double), dimension(ZONES) :: T_arr
+    real(c_double), dimension(ZONES) :: rho_arr
+
+    ! Output Arrays
+    real(c_double), dimension(ZONES) :: energy_out
+    real(c_double), dimension(ZONES) :: dedt
+    real(c_double), dimension(ZONES) :: dedrho
+    real(c_double), dimension(ZONES) :: snu_e_loss
+    real(c_double), dimension(ZONES) :: snu_flux
+    real(c_double), dimension(ZONES) :: dmass
+
+    ! Time settings
+    real(c_double) :: tMax = 3.0e17  ! 10 Gyr total time
+    real(c_double) :: dt0 = 1e-12    ! Starting Timestep
+
+    ! --- 2. Setup Data ---
+    print *, "Testing GridFireEvolve Multi (Fortran)"
+    print *, " Number of zones: ", ZONES
+    print *, " Number of species: ", NUM_SPECIES
+
+    do z = 1, ZONES
+        ! Initialize Abundances (Copy root to every zone)
+        Y_in(:, z) = abundance_root
+
+        ! Initialize T and Rho gradient
+        ! T: 1.0e7 -> 2.0e7 in steps of 1.0e5
+        T_arr(z) = 1.0d7 + dble(z-1) * 1.0d5
+        rho_arr(z) = 1.5d2
+
+        if (z <= 3) then
+            print '(A, I0, A, ES12.5, A, ES12.5, A)', &
+                    " Zone ", z-1, " - Temp: ", T_arr(z), " K, Rho: ", rho_arr(z), " g/cm^3"
+        end if
+    end do
+
+    ! --- 3. Initialize GridFire Multi-Zone ---
+    print *, "Initializing GridFire..."
+    ! Note: Pass integer(c_size_t) for zone count
+    call net%gff_init(MULTI_ZONE, int(ZONES, c_size_t))
+
+    ! --- 4. Register Species ---
+    print *, "Registering species..."
+    call net%gff_register_species(species_names)
+
+    ! --- 5. Configure Engine & Solver ---
+    print *, "Setting up Main Sequence Policy..."
+    call net%gff_setup_policy("MAIN_SEQUENCE_POLICY", abundance_root)
+
+    print *, "Setting up CVODE Solver..."
+    call net%gff_setup_solver("CVODE")
+
+    ! --- 6. Evolve ---
+    print *, "Evolving system..."
+
+    ! Note: We pass the arrays T_arr and rho_arr.
+    call net%gff_evolve(Y_in, T_arr, rho_arr, tMax, dt0, &
+            Y_out, energy_out, dedt, dedrho, &
+            snu_e_loss, snu_flux, dmass, ierr)
+
+    if (ierr /= 0) then
+        print *, "Evolution Failed with error code: ", ierr
+        print *, "Error Message: ", net%gff_get_last_error()
+        call net%gff_free()
+        stop
+    end if
+
+    ! --- 7. Report Results ---
+    print *, ""
+    print *, "--- Results (First 3 Zones) ---"
+
+    do z = 1, 3
+        print *, "=== Zone ", z-1, " ==="
+        print '(A, ES12.5, A)', " Energy Gen:  ", energy_out(z), " erg/g/s"
+        print '(A, ES12.5)',    " Mass Lost:   ", dmass(z)
+        print '(A, ES12.5)',    " T:           ", T_arr(z)
+
+        print *, " Key Abundances (H-1, He-4, C-12):"
+        print '(3(ES12.5, 1X))', Y_out(1, z), Y_out(3, z), Y_out(4, z)
+        print *, ""
+    end do
+
+    print *, "... (Zones 4-", ZONES, " omitted) ..."
+
+    ! --- 8. Cleanup ---
+    call net%gff_free()
+
+end program main_multi

tests/extern/fortran/gridfire_evolve_single.f90

@@ -41,30 +41,31 @@ program main
     ! Thermodynamic Conditions (Solar Core-ish)
     real(c_double) :: T = 1.5e7      ! 15 Million K
     real(c_double) :: rho = 150.0e0  ! 150 g/cm^3
-    real(c_double) :: dt = 3.0e17     ! 1 second timestep
+    real(c_double) :: tMax = 3.0e17  ! 10 Gyr total time
+    real(c_double) :: dt0 = 1e-12    ! Starting Timestep
 
     ! --- 2. Initialize GridFire ---
     print *, "Initializing GridFire..."
-    call net%gff_init()
+    call net%gff_init(SINGLE_ZONE)
 
     ! --- 3. Register Species ---
     print *, "Registering species..."
-    call net%register_species(species_names)
+    call net%gff_register_species(species_names)
 
     ! --- 4. Configure Engine & Solver ---
     print *, "Setting up Main Sequence Policy..."
-    call net%setup_policy("MAIN_SEQUENCE_POLICY", Y_in)
+    call net%gff_setup_policy("MAIN_SEQUENCE_POLICY", Y_in)
 
     print *, "Setting up CVODE Solver..."
-    call net%setup_solver("CVODE")
+    call net%gff_setup_solver("CVODE")
 
     ! --- 5. Evolve ---
-    print *, "Evolving system (dt =", dt, "s)..."
-    call net%evolve(Y_in, T, rho, dt, Y_out, energy_out, dedt, dedrho, snu_e_loss, snu_flux, dmass, ierr)
+    print *, "Evolving system (t = ", tMax, "s dt =", dt0, "s)..."
+    call net%gff_evolve(Y_in, T, rho, tMax, dt0, Y_out, energy_out, dedt, dedrho, snu_e_loss, snu_flux, dmass, ierr)
 
     if (ierr /= 0) then
         print *, "Evolution Failed with error code: ", ierr
-        print *, "Error Message: ", net%get_last_error()
+        print *, "Error Message: ", net%gff_get_last_error()
         call net%gff_free() ! Always cleanup
         stop
     end if

tests/extern/fortran/meson.build

@@ -1,5 +1,11 @@
-executable('test_fortran_extern', 'gridfire_evolve.f90',
+executable('gf_fortran_single_zone_test', 'gridfire_evolve_single.f90',
   install: false,
   fortran_args: ['-Wall', '-Wextra'],
   dependencies: [gridfire_fortran_dep]
-)
+)
+
+executable('gf_fortran_multi_zone_test', 'gridfire_evolve_multi.f90',
+           install: false,
+           fortran_args: ['-Wall', '-Wextra'],
+           dependencies: [gridfire_fortran_dep]
+)

tests/graphnet_sandbox/main.cpp

@@ -248,7 +248,7 @@ int main() {
     std::array<NetIn, nZones> netIns;
     for (size_t zone = 0; zone < nZones; ++zone) {
         netIns[zone] = netIn;
-        netIns[zone].temperature = 1.0e7;
+        netIns[zone].temperature = 1.5e7;
     }
 
     const solver::PointSolver localSolver(engine);
@@ -256,4 +256,4 @@ int main() {
     const solver::GridSolver gridSolver(engine, localSolver);
 
     std::vector<NetOut> netOuts = gridSolver.evaluate(solverCtx, netIns | std::ranges::to<std::vector>());
-}
+}

tests/python/py_test_multi.py

@@ -0,0 +1,79 @@
+from gridfire.solver import GridSolver, PointSolver, GridSolverContext
+from gridfire.policy import MainSequencePolicy
+from fourdst.composition import Composition
+
+from fourdst.composition import CanonicalComposition
+from fourdst.atomic import Species
+from gridfire.type import NetIn
+
+import numpy as np
+
+def rescale_composition(comp_ref : Composition, ZZs : float, Y_primordial : float = 0.248) -> Composition:
+    CC : CanonicalComposition  = comp_ref.getCanonicalComposition()
+
+    dY_dZ = (CC.Y - Y_primordial) / CC.Z
+
+    Z_new = CC.Z * (10**ZZs)
+    Y_bulk_new = Y_primordial + (dY_dZ * Z_new)
+    X_new = 1.0 - Z_new - Y_bulk_new
+
+    if X_new < 0: raise ValueError(f"ZZs={ZZs} yields unphysical composition (X < 0)")
+
+    ratio_H  = X_new / CC.X if CC.X > 0 else 0
+    ratio_He = Y_bulk_new / CC.Y if CC.Y > 0 else 0
+    ratio_Z  = Z_new / CC.Z if CC.Z > 0 else 0
+
+    Y_new_list = []
+    newComp : Composition = Composition()
+    s: Species
+    for s  in comp_ref.getRegisteredSpecies():
+        Xi_ref = comp_ref.getMassFraction(s)
+
+        if s.el() == "H":
+            Xi_new = Xi_ref * ratio_H
+        elif s.el() == "He":
+            Xi_new = Xi_ref * ratio_He
+        else:
+            Xi_new = Xi_ref * ratio_Z
+
+        Y = Xi_new / s.mass()
+        newComp.registerSpecies(s)
+        newComp.setMolarAbundance(s, Y)
+
+    return newComp
+
+def init_composition(ZZs : float = 0) -> Composition:
+    Y_solar = [7.0262E-01, 9.7479E-06, 6.8955E-02, 2.5000E-04, 7.8554E-05, 6.0144E-04, 8.1031E-05, 2.1513E-05]
+    S = ["H-1", "He-3", "He-4", "C-12", "N-14", "O-16", "Ne-20", "Mg-24"]
+    return rescale_composition(Composition(S, Y_solar), ZZs)
+
+
+def init_netIn(temp: float, rho: float, time: float, comp: Composition) -> NetIn:
+    n : NetIn = NetIn()
+    n.temperature = temp
+    n.density = rho
+    n.tMax = time
+    n.dt0 = 1e-12
+    n.composition = comp
+    return n
+
+def years_to_seconds(years: float) -> float:
+    return years * 3.1536e7
+
+
+def main():
+    C = init_composition()
+    temps = np.linspace(1.5e7, 2e7, 100)
+    rhos = np.linspace(1.5e2, 1.5e2, 100)
+    netIns = []
+    for T, R in zip(temps, rhos):
+        netIns.append(init_netIn(T, R, years_to_seconds(100e6), C))
+    policy = MainSequencePolicy(C)
+    construct = policy.construct()
+    local_solver = PointSolver(construct.engine)
+    grid_solver = GridSolver(construct.engine, local_solver)
+    solver_ctx = GridSolverContext(construct.scratch_blob)
+    results = grid_solver.evaluate(solver_ctx, netIns)
+
+if __name__ == "__main__":
+    main()

tests/python/py_test_single.py

@@ -0,0 +1,73 @@
+from gridfire.solver import PointSolver, PointSolverContext
+from gridfire.policy import MainSequencePolicy
+from fourdst.composition import Composition
+
+from fourdst.composition import CanonicalComposition
+from fourdst.atomic import Species
+from gridfire.type import NetIn
+
+def rescale_composition(comp_ref : Composition, ZZs : float, Y_primordial : float = 0.248) -> Composition:
+    CC : CanonicalComposition  = comp_ref.getCanonicalComposition()
+
+    dY_dZ = (CC.Y - Y_primordial) / CC.Z
+
+    Z_new = CC.Z * (10**ZZs)
+    Y_bulk_new = Y_primordial + (dY_dZ * Z_new)
+    X_new = 1.0 - Z_new - Y_bulk_new
+
+    if X_new < 0: raise ValueError(f"ZZs={ZZs} yields unphysical composition (X < 0)")
+
+    ratio_H  = X_new / CC.X if CC.X > 0 else 0
+    ratio_He = Y_bulk_new / CC.Y if CC.Y > 0 else 0
+    ratio_Z  = Z_new / CC.Z if CC.Z > 0 else 0
+
+    Y_new_list = []
+    newComp : Composition = Composition()
+    s: Species
+    for s  in comp_ref.getRegisteredSpecies():
+        Xi_ref = comp_ref.getMassFraction(s)
+
+        if s.el() == "H":
+            Xi_new = Xi_ref * ratio_H
+        elif s.el() == "He":
+            Xi_new = Xi_ref * ratio_He
+        else:
+            Xi_new = Xi_ref * ratio_Z
+
+        Y = Xi_new / s.mass()
+        newComp.registerSpecies(s)
+        newComp.setMolarAbundance(s, Y)
+
+    return newComp
+
+def init_composition(ZZs : float = 0) -> Composition:
+    Y_solar = [7.0262E-01, 9.7479E-06, 6.8955E-02, 2.5000E-04, 7.8554E-05, 6.0144E-04, 8.1031E-05, 2.1513E-05]
+    S = ["H-1", "He-3", "He-4", "C-12", "N-14", "O-16", "Ne-20", "Mg-24"]
+    return rescale_composition(Composition(S, Y_solar), ZZs)
+
+
+def init_netIn(temp: float, rho: float, time: float, comp: Composition) -> NetIn:
+    n : NetIn = NetIn()
+    n.temperature = temp
+    n.density = rho
+    n.tMax = time
+    n.dt0 = 1e-12
+    n.composition = comp
+    return n
+
+def years_to_seconds(years: float) -> float:
+    return years * 3.1536e7
+
+
+def main():
+    C = init_composition()
+    netIn = init_netIn(2.75e6, 1.5e1, years_to_seconds(10e9), C)
+    policy = MainSequencePolicy(C)
+    construct = policy.construct()
+    solver = PointSolver(construct.engine)
+    solver_ctx = PointSolverContext(construct.scratch_blob)
+    results = solver.evaluate(solver_ctx, netIn, False, False)
+    print(results)
+
+if __name__ == "__main__":
+    main()

tests/python/test.py

@@ -1,51 +0,0 @@
-from gridfire.engine import GraphEngine, MultiscalePartitioningEngineView, AdaptiveEngineView
-from gridfire.solver import DirectNetworkSolver
-from gridfire.type import NetIn
-
-from fourdst.composition import Composition
-from fourdst.atomic import species
-
-symbols : list[str] = ["H-1", "He-3", "He-4", "C-12", "N-14", "O-16", "Ne-20", "Mg-24"]
-X : list[float]     = [0.708, 2.94e-5, 0.276, 0.003, 0.0011, 9.62e-3, 1.62e-3, 5.16e-4]
-
-
-comp = Composition()
-comp.registerSymbol(symbols)
-comp.setMassFraction(symbols, X)
-comp.finalize(True)
-
-print(f"Initial H-1 mass fraction {comp.getMassFraction("H-1")}")
-
-netIn = NetIn()
-netIn.composition = comp
-netIn.temperature = 1.5e7
-netIn.density = 1.6e2
-netIn.tMax = 4e17
-netIn.dt0 = 1e-12
-
-baseEngine = GraphEngine(netIn.composition, 2)
-baseEngine.setUseReverseReactions(False)
-
-qseEngine = MultiscalePartitioningEngineView(baseEngine)
-
-adaptiveEngine = AdaptiveEngineView(qseEngine)
-
-solver = DirectNetworkSolver(adaptiveEngine)
-
-
-def callback(context):
-    H1Index = context.engine.getSpeciesIndex(species["H-1"])
-    He4Index = context.engine.getSpeciesIndex(species["He-4"])
-    C12ndex = context.engine.getSpeciesIndex(species["C-12"])
-    Mgh24ndex = context.engine.getSpeciesIndex(species["Mg-24"])
-    print(f"Time: {context.t}, H-1: {context.state[H1Index]}, He-4: {context.state[He4Index]}, C-12: {context.state[C12ndex]}, Mg-24: {context.state[Mgh24ndex]}")
-
-# solver.set_callback(callback)
-results = solver.evaluate(netIn)
-
-print(f"Final H-1 mass fraction {results.composition.getMassFraction("H-1")}")
-
-
-
-
-

tools/cli/meson.build

@@ -1 +0,0 @@
-subdir('gf_quick')

tools/gf_multi/main.cpp

@@ -0,0 +1,393 @@
+// ReSharper disable CppUnusedIncludeDirective
+#include <iostream>
+#include <fstream>
+#include <chrono>
+#include <thread>
+#include <format>
+
+#include "gridfire/gridfire.h"
+#include <cppad/utility/thread_alloc.hpp> // Required for parallel_setup
+
+#include "fourdst/composition/composition.h"
+#include "fourdst/logging/logging.h"
+#include "fourdst/atomic/species.h"
+#include "fourdst/composition/utils.h"
+
+#include "quill/Logger.h"
+#include "quill/Backend.h"
+#include "CLI/CLI.hpp"
+
+#include <clocale>
+
+#include "gridfire/utils/gf_omp.h"
+
+static std::terminate_handler g_previousHandler = nullptr;
+static std::vector<std::pair<double, std::unordered_map<std::string, std::pair<double, double>>>> g_callbackHistory;
+static bool s_wrote_abundance_history = false;
+void quill_terminate_handler();
+
+enum class ScalingTypes {
+    LINEAR,
+    LOG,
+    GEOM
+};
+
+std::map<std::string, ScalingTypes> scaling_type_map = {
+    {"linear", ScalingTypes::LINEAR},
+    {"log",    ScalingTypes::LOG},
+    {"geom",   ScalingTypes::GEOM}
+};
+
+template<typename T>
+concept IsOrderableLinear = std::floating_point<T>;
+
+template<typename T>
+concept IsOrderableLog = std::floating_point<T>;
+
+template<IsOrderableLinear T>
+constexpr std::vector<T> linspace(T start, T end, size_t N) {
+    if (N == 0) {
+        return {};
+    }
+    if (N == 1) {
+        return {start};
+    }
+
+    std::vector<T> result{};
+    result.resize(N);
+
+    for (std::size_t i = 0; i < N; ++i) {
+        const T t = static_cast<T>(i) / static_cast<T>(N - 1);
+        result[i] = std::lerp(start, end, t);
+    }
+
+    return result;
+}
+
+template<IsOrderableLog T>
+std::vector<T> logspace(T start, T end, size_t N) {
+    if (N == 0) {
+        return {};
+    }
+    if (N == 1) {
+        return {start};
+    }
+
+    std::vector<T> result{};
+    result.resize(N);
+
+    const T log_start = start;
+    const T log_end = end;
+
+    for (std::size_t i = 0; i < N; ++i) {
+        const T t = static_cast<T>(i) / static_cast<T>(N - 1);
+        const T exponent = std::lerp(log_start, log_end, t);
+        result[i] = std::pow(static_cast<T>(10), exponent);
+    }
+
+    return result;
+}
+
+template<IsOrderableLog T>
+std::vector<T> geomspace(T start, T end, size_t N) {
+    if (start <= 0 || end <= 0) {
+        throw std::domain_error("geomspace requires positive start/end values");
+    }
+
+    const T log_start = std::log10(start);
+    const T log_end = std::log10(end);
+
+    std::vector<T> result = logspace<T>(log_start, log_end, N);
+
+    result[0] = start;
+    result[N - 1] = end;
+
+    return result;
+}
+
+
+
+gridfire::NetIn init(const double temp, const double rho, const double tMax) {
+    std::setlocale(LC_ALL, "");
+    g_previousHandler = std::set_terminate(quill_terminate_handler);
+    quill::Logger* logger = fourdst::logging::LogManager::getInstance().getLogger("log");
+    logger->set_log_level(quill::LogLevel::Info);
+
+    using namespace gridfire;
+    const std::vector<double> X            = {0.7081145999999999, 2.94e-5, 0.276, 0.003, 0.0011, 9.62e-3, 1.62e-3, 5.16e-4};
+    const std::vector<std::string> symbols = {"H-1", "He-3", "He-4", "C-12", "N-14", "O-16", "Ne-20", "Mg-24"};
+
+
+    const fourdst::composition::Composition composition = fourdst::composition::buildCompositionFromMassFractions(symbols, X);
+
+    NetIn netIn;
+    netIn.composition = composition;
+    netIn.temperature = temp;
+    netIn.density = rho;
+    netIn.energy = 0;
+
+    netIn.tMax = tMax;
+    netIn.dt0 = 1e-12;
+
+    return netIn;
+}
+
+void log_results(const gridfire::NetOut& netOut, const gridfire::NetIn& netIn) {
+    std::vector<fourdst::atomic::Species> logSpecies = {
+        fourdst::atomic::H_1,
+        fourdst::atomic::He_3,
+        fourdst::atomic::He_4,
+        fourdst::atomic::C_12,
+        fourdst::atomic::N_14,
+        fourdst::atomic::O_16,
+        fourdst::atomic::Ne_20,
+        fourdst::atomic::Mg_24
+    };
+
+    std::vector<double> initial;
+    std::vector<double> final;
+    std::vector<double> delta;
+    std::vector<double> fractional;
+    for (const auto& species : logSpecies) {
+        double initial_X = netIn.composition.getMassFraction(species);
+        double final_X = netOut.composition.getMassFraction(species);
+        double delta_X = final_X - initial_X;
+        double fractionalChange = (delta_X) / initial_X * 100.0;
+
+        initial.push_back(initial_X);
+        final.push_back(final_X);
+        delta.push_back(delta_X);
+        fractional.push_back(fractionalChange);
+    }
+
+    initial.push_back(0.0); // Placeholder for energy
+    final.push_back(netOut.energy);
+    delta.push_back(netOut.energy);
+    fractional.push_back(0.0); // Placeholder for energy
+
+    initial.push_back(0.0);
+    final.push_back(netOut.dEps_dT);
+    delta.push_back(netOut.dEps_dT);
+    fractional.push_back(0.0);
+
+    initial.push_back(0.0);
+    final.push_back(netOut.dEps_dRho);
+    delta.push_back(netOut.dEps_dRho);
+    fractional.push_back(0.0);
+
+    initial.push_back(0.0);
+    final.push_back(netOut.specific_neutrino_energy_loss);
+    delta.push_back(netOut.specific_neutrino_energy_loss);
+    fractional.push_back(0.0);
+
+    initial.push_back(0.0);
+    final.push_back(netOut.specific_neutrino_flux);
+    delta.push_back(netOut.specific_neutrino_flux);
+    fractional.push_back(0.0);
+
+    initial.push_back(netIn.composition.getMeanParticleMass());
+    final.push_back(netOut.composition.getMeanParticleMass());
+    delta.push_back(final.back() - initial.back());
+    fractional.push_back((final.back() - initial.back()) / initial.back() * 100.0);
+
+    std::vector<std::string> rowLabels = [&]() -> std::vector<std::string> {
+        std::vector<std::string> labels;
+        for (const auto& species : logSpecies) {
+            labels.emplace_back(species.name());
+        }
+        labels.emplace_back("ε");
+        labels.emplace_back("dε/dT");
+        labels.emplace_back("dε/dρ");
+        labels.emplace_back("Eν");
+        labels.emplace_back("Fν");
+        labels.emplace_back("<μ>");
+        return labels;
+    }();
+
+
+    gridfire::utils::Column<std::string> paramCol("Parameter", rowLabels);
+    gridfire::utils::Column<double> initialCol("Initial", initial);
+    gridfire::utils::Column<double> finalCol  ("Final", final);
+    gridfire::utils::Column<double> deltaCol  ("δ", delta);
+    gridfire::utils::Column<double> percentCol("% Change", fractional);
+
+    std::vector<std::unique_ptr<gridfire::utils::ColumnBase>> columns;
+    columns.push_back(std::make_unique<gridfire::utils::Column<std::string>>(paramCol));
+    columns.push_back(std::make_unique<gridfire::utils::Column<double>>(initialCol));
+    columns.push_back(std::make_unique<gridfire::utils::Column<double>>(finalCol));
+    columns.push_back(std::make_unique<gridfire::utils::Column<double>>(deltaCol));
+    columns.push_back(std::make_unique<gridfire::utils::Column<double>>(percentCol));
+
+
+    gridfire::utils::print_table("Simulation Results", columns);
+}
+
+
+void record_abundance_history_callback(const gridfire::solver::PointSolverTimestepContext& ctx) {
+    s_wrote_abundance_history = true;
+    const auto& engine = ctx.engine;
+    // std::unordered_map<std::string, std::pair<double, double>> abundances;
+    std::vector<double> Y;
+    for (const auto& species : engine.getNetworkSpecies(ctx.state_ctx)) {
+        const size_t sid = engine.getSpeciesIndex(ctx.state_ctx, species);
+        double y =  N_VGetArrayPointer(ctx.state)[sid];
+        Y.push_back(y > 0.0 ? y : 0.0); // Regularize tiny negative abundances to zero
+    }
+
+    fourdst::composition::Composition comp(engine.getNetworkSpecies(ctx.state_ctx), Y);
+
+
+    std::unordered_map<std::string, std::pair<double, double>> abundances;
+    for (const auto& sp : comp | std::views::keys) {
+        abundances.emplace(std::string(sp.name()), std::make_pair(sp.mass(), comp.getMolarAbundance(sp)));
+    }
+    g_callbackHistory.emplace_back(ctx.t, abundances);
+}
+
+
+void save_callback_data(const std::string_view filename) {
+    std::set<std::string> unique_species;
+    for (const auto &abundances: g_callbackHistory | std::views::values) {
+        for (const auto &species_name: abundances | std::views::keys) {
+            unique_species.insert(species_name);
+        }
+    }
+    std::ofstream csvFile(filename.data(), std::ios::out);
+    csvFile << "t,";
+
+    size_t i = 0;
+    for (const auto& species_name : unique_species) {
+        csvFile << species_name;
+        if (i < unique_species.size() - 1) {
+            csvFile << ",";
+        }
+        i++;
+    }
+
+    csvFile << "\n";
+
+    for (const auto& [time, data] : g_callbackHistory) {
+        csvFile << time << ",";
+        size_t j = 0;
+        for (const auto& species_name : unique_species) {
+            if (!data.contains(species_name)) {
+                csvFile << "0.0";
+            } else {
+                csvFile << data.at(species_name).second;
+            }
+            if (j < unique_species.size() - 1) {
+                csvFile << ",";
+            }
+            ++j;
+        }
+        csvFile << "\n";
+    }
+
+    csvFile.close();
+}
+
+void log_callback_data(const double temp) {
+    if (s_wrote_abundance_history) {
+        std::cout << "Saving abundance history to abundance_history.csv" << std::endl;
+        save_callback_data("abundance_history_" + std::to_string(temp) + ".csv");
+    }
+
+}
+
+void quill_terminate_handler()
+{
+    log_callback_data(1.5e7);
+    quill::Backend::stop();
+    if (g_previousHandler)
+        g_previousHandler();
+    else
+        std::abort();
+}
+
+void callback_main(const gridfire::solver::PointSolverTimestepContext& ctx) {
+    record_abundance_history_callback(ctx);
+}
+
+int main(int argc, char** argv) {
+    GF_PAR_INIT();
+    using namespace gridfire;
+
+    double tMin = 1e7;
+    double tMax = 3e7;
+    ScalingTypes tempScaling = ScalingTypes::LINEAR;
+
+    double rhoMin = 1e2;
+    double rhoMax = 1e3;
+    ScalingTypes rhoScaling = ScalingTypes::LOG;
+
+    double evolveTime = 1e13;
+    size_t shells = 10;
+
+
+    CLI::App app("GridFire Quick CLI Test");
+    // Add temp, rho, and tMax as options if desired
+    app.add_option("--tMin", tMin, "Initial Temperature")->default_val(std::format("{:5.2E}", tMin));
+    app.add_option("--tMax", tMax, "Maximum Temperature")->default_val(std::format("{:5.2E}", tMax));
+    app.add_option("--tempScaling", tempScaling, "Temperature Scaling Type (linear, log, geom)")->default_val(ScalingTypes::LINEAR)->transform(CLI::CheckedTransformer(scaling_type_map, CLI::ignore_case));
+
+    app.add_option("--rhoMin", rhoMin, "Initial Density")->default_val(std::format("{:5.2E}", rhoMin));
+    app.add_option("--rhoMax", rhoMax, "Maximum Density")->default_val(std::format("{:5.2E}", rhoMax));
+    app.add_option("--rhoScaling", rhoScaling, "Density Scaling Type (linear, log, geom)")->default_val(ScalingTypes::LOG)->transform(CLI::CheckedTransformer(scaling_type_map, CLI::ignore_case));
+
+    app.add_option("--shell", shells, "Number of Shells")->default_val(shells);
+
+    app.add_option("--evolveTime", evolveTime, "Evolution Time")->default_val(std::format("{:5.2E}", evolveTime));
+
+
+    CLI11_PARSE(app, argc, argv);
+    NetIn rootNetIn = init(tMin, tMax, evolveTime);
+
+    std::vector<double> temps;
+    std::vector<double> densities;
+
+    switch (tempScaling) {
+        case ScalingTypes::LINEAR:
+            temps = linspace<double>(tMin, tMax, static_cast<size_t>(shells));
+            break;
+        case ScalingTypes::LOG:
+            temps = logspace<double>(std::log10(tMin), std::log10(tMax), static_cast<size_t>(shells));
+            break;
+        case ScalingTypes::GEOM:
+            temps = geomspace<double>(tMin, tMax, static_cast<size_t>(shells));
+            break;
+    }
+    switch (rhoScaling) {
+        case ScalingTypes::LINEAR:
+            densities = linspace<double>(rhoMin, rhoMax, static_cast<size_t>(shells));
+            break;
+        case ScalingTypes::LOG:
+            densities = logspace<double>(std::log10(rhoMin), std::log10(rhoMax), static_cast<size_t>(shells));
+            break;
+        case ScalingTypes::GEOM:
+            densities = geomspace<double>(rhoMin, rhoMax, static_cast<size_t>(shells));
+            break;
+    }
+
+    std::vector<NetIn> netIns;
+    netIns.reserve(shells);
+    for (size_t i = 0; i < static_cast<size_t>(shells); ++i) {
+        NetIn netIn = rootNetIn;
+        netIn.temperature = temps[i];
+        netIn.density = densities[i];
+        netIns.emplace_back(netIn);
+    }
+
+    policy::MainSequencePolicy stellarPolicy(rootNetIn.composition);
+    auto [engine, ctx_template] = stellarPolicy.construct();
+
+    solver::PointSolver point_solver(engine);
+    solver::GridSolver grid_solver(engine, point_solver);
+    solver::GridSolverContext solver_ctx(*ctx_template);
+
+
+    std::vector<NetOut> results = grid_solver.evaluate(solver_ctx, netIns);
+    for (size_t i = 0; i < results.size(); ++i) {
+        std::cout << "=== Shell " << i << " ===" << std::endl;
+        log_results(results[i], netIns[i]);
+    }
+}

tools/gf_multi/meson.build

@@ -0,0 +1 @@
+executable('gf_multi', 'main.cpp', dependencies: [gridfire_dep, cli11_dep])

tools/gf_quick/main.cpp

@@ -346,21 +346,15 @@ int main(int argc, char** argv) {
     double temp = 1.5e7;
     double rho = 1.5e2;
     double tMax = 3.1536e+16;
-    double X = 0.7;
-    double Z = 0.02;
 
 
     CLI::App app("GridFire Quick CLI Test");
-    // Add temp, rho, and tMax as options if desired
     app.add_option("--temp", temp, "Initial Temperature")->default_val(std::format("{:5.2E}", temp));
     app.add_option("--rho", rho, "Initial Density")->default_val(std::format("{:5.2E}", rho));
     app.add_option("--tmax", tMax, "Maximum Time")->default_val(std::format("{:5.2E}", tMax));
-    // app.add_option("--X", X, "Target Hydrogen Mass Fraction")->default_val(std::format("{:5.2f}", X));
-    // app.add_option("--Z", Z, "Target Metal Mass Fraction")->default_val(std::format("{:5.2f}", Z));
 
     CLI11_PARSE(app, argc, argv);
     NetIn netIn = init(temp, rho, tMax);
-    // netIn.composition = rescale(netIn.composition, X, Z);
 
     policy::MainSequencePolicy stellarPolicy(netIn.composition);
     auto [engine, ctx_template] = stellarPolicy.construct();
@@ -370,4 +364,4 @@ int main(int argc, char** argv) {
 
     NetOut result = solver.evaluate(solver_context, netIn);
     log_results(result, netIn);
-}
+}

tools/meson.build

@@ -1,4 +1,5 @@
 if get_option('build_tools')
-    subdir('config')
-    subdir('cli')
+    subdir('gf_config')
+    subdir('gf_quick')
+    subdir('gf_multi')
 endif

utils/wheels/build-wheels-macos_aarch64.sh

@@ -31,18 +31,6 @@ cd "${TMPDIR}/project"
 # 3. Build Configuration
 export MACOSX_DEPLOYMENT_TARGET=15.0
 
-# Meson options passed to pip via config-settings
-# Note: We use an array to keep the command clean
-MESON_ARGS=(
-    "-Csetup-args=-Dunity=off"
-    "-Csetup-args=-Dbuild-python=true"
-    "-Csetup-args=-Dbuild-fortran=false"
-    "-Csetup-args=-Dbuild-tests=false"
-    "-Csetup-args=-Dpkg-config=false"
-    "-Csetup-args=-Dunity-safe=true"
-)
-
-PYTHON_VERSIONS=("3.8.20" "3.9.23" "3.10.18" "3.11.13" "3.12.11" "3.13.5" "3.13.5t" "3.14.0rc1" "3.14.0rc1t" 'pypy3.10-7.3.19' "pypy3.11-7.3.20")
 PYTHON_VERSIONS=("3.9.23" "3.10.18" "3.11.13" "3.12.11" "3.13.5" "3.13.5t" "3.14.0rc1" "3.14.0rc1t" 'pypy3.10-7.3.19' "pypy3.11-7.3.20")
 
 if ! command -v pyenv &> /dev/null; then
@@ -56,12 +44,6 @@ for PY_VERSION in "${PYTHON_VERSIONS[@]}"; do
   (
     set -e
 
-    # Check if version exists in pyenv
-    if ! pyenv versions --bare --filter="${PY_VERSION}" &>/dev/null; then
-        echo "⚠️  Python version matching '${PY_VERSION}' not found by pyenv. Skipping."
-        continue
-    fi
-    
     pyenv shell "${PY_VERSION}"
     PY="$(pyenv which python)"
     
@@ -70,14 +52,14 @@ for PY_VERSION in "${PYTHON_VERSIONS[@]}"; do
     echo "----------------------------------------------------------------"
 
     # Install build deps explicitly so we can skip build isolation
-    "$PY" -m pip install --upgrade pip setuptools wheel meson meson-python delocate
+    "$PY" -m pip install --upgrade pip setuptools wheel meson-python delocate
+    "$PY" -m pip install meson==1.9.1
+
+    echo "➤ Building wheel with ccache enabled"
+    echo "➤ Found meson version $(meson --version)"
 
-    # PERF: --no-build-isolation prevents creating a fresh venv and reinstalling meson/ninja 
     # for every single build, saving significant I/O and network time.
-    CC="ccache clang" CXX="ccache clang++" "$PY" -m pip wheel . \
-      --no-build-isolation \
-      "${MESON_ARGS[@]}" \
-       -w "${WHEEL_DIR}" -vv
+    CC="ccache clang" CXX="ccache clang++" "$PY" -m pip wheel . --no-build-isolation -w "${WHEEL_DIR}" -v
 
     # We expect exactly one new wheel in the tmp dir per iteration
     CURRENT_WHEEL=$(find "${WHEEL_DIR}" -name "*.whl" | head -n 1)