Struct diffsol::ode_solver::sdirk::Sdirk

pub struct Sdirk<M, Eqn, LS>
where
    M: DenseMatrix<T = Eqn::T, V = Eqn::V>,
    LS: LinearSolver<SdirkCallable<Eqn>>,
    Eqn: OdeEquations,
    for<'a> &'a Eqn::V: VectorRef<Eqn::V>,
    for<'a> &'a Eqn::M: MatrixRef<Eqn::M>,
{ /* private fields */ }

A singly diagonally implicit Runge-Kutta method. Can optionally have an explicit first stage for ESDIRK methods. The particular method is defined by the Tableau used to create the solver. If the beta matrix of the Tableau is present this is used for interpolation, otherwise hermite interpolation is used.

Restrictions:

• The upper triangular part of the a matrix must be zero (i.e. not fully implicit).
• The diagonal of the a matrix must be the same non-zero value for all rows (i.e. an SDIRK method), except for the first row which can be zero for ESDIRK methods.
• The last row of the a matrix must be the same as the b vector, and the last element of the c vector must be 1 (i.e. a stiffly accurate method)

Implementations

impl<M, Eqn, LS> Sdirk<M, Eqn, LS>

where LS: LinearSolver<SdirkCallable<Eqn>>, M: DenseMatrix<T = Eqn::T, V = Eqn::V>, Eqn: OdeEquations, for<'a> &'a Eqn::V: VectorRef<Eqn::V>, for<'a> &'a Eqn::M: MatrixRef<Eqn::M>,

pub fn new(tableau: Tableau<M>, linear_solver: LS) -> Self

pub fn get_statistics(&self) -> &BdfStatistics<Eqn::T>

Trait Implementations

impl<M, Eqn, LS> OdeSolverMethod<Eqn> for Sdirk<M, Eqn, LS>

where LS: LinearSolver<SdirkCallable<Eqn>>, M: DenseMatrix<T = Eqn::T, V = Eqn::V>, Eqn: OdeEquations, for<'a> &'a Eqn::V: VectorRef<Eqn::V>, for<'a> &'a Eqn::M: MatrixRef<Eqn::M>,

fn problem(&self) -> Option<&OdeSolverProblem<Eqn>>

Get the current problem if it has been set

fn order(&self) -> usize

Get the current order of accuracy of the solver (e.g. explict euler method is first-order)

fn take_state(&mut self) -> Option<OdeSolverState<Eqn::V>>

Take the current state of the solver, if it exists, returning it to the user. This is useful if you want to use this state in another solver or problem. Note that this will unset the current problem and solver state, so you will need to call set_problem again before calling step or solve.

fn set_problem( &mut self, state: OdeSolverState<Eqn::V>, problem: &OdeSolverProblem<Eqn> )

Set the problem to solve, this performs any initialisation required by the solver. Call this before calling step or solve. The solver takes ownership of the initial state given by state, this is assumed to be consistent with any algebraic constraints, and the time step h is assumed to be set appropriately for the problem

fn step(&mut self) -> Result<OdeSolverStopReason<Eqn::T>>

Step the solution forward by one step, altering the internal state of the solver. The return value is a Result containing the reason for stopping the solver, possible reasons are:

fn set_stop_time(&mut self, tstop: <Eqn as OdeEquations>::T) -> Result<()>

Set a stop time for the solver. The solver will stop when the internal time reaches this time. Once it stops, the stop time is unset. If tstop is at or before the current internal time, an error is returned.

fn interpolate_sens( &self, t: <Eqn as OdeEquations>::T ) -> Result<Vec<<Eqn as OdeEquations>::V>>

Interpolate the sensitivity vectors at a given time. This time should be between the current time and the last solver time step

fn interpolate(&self, t: Eqn::T) -> Result<Eqn::V>

Interpolate the solution at a given time. This time should be between the current time and the last solver time step

fn state(&self) -> Option<&OdeSolverState<Eqn::V>>

Get the current state of the solver, if it exists

fn state_mut(&mut self) -> Option<&mut OdeSolverState<Eqn::V>>

Get a mutable reference to the current state of the solver, if it exists Note that calling this will cause the next call to step to perform some reinitialisation to take into account the mutated state, this could be expensive for multi-step methods.