ERROR: TypeError: in new, expected Float64, got a value of type ForwardDiff.Dual{Nothing,Float64,10}

General Usage
,
1

I’m trying to solve a problem similar to the Trebuche problem using the sciml_train diffeqflux, etc. I have a neural network married to a diffeq simulation and the neural network would ultimately condition the parameters to the diffeq simulation based on its inputs for optimal performance based on a loss funciton.

But, to setup the simulation’s u0 and parameters, I do some calculations using some custom composite types. The composite types were defined to define the fields as Float64’s because that is what makes sense for them and changing that could impact many other projects. The solver runs fine by itself.

Zygoteadjoint, chokes on try/catches that are nowhere in my code, and I don’t know how to find them.

So to solve this problem, I’ve tried setting up a Zygote.forwarddiff similar to how the Trebuchet problem does things. model-zoo/DiffRL.jl at master · FluxML/model-zoo · GitHub

Telling Zygote to use forwarddiff by wrapping it in that function call.

This has led me to a clue which may be the source of all of my problems.

My composite type expects the Float64, but gets the Dual so it blows chunks. How do I fix things, so I don’t need to rewrite my composite types… as there may be many many of those and who knows what it will break?
I noticed a previous discord where there was an eltype conversion on the inputs to the sciml but the links to the documentation were broken and I have not been able to find it. Is there a clean and simple way to take care of it.

Error message:

ERROR: TypeError: in new, expected Float64, got a value of type ForwardDiff.Dual{Nothing,Float64,10}

The object that is being created inside the code.

struct xyzVec <:AbstractVec
    x::Float64
    y::Float64
    z::Float64
end

So far I have found no mention of this in the documentation.

Here is my attempt to clean up some of my code to serve as an example.

function runSim_noSave(a, 
    b, 
    c)
    sc = makeCompTypeInputs(;
                a, 
                b, 
                c)
    runSim_noSave(sc)
end

function runSim_noSave(sc::MyType)
    
    u0 = setupInitialConditions(sc)
    p = toParameter(sc)

    # Setup ODE Problem
    _prob = remake(prob_noSave; p, u0, callback = cb_noSave)
    sol = solve(_prob,Tsit5(),reltol=1e-9,sensealg=sensitivity)

    return(;sol,sc)
end

runForwardDiff(ps) = forwarddiff( x-> runSim_noSave(x...), ps)

The error gets generated in the function I called: makeCompTypeInputs

2

The problem you are having with ForwardDiff is described in the third bullet here: Limitations of ForwardDiff · ForwardDiff

It is hard to say exactly what has gone wrong with Zygote without seeing the error it produces (and hopefully some testable code!).

In the code you presented, AbstractVec is suspicious, did you mean AbstractVector? Did you implement the array interface for your new type?

You indicated you need to use Float64 elsewhere in your code, so you might try defining your struct like this so it can be used for both Float64 and Dual values:

struct xyzVec{T<:Real} <: AbstractVector{T} 
    x::T
    y::T
    z::T
end
``
1 Like
3

AbstractVec was just something I had done for that Module I created. That xyzVector module was one of the first things I had done when learning Julia. It turned out to be faster than other available methods like StaticArrays and normal arrays so I stuck with it.

I was hoping to not use ForwardDiff, but trying to find why I’m getting a try/catch error using Zygote is next to impossible unless there is a trick. I don’t understand how to decipher the incredibly long Tuple it creates in the error message.

If you think type generalizing the constructor would work for zygote, I could try that.

4

I switched back to Zygote without the ForwardDiff.

do you think that @warn, or @error loggers might have a try/catch in there?
Is there a list of things to avoid?
Is there a way to decipher a tuple like this?

ERROR: Compiling Tuple{typeof(OrdinaryDiffEq._postamble!),OrdinaryDiffEq.ODEIntegrator{OrdinaryDiffEq.Tsit5,true,Array{Float64,1},Nothing,Float64,Array{Float64,1},Float64,Float64,Float64,Array{Array{Float64,1},1},SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Array{Array{Array{Float64,1},1},1},SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,OrdinaryDiffEq.InterpolationData{SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Array{Array{Float64,1},1},Array{Float64,1},Array{Array{Array{Float64,1},1},1},OrdinaryDiffEq.Tsit5Cache{Array{Float64,1},Array{Float64,1},Array{Float64,1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}}},DiffEqBase.DEStats},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},OrdinaryDiffEq.Tsit5Cache{Array{Float64,1},Array{Float64,1},Array{Float64,1},OrdinaryDiffEq.Tsit5ConstantCache{Float64,Float64}},OrdinaryDiffEq.DEOptions{Float64,Float64,Float64,Float64,typeof(DiffEqBase.ODE_DEFAULT_NORM),typeof(LinearAlgebra.opnorm),Nothing,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN),typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE),typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK),DataStructures.BinaryHeap{Float64,Base.Order.ForwardOrdering},DataStructures.BinaryHeap{Float64,Base.Order.ForwardOrdering},Nothing,Nothing,Int64,Tuple{},Tuple{},Tuple{}},Array{Float64,1},Float64,Nothing,OrdinaryDiffEq.DefaultInit}}: try/catch is not supported.



Stacktrace:
 [1] error(::String) at .\error.jl:33
 [2] instrument(::IRTools.Inner.IR) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\reverse.jl:121
 [3] #Primal#20 at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\reverse.jl:202 [inlined]
 [4] Zygote.Adjoint(::IRTools.Inner.IR; varargs::Nothing, normalise::Bool) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\reverse.jl:315
 [5] _lookup_grad(::Type{T} where T) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\emit.jl:101
 [6] #s2941#1123 at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:34 [inlined]
 [7] #s2941#1123(::Any, ::Any, ::Any) at .\none:0
 [8] (::Core.GeneratedFunctionStub)(::Any, ::Vararg{Any,N} where N) at .\boot.jl:527
 [9] postamble! at C:\Users\username\.julia\packages\OrdinaryDiffEq\Iu97h\src\integrators\integrator_utils.jl:118 [inlined]
 [10] (::typeof(∂(postamble!)))(::Nothing) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [11] solve! at C:\Users\username\.julia\packages\OrdinaryDiffEq\Iu97h\src\solve.jl:461 [inlined]
 [12] (::typeof(∂(solve!)))(::Nothing) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [13] #__solve#399 at C:\Users\username\.julia\packages\OrdinaryDiffEq\Iu97h\src\solve.jl:5 [inlined]
 [14] (::typeof(∂(#__solve#399)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [15] #151 at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191 [inlined]
 [16] #1694#back at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59 [inlined]
 [17] (::typeof(∂(__solve##kw)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [18] #151 at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191 [inlined]
 [19] (::Zygote.var"#1694#back#153"{Zygote.var"#151#152"{typeof(∂(__solve##kw)),Tuple{Tuple{Nothing,Nothing,Nothing},Tuple{Nothing}}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59  
 [20] #solve_call#56 at C:\Users\username\.julia\packages\DiffEqBase\gtaOc\src\solve.jl:61 [inlined]
 [21] (::typeof(∂(#solve_call#56)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [22] (::Zygote.var"#151#152"{typeof(∂(#solve_call#56)),Tuple{NTuple{4,Nothing},Tuple{Nothing}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191
 [23] (::Zygote.var"#1694#back#153"{Zygote.var"#151#152"{typeof(∂(#solve_call#56)),Tuple{NTuple{4,Nothing},Tuple{Nothing}}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59
 ... (the last 3 lines are repeated 1 more time)
 [27] #solve_up#58 at C:\Users\username\.julia\packages\DiffEqBase\gtaOc\src\solve.jl:82 [inlined]
 [28] (::typeof(∂(#solve_up#58)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [29] (::Zygote.var"#151#152"{typeof(∂(#solve_up#58)),Tuple{NTuple{6,Nothing},Tuple{Nothing}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191
 [30] #1694#back at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59 [inlined]

I sanitized my stacktrace, so if something looks wierd, I may have changed a name incorrectly. And the stack trace is twice as long as allowed by discourse so I’m truncating it.

5 
[31] (::typeof(∂(solve_up##kw)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [32] #151 at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191 [inlined]
 [33] (::Zygote.var"#1694#back#153"{Zygote.var"#151#152"{typeof(∂(solve_up##kw)),Tuple{NTuple{6,Nothing},Tuple{Nothing}}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59
 [34] #solve#57 at C:\Users\username\.julia\packages\DiffEqBase\gtaOc\src\solve.jl:70 [inlined]
 [35] (::typeof(∂(#solve#57)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [36] (::Zygote.var"#151#152"{typeof(∂(#solve#57)),Tuple{NTuple{6,Nothing},Tuple{Nothing}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191
 [37] (::Zygote.var"#1694#back#153"{Zygote.var"#151#152"{typeof(∂(#solve#57)),Tuple{NTuple{6,Nothing},Tuple{Nothing}}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59
 [38] (::typeof(∂(solve##kw)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [39] (::Zygote.var"#151#152"{typeof(∂(solve##kw)),Tuple{NTuple{4,Nothing},Tuple{}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191
 [40] #1694#back at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59 [inlined]
 [41] #167 at C:\Users\username\.julia\packages\DiffEqSensitivity\1jYVp\src\concrete_solve.jl:280 [inlined]
 [42] (::typeof(∂(λ)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [43] #41 at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface.jl:40 [inlined]
 [44] #263#back at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:65 [inlined]
 [45] (::Zygote.var"#151#152"{DiffEqBase.var"#263#back#73"{Zygote.var"#41#42"{typeof(∂(λ))}},Tuple{NTuple{6,Nothing},Tuple{Nothing}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191       
 [46] (::Zygote.var"#1694#back#153"{Zygote.var"#151#152"{DiffEqBase.var"#263#back#73"{Zygote.var"#41#42"{typeof(∂(λ))}},Tuple{NTuple{6,Nothing},Tuple{Nothing}}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59
 [47] #solve#57 at C:\Users\username\.julia\packages\DiffEqBase\gtaOc\src\solve.jl:70 [inlined]
 [48] (::typeof(∂(#solve#57)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [49] (::Zygote.var"#151#152"{typeof(∂(#solve#57)),Tuple{NTuple{6,Nothing},Tuple{Nothing}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191
 [50] (::Zygote.var"#1694#back#153"{Zygote.var"#151#152"{typeof(∂(#solve#57)),Tuple{NTuple{6,Nothing},Tuple{Nothing}}}})(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59
 [51] (::typeof(∂(solve##kw)))(::SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [52] runSim_noSave at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\myModule1.jl:682 [inlined]
 [53] (::typeof(∂(runSim_noSave)))(::NamedTuple{(:sol, :sc),Tuple{SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing},Nothing}}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [54] runSim_noSave at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\myModule1.jl:708 [inlined]
 [55] (::typeof(∂(runSim_noSave)))(::NamedTuple{(:sol, :sc),Tuple{SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing},Nothing}}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [56] #151 at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191 [inlined]
 [57] #1694#back at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59 [inlined]
 [58] runNominal at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\MyModule2.jl:158 [inlined]
 [59] (::typeof(∂(runNominal)))(::NamedTuple{(:sol, :sc),Tuple{SciMLBase.ODESolution{Float64,2,Array{Array{Float64,1},1},Nothing,Nothing,Array{Float64,1},Nothing,SciMLBase.ODEProblem{Array{Float64,1},Tuple{Float64,Float64},true,Array{Float64,1},SciMLBase.ODEFunction{true,Main.MyModule2.MOD1.var"#17#18",LinearAlgebra.UniformScaling{Bool},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,Nothing,typeof(SciMLBase.DEFAULT_OBSERVED),Nothing},Base.Iterators.Pairs{Symbol,DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}},Tuple{Symbol},NamedTuple{(:callback,),Tuple{DiffEqBase.CallbackSet{Tuple{DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#10#11",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64},DiffEqBase.ContinuousCallback{Main.MyModule2.MOD1.var"#8#9",typeof(SciMLBase.terminate!),typeof(SciMLBase.terminate!),typeof(DiffEqBase.INITIALIZE_DEFAULT),typeof(DiffEqBase.FINALIZE_DEFAULT),Float64,Int64,Nothing,Int64}},Tuple{}}}}},SciMLBase.StandardODEProblem},OrdinaryDiffEq.Tsit5,SciMLBase.LinearInterpolation{Array{Float64,1},Array{Array{Float64,1},1}},Nothing},Nothing}}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
6 
 [60] runNetworkSim at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\MyModule2.jl:180 [inlined]
 [61] (::typeof(∂(runNetworkSim)))(::Tuple{Float64,Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [62] perform_adjoint at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\MyModule2.jl:209 [inlined]
 [63] (::typeof(∂(perform_adjoint)))(::NamedTuple{(:loss, :count, :numHits),Tuple{Float64,Float64,Nothing}}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [64] loss_adjoint at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\MyModule2.jl:220 [inlined]
 [65] (::typeof(∂(loss_adjoint)))(::Tuple{Float64,Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [66] #7 at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\MyModule2.jl:290 [inlined]
 [67] (::typeof(∂(#7)))(::Tuple{Float64,Nothing}) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [68] #69 at C:\Users\username\.julia\packages\DiffEqFlux\hvOcT\src\train.jl:2 [inlined]
 [69] #151 at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191 [inlined]
 [70] #1694#back at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59 [inlined]
 [71] OptimizationFunction at C:\Users\username\.julia\packages\SciMLBase\eghDQ\src\problems\basic_problems.jl:107 [inlined]
 ... (the last 3 lines are repeated 1 more time)
 [75] #151 at C:\Users\username\.julia\packages\Zygote\KpME9\src\lib\lib.jl:191 [inlined]
 [76] (::Zygote.var"#1694#back#153"{Zygote.var"#151#152"{typeof(∂(λ)),Tuple{Tuple{Nothing,Nothing},Int64}}})(::Tuple{Float64,Nothing}) at C:\Users\username\.julia\packages\ZygoteRules\OjfTt\src\adjoint.jl:59
 [77] #8 at C:\Users\username\.julia\packages\GalacticOptim\Ha1cY\src\solve.jl:94 [inlined]
 [78] (::typeof(∂(λ)))(::Float64) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface2.jl:0
 [79] (::Zygote.var"#54#55"{Params,Zygote.Context,typeof(∂(λ))})(::Float64) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface.jl:172
 [80] gradient(::Function, ::Params) at C:\Users\username\.julia\packages\Zygote\KpME9\src\compiler\interface.jl:49
 [81] __solve(::SciMLBase.OptimizationProblem{false,SciMLBase.OptimizationFunction{false,GalacticOptim.AutoZygote,SciMLBase.OptimizationFunction{true,GalacticOptim.AutoZygote,DiffEqFlux.var"#69#70"{Main.MyModule2.var"#7#8"},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},GalacticOptim.var"#146#156"{GalacticOptim.var"#145#155"{SciMLBase.OptimizationFuGalacticOptim.var"#145#155"{SciMLBase.OptimizationFunction{true,GalacticOptim.AutoZygote,DiffEqFlux.var"#69#70"{Main.MyModule2.var"#7#8"},Nothing,NothincOptim.var"#149#159"{GalacticOptim.var"#145#155"{Scig,Nothing,Nothing,Nothing,Nothing},Nothing}},GalacticOptim.var"#149#159"{GalacticOptim.var"#145#155"{SciMLBase.OptimizationFunction{true,GalacticOpting},Nothing}},GalacticOptim.var"#154#164",Nothing,Nom.AutoZygote,DiffEqFlux.var"#69#70"{Main.MyModule2.var"#7#8"},Nothing,Nothing,Nothing,Nothing,Nothing,Nothing},Nothing}},GalacticOptim.var"#154#164",Notle{(:cb, :maxiters, :save_best),Tuple{Main.MyModule2.vahing,Nothing,Nothing},Array{Float32,1},SciMLBase.NullParameters,Nothing,Nothing,Nothing,Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},N, kwargs::Base.Iterators.Pairs{Union{},Union{},TupleamedTuple{(:cb, :maxiters, :save_best),Tuple{Main.MyModule2.var"#5#6",Int64,Bool}}}}, ::ADAM, ::Base.Iterators.Cycle{Tuple{GalacticOptim.NullData}}; maxiters::Int64, cb::Function, progress::Bool, save_best::Bool, kwargs::Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}) at C:\Users\username\.julia\packages\GalacticOptim\Ha1cY\src\solve.jl:93                                                                                        ol,Symbol,Symbol},NamedTuple{(:cb, :maxiters, :save_
 [82] #solve#450 at C:\Users\username\.julia\packages\SciMLBase\eghDQ\src\solve.jl:3 [inlined]
 [83] sciml_train(::Main.MyModule2.var"#7#8", ::Array{Float32,1}, ::ADAM, ::GalacticOptim.AutoZygote; kwargs::Base.Iterators.Pairs{Symbol,Any,Tuple{Symbol,Symbol,Symbol},NamedTuple{(:cb, :maxiters, :save_best),Tuple{Main.MyModule2.var"#5#6",Int64,Bool}}}) at C:\Users\username\.julia\packages\DiffEqFlux\hvOcT\src\train.jl:5
 [84] tester() at c:\Users\username\Documents\2020\Julia\development\MyProject\examples\myModule1\MyModule2.jl:290
7

Maybe? Poking around in the source it looks like maybe during macro expansion there is a try/catch but the expanded result does not have one. You can try marking a block of code with Zygote.ignore to prevent it from being differentiated, the documentation there does mention logging.

I don’t know of one, I haven’t seen this particular error before.

Yeah, that is a Tuple Type, each entry is the type of that entry in the tuple instance. Since the first entry in the tuple is the type of a function (OrdinaryDiffEq._postamble!), this is a function signature and the rest of the entries are the argument types of that function. Many of those types are themselves parametric, so all those type names present as well. Expanding it is interesting to see how DifferentialEquations uses types to encode the problem, but not helpful for debugging this problem.