Derivative boundary condition support is missing

[caMi11er]

I’m trying to use BVProblem with solver RadauIIa5.
In the boundary condition function called by the solver,
I need to refer to the first derivative of the solution.

sol(tx, Val{1}; idxs=1) is rejected by BVProblem with solver RadauIIa5.

ERROR: MethodError: no method matching (::BoundaryValueDiffEqCore.EvalSol{BoundaryValueDiffEqFIRK.FIRKCacheExpand{…}, Vector{…}, Vector{…}})(::Float64, ::Type{Val{…}}; idxs::Int64)
 .
 .
 .
Closest candidates are:
  (::BoundaryValueDiffEqCore.EvalSol{C})(::Number) where C<:BoundaryValueDiffEqFIRK.FIRKCacheExpand got unsupported keyword argument "idxs"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/interpolation.jl:134

Stacktrace:
  [1] bcond!(resid::Vector{…}, sol::BoundaryValueDiffEqCore.EvalSol{…}, par::Tuple{…}, r::Vector{…})
    @ Main ~/Applications/Julia/RealisticSeismology-main/src/RealMod/src/shtar.jl:59
  [2] eval_bc_residual!(resid::Vector{…}, ::SciMLBase.StandardBVProblem, bc!::typeof(bcond!), sol::BoundaryValueDiffEqCore.EvalSol{…}, p::Tuple{…}, t::Vector{…})

I'm told that DiffResults.derivative is also unavailable…
ChrisRackauckas: the analytical solution to the derivative should be implemented but it’s not in this case and it’s missing a better error message.

[ErikQQY]

I guess you are trying to access the derivative boundary conditions in the boundary condition definition (maybe related to #83), which is not explicitly supported and tested, but since we have changed to the solution evaluation syntax in boundary conditions, we can do that with some additional dispatches, so could you please share an MWE where you are trying to use derivative boundary conditions?

[caMi11er]

#  This example using BVProblem with solver RadauIIa5 is based on
# an attmpt to reproduce the analytic solution... 
#   y(t) = t^2 + 10.

using BoundaryValueDiffEqFIRK  

function f!(dy_dt, y, par, t)

#  It seems that t is provided as a vector.

#    dy_dt = 2.0 .* t         # error!
    dy_dt[1] = 2.0 .* t
    
#    [dy_dt]     # These square brackets are not required, and don't seem to matter.
                 # In fact, this line is extraneous
                 
end

function initialGuess(t)
#  And here, t seems to be a vector
# The arguments of this function appear to be undocumented.

# We use the correct solution but without the constant as the initial guess 

    [t .* t]      # If these square brackets are absent ==> error msg!  Why the difference?    

end

function bc!(resid, soln, par, t)   #  Boundary conditions 
# Here again t seems to be a vector.

    resid[1] = (soln[1,1] - 11.0)      
    resid[2] = (soln(1.0,Val{2})[1] - 2.0)

end

tspan = (1.0, 10.0)

bvp = BVProblem(BVPFunction(f!, bc!; bcresid_prototype = zeros(2) ), initialGuess , tspan, 0.0)

soln = solve(bvp, RadauIIa5(); dt = 0.1, abstol=1e-2, reltol=1e-2) 

julia> include("../../../BVProblem,Example3d.jl")
ERROR: LoadError: MethodError: no method matching (::BoundaryValueDiffEqCore.EvalSol{BoundaryValueDiffEqFIRK.FIRKCacheExpand{…}, Vector{…}, Vector{…}})(::Float64, ::Type{Val{…}})
The object of type `BoundaryValueDiffEqCore.EvalSol{BoundaryValueDiffEqFIRK.FIRKCacheExpand{true, Float64, Tuple{Int64}, BVPFunction{true, SciMLBase.FullSpecialize, false, typeof(f!), typeof(bc!), LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Float64}, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, SymbolicIndexingInterface.SymbolCache{Nothing, Nothing, Nothing, Nothing, Dict{Any, Any}}, Nothing}, typeof(bc!), BVProblem{Vector{Float64}, Tuple{Float64, Float64}, true, true, Float64, BVPFunction{true, SciMLBase.FullSpecialize, false, typeof(f!), typeof(bc!), LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Float64}, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, SymbolicIndexingInterface.SymbolCache{Nothing, Nothing, Nothing, Nothing, Dict{Any, Any}}, Nothing}, SciMLBase.StandardBVProblem, Base.Pairs{Symbol, Union{}, Tuple{}, @NamedTuple{}}}, SciMLBase.StandardBVProblem, Float64, RadauIIa5{Nothing, BVPJacobianAlgorithm{AutoForwardDiff{nothing, Nothing}, AutoSparse{AutoForwardDiff{nothing, Nothing}, ADTypes.NoSparsityDetector, ADTypes.NoColoringAlgorithm}, AutoSparse{AutoForwardDiff{nothing, Nothing}, ADTypes.NoSparsityDetector, ADTypes.NoColoringAlgorithm}}, Float64}, BoundaryValueDiffEqFIRK.FIRKTableau{false, Int64, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, BoundaryValueDiffEqFIRK.FIRKInterpTableau{false, Matrix{Float64}, Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{PreallocationTools.DiffCache{Matrix{Float64}, Vector{Float64}}}, Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}}, RecursiveArrayTools.VectorOfArray{Float64, 2, Vector{Vector{Float64}}}, Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}}, PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}, Vector{Float64}, RecursiveArrayTools.VectorOfArray{Float64, 2, Vector{Vector{Float64}}}, Tuple{Int64}, @NamedTuple{abstol::Float64, dt::Float64, adaptive::Bool, reltol::Float64}}, Vector{Vector{Float64}}, Vector{Float64}}` exists, but no method is defined for this combination of argument types when trying to treat it as a callable object.

Closest candidates are:
  (::BoundaryValueDiffEqCore.EvalSol{C})(::Number) where C<:BoundaryValueDiffEqFIRK.FIRKCacheExpand
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/interpolation.jl:134

Stacktrace:
  [1] bc!(resid::Vector{…}, soln::BoundaryValueDiffEqCore.EvalSol{…}, par::Float64, t::Vector{…})
    @ Main ~/Applications/Julia/RealisticSeismology-main/BVProblem,Example3d.jl:34
  [2] eval_bc_residual!(resid::Vector{…}, ::SciMLBase.StandardBVProblem, bc!::typeof(bc!), sol::BoundaryValueDiffEqCore.EvalSol{…}, p::Float64, t::Vector{…})
    @ BoundaryValueDiffEqCore ~/.julia/packages/BoundaryValueDiffEqCore/vnuZ6/src/utils.jl:123
  [3] __firk_loss!(resid::Vector{…}, u::Vector{…}, p::Float64, y::Vector{…}, pt::SciMLBase.StandardBVProblem, bc!::typeof(bc!), residual::Vector{…}, mesh::Vector{…}, cache::BoundaryValueDiffEqFIRK.FIRKCacheExpand{…}, eval_sol::BoundaryValueDiffEqCore.EvalSol{…})
    @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/firk.jl:670
  [4] (::BoundaryValueDiffEqFIRK.var"#119#125"{…})(du::Vector{…}, u::Vector{…}, p::Float64)
    @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/firk.jl:426
  [5] (::NonlinearFunction{…})(::Vector{…}, ::Vararg{…})
    @ SciMLBase ~/.julia/packages/SciMLBase/tWwhl/src/scimlfunctions.jl:2469
  [6] evaluate_f(prob::NonlinearLeastSquaresProblem{Vector{…}, true, Float64, NonlinearFunction{…}, @Kwargs{}}, u::Vector{Float64})
    @ NonlinearSolveBase.Utils ~/.julia/packages/NonlinearSolveBase/Kek5u/src/utils.jl:174
  [7] __init(::NonlinearLeastSquaresProblem{…}, ::GeneralizedFirstOrderAlgorithm{…}; stats::SciMLBase.NLStats, alias_u0::Bool, maxiters::Int64, abstol::Float64, reltol::Float64, maxtime::Nothing, termination_condition::Nothing, internalnorm::Function, linsolve_kwargs::@NamedTuple{}, initializealg::NonlinearSolveBase.NonlinearSolveDefaultInit, kwargs::@Kwargs{…})
    @ NonlinearSolveFirstOrder ~/.julia/packages/NonlinearSolveFirstOrder/3kzAL/src/solve.jl:151
  [8] __solve(::NonlinearLeastSquaresProblem{…}, ::GeneralizedFirstOrderAlgorithm{…}; kwargs::@Kwargs{…})
    @ NonlinearSolveBase ~/.julia/packages/NonlinearSolveBase/Kek5u/src/solve.jl:5
  [9] macro expansion
    @ ~/.julia/packages/NonlinearSolveBase/Kek5u/src/solve.jl:173 [inlined]
 [10] __generated_polysolve(::NonlinearLeastSquaresProblem{…}, ::NonlinearSolvePolyAlgorithm{…}; stats::SciMLBase.NLStats, alias_u0::Bool, verbose::Bool, initializealg::NonlinearSolveBase.NonlinearSolveDefaultInit, kwargs::@Kwargs{…})
    @ NonlinearSolveBase ~/.julia/packages/NonlinearSolveBase/Kek5u/src/solve.jl:130
 [11] __solve(::NonlinearLeastSquaresProblem{…}, ::NonlinearSolvePolyAlgorithm{…}; kwargs::@Kwargs{…})
    @ NonlinearSolveBase ~/.julia/packages/NonlinearSolveBase/Kek5u/src/solve.jl:127
 [12] __perform_firk_iteration(cache::BoundaryValueDiffEqFIRK.FIRKCacheExpand{…}, abstol::Float64, adaptive::Bool; nlsolve_kwargs::@NamedTuple{}, kwargs::@Kwargs{…})
    @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/firk.jl:358
 [13] __perform_firk_iteration
    @ ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/firk.jl:354 [inlined]
 [14] solve!(cache::BoundaryValueDiffEqFIRK.FIRKCacheExpand{…})
    @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/firk.jl:309
 [15] __solve(::BVProblem{…}, ::RadauIIa5{…}; kwargs::@Kwargs{…})
    @ BoundaryValueDiffEqCore ~/.julia/packages/BoundaryValueDiffEqCore/vnuZ6/src/BoundaryValueDiffEqCore.jl:37
 [16] __solve
    @ ~/.julia/packages/BoundaryValueDiffEqCore/vnuZ6/src/BoundaryValueDiffEqCore.jl:34 [inlined]
 [17] #solve_call#44
    @ ~/.julia/packages/DiffEqBase/R2Vjs/src/solve.jl:634 [inlined]
 [18] solve_up(prob::BVProblem{…}, sensealg::Nothing, u0::Function, p::Float64, args::RadauIIa5{…}; kwargs::@Kwargs{…})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/R2Vjs/src/solve.jl:1122
 [19] solve_up
    @ ~/.julia/packages/DiffEqBase/R2Vjs/src/solve.jl:1101 [inlined]
 [20] solve(prob::BVProblem{…}, args::RadauIIa5{…}; sensealg::Nothing, u0::Nothing, p::Nothing, wrap::Val{…}, kwargs::@Kwargs{…})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/R2Vjs/src/solve.jl:1038
 [21] top-level scope
    @ ~/Applications/Julia/RealisticSeismology-main/BVProblem,Example3d.jl:42
 [22] include(fname::String)
    @ Main ./sysimg.jl:38
 [23] top-level scope
    @ REPL[160]:1
in expression starting at /Users/andy 1/Applications/Julia/RealisticSeismology-main/BVProblem,Example3d.jl:42
Some type information was truncated. Use `show(err)` to see complete types.

[caMi11er]

Could you please tell me where I might find a list of documented features that are unsupported by this solver at this time?
(Maybe I should just give up on using this solver for now?)

For example, as I had no intention of invoking ForwardDiff, but this solver tries to use it anyway,
I preferred to disable it to avoid having to figure out how to cope with the resulting Type incompatibilities.
This FAQ says:

The first way, the easy way, is to just turn off autodifferentiation with the autodiff=false option in the solver. 
Every solver which uses autodifferentiation has this option. 

But I just now discovered that autodiff = false is also unsupported:

   sol = solve(prob, RadauIIa5(autodiff = false); dt = 0.1, abstol=1e-6, reltol=1e-6)    

ERROR: MethodError: no method matching RadauIIa5(; autodiff::Bool)
This error has been manually thrown, explicitly, so the method may exist but be intentionally marked as unimplemented.

Closest candidates are:
  RadauIIa5(; nlsolve, jac_alg, nested_nlsolve, nest_tol, defect_threshold, max_num_subintervals) got unsupported keyword argument "autodiff"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:83
  RadauIIa5(::N, ::J, ::Bool, ::Union{Nothing, Number}, ::T, ::Int64) where {N, J<:BVPJacobianAlgorithm, T} got unsupported keyword argument "autodiff"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:84
  RadauIIa5(::N, ::J; nested, nest_tol, defect_threshold, max_num_subintervals) where {N, J} got unsupported keyword argument "autodiff"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:91

Please advise.

[caMi11er]

One more point — the MWE in my last post does not trigger ForwardDiff.
I inserted this global…

function f!(dy_dt, y, par, t)

    global typeofy = typeof(y)

to get

Vector{Float64} (alias for Array{Float64, 1})

but in my real code using the same solver that somehow triggers ForwardDiff, I get

julia> typeofy
Base.ReinterpretArray{ForwardDiff.Dual{ForwardDiff.Tag{BoundaryValueDiffEqCore.__Fix3{BoundaryValueDiffEqFIRK.var"#117#123"{BoundaryValueDiffEqFIRK.FIRKCacheExpand{true, Float64, Tuple{Int64}, BVPFunction{true, SciMLBase.FullSpecialize, false, typeof(shtructure!), typeof(bcond!), LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Float64}, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, SymbolicIndexingInterface.SymbolCache{Nothing, Nothing, Nothing, Nothing, Dict{Any, Any}}, Nothing}, typeof(bcond!), BVProblem{Vector{Float64}, Tuple{Float64, Float64}, true, true, Tuple{Sim{ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, Float64, Float64, Interpolations.GriddedInterpolation{Float64, 1, Vector{Float64}, Gridded{Linear{Throw{OnGrid}}}, Tuple{Vector{Float64}}}}, Float64, Float64, Float64}, BVPFunction{true, SciMLBase.FullSpecialize, false, typeof(shtructure!), typeof(bcond!), LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Vector{Float64}, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, SymbolicIndexingInterface.SymbolCache{Nothing, Nothing, Nothing, Nothing, Dict{Any, Any}}, Nothing}, SciMLBase.StandardBVProblem, Base.Pairs{Symbol, Union{}, Tuple{}, @NamedTuple{}}}, SciMLBase.StandardBVProblem, Tuple{Sim{ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, Float64, Float64, Interpolations.GriddedInterpolation{Float64, 1, Vector{Float64}, Gridded{Linear{Throw{OnGrid}}}, Tuple{Vector{Float64}}}}, Float64, Float64, Float64}, RadauIIa5{Nothing, BVPJacobianAlgorithm{AutoForwardDiff{nothing, Nothing}, AutoSparse{AutoForwardDiff{nothing, Nothing}, ADTypes.NoSparsityDetector, ADTypes.NoColoringAlgorithm}, AutoSparse{AutoForwardDiff{nothing, Nothing}, ADTypes.NoSparsityDetector, ADTypes.NoColoringAlgorithm}}, Float64}, BoundaryValueDiffEqFIRK.FIRKTableau{false, Int64, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, BoundaryValueDiffEqFIRK.FIRKInterpTableau{false, Matrix{Float64}, Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{PreallocationTools.DiffCache{Matrix{Float64}, Vector{Float64}}}, Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}}, RecursiveArrayTools.VectorOfArray{Float64, 2, Vector{Vector{Float64}}}, Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}}, PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}, Vector{Float64}, RecursiveArrayTools.VectorOfArray{Float64, 2, Vector{Vector{Float64}}}, Tuple{Int64}, @NamedTuple{abstol::Float64, dt::Float64, adaptive::Bool, reltol::Float64}}}, Tuple{Sim{ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, OffsetArrays.OffsetMatrix{Float64, Matrix{Float64}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Cubic{Line{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, ScaledInterpolation{Float64, 2, Interpolations.BSplineInterpolation{Float64, 2, Matrix{Float64}, BSpline{Linear{Throw{OnGrid}}}, Tuple{Base.OneTo{Int64}, Base.OneTo{Int64}}}, BSpline{Linear{Throw{OnGrid}}}, Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}}, Float64, Float64, Interpolations.GriddedInterpolation{Float64, 1, Vector{Float64}, Gridded{Linear{Throw{OnGrid}}}, Tuple{Vector{Float64}}}}, Float64, Float64, Float64}}, Float64}, Float64, 10}, 1, Float64, SubArray{Float64, 1, Vector{Float64}, Tuple{UnitRange{Int64}}, true}, false}

julia> 

but the t argument is not a vector in this case!

Float64

Will t become a vector later in the solution process, requiring broadcast operators?

How should I convert this to float64 to use as arguments in my functions?

Base.ReinterpretArray{ForwardDiff.Dual{ForwardDiff.Tag{BoundaryValueDiffEqCore...

[ChrisRackauckas]

That FAQ needs to get updated to DifferentiationInterface, i.e. autodiff= ADTypes.AutoForwardDiff()

But yes the main issue is that the interpolations need the analytical derivative dispatches, which this library's methods haven't gotten to yet. They aren't hard to add though.

[caMi11er]

Another possibly unimplemented feature of RadauIIa5

Its description here says ...

For type-stability, the chunksizes for ForwardDiff ADTypes in BVPJacobianAlgorithm must be provided. 

so I tried...

    sol = solve(prob, RadauIIa5(adtype=AutoForwardDiff(; chunksize=300) ); dt = 0.1, abstol=1e-6, reltol=1e-6) 

and was rewarded with...

ERROR: MethodError: no method matching RadauIIa5(; adtype::AutoForwardDiff{300, Nothing})
This error has been manually thrown, explicitly, so the method may exist but be intentionally marked as unimplemented.

Closest candidates are:
  RadauIIa5(; nlsolve, jac_alg, nested_nlsolve, nest_tol, defect_threshold, max_num_subintervals) got unsupported keyword argument "adtype"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:83
  RadauIIa5(::N, ::J, ::Bool, ::Union{Nothing, Number}, ::T, ::Int64) where {N, J<:BVPJacobianAlgorithm, T} got unsupported keyword argument "adtype"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:84
  RadauIIa5(::N, ::J; nested, nest_tol, defect_threshold, max_num_subintervals) where {N, J} got unsupported keyword argument "adtype"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:91

Stacktrace:
 [1] kwerr(kw::@NamedTuple{adtype::AutoForwardDiff{300, Nothing}}, args::Type)
   @ Base ./error.jl:165
 [2] integrate_shtar(eos::Sim{…}, M::Float64, rμ::Float64, pf::Float64)
   @ Main ~/Applications/Julia/RealisticSeismology-main/src/RealMod/src/shtar.jl:120
 [3] Shtar(eos::Sim{…}, Madm::Float64, pf::Float64)
   @ Main ~/Applications/Julia/RealisticSeismology-main/src/RealMod/src/shtar.jl:180
 [4] top-level scope
   @ REPL[182]:1
Some type information was truncated. Use `show(err)` to see complete types.

[caMi11er]

Regarding priorities...
Let me note here that it is not urgent for me to have access to the derivative calculations such as

    resid[2] = (soln(1.0,Val{2})[1] - 2.0)

as I can code my own finite differences for boundary conditions.

On the other hand, it would take a lot of work for me to propagate ForwardDiff.Dual through my derivative function,
so from my point of view, it's much more urgent to implement autodiff = false, if possible...

   sol = solve(prob, RadauIIa5(autodiff = false); dt = 0.1, abstol=1e-6, reltol=1e-6)    

[ChrisRackauckas]

autodiff = AutoFiniteDiff() should be fine?

[caMi11er]

Thanks, but nope...

    sol = solve(prob, RadauIIa5(autodiff = AutoFiniteDiff() ); dt = 0.1, abstol=1e-6, reltol=1e-6)

ERROR: MethodError: no method matching RadauIIa5(; autodiff::AutoFiniteDiff{Val{:forward}, Val{:forward}, Val{:hcentral}, Nothing, Nothing})
This error has been manually thrown, explicitly, so the method may exist but be intentionally marked as unimplemented.

Closest candidates are:
  RadauIIa5(; nlsolve, jac_alg, nested_nlsolve, nest_tol, defect_threshold, max_num_subintervals) got unsupported keyword argument "autodiff"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:83
  RadauIIa5(::N, ::J, ::Bool, ::Union{Nothing, Number}, ::T, ::Int64) where {N, J<:BVPJacobianAlgorithm, T} got unsupported keyword argument "autodiff"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:84
  RadauIIa5(::N, ::J; nested, nest_tol, defect_threshold, max_num_subintervals) where {N, J} got unsupported keyword argument "autodiff"
   @ BoundaryValueDiffEqFIRK ~/.julia/packages/BoundaryValueDiffEqFIRK/ddek7/src/algorithms.jl:91

Stacktrace:
 [1] kwerr(kw::@NamedTuple{autodiff::AutoFiniteDiff{Val{:forward}, Val{:forward}, Val{:hcentral}, Nothing, Nothing}}, args::Type)
   @ Base ./error.jl:165
 [2] integrate_shtar(eos::Sim{…}, M::Float64, rμ::Float64, pf::Float64)
   @ Main ~/Applications/Julia/RealisticSeismology-main/src/RealMod/src/shtar.jl:121
 [3] Shtar(eos::Sim{…}, Madm::Float64, pf::Float64)
   @ Main ~/Applications/Julia/RealisticSeismology-main/src/RealMod/src/shtar.jl:181
 [4] top-level scope
   @ REPL[186]:1
Some type information was truncated. Use `show(err)` to see complete types.

[ChrisRackauckas]

oh that would just be waiting for #258 to merge, which should be this week.

[caMi11er]

ohK!