Public API

This page lists exported symbols of CTFlows.Systems.

From `CTFlows.Systems`

`CTFlows.Systems` [Module]

julia

Systems

System types and contracts for CTFlows.

This module defines the AbstractSystem type and its required methods:

get_ip_rhs: returns the in-place right-hand side function for integration
get_oop_rhs: returns the out-of-place right-hand side function for integration
get_ip_rhs_augmented: returns the augmented in-place right-hand side for Hamiltonian systems
dimensions: returns dimensional information (state, costate, control, variable)

`AbstractHVFRHS` [Abstract Type]

CTFlows.Systems.AbstractHVFRHS Type

julia

AbstractHVFRHS{T<:Traits.AbstractMutabilityTrait} <: AbstractRHS{T}

Abstract base type for HamiltonianVectorField RHS functors.

Provides a common supertype for all Hamiltonian vector field functors, enabling generic display methods that access the .hvf field.

Type Parameters

T <: Traits.AbstractMutabilityTrait: The mutability trait (InPlace or OutOfPlace).

`AbstractHamRHS` [Abstract Type]

CTFlows.Systems.AbstractHamRHS Type

julia

abstract type AbstractHamRHS{T<:CTBase.Traits.AbstractMutabilityTrait} <: CTFlows.Systems.AbstractRHS{T<:CTBase.Traits.AbstractMutabilityTrait}

Abstract supertype for Hamiltonian right-hand side (RHS) functors.

RHS functors compute the derivatives for Hamiltonian systems according to Hamilton's equations. The type parameter encodes the mutability trait (in-place vs out-of-place) for compile-time dispatch.

Type Parameters

T <: AbstractMutabilityTrait: Mutability trait (InPlace or OutOfPlace).

Interface Requirements

All subtypes must implement a callable interface:

In-place: (f::SubType)(du, u, λ, t) for mutating output
Out-of-place: (f::SubType)(u, λ, t) -> du for allocating output

Notes

Subtypes include CTFlows.Systems.AbstractIPHamRHS and CTFlows.Systems.AbstractOoPHamRHS.
These functors are created by build_rhs and related functions.

`AbstractHamiltonianSystem` [Abstract Type]

CTFlows.Systems.AbstractHamiltonianSystem Type

julia

abstract type AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics}

Alias for Hamiltonian systems.

Matches any AbstractSystem with HamiltonianDynamics as the dynamics parameter. The AD capability is encoded as a plain trait (ad_trait) on the concrete type, not as a type parameter of this alias.

Type Parameters

TD <: TimeDependence: Time dependence trait (Autonomous or NonAutonomous)
VD <: VariableDependence: Variable dependence trait (Fixed or NonFixed)

Example

julia

julia> using CTFlows: Systems

julia> Systems.HamiltonianSystem <: Systems.AbstractHamiltonianSystem
true

`AbstractIPHVFRHS` [Abstract Type]

CTFlows.Systems.AbstractIPHVFRHS Type

julia

AbstractIPHVFRHS <: AbstractHVFRHS{Traits.InPlace}

Abstract base type for in-place HamiltonianVectorField RHS functors.

`AbstractIPHamRHS` [Abstract Type]

CTFlows.Systems.AbstractIPHamRHS Type

julia

abstract type AbstractIPHamRHS <: CTFlows.Systems.AbstractHamRHS{CTBase.Traits.InPlace}

Abstract supertype for in-place Hamiltonian RHS functors.

Subtypes of this abstract type implement in-place computation of Hamiltonian derivatives, mutating the output vector du rather than allocating a new one.

Notes

All subtypes must implement (f::SubType)(du, u, λ, t).
Concrete subtypes include CTFlows.Systems.HamIpRHS and CTFlows.Systems.HamIpAugRHS.

`AbstractIPPseudoHVFRHS` [Abstract Type]

CTFlows.Systems.AbstractIPPseudoHVFRHS Type

julia

abstract type AbstractIPPseudoHVFRHS <: CTFlows.Systems.AbstractPseudoHVFRHS{CTBase.Traits.InPlace}

Abstract supertype for in-place PseudoHamiltonianVectorFieldSystem RHS functors.

`AbstractIPPseudoHamRHS` [Abstract Type]

CTFlows.Systems.AbstractIPPseudoHamRHS Type

julia

abstract type AbstractIPPseudoHamRHS <: CTFlows.Systems.AbstractPseudoHamRHS{CTBase.Traits.InPlace}

Abstract supertype for in-place pseudo-Hamiltonian RHS functors.

`AbstractIPRHS` [Abstract Type]

CTFlows.Systems.AbstractIPRHS Type

julia

AbstractIPRHS <: AbstractRHS{Traits.InPlace}

Abstract supertype for in-place RHS functors.

These functors have the signature (du, u, λ, t) -> nothing and modify du in place.

`AbstractOoPHVFRHS` [Abstract Type]

CTFlows.Systems.AbstractOoPHVFRHS Type

julia

AbstractOoPHVFRHS <: AbstractHVFRHS{Traits.OutOfPlace}

Abstract base type for out-of-place HamiltonianVectorField RHS functors.

`AbstractOoPHamRHS` [Abstract Type]

CTFlows.Systems.AbstractOoPHamRHS Type

julia

abstract type AbstractOoPHamRHS <: CTFlows.Systems.AbstractHamRHS{CTBase.Traits.OutOfPlace}

Abstract supertype for out-of-place Hamiltonian RHS functors.

Subtypes of this abstract type implement out-of-place computation of Hamiltonian derivatives, allocating and returning a new output vector.

Notes

All subtypes must implement (f::SubType)(u, λ, t) -> du.
Concrete subtypes include CTFlows.Systems.HamOoPRHS.

`AbstractOoPPseudoHVFRHS` [Abstract Type]

CTFlows.Systems.AbstractOoPPseudoHVFRHS Type

julia

abstract type AbstractOoPPseudoHVFRHS <: CTFlows.Systems.AbstractPseudoHVFRHS{CTBase.Traits.OutOfPlace}

Abstract supertype for out-of-place PseudoHamiltonianVectorFieldSystem RHS functors.

`AbstractOoPPseudoHamRHS` [Abstract Type]

CTFlows.Systems.AbstractOoPPseudoHamRHS Type

julia

abstract type AbstractOoPPseudoHamRHS <: CTFlows.Systems.AbstractPseudoHamRHS{CTBase.Traits.OutOfPlace}

Abstract supertype for out-of-place pseudo-Hamiltonian RHS functors.

`AbstractOoPRHS` [Abstract Type]

CTFlows.Systems.AbstractOoPRHS Type

julia

AbstractOoPRHS <: AbstractRHS{Traits.OutOfPlace}

Abstract supertype for out-of-place RHS functors.

These functors have the signature (u, λ, t) -> du and return a new array without modifying the input.

`AbstractPseudoHVFRHS` [Abstract Type]

CTFlows.Systems.AbstractPseudoHVFRHS Type

julia

abstract type AbstractPseudoHVFRHS{T<:CTBase.Traits.AbstractMutabilityTrait} <: CTFlows.Systems.AbstractRHS{T<:CTBase.Traits.AbstractMutabilityTrait}

Abstract supertype for PseudoHamiltonianVectorFieldSystem right-hand side (RHS) functors. The type parameter encodes the mutability trait (in-place vs out-of-place).

`AbstractPseudoHamRHS` [Abstract Type]

CTFlows.Systems.AbstractPseudoHamRHS Type

julia

abstract type AbstractPseudoHamRHS{T<:CTBase.Traits.AbstractMutabilityTrait} <: CTFlows.Systems.AbstractRHS{T<:CTBase.Traits.AbstractMutabilityTrait}

Abstract supertype for pseudo-Hamiltonian right-hand side (RHS) functors. The type parameter encodes the mutability trait (in-place vs out-of-place).

`AbstractRHS` [Abstract Type]

CTFlows.Systems.AbstractRHS Type

julia

AbstractRHS{T<:Traits.AbstractMutabilityTrait}

Abstract supertype for all RHS functors.

Parameterized by the interface mutability trait:

Traits.InPlace: in-place interface (du, u, λ, t) -> nothing
Traits.OutOfPlace: out-of-place interface (u, λ, t) -> du

`AbstractStateSystem` [Abstract Type]

CTFlows.Systems.AbstractStateSystem Type

julia

abstract type AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.StateDynamics}

Alias for state systems (non-Hamiltonian).

Matches any AbstractSystem with StateDynamics as the dynamics parameter.

Type Parameters

TD <: TimeDependence: Time dependence trait (Autonomous or NonAutonomous)
VD <: VariableDependence: Variable dependence trait (Fixed or NonFixed)

Example

julia

julia> using CTFlows: Systems

julia> Systems.VectorFieldSystem <: Systems.AbstractStateSystem
true

`AbstractSystem` [Abstract Type]

CTFlows.Systems.AbstractSystem Type

julia

abstract type AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, D<:CTBase.Traits.AbstractDynamicsTrait}

Abstract type for all systems in CTFlows.

An AbstractSystem represents a fully assembled object that can be integrated. It embeds its own right-hand side, dimensional metadata, and solution-building logic.

Contract

All subtypes must implement:

get_ip_rhs(system::AbstractSystem, config): Returns a function (du, u, p, t) -> nothing that fills du in place.
get_oop_rhs(system::AbstractSystem, config): Returns a function (u, p, t) -> du that returns the derivative.

Hamiltonian systems supporting variable-costate integration additionally implement get_ip_rhs_augmented(system::AbstractHamiltonianSystem, config).

Example

julia

using CTFlows: Systems

# Define a concrete system
struct MySystem <: Systems.AbstractSystem{Traits.Autonomous, Traits.Fixed, Traits.StateDynamics}
    data::Vector{Float64}
end

# Implement required contract methods
function Systems.get_ip_rhs(sys::MySystem, config)
    return (du, u, p, t) -> du .= sys.data .* u
end

function Systems.get_oop_rhs(sys::MySystem, config)
    return (u, p, t) -> sys.data .* u
end

`ConstrainedPseudoHamIpAugRHS` [Struct]

CTFlows.Systems.ConstrainedPseudoHamIpAugRHS Type

julia

struct ConstrainedPseudoHamIpAugRHS{PH<:CTBase.Data.PseudoHamiltonian, L<:CTBase.Data.ControlLaw, G, M, B<:CTBase.Differentiation.AbstractADBackend, CX<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}, CP<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}} <: CTFlows.Systems.AbstractIPPseudoHamRHS

In-place augmented RHS functor for a CTFlows.Systems.ConstrainedPseudoHamiltonianSystem with variable costate. Extends CTFlows.Systems.ConstrainedPseudoHamIpRHS with ṗv = -∂/∂v[H̃ + μ_·g] (control and multiplier frozen), computed by CTBase.Differentiation.pseudo_variable_gradient. The augmented state is [x; p; pv]; the ṗv block picks up −μ_ᵀ ∂g/∂v at frozen μ.

Fields

h̃::PH: base pseudo-Hamiltonian H̃(t, x, p, u, v).
law::L: dynamic closed-loop control law u(t, x, p, v).
g::G: path constraint g(t, x, u, v).
μ::M: multiplier μ(t, x, p, v).
backend::B: the AD backend.
n_x::Int: state dimension.
n_v::Int: variable dimension.
cx::CX: state coercion.
cp::CP: costate coercion.

`ConstrainedPseudoHamIpRHS` [Struct]

CTFlows.Systems.ConstrainedPseudoHamIpRHS Type

julia

struct ConstrainedPseudoHamIpRHS{PH<:CTBase.Data.PseudoHamiltonian, L<:CTBase.Data.ControlLaw, G, M, B<:CTBase.Differentiation.AbstractADBackend, CX<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}, CP<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}} <: CTFlows.Systems.AbstractIPPseudoHamRHS

In-place RHS functor for a CTFlows.Systems.ConstrainedPseudoHamiltonianSystem. Evaluates the feedback control u_ = law(t, x, p, v) and the multiplier value μ_ = μ(t, x, p, v), then computes, at that fixed (u_, μ_),

julia

ẋ =  ∂/∂p [ H̃ + μ_·g ]
ṗ = -∂/∂x [ H̃ + μ_·g ]

with g differentiated and μ_ frozen (constrained :partial mode).

Fields

h̃::PH: base pseudo-Hamiltonian H̃(t, x, p, u, v).
law::L: dynamic closed-loop control law u(t, x, p, v).
g::G: path constraint g(t, x, u, v).
μ::M: multiplier μ(t, x, p, v).
backend::B: the AD backend.
N::Int: state dimension.
cx::CX: state coercion.
cp::CP: costate coercion.

`ConstrainedPseudoHamOoPRHS` [Struct]

CTFlows.Systems.ConstrainedPseudoHamOoPRHS Type

julia

struct ConstrainedPseudoHamOoPRHS{PH<:CTBase.Data.PseudoHamiltonian, L<:CTBase.Data.ControlLaw, G, M, B<:CTBase.Differentiation.AbstractADBackend, CX<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}, CP<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}} <: CTFlows.Systems.AbstractOoPPseudoHamRHS

Out-of-place RHS functor for a CTFlows.Systems.ConstrainedPseudoHamiltonianSystem; see CTFlows.Systems.ConstrainedPseudoHamIpRHS for the computation. Returns vcat(∂p, -∂x).

Fields

h̃::PH: base pseudo-Hamiltonian H̃(t, x, p, u, v).
law::L: dynamic closed-loop control law u(t, x, p, v).
g::G: path constraint g(t, x, u, v).
μ::M: multiplier μ(t, x, p, v).
backend::B: the AD backend.
N::Int: state dimension.
cx::CX: state coercion.
cp::CP: costate coercion.

`ConstrainedPseudoHamiltonianSystem` [Struct]

CTFlows.Systems.ConstrainedPseudoHamiltonianSystem Type

julia

struct ConstrainedPseudoHamiltonianSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, PH<:(CTBase.Data.PseudoHamiltonian{<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}), L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback}), G, M, BACKEND<:CTBase.Differentiation.AbstractADBackend} <: CTFlows.Systems.AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics}

Concrete AbstractHamiltonianSystem built from a pseudo-Hamiltonian H̃(t,x,p,u,v), a dynamic closed-loop control law u(t,x,p,v), a path constraint g(t,x,u,v) and a multiplier μ(t,x,p,v). It integrates the Hamiltonian system of the constrained pseudo-Hamiltonian H̃ + μ·g

julia

ẋ =  ∂/∂p [H̃ + μ·g] ,   ṗ = -∂/∂x [H̃ + μ·g]

with both the control u = u(t,x,p,v) and the multiplier value μ = μ(t,x,p,v) held fixed during differentiation (the constrained :partial mode): g is differentiated in (x,p,v), μ is not. This is the counterpart of CTFlows.Systems.PseudoHamiltonianSystem for constrained flows; the constrained :total mode instead bakes μ as a function and composes with the law (see CTFlows.Flows.ConstrainedPseudoHamiltonianFunction).

Type Parameters

TD <: TimeDependence, VD <: VariableDependence: traits of the pseudo-Hamiltonian.
PH <: PseudoHamiltonian: concrete pseudo-Hamiltonian type.
L <: ControlLaw: concrete control-law type (DynClosedLoopFeedback).
G: concrete path-constraint type.
M: concrete multiplier type.
BACKEND <: AbstractADBackend: concrete AD backend type.

Fields

h̃::PH: the (base) pseudo-Hamiltonian.
law::L: the dynamic closed-loop control law.
g::G: the path constraint g(t,x,u,v).
μ::M: the multiplier μ(t,x,p,v).
backend::BACKEND: the AD backend.

`FrozenConstrainedPseudoHamiltonian` [Struct]

CTFlows.Systems.FrozenConstrainedPseudoHamiltonian Type

julia

struct FrozenConstrainedPseudoHamiltonian{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, PH, G, T} <: CTBase.Data.AbstractPseudoHamiltonian{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}

Constrained pseudo-Hamiltonian carrying a frozen multiplier value, used to compute the constrained :partial-mode gradients. Represents

julia

H̃c(t, x, p, u, v) = H̃(t, x, p, u, v) + μ_ · g(t, x, u, v)

where μ_ is a numeric value (already evaluated at the current point), so automatic differentiation through this functor differentiates H̃ and g but treats μ_ as a constant — the constrained :partial semantics (μ frozen alongside u, g differentiated). It subtypes CTBase.Data.AbstractPseudoHamiltonian so it is accepted by CTBase.Differentiation.pseudo_hamiltonian_gradient and CTBase.Differentiation.pseudo_variable_gradient, which call it only through the uniform (t, x, p, u, v) signature.

Type Parameters

TD, VD: time- and variable-dependence traits, inherited from the base H̃.
PH: type of the base pseudo-Hamiltonian H̃.
G: type of the path constraint g.
T: type of the frozen multiplier value μ_.

Fields

h̃::PH: base pseudo-Hamiltonian, uniform call H̃(t, x, p, u, v).
g::G: path constraint, uniform call g(t, x, u, v).
μ_::T: frozen multiplier value (scalar or vector), captured as a constant.

`HamiltonianGradient` [Struct]

CTFlows.Systems.HamiltonianGradient Type

julia

struct HamiltonianGradient{H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}

Functor returning the gradient (∂H/∂x, ∂H/∂p) of a true Hamiltonian, evaluated as (t, x, p, v). For a Hamiltonian composed with a control law, the gradient is the total derivative (differentiated through the law). The tuple is non-negated.

Fields

h::H: the Hamiltonian to differentiate.
backend::B: the AD backend.

`HamiltonianSystem` [Struct]

CTFlows.Systems.HamiltonianSystem Type

julia

struct HamiltonianSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, H<:CTBase.Data.AbstractHamiltonian{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}, BACKEND<:CTBase.Differentiation.AbstractADBackend} <: CTFlows.Systems.AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics}

Concrete AbstractHamiltonianSystem wrapping a scalar Hamiltonian function with an AD backend.

The system does not store pre-computed RHS closures. Instead, closures are built lazily by build_rhs and build_oop_rhs based on the actual initial condition types, ensuring correct handling of scalar, vector (including length-1), and matrix inputs with consistent output shapes.

Type Parameters

TD <: TimeDependence: Autonomous or NonAutonomous.
VD <: VariableDependence: Fixed or NonFixed.
H <: AbstractHamiltonian{TD, VD}: concrete Hamiltonian type. Any CTBase.Data.AbstractHamiltonian is accepted, including a CTBase.Data.ComposedHamiltonian (a pseudo-Hamiltonian composed with a control law), so the AD path differentiates through the control law.
BACKEND <: AbstractADBackend: concrete AD backend type.

Fields

h::H: the underlying scalar Hamiltonian function.
backend::BACKEND: the AD backend for gradient computation.

Example

julia

julia> using CTFlows: Systems

julia> using CTBase: Data

julia> h = Data.Hamiltonian((t, x, p, v) -> 0.5 * sum(x.^2) + sum(p.^2); autonomous=true, variable=false)
Hamiltonian{var"#1", Autonomous, Fixed}

julia> sys = Systems.HamiltonianSystem(h, AutoForwardDiff())
HamiltonianSystem
  time_dependence: Autonomous
  variable_dependence: Fixed
  hamiltonian: Hamiltonian{var"#1", Autonomous, Fixed}
  backend: AutoForwardDiff()

See also: CTBase.Data.Hamiltonian, CTFlows.Systems.AbstractHamiltonianSystem, CTBase.Traits.AbstractADTrait, build_rhs, build_oop_rhs.

`HamiltonianVariableGradient` [Struct]

CTFlows.Systems.HamiltonianVariableGradient Type

julia

struct HamiltonianVariableGradient{H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}

Functor returning the variable gradient ∂H/∂v of a true Hamiltonian, evaluated as (t, x, p, v) — the quantity (before negation) that drives the augmented variable-costate equation ṗv = -∂H/∂v. Non-negated.

Fields

h::H: the Hamiltonian to differentiate.
backend::B: the AD backend.

`HamiltonianVectorFieldSystem` [Struct]

CTFlows.Systems.HamiltonianVectorFieldSystem Type

julia

struct HamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, MD<:CTBase.Traits.AbstractMutabilityTrait} <: CTFlows.Systems.AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics}

Concrete AbstractHamiltonianSystem wrapping a HamiltonianVectorField.

Type Parameters

F: concrete type of the wrapped HamiltonianVectorField function.
TD <: TimeDependence: Autonomous or NonAutonomous.
VD <: VariableDependence: Fixed or NonFixed.
MD <: AbstractMutabilityTrait: InPlace or OutOfPlace.

Fields

hvf::HamiltonianVectorField{F, TD, VD, MD}: the underlying Hamiltonian vector field.

Example

julia

julia> using CTFlows: Systems

julia> hvf = Data.HamiltonianVectorField((x, p) -> (x, -p))
HamiltonianVectorField: autonomous, fixed (no variable), out-of-place
  natural call: f(x, p)
  uniform call: f(t, x, p, v)

julia> sys = Systems.HamiltonianVectorFieldSystem(hvf)
HamiltonianVectorFieldSystem
├─ time_dependence: Autonomous
├─ variable_dependence: Fixed
└─ HamiltonianVectorField: autonomous, fixed (no variable), out-of-place
   natural call: f(x, p)
   uniform call: f(t, x, p, v)

See also: CTBase.Data.HamiltonianVectorField, CTFlows.Systems.AbstractHamiltonianSystem, TimeDependence, CTBase.Traits.VariableDependence, build_rhs, build_oop_rhs.

`ODEParameters` [Struct]

CTFlows.Systems.ODEParameters Type

julia

struct ODEParameters{V}

Wrapper type for parameters passed through SciML's p slot.

This type formalizes the contract for what transits in the ODE problem's parameter slot. For CTFlows, the primary content is the variable parameter for NonFixed systems (or nothing for Fixed systems).

The wrapper makes the contract explicit and extensible — additional fields can be added later (callbacks, extra data) without breaking existing code.

Fields

variable::V: The variable parameter (or nothing for Fixed systems).

Constructor Validation

V can be Nothing (for Fixed systems) or any concrete type (for NonFixed).
No validation is performed at construction — the system's VariableDependence determines whether variable should be used.

Example

julia

using CTFlows: Systems

# Fixed system: variable is nothing
params_fixed = Systems.ODEParameters(nothing)

# NonFixed system: variable is a value
params_nonfixed = Systems.ODEParameters(0.5)

# NonFixed system: variable is a vector
params_vector = Systems.ODEParameters([1.0, 2.0])

Notes

This type is used exclusively by the SciML extension to wrap the variable before passing it to ODEProblem.
The RHS functor reads variable(p) to access the actual variable value.

`PseudoHamIpAugRHS` [Struct]

CTFlows.Systems.PseudoHamIpAugRHS Type

julia

struct PseudoHamIpAugRHS{PH<:CTBase.Data.PseudoHamiltonian, L<:CTBase.Data.ControlLaw, B<:CTBase.Differentiation.AbstractADBackend, CX<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}, CP<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}} <: CTFlows.Systems.AbstractIPPseudoHamRHS

In-place augmented RHS functor for a PseudoHamiltonianSystem with variable costate. Extends CTFlows.Systems.PseudoHamIpRHS with ṗv = -∂H̃/∂v (control fixed), computed by CTBase.Differentiation.pseudo_variable_gradient. The augmented state is [x; p; pv].

Fields

h̃::PH: the pseudo-Hamiltonian H̃(t, x, p, u, v).
law::L: the dynamic closed-loop control law u(t, x, p, v).
backend::B: the AD backend.
n_x::Int: state dimension.
n_v::Int: variable dimension.
cx::CX: state coercion.
cp::CP: costate coercion.

`PseudoHamIpRHS` [Struct]

CTFlows.Systems.PseudoHamIpRHS Type

julia

struct PseudoHamIpRHS{PH<:CTBase.Data.PseudoHamiltonian, L<:CTBase.Data.ControlLaw, B<:CTBase.Differentiation.AbstractADBackend, CX<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}, CP<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}} <: CTFlows.Systems.AbstractIPPseudoHamRHS

In-place RHS functor for a PseudoHamiltonianSystem. Evaluates the feedback control u = law(t, x, p, v) and then computes, at that fixed u,

julia

ẋ =  ∂H̃/∂p
ṗ = -∂H̃/∂x

Fields

h̃::PH: the pseudo-Hamiltonian H̃(t, x, p, u, v).
law::L: the dynamic closed-loop control law u(t, x, p, v).
backend::B: the AD backend.
N::Int: state dimension.
cx::CX: state coercion.
cp::CP: costate coercion.

`PseudoHamOoPRHS` [Struct]

CTFlows.Systems.PseudoHamOoPRHS Type

julia

struct PseudoHamOoPRHS{PH<:CTBase.Data.PseudoHamiltonian, L<:CTBase.Data.ControlLaw, B<:CTBase.Differentiation.AbstractADBackend, CX<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}, CP<:Union{typeof(identity), typeof(CTFlows.Systems._safe_only)}} <: CTFlows.Systems.AbstractOoPPseudoHamRHS

Out-of-place RHS functor for a PseudoHamiltonianSystem; see CTFlows.Systems.PseudoHamIpRHS for the computation. Returns vcat(∂p, -∂x).

Fields

h̃::PH: the pseudo-Hamiltonian H̃(t, x, p, u, v).
law::L: the dynamic closed-loop control law u(t, x, p, v).
backend::B: the AD backend.
N::Int: state dimension.
cx::CX: state coercion.
cp::CP: costate coercion.

`PseudoHamiltonianGradient` [Struct]

CTFlows.Systems.PseudoHamiltonianGradient Type

julia

struct PseudoHamiltonianGradient{H<:CTBase.Data.AbstractPseudoHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}

Functor returning the gradient (∂H̃/∂x, ∂H̃/∂p) of a pseudo-Hamiltonian, evaluated as (t, x, p, u, v) at fixed control u. Non-negated.

Fields

h̃::H: the pseudo-Hamiltonian to differentiate.
backend::B: the AD backend.

`PseudoHamiltonianSystem` [Struct]

CTFlows.Systems.PseudoHamiltonianSystem Type

julia

struct PseudoHamiltonianSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, PH<:(CTBase.Data.PseudoHamiltonian{<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}), L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback}), BACKEND<:CTBase.Differentiation.AbstractADBackend} <: CTFlows.Systems.AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics}

Concrete AbstractHamiltonianSystem built from a pseudo-Hamiltonian H̃(t,x,p,u,v) and a dynamic closed-loop control law u(t,x,p,v). It integrates the Hamiltonian system

julia

ẋ =  ∂H̃/∂p ,   ṗ = -∂H̃/∂x

with the control held fixed at the feedback value u = u(t,x,p,v) during differentiation (the :partial mode). This coincides with the true Hamiltonian flow of CTBase.Data.ComposedHamiltonian only where the feedback is stationary (∂H̃/∂u = 0).

Type Parameters

TD <: TimeDependence, VD <: VariableDependence: traits of the pseudo-Hamiltonian.
PH <: PseudoHamiltonian: concrete pseudo-Hamiltonian type.
L <: ControlLaw: concrete control-law type (DynClosedLoopFeedback).
BACKEND <: AbstractADBackend: concrete AD backend type.

Fields

h̃::PH: the pseudo-Hamiltonian.
law::L: the dynamic closed-loop control law.
backend::BACKEND: the AD backend.

`PseudoHamiltonianVariableGradient` [Struct]

CTFlows.Systems.PseudoHamiltonianVariableGradient Type

julia

struct PseudoHamiltonianVariableGradient{H<:CTBase.Data.AbstractPseudoHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}

Functor returning the variable gradient ∂H̃/∂v of a pseudo-Hamiltonian, evaluated as (t, x, p, u, v) at fixed control u. Non-negated.

Fields

h̃::H: the pseudo-Hamiltonian to differentiate.
backend::B: the AD backend.

`PseudoHamiltonianVectorFieldSystem` [Struct]

CTFlows.Systems.PseudoHamiltonianVectorFieldSystem Type

julia

struct PseudoHamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, MD<:CTBase.Traits.AbstractMutabilityTrait, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})} <: CTFlows.Systems.AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics}

Concrete AbstractHamiltonianSystem built from a pseudo-Hamiltonian vector field h̃vf(t,x,p,u,v) = (ẋ,ṗ) (already differentiated by the user, no AD) and a dynamic closed-loop control law u(t,x,p,v). It integrates

julia

ẋ, ṗ = h̃vf(t, x, p, u, v)   with   u = law(t, x, p, v)

by evaluating the feedback law once per step and passing the resulting u directly to h̃vf — the vector-field analogue of CTFlows.Systems.PseudoHamiltonianSystem, which instead differentiates a scalar pseudo-Hamiltonian H̃ by AD at fixed u. Here there is no AD anywhere: h̃vf already returns the derivatives directly.

Type Parameters

F: concrete type of the wrapped pseudo-Hamiltonian vector field function.
TD <: TimeDependence, VD <: VariableDependence, MD <: AbstractMutabilityTrait: traits of the pseudo-Hamiltonian vector field.
L <: ControlLaw: concrete control-law type (DynClosedLoopFeedback).

Fields

h̃vf::PseudoHamiltonianVectorField{F,TD,VD,MD}: the pseudo-Hamiltonian vector field.
law::L: the dynamic closed-loop control law.

`VectorFieldSystem` [Struct]

CTFlows.Systems.VectorFieldSystem Type

julia

struct VectorFieldSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, MD<:CTBase.Traits.AbstractMutabilityTrait, F<:CTBase.Data.AbstractVectorField{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, MD<:CTBase.Traits.AbstractMutabilityTrait}} <: CTFlows.Systems.AbstractSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.StateDynamics}

Concrete AbstractSystem wrapping an CTBase.Data.AbstractVectorField. The variable for NonFixed vector fields is not stored here; it is passed at flow-call time via the variable kwarg and threaded through ODEProblem's p slot wrapped in a Systems.ODEParameters struct.

The system does not store pre-computed RHS closures. Instead, closures are built lazily by get_ip_rhs/get_oop_rhs based on the actual initial condition type, coercing a 1-D state to a scalar before calling the user's vector field (issue control-toolbox/CTFlows.jl#357) — mirroring CTFlows.Systems.HamiltonianVectorFieldSystem.

Fields

vf::F: the underlying vector field (any Data.AbstractVectorField{TD,VD,MD}).

Example

julia

julia> using CTFlows: Systems

julia> vf = Data.VectorField(x -> -x)
VectorField: autonomous, fixed (no variable), out-of-place
  natural call: f(x)
  uniform call: f(t, x, v)

julia> sys = Systems.VectorFieldSystem(vf)
VectorFieldSystem
├─ time_dependence: Autonomous
├─ variable_dependence: Fixed
└─ VectorField: autonomous, fixed (no variable), out-of-place
   natural call: f(x)
   uniform call: f(t, x, v)

`__hvf_inplace` [Function]

CTFlows.Systems.__hvf_inplace Function

julia

__hvf_inplace() -> Bool

Default value for in-place flag in hamiltonian_vector_field getter.

Returns false by default, meaning the getter returns out-of-place vector fields unless specified otherwise.

`backend` [Function]

CTFlows.Systems.backend Function

julia

backend(
    sys::CTFlows.Systems.HamiltonianSystem
) -> CTBase.Differentiation.AbstractADBackend

Return the automatic differentiation backend from a HamiltonianSystem.

Arguments

sys::HamiltonianSystem: The Hamiltonian system.

Returns

Differentiation.AbstractADBackend: The AD backend used for gradient computation.

julia

backend(
    sys::CTFlows.Systems.PseudoHamiltonianSystem
) -> CTBase.Differentiation.AbstractADBackend

Return the AD backend of a PseudoHamiltonianSystem.

julia

backend(
    sys::CTFlows.Systems.ConstrainedPseudoHamiltonianSystem
) -> CTBase.Differentiation.AbstractADBackend

Return the AD backend of a ConstrainedPseudoHamiltonianSystem.

`build_system` [Function]

CTFlows.Systems.build_system Function

julia

build_system(
    vf::CTBase.Data.AbstractVectorField
) -> CTFlows.Systems.HamiltonianVectorFieldSystem

Build a VectorFieldSystem from a VectorField.

Constructs a concrete system that wraps the vector field and pre-computes its right-hand side function for integration. The resulting system is ready for use with flow integration pipelines.

Arguments

vf::Data.AbstractVectorField: The vector field to wrap into a system.

Returns

VectorFieldSystem: A concrete system wrapping the vector field with a pre-computed RHS function.

Example

julia

julia> using CTFlows: Systems

julia> vf = VectorField(x -> -x; autonomous=true, variable=false)
VectorField
  time_dependence: Autonomous
  variable_dependence: Fixed
  function: var"#1"

julia> sys = Systems.build_system(vf)
VectorFieldSystem
  time_dependence: Autonomous
  variable_dependence: Fixed
  vector_field: VectorField{var"#1", Autonomous, Fixed}

julia

build_system(
    hvf::CTBase.Data.AbstractHamiltonianVectorField
) -> CTFlows.Systems.HamiltonianVectorFieldSystem

Build a HamiltonianVectorFieldSystem from a HamiltonianVectorField.

Constructs a concrete Hamiltonian system that wraps the Hamiltonian vector field. RHS closures are built lazily based on actual initial condition types during flow integration.

Arguments

hvf::Data.AbstractHamiltonianVectorField: The Hamiltonian vector field to wrap into a system.

Returns

HamiltonianVectorFieldSystem: A concrete Hamiltonian system.

Example

julia

julia> using CTFlows: Systems

julia> hvf = HamiltonianVectorField((x, p) -> (x, -p); autonomous=true, variable=false)
HamiltonianVectorField
  time_dependence: Autonomous
  variable_dependence: Fixed
  function: var"#1"

julia> sys = Systems.build_system(hvf)
HamiltonianVectorFieldSystem
  time_dependence: Autonomous
  variable_dependence: Fixed
  hamiltonian_vector_field: HamiltonianVectorField{var"#1", Autonomous, Fixed}

julia

build_system(
    h::CTBase.Data.AbstractHamiltonian,
    backend::CTBase.Differentiation.AbstractADBackend
) -> CTFlows.Systems.HamiltonianSystem

Build a CTFlows.Systems.HamiltonianSystem from a scalar Hamiltonian function with automatic differentiation.

Constructs a concrete Hamiltonian system that wraps the scalar Hamiltonian function with an AD backend. RHS closures are built lazily based on actual initial condition types during flow integration.

Arguments

h::Data.AbstractHamiltonian: The scalar Hamiltonian function to wrap into a system.
backend::Differentiation.AbstractADBackend: The automatic differentiation backend (e.g., AutoForwardDiff, AutoZygote).

Returns

HamiltonianSystem: A concrete Hamiltonian system with automatic differentiation support.

Example

julia

julia> using CTFlows: Systems

julia> using CTBase: Data

julia> h = Data.Hamiltonian((t, x, p, v) -> 0.5 * sum(x.^2) + sum(p.^2); autonomous=true, variable=false)
Hamiltonian{var"#1", Autonomous, Fixed}

julia> sys = Systems.build_system(h, AutoForwardDiff())
HamiltonianSystem
  time_dependence: Autonomous
  variable_dependence: Fixed
  hamiltonian: Hamiltonian{var"#1", Autonomous, Fixed}
  backend: AutoForwardDiff()

Notes

The AD backend is used to compute Hamiltonian gradients ∂H/∂x and ∂H/∂p automatically during integration.
This overload is for scalar Hamiltonian functions where gradients are computed via AD. For explicit vector fields, use CTFlows.Systems.HamiltonianVectorFieldSystem instead.

julia

build_system(
    h̃::CTBase.Data.PseudoHamiltonian,
    law::CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback},
    backend::CTBase.Differentiation.AbstractADBackend
) -> CTFlows.Systems.PseudoHamiltonianSystem

Build a CTFlows.Systems.PseudoHamiltonianSystem from a pseudo-Hamiltonian H̃(t,x,p,u,v), a dynamic closed-loop control law u(t,x,p,v), and an AD backend.

The resulting system integrates ẋ = ∂H̃/∂p, ṗ = -∂H̃/∂x with the control held fixed at the feedback value u = u(t,x,p,v) during differentiation (the :partial mode).

Arguments

h̃::Data.PseudoHamiltonian: the pseudo-Hamiltonian.
law::Data.ControlLaw: the control law; must carry DynClosedLoopFeedback.
backend::Differentiation.AbstractADBackend: the AD backend.

julia

build_system(
    h̃vf::CTBase.Data.AbstractPseudoHamiltonianVectorField,
    law::CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback}
) -> CTFlows.Systems.PseudoHamiltonianVectorFieldSystem

Build a CTFlows.Systems.PseudoHamiltonianVectorFieldSystem from a pseudo-Hamiltonian vector field h̃vf(t,x,p,u,v) = (ẋ,ṗ) (already differentiated by the user, no AD) and a dynamic closed-loop control law u(t,x,p,v).

Unlike CTFlows.Systems.build_system(h̃::CTBase.Data.PseudoHamiltonian, law::CTBase.Data.ControlLaw, backend::CTBase.Differentiation.AbstractADBackend), no AD backend is needed: h̃vf already returns the derivatives directly, and the feedback law is evaluated once per step to produce the control passed to h̃vf.

Arguments

h̃vf::Data.AbstractPseudoHamiltonianVectorField: the pseudo-Hamiltonian vector field.
law::Data.ControlLaw: the control law; must carry DynClosedLoopFeedback.

julia

build_system(
    h̃::CTBase.Data.PseudoHamiltonian,
    law::CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback},
    g,
    μ,
    backend::CTBase.Differentiation.AbstractADBackend
) -> CTFlows.Systems.ConstrainedPseudoHamiltonianSystem

Build a CTFlows.Systems.ConstrainedPseudoHamiltonianSystem from a pseudo-Hamiltonian H̃(t,x,p,u,v), a dynamic closed-loop control law u(t,x,p,v), a path constraint g(t,x,u,v), a multiplier μ(t,x,p,v), and an AD backend.

The resulting system integrates the constrained Hamiltonian H̃ + μ·g in the :partial mode: both the control u = u(t,x,p,v) and the multiplier value μ = μ(t,x,p,v) are held fixed during differentiation (g is differentiated, μ is not).

Arguments

h̃::Data.PseudoHamiltonian: the base pseudo-Hamiltonian.
law::Data.ControlLaw: the control law; must carry DynClosedLoopFeedback.
g: the path constraint (uniform call g(t,x,u,v)), e.g. a CTBase.Data.PathConstraint.
μ: the multiplier (uniform call μ(t,x,p,v)), e.g. a CTBase.Data.Multiplier.
backend::Differentiation.AbstractADBackend: the AD backend.

`control_law` [Function]

CTFlows.Systems.control_law Function

julia

control_law(
    sys::CTFlows.Systems.PseudoHamiltonianSystem
) -> CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback}

Return the control law u(t,x,p,v) of a PseudoHamiltonianSystem.

julia

control_law(
    sys::CTFlows.Systems.ConstrainedPseudoHamiltonianSystem
) -> CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback}

Return the control law u(t,x,p,v) of a ConstrainedPseudoHamiltonianSystem.

julia

control_law(
    sys::CTFlows.Systems.HamiltonianSystem
) -> CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback}

Return the control law u(t, x, p, v) of a HamiltonianSystem built in the :total mode (wrapping a CTBase.Data.ComposedHamiltonian).

Throws

CTBase.Exceptions.IncorrectArgument: if the system wraps a plain Hamiltonian with no associated control law.

julia

control_law(f::CTFlows.Flows.AbstractHamiltonianFlow) -> Any

Return the control law u(t, x, p, v) carried by a Hamiltonian flow built from a control law. Delegates to CTFlows.Systems.control_law.

Throws

CTBase.Exceptions.IncorrectArgument: for a flow that carries no control law.

`get_hamiltonian_gradient` [Function]

CTFlows.Systems.get_hamiltonian_gradient Function

julia

get_hamiltonian_gradient(
    sys::Union{CTFlows.Systems.HamiltonianSystem, CTFlows.Systems.PseudoHamiltonianSystem};
    ad_backend
) -> CTFlows.Systems.HamiltonianGradient

Return a CTFlows.Systems.HamiltonianGradient functor (t, x, p, v) -> (∂H/∂x, ∂H/∂p) for the true Hamiltonian of an AD-backed Hamiltonian system. For a PseudoHamiltonianSystem (or a :total HamiltonianSystem), the gradient is the total derivative — it differentiates through the control law.

The ad_backend keyword selects the AD backend used to differentiate; it defaults to the system's own backend but can be overridden (e.g. to use reverse mode for the gradient).

julia

get_hamiltonian_gradient(
    f::CTFlows.Flows.AbstractHamiltonianFlow;
    kwargs...
) -> CTFlows.Systems.HamiltonianGradient

Return a callable (t, x, p, v) -> (∂H/∂x, ∂H/∂p) for the true Hamiltonian of a Hamiltonian flow. Delegates to CTFlows.Systems.get_hamiltonian_gradient; the ad_backend keyword (default: the system's backend) selects the AD backend.

`get_ip_rhs` [Function]

CTFlows.Systems.get_ip_rhs Function

julia

get_ip_rhs(
    system::CTFlows.Systems.AbstractSystem,
    config
) -> CTFlows.Systems.ConstrainedPseudoHamIpRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the in-place right-hand side function for a system given a configuration.

The returned function must have the signature (du, u, p, t) -> nothing and fill du in place with the derivative at state u, parameters p, and time t.

Eager systems (e.g., VectorFieldSystem) ignore the config and return pre-computed closures. Lazy systems (e.g., HamiltonianSystem) read x0/p0 from the config to build type-specific closures.

Arguments

system::AbstractSystem: The system.
config: The configuration containing initial conditions and time span.

Returns

Function: The in-place RHS closure with signature (du, u, p, t) -> nothing.

Throws

CTBase.Exceptions.NotImplemented: If not implemented by the concrete type.

julia

get_ip_rhs(
    sys::CTFlows.Systems.VectorFieldSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace, F<:CTBase.Data.AbstractVectorField{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace}},
    config::CTFlows.Configs.AbstractStateConfig
) -> CTFlows.Systems.IPVFOoPRHS{VF} where VF<:(CTBase.Data.AbstractVectorField{TD, VD, CTBase.Traits.OutOfPlace} where {TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence})

Return the in-place right-hand side for an out-of-place VectorFieldSystem.

Lazy implementation: reads x0 from the config to build a type-specific closure, coercing the state to a scalar before calling the user's vector field when the declared dimension is 1 (issue #357) — see CTFlows.Systems._coerce_state.

Arguments

sys::VectorFieldSystem{..., OutOfPlace, ...}: The out-of-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

IPVFOoPRHS: An in-place RHS functor with signature (du, u, p, t) -> nothing.

julia

get_ip_rhs(
    sys::CTFlows.Systems.VectorFieldSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace, F<:CTBase.Data.AbstractVectorField{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace}},
    config::CTFlows.Configs.AbstractStateConfig
) -> CTFlows.Systems.IPVFIpRHS

Return the in-place right-hand side for an in-place VectorFieldSystem.

Lazy implementation: reads x0 from the config to build a type-specific closure.

Arguments

sys::VectorFieldSystem{..., InPlace, ...}: The in-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

IPVFIpRHS: An in-place RHS functor with signature (du, u, p, t) -> nothing.

julia

get_ip_rhs(
    sys::CTFlows.Systems.HamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.IPHVFOoPRHS

Return the in-place right-hand side for a HamiltonianVectorFieldSystem.

Lazy implementation: reads x0/p0 from the config to build type-specific closures.

Arguments

sys::HamiltonianVectorFieldSystem{..., OutOfPlace, ...}: The out-of-place system.
config::Configs.AbstractHamiltonianConfig: The Hamiltonian configuration.

Returns

IPHVFOoPRHS: An in-place RHS functor.

julia

get_ip_rhs(
    sys::CTFlows.Systems.HamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.IPHVFIpRHS

Return the in-place right-hand side for a HamiltonianVectorFieldSystem.

Lazy implementation: reads x0/p0 from the config to build type-specific closures.

Arguments

sys::HamiltonianVectorFieldSystem{..., InPlace, ...}: The in-place system.
config::Configs.AbstractHamiltonianConfig: The Hamiltonian configuration.

Returns

IPHVFIpRHS: An in-place RHS functor.

julia

get_ip_rhs(
    sys::CTFlows.Systems.HamiltonianSystem,
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.HamIpRHS

Return the in-place right-hand side for a HamiltonianSystem.

Lazy implementation: reads x0/p0 from the config to build type-specific closures.

Arguments

sys::HamiltonianSystem: The Hamiltonian system.
config::Configs.AbstractHamiltonianConfig: The Hamiltonian configuration.

Returns

HamIpRHS: An in-place RHS functor with embedded AD cache.

julia

get_ip_rhs(
    sys::CTFlows.Systems.PseudoHamiltonianSystem,
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.PseudoHamIpRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the in-place RHS (CTFlows.Systems.PseudoHamIpRHS) for a PseudoHamiltonianSystem.

julia

get_ip_rhs(
    sys::CTFlows.Systems.PseudoHamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.IPPseudoHVFOoPRHS{F, TD, VD, L} where {F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the in-place RHS (CTFlows.Systems.IPPseudoHVFOoPRHS) for a PseudoHamiltonianVectorFieldSystem wrapping an out-of-place vector field.

julia

get_ip_rhs(
    sys::CTFlows.Systems.PseudoHamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.IPPseudoHVFIpRHS{F, TD, VD, L} where {F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the in-place RHS (CTFlows.Systems.IPPseudoHVFIpRHS) for a PseudoHamiltonianVectorFieldSystem wrapping an in-place vector field.

julia

get_ip_rhs(
    sys::CTFlows.Systems.ConstrainedPseudoHamiltonianSystem,
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.ConstrainedPseudoHamIpRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the in-place RHS (CTFlows.Systems.ConstrainedPseudoHamIpRHS) for a ConstrainedPseudoHamiltonianSystem.

julia

get_ip_rhs(
    sys::CTFlowsSciMLFlows.SciMLFunctionSystem{F<:SciMLBase.AbstractODEFunction{true}},
    config::CTFlows.Configs.AbstractStateConfig
) -> CTFlowsSciMLFlows.IPSciMLIpRHS

Return the in-place right-hand side for an in-place SciMLFunctionSystem.

Lazy implementation: reads x0 from the config to build a type-specific closure.

Arguments

sys::SciMLFunctionSystem{<:SciMLBase.AbstractODEFunction{true}}: The in-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

Systems.AbstractIPRHS: The in-place closure with signature (du, u, λ, t) -> nothing.

julia

get_ip_rhs(
    sys::CTFlowsSciMLFlows.SciMLFunctionSystem{F<:SciMLBase.AbstractODEFunction{false}},
    config::CTFlows.Configs.AbstractStateConfig
) -> CTFlowsSciMLFlows.IPSciMLOoPRHS

Return the in-place right-hand side for an out-of-place SciMLFunctionSystem.

Lazy implementation: reads x0 from the config to build a type-specific closure.

Arguments

sys::SciMLFunctionSystem{<:SciMLBase.AbstractODEFunction{false}}: The out-of-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

Systems.AbstractIPRHS: The in-place closure with signature (du, u, λ, t) -> nothing.

`get_ip_rhs_augmented` [Function]

CTFlows.Systems.get_ip_rhs_augmented Function

julia

get_ip_rhs_augmented(
    system::CTFlows.Systems.AbstractHamiltonianSystem,
    config
) -> CTFlows.Systems.ConstrainedPseudoHamIpAugRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the augmented in-place right-hand side function for a Hamiltonian system.

The returned function computes state, costate, and variable costate derivatives. Only applicable to Hamiltonian systems with variable costate support.

Arguments

system::AbstractHamiltonianSystem: The Hamiltonian system.
config: The augmented Hamiltonian configuration containing x0, p0, and pv0.

Returns

Function: The augmented in-place RHS closure with signature (du, u, p, t) -> nothing.

Throws

CTBase.Exceptions.NotImplemented: If not implemented by the concrete type.

julia

get_ip_rhs_augmented(
    sys::CTFlows.Systems.HamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace},
    config::CTFlows.Configs.AbstractAugmentedHamiltonianConfig
) -> CTFlows.Systems.IPHVFOoPAugRHS

Return the augmented in-place right-hand side for a HamiltonianVectorFieldSystem.

Lazy implementation: reads x0/p0/pv0 from the config to build the augmented closure.

Arguments

sys::HamiltonianVectorFieldSystem{..., OutOfPlace, ...}: The out-of-place system.
config::Configs.AbstractAugmentedHamiltonianConfig: The augmented Hamiltonian configuration.

Returns

IPHVFOoPAugRHS: An augmented in-place RHS functor.

julia

get_ip_rhs_augmented(
    sys::CTFlows.Systems.HamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace},
    config::CTFlows.Configs.AbstractAugmentedHamiltonianConfig
) -> CTFlows.Systems.IPHVFIpAugRHS

Return the augmented in-place right-hand side for a HamiltonianVectorFieldSystem.

Lazy implementation: reads x0/p0/pv0 from the config to build the augmented closure.

Arguments

sys::HamiltonianVectorFieldSystem{..., InPlace, ...}: The in-place system.
config::Configs.AbstractAugmentedHamiltonianConfig: The augmented Hamiltonian configuration.

Returns

IPHVFIpAugRHS: An augmented in-place RHS functor.

julia

get_ip_rhs_augmented(
    sys::CTFlows.Systems.HamiltonianSystem,
    config::CTFlows.Configs.AbstractAugmentedHamiltonianConfig
) -> CTFlows.Systems.HamIpAugRHS

Return the augmented in-place right-hand side for a HamiltonianSystem.

Lazy implementation: reads x0/p0/pv0 from the config to build the augmented closure.

Arguments

sys::HamiltonianSystem: The Hamiltonian system.
config::Configs.AbstractAugmentedHamiltonianConfig: The augmented Hamiltonian configuration.

Returns

HamIpAugRHS: An augmented in-place RHS functor with embedded AD cache.

julia

get_ip_rhs_augmented(
    sys::CTFlows.Systems.PseudoHamiltonianSystem,
    config::CTFlows.Configs.AbstractAugmentedHamiltonianConfig
) -> CTFlows.Systems.PseudoHamIpAugRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the augmented in-place RHS (CTFlows.Systems.PseudoHamIpAugRHS) for a PseudoHamiltonianSystem with variable costate.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_ip_rhs_augmented(
    sys::CTFlows.Systems.PseudoHamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace},
    config::CTFlows.Configs.AbstractAugmentedHamiltonianConfig
) -> CTFlows.Systems.IPPseudoHVFOoPAugRHS{F, TD, VD, L} where {F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the augmented in-place RHS (CTFlows.Systems.IPPseudoHVFOoPAugRHS) for a PseudoHamiltonianVectorFieldSystem wrapping an out-of-place vector field, with variable costate.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_ip_rhs_augmented(
    sys::CTFlows.Systems.PseudoHamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace},
    config::CTFlows.Configs.AbstractAugmentedHamiltonianConfig
) -> CTFlows.Systems.IPPseudoHVFIpAugRHS{F, TD, VD, L} where {F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the augmented in-place RHS (CTFlows.Systems.IPPseudoHVFIpAugRHS) for a PseudoHamiltonianVectorFieldSystem wrapping an in-place vector field, with variable costate.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_ip_rhs_augmented(
    sys::CTFlows.Systems.ConstrainedPseudoHamiltonianSystem,
    config::CTFlows.Configs.AbstractAugmentedHamiltonianConfig
) -> CTFlows.Systems.ConstrainedPseudoHamIpAugRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the augmented in-place RHS (CTFlows.Systems.ConstrainedPseudoHamIpAugRHS) for a ConstrainedPseudoHamiltonianSystem with variable costate.

See also: CTFlows.Systems.get_ip_rhs.

`get_oop_rhs` [Function]

CTFlows.Systems.get_oop_rhs Function

julia

get_oop_rhs(
    system::CTFlows.Systems.AbstractSystem,
    config
) -> CTFlows.Systems.ConstrainedPseudoHamOoPRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the out-of-place right-hand side function for a system given a configuration.

The returned function must have the signature (u, p, t) -> du and return the derivative at state u, parameters p, and time t without modifying u.

Eager systems ignore the config and return pre-computed closures. Lazy systems read x0/p0 from the config to build type-specific closures.

Arguments

system::AbstractSystem: The system.
config: The configuration containing initial conditions and time span.

Returns

Function: The out-of-place RHS closure with signature (u, p, t) -> du.

Throws

CTBase.Exceptions.NotImplemented: If not implemented by the concrete type.

julia

get_oop_rhs(
    sys::CTFlows.Systems.VectorFieldSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace, F<:CTBase.Data.AbstractVectorField{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace}},
    config::CTFlows.Configs.AbstractStateConfig
) -> CTFlows.Systems.OoPVFOoPRHS{VF} where VF<:(CTBase.Data.AbstractVectorField{TD, VD, CTBase.Traits.OutOfPlace} where {TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence})

Return the out-of-place right-hand side for an out-of-place VectorFieldSystem.

Lazy implementation: reads x0 from the config to build a type-specific closure.

Arguments

sys::VectorFieldSystem{..., OutOfPlace, ...}: The out-of-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

OoPVFOoPRHS: An out-of-place RHS functor with signature (u, p, t) -> du.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.VectorFieldSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace, F<:CTBase.Data.AbstractVectorField{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace}},
    config::CTFlows.Configs.AbstractStateConfig
) -> Union{CTFlows.Systems.OoPVFIpFinalizeRHS, CTFlows.Systems.OoPVFIpRHS}

Return the out-of-place right-hand side for an in-place VectorFieldSystem.

Lazy implementation: reads x0 from the config to build a type-specific closure. This method is called when !ismutable(u0), so the finalize path is used whenever x0 is itself immutable (e.g. SVector).

Arguments

sys::VectorFieldSystem{..., InPlace, ...}: The in-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

OoPVFIpRHS or OoPVFIpFinalizeRHS: An out-of-place RHS functor.

Notes

Emits a performance warning when called with immutable initial conditions.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.HamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.OoPHVFOoPRHS

Return the out-of-place right-hand side for a HamiltonianVectorFieldSystem.

Lazy implementation: reads x0/p0 from the config to build type-specific closures.

Arguments

sys::HamiltonianVectorFieldSystem{..., OutOfPlace, ...}: The out-of-place system.
config::Configs.AbstractHamiltonianConfig: The Hamiltonian configuration.

Returns

OoPHVFOoPRHS: An out-of-place RHS functor.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.HamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> Union{CTFlows.Systems.OoPHVFIpFinalizeRHS, CTFlows.Systems.OoPHVFIpRHS}

Return the out-of-place right-hand side for a HamiltonianVectorFieldSystem.

Lazy implementation: reads x0/p0 from the config to build type-specific closures. For immutable initial conditions, returns the finalize closure.

Arguments

sys::HamiltonianVectorFieldSystem{..., InPlace, ...}: The in-place system.
config::Configs.AbstractHamiltonianConfig: The Hamiltonian configuration.

Returns

OoPHVFIpRHS or OoPHVFIpFinalizeRHS: An out-of-place RHS functor.

Notes

Emits a performance warning when called with immutable initial conditions.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.HamiltonianSystem,
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.HamOoPRHS

Return the out-of-place right-hand side for a HamiltonianSystem.

Lazy implementation: reads x0/p0 from the config to build type-specific closures.

Arguments

sys::HamiltonianSystem: The Hamiltonian system.
config::Configs.AbstractHamiltonianConfig: The Hamiltonian configuration.

Returns

HamOoPRHS: An out-of-place RHS functor with embedded AD cache.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.PseudoHamiltonianSystem,
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.PseudoHamOoPRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the out-of-place RHS (CTFlows.Systems.PseudoHamOoPRHS) for a PseudoHamiltonianSystem.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.PseudoHamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.OutOfPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.OoPPseudoHVFOoPRHS{F, TD, VD, L} where {F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the out-of-place RHS (CTFlows.Systems.OoPPseudoHVFOoPRHS) for a PseudoHamiltonianVectorFieldSystem wrapping an out-of-place vector field.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.PseudoHamiltonianVectorFieldSystem{F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.InPlace},
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> Union{CTFlows.Systems.OoPPseudoHVFIpFinalizeRHS{F, TD, VD, L} where {F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}, CTFlows.Systems.OoPPseudoHVFIpRHS{F, TD, VD, L} where {F<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}}

Return the out-of-place RHS for a PseudoHamiltonianVectorFieldSystem wrapping an in-place vector field.

Returns

CTFlows.Systems.OoPPseudoHVFIpFinalizeRHS for immutable initial conditions (e.g. SVector), converting the result back to the input array type.
CTFlows.Systems.OoPPseudoHVFIpRHS otherwise.

Notes

Emits a performance warning when called with immutable initial conditions.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlows.Systems.ConstrainedPseudoHamiltonianSystem,
    config::CTFlows.Configs.AbstractHamiltonianConfig
) -> CTFlows.Systems.ConstrainedPseudoHamOoPRHS{PH, L} where {PH<:CTBase.Data.PseudoHamiltonian, L<:(CTBase.Data.ControlLaw{<:Function, CTBase.Traits.DynClosedLoopFeedback})}

Return the out-of-place RHS (CTFlows.Systems.ConstrainedPseudoHamOoPRHS) for a ConstrainedPseudoHamiltonianSystem.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlowsSciMLFlows.SciMLFunctionSystem{F<:SciMLBase.AbstractODEFunction{false}},
    config::CTFlows.Configs.AbstractStateConfig
) -> CTFlowsSciMLFlows.OoPSciMLOoPRHS

Return the out-of-place right-hand side for an out-of-place SciMLFunctionSystem.

Lazy implementation: reads x0 from the config to build a type-specific closure.

Arguments

sys::SciMLFunctionSystem{<:SciMLBase.AbstractODEFunction{false}}: The out-of-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

Systems.AbstractOoPRHS: The out-of-place closure with signature (u, λ, t) -> du.

See also: CTFlows.Systems.get_ip_rhs.

julia

get_oop_rhs(
    sys::CTFlowsSciMLFlows.SciMLFunctionSystem{F<:SciMLBase.AbstractODEFunction{true}},
    config::CTFlows.Configs.AbstractStateConfig
) -> Union{CTFlowsSciMLFlows.OoPSciMLIpFinalizeRHS, CTFlowsSciMLFlows.OoPSciMLIpRHS}

Return the out-of-place right-hand side for an in-place SciMLFunctionSystem.

Arguments

sys::SciMLFunctionSystem{<:SciMLBase.AbstractODEFunction{true}}: The in-place system.
config::Configs.AbstractStateConfig: The state configuration.

Returns

Systems.AbstractOoPRHS: The out-of-place closure with signature (u, λ, t) -> du.

Notes

Emits a performance warning when called with immutable initial conditions.

See also: CTFlows.Systems.get_ip_rhs.

`get_pseudo_hamiltonian_gradient` [Function]

CTFlows.Systems.get_pseudo_hamiltonian_gradient Function

julia

get_pseudo_hamiltonian_gradient(
    sys::Union{CTFlows.Systems.HamiltonianSystem, CTFlows.Systems.PseudoHamiltonianSystem};
    ad_backend
) -> CTFlows.Systems.PseudoHamiltonianGradient{H} where H<:CTBase.Data.PseudoHamiltonian

Return a CTFlows.Systems.PseudoHamiltonianGradient functor (t, x, p, u, v) -> (∂H̃/∂x, ∂H̃/∂p) for the pseudo-Hamiltonian, differentiated at fixed control u. Available for a PseudoHamiltonianSystem and for a :total HamiltonianSystem wrapping a ComposedHamiltonian.

The ad_backend keyword selects the AD backend (default: the system's own backend).

julia

get_pseudo_hamiltonian_gradient(
    f::CTFlows.Flows.AbstractHamiltonianFlow;
    kwargs...
) -> CTFlows.Systems.PseudoHamiltonianGradient{H} where H<:CTBase.Data.PseudoHamiltonian

Return a callable (t, x, p, u, v) -> (∂H̃/∂x, ∂H̃/∂p) for the pseudo-Hamiltonian of a Hamiltonian flow (differentiated at fixed control), when available. Delegates to CTFlows.Systems.get_pseudo_hamiltonian_gradient; the ad_backend keyword (default: the system's backend) selects the AD backend.

`get_pseudo_variable_gradient` [Function]

CTFlows.Systems.get_pseudo_variable_gradient Function

julia

get_pseudo_variable_gradient(
    sys::Union{CTFlows.Systems.HamiltonianSystem, CTFlows.Systems.PseudoHamiltonianSystem};
    ad_backend
) -> CTFlows.Systems.PseudoHamiltonianVariableGradient{H} where H<:CTBase.Data.PseudoHamiltonian

Return a CTFlows.Systems.PseudoHamiltonianVariableGradient functor (t, x, p, u, v) -> ∂H̃/∂v for the pseudo-Hamiltonian, differentiated at fixed control u.

The ad_backend keyword selects the AD backend (default: the system's own backend).

julia

get_pseudo_variable_gradient(
    f::CTFlows.Flows.AbstractHamiltonianFlow;
    kwargs...
) -> CTFlows.Systems.PseudoHamiltonianVariableGradient{H} where H<:CTBase.Data.PseudoHamiltonian

Return a callable (t, x, p, u, v) -> ∂H̃/∂v for the pseudo-Hamiltonian of a Hamiltonian flow (differentiated at fixed control), when available. Delegates to CTFlows.Systems.get_pseudo_variable_gradient; the ad_backend keyword (default: the system's backend) selects the AD backend.

`get_variable_gradient` [Function]

CTFlows.Systems.get_variable_gradient Function

julia

get_variable_gradient(
    sys::Union{CTFlows.Systems.HamiltonianSystem, CTFlows.Systems.PseudoHamiltonianSystem};
    ad_backend
) -> CTFlows.Systems.HamiltonianVariableGradient

Return a CTFlows.Systems.HamiltonianVariableGradient functor (t, x, p, v) -> ∂H/∂v for the true Hamiltonian of an AD-backed Hamiltonian system — the same quantity (before negation) that drives the augmented variable-costate equation ṗv = -∂H/∂v.

The ad_backend keyword selects the AD backend (default: the system's own backend).

julia

get_variable_gradient(
    f::CTFlows.Flows.AbstractHamiltonianFlow;
    kwargs...
) -> CTFlows.Systems.HamiltonianVariableGradient

Return a callable (t, x, p, v) -> ∂H/∂v for the true Hamiltonian of a Hamiltonian flow — the quantity (before negation) driving ṗv = -∂H/∂v. Delegates to CTFlows.Systems.get_variable_gradient; the ad_backend keyword (default: the system's backend) selects the AD backend.

`hamiltonian` [Function]

CTFlows.Systems.hamiltonian Function

julia

hamiltonian(_::CTFlows.Systems.HamiltonianVectorFieldSystem)

Throw an IncorrectArgument error: a HamiltonianVectorFieldSystem stores the vector field X_H directly and carries no scalar Hamiltonian. Use CTFlows.Systems.hamiltonian_vector_field to retrieve X_H instead.

julia

hamiltonian(
    sys::CTFlows.Systems.HamiltonianSystem
) -> CTBase.Data.AbstractHamiltonian

Return the Hamiltonian function from a HamiltonianSystem.

Arguments

sys::HamiltonianSystem: The Hamiltonian system.

Returns

Data.Hamiltonian: The Hamiltonian function wrapped by the system.

julia

hamiltonian(
    sys::CTFlows.Systems.PseudoHamiltonianSystem
) -> CTBase.Data.ComposedHamiltonian

Return the true Hamiltonian of a PseudoHamiltonianSystem — the CTBase.Data.ComposedHamiltonian H(t,x,p,v) = H̃(t,x,p,u(t,x,p,v),v) obtained by eliminating the control with the feedback law. Built on the fly.

julia

hamiltonian(
    _::CTFlows.Systems.PseudoHamiltonianVectorFieldSystem
)

Throw an IncorrectArgument error: a PseudoHamiltonianVectorFieldSystem stores the pseudo-Hamiltonian vector field X_H̃ directly and carries no scalar Hamiltonian. Use CTFlows.Systems.hamiltonian_vector_field to retrieve X_H̃ instead.

julia

hamiltonian(
    sys::CTFlows.Systems.ConstrainedPseudoHamiltonianSystem
) -> CTBase.Data.ComposedHamiltonian

Return the base (unconstrained) true Hamiltonian of a ConstrainedPseudoHamiltonianSystem — the CTBase.Data.ComposedHamiltonian H(t,x,p,v) = H̃(t,x,p,u(t,x,p,v),v). The integrated dynamics additionally include the μ·g term (with μ frozen during differentiation); the constraint and multiplier are available via CTFlows.Systems.constraint / CTFlows.Systems.multiplier. On a boundary arc, where g ≡ 0, this base Hamiltonian coincides with the constrained one.

julia

hamiltonian(f::CTFlows.Flows.AbstractHamiltonianFlow) -> Any

Return the Hamiltonian H(t, x, p, v) underlying a Hamiltonian flow.

Delegates to the system-level getter CTFlows.Systems.hamiltonian. The returned object is callable as a scalar function of (t, x, p, v) (or the shorter signatures allowed by the flow's time/variable dependence). It is available for flows built from a scalar Hamiltonian — HamiltonianSystem (including the :total mode of an OCP-with-control flow) and PseudoHamiltonianSystem (the :partial mode, where it reconstructs the composed Hamiltonian). Flows built from a raw Hamiltonian vector field carry no scalar Hamiltonian and are not supported.

This is the getter to use when writing a transversality condition on a free time in a shooting method: with v = t0 and/or tf a variable, the augmented flow integrates the naive adjoint ṗv = -∂H/∂v (initialized at 0), and the mitigated transversality conditions read p_{t0}(tf) = -H(t0, x0, p0, v) and p_{tf}(tf) = H(tf, xf, pf, v).

Example

julia

H = CTFlows.Systems.hamiltonian(flow)
xf, pf, pvf = flow(t0, x0, p0, tf; variable = v, variable_costate = true)
s = pvf[idx_tf] - H(tf, xf, pf, v)   # transversality for free final time

`hamiltonian_vector_field` [Function]

CTFlows.Systems.hamiltonian_vector_field Function

julia

hamiltonian_vector_field(
    h::CTBase.Data.AbstractHamiltonian{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence};
    ad_backend,
    inplace
) -> Union{CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFIpFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:(CTBase.Differentiation.DifferentiationInterface{CTBase.Strategies.CPU, CTBase.Strategies.StrategyOptions{NT}} where NT<:NamedTuple)}, CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFOoPFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:(CTBase.Differentiation.DifferentiationInterface{CTBase.Strategies.CPU, CTBase.Strategies.StrategyOptions{NT}} where NT<:NamedTuple)}}

Get the Hamiltonian vector field from a Hamiltonian.

This function computes the Hamiltonian vector field X_H = (∂H/∂p, -∂H/∂x) (also known as the symplectic gradient of H) for a given Hamiltonian using automatic differentiation. It accepts any CTBase.Data.AbstractHamiltonian — a scalar Hamiltonian or a ComposedHamiltonian (as produced by an OCP + control law) — so it also covers pseudo-Hamiltonian flows. The returned vector field wraps a callable CTFlows.Systems.HVFOoPFunctor or CTFlows.Systems.HVFIpFunctor whose call signature matches the Hamiltonian's time and variable dependence traits.

Arguments

h::Data.AbstractHamiltonian{TD, VD}: The Hamiltonian with traits TD (time dependence) and VD (variable dependence).
ad_backend::Differentiation.AbstractADBackend: The AD backend to use (default: __hvf_ad_backend() = Differentiation.DifferentiationInterface(), the CPU default).
inplace::Bool: Whether to return an in-place functor (default: __hvf_inplace() = false).

Returns

Data.HamiltonianVectorField: The Hamiltonian vector field with correct traits matching the input Hamiltonian.

Notes

ad_backend must already be a fully-built strategy (e.g. from Flow's registry-based routing, or constructed directly as Differentiation.DifferentiationInterface{Strategies.GPU}(...)). This function does not build or device-select a backend from a raw ADTypes.AbstractADType.
The functor call signature depends on the Hamiltonian's traits:
- Autonomous/Fixed: (x, p) -> (∂p, -∂x) or (dx, dp, x, p) -> nothing (in-place)
- NonAutonomous/Fixed: (t, x, p) -> (∂p, -∂x) or (dx, dp, t, x, p) -> nothing (in-place)
- Autonomous/NonFixed: (x, p, v; variable_costate=false) -> (∂p, -∂x) or (x, p, v; variable_costate=true) -> (∂p, -∂x, -∂v)
- NonAutonomous/NonFixed: (t, x, p, v; variable_costate=false) -> (∂p, -∂x) or (t, x, p, v; variable_costate=true) -> (∂p, -∂x, -∂v)

julia

hamiltonian_vector_field(
    sys::CTFlows.Systems.HamiltonianVectorFieldSystem;
    inplace
) -> CTBase.Data.HamiltonianVectorField

Get the Hamiltonian vector field from a HamiltonianVectorFieldSystem.

This is a trivial getter that returns the pre-stored Hamiltonian vector field from the system. No computation is performed since the vector field is already constructed.

Arguments

sys::HamiltonianVectorFieldSystem: The system with a pre-stored Hamiltonian vector field.

Returns

Data.HamiltonianVectorField: The stored Hamiltonian vector field (identical to sys.hvf).

Notes

This overload is used when the Hamiltonian vector field is already known and stored, avoiding redundant automatic differentiation.
The returned vector field is identical to sys.hvf (same object reference).

julia

hamiltonian_vector_field(
    sys::CTFlows.Systems.HamiltonianSystem;
    inplace
) -> Union{CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFIpFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}, CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFOoPFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}}

Get the Hamiltonian vector field from a HamiltonianSystem (AD-backed).

This function extracts the Hamiltonian and AD backend from the system and delegates to the Hamiltonian overload to compute the vector field via automatic differentiation.

Arguments

sys::HamiltonianSystem: The system containing a Hamiltonian and AD backend.
inplace::Bool: Whether to return an in-place closure (default: __hvf_inplace() = false).

Returns

Data.HamiltonianVectorField: The Hamiltonian vector field with correct traits matching the system's Hamiltonian.

Notes

This overload uses the AD backend returned by backend(sys) for gradient computation, passed through as-is (no unwrapping/rewrapping), so a device-specific backend (e.g. DifferentiationInterface{Strategies.GPU}) is preserved.
The inplace parameter controls whether the returned closure writes results in-place.
Delegates to CTFlows.Systems.hamiltonian_vector_field.

julia

hamiltonian_vector_field(
    sys::CTFlows.Systems.AbstractHamiltonianSystem;
    inplace,
    kwargs...
) -> CTBase.Data.HamiltonianVectorField

Get the Hamiltonian vector field from any AbstractHamiltonianSystem, dispatching on ad_trait.

WithAD systems: computes the vector field via automatic differentiation using hamiltonian(sys) and backend(sys) (protocol methods the system must implement).
WithoutAD systems: throws NotImplemented — the system must implement hamiltonian_vector_field directly (as HamiltonianVectorFieldSystem does).

Throws

Exceptions.NotImplemented: when the system's AD trait is WithoutAD and no specialized hamiltonian_vector_field overload exists for the system type.

julia

hamiltonian_vector_field(
    f::CTFlows.Flows.AbstractHamiltonianFlow;
    kwargs...
) -> Union{CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFIpFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}, CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFOoPFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}}

Return the (symplectic) Hamiltonian vector field X_H = (∂H/∂p, -∂H/∂x) of a Hamiltonian flow, as a CTBase.Data.HamiltonianVectorField. Delegates to the system-level CTFlows.Systems.hamiltonian_vector_field, so it also covers flows built from a pseudo-Hamiltonian (or an OCP) and a control law (:partial / :total), whose Hamiltonian is a CTBase.Data.ComposedHamiltonian.

julia

hamiltonian_vector_field(
    flow::CTFlows.Flows.Flow{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics, <:CTFlows.Systems.HamiltonianSystem{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, H} where H<:CTBase.Data.AbstractHamiltonian{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}};
    inplace
) -> Union{CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFIpFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}, CTBase.Data.HamiltonianVectorField{CTFlows.Systems.HVFOoPFunctor{H, B}} where {H<:CTBase.Data.AbstractHamiltonian, B<:CTBase.Differentiation.AbstractADBackend}}

Get the Hamiltonian vector field from a HamiltonianFlow with an AD-backed system.

Delegates to the system-level getter. The inplace parameter controls whether the returned closure writes results in-place.

julia

hamiltonian_vector_field(
    flow::CTFlows.Flows.Flow{TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence, CTBase.Traits.HamiltonianDynamics, <:CTFlows.Systems.HamiltonianVectorFieldSystem{<:Function, TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}}
) -> CTBase.Data.HamiltonianVectorField

Get the Hamiltonian vector field from a HamiltonianFlow with an HVF-backed system.

Returns the pre-stored vector field from the HamiltonianVectorFieldSystem without any recomputation.

`pseudo_hamiltonian` [Function]

CTFlows.Systems.pseudo_hamiltonian Function

julia

pseudo_hamiltonian(
    sys::CTFlows.Systems.PseudoHamiltonianSystem
) -> CTBase.Data.PseudoHamiltonian{<:Function, TD, VD} where {TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}

Return the pseudo-Hamiltonian H̃ of a PseudoHamiltonianSystem.

julia

pseudo_hamiltonian(
    sys::CTFlows.Systems.ConstrainedPseudoHamiltonianSystem
) -> CTBase.Data.PseudoHamiltonian{<:Function, TD, VD} where {TD<:CTBase.Traits.TimeDependence, VD<:CTBase.Traits.VariableDependence}

Return the base pseudo-Hamiltonian H̃ of a ConstrainedPseudoHamiltonianSystem (without the μ·g term). The constraint and multiplier are exposed separately by CTFlows.Systems.constraint and CTFlows.Systems.multiplier.

julia

pseudo_hamiltonian(
    sys::CTFlows.Systems.HamiltonianSystem
) -> CTBase.Data.PseudoHamiltonian

Return the pseudo-Hamiltonian H̃ underlying a HamiltonianSystem, when the system wraps a CTBase.Data.ComposedHamiltonian — i.e. it was built in the :total mode of an OCP-with-control (or pseudo-Hamiltonian + control law) flow. The control is not eliminated: H̃(t, x, p, u, v) keeps u as an independent argument.

Throws

CTBase.Exceptions.IncorrectArgument: if the system wraps a plain Hamiltonian with no associated control law (no pseudo-Hamiltonian to recover).

julia

pseudo_hamiltonian(
    f::CTFlows.Flows.AbstractHamiltonianFlow
) -> Any

Return the pseudo-Hamiltonian H̃(t, x, p, u, v) underlying a Hamiltonian flow, when available — i.e. when the flow was built from a pseudo-Hamiltonian (or an OCP) and a control law, in either the :partial or the :total mode. Delegates to CTFlows.Systems.pseudo_hamiltonian.

Throws

CTBase.Exceptions.IncorrectArgument: for a flow that carries no control law.

`variable` [Function]

CTFlows.Systems.variable Function

julia

variable(p::CTFlows.Systems.ODEParameters) -> Any

Accessor for the variable field of ODEParameters.

Returns the variable parameter stored in the ODEParameters wrapper. For Fixed systems, this is nothing. For NonFixed systems, this is the actual variable value (scalar or vector).

Arguments

p::ODEParameters: The ODEParameters instance.

Returns

The variable value (or nothing for Fixed systems).

Example

julia

julia> using CTFlows: Systems

julia> params_fixed = Systems.ODEParameters(nothing)
ODEParameters{Nothing}(nothing)

julia> Systems.variable(params_fixed)
nothing

julia> params_nonfixed = Systems.ODEParameters(0.5)
ODEParameters{Float64}(0.5)

julia> Systems.variable(params_nonfixed)
0.5

`vector_field` [Function]

CTFlows.Systems.vector_field Function

julia

vector_field(
    sys::CTFlows.Systems.VectorFieldSystem
) -> CTBase.Data.AbstractVectorField

Return the underlying vector field of a VectorFieldSystem, as a CTBase.Data.AbstractVectorField — the field X(t, x, v) integrated by the state flow.

julia

vector_field(
    f::CTFlows.Flows.AbstractHamiltonianFlow;
    kwargs...
) -> Any

Return the vector field of a flow: the (symplectic) Hamiltonian vector field X_H for a Hamiltonian flow. Alias of CTFlows.Systems.hamiltonian_vector_field on the Hamiltonian side; see the StateDynamics method for state flows.

julia

vector_field(f::CTFlows.Flows.AbstractStateFlow) -> Any

Return the underlying vector field X(t, x, v) of a state flow, as a CTBase.Data.AbstractVectorField. Delegates to the system-level CTFlows.Systems.vector_field.

Public API ​

From CTFlows.Systems ​

CTFlows.Systems [Module] ​

AbstractHVFRHS [Abstract Type] ​

AbstractHamRHS [Abstract Type] ​

AbstractHamiltonianSystem [Abstract Type] ​

AbstractIPHVFRHS [Abstract Type] ​

AbstractIPHamRHS [Abstract Type] ​

AbstractIPPseudoHVFRHS [Abstract Type] ​

AbstractIPPseudoHamRHS [Abstract Type] ​

AbstractIPRHS [Abstract Type] ​

AbstractOoPHVFRHS [Abstract Type] ​

AbstractOoPHamRHS [Abstract Type] ​

AbstractOoPPseudoHVFRHS [Abstract Type] ​

AbstractOoPPseudoHamRHS [Abstract Type] ​

AbstractOoPRHS [Abstract Type] ​

AbstractPseudoHVFRHS [Abstract Type] ​

AbstractPseudoHamRHS [Abstract Type] ​

AbstractRHS [Abstract Type] ​

AbstractStateSystem [Abstract Type] ​

AbstractSystem [Abstract Type] ​

ConstrainedPseudoHamIpAugRHS [Struct] ​

ConstrainedPseudoHamIpRHS [Struct] ​

ConstrainedPseudoHamOoPRHS [Struct] ​

ConstrainedPseudoHamiltonianSystem [Struct] ​

FrozenConstrainedPseudoHamiltonian [Struct] ​

HamiltonianGradient [Struct] ​

HamiltonianSystem [Struct] ​

HamiltonianVariableGradient [Struct] ​

HamiltonianVectorFieldSystem [Struct] ​

ODEParameters [Struct] ​

PseudoHamIpAugRHS [Struct] ​

PseudoHamIpRHS [Struct] ​

PseudoHamOoPRHS [Struct] ​

PseudoHamiltonianGradient [Struct] ​

PseudoHamiltonianSystem [Struct] ​

PseudoHamiltonianVariableGradient [Struct] ​

PseudoHamiltonianVectorFieldSystem [Struct] ​

VectorFieldSystem [Struct] ​

__hvf_inplace [Function] ​

backend [Function] ​

build_system [Function] ​

control_law [Function] ​

get_hamiltonian_gradient [Function] ​

get_ip_rhs [Function] ​

get_ip_rhs_augmented [Function] ​

get_oop_rhs [Function] ​

get_pseudo_hamiltonian_gradient [Function] ​

get_pseudo_variable_gradient [Function] ​

get_variable_gradient [Function] ​

hamiltonian [Function] ​

hamiltonian_vector_field [Function] ​

pseudo_hamiltonian [Function] ​

variable [Function] ​

vector_field [Function] ​

Public API

From `CTFlows.Systems`

`CTFlows.Systems` [Module]

`AbstractHVFRHS` [Abstract Type]

`AbstractHamRHS` [Abstract Type]

`AbstractHamiltonianSystem` [Abstract Type]

`AbstractIPHVFRHS` [Abstract Type]

`AbstractIPHamRHS` [Abstract Type]

`AbstractIPPseudoHVFRHS` [Abstract Type]

`AbstractIPPseudoHamRHS` [Abstract Type]

`AbstractIPRHS` [Abstract Type]

`AbstractOoPHVFRHS` [Abstract Type]

`AbstractOoPHamRHS` [Abstract Type]

`AbstractOoPPseudoHVFRHS` [Abstract Type]

`AbstractOoPPseudoHamRHS` [Abstract Type]

`AbstractOoPRHS` [Abstract Type]

`AbstractPseudoHVFRHS` [Abstract Type]

`AbstractPseudoHamRHS` [Abstract Type]

`AbstractRHS` [Abstract Type]

`AbstractStateSystem` [Abstract Type]

`AbstractSystem` [Abstract Type]

`ConstrainedPseudoHamIpAugRHS` [Struct]

`ConstrainedPseudoHamIpRHS` [Struct]

`ConstrainedPseudoHamOoPRHS` [Struct]

`ConstrainedPseudoHamiltonianSystem` [Struct]

`FrozenConstrainedPseudoHamiltonian` [Struct]

`HamiltonianGradient` [Struct]

`HamiltonianSystem` [Struct]

`HamiltonianVariableGradient` [Struct]

`HamiltonianVectorFieldSystem` [Struct]

`ODEParameters` [Struct]

`PseudoHamIpAugRHS` [Struct]

`PseudoHamIpRHS` [Struct]

`PseudoHamOoPRHS` [Struct]

`PseudoHamiltonianGradient` [Struct]

`PseudoHamiltonianSystem` [Struct]

`PseudoHamiltonianVariableGradient` [Struct]

`PseudoHamiltonianVectorFieldSystem` [Struct]

`VectorFieldSystem` [Struct]

`__hvf_inplace` [Function]

`backend` [Function]

`build_system` [Function]

`control_law` [Function]

`get_hamiltonian_gradient` [Function]

`get_ip_rhs` [Function]

`get_ip_rhs_augmented` [Function]

`get_oop_rhs` [Function]

`get_pseudo_hamiltonian_gradient` [Function]

`get_pseudo_variable_gradient` [Function]

`get_variable_gradient` [Function]

`hamiltonian` [Function]

`hamiltonian_vector_field` [Function]

`pseudo_hamiltonian` [Function]

`variable` [Function]

`vector_field` [Function]