evoxels 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

evoxels/inversion.py

@@ -72,7 +72,7 @@ class InversionModel:
         solver = PseudoSpectralIMEX_dfx(problem.fourier_symbol)
 
         solution = dfx.diffeqsolve(
-            dfx.ODETerm(lambda t, y, args: problem.rhs(y, t)),
+            dfx.ODETerm(lambda t, y, args: problem.rhs(t, y)),
             solver,
             t0=saveat.subs.ts[0],
             t1=saveat.subs.ts[-1],

evoxels/precompiled_solvers/allen_cahn.py

@@ -23,7 +23,7 @@ def run_allen_cahn_solver(
     plot_bounds = None,
 ):
     """
-    Runs the Cahn-Hilliard solver with a predefined problem and timestepper.
+    Solves time-dependent Allen-Cahn problem with ForwardEuler timestepper.
     """
     solver = TimeDependentSolver(
         voxelfields,

evoxels/precompiled_solvers/cahn_hilliard.py

@@ -20,7 +20,7 @@ def run_cahn_hilliard_solver(
     plot_bounds = None,
 ):
     """
-    Runs the Cahn-Hilliard solver with a predefined problem and timestepper.
+    Solves time-dependent Cahn-Hilliard problem with PseudoSpectralIMEX timestepper.
     """
     solver = TimeDependentSolver(
         voxelfields,

evoxels/problem_definition.py

@@ -13,17 +13,17 @@ _i_ = slice(1, -1)  # inner elements [1:-1]
 class ODE(ABC):
     @property
     @abstractmethod
-    def order(self):
+    def order(self) -> int:
         """Spatial order of convergence for numerical right-hand side."""
         pass
 
     @abstractmethod
-    def rhs_analytic(self, u, t):
+    def rhs_analytic(self, t, u):
         """Sympy expression of the problem right-hand side.
 
         Args:
-            u : Sympy function of current state.
             t (float): Current time.
+            u : Sympy function of current state.
 
         Returns:
             Sympy function of problem right-hand side.
@@ -31,12 +31,12 @@ class ODE(ABC):
         pass
 
     @abstractmethod
-    def rhs(self, u, t):
+    def rhs(self, t, u):
         """Numerical right-hand side of the ODE system.
 
         Args:
-            u (array): Current state.
             t (float): Current time.
+            u (array): Current state.
 
         Returns:
             Same type as ``u`` containing the time derivative.
@@ -120,9 +120,11 @@ class ReactionDiffusion(SemiLinearODE):
             bc_fun = self.vg.bc.pad_zero_flux_periodic
             self.pad_boundary = lambda field, bc0, bc1: bc_fun(field)
             k_squared = self.vg.fft_k_squared_nonperiodic()
+        else:
+            raise ValueError(f"Unsupported BC type: {self.BC_type}")
 
         self._fourier_symbol = -self.D * self.A * k_squared
-    
+
     @property
     def order(self):
         return 2
@@ -130,14 +132,14 @@ class ReactionDiffusion(SemiLinearODE):
     @property
     def fourier_symbol(self):
         return self._fourier_symbol
-    
-    def _eval_f(self, c, t, lib):
+
+    def _eval_f(self, t, c, lib):
         """Evaluate source/forcing term using ``self.f``."""
         try:
-            return self.f(c, t, lib)
+            return self.f(t, c, lib)
         except TypeError:
-            return self.f(c, t)
-        
+            return self.f(t, c)
+
     @property
     def bc_type(self):
         return self.BC_type
@@ -145,12 +147,12 @@ class ReactionDiffusion(SemiLinearODE):
     def pad_bc(self, u):
         return self.pad_boundary(u, self.bcs[0], self.bcs[1])
     
-    def rhs_analytic(self, u, t):
-        return self.D*spv.laplacian(u) + self._eval_f(u, t, sp)
-    
-    def rhs(self, u, t):
+    def rhs_analytic(self, t, u):
+        return self.D*spv.laplacian(u) + self._eval_f(t, u, sp)
+
+    def rhs(self, t, u):
         laplace = self.vg.laplace(self.pad_bc(u))
-        update = self.D * laplace + self._eval_f(u, t, self.vg.lib)
+        update = self.D * laplace + self._eval_f(t, u, self.vg.lib)
         return update
 
 @dataclass
@@ -185,15 +187,15 @@ class ReactionDiffusionSBM(ReactionDiffusion, SmoothedBoundaryODE):
     def pad_bc(self, u):
         return self.pad_boundary(u, self.bcs[0], self.bcs[1])
 
-    def rhs_analytic(self, mask, u, t):
-        grad = spv.gradient(u)
-        norm_grad = sp.sqrt(grad.dot(grad))
+    def rhs_analytic(self, t, u, mask):
+        grad_m = spv.gradient(mask)
+        norm_grad_m = sp.sqrt(grad_m.dot(grad_m))
 
-        divergence = spv.divergence(self.D*(grad - u/mask*spv.gradient(mask)))
-        du = divergence + norm_grad*self.bc_flux + mask*self._eval_f(u/mask, t, sp)
+        divergence = spv.divergence(self.D*(spv.gradient(u) - u/mask*grad_m))
+        du = divergence + norm_grad_m*self.bc_flux + mask*self._eval_f(t, u/mask, sp)
         return du
 
-    def rhs(self, u, t):
+    def rhs(self, t, u):
         z = self.pad_bc(u)
         divergence = self.vg.grad_x_face(self.vg.grad_x_face(z) -\
                         self.vg.to_x_face(z/self.mask) * self.vg.grad_x_face(self.mask)
@@ -207,7 +209,7 @@ class ReactionDiffusionSBM(ReactionDiffusion, SmoothedBoundaryODE):
 
         update = self.D * divergence + \
                  self.norm*self.bc_flux + \
-                 self.mask[:,1:-1,1:-1,1:-1]*self._eval_f(u/self.mask[:,1:-1,1:-1,1:-1], t, self.vg.lib)
+                 self.mask[:,1:-1,1:-1,1:-1]*self._eval_f(t, u/self.mask[:,1:-1,1:-1,1:-1], self.vg.lib)
         return update
 
 
@@ -249,13 +251,13 @@ class PeriodicCahnHilliard(SemiLinearODE):
         except TypeError:
             return self.mu_hom(c)
 
-    def rhs_analytic(self, c, t):
+    def rhs_analytic(self, t, c):
         mu = self._eval_mu(c, sp) - 2*self.eps*spv.laplacian(c)
         fluxes = self.D*c*(1-c)*spv.gradient(mu)
         rhs = spv.divergence(fluxes)
         return rhs
 
-    def rhs(self, c, t):
+    def rhs(self, t, c):
         r"""Evaluate :math:`\partial c / \partial t` for the CH equation.
 
         Numerical computation of
@@ -341,7 +343,7 @@ class AllenCahnEquation(SemiLinearODE):
         except TypeError:
             return self.potential(phi)
 
-    def rhs_analytic(self, phi, t):
+    def rhs_analytic(self, t, phi):
         grad = spv.gradient(phi)
         laplace  = spv.laplacian(phi)
         norm_grad = sp.sqrt(grad.dot(grad))
@@ -354,7 +356,7 @@ class AllenCahnEquation(SemiLinearODE):
                   + 3/self.eps * phi * (1-phi) * self.force
         return self.M * df_dphi
 
-    def rhs(self, phi, t):
+    def rhs(self, t, phi):
         r"""Two-phase Allen-Cahn equation
         
         Microstructural evolution of the order parameter ``\phi``
@@ -422,13 +424,13 @@ class CoupledReactionDiffusion(SemiLinearODE):
         except TypeError:
             return self.interaction(u)
 
-    def rhs_analytic(self, u, t):
+    def rhs_analytic(self, t, u):
         interaction = self._eval_interaction(u, sp)
         dc_A = self.D_A*spv.laplacian(u[0]) - interaction + self.feed * (1-u[0])
         dc_B = self.D_B*spv.laplacian(u[1]) + interaction - self.kill * u[1]
         return (dc_A, dc_B)
 
-    def rhs(self, u, t):
+    def rhs(self, t, u):
         r"""Two-component reaction-diffusion system
         
         Use batch channels for multiple species:

evoxels/profiler.py

@@ -3,12 +3,20 @@ import psutil
 import os
 import subprocess
 import tracemalloc
+import shutil
 from abc import ABC, abstractmethod
 
 class MemoryProfiler(ABC):
     """Base interface for tracking host and device memory usage."""
+    def __init__(self):
+        self.max_used_cpu = 0.0
+        self.max_used_gpu = 0.0
+        self.track_gpu = False  # subclasses set this
+
     def get_cuda_memory_from_nvidia_smi(self):
         """Return currently used CUDA memory in megabytes."""
+        if shutil.which("nvidia-smi") is None:
+            return None
         try:
             output = subprocess.check_output(
                 ['nvidia-smi', '--query-gpu=memory.used',
@@ -23,8 +31,10 @@ class MemoryProfiler(ABC):
         process = psutil.Process(os.getpid())
         used_cpu = process.memory_info().rss / 1024**2
         self.max_used_cpu = np.max((self.max_used_cpu, used_cpu))
-        used = self.get_cuda_memory_from_nvidia_smi()
-        self.max_used_gpu = np.max((self.max_used_gpu, used))
+        if self.track_gpu:
+            used = self.get_cuda_memory_from_nvidia_smi()
+            if used is not None:
+                self.max_used_gpu = np.max((self.max_used_gpu, used))
 
     @abstractmethod
     def print_memory_stats(self, start: float, end: float, iters: int):
@@ -35,13 +45,14 @@ class TorchMemoryProfiler(MemoryProfiler):
     def __init__(self, device):
         """Initialize the profiler for a given torch device."""
         import torch
+        super().__init__()
         self.torch = torch
         self.device = device
+        self.track_gpu = (device.type == 'cuda')
+
         tracemalloc.start()
-        if device.type == 'cuda':
+        if self.track_gpu:
             torch.cuda.reset_peak_memory_stats(device=device)
-        self.max_used_gpu = 0
-        self.max_used_cpu = 0
 
     def print_memory_stats(self, start, end, iters):
         """Print usage statistics for the Torch backend."""
@@ -60,7 +71,10 @@ class TorchMemoryProfiler(MemoryProfiler):
         elif self.device.type == 'cuda':
             self.update_memory_stats()
             used = self.get_cuda_memory_from_nvidia_smi()
-            print(f"GPU-RAM (nvidia-smi)  current: {used} MB ({self.max_used_gpu} MB max)")
+            if used is None:
+                print("GPU-RAM (nvidia-smi) unavailable.")
+            else:
+                print(f"GPU-RAM (nvidia-smi)  current: {used} MB ({self.max_used_gpu} MB max)")
             print(f"GPU-RAM (torch)       current: "
                   f"{self.torch.cuda.memory_allocated(self.device) / 1024**2:.2f} MB "
                   f"({self.torch.cuda.max_memory_allocated(self.device) / 1024**2:.2f} MB max, "
@@ -70,9 +84,9 @@ class JAXMemoryProfiler(MemoryProfiler):
     def __init__(self):
         """Initialize the profiler for JAX."""
         import jax
+        super().__init__()
         self.jax = jax
-        self.max_used_gpu = 0
-        self.max_used_cpu = 0
+        self.track_gpu = any(d.platform == "gpu" for d in jax.devices())
         tracemalloc.start()
 
     def print_memory_stats(self, start, end, iters):
@@ -88,7 +102,10 @@ class JAXMemoryProfiler(MemoryProfiler):
         current = process.memory_info().rss / 1024**2
         print(f"CPU-RAM (psutil)      current: {current:.2f} MB ({self.max_used_cpu:.2f} MB max)")
 
-        if self.jax.default_backend() == 'gpu':
+        if self.track_gpu:
             self.update_memory_stats()
             used = self.get_cuda_memory_from_nvidia_smi()
-            print(f"GPU-RAM (nvidia-smi)  current: {used} MB ({self.max_used_gpu} MB max)")
+            if used is None:
+                print("GPU-RAM (nvidia-smi) unavailable.")
+            else:
+                print(f"GPU-RAM (nvidia-smi)  current: {used} MB ({self.max_used_gpu} MB max)")

evoxels/solvers.py

@@ -1,13 +1,14 @@
 from IPython.display import clear_output
 from dataclasses import dataclass
 from typing import Callable, Any, Type
+from abc import ABC, abstractmethod
 from timeit import default_timer as timer
 import sys
 from .problem_definition import ODE
 from .timesteppers import TimeStepper
 
 @dataclass
-class TimeDependentSolver:
+class BaseSolver(ABC):
     """Generic wrapper for solving one or more fields with a time stepper."""
     vf: Any  # VoxelFields object
     fieldnames: str | list[str]
@@ -33,46 +34,24 @@ class TimeDependentSolver:
             self.profiler = JAXMemoryProfiler()
         else:
             raise ValueError(f"Unsupported backend: {self.backend}")
-
-    def solve(
-        self,
-        time_increment=0.1,
-        frames=10,
-        max_iters=100,
-        problem_kwargs=None,
-        jit=True,
-        verbose=True,
-        vtk_out=False,
-        plot_bounds=None,
-        colormap='viridis'
-        ):
-        """Run the time integration loop.
-
-        Args:
-            time_increment (float): Size of a single time step.
-            frames (int): Number of output frames (for plotting, vtk, checks).
-            max_iters (int): Number of time steps to compute.
-            problem_kwargs (dict | None): Problem-specific input arguments.
-            jit (bool): Create just-in-time compiled kernel if ``True`` 
-            verbose (bool | str): If ``True`` prints memory stats, ``'plot'``
-                updates an interactive plot.
-            vtk_out (bool): Write VTK files for each frame if ``True``.
-            plot_bounds (tuple | None): Optional value range for plots.
-        """
-
-        problem_kwargs = problem_kwargs or {}
+        
         if isinstance(self.fieldnames, str):
             self.fieldnames = [self.fieldnames]
         else:
             self.fieldnames = list(self.fieldnames)
 
+    def _init_fields(self):
+        """Initialize fields in the voxel grid."""
         u_list = [self.vg.init_scalar_field(self.vf.fields[name]) for name in self.fieldnames]
         u = self.vg.concatenate(u_list, 0)
         u = self.vg.bc.trim_boundary_nodes(u)
-
+        return u
+    
+    def _init_stepper(self, time_increment, problem_kwargs, jit):
+        problem_kwargs = problem_kwargs or {}
         if self.step_fn is not None:
-            step = self.step_fn
             self.problem = None
+            step = self.step_fn
         else:
             if self.problem_cls is None or self.timestepper_cls is None:
                 raise ValueError("Either provide step_fn or both problem_cls and timestepper_cls")
@@ -88,23 +67,47 @@ class TimeDependentSolver:
             import torch
             step = torch.compile(step)
 
-        n_out = max_iters // frames
-        frame = 0
-        slice_idx = self.vf.Nz // 2
+        return step
+    
+    @abstractmethod
+    def _run_loop(self, u, step, time_increment, frames, max_iters,
+                  vtk_out, verbose, plot_bounds, colormap):
+        """Abstract method for running the time integration loop."""
+        raise NotImplementedError("Subclasses must implement _run_loop method.")
 
-        start = timer()
-        for i in range(max_iters):
-            time = i * time_increment
-            if i % n_out == 0:
-                self._handle_outputs(u, frame, time, slice_idx, vtk_out, verbose, plot_bounds, colormap)
-                frame += 1
+    def solve(
+        self,
+        time_increment=0.1,
+        frames=10,
+        max_iters=100,
+        problem_kwargs=None,
+        jit=True,
+        verbose=True,
+        vtk_out=False,
+        plot_bounds=None,
+        colormap='viridis'
+        ):
+        """Run the time integration loop.
 
-            u = step(u, time)
+        Args:
+            time_increment (float): Size of a single time step.
+            frames (int): Number of output frames (for plotting, vtk, checks).
+            max_iters (int): Number of time steps to compute.
+            problem_kwargs (dict | None): Problem-specific input arguments.
+            jit (bool): Create just-in-time compiled kernel if ``True`` 
+            verbose (bool | str): If ``True`` prints memory stats, ``'plot'``
+                updates an interactive plot.
+            vtk_out (bool): Write VTK files for each frame if ``True``.
+            plot_bounds (tuple | None): Optional value range for plots.
+        """
+        u = self._init_fields()
+        step = self._init_stepper(time_increment, problem_kwargs, jit)
 
+        start = timer()
+        u = self._run_loop(u, step, time_increment, frames, max_iters,
+                           vtk_out, verbose, plot_bounds, colormap)
         end = timer()
-        time = max_iters * time_increment
-        self._handle_outputs(u, frame, time, slice_idx, vtk_out, verbose, plot_bounds, colormap)
-
+        self.computation_time = end - start
         if verbose:
             self.profiler.print_memory_stats(start, end, max_iters)
 
@@ -113,10 +116,10 @@ class TimeDependentSolver:
         if getattr(self, 'problem', None) is not None:
             u_out = self.vg.bc.trim_ghost_nodes(self.problem.pad_bc(u))
         else:
-            u_out = u
+            u_out = self.vg.bc.trim_ghost_nodes(self.vg.pad_zeros(u))
 
         for i, name in enumerate(self.fieldnames):
-            self.vf.fields[name] = self.vg.export_scalar_field_to_numpy(u_out[i:i+1])
+            self.vf.set_field(name, self.vg.export_scalar_field_to_numpy(u_out[i:i+1]))
 
         if verbose:
             self.profiler.update_memory_stats()
@@ -129,6 +132,70 @@ class TimeDependentSolver:
             filename = self.problem_cls.__name__ + "_" +\
                        self.fieldnames[0] + f"_{frame:03d}.vtk"
             self.vf.export_to_vtk(filename=filename, field_names=self.fieldnames)
+
         if verbose == 'plot':
             clear_output(wait=True)
             self.vf.plot_slice(self.fieldnames[0], slice_idx, time=time, colormap=colormap, value_bounds=plot_bounds)
+
+@dataclass
+class TimeDependentSolver(BaseSolver):
+    """Solver for time-dependent problems."""
+    def _run_loop(self, u, step, time_increment, frames, max_iters,
+                  vtk_out, verbose, plot_bounds, colormap):
+        n_out = max_iters // frames
+        frame = 0
+        slice_idx = self.vf.Nz // 2
+
+        for i in range(max_iters):
+            time = i * time_increment
+            if i % n_out == 0:
+                self._handle_outputs(u, frame, time, slice_idx, vtk_out,
+                                     verbose, plot_bounds, colormap)
+                frame += 1
+
+            u = step(time, u)
+        time = max_iters * time_increment
+        self._handle_outputs(u, frame, time, slice_idx, vtk_out,
+                             verbose, plot_bounds, colormap)
+        return u
+
+@dataclass
+class SteadyStatePseudoTimeSolver(BaseSolver):
+    """Solver for steady-state problems."""
+    conv_crit: float = 1e-6
+    check_freq: int = 10
+    
+    def _run_loop(self, u, step, time_increment, frames, max_iters,
+                  vtk_out, verbose, plot_bounds, colormap):
+        slice_idx = self.vf.Nz // 2
+        self.converged = False
+        self.iter = 0
+
+        while not self.converged and self.iter < max_iters:
+            time = self.iter * time_increment
+            diff = u - step(time, u)
+            u = step(time, u)
+
+            if self.iter % self.check_freq == 0:
+                self.converged = self.check_convergence(diff, verbose)
+
+        self._handle_outputs(u, 0, time, slice_idx, vtk_out,
+                             verbose, plot_bounds, colormap)
+        return u
+    
+    def check_convergence(self, diff, verbose):
+        """Check for convergence based on relative change in fields."""
+        converged = True
+        for i, name in enumerate(self.fieldnames):
+            # Check if Frobenius norm of change is below threshold
+            rel_change = self.vg.lib.linalg.norm(diff[i]) / \
+                         self.vg.lib.sqrt(self.vf.Nx * self.vf.Ny * self.vf.Nz)
+            if rel_change > self.conv_crit:
+                converged = False
+            if verbose:
+                print(f"Iter {self.iter}: Field '{name}' relative change: {rel_change:.2e}")
+
+        if converged and verbose:
+            print(f"Converged after {self.iter} iterations.")
+
+        return converged

evoxels/timesteppers.py

@@ -16,13 +16,13 @@ class TimeStepper(ABC):
         pass
 
     @abstractmethod
-    def step(self, u: State, t: float) -> State:
+    def step(self, t: float, u: State) -> State:
         """
         Take one timestep from t to (t+dt).
 
         Args:
-            u       : Current state
             t       : Current time
+            u       : Current state
         Returns:
             Updated state at t + dt.
         """
@@ -39,8 +39,8 @@ class ForwardEuler(TimeStepper):
     def order(self) -> int:
         return 1
 
-    def step(self, u: State, t: float) -> State:
-        return u + self.dt * self.problem.rhs(u, t)
+    def step(self, t: float, u: State) -> State:
+        return u + self.dt * self.problem.rhs(t, u)
 
 
 @dataclass
@@ -68,8 +68,8 @@ class PseudoSpectralIMEX(TimeStepper):
     def order(self) -> int:
         return 1
 
-    def step(self, u: State, t: float) -> State:
-        dc = self.pad(self.problem.rhs(u, t))
+    def step(self, t: float, u: State) -> State:
+        dc = self.pad(self.problem.rhs(t, u))
         dc_fft = self._fft_prefac * self.problem.vg.rfftn(dc, dc.shape)
         update = self.problem.vg.irfftn(dc_fft, dc.shape)[:,:u.shape[1]]
         return u + update

evoxels/utils.py

@@ -3,15 +3,21 @@ import sympy as sp
 import sympy.vector as spv
 import evoxels as evo
 from evoxels.problem_definition import SmoothedBoundaryODE
+from evoxels.solvers import TimeDependentSolver
+import contextlib
+import io
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D  # noqa: F401 (needed for 3D projection)
+from matplotlib.patches import Patch
 
 ### Generalized test case
 def rhs_convergence_test(
-    ODE_class,       # an ODE class with callable rhs(field, t)->torch.Tensor (shape [x,y,z])
-    problem_kwargs,  # problem parameters to instantiate ODE
-    test_function,   # exact init_fun(x,y,z)->np.ndarray
-    mask_function=None, 
-    convention="cell_center",
-    dtype="float32",
+    ODE_class,
+    problem_kwargs,
+    test_function,
+    mask_function = None,
+    convention = "cell_center",
+    dtype = "float32",
     powers = np.array([3,4,5,6,7]),
     backend = "torch"
 ):
@@ -22,7 +28,7 @@ def rhs_convergence_test(
     slope arrays have one entry for each provided function.
 
     Args:
-        ODE_class: an ODE class with callable rhs(field, t).
+        ODE_class: ODE class with callable rhs(t, u).
         problem_kwargs: problem-specific parameters to instantiate ODE.
         test_function: single sympy expression or a list of expressions.
         mask_function: static mask for smoothed boundary method.
@@ -38,7 +44,9 @@ def rhs_convergence_test(
             "is not a SmoothedBoundaryODE."
         )
     CS = spv.CoordSys3D('CS')
+
     # Prepare lambdified mask if needed
+    # Assumed to be static i.e. no function of t
     mask = (
         sp.lambdify((CS.x, CS.y, CS.z), mask_function, "numpy")
         if mask_function is not None
@@ -67,50 +75,51 @@ def rhs_convergence_test(
         elif convention == 'staggered_x':
             vf = evo.VoxelFields((2**p + 1, 2**p, 2**p), (1, 1, 1), convention=convention)
         vf.precision = dtype
-        grid = vf.meshgrid()
+        dx[i] = vf.spacing[0]
+
         if backend == 'torch':
             vg = evo.voxelgrid.VoxelGridTorch(vf.grid_info(), precision=vf.precision, device='cpu')
         elif backend == 'jax':
             vg = evo.voxelgrid.VoxelGridJax(vf.grid_info(), precision=vf.precision)
-    
+
+        # Init mask if smoothed boundary ODE
+        numpy_grid = vf.meshgrid()
+        if mask is not None:
+            problem_kwargs["mask"] = mask(*numpy_grid)
+
         # Initialise fields
         u_list = []
         for func in test_functions:
             init_fun = sp.lambdify((CS.x, CS.y, CS.z), func, "numpy")
-            init_data = init_fun(*grid)
+            init_data = init_fun(*numpy_grid)
             u_list.append(vg.init_scalar_field(init_data))
 
         u = vg.concatenate(u_list, 0)
         u = vg.bc.trim_boundary_nodes(u)
 
-        # Init mask if smoothed boundary ODE
-        if mask is not None:
-            problem_kwargs["mask"] = mask(*grid)
-
         ODE = ODE_class(vg, **problem_kwargs)
-        rhs_numeric = ODE.rhs(u, 0)
+        rhs_numeric = ODE.rhs(0, u)
 
         if n_funcs > 1 and mask is not None:
-            rhs_analytic = ODE.rhs_analytic(mask_function, test_functions, 0)
+            rhs_analytic = ODE.rhs_analytic(0, test_functions, mask_function)
         elif n_funcs > 1 and mask is None:
-            rhs_analytic = ODE.rhs_analytic(test_functions, 0)
+            rhs_analytic = ODE.rhs_analytic(0, test_functions)
         elif n_funcs == 1 and mask is not None:
-            rhs_analytic = [ODE.rhs_analytic(mask_function, test_functions[0], 0)]
+            rhs_analytic = [ODE.rhs_analytic(0, test_functions[0], mask_function)]
         else:
-            rhs_analytic = [ODE.rhs_analytic(test_functions[0], 0)]
+            rhs_analytic = [ODE.rhs_analytic(0, test_functions[0])]
 
         # Compute solutions
         for j, func in enumerate(test_functions):
             comp = vg.export_scalar_field_to_numpy(rhs_numeric[j:j+1])
             exact_fun = sp.lambdify((CS.x, CS.y, CS.z), rhs_analytic[j], "numpy")
-            exact = exact_fun(*grid)
+            exact = exact_fun(*numpy_grid)
             if convention == "staggered_x":
                 exact = exact[1:-1, :, :]
 
             # Error norm
             diff = comp - exact
             errors[j, i] = np.linalg.norm(diff) / np.linalg.norm(exact)
-        dx[i] = vf.spacing[0]
 
     # Fit slope after loop
     slopes = np.array(
@@ -121,4 +130,316 @@ def rhs_convergence_test(
     order = ODE.order
 
     return dx, errors if errors.shape[0] > 1 else errors[0], slopes, order
-    
+
+
+def mms_convergence_test(
+    ODE_class,       # an ODE class with callable rhs(field, t)->torch.Tensor (shape [x,y,z])
+    problem_kwargs,  # problem parameters to instantiate ODE
+    test_function,   # exact init_fun(x,y,z)->np.ndarray
+    mask_function=None,
+    timestepper_cls=None,
+    convention="cell_center",
+    dtype="float32",
+    mode = 'temporal',
+    g_powers = np.array([3,4,5,6,7]),
+    t_powers = np.array([3,4,5,6,7]),
+    t_final = 1,
+    backend = "jax",
+    device = 'cpu'
+):
+    """Evaluate temporal and spatial order of ODE solution.
+
+    ``test_function`` can be a single sympy expression or a list of
+    expressions representing multiple variables. The returned error and
+    slope arrays have one entry for each provided function.
+
+    Args:
+        ODE_class: ODE class with callable rhs(t, u).
+        problem_kwargs: problem-specific parameters to instantiate ODE.
+        test_function: single sympy expression or a list of expressions.
+        mask_function: static mask for smoothed boundary method.
+        timestepper_cls: timestepper class with callable step(t, u).
+        convention: grid convention.
+        dtype: floate precision (``float32`` or ``float64``).
+        mode: Use ``temporal`` or ``spatial`` to construct MMS forcing.
+        g_powers: refine grid in powers of two (i.e. ``Nx = 2**p``).
+        t_powers: refine time increment in powers of two (i.e. ``dt = 2**p``).
+        t_final: End time for evaluation. Should be order of L^2/D.
+        backend: use ``torch`` or ``jax`` for testing.
+        device: use ``cpu`` or ``cuda`` for testing in torch.
+    """
+    # Verify mask_function only used with SmoothedBoundaryODE
+    if mask_function is not None and not issubclass(ODE_class, SmoothedBoundaryODE):
+        raise TypeError(
+            f"Mask function provided but {ODE_class.__name__} "
+            "is not a SmoothedBoundaryODE."
+        )
+    CS = spv.CoordSys3D('CS')
+    t = sp.symbols('t', real=True)
+
+    # Prepare lambdified mask if needed
+    # Assumed to be static i.e. no function of t
+    mask = (
+        sp.lambdify((CS.x, CS.y, CS.z), mask_function, "numpy")
+        if mask_function is not None
+        else None
+    )
+
+    if isinstance(test_function, (list, tuple)):
+        test_functions = list(test_function)
+    else:
+        test_functions = [test_function]
+    n_funcs = len(test_functions)
+
+    # Multiply test functions with mask for SBM testing
+    if mask is not None:
+        temp_list = []
+        for func in test_functions:
+            temp_list.append(func*mask_function)
+        test_functions = temp_list
+
+    if mode == 'temporal':
+        u_list = [sp.lambdify((t, CS.x, CS.y, CS.z),
+                                sp.N(func), backend) \
+                    for func in test_functions]
+    u_t_list = [sp.lambdify((t, CS.x, CS.y, CS.z),
+                            sp.N(sp.diff(func, t)), backend) \
+                for func in test_functions]
+
+    dx     = np.zeros(len(g_powers))
+    dt     = np.zeros(len(t_powers))
+    errors = np.zeros((n_funcs, len(t_powers), len(g_powers)))
+
+    for i, p in enumerate(g_powers):
+        if convention == 'cell_center':
+            vf = evo.VoxelFields((2**p, 2**p, 2**p), (1, 1, 1), convention=convention)
+        elif convention == 'staggered_x':
+            vf = evo.VoxelFields((2**p + 1, 2**p, 2**p), (1, 1, 1), convention=convention)
+        else:
+            raise ValueError("Chosen convention must be cell_center or staggered_x.")
+        vf.precision = dtype
+        dx[i] = vf.spacing[0]
+    
+        if backend == 'torch':
+            vg = evo.voxelgrid.VoxelGridTorch(vf.grid_info(), precision=vf.precision, device=device)
+        elif backend == 'jax':
+            vg = evo.voxelgrid.VoxelGridJax(vf.grid_info(), precision=vf.precision)
+
+        # Init mask if smoothed boundary ODE
+        numpy_grid = vf.meshgrid()
+        if mask is not None:
+            problem_kwargs["mask"] = mask(*numpy_grid)
+
+        ODE = ODE_class(vg, **problem_kwargs)
+        rhs_orig = ODE.rhs
+        grid = vg.meshgrid()
+        if convention == 'staggered_x':
+            grid = (grid[0][1:-1,:,:], grid[1][1:-1,:,:], grid[2][1:-1,:,:])
+
+        # Construct new rhs including forcing term from MMS
+        if mode == 'temporal':
+            def mms_rhs(t, u):
+                """Manufactured solution rhs
+                with numerical evaluation of rhs in forcing, i.e.
+                forcing = du/dt_exact(t,grid) - rhs_num(t, u_exact(t,grid))
+                """
+                rhs = rhs_orig(t, u)
+                t_ = vg.to_backend(t)
+                u_ex_list = []
+                for j, func in enumerate(test_functions):
+                    u_ex_list.append(vg.expand_dim(u_list[j](t_, *grid), 0))
+                    rhs = vg.set(rhs, j, rhs[j] + u_t_list[j](t_, *grid))
+                u_ex = vg.concatenate(u_ex_list, 0)
+                rhs -= rhs_orig(t, u_ex)
+                return rhs
+
+        elif mode == 'spatial':
+            if n_funcs > 1 and mask is not None:
+                rhs_func = ODE.rhs_analytic(t, test_functions, mask_function)
+                rhs_analytic = [sp.lambdify((t, CS.x, CS.y, CS.z), sp.N(func), backend) for func in rhs_func]
+            elif n_funcs > 1 and mask is None:
+                rhs_func = ODE.rhs_analytic(t, test_functions)
+                rhs_analytic = [sp.lambdify((t, CS.x, CS.y, CS.z), sp.N(func), backend) for func in rhs_func]
+            elif n_funcs == 1 and mask is not None:
+                rhs_func = ODE.rhs_analytic(t, test_functions[0], mask_function)
+                rhs_analytic = [sp.lambdify((t, CS.x, CS.y, CS.z), sp.N(rhs_func), backend)]
+            else:
+                rhs_func = ODE.rhs_analytic(t, test_functions[0])
+                rhs_analytic = [sp.lambdify((t, CS.x, CS.y, CS.z), sp.N(rhs_func), backend)]
+
+            def mms_rhs(t, u):
+                """Manufactured solution rhs
+                with analytical evaluation of rhs in forcing, i.e.
+                forcing = du/dt_exact(t,grid) - rhs_exact(t, grid)
+                """
+                rhs = rhs_orig(t, u)
+                t_ = vg.to_backend(t)
+                for j, func in enumerate(test_functions):
+                    rhs = vg.set(rhs, j, rhs[j] - rhs_analytic[j](t_, *grid))
+                    rhs = vg.set(rhs, j, rhs[j] + u_t_list[j](t_, *grid))
+                return rhs
+        else:
+            raise ValueError("Mode must be 'temporal' or 'spatial'.")
+
+        # Over-write original rhs with contructed mms_rhs
+        ODE.rhs = mms_rhs
+
+        # Loop over time refinements
+        for k, q in enumerate(t_powers):
+            # Initialise fields
+            field_names = []
+            for j, func in enumerate(test_functions):
+                fun = sp.lambdify((t, CS.x, CS.y, CS.z), func, "numpy")
+                init_data = fun(0, *numpy_grid)
+                final_data = fun(t_final, *numpy_grid)
+                vf.add_field(f'u{j}', init_data)
+                vf.add_field(f'u{j}_final', final_data)
+                field_names.append(f'u{j}')
+
+            # Init time increment and step function
+            dt[k] = t_final / 2**q
+            timestepper = timestepper_cls(ODE, dt[k])
+            step = timestepper.step
+
+            # Init solver
+            solver = TimeDependentSolver(
+                vf, field_names,
+                backend, device=device,
+                step_fn=step
+            )
+
+            # Wrap solve to capture NaN exit
+            nan_hit = False
+            buf = io.StringIO()
+            with contextlib.redirect_stdout(buf):
+                try:
+                    solver.solve(dt[k], 8, int(2**q), problem_kwargs, verbose=False)
+                except SystemExit:
+                    nan_hit = True
+
+            if nan_hit:
+                errors[:, k, i] = np.nan
+                continue
+        
+            # Compute relative L2 error
+            for j, func in enumerate(test_functions):
+                exact = vf.fields[f'u{j}_final']
+                diff = vf.fields[f'u{j}'] - exact
+                if convention == 'staggered_x':
+                    errors[j, k, i] = np.linalg.norm(diff[1:-1,:,:]) / np.linalg.norm(exact[1:-1,:,:])
+                else:
+                    errors[j, k, i] = np.linalg.norm(diff) / np.linalg.norm(exact)
+
+    # Fit slope after loop
+    def calc_slope(x, y):
+        mask = np.isfinite(y)
+        if mask.sum() < 2:
+            return np.nan
+        return np.polyfit(np.log(x[mask]), np.log(y[mask]), 1)[0]
+
+    t_slopes = np.array([calc_slope(dt, err[:,0]) for err in errors])
+    g_slopes = np.array([calc_slope(dx, err[-1,:]) for err in errors])
+
+    results = {
+        'dt': dt,
+        'dx': dx,
+        'error': errors if n_funcs > 1 else errors[0],
+        't_slopes': t_slopes if n_funcs > 1 else t_slopes[0],
+        'g_slopes': g_slopes if n_funcs > 1 else g_slopes[0],
+        'n_funcs': n_funcs,
+        't_order': timestepper.order,
+        'g_order': ODE.order,
+    }
+    return results
+
+
+def plot_error_surface(series, log_axes=(True, True, True), z_max=0, title=None, alpha=0.4):
+    """
+    Plot one or more 3D surfaces z(x, y) with semi-transparent tiles and solid mesh lines.
+
+    Parameters
+    ----------
+    series : tuple[list] of dict
+        Each dict must have:
+          - 'dt': 1D array-like of dt-values  (length Nx)
+          - 'dx': 1D array-like of dx-values  (length Ny)
+          - 'error': 2D array-like of values Z(X, Y) with shape (Nx, Ny)
+          - 'name': (optional) label for legend
+    log_axes : tuple(bool, bool, bool)
+        (log_x, log_y, log_z): apply log10 to respective axis data when True.
+        For Z, nonpositive values are masked to NaN before log10.
+    title : str or None
+        Plot title.
+    alpha : float
+        Face transparency for surfaces.
+    """
+    if not isinstance(series, (list, tuple)) or len(series) == 0:
+        raise ValueError("`series` must be a non-empty tuple/list of dictionaries.")
+
+    log_x, log_y, log_z = log_axes
+
+    # Distinct colors
+    base_colors = ['tab:red', 'tab:blue', 'tab:green', 'tab:gray',
+                   'tab:purple', 'tab:brown', 'tab:pink', 'tab:orange',
+                   'tab:olive', 'tab:cyan']
+
+    fig = plt.figure(figsize=(5, 5))
+    ax = fig.add_subplot(111, projection='3d')
+    legend_patches = []
+
+    count = 0
+    for i, s in enumerate(series):
+        if not isinstance(s, dict) or not all(k in s for k in ('dt', 'dx', 'error')):
+            raise ValueError(f"Item {i} must be a dict with keys 'dt', 'dx', 'error' (and optional 'name').")
+
+        x_in = np.asarray(s['dt'])
+        y_in = np.asarray(s['dx'])
+        Z = np.asarray(s['error'])
+        Z = np.expand_dims(Z, axis=0) if Z.ndim == 2 else Z
+        name = s.get('name', f'[{i}]')
+
+        # Handle (1D,1D,2D) or (2D,2D,2D)
+        if x_in.ndim == 1 and y_in.ndim == 1:
+            X, Y = np.meshgrid(x_in, y_in, indexing='ij')  # (Nx, Ny)
+        else:
+            raise ValueError(f"Item {i}: dt and dx must both be 1D grids.")
+
+        if Z.shape[1:] != X.shape:
+            raise ValueError(f"Item {i}: z.shape {Z.shape} must match x/y grid shape {X.shape}.")
+
+        # Apply log scaling
+        Xp = np.log10(X) if log_x else X
+        Yp = np.log10(Y) if log_y else Y
+        if log_z:
+            Z = np.where(Z > 0, Z, np.nan)
+            Zp = np.log10(Z)
+        else:
+            Zp = Z
+
+        for j in range(s['n_funcs']):
+            color = base_colors[count % len(base_colors)]
+            ax.plot_surface(
+                Xp, Yp, Zp[j],
+                color=color,         # uniform color per surface
+                alpha=alpha,         # semi-transparent tiles
+                edgecolor=color,     # solid mesh lines
+                linewidth=0.6,
+                antialiased=True,
+                shade=False
+            )
+            label = name + f"_u{j}" if j > 0 else name
+            legend_patches.append(Patch(facecolor=color, edgecolor=color, alpha=alpha, label=label))
+            count += 1
+
+    # Axis labels reflect log choice
+    ax.set_xlabel('log10(dt)' if log_x else 'dt')
+    ax.set_ylabel('log10(dx)' if log_y else 'dx')
+    ax.text2D(0.0, 0.8, 'log10(error)' if log_z else 'error',
+              transform=ax.transAxes, va="top", ha="left")
+    ax.set_zlim(top=z_max)
+    ax.set_title(title or 'Error Surfaces')
+    ax.view_init(elev=25., azim=-145, roll=0)
+
+    ax.legend(handles=legend_patches, loc='best')
+    fig.tight_layout()
+    plt.show()

evoxels/voxelfields.py

@@ -120,30 +120,40 @@ class VoxelFields:
         grid = Grid(self.shape, self.origin, self.spacing, self.convention)
         return grid
 
-    def add_field(self, name: str, array=None):
+    def set_field(self, name: str, array: np.ndarray):
         """
-        Adds a field to the voxel grid.
+        Set field values for an existing field in the voxel grid.
 
         Args:
             name (str): Name of the field.
-            array (numpy.ndarray, optional): 3D array to initialize the field. If None, initializes with zeros.
+            array (numpy.ndarray, optional): 3D array.
 
         Raises:
             ValueError: If the provided array does not match the voxel grid dimensions.
             TypeError: If the provided array is not a numpy array.
         """
-        if array is not None:
-            if isinstance(array, np.ndarray):
-                if array.shape == self.shape:
-                    self.fields[name] = array
-                else:
-                    raise ValueError(
-                        f"The provided array must have the shape {self.shape}."
-                    )
+        if isinstance(array, np.ndarray):
+            if array.shape == self.shape:
+                self.fields[name] = array
             else:
-                raise TypeError("The provided array must be a numpy array.")
+                raise ValueError(
+                    f"The provided array must have the shape {self.shape}."
+                )
+        else:
+            raise TypeError("The provided array must be a numpy array.")
+        
+    def add_field(self, name: str, array=None):
+        """
+        Adds a field to the voxel grid.
+
+        Args:
+            name (str): Name of the field.
+            array (numpy.ndarray, optional): 3D array to initialize the field. If None, initializes with zeros.
+        """
+        if array is not None:
+            self.set_field(name, array)
         else:
-            self.fields[name] = np.zeros(self.shape)
+            self.set_field(name, np.zeros(self.shape))
 
     def set_voxel_sphere(self, name: str, center, radius, label: int | float = 1):
         """Create a voxelized representation of a sphere in 3D

{evoxels-0.1.1.dist-info → evoxels-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: evoxels
-Version: 0.1.1
+Version: 1.0.0
 Summary: Differentiable physics framework for voxel-based microstructure simulations
 Author-email: Simon Daubner <s.daubner@imperial.ac.uk>
 License: MIT
@@ -40,6 +40,7 @@ Provides-Extra: notebooks
 Requires-Dist: ipywidgets; extra == "notebooks"
 Requires-Dist: ipympl; extra == "notebooks"
 Requires-Dist: notebook; extra == "notebooks"
+Requires-Dist: taufactor; extra == "notebooks"
 Dynamic: license-file
 
 [![Python package](https://github.com/daubners/evoxels/actions/workflows/python-package.yml/badge.svg?branch=main)](https://github.com/daubners/evoxels/actions/workflows/python-package.yml)
@@ -81,7 +82,7 @@ TL;DR
 ```bash
 conda create --name voxenv python=3.12
 conda activate voxenv
-pip install evoxels[torch,jax,dev,notebooks]
+pip install "evoxels[torch,jax,dev,notebooks]"
 pip install --upgrade "jax[cuda12]"
 ```
 
@@ -103,7 +104,7 @@ Navigate to the evoxels folder, then
 ```
 pip install -e .[torch] # install with torch backend
 pip install -e .[jax]   # install with jax backend
-pip install -e .[dev, notebooks] # install testing and notebooks
+pip install -e .[dev,notebooks] # install testing and notebooks
 ```
 Note that the default `[jax]` installation is only CPU compatible. To install the corresponding CUDA libraries check your CUDA version with
 ```bash
@@ -115,7 +116,7 @@ pip install -U "jax[cuda12]"
 ```
 To install both backends within one environment it is important to install torch first and then upgrade the `jax` installation e.g.
 ```bash
-pip install evoxels[torch, jax, dev, notebooks]
+pip install "evoxels[torch,jax,dev,notebooks]"
 pip install --upgrade "jax[cuda12]"
 ```
 To work with the example notebooks install Jupyter and all notebook related dependencies via

evoxels-1.0.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+evoxels/__init__.py,sha256=LLogj7BjzLNi9voNIQkmDYmj_dT82Aw8ph9RAlaPLuU,376
+evoxels/boundary_conditions.py,sha256=IZbPFvPVknWtTyXdDYEQiWCmw1RhwAlCfx0GBpGt7wg,5129
+evoxels/fd_stencils.py,sha256=kpFszQqjSPuWzRPyscR13uaDM9GWiBvmBVopBRosohs,4581
+evoxels/function_approximators.py,sha256=_WwsypBWSigMlyvT_Qgc8rHN7SsyvyFL9WgB1QqPdHY,2545
+evoxels/inversion.py,sha256=9EQcr2-Xe5zAEhbqd-ZbOPRqqfRtrHE8pKW2TFPXdC8,8694
+evoxels/problem_definition.py,sha256=2i0_qwgxX_6Fi0qZR4gB7u_p5OU4IKuTjSYVFVX20MA,14641
+evoxels/profiler.py,sha256=3-kIku5ebOEawKL73LIKZ6HnM0odqhGRrLf54fbY7SY,4544
+evoxels/solvers.py,sha256=s3s_tjvO8YTnYFc_u-2WY6Jyoz47O8tWWkci4k9rLLg,7886
+evoxels/timesteppers.py,sha256=VUvPrnhsHW3H7FwfrGpwvXl0GAWpThf-ULH-tIT44_8,3509
+evoxels/utils.py,sha256=YrUz4JGORrhogjYykojEvUVSfuAkJqfgw9pA3DI1eCQ,17306
+evoxels/voxelfields.py,sha256=UYY2mg5xONkiKwWBji-XIMu_t3isg3ey9J8XKmBYb5A,13573
+evoxels/voxelgrid.py,sha256=r5yoo2J6ogHEOzFbhjikbi4wXQfurmZB4EWf6AEHIK0,9549
+evoxels/precompiled_solvers/__init__.py,sha256=V8oekjyg13ziQ1Gdf0pHHYubZcB6Oec5a8RG0d09Y1c,50
+evoxels/precompiled_solvers/allen_cahn.py,sha256=h44HKG_NNalJBN6_uyBciAthAjUaoQ4rw_JsV1rQCeo,1372
+evoxels/precompiled_solvers/cahn_hilliard.py,sha256=yC-iGEvD8Efdmp6YEUfysl2L1jbfjU62-TR1T05S68E,1166
+evoxels-1.0.0.dist-info/licenses/LICENSE,sha256=2ScNJCT83dGOKEIpmeO0sq7sf6-Rru3SsnDHJ2UFdcg,1065
+evoxels-1.0.0.dist-info/METADATA,sha256=TSASC3rlti5rGIZQYB-kb3N6b-RcoTlW6YQJpJunwMk,7665
+evoxels-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+evoxels-1.0.0.dist-info/top_level.txt,sha256=g6OihMiKjYgojKrMM8ckpmFVh-ExPN8f4MZPWscCbqo,8
+evoxels-1.0.0.dist-info/RECORD,,

{evoxels-0.1.1.dist-info → evoxels-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

evoxels-0.1.1.dist-info/RECORD

@@ -1,20 +0,0 @@
-evoxels/__init__.py,sha256=LLogj7BjzLNi9voNIQkmDYmj_dT82Aw8ph9RAlaPLuU,376
-evoxels/boundary_conditions.py,sha256=IZbPFvPVknWtTyXdDYEQiWCmw1RhwAlCfx0GBpGt7wg,5129
-evoxels/fd_stencils.py,sha256=kpFszQqjSPuWzRPyscR13uaDM9GWiBvmBVopBRosohs,4581
-evoxels/function_approximators.py,sha256=_WwsypBWSigMlyvT_Qgc8rHN7SsyvyFL9WgB1QqPdHY,2545
-evoxels/inversion.py,sha256=wKRaJ14eLGBWIeJbAk1pSFP6kFmKDeM9OBvSHndUAz4,8694
-evoxels/problem_definition.py,sha256=nfr0M1yH0v16btJoE9_0xlukxjyHx3BmnM1pWyXIsew,14559
-evoxels/profiler.py,sha256=2nGEbQBTaP_FUdA7OojmxQe2npLJwgDC-RVF4DNJ51A,3995
-evoxels/solvers.py,sha256=tA-3bqHApktZnENMNWZIz-bsgX2QKRzW8FzKrwsvQXE,5172
-evoxels/timesteppers.py,sha256=YbaWViKklhZeYKjl4SetWUALS4q6Fm7zCYy6cBesGgw,3509
-evoxels/utils.py,sha256=wp-tL2SkFIjSM3B1IwbMGLcVGPO6T8wr4bGitgn7z1k,4686
-evoxels/voxelfields.py,sha256=e6DEqv1C7MavOqFx9RhEMD-SktVEO1JDLRv43WNiCTU,13300
-evoxels/voxelgrid.py,sha256=r5yoo2J6ogHEOzFbhjikbi4wXQfurmZB4EWf6AEHIK0,9549
-evoxels/precompiled_solvers/__init__.py,sha256=V8oekjyg13ziQ1Gdf0pHHYubZcB6Oec5a8RG0d09Y1c,50
-evoxels/precompiled_solvers/allen_cahn.py,sha256=ZutF6L3LYqyCC3tIEQwHmQchZSbhZFmcLy-UNaN4yH0,1373
-evoxels/precompiled_solvers/cahn_hilliard.py,sha256=Bn2Tbv-kbLwinvVkCr07CT8OrR9im0kvKk0o9ySghFI,1158
-evoxels-0.1.1.dist-info/licenses/LICENSE,sha256=2ScNJCT83dGOKEIpmeO0sq7sf6-Rru3SsnDHJ2UFdcg,1065
-evoxels-0.1.1.dist-info/METADATA,sha256=S5YiDQxd-JWhMDI1Jbwyx4gWkWFXJnk4fiB2khxmiaw,7618
-evoxels-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-evoxels-0.1.1.dist-info/top_level.txt,sha256=g6OihMiKjYgojKrMM8ckpmFVh-ExPN8f4MZPWscCbqo,8
-evoxels-0.1.1.dist-info/RECORD,,