# Problems saving/opening ODESolution from SciML with JLD2

**URL:** https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958
**Category:** Numerics
**Tags:** package, jld2, sciml, differentialequation, ordinarydiffeq
**Created:** [November 30, 2023, 4:30pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958 "2023-11-30T16:30:45Z")
**Posts on this page:** 13
**Page:** 1

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [November 30, 2023, 4:30pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/1 "2023-11-30T16:30:45Z")

</div>

I define a custom `struct` to hold the parameters for the coupled ODEs I’m solving with `OrdinaryDiffEq.jl`, which typically stores various numbers and arrays (1D or 2D), as well as vectors of dualcache vectors in `par.dualcache` for storing intermediate output when doing in-place calculation for the ODE RHS function `fun!(du,u,par,t)`,

i.e.`typeof(par.dualcache) = Vector{DiffCache{Vector{Float64}, Vector{Float64}}} (alias for Array{PreallocationTools.DiffCache{Array{Float64, 1}, Array{Float64, 1}}, 1})`

Sometimes I’m not exactly sure what information I will ultimately need when doing the analysis at the time of running the simulation, so I just the whole `ODESolution` output using `JLD2.jl`. The problem is that sometimes after a while when I have (intentionally or accidentally) updated the packages, then when I want to open the `.jld2` file, I have the following error:

```julia
MethodError: Cannot `convert` an object of type 
  JLD2.ReconstructedStatic{Symbol("SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol(\"ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\\\"OptControl.#TFE1D!\\\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}\"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol(\"ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}\"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}"), (:f, :t, :p), Tuple{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}} to an object of type 
  SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}

Closest candidates are:
  convert(::Type{T}, ::T) where T
   @ Base Base.jl:64

Stacktrace:
  [1] rconvert(T::Type, x::JLD2.ReconstructedStatic{Symbol("SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol(\"ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\\\"OptControl.#TFE1D!\\\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}\"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol(\"ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}\"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}"), (:f, :t, :p), Tuple{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\custom_serialization.jl:9
  [2] jlconvert
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\writing_datatypes.jl:315 [inlined]
  [3] macro expansion
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:720 [inlined]
  [4] jlconvert(#unused#::JLD2.ReadRepresentation{OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32, 40, 80, 120, 121, 122, 123, 131, 139, 147, 155, 163, 171, 179, 187), Tuple{Vector{Float64}, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Bool, Bool, Bool, Float64, Vector{Float64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}, Vector{Float64}, Float64, Float64, Float64}, Tuple{JLD2.RelOffset, Float64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), Bool, Bool, Bool, Float64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Float64, Float64, Float64}, 195}()}, f::JLD2.JLDFile{JLD2.MmapIO}, ptr::Ptr{Nothing}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:685
  [5] read_scalar(f::JLD2.JLDFile{JLD2.MmapIO}, rr::JLD2.ReadRepresentation{OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32, 40, 80, 120, 121, 122, 123, 131, 139, 147, 155, 163, 171, 179, 187), Tuple{Vector{Float64}, Float64, Vector{Float64}, Vector{Float64}, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Bool, Bool, Bool, Float64, Vector{Float64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}, Vector{Float64}, Float64, Float64, Float64}, Tuple{JLD2.RelOffset, Float64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), Bool, Bool, Bool, Float64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Float64, Float64, Float64}, 195}()}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\dataio.jl:37
  [6] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, rr::Any, read_dataspace::Tuple{JLD2.ReadDataspace, JLD2.RelOffset, JLD2.DataLayout, JLD2.FilterPipeline}, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:238
  [7] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, dataspace::JLD2.ReadDataspace, datatype_class::UInt8, datatype_offset::Int64, layout::JLD2.DataLayout, filters::JLD2.FilterPipeline, header_offset::JLD2.RelOffset, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:194
  [8] load_dataset(f::JLD2.JLDFile{JLD2.MmapIO}, offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:125
  [9] jlconvert
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\writing_datatypes.jl:314 [inlined]
 

```

When I used the old `Manifest.toml` and revert back to the older versions of the packages (with the exact same codes on my end), then I managed to retrieve `sol` from the saved `.jld2` file. I haven’t changed anything about my own custom `struct` for storing various relevant parameters/quantities and the ODE function as it’s still the same code, so apparently with the latter versions of `JLD2` or parts of those `SciML` packages something break.

To prevent this from happening again, my question is:

1. The feature I really want to keep in the stored data is the interpolation, i.e. `sol(t)`. Are there any ways to store `sol` which can preserve this feature, without storing `sol.prob.p` (i.e. my custom `struct`) or the ODE function, both of which might cause issues in latter versions of reasons I’m not aware of?

2. I have pinned some of the key packages I use for running my simulations, such as `OrdinaryDiffEq.jl`, but sometimes when I just wanna upgrade other non-relevant packages like `Makie.jl` for plotting, it also updates the other `SciML` packages like `LinearSolve` that `OrdinaryDiffEq` depend on. How backward compatible can I expect for these ‘inner’ packages? Just to be extra safe, are there other `SciML` packages that I should pin in order to prevent accidentally update? Or in my case from the error message, it looks like there are also some issues with `SparseArrays.SparseMatrixCSC` (I need to pass the sparsity pattern to speed up computation). Are there anything I can do regarding fixing the versions of the packages which are relevant to solving ODEs?

---

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [November 30, 2023, 4:31pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/2 "2023-11-30T16:31:41Z")

</div>

The error message is too long to be posted in one post:

```julia
[10] macro expansion
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:720 [inlined]
 [11] jlconvert(#unused#::JLD2.ReadRepresentation{OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, JLD2.OnDiskRepresentation{(0, 8, 16, 16, 24, 32, 40, 48, 122, 130, 138, 146, 154, 162, 163, 171, 175), Tuple{Vector{Float64}, Vector{Float64}, Nothing, Vector{Float64}, Float64, Float64, Float64, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, Float64, Float64, Float64, Int64, Int64, OrdinaryDiffEq.NLStatus, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}, OrdinaryDiffEq.MethodType, Int64}, Tuple{JLD2.RelOffset, JLD2.RelOffset, nothing, JLD2.RelOffset, Float64, Float64, Float64, JLD2.OnDiskRepresentation{(0, 16, 24, 40, 56, 57, 58), Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, 74}(), Float64, Float64, Float64, Int64, Int64, OrdinaryDiffEq.NLStatus, JLD2.RelOffset, OrdinaryDiffEq.MethodType, Int64}, 183}()}, f::JLD2.JLDFile{JLD2.MmapIO}, ptr::Ptr{Nothing}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:685
 [12] read_scalar(f::JLD2.JLDFile{JLD2.MmapIO}, rr::JLD2.ReadRepresentation{OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, JLD2.OnDiskRepresentation{(0, 8, 16, 16, 24, 32, 40, 48, 122, 130, 138, 146, 154, 162, 163, 171, 175), Tuple{Vector{Float64}, Vector{Float64}, Nothing, Vector{Float64}, Float64, Float64, Float64, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, Float64, Float64, Float64, Int64, Int64, OrdinaryDiffEq.NLStatus, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}, OrdinaryDiffEq.MethodType, Int64}, Tuple{JLD2.RelOffset, JLD2.RelOffset, nothing, JLD2.RelOffset, Float64, Float64, Float64, JLD2.OnDiskRepresentation{(0, 16, 24, 40, 56, 57, 58), Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, 74}(), Float64, Float64, Float64, Int64, Int64, OrdinaryDiffEq.NLStatus, JLD2.RelOffset, OrdinaryDiffEq.MethodType, Int64}, 183}()}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\dataio.jl:37
 [13] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, rr::Any, read_dataspace::Tuple{JLD2.ReadDataspace, JLD2.RelOffset, JLD2.DataLayout, JLD2.FilterPipeline}, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:238
 [14] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, dataspace::JLD2.ReadDataspace, datatype_class::UInt8, datatype_offset::Int64, layout::JLD2.DataLayout, filters::JLD2.FilterPipeline, header_offset::JLD2.RelOffset, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:194
 [15] load_dataset(f::JLD2.JLDFile{JLD2.MmapIO}, offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:125
 [16] jlconvert
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\writing_datatypes.jl:314 [inlined]
 [17] macro expansion
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:720 [inlined]
 [18] jlconvert(#unused#::JLD2.ReadRepresentation{OrdinaryDiffEq.FBDFCache{5, OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Float64, Vector{Float64}, Matrix{Float64}, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Float64, Vector{Float64}, Vector{Float64}}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192), Tuple{Any, Any, Any, Any, Float64, Any, Int64, Int64, Any, Any, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Val{5}, Int64, Int64, Any, Any, Float64, Float64, Float64, Float64, Any, Any, Any, Any, Any, Int64}, Tuple{JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Float64, JLD2.RelOffset, Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.OnDiskRepresentation{(0,), Tuple{NTuple{30, Rational{Int64}}}, Tuple{JLD2.CustomSerialization{Array, JLD2.RelOffset}}, 8}(), nothing, Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, Float64, Float64, Float64, Float64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Int64}, 200}()}, f::JLD2.JLDFile{JLD2.MmapIO}, ptr::Ptr{Nothing}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:685
 [19] read_scalar(f::JLD2.JLDFile{JLD2.MmapIO}, rr::JLD2.ReadRepresentation{OrdinaryDiffEq.FBDFCache{5, OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Float64, Vector{Float64}, Matrix{Float64}, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Float64, Vector{Float64}, Vector{Float64}}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 88, 96, 104, 112, 120, 128, 136, 144, 152, 160, 168, 176, 184, 192), Tuple{Any, Any, Any, Any, Float64, Any, Int64, Int64, Any, Any, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Val{5}, Int64, Int64, Any, Any, Float64, Float64, Float64, Float64, Any, Any, Any, Any, Any, Int64}, Tuple{JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Float64, JLD2.RelOffset, Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.OnDiskRepresentation{(0,), Tuple{NTuple{30, Rational{Int64}}}, Tuple{JLD2.CustomSerialization{Array, JLD2.RelOffset}}, 8}(), nothing, Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, Float64, Float64, Float64, Float64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Int64}, 200}()}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\dataio.jl:37
 [20] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, rr::Any, read_dataspace::Tuple{JLD2.ReadDataspace, JLD2.RelOffset, JLD2.DataLayout, JLD2.FilterPipeline}, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:238
 [21] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, dataspace::JLD2.ReadDataspace, datatype_class::UInt8, datatype_offset::Int64, layout::JLD2.DataLayout, filters::JLD2.FilterPipeline, header_offset::JLD2.RelOffset, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:194
 [22] load_dataset(f::JLD2.JLDFile{JLD2.MmapIO}, offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:125
 [23] jlconvert
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\writing_datatypes.jl:314 [inlined]
 [24] macro expansion
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:766 [inlined]
 [25] jlconvert(#unused#::JLD2.ReadRepresentation{OrdinaryDiffEq.InterpolationData{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.FBDFCache{5, OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Float64, Vector{Float64}, Matrix{Float64}, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Float64, Vector{Float64}, Vector{Float64}}}, JLD2.OnDiskRepresentation{(0, 81, 89, 97, 105, 106), Tuple{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Any, Any, Any, Bool, Any}, Tuple{JLD2.OnDiskRepresentation{(0,), Tuple{NamedTuple{(:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}}, Tuple{JLD2.OnDiskRepresentation{(0, 1, 41), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Tuple{UniformScaling{Bool}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}()}, 0x00000051}()}, 0x00000051}(), JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Bool, JLD2.RelOffset}, 114}()}, f::JLD2.JLDFile{JLD2.MmapIO}, ptr::Ptr{Nothing}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:685
 [26] macro expansion
    @ C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:766 [inlined]

```

---

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [November 30, 2023, 4:34pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/3 "2023-11-30T16:34:15Z")

</div>

```julia
 [27] jlconvert(#unused#::JLD2.ReadRepresentation{ODESolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}, JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, FBDF{5, 12, false, LinearSolve.DefaultLinearSolver, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing, Nothing, Nothing}, OrdinaryDiffEq.InterpolationData{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.FBDFCache{5, OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Float64, Vector{Float64}, Matrix{Float64}, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Float64, Vector{Float64}, Vector{Float64}}}, SciMLBase.DEStats, Nothing}, JLD2.OnDiskRepresentation{(0, 8, 8, 8, 16, 24, 377, 487, 601, 602, 610, 618, 618), Tuple{Any, Nothing, Nothing, Any, Any, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}, JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, FBDF{5, 12, false, LinearSolve.DefaultLinearSolver, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing, Nothing, Nothing}, OrdinaryDiffEq.InterpolationData{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.FBDFCache{5, OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Float64, Vector{Float64}, Matrix{Float64}, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Float64, Vector{Float64}, Vector{Float64}}}, Bool, Int64, Any, Nothing, SciMLBase.ReturnCode.T}, Tuple{JLD2.RelOffset, nothing, nothing, JLD2.RelOffset, JLD2.RelOffset, JLD2.OnDiskRepresentation{(0, 81, 89, 105, 353, 353), Tuple{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Any, Tuple{Float64, Float64}, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, Tuple{JLD2.OnDiskRepresentation{(0,), Tuple{NamedTuple{(:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}}, Tuple{JLD2.OnDiskRepresentation{(0, 1, 41), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Tuple{UniformScaling{Bool}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}()}, 0x00000051}()}, 0x00000051}(), JLD2.RelOffset, Tuple{Float64, Float64}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 160, 168, 216, 224, 232, 240), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}, Tuple{JLD2.RelOffset, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, JLD2.RelOffset}, 0x000000f8}(), nothing, nothing}, 353}(), JLD2.OnDiskRepresentation{(0, 0, 4, 78, 78, 78, 78, 94), Tuple{Val{5}, LinearSolve.DefaultLinearSolver, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Nothing, Nothing, Symbol, Symbol}, Tuple{nothing, LinearSolve.DefaultLinearSolver, JLD2.OnDiskRepresentation{(0, 16, 24, 40, 56, 57, 58), Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, 74}(), nothing, nothing, nothing, JLD2.Vlen{String}, JLD2.Vlen{String}}, 110}(), JLD2.OnDiskRepresentation{(0, 81, 89, 97, 105, 106), Tuple{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Any, Any, Any, Bool, Any}, Tuple{JLD2.OnDiskRepresentation{(0,), Tuple{NamedTuple{(:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}}, Tuple{JLD2.OnDiskRepresentation{(0, 1, 41), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Tuple{UniformScaling{Bool}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}()}, 0x00000051}()}, 0x00000051}(), JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Bool, JLD2.RelOffset}, 114}(), Bool, Int64, JLD2.RelOffset, nothing, SciMLBase.ReturnCode.T}, 622}()}, f::JLD2.JLDFile{JLD2.MmapIO}, ptr::Ptr{Nothing}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\data\reconstructing_datatypes.jl:685

```

---

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [November 30, 2023, 4:34pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/4 "2023-11-30T16:34:39Z")

</div>

```julia
 [28] read_scalar(f::JLD2.JLDFile{JLD2.MmapIO}, rr::JLD2.ReadRepresentation{ODESolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}, JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, FBDF{5, 12, false, LinearSolve.DefaultLinearSolver, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing, Nothing, Nothing}, OrdinaryDiffEq.InterpolationData{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.FBDFCache{5, OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Float64, Vector{Float64}, Matrix{Float64}, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Float64, Vector{Float64}, Vector{Float64}}}, SciMLBase.DEStats, Nothing}, JLD2.OnDiskRepresentation{(0, 8, 8, 8, 16, 24, 377, 487, 601, 602, 610, 618, 618), Tuple{Any, Nothing, Nothing, Any, Any, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}, JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, FBDF{5, 12, false, LinearSolve.DefaultLinearSolver, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Val{:forward}, true, nothing, Nothing, Nothing}, OrdinaryDiffEq.InterpolationData{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, OrdinaryDiffEq.FBDFCache{5, OrdinaryDiffEq.NLSolver{NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, true, Vector{Float64}, Float64, Nothing, Float64, OrdinaryDiffEq.NLNewtonCache{Vector{Float64}, Float64, Float64, Vector{Float64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SciMLBase.UJacobianWrapper{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Float64, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}}, FiniteDiff.JacobianCache{Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Vector{Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Val{:forward}(), Float64}, LinearSolve.LinearCache{SparseArrays.SparseMatrixCSC{Float64, Int64}, Vector{Float64}, Vector{Float64}, SciMLBase.NullParameters, LinearSolve.DefaultLinearSolver, LinearSolve.DefaultLinearSolverInit{SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, SparseArrays.SPQR.QRSparse{Float64, Int64}, Nothing, Nothing, Sparspak.SpkSparseSolver.SparseSolver{Int64, Float64}, KLU.KLUFactorization{Float64, Int64}, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Nothing, SparseArrays.UMFPACK.UmfpackLU{Float64, Int64}, Tuple{Nothing, Nothing}, Nothing, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, Nothing, SparseArrays.CHOLMOD.Factor{Float64}, SparseArrays.CHOLMOD.Factor{Float64}}, LinearSolve.InvPreconditioner{Diagonal{Float64, Vector{Float64}}}, Diagonal{Float64, Vector{Float64}}, Float64, Bool}}}, Vector{Float64}, Vector{Float64}, Vector{Float64}, Float64, Vector{Float64}, Matrix{Float64}, StaticArraysCore.SMatrix{5, 6, Rational{Int64}, 30}, Float64, Vector{Float64}, Vector{Float64}}}, Bool, Int64, Any, Nothing, SciMLBase.ReturnCode.T}, Tuple{JLD2.RelOffset, nothing, nothing, JLD2.RelOffset, JLD2.RelOffset, JLD2.OnDiskRepresentation{(0, 81, 89, 105, 353, 353), Tuple{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Any, Tuple{Float64, Float64}, JLD2.ReconstructedMutable{Symbol("ModelParams{Vector{Float64},Float64,Float64,Nothing,Nothing,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{PreallocationTools.DiffCache{Vector{Float64}, Vector{Float64}}},Nothing}"), (:D, :V, :εr, :W, :A, :dims, :order, :tf, :Nx, :Lx, :x0, :Ny, :Ly, :y0, :x, :dx, :y, :dy, :area, :hmean, :caches), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}}, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, SciMLBase.StandardODEProblem}, Tuple{JLD2.OnDiskRepresentation{(0,), Tuple{NamedTuple{(:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}}, Tuple{JLD2.OnDiskRepresentation{(0, 1, 41), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Tuple{UniformScaling{Bool}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}()}, 0x00000051}()}, 0x00000051}(), JLD2.RelOffset, Tuple{Float64, Float64}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 160, 168, 216, 224, 232, 240), Tuple{Any, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, Any}, Tuple{JLD2.RelOffset, Float64, Float64, Float64, Float64, Int64, Int64, Float64, Int64, Float64, Float64, Int64, Float64, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Float64, Float64, Float64, JLD2.RelOffset}, 0x000000f8}(), nothing, nothing}, 353}(), JLD2.OnDiskRepresentation{(0, 0, 4, 78, 78, 78, 78, 94), Tuple{Val{5}, LinearSolve.DefaultLinearSolver, NLNewton{Rational{Int64}, Rational{Int64}, Rational{Int64}, Rational{Int64}}, typeof(OrdinaryDiffEq.DEFAULT_PRECS), Nothing, Nothing, Symbol, Symbol}, Tuple{nothing, LinearSolve.DefaultLinearSolver, JLD2.OnDiskRepresentation{(0, 16, 24, 40, 56, 57, 58), Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, Tuple{Rational{Int64}, Int64, Rational{Int64}, Rational{Int64}, Bool, Bool, Rational{Int64}}, 74}(), nothing, nothing, nothing, JLD2.Vlen{String}, JLD2.Vlen{String}}, 110}(), JLD2.OnDiskRepresentation{(0, 81, 89, 97, 105, 106), Tuple{JLD2.ReconstructedStatic{Symbol("ODEFunction{true, SciMLBase.FullSpecialize, JLD2.UnknownType{Symbol(\"OptControl.#TFE1D!\"), Tuple{}}, UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}"), (:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}, Any, Any, Any, Bool, Any}, Tuple{JLD2.OnDiskRepresentation{(0,), Tuple{NamedTuple{(:mass_matrix, :jac_prototype, :sparsity), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}}}, Tuple{JLD2.OnDiskRepresentation{(0, 1, 41), Tuple{UniformScaling{Bool}, SparseArrays.SparseMatrixCSC{Float64, Int64}, SparseArrays.SparseMatrixCSC{Float64, Int64}}, Tuple{UniformScaling{Bool}, JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}(), JLD2.OnDiskRepresentation{(0, 8, 16, 24, 32), Tuple{Int64, Int64, Vector{Int64}, Vector{Int64}, Vector{Float64}}, Tuple{Int64, Int64, JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset}, 40}()}, 0x00000051}()}, 0x00000051}(), JLD2.RelOffset, JLD2.RelOffset, JLD2.RelOffset, Bool, JLD2.RelOffset}, 114}(), Bool, Int64, JLD2.RelOffset, nothing, SciMLBase.ReturnCode.T}, 622}()}, header_offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\dataio.jl:37
 [29] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, rr::Any, read_dataspace::Tuple{JLD2.ReadDataspace, JLD2.RelOffset, JLD2.DataLayout, JLD2.FilterPipeline}, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:238
 [30] read_data(f::JLD2.JLDFile{JLD2.MmapIO}, dataspace::JLD2.ReadDataspace, datatype_class::UInt8, datatype_offset::Int64, layout::JLD2.DataLayout, filters::JLD2.FilterPipeline, header_offset::JLD2.RelOffset, attributes::Vector{JLD2.ReadAttribute})
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:194
 [31] load_dataset(f::JLD2.JLDFile{JLD2.MmapIO}, offset::JLD2.RelOffset)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\datasets.jl:125
 [32] getindex(g::JLD2.Group{JLD2.JLDFile{JLD2.MmapIO}}, name::String)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\groups.jl:109
 [33] getindex(f::JLD2.JLDFile{JLD2.MmapIO}, name::String)
    @ JLD2 C:\Users\yhcha\.julia\packages\JLD2\u57Vt\src\JLD2.jl:483
 [34] top-level scope
    @ In[19]:1

```

---

<div class="post-metadata">

### Author: ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [November 30, 2023, 5:12pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/5 "2023-11-30T17:12:59Z")

</div>

Did you redefine the functions as the docs explain before reading in the JLD2?

---

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [November 30, 2023, 6:21pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/6 "2023-11-30T18:21:30Z")

</div>

I’m very sure I’m using the same piece of code that defines my own custom `struct` for holding parameters, and when I used the old Manifest.toml file then I have no problem opening the `.jld2` file and accessing the structure. It’s only when I have a fresh project environment (with the same packages and updated to newer versions) that I have issues opening the `.jld2` data file, so I guess I didn’t accidentally re-define the ODEFunction?

---

<div class="post-metadata">

### Author: ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [November 30, 2023, 10:18pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/7 "2023-11-30T22:18:57Z")

</div>

> [@yhchang96](#):
>
> It’s only when I have a fresh project environment (with the same packages and updated to newer versions) that I have issues opening the `.jld2` data file, so I guess I didn’t accidentally re-define the ODEFunction?

If the solution object has changed (which it has) then reading it into the new struct won’t work.

---

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [November 30, 2023, 11:05pm UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/8 "2023-11-30T23:05:10Z")

</div>

and that’s why I’m asking about backward compatibility and whether any ‘internal’ structs used by `OrdinaryDiffEq` could have changed. The following are the things I can think of which might cause issues:

1. The `ODEFunction` includes a sparsity pattern of type `SparseArrays.SparseMatrixCSC{Float64, Int64}` which I computed and supplied, so if something in `SparseArrays` is changed this may cause issues? But I presume as a standard library the backward compatibility should be pretty stable.

2. `sol.prob.f` shows `typeof(f)`, where `f` is the du/dt ODE RHS function I supply, so I guess if anything computations (I only have in-place addition/subtraction/multiplication/division) defined inside the function is changed, this might cause problems? But then as I said with the exact same piece of code defining `f`, I got errors when I load the `.jld2` file using newer versions of the (external) packages, but no problems when using older versions of the same (external) packages. Very unlikely that something on my end (things I define explicitly) has been changed accidentally.

3. For the actual parameter struct `par=sol.prob.p` which I define, it has the field `dualcache` where `typeof(par.dualcache) = Vector{DiffCache{Vector{Float64}, Vector{Float64}}} (alias for Array{PreallocationTools.DiffCache{Array{Float64, 1}, Array{Float64, 1}}, 1})`.

4. I also store an `ODESolution` inside `par`, i.e. `isa(par.solFwd, ODESolution)` is `true`.

---

<div class="post-metadata">

### Author: ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [December 1, 2023, 5:25am UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/9 "2023-12-01T05:25:04Z")

</div>

> [@yhchang96](#):
>
> and that’s why I’m asking about backward compatibility and whether any ‘internal’ structs used by `OrdinaryDiffEq` could have changed.

They have. I think some things like the stats added new fields and such. These are generally non-breaking changes but indeed it would give JLD2 trouble.

---

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [December 1, 2023, 6:52am UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/10 "2023-12-01T06:52:39Z")

</div>

and if that’s the case, then pinning the versions of some of those internal SciML packages should help? and if so which ones are the important ones for fixing versions (for solving ODEs)? `SciMLBase` and `DiffEqBase`? anything else?

---

<div class="post-metadata">

### Author: ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [December 1, 2023, 9:16am UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/11 "2023-12-01T09:16:31Z")

</div>

> [@yhchang96](#):
>
> then pinning the versions of some of those internal SciML packages should help?

It should.

> [@yhchang96](#):
>
> `SciMLBase` and `DiffEqBase`?

SciMLBase and DiffEqBase should be all that’s required for the interface types, though the solution can hold the algorithm type so in theory if an algorithm struct changed you would need to pin the solver too.

---

<div class="post-metadata">

### Author: ![yhchang96](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/yhchang96/32/36499_2.png) [@yhchang96](https://discourse.julialang.org/u/yhchang96)
#### Post date: [December 2, 2023, 12:47am UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/12 "2023-12-02T00:47:11Z")

</div>

Aren’t the algorithm type defined within `OrdinaryDiffEq`? For me specifically it’s `FBDF`, `QNDF`, `QBDF` that matter.

---

<div class="post-metadata">

### Author: ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)
#### Post date: [December 2, 2023, 12:49am UTC](https://discourse.julialang.org/t/problems-saving-opening-odesolution-from-sciml-with-jld2/106958/13 "2023-12-02T00:49:40Z")

</div>

Yes