Struct MOLSystem2D 

pub struct MOLSystem2D<S: SparseScalar> { /* private fields */ }

2D Method of Lines system.

Converts a 2D PDE of the form u_t = L[u] + R(t, x, y, u) into an ODE system, where L is a linear spatial operator assembled as a sparse matrix and R is an optional nonlinear reaction term.

Implementations

impl<S: SparseScalar> MOLSystem2D<S>

pub fn heat(grid: Grid2D<S>, alpha: S, bc: &BoundaryConditions2D<S>) -> Self

Create a 2D MOL system for the heat equation: u_t = alpha * laplacian(u).

pub fn laplacian(grid: Grid2D<S>, bc: &BoundaryConditions2D<S>) -> Self

Create a 2D MOL system for the Laplacian: u_t = laplacian(u).

pub fn with_operator( grid: Grid2D<S>, coeffs: &Operator2DCoefficients<S>, bc: &BoundaryConditions2D<S>, ) -> Self

Create a 2D MOL system with a general linear operator.

pub fn with_reaction<F>(self, reaction: F) -> Self

where F: Fn(S, S, S, S) -> S + Send + Sync + 'static,

Add a nonlinear reaction term R(t, x, y, u) to the system.

The full PDE becomes: u_t = L[u] + R(t, x, y, u).

pub fn grid(&self) -> &Grid2D<S>

Get the spatial grid.

pub fn n_interior(&self) -> usize

Number of interior points (ODE dimension).

pub fn build_full_solution(&self, u_interior: &[S]) -> Vec<S>

Build the full solution array including boundaries.

Interior values are stored in column-major order: u[jj * nx_int + ii]. The full array has nx*ny entries in the same column-major layout.

Trait Implementations

impl<S: SparseScalar> OdeSystem<S> for MOLSystem2D<S>

fn jacobian(&self, t: S, y: &[S], jac: &mut [S])

Analytical Jacobian: copy the assembled sparse spatial operator (which already equals ∂(L[u])/∂u by construction) into the row-major dense buffer the solver expects, then add the reaction term’s contribution to the diagonal.

The reaction Jacobian is diagonal because the reaction is pointwise: R(t, x_i, y_j, u_i) depends only on the local state u_i, so ∂R_i/∂u_k is identically zero for any k != i. Off- diagonal entries cannot be populated by a pointwise reaction, no matter what the closure contains. This is what makes the FD-on-the-diagonal fallback affordable: one extra closure call per interior point versus the O(N) rhs evaluations the trait-default FD would need to populate the same entries through perturbation. If a future reaction model couples grid points (nonlocal / integro-PDE / multi-component), the trait default’s full FD path is the correct fallback — but that’s out of scope for v1.

fn dim(&self) -> usize

Dimension of the system.

fn rhs(&self, t: S, y: &[S], dydt: &mut [S])

Compute the right-hand side: dydt = f(t, y)

fn is_autonomous(&self) -> bool

Is the system autonomous? (f does not depend on t explicitly)

fn has_mass_matrix(&self) -> bool

Does this system have a mass matrix?

fn mass_matrix(&self, mass: &mut [S])

Get the mass matrix M for the DAE: M * y’ = f(t, y)

fn is_singular_mass(&self) -> bool

Is the mass matrix singular? (i.e., is this a DAE?)

fn algebraic_indices(&self) -> Vec<usize>

Return indices of algebraic variables (where M[i,i] = 0).