Struct Checkpointing 

pub struct Checkpointing<Eqn, State>
where
    Eqn: OdeEquations,
    State: OdeSolverState<Eqn::V>,
{ /* private fields */ }

Checkpointing system for adjoint sensitivity analysis.

This struct manages checkpoints of an ODE solution for use in adjoint sensitivity computation. It stores solution states at discrete checkpoints and uses Hermite interpolation between them to provide solution values at arbitrary time points during the backward adjoint solve.

The checkpointing system uses a two-level interpolation strategy:

1. Checkpoints: Discrete saved states of the ODE solution
2. Segments: Hermite interpolators that densely sample between adjacent checkpoints

When interpolating at a time point, the system first checks if it’s in the current segment. If not, it re-solves the ODE between the appropriate checkpoints to create a new segment, then interpolates within that segment.

Implementations

impl<Eqn, State> Checkpointing<Eqn, State>

where Eqn: OdeEquations, State: OdeSolverState<Eqn::V>,

pub fn new<'a, Method>( solver: Option<&mut Method>, start_idx: usize, checkpoints: Vec<State>, segment: Option<HermiteInterpolator<Eqn::V>>, ) -> Self

where Eqn: 'a, Method: OdeSolverMethod<'a, Eqn, State = State>,

Create a new checkpointing system.

Arguments

• solver: The forward solver to use for re-solving segments
• start_idx: Index of the checkpoint to start from (must be < checkpoints.len() - 1)
• checkpoints: Vector of saved solution states (must have at least 2 elements)
• segment: Optional pre-computed Hermite interpolator for the initial segment given by start_idx. If None, the segment between checkpoints[start_idx] and checkpoints[start_idx+1] will be computed automatically.

Panics

Panics if checkpoints.len() < 2 or if start_idx >= checkpoints.len() - 1.

pub fn terminal_reset_root_idx(&self) -> Option<usize>

Returns the root index when this checkpointing segment ended at a root.

None means the segment ended at a configured stop time.

pub fn first_checkpoint(&self) -> &State

pub fn last_checkpoint(&self) -> &State

pub fn last_t(&self) -> Eqn::T

Get the last (most recent) time point in the current segment.

Returns

The last time value in the current interpolation segment.

Panics

Panics if the segment is empty (should never happen with valid construction).

pub fn first_t(&self) -> Eqn::T

pub fn end_t(&self) -> Eqn::T

pub fn last_h(&self) -> Option<Eqn::T>

Get the last time step size in the current segment.

Returns

The difference between the last two time points in the current segment, or None if the segment has fewer than two points.

pub fn interpolate<'a, Method>( &self, solver: Option<&mut Method>, t: Eqn::T, y: &mut Eqn::V, ) -> Result<(), DiffsolError>

where Eqn: 'a, Method: OdeSolverMethod<'a, Eqn, State = State>,

Interpolate the solution at a given time point.

This method provides the forward solution value at time t for use during the backward adjoint solve. It first checks if t is within the current or previous segment. If not, it identifies the appropriate checkpoint interval, re-solves the ODE between those checkpoints to create a new segment, and then interpolates within that segment.

Arguments

• t: The time at which to interpolate the solution
• y: Output vector to store the interpolated solution

Returns

• Ok(()) if interpolation succeeded
• Err(...) if t is outside the range of checkpoints (beyond roundoff tolerance) or if re-solving the ODE fails

Notes

Small deviations from the checkpoint range (within roundoff error) are automatically snapped to the nearest checkpoint boundary.

Trait Implementations

impl<Eqn, State> Clone for Checkpointing<Eqn, State>

where Eqn: OdeEquations, State: OdeSolverState<Eqn::V>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.