Struct RkState 

pub struct RkState<V: Vector> { /* private fields */ }

State container for the SDIRK Runge-Kutta solversintegrator. For the common state API use as_ref and as_mut methods.

Trait Implementations

impl<V: Clone + Vector> Clone for RkState<V>

where V::T: Clone,

fn clone(&self) -> RkState<V>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V> OdeSolverState<V> for RkState<V>

where V: Vector,

fn set_problem<Eqn: OdeEquations>( &mut self, _ode_problem: &OdeSolverProblem<Eqn>, ) -> Result<(), DiffsolError>

Set the ODE problem for the state, allocating any necessary data structures.

fn set_augmented_problem<Eqn: OdeEquations, AugmentedEqn: AugmentedOdeEquations<Eqn>>( &mut self, _ode_problem: &OdeSolverProblem<Eqn>, _augmented_eqn: &AugmentedEqn, ) -> Result<(), DiffsolError>

Set the augmented ODE problem (for sensitivities) for the state.

fn new_from_common(state: StateCommon<V>) -> Self

Create a new state from a common state representation.

fn into_common(self) -> StateCommon<V>

Convert the state into a common state representation.

fn as_mut(&mut self) -> StateRefMut<'_, V>

Get a mutable reference to the state.

fn as_ref(&self) -> StateRef<'_, V>

Get an immutable reference to the state.

fn check_consistent_with_problem<Eqn: OdeEquations>( &self, problem: &OdeSolverProblem<Eqn>, ) -> Result<(), DiffsolError>

Check that the state is consistent with the given ODE problem.

fn check_sens_consistent_with_problem<Eqn: OdeEquations, AugmentedEqn: AugmentedOdeEquations<Eqn>>( &self, problem: &OdeSolverProblem<Eqn>, augmented_eqn: &AugmentedEqn, ) -> Result<(), DiffsolError>

Check that the sensitivity vectors in the state are consistent with the given ODE problem.

fn state_mut_op<Eqn, O>( &mut self, eqn: &Eqn, op: &O, ) -> Result<(), DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>, O: NonLinearOp<T = V::T, V = V, M = Eqn::M>,

Apply a non-linear operator to the current state in-place, replacing state.y with op(state.y, state.t) and recomputing state.dy = rhs(state.y, state.t).

fn state_mut_op_with_sens_and_reset<Eqn, G, R>( &mut self, eqn: &Eqn, reset_op: &G, root_op: &R, root_idx: usize, ) -> Result<(), DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>, G: NonLinearOpJacobian<T = V::T, V = V, M = Eqn::M> + NonLinearOpSens<T = V::T, V = V, M = Eqn::M> + NonLinearOpTimePartial<T = V::T, V = V, M = Eqn::M>, R: NonLinearOpJacobian<T = V::T, V = V, M = Eqn::M> + NonLinearOpSens<T = V::T, V = V, M = Eqn::M> + NonLinearOpTimePartial<T = V::T, V = V, M = Eqn::M>,

Apply a reset operator to the current state and propagate sensitivities through a time-dependent root-triggered event correction.

fn state_mut_op_with_adjoint_and_reset<'a, Eqn, Method, G, R>( &mut self, adj_eqn: &mut AdjointEquations<'a, Eqn, Method>, reset_op: &G, root_op: &R, root_idx: usize, fwd_state_minus: &Self, fwd_state_plus: &Self, ) -> Result<(), DiffsolError>

where Eqn: OdeEquationsAdjoint<T = V::T, V = V, C = V::C>, Method: OdeSolverMethod<'a, Eqn>, G: NonLinearOpJacobian<T = V::T, V = V, M = Eqn::M> + NonLinearOpAdjoint<T = V::T, V = V, M = Eqn::M> + NonLinearOpSensAdjoint<T = V::T, V = V, M = Eqn::M> + NonLinearOpTimePartial<T = V::T, V = V, M = Eqn::M>, R: NonLinearOpJacobian<T = V::T, V = V, M = Eqn::M> + NonLinearOpAdjoint<T = V::T, V = V, M = Eqn::M> + NonLinearOpSensAdjoint<T = V::T, V = V, M = Eqn::M> + NonLinearOpTimePartial<T = V::T, V = V, M = Eqn::M>,

Propagate adjoint variables through a time-dependent root-triggered reset.

fn state_mut_adjoint_terminal_root<'a, Eqn, Method>( &mut self, adj_eqn: &mut AdjointEquations<'a, Eqn, Method>, root_idx: usize, forward: &Self, ) -> Result<(), DiffsolError>

where Eqn: OdeEquationsAdjoint<T = V::T, V = V, C = V::C, Root: NonLinearOpJacobian<T = V::T, V = V, M = Eqn::M> + NonLinearOpAdjoint<T = V::T, V = V, M = Eqn::M> + NonLinearOpSensAdjoint<T = V::T, V = V, M = Eqn::M> + NonLinearOpTimePartial<T = V::T, V = V, M = Eqn::M>, Out: NonLinearOp<T = V::T, V = V, M = Eqn::M>>, Method: OdeSolverMethod<'a, Eqn>,

Add the terminal-root adjoint correction for a root-defined final time.

fn new<Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>,

Create a new solver state from an ODE problem. This function will set the initial step size based on the given solver. If you want to create a state without this default initialisation, use Self::new_without_initialise instead. You can then use Self::set_consistent and Self::set_step_size to set the state up if you need to.

fn new_and_consistent<LS, Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquationsImplicit<T = V::T, V = V, C = V::C>, LS: LinearSolver<Eqn::M>,

Create a new solver state from an ODE problem. This function will make the state consistent with any algebraic constraints using a default nonlinear solver. It will also set the initial step size based on the given solver. If you want to create a state without this default initialisation, use Self::new_without_initialise instead. You can then use Self::set_consistent and Self::set_step_size to set the state up if you need to.

fn new_with_sensitivities<Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquationsImplicitSens<T = V::T, V = V, C = V::C>,

Create a new solver state from an ODE problem with sensitivity equations. This will initialize the sensitivity vectors but will not make them consistent with algebraic constraints.

fn new_with_sensitivities_and_consistent<LS, Eqn>( ode_problem: &OdeSolverProblem<Eqn>, solver_order: usize, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquationsImplicitSens<T = V::T, V = V, C = V::C>, LS: LinearSolver<Eqn::M>,

Create a new solver state from an ODE problem with sensitivity equations, making both the main state and sensitivities consistent with algebraic constraints.

fn new_without_initialise<Eqn>( ode_problem: &OdeSolverProblem<Eqn>, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>,

Create a new solver state from an ODE problem, without any initialisation apart from setting the initial time state vector y, the initial time derivative dy and if applicable the sensitivity vectors s. This is useful if you want to set up the state yourself, or if you want to use a different nonlinear solver to make the state consistent, or if you want to set the step size yourself or based on the exact order of the solver.

fn new_without_initialise_augmented<Eqn, AugmentedEqn>( ode_problem: &OdeSolverProblem<Eqn>, augmented_eqn: &mut AugmentedEqn, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>, AugmentedEqn: AugmentedOdeEquations<Eqn>,

Create a new solver state with augmented equations (sensitivities) from an ODE problem, without making the augmented state consistent.

fn new_without_initialise_augmented_at<Eqn, AugmentedEqn>( ode_problem: &OdeSolverProblem<Eqn>, augmented_eqn: &mut AugmentedEqn, t: V::T, ) -> Result<Self, DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>, AugmentedEqn: AugmentedOdeEquations<Eqn>,

Create a new solver state with augmented equations from an ODE problem, evaluating the augmented initial/output operators at a caller-supplied time while leaving the base state allocation behavior unchanged.

fn initialise_augmented_state<Eqn, AugmentedEqn>( augmented_eqn: &mut AugmentedEqn, ode_problem: &OdeSolverProblem<Eqn>, state: &mut StateCommon<V>, ) -> Result<(), DiffsolError>

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>, AugmentedEqn: AugmentedOdeEquations<Eqn>,

fn set_consistent<Eqn, S>( &mut self, ode_problem: &OdeSolverProblem<Eqn>, root_solver: &mut S, ) -> Result<(), DiffsolError>

where Eqn: OdeEquationsImplicit<T = V::T, V = V, C = V::C>, S: NonLinearSolver<Eqn::M>,

Calculate a consistent state and time derivative of the state, based on the equations of the problem.

fn set_consistent_augmented<Eqn, AugmentedEqn, S>( &mut self, ode_problem: &OdeSolverProblem<Eqn>, augmented_eqn: &mut AugmentedEqn, root_solver: &mut S, ) -> Result<(), DiffsolError>

where Eqn: OdeEquationsImplicit<T = V::T, V = V, C = V::C>, AugmentedEqn: AugmentedOdeEquationsImplicit<Eqn> + Debug, S: NonLinearSolver<AugmentedEqn::M>,

Calculate the initial sensitivity vectors and their time derivatives, based on the equations of the problem. Note that this function assumes that the state is already consistent with the algebraic constraints (either via Self::set_consistent or by setting the state up manually).

fn set_step_size<Eqn>( &mut self, h0: Eqn::T, atol: &Eqn::V, rtol: Eqn::T, eqn: &Eqn, solver_order: usize, )

where Eqn: OdeEquations<T = V::T, V = V, C = V::C>,

compute size of first step based on alg in Hairer, Norsett, Wanner Solving Ordinary Differential Equations I, Nonstiff Problems Section II.4.2 Note: this assumes that the state is already consistent with the algebraic constraints and y and dy are already set appropriately