algebraicjulia / algebraicdynamics.jl Goto Github PK

Building dynamical systems compositionally

Home Page: https://algebraicjulia.github.io/AlgebraicDynamics.jl/

License: MIT License

Julia 0.96% Jupyter Notebook 99.04%

algebraicdynamics.jl's Introduction

AlgebraicDynamics.jl

AlgebraicDynamics is a library for compositional dynamical systems. We build on Catlab.jl to provide a software interfaces for the specification and solution of dynamical systems with compositional and hierarchical structure. The implementation of the composition of dynamical systems follows the mathematics of operads and operad algebras. The documentation describes the process of composing primitive dynamical systems and contains notebooks with illustrative examples.

algebraicdynamics.jl's People

Contributors

Stargazers

Watchers

Forkers

xiaoyan-li bosonbaas slwu89 christovis stjordanis ntfrgl kris-brown lilithhafner danielrmeyer tylerhanks hhhults kodyparsotan

algebraicdynamics.jl's Issues

Passing batch of initial states / batch of inputs.

The underlying OrdinaryDiffEq.jl package supports solving from a batch of initial conditions. It's very likely I am misunderstanding something but in principle it should be possible to support the same even here. Would love to know if there is a particular reason that the dynamics and readout functions have their type signatures restricted to AbstractVector.

Label ports of composite models constructed by CPG

The plotting a machine uses the port labels as labels in a plot. For Machines constructed as a composite with a CPG syntax, the CPG may give the outer port labels (see Catlab Issue #500).

Precompilation warning about overwritten methods

The latest released version of AlgDynamics (v0.2) emits warnings during precompilation:

┌ AlgebraicDynamics [5fd6ff03-a254-427e-8840-ba658f502e32]
│  WARNING: Method definition (::Type{AlgebraicDynamics.DWDDynam.Machine{T, I, AlgebraicDynamics.DWDDynam.ContinuousDirectedSystem{T}}})(Any, Any, Any, Any, Any, Any) where {T, I<:AlgebraicDynamics.DWDDynam.InstantaneousDirectedInterface{T}} in module DWDDynam at /home/epatters/.julia/packages/AlgebraicDynamics/uVDs7/src/dwd_dynam.jl:191 overwritten at /home/epatters/.julia/packages/AlgebraicDynamics/uVDs7/src/dwd_dynam.jl:197.
│    ** incremental compilation may be fatally broken for this module **
│  
│  WARNING: Method definition (::Type{AlgebraicDynamics.DWDDynam.Machine{T, I, AlgebraicDynamics.DWDDynam.DelayDirectedSystem{T}}})(Any, Any, Any, Any, Any, Any) where {T, I<:AlgebraicDynamics.DWDDynam.InstantaneousDirectedInterface{T}} in module DWDDynam at /home/epatters/.julia/packages/AlgebraicDynamics/uVDs7/src/dwd_dynam.jl:245 overwritten at /home/epatters/.julia/packages/AlgebraicDynamics/uVDs7/src/dwd_dynam.jl:251.
│    ** incremental compilation may be fatally broken for this module **
└

There are a lot of constructors for these types, so it's not too surprising that there appears to be some redundant/inconsistent ones.

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Generation of stochastic models

Hi!

Are there any plans to implement the construction of stochastic models (SDEs, jump systems for continuous systems, Markov models for discrete time systems)?

Feedback on example?

Hi @jpfairbanks @slibkind

I'm trying to write an example of my standard SIR model plus some extensions using AlgebraicDynamics.jl. Here's a gist of what I have so far - I would be keen to get input before putting it up, as I don't want to provide a poor implementation. In particular, it would be nice to have the 'method of stages' (where one has a number of artificial stages arranged in serial and/or parallel) presented in a nicer way - possibly as a machine with the wiring done as a loop so as to add an arbitrary number of stages?

convenient macro for directed composition?

Hi, is there a similar macro to @relation that can be used to define the composition pattern for systems of continuous machines? The examples construct them by hand for directed composition. Thanks!

Add support for labelled arrays

Allow user to specify the state as a labelled array. Each machine will contain not just a number of states but the labels for the states as well. Readouts can be specified by label.

Improve vectors on the wires functionality

Currently, the approach to allowing vectors on the wires is to have every wire carry a vector of the same length which is specified in the type parameter. This structuring has some downsides related to type checking and constructors of machines (see for example PR #112).

Specifying vector passing as part of the interface type, instead of as a type parameter for example, makes the hierarchy of interfaces clunky.

Finally, we would like to add support for vectors of different lengths along the wires.

Improved Plotting

Improve plotting functionality to use the readout (resp. portmap) of the machine (resp. resource sharer). If outputs (resp. exposed ports is given as an array use this to label the plot.

specify a vector of history functions for each machine or resource sharer

Currently delayed machines and resource sharers only specify a unique dynamics function for each one, and the history function is defined "externally", applied to the composed state. It would be nice if each box could have its own history function, which would probably need to be dealt with in induced_dynamics for resource sharers and oapply for machines.

Better support for specifying state variables of composite machines

Following this discussion, it is clear that the current system places the onus of proper bookkeeping of the state of a composite machine on the user. A new feature that allows the user to use the wiring diagram to specify a state as a composite would reduce some of this burden.

There is also interest in having "stateful" machines, i.e. those which are equipped with a current state. This may have performance implications.

Ensuring differentiability of composed system

A standard use case would be gradient based parameter calibration. Thanks to DiffEqSensitivity it should be possible differentiate through most ODEProblems as long as the functions are setup correctly.

On the master branch following the same Cyber-Physical example in the gist we run into following error

Click to expand Error!

ERROR: LoadError: MethodError: no method matching readout(::ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, ::AlgebraicDynamics.DWDDynam.var"#56#58"{Int64, Catlab.CategoricalAlgebra.Limits.Colimit{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FreeDiagrams.DiscreteDiagram{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Any, Vector{Catlab.CategoricalAlgebra.FinSets.FinSetInt}}, Catlab.CategoricalAlgebra.FreeDiagrams.Multicospan{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}, Vector{Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}}}}, Matrix{Float64}}, ::Tuple{Int64, Int64, Int64}, ::Float64)
Closest candidates are:
  readout(::AbstractMachine, ::AbstractVector{T} where T, ::Any, ::Any) at /home/jagupt/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:192
  readout(::AbstractMachine, ::Catlab.CategoricalAlgebra.Sets.SetFunction{Dom, Codom} where {S, Dom<:(Catlab.CategoricalAlgebra.FinSets.FinSet{S, T} where T), Codom<:Catlab.CategoricalAlgebra.Sets.SetOb}, ::Any...) at /home/jagupt/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:193
  readout(::DelayMachine{T, I} where {T, I}, ::AbstractVector{T} where T, ::Any, ::Any) at /home/jagupt/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:191
  ...
Stacktrace:
  [1] (::AlgebraicDynamics.DWDDynam.var"#59#60"{Vector{AlgebraicDynamics.DWDDynam.var"#56#58"{Int64, Catlab.CategoricalAlgebra.Limits.Colimit{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FreeDiagrams.DiscreteDiagram{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Any, Vector{Catlab.CategoricalAlgebra.FinSets.FinSetInt}}, Catlab.CategoricalAlgebra.FreeDiagrams.Multicospan{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}, Vector{Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}}}}, Matrix{Float64}}}, Tuple{Tuple{Int64, Int64, Int64}, Float64}})(::Tuple{Int64, ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}})
    @ AlgebraicDynamics.DWDDynam ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:425
  [2] iterate
    @ ./generator.jl:47 [inlined]
  [3] collect
    @ ./array.jl:681 [inlined]
  [4] map
    @ ./abstractarray.jl:2323 [inlined]
  [5] get_readouts
    @ ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:424 [inlined]
  [6] (::AlgebraicDynamics.DWDDynam.var"#v#44"{AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}, WiringDiagram{Any, Any, Any, Any}, Vector{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}}, Catlab.CategoricalAlgebra.Limits.Colimit{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FreeDiagrams.DiscreteDiagram{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Any, Vector{Catlab.CategoricalAlgebra.FinSets.FinSetInt}}, Catlab.CategoricalAlgebra.FreeDiagrams.Multicospan{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}, Vector{Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}}}}, Catlab.CategoricalAlgebra.Limits.Colimit{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FreeDiagrams.DiscreteDiagram{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Any, Vector{Catlab.CategoricalAlgebra.FinSets.FinSetInt}}, Catlab.CategoricalAlgebra.FreeDiagrams.Multicospan{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}, Vector{Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}}}}})(u::Matrix{Float64}, xs::Matrix{Float64}, p::Tuple{Int64, Int64, Int64}, t::Float64)
    @ AlgebraicDynamics.DWDDynam ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:352
  [7] eval_dynamics(f::ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, u::Matrix{Float64}, xs::Matrix{Float64}, p::Tuple{Int64, Int64, Int64}, t::Float64)
    @ AlgebraicDynamics.DWDDynam ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:208
  [8] #24
    @ ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:250 [inlined]
  [9] ODEFunction
    @ ~/.julia/packages/SciMLBase/x3z0g/src/scimlfunctions.jl:334 [inlined]
 [10] initialize!(integrator::OrdinaryDiffEq.ODEIntegrator{CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, false, Matrix{Float64}, Nothing, Float64, Tuple{Int64, Int64, Int64}, Float64, Float64, Float64, Float64, Vector{Matrix{Float64}}, OrdinaryDiffEq.ODECompositeSolution{Float64, 3, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Int64, Int64, Int64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64, SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{Float64}, Tuple{Int64, Int64, Int64}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{Int64, Int64, Int64}}, Matrix{Float64}, LinearAlgebra.LU{Float64, Matrix{Float64}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64, SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{Float64}, Tuple{Int64, Int64, Int64}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{Int64, Int64, Int64}}, Matrix{Float64}, LinearAlgebra.LU{Float64, Matrix{Float64}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.DEOptions{Float64, Float64, Float64, Float64, PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, UnitRange{Int64}, Int64, Tuple{}, Vector{Float64}, Tuple{}}, Matrix{Float64}, Float64, Nothing, OrdinaryDiffEq.DefaultInit}, cache::OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/perform_step/low_order_rk_perform_step.jl:569
 [11] initialize!(integrator::OrdinaryDiffEq.ODEIntegrator{CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, false, Matrix{Float64}, Nothing, Float64, Tuple{Int64, Int64, Int64}, Float64, Float64, Float64, Float64, Vector{Matrix{Float64}}, OrdinaryDiffEq.ODECompositeSolution{Float64, 3, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Int64, Int64, Int64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64, SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{Float64}, Tuple{Int64, Int64, Int64}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{Int64, Int64, Int64}}, Matrix{Float64}, LinearAlgebra.LU{Float64, Matrix{Float64}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64, SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{Float64}, Tuple{Int64, Int64, Int64}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{Int64, Int64, Int64}}, Matrix{Float64}, LinearAlgebra.LU{Float64, Matrix{Float64}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.DEOptions{Float64, Float64, Float64, Float64, PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, UnitRange{Int64}, Int64, Tuple{}, Vector{Float64}, Tuple{}}, Matrix{Float64}, Float64, Nothing, OrdinaryDiffEq.DefaultInit}, cache::OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Tsit5ConstantCache{Float64, Float64}, OrdinaryDiffEq.Rosenbrock23ConstantCache{Float64, SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{Float64}, Tuple{Int64, Int64, Int64}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{Int64, Int64, Int64}}, Matrix{Float64}, LinearAlgebra.LU{Float64, Matrix{Float64}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/perform_step/composite_perform_step.jl:39
 [12] __init(prob::ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Int64, Int64, Int64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, alg::CompositeAlgorithm{Tuple{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{5, false, DefaultLinSolve, Val{:forward}}}, AutoSwitch{Tsit5{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Rosenbrock23{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, timeseries_init::Tuple{}, ts_init::Tuple{}, ks_init::Tuple{}, recompile::Type{Val{true}}; saveat::Vector{Float64}, tstops::Tuple{}, d_discontinuities::Tuple{}, save_idxs::UnitRange{Int64}, save_everystep::Bool, save_on::Bool, save_start::Bool, save_end::Nothing, callback::Nothing, dense::Bool, calck::Bool, dt::Float64, dtmin::Nothing, dtmax::Float64, force_dtmin::Bool, adaptive::Bool, gamma::Rational{Int64}, abstol::Nothing, reltol::Nothing, qmin::Rational{Int64}, qmax::Int64, qsteady_min::Int64, qsteady_max::Int64, beta1::Nothing, beta2::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, maxiters::Int64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), internalopnorm::typeof(LinearAlgebra.opnorm), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, timeseries_errors::Bool, dense_errors::Bool, advance_to_tstop::Bool, stop_at_next_tstop::Bool, initialize_save::Bool, progress::Bool, progress_steps::Int64, progress_name::String, progress_message::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), userdata::Nothing, allow_extrapolation::Bool, initialize_integrator::Bool, alias_u0::Bool, alias_du0::Bool, initializealg::OrdinaryDiffEq.DefaultInit, kwargs::Base.Iterators.Pairs{Symbol, Any, Tuple{Symbol, Symbol}, NamedTuple{(:default_set, :sense), Tuple{Bool, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/solve.jl:456
 [13] #__solve#493
    @ ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/solve.jl:4 [inlined]
 [14] __solve(::ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Int64, Int64, Int64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, ::Nothing; default_set::Bool, kwargs::Base.Iterators.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:saveat, :save_idxs, :sense), Tuple{Vector{Float64}, UnitRange{Int64}, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}})
    @ DifferentialEquations ~/.julia/packages/DifferentialEquations/7WPQg/src/default_solve.jl:8
 [15] #solve_call#42
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:61 [inlined]
 [16] #solve_up#44
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:93 [inlined]
 [17] #solve#43
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:73 [inlined]
 [18] _concrete_solve_adjoint(::ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Int64, Int64, Int64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, ::Nothing, ::ForwardDiffSensitivity{0, nothing}, ::Matrix{Float64}, ::Tuple{Int64, Int64, Int64}; saveat::Vector{Float64}, save_idxs::Nothing, kwargs::Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}})
    @ DiffEqSensitivity ~/.julia/packages/DiffEqSensitivity/uakCr/src/concrete_solve.jl:346
 [19] #_concrete_solve_adjoint#219
    @ ~/.julia/packages/DiffEqSensitivity/uakCr/src/concrete_solve.jl:66 [inlined]
 [20] #_solve_adjoint#61
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:345 [inlined]
 [21] #rrule#59
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:310 [inlined]
 [22] chain_rrule_kw
    @ ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:228 [inlined]
 [23] macro expansion
    @ ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0 [inlined]
 [24] _pullback
    @ ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:9 [inlined]
 [25] _apply
    @ ./boot.jl:804 [inlined]
 [26] adjoint
    @ ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:200 [inlined]
 [27] _pullback
    @ ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:65 [inlined]
 [28] _pullback
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:73 [inlined]
 [29] _pullback(::Zygote.Context, ::DiffEqBase.var"##solve#43", ::Nothing, ::Nothing, ::Nothing, ::Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, ::typeof(solve), ::ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Int64, Int64, Int64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
 [30] _apply(::Function, ::Vararg{Any, N} where N)
    @ Core ./boot.jl:804
 [31] adjoint
    @ ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:200 [inlined]
 [32] _pullback
    @ ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:65 [inlined]
 [33] _pullback
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:68 [inlined]
 [34] _pullback(::Zygote.Context, ::CommonSolve.var"#solve##kw", ::NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, ::typeof(solve), ::ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Int64, Int64, Int64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
 [35] _pullback
    @ /mnt/tools/julia/dev/AlgebraicDynamics/examples/Cyber-Physical_param_calibration.jl:116 [inlined]
 [36] _pullback(ctx::Zygote.Context, f::var"#105#106", args::Tuple{Float64, Float64, Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
 [37] _pullback(f::Function, args::Tuple{Float64, Float64, Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface.jl:34
 [38] pullback(f::Function, args::Tuple{Float64, Float64, Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface.jl:40
 [39] gradient(f::Function, args::Tuple{Float64, Float64, Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface.jl:75
 [40] top-level scope
    @ /mnt/tools/julia/dev/AlgebraicDynamics/examples/Cyber-Physical_param_calibration.jl:113

Same is true in the batched case on fix_Problem branch with this gist, but we see a more useful error:

Click to expand Error!

[ Info: Precompiling AlgebraicDynamics [5fd6ff03-a254-427e-8840-ba658f502e32]
ERROR: LoadError: TypeError: in typeassert, expected Float64, got a value of type ForwardDiff.Dual{Nothing, Float64, 5}
Stacktrace:
  [1] setindex!
    @ ./array.jl:845 [inlined]
  [2] macro expansion
    @ ./multidimensional.jl:903 [inlined]
  [3] macro expansion
    @ ./cartesian.jl:64 [inlined]
  [4] _unsafe_setindex!(::IndexLinear, ::Matrix{Float64}, ::Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ::Int64, ::Base.Slice{Base.OneTo{Int64}})
    @ Base ./multidimensional.jl:898
  [5] _setindex!(::IndexLinear, ::Matrix{Float64}, ::Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ::Int64, ::Base.Slice{Base.OneTo{Int64}})
    @ Base ./multidimensional.jl:887
  [6] setindex!
    @ ./abstractarray.jl:1267 [inlined]
  [7] fill_readins!(readins::Matrix{Float64}, d::WiringDiagram{Any, Any, Any, Any}, Inputs::Catlab.CategoricalAlgebra.Limits.Colimit{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FreeDiagrams.DiscreteDiagram{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Any, Vector{Catlab.CategoricalAlgebra.FinSets.FinSetInt}}, Catlab.CategoricalAlgebra.FreeDiagrams.Multicospan{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}, Vector{Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}}}}, readouts::Vector{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, xs::Matrix{Float64})
    @ AlgebraicDynamics.DWDDynam ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:435
  [8] (::AlgebraicDynamics.DWDDynam.var"#v#44"{AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}, WiringDiagram{Any, Any, Any, Any}, Vector{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}}, Catlab.CategoricalAlgebra.Limits.Colimit{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FreeDiagrams.DiscreteDiagram{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Any, Vector{Catlab.CategoricalAlgebra.FinSets.FinSetInt}}, Catlab.CategoricalAlgebra.FreeDiagrams.Multicospan{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}, Vector{Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}}}}, Catlab.CategoricalAlgebra.Limits.Colimit{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FreeDiagrams.DiscreteDiagram{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Any, Vector{Catlab.CategoricalAlgebra.FinSets.FinSetInt}}, Catlab.CategoricalAlgebra.FreeDiagrams.Multicospan{Catlab.CategoricalAlgebra.FinSets.FinSetInt, Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}, Vector{Catlab.CategoricalAlgebra.FinSets.FinDomFunctionVector{Int64, UnitRange{Int64}, Catlab.CategoricalAlgebra.FinSets.FinSetInt}}}}})(u::Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, xs::Matrix{Float64}, p::Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, t::Float64)
    @ AlgebraicDynamics.DWDDynam ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:355
  [9] eval_dynamics(f::ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, u::Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, xs::Matrix{Float64}, p::Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, t::Float64)
    @ AlgebraicDynamics.DWDDynam ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:208
 [10] #24
    @ ~/.julia/dev/AlgebraicDynamics/src/dwd_dynam.jl:250 [inlined]
 [11] ODEFunction
    @ ~/.julia/packages/SciMLBase/x3z0g/src/scimlfunctions.jl:334 [inlined]
 [12] ode_determine_initdt(u0::Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, t::Float64, tdir::Float64, dtmax::Float64, abstol::ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, reltol::ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), prob::ODEProblem{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{Float64, Float64}, false, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, integrator::OrdinaryDiffEq.ODEIntegrator{CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, false, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Nothing, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Float64, Float64, Float64, Float64, Vector{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.ODECompositeSolution{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, 3, Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}}, ODEProblem{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{Float64, Float64}, false, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, Vector{Float64}, Vector{Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Vern9ConstantCache{OrdinaryDiffEq.Vern9Tableau{Float64, Float64}}, OrdinaryDiffEq.Rosenbrock5ConstantCache{SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.Rodas5Tableau{Float64, Float64}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, LinearAlgebra.LU{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Vern9ConstantCache{OrdinaryDiffEq.Vern9Tableau{Float64, Float64}}, OrdinaryDiffEq.Rosenbrock5ConstantCache{SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.Rodas5Tableau{Float64, Float64}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, LinearAlgebra.LU{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.DEOptions{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Float64, Float64, PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, UnitRange{Int64}, Int64, Tuple{}, Vector{Float64}, Tuple{}}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Nothing, OrdinaryDiffEq.DefaultInit})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/initdt.jl:201
 [13] auto_dt_reset!(integrator::OrdinaryDiffEq.ODEIntegrator{CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, false, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Nothing, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Float64, Float64, Float64, Float64, Vector{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.ODECompositeSolution{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, 3, Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}}, ODEProblem{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{Float64, Float64}, false, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, Vector{Float64}, Vector{Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Vern9ConstantCache{OrdinaryDiffEq.Vern9Tableau{Float64, Float64}}, OrdinaryDiffEq.Rosenbrock5ConstantCache{SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.Rodas5Tableau{Float64, Float64}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, LinearAlgebra.LU{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Vern9ConstantCache{OrdinaryDiffEq.Vern9Tableau{Float64, Float64}}, OrdinaryDiffEq.Rosenbrock5ConstantCache{SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.Rodas5Tableau{Float64, Float64}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, LinearAlgebra.LU{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.DEOptions{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Float64, Float64, PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, UnitRange{Int64}, Int64, Tuple{}, Vector{Float64}, Tuple{}}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Nothing, OrdinaryDiffEq.DefaultInit})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/integrators/integrator_interface.jl:329
 [14] handle_dt!(integrator::OrdinaryDiffEq.ODEIntegrator{CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, false, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Nothing, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Float64, Float64, Float64, Float64, Vector{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.ODECompositeSolution{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, 3, Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}}, ODEProblem{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{Float64, Float64}, false, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.CompositeInterpolationData{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, Vector{Float64}, Vector{Vector{Vector{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Vern9ConstantCache{OrdinaryDiffEq.Vern9Tableau{Float64, Float64}}, OrdinaryDiffEq.Rosenbrock5ConstantCache{SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.Rodas5Tableau{Float64, Float64}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, LinearAlgebra.LU{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}}, DiffEqBase.DEStats}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, OrdinaryDiffEq.CompositeCache{Tuple{OrdinaryDiffEq.Vern9ConstantCache{OrdinaryDiffEq.Vern9Tableau{Float64, Float64}}, OrdinaryDiffEq.Rosenbrock5ConstantCache{SciMLBase.TimeDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, SciMLBase.UDerivativeWrapper{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, OrdinaryDiffEq.Rodas5Tableau{Float64, Float64}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, LinearAlgebra.LU{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}}, DefaultLinSolve}}, OrdinaryDiffEq.AutoSwitchCache{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, OrdinaryDiffEq.DEOptions{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Float64, Float64, PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, UnitRange{Int64}, Int64, Tuple{}, Vector{Float64}, Tuple{}}, Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, Nothing, OrdinaryDiffEq.DefaultInit})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/solve.jl:504
 [15] __init(prob::ODEProblem{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{Float64, Float64}, false, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, alg::CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, AutoSwitch{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}, timeseries_init::Tuple{}, ts_init::Tuple{}, ks_init::Tuple{}, recompile::Type{Val{true}}; saveat::Vector{Float64}, tstops::Tuple{}, d_discontinuities::Tuple{}, save_idxs::UnitRange{Int64}, save_everystep::Bool, save_on::Bool, save_start::Bool, save_end::Nothing, callback::Nothing, dense::Bool, calck::Bool, dt::Float64, dtmin::Nothing, dtmax::Float64, force_dtmin::Bool, adaptive::Bool, gamma::Rational{Int64}, abstol::Nothing, reltol::Nothing, qmin::Rational{Int64}, qmax::Int64, qsteady_min::Int64, qsteady_max::Int64, beta1::Nothing, beta2::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, maxiters::Int64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), internalopnorm::typeof(LinearAlgebra.opnorm), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, timeseries_errors::Bool, dense_errors::Bool, advance_to_tstop::Bool, stop_at_next_tstop::Bool, initialize_save::Bool, progress::Bool, progress_steps::Int64, progress_name::String, progress_message::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), userdata::Nothing, allow_extrapolation::Bool, initialize_integrator::Bool, alias_u0::Bool, alias_du0::Bool, initializealg::OrdinaryDiffEq.DefaultInit, kwargs::Base.Iterators.Pairs{Symbol, Any, Tuple{Symbol, Symbol}, NamedTuple{(:default_set, :sense), Tuple{Bool, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/solve.jl:466
 [16] __solve(::ODEProblem{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{Float64, Float64}, false, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, ::CompositeAlgorithm{Tuple{Vern9, Rodas5{5, false, DefaultLinSolve, Val{:forward}}}, AutoSwitch{Vern9, Rodas5{0, false, DefaultLinSolve, Val{:forward}}, Rational{Int64}, Int64}}; kwargs::Base.Iterators.Pairs{Symbol, Any, NTuple{4, Symbol}, NamedTuple{(:default_set, :saveat, :save_idxs, :sense), Tuple{Bool, Vector{Float64}, UnitRange{Int64}, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/4BjSL/src/solve.jl:4
 [17] __solve(::ODEProblem{Matrix{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, Tuple{Float64, Float64}, false, Tuple{ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}, ForwardDiff.Dual{ForwardDiff.Tag{ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Float64}, Float64, 5}}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, ::Nothing; default_set::Bool, kwargs::Base.Iterators.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:saveat, :save_idxs, :sense), Tuple{Vector{Float64}, UnitRange{Int64}, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}})
    @ DifferentialEquations ~/.julia/packages/DifferentialEquations/7WPQg/src/default_solve.jl:8
 [18] #solve_call#42
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:61 [inlined]
 [19] #solve_up#44
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:93 [inlined]
 [20] #solve#43
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:73 [inlined]
 [21] (::DiffEqSensitivity.var"#252#258"{0, Matrix{Float64}, Vector{Float64}, Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, Nothing, ForwardDiffSensitivity{0, nothing}, Matrix{Float64}, Tuple{Float64, Float64, Float64}, Tuple{}, UnitRange{Int64}})()
    @ DiffEqSensitivity ~/.julia/packages/DiffEqSensitivity/uakCr/src/concrete_solve.jl:521
 [22] unthunk
    @ ~/.julia/packages/ChainRulesCore/7ZiwT/src/tangent_types/thunks.jl:194 [inlined]
 [23] wrap_chainrules_output
    @ ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:104 [inlined]
 [24] map
    @ ./tuple.jl:215 [inlined]
 [25] map (repeats 3 times)
    @ ./tuple.jl:216 [inlined]
 [26] wrap_chainrules_output
    @ ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:105 [inlined]
 [27] ZBack
    @ ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:204 [inlined]
 [28] (::Zygote.var"#kw_zpullback#40"{DiffEqSensitivity.var"#forward_sensitivity_backpass#255"{0, Vector{Float64}, Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, Nothing, ForwardDiffSensitivity{0, nothing}, Matrix{Float64}, Tuple{Float64, Float64, Float64}, Tuple{}, UnitRange{Int64}}})(dy::Matrix{Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/chainrules.jl:230
 [29] (::Zygote.var"#208#209"{Tuple{NTuple{6, Nothing}, Tuple{}}, Zygote.var"#kw_zpullback#40"{DiffEqSensitivity.var"#forward_sensitivity_backpass#255"{0, Vector{Float64}, Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, Nothing, ForwardDiffSensitivity{0, nothing}, Matrix{Float64}, Tuple{Float64, Float64, Float64}, Tuple{}, UnitRange{Int64}}}})(Δ::Matrix{Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:203
 [30] (::Zygote.var"#1733#back#210"{Zygote.var"#208#209"{Tuple{NTuple{6, Nothing}, Tuple{}}, Zygote.var"#kw_zpullback#40"{DiffEqSensitivity.var"#forward_sensitivity_backpass#255"{0, Vector{Float64}, Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, Nothing, ForwardDiffSensitivity{0, nothing}, Matrix{Float64}, Tuple{Float64, Float64, Float64}, Tuple{}, UnitRange{Int64}}}}})(Δ::Matrix{Float64})
    @ Zygote ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67
 [31] Pullback
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:73 [inlined]
 [32] (::Zygote.Pullback{Tuple{DiffEqBase.var"##solve#43", Nothing, Nothing, Nothing, Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, typeof(solve), ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}}, Any})(Δ::Matrix{Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
 [33] #208
    @ ~/.julia/packages/Zygote/AlLTp/src/lib/lib.jl:203 [inlined]
 [34] (::Zygote.var"#1733#back#210"{Zygote.var"#208#209"{Tuple{NTuple{6, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{DiffEqBase.var"##solve#43", Nothing, Nothing, Nothing, Base.Iterators.Pairs{Symbol, InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}, Tuple{Symbol}, NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, typeof(solve), ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}}, Any}}})(Δ::Matrix{Float64})
    @ Zygote ~/.julia/packages/ZygoteRules/AIbCs/src/adjoint.jl:67
 [35] Pullback
    @ ~/.julia/packages/DiffEqBase/YIT73/src/solve.jl:68 [inlined]
 [36] (::Zygote.Pullback{Tuple{CommonSolve.var"#solve##kw", NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, typeof(solve), ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}}, Any})(Δ::Matrix{Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
 [37] Pullback
    @ /mnt/tools/julia/dev/AlgebraicDynamics/examples/Cyber-Physical.jl:112 [inlined]
 [38] (::Zygote.Pullback{Tuple{var"#11#12", Tuple{Float64, Float64, Float64}}, Tuple{Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Matrix{Float64}}}, Zygote.var"#1613#back#155"{typeof(identity)}, Zygote.var"#2163#back#380"{Zygote.var"#378#379"}, Zygote.Pullback{Tuple{Type{ODEProblem}, ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}, Matrix{Float64}, Tuple{Int64, Float64}, Tuple{Float64, Float64, Float64}}, Tuple{Zygote.Pullback{Tuple{AlgebraicDynamics.DWDDynam.var"##ODEProblem#23", Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{ODEProblem}, ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}, Matrix{Float64}, Tuple{Int64, Float64}, Tuple{Float64, Float64, Float64}}, Any}, Zygote.Pullback{Tuple{Type{NamedTuple}}, Tuple{}}, Zygote.var"#2076#back#357"{Zygote.var"#pairs_namedtuple_pullback#356"{(), NamedTuple{(), Tuple{}}}}}}, Zygote.Pullback{Tuple{CommonSolve.var"#solve##kw", NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, typeof(solve), ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}}, Any}, Zygote.Pullback{Tuple{Type{NamedTuple{(:sense,), T} where T<:Tuple}, Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, Tuple{Zygote.var"#1777#back#226"{Zygote.Jnew{NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, Nothing, true}}}}}}, Zygote.ZBack{ChainRules.var"#sum_abs2_pullback#1395"{Array{Float64, 3}}}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Matrix{Float64}}}, Zygote.var"#1613#back#155"{typeof(identity)}, Zygote.Pullback{Tuple{Type{ZygoteVJP}}, Tuple{}}, Zygote.Pullback{Tuple{Core.var"#Type##kw", NamedTuple{(:autojacvec,), Tuple{ZygoteVJP}}, Type{InterpolatingAdjoint}}, Any}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}}}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Tuple{Int64, Float64}}}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Array{Float64, 3}}}, Zygote.Pullback{Tuple{typeof(Base.Broadcast.materialize), Array{Float64, 3}}, Tuple{}}, Zygote.var"#3766#back#1024"{Zygote.var"#1022#1023"{Array{Float64, 3}, Matrix{Float64}}}, Zygote.Pullback{Tuple{Type{NamedTuple{(:autojacvec,), T} where T<:Tuple}, Tuple{ZygoteVJP}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:autojacvec,), Tuple{ZygoteVJP}}}, Tuple{ZygoteVJP}}, Tuple{Zygote.var"#1777#back#226"{Zygote.Jnew{NamedTuple{(:autojacvec,), Tuple{ZygoteVJP}}, Nothing, true}}}}}}}})(Δ::Float64)
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface2.jl:0
 [39] (::Zygote.var"#55#56"{Zygote.Pullback{Tuple{var"#11#12", Tuple{Float64, Float64, Float64}}, Tuple{Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Matrix{Float64}}}, Zygote.var"#1613#back#155"{typeof(identity)}, Zygote.var"#2163#back#380"{Zygote.var"#378#379"}, Zygote.Pullback{Tuple{Type{ODEProblem}, ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}, Matrix{Float64}, Tuple{Int64, Float64}, Tuple{Float64, Float64, Float64}}, Tuple{Zygote.Pullback{Tuple{AlgebraicDynamics.DWDDynam.var"##ODEProblem#23", Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, Type{ODEProblem}, ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}, Matrix{Float64}, Tuple{Int64, Float64}, Tuple{Float64, Float64, Float64}}, Any}, Zygote.Pullback{Tuple{Type{NamedTuple}}, Tuple{}}, Zygote.var"#2076#back#357"{Zygote.var"#pairs_namedtuple_pullback#356"{(), NamedTuple{(), Tuple{}}}}}}, Zygote.Pullback{Tuple{CommonSolve.var"#solve##kw", NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, typeof(solve), ODEProblem{Matrix{Float64}, Tuple{Float64, Float64}, false, Tuple{Float64, Float64, Float64}, ODEFunction{false, AlgebraicDynamics.DWDDynam.var"#24#25"{ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}, Matrix{Float64}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing}, Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}}, Any}, Zygote.Pullback{Tuple{Type{NamedTuple{(:sense,), T} where T<:Tuple}, Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}}, Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, Tuple{Zygote.var"#1777#back#226"{Zygote.Jnew{NamedTuple{(:sense,), Tuple{InterpolatingAdjoint{0, true, Val{:central}, ZygoteVJP, Bool}}}, Nothing, true}}}}}}, Zygote.ZBack{ChainRules.var"#sum_abs2_pullback#1395"{Array{Float64, 3}}}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Matrix{Float64}}}, Zygote.var"#1613#back#155"{typeof(identity)}, Zygote.Pullback{Tuple{Type{ZygoteVJP}}, Tuple{}}, Zygote.Pullback{Tuple{Core.var"#Type##kw", NamedTuple{(:autojacvec,), Tuple{ZygoteVJP}}, Type{InterpolatingAdjoint}}, Any}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, ContinuousMachine{Float64, AlgebraicDynamics.DWDDynam.DirectedInterface{Float64}}}}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Tuple{Int64, Float64}}}, Zygote.var"#1590#back#149"{Zygote.var"#147#148"{Zygote.Context, GlobalRef, Array{Float64, 3}}}, Zygote.Pullback{Tuple{typeof(Base.Broadcast.materialize), Array{Float64, 3}}, Tuple{}}, Zygote.var"#3766#back#1024"{Zygote.var"#1022#1023"{Array{Float64, 3}, Matrix{Float64}}}, Zygote.Pullback{Tuple{Type{NamedTuple{(:autojacvec,), T} where T<:Tuple}, Tuple{ZygoteVJP}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:autojacvec,), Tuple{ZygoteVJP}}}, Tuple{ZygoteVJP}}, Tuple{Zygote.var"#1777#back#226"{Zygote.Jnew{NamedTuple{(:autojacvec,), Tuple{ZygoteVJP}}, Nothing, true}}}}}}}}})(Δ::Float64)
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface.jl:41
 [40] gradient(f::Function, args::Tuple{Float64, Float64, Float64})
    @ Zygote ~/.julia/packages/Zygote/AlLTp/src/compiler/interface.jl:76
 [41] top-level scope
    @ /mnt/tools/julia/dev/AlgebraicDynamics/examples/Cyber-Physical.jl:109

Oapply but for DWDs

@slibkind, now that you've convinced me that machines > resource sharers, what would it take to get an oapply for DWDs? @mehalter and @bosonbaas both have had really great experiences with using the @relation and oapply to specify systems in a cospan algebra (see #15 and AlgebraicPetri).

How does this relate to your Graph -> Machine code? We could create graphs that represent the meshes in the PDE context and then generate machines from them. Since the PDE problems are inherently undirected that might make more sense than using DWDs where all the inputs are also outputs. Then we could continue to use the Open(Graph) to create the big mesh from stencil points < patches < meshes with the @relation and oapply (#15) then call your Machine(::Graph) constructor to get a machine from a graph (#14). It is a silly machine because each subsystem has the inputs = outputs property, but that is just a natural consequence of being an undirected mesh.

Formulating Dynam IVPs as C-Sets

@epatters @slibkind, Is this the right formulation for a C-Set of IVPs?

Notes: Function and Type are julia types that implement the dynamical system and vector spaces.

Add support for Stochastic Differential Equations

Issue with dependency versions

Hello,

I am trying to use this project and am unable to download/compile it correctly. Using Julia 1.7.2 with no other packages installed, running "]add AlgebraicDynamics" does not build. 10 dependencies fail.

The error is:

ERROR: The following 1 direct dependency failed to precompile:

AlgebraicDynamics [5fd6ff03-a254-427e-8840-ba658f502e32]

Failed to precompile AlgebraicDynamics [5fd6ff03-a254-427e-8840-ba658f502e32] to /home/undergrad/.julia/compiled/v1.7/AlgebraicDynamics/jl_blhdXu.
ERROR: LoadError: UndefVarError: DEFAULT_LINSOLVE not defined

which I believe is cascading and causing the other dependencies to fail. This issue is in DifferentialEquations, but only in this project. DifferentialEquations builds correctly on its own.

I believe this is most likely a bug with the required/allowed versions.

Let me know if any other information would be helpful for reproducing this bug.

Performance warning from SciML

628
     Testing Running tests...
[629](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:632)
Test Summary: | Pass  Total   Time
[630](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:633)
UWDDynam      |   55     55  38.5s
[631](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:634)
Test Summary: | Pass  Total   Time
[632](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:635)
DWDDynam      |   54     54  53.1s
[633](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:636)
Test Summary: | Pass  Total   Time
[634](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:637)
CPGDynam      |   71     71  22.2s
[635](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:638)
┌ Warning: Using arrays or dicts to store parameters of different types can hurt performance.
[636](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:639)
│ Consider using tuples instead.
[637](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:640)
└ @ SciMLBase ~/.julia/packages/SciMLBase/s9wrq/src/performance_warnings.jl:32
[638](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:641)
┌ Warning: Using arrays or dicts to store parameters of different types can hurt performance.
[639](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:642)
│ Consider using tuples instead.
[640](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:643)
└ @ SciMLBase ~/.julia/packages/SciMLBase/s9wrq/src/performance_warnings.jl:32
[641](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:644)
┌ Warning: Using arrays or dicts to store parameters of different types can hurt performance.
[642](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:645)
│ Consider using tuples instead.
[643](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:646)
└ @ SciMLBase ~/.julia/packages/SciMLBase/s9wrq/src/performance_warnings.jl:32
[644](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:647)
┌ Warning: Using arrays or dicts to store parameters of different types can hurt performance.
[645](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:648)
│ Consider using tuples instead.
[646](https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/actions/runs/5347756391/jobs/9696703768?pr=123#step:7:649)
└ @ SciMLBase ~/.julia/packages/SciMLBase/s9wrq/src/performance_warnings.jl:32

In the current PR #123 we get some warnings that should be run down. It looks like we are passing parameters as an array instead of a tuple somewhere. This is a good first issue and a potentially breaking change.

portmap documentation

Hi, for creating Resource Sharers, the API docs show there is a final argument called portmap, though this is not provided explictly by the first few examples I saw in Examples. Is it possible to add a note for what it means and when to write it explicitly?

Machines and discrete systems

Matrix models are widely used in ecology, and are much like machines in your parlance. However, in these models, it is common to have an ordering of the various submodels (e.g. first have a birth model, then a migration model, then a death model), rather than have them working simultaneously. Is this something that can be supported in your directed syntax?

First release roadmap

Here are the things left to do before the first release

Improving Instantaneous Machines

Currently dependency is represented by a span representing the relationship between ports. The first foot represents the input ports and the second foot represents the output ports. Consider a different representation (as a sparse matrix or as a list of pairs). If keeping this then verify the size of the feet of the span.
Improve the induced_dependency function
allow for passing wires

signature of readout map

For AbstractMachines change the signature of the readout map to match the signature of the update function, i.e. the readout function is of the form r(u,p,t) and can depend on the parameters and time.

better use of variable names in docs

This is a very small "issue", but in section 3 of Composing Dynamical Systems on the main docs page https://github.com/AlgebraicJulia/AlgebraicDynamics.jl/blob/master/docs/src/index.md the variable p is used to refer to the port map on one line, and is then reused on the following line to refer to the dynamics function's parameters. I'd suggest using something else for one of these two.

Support for models with delays?

I'm curious as to your thoughts on how delays could get represented in the framework- see e.g. https://github.com/epirecipes/sir-julia/blob/master/markdown/dde/dde.md for a simple model with a delay.

Support for stochastic models?

It would be cool if there could be support for models with noise terms; i.e. stochastic differential equations. DifferentialEquations.jl has support for this, so maybe just keep this in mind if you end up adding delay differential equations: maybe do it in a generic enough way to also support SDEs?

Would be neat for all kinds of stuff.

Machines from Graphs

I just worked out the Machines from Graphs example on paper and I'm really excited about it. This is going to be the killer app for "functorial data migration in scientific computing". In this slide
we have talked about how every time a computer scientist uses graphs they are actually doing ACT. The implementation of F: Th(Machines) --> Th(LabeledGraphs) and the pullback data migration functor induces a contravariant functor on their models DF: LabeledGraphs --> Machines is a way to formally discuss how a computer scientist "represents a machine by drawing a labeled graph".

I think we are going to see how CS data structures that are oriented and give rise to processes are C-Sets of categories that have functors into Th(Graph) or Th(BipartiteGraph) and nonoriented mathematical objects are C-Sets of categories that have functors into Th(SymGraph). The pullback migration functors induced by these functors between schemas are going to specify the ways of representing the structure as a graph.

For the case of "a dynamical system represented by a graph, we get the following square, which explains how a dynamical system machine can be derived from "a graph with additional data." The top side of the square shows how the interconnection pattern of the machine is derived from the edge set, and the right side of the square shows how the additional data lives on the graph. The left side shows how the dynamics live over the interconnection pattern and the bottom side shows how to derive the dynamics from the vertex labels.

Docs build failing with error from OrdinaryDiffEq

The docs build, specifically the cyber physical systems example, has started failing with this error:

ERROR: LoadError: LoadError: Detected non-constant types in an out-of-place ODE solve, i.e. for
`du = f(u,p,t)` we see `typeof(du) !== typeof(u/t)`. This is not
supported by OrdinaryDiffEq.jl's solvers. Please either make `f`
type-constant (i.e. typeof(du) === typeof(u/t)) or use the mutating
in-place form `f(du,u,p,t)` (which is type-constant by construction).

Note that one common case for this is when computing with GPUs, using
`Float32` for `u0` and `Float64` for `tspan`. To correct this, ensure
that the element type of `tspan` matches the preferred compute type,
for example `ODEProblem(f,0f0,(0f0,1f0))` for `Float32`-based time.

typeof(u/t) = Vector{Float64}
typeof(du) = LabelledArrays.LArray{Float64, 1, Vector{Float64}, (:sc,)}

in expression starting at /home/runner/work/AlgebraicDynamics.jl/AlgebraicDynamics.jl/docs/src/examples/Cyber-Physical.ipynb:13
when executing the following code block from inputfile `~/work/AlgebraicDynamics.jl/AlgebraicDynamics.jl/examples/Cyber-Physical.jl`

# initial values
xₒ = LVector( e = 0.01,  # [e, d] -> [θ offset, 𝛿 control input]
              d = 0.05);

uₒ = [0.0, 0, 0, 0, 0]
tspan = (0, 20.0)

params = (𝓐l = 100,  # decay constant of sensor
          𝓐c = 100,  # decay constant of controller
          𝓑c = 0)    # ratio of velocity to reference velocity

prob = ODEProblem(𝑢ᵤₐᵥ, uₒ, xₒ, tspan, params)
sol = solve(prob, alg_hints=[:stiff]);

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.