Struct ParametricMOLSystem2D 

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

Parametric 2D Method of Lines system.

See the module-level docs for the parameter layout, the linearity argument that makes the scaled-operator path correct, and the boundary-condition handling.

Implementations

impl<S: SparseScalar> ParametricMOLSystem2D<S>

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

Build a parametric heat equation u_t = α∇²u with the diffusion coefficient α as the single parameter.

pub fn heat_with_reaction<R>( grid: Grid2D<S>, alpha_nominal: S, bc: &BoundaryConditions2D<S>, nominal_reaction_params: Vec<S>, reaction: R, ) -> Self

where R: Fn(S, S, S, S, &[S]) -> S + Send + Sync + 'static,

Build a parametric heat equation with a parametric reaction term.

The full parameter vector is [α, reaction_params...] — nominal_reaction_params supplies nominal values for the reaction parameters only; α goes in slot 0 separately.

The reaction closure receives (t, x, y, u, &p_full) where p_full is the full parameter slice (p_full[0] is α; p_full[1..] are the reaction parameters supplied here).

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

Get the spatial grid.

pub fn n_interior(&self) -> usize

Number of interior points (the ODE state dimension).

Trait Implementations

impl<S: SparseScalar> ParametricOdeSystem<S> for ParametricMOLSystem2D<S>

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

Analytical state Jacobian: α · L0 plus the diagonal reaction contribution. Same structure as MOLSystem2D::jacobian, but the linear part is scaled by α from the parameter vector — and the reaction sees the full parameter slice.

fn jacobian_p(&self, t: S, y: &[S], jp: &mut [S])

Analytical parameter Jacobian. Column 0 (the α slot) is L0·y + bc_rhs_0 analytically, plus any ∂R/∂α contribution from the reaction closure (FD-detected). Columns 1..N_s are pure reaction contributions (FD on the closure with the relevant slot perturbed). The reaction is pointwise so each column has only diagonal entries (one nonzero per grid point).

fn n_states(&self) -> usize

Number of state variables N (the dimension of y).

fn n_params(&self) -> usize

Number of parameters N_s (the dimension of p).

fn params(&self) -> &[S]

Nominal parameter vector. Length must equal Self::n_params.

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

Evaluate f(t, y, p) -> dy/dt for an arbitrary parameter vector p.

fn has_analytical_jacobian_y(&self) -> bool

Returns true iff Self::jacobian_y has been overridden with an analytical implementation. Default: false.

fn has_analytical_jacobian_p(&self) -> bool

Returns true iff Self::jacobian_p has been overridden with an analytical implementation. Default: false. See Self::has_analytical_jacobian_y for the rationale, contract, and debug-build consistency check.

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

Convenience: evaluate the RHS at the system’s nominal parameters.

fn initial_sensitivity(&self, _y0: &[S], s0: &mut [S])

Initial sensitivity ∂y_0/∂p, column-major (s0[k*N + i], length N · N_s).