Struct AdjointRhs 

pub struct AdjointRhs<'a, Eqn, Method>
where
    Eqn: OdeEquations,
    Method: OdeSolverMethod<'a, Eqn>,
{ /* private fields */ }

Right-hand side of the adjoint equations is:

F(λ, x, t) = -f^T_x(x, t) λ - g^T_x(x,t)

f_x is the partial derivative of the right-hand side with respect to the state vector. g_x is the partial derivative of the functional g with respect to the state vector.

We need the current state x(t), which is obtained from the checkpointed forward solve at the current time step.

Implementations

impl<'a, Eqn, Method> AdjointRhs<'a, Eqn, Method>

where Eqn: OdeEquations, Method: OdeSolverMethod<'a, Eqn>,

pub fn new( eqn: &'a Eqn, context: Rc<RefCell<AdjointContext<'a, Eqn, Method>>>, with_out: bool, ) -> Self

Trait Implementations

impl<'a, Eqn, Method> NonLinearOp for AdjointRhs<'a, Eqn, Method>

where Eqn: OdeEquationsAdjoint, Method: OdeSolverMethod<'a, Eqn>,

fn call_inplace(&self, lambda: &Self::V, t: Self::T, y: &mut Self::V)

F(λ, x, t) = -f^T_x(x, t) λ - g^T_x(x,t)

fn call(&self, x: &Self::V, t: Self::T) -> Self::V

Compute the operator F(x, t) at a given state and time, and return the result. Use [Self::call_inplace] to for a non-allocating version.

impl<'a, Eqn, Method> NonLinearOpJacobian for AdjointRhs<'a, Eqn, Method>

where Eqn: OdeEquationsAdjoint, Method: OdeSolverMethod<'a, Eqn>,

fn jac_mul_inplace( &self, _x: &Self::V, t: Self::T, v: &Self::V, y: &mut Self::V, )

Compute the product of the Jacobian with a given vector J(x, t) * v.

fn jacobian_inplace(&self, _x: &Self::V, t: Self::T, y: &mut Self::M)

Compute the Jacobian matrix J(x, t) of the operator and store it in the matrix y. y should have been previously initialised using the output of Self::jacobian_sparsity. The default implementation of this method computes the Jacobian using Self::jac_mul_inplace, but it can be overriden for more efficient implementations.

fn jacobian_sparsity(&self) -> Option<<Self::M as Matrix>::Sparsity>

Return sparsity information (if available)

fn jac_mul(&self, x: &Self::V, t: Self::T, v: &Self::V) -> Self::V

Compute the product of the Jacobian with a given vector J(x, t) * v, and return the result. Use [Self::jac_mul_inplace] to for a non-allocating version.

fn jacobian(&self, x: &Self::V, t: Self::T) -> Self::M

Compute the Jacobian matrix J(x, t) of the operator and return it. See Self::jacobian_inplace for a non-allocating version.

fn _default_jacobian_inplace(&self, x: &Self::V, t: Self::T, y: &mut Self::M)

Default implementation of the Jacobian computation (this is the default for Self::jacobian_inplace).

impl<'a, Eqn, Method> Op for AdjointRhs<'a, Eqn, Method>

where Eqn: OdeEquations, Method: OdeSolverMethod<'a, Eqn>,

type T = <Eqn as Op>::T

type V = <Eqn as Op>::V

type M = <Eqn as Op>::M

type C = <Eqn as Op>::C

fn nstates(&self) -> usize

Return the number of input states of the operator.

fn nout(&self) -> usize

Return the number of outputs of the operator.

fn nparams(&self) -> usize

Return the number of parameters of the operator.

fn context(&self) -> &Self::C

return the context of the operator

fn statistics(&self) -> OpStatistics

Return statistics about the operator (e.g. how many times it was called, how many times the jacobian was computed, etc.)