Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

[BUG] Cannot install and use Bloqade with a clean Julia installation #605

Closed
mrs504aa opened this issue Oct 20, 2023 · 16 comments
Closed

[BUG] Cannot install and use Bloqade with a clean Julia installation #605

mrs504aa opened this issue Oct 20, 2023 · 16 comments
Labels
bug Something isn't working

Comments

@mrs504aa
Copy link

Describe the bug
Cannot install and use Bloqade.jl with a clean Julia 1.9 installation.

To Reproduce

               _
   _       _ _(_)_     |  Documentation: https://docs.julialang.org
  (_)     | (_) (_)    |
   _ _   _| |_  __ _   |  Type "?" for help, "]?" for Pkg help.
  | | | | | | |/ _` |  |
  | | |_| | | | (_| |  |  Version 1.9.0 (2023-05-07)
 _/ |\__'_|_|_|\__'_|  |  Official https://julialang.org/ release
|__/                   |

(@v1.9) pkg> add Bloqade#master

(@v1.9) pkg> precompile Bloqade
Precompiling Bloqade
  ✗ Measurements → MeasurementsJunoExt
  ✗ Bloqade
  0 dependencies successfully precompiled in 24 seconds. 292 already precompiled.

ERROR: The following 1 direct dependency failed to precompile:

Bloqade [bd27d05e-4ce1-5e79-84dd-c5d7d508bbe1]

Failed to precompile Bloqade [bd27d05e-4ce1-5e79-84dd-c5d7d508bbe1] to "/home/mrs504aa/.julia/compiled/v1.9/Bloqade/jl_nK2Pkk".
ERROR: LoadError: UndefVarError: `measure` not defined
Stacktrace:
 [1] top-level scope
   @ ~/.julia/packages/Measurements/hcRfF/ext/MeasurementsJunoExt.jl:32
 [2] include
   @ ./Base.jl:457 [inlined]
 [3] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String)
   @ Base ./loading.jl:2010
 [4] top-level scope
   @ stdin:2
in expression starting at /home/mrs504aa/.julia/packages/Measurements/hcRfF/ext/MeasurementsJunoExt.jl:19
in expression starting at stdin:2
┌ Error: Error during loading of extension MeasurementsJunoExt of Measurements, use `Base.retry_load_extensions()` to retry.
│   exception =
│    1-element ExceptionStack:
│    Failed to precompile MeasurementsJunoExt [aa3a5f68-a9a9-5515-b92b-e1de3a6bc6b9] to "/home/mrs504aa/.julia/compiled/v1.9/MeasurementsJunoExt/jl_JNtvJa".
│    Stacktrace:
│      [1] error(s::String)
│        @ Base ./error.jl:35
│      [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
│        @ Base ./loading.jl:2260
│      [3] compilecache
│        @ ./loading.jl:2127 [inlined]
│      [4] _require(pkg::Base.PkgId, env::Nothing)
│        @ Base ./loading.jl:1770
│      [5] _require_prelocked(uuidkey::Base.PkgId, env::Nothing)
│        @ Base ./loading.jl:1625
│      [6] _require_prelocked(uuidkey::Base.PkgId)
│        @ Base ./loading.jl:1623
│      [7] run_extension_callbacks(extid::Base.ExtensionId)
│        @ Base ./loading.jl:1198
│      [8] run_extension_callbacks(pkgid::Base.PkgId)
│        @ Base ./loading.jl:1255
│      [9] run_package_callbacks(modkey::Base.PkgId)
│        @ Base ./loading.jl:1083
│     [10] _require_prelocked(uuidkey::Base.PkgId, env::String)
│        @ Base ./loading.jl:1632
│     [11] macro expansion
│        @ ./loading.jl:1613 [inlined]
│     [12] macro expansion
│        @ ./lock.jl:267 [inlined]
│     [13] require(into::Module, mod::Symbol)
│        @ Base ./loading.jl:1576
│     [14] include
│        @ ./Base.jl:457 [inlined]
│     [15] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
│        @ Base ./loading.jl:2010
│     [16] top-level scope
│        @ stdin:2
│     [17] eval
│        @ ./boot.jl:370 [inlined]
│     [18] include_string(mapexpr::typeof(identity), mod::Module, code::String, filename::String)
│        @ Base ./loading.jl:1864
│     [19] include_string
│        @ ./loading.jl:1874 [inlined]
│     [20] exec_options(opts::Base.JLOptions)
│        @ Base ./client.jl:305
│     [21] _start()
│        @ Base ./client.jl:522
└ @ Base loading.jl:1204
ERROR: LoadError: MethodError: no method matching OrdinaryDiffEq.DEOptions{Float64, Float64, Float64, Float64, OrdinaryDiffEq.PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, SciMLBase.CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, Nothing, Int64, Tuple{}, Tuple{}, Tuple{}}(::Int64, ::Bool, ::Bool, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::OrdinaryDiffEq.PIController{Rational{Int64}}, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::typeof(LinearAlgebra.opnorm), ::Nothing, ::DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, ::DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, ::DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Nothing, ::Bool, ::Int64, ::String, ::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Nothing, ::SciMLBase.CallbackSet{Tuple{}, Tuple{}}, ::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), ::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool)

Closest candidates are:
  (::Type{OrdinaryDiffEq.DEOptions{absType, relType, QT, tType, Controller, F1, F2, F3, F4, F5, F6, F7, tstopsType, discType, ECType, SType, MI, tcache, savecache, disccache}} where {absType, relType, QT, tType, Controller, F1, F2, F3, F4, F5, F6, F7, tstopsType, discType, ECType, SType, MI, tcache, savecache, disccache})(::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any)
   @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/yppG9/src/integrators/type.jl:4

Stacktrace:
  [1] __init(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, alg::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, timeseries_init::Tuple{}, ts_init::Tuple{}, ks_init::Tuple{}, recompile::Type{Val{true}}; saveat::Tuple{}, tstops::Tuple{}, d_discontinuities::Tuple{}, save_idxs::Nothing, save_everystep::Bool, save_on::Bool, save_start::Bool, save_end::Nothing, callback::Nothing, dense::Bool, calck::Bool, dt::Float64, dtmin::Nothing, dtmax::Float64, force_dtmin::Bool, adaptive::Bool, gamma::Rational{Int64}, abstol::Float64, reltol::Float64, qmin::Rational{Int64}, qmax::Int64, qsteady_min::Int64, qsteady_max::Int64, beta1::Nothing, beta2::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, maxiters::Int64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), internalopnorm::typeof(LinearAlgebra.opnorm), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, timeseries_errors::Bool, dense_errors::Bool, advance_to_tstop::Bool, stop_at_next_tstop::Bool, initialize_save::Bool, progress::Bool, progress_steps::Int64, progress_name::String, progress_message::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), userdata::Nothing, allow_extrapolation::Bool, initialize_integrator::Bool, initializealg::OrdinaryDiffEq.DefaultInit, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/integrator_init.jl:367
  [2] __solve(::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, ::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; kwargs::Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/yppG9/src/solve.jl:5
  [3] solve_call(_prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; merge_callbacks::Bool, kwargshandle::DiffEqBase.KeywordArgError, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:559
  [4] solve_call(_prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:529
  [5] solve_up(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, sensealg::Nothing, u0::Vector{ComplexF64}, p::Nothing, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:1020
  [6] solve_up(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, sensealg::Nothing, u0::Vector{ComplexF64}, p::Nothing, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:993
  [7] solve(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; sensealg::Nothing, initial_state::Nothing, kw::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/problem.jl:180
  [8] solve(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/problem.jl:167
  [9] emulate!(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/problem.jl:186
 [10] top-level scope
    @ ~/.julia/packages/Bloqade/dIoJN/src/precompile.jl:18
 [11] include(mod::Module, _path::String)
    @ Base ./Base.jl:457
 [12] include(x::String)
    @ Bloqade ~/.julia/packages/Bloqade/dIoJN/src/Bloqade.jl:1
 [13] top-level scope
    @ ~/.julia/packages/Bloqade/dIoJN/src/Bloqade.jl:58
 [14] include
    @ ./Base.jl:457 [inlined]
 [15] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:2010
 [16] top-level scope
    @ stdin:2
in expression starting at /home/mrs504aa/.julia/packages/Bloqade/dIoJN/src/precompile.jl:1
in expression starting at /home/mrs504aa/.julia/packages/Bloqade/dIoJN/src/Bloqade.jl:1
in expression starting at stdin:2

Expected behavior
All packages precompiled successfully.

Screenshots
image

Version Info

  • Julia version
mrs504aa@MRS504AA-LAPTOP:~$ julia --version
julia version 1.9.0
  • Package Version (use Pkg.status() to see the version of your current environment)
(@v1.9) pkg> status
Status `~/.julia/environments/v1.9/Project.toml` (empty project)
  • System information
mrs504aa@MRS504AA-LAPTOP:~$ neofetch
       _,met$$$$$gg.          mrs504aa@MRS504AA-LAPTOP
    ,g$$$$$$$$$$$$$$$P.       ------------------------
  ,g$$P"     """Y$$.".        OS: Debian GNU/Linux 11 (bullseye) on Windows 10 x86_64
 ,$$P'              `$$$.     Kernel: 5.15.123.1-microsoft-standard-WSL2
',$$P       ,ggs.     `$$b:   Uptime: 44 mins
`d$$'     ,$P"'   .    $$$    Packages: 639 (dpkg)
 $$P      d$'     ,    $$P    Shell: bash 5.1.4
 $$:      $$.   -    ,d$$'    Terminal: Windows Terminal
 $$;      Y$b._   _,d$P'      CPU: AMD Ryzen 7 5800H with Radeon Graphics (16) @ 3.193GHz
 Y$$.    `.`"Y$$$$P"'         Memory: 389MiB / 19682MiB

Additional context
This bug also happens on Windows 11 with Julia 1.9.2 and 1.9.3.
@mrs504aa mrs504aa added the bug Something isn't working label Oct 20, 2023
@johnzl-777
Copy link
Collaborator

Hi @mrs504aa ,thanks for bringing this to our attention! This has been an issue we've been seeing across the board and seems to come from Measurements.jl. The quickest way to fix this is to clone Measurements.jl and then dev it into your environment. You'll have to edit ext/MeasurementsJunoExt.jl to fix this line of code (line 32):

Juno.Row(measure.val, Text(" ± "), measure.err)

You just have to turn it into the following:

Juno.Row(measure) = 
Juno.Row(measure.val, Text(" ± "), measure.err)

I'll file a bug report on the Measurements.jl side of things to have this corrected.

@johnzl-777
Copy link
Collaborator

Here's the bug report

@mrs504aa
Copy link
Author

Thanks. I tried your solution and successfully fixed the problem about Measurements.jl.
But still, there is one more problem I believe which is caused by Bloqade.jl itself or OrdinaryDiffEq.jl.

(@v1.9) pkg> precompile Bloqade
Precompiling Bloqade
  ✗ Bloqade
  0 dependencies successfully precompiled in 18 seconds. 293 already precompiled.

ERROR: The following 1 direct dependency failed to precompile:

Bloqade [bd27d05e-4ce1-5e79-84dd-c5d7d508bbe1]

Failed to precompile Bloqade [bd27d05e-4ce1-5e79-84dd-c5d7d508bbe1] to "/home/mrs504aa/.julia/compiled/v1.9/Bloqade/jl_xAlU4A".
ERROR: LoadError: MethodError: no method matching OrdinaryDiffEq.DEOptions{Float64, Float64, Float64, Float64, OrdinaryDiffEq.PIController{Rational{Int64}}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Nothing, SciMLBase.CallbackSet{Tuple{}, Tuple{}}, typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, Nothing, Nothing, Int64, Tuple{}, Tuple{}, Tuple{}}(::Int64, ::Bool, ::Bool, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::Float64, ::OrdinaryDiffEq.PIController{Rational{Int64}}, ::typeof(DiffEqBase.ODE_DEFAULT_NORM), ::typeof(LinearAlgebra.opnorm), ::Nothing, ::DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, ::DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, ::DataStructures.BinaryHeap{Float64, DataStructures.FasterForward}, ::Tuple{}, ::Tuple{}, ::Tuple{}, ::Nothing, ::Bool, ::Int64, ::String, ::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Bool, ::Nothing, ::SciMLBase.CallbackSet{Tuple{}, Tuple{}}, ::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), ::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), ::Bool, ::Bool, ::Bool, ::Bool, ::Bool)

Closest candidates are:
  (::Type{OrdinaryDiffEq.DEOptions{absType, relType, QT, tType, Controller, F1, F2, F3, F4, F5, F6, F7, tstopsType, discType, ECType, SType, MI, tcache, savecache, disccache}} where {absType, relType, QT, tType, Controller, F1, F2, F3, F4, F5, F6, F7, tstopsType, discType, ECType, SType, MI, tcache, savecache, disccache})(::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any, ::Any)
   @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/yppG9/src/integrators/type.jl:4

Stacktrace:
  [1] __init(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, alg::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, timeseries_init::Tuple{}, ts_init::Tuple{}, ks_init::Tuple{}, recompile::Type{Val{true}}; saveat::Tuple{}, tstops::Tuple{}, d_discontinuities::Tuple{}, save_idxs::Nothing, save_everystep::Bool, save_on::Bool, save_start::Bool, save_end::Nothing, callback::Nothing, dense::Bool, calck::Bool, dt::Float64, dtmin::Nothing, dtmax::Float64, force_dtmin::Bool, adaptive::Bool, gamma::Rational{Int64}, abstol::Float64, reltol::Float64, qmin::Rational{Int64}, qmax::Int64, qsteady_min::Int64, qsteady_max::Int64, beta1::Nothing, beta2::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, maxiters::Int64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), internalopnorm::typeof(LinearAlgebra.opnorm), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, timeseries_errors::Bool, dense_errors::Bool, advance_to_tstop::Bool, stop_at_next_tstop::Bool, initialize_save::Bool, progress::Bool, progress_steps::Int64, progress_name::String, progress_message::typeof(DiffEqBase.ODE_DEFAULT_PROG_MESSAGE), userdata::Nothing, allow_extrapolation::Bool, initialize_integrator::Bool, initializealg::OrdinaryDiffEq.DefaultInit, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/integrator_init.jl:367
  [2] __solve(::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, ::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; kwargs::Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}})
    @ OrdinaryDiffEq ~/.julia/packages/OrdinaryDiffEq/yppG9/src/solve.jl:5
  [3] solve_call(_prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; merge_callbacks::Bool, kwargshandle::DiffEqBase.KeywordArgError, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:559
  [4] solve_call(_prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:529
  [5] solve_up(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, sensealg::Nothing, u0::Vector{ComplexF64}, p::Nothing, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:1020
  [6] solve_up(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, sensealg::Nothing, u0::Vector{ComplexF64}, p::Nothing, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False})
    @ DiffEqBase ~/.julia/packages/DiffEqBase/s433k/src/solve.jl:993
  [7] solve(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}; sensealg::Nothing, initial_state::Nothing, kw::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/problem.jl:180
  [8] solve(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}}, args::OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/problem.jl:167
  [9] emulate!(prob::BloqadeODE.SchrodingerProblem{YaoArrayRegister.ArrayReg{2, ComplexF64, Matrix{ComplexF64}}, SciMLBase.ODEFunction{true, SciMLBase.FullSpecialize, BloqadeODE.SchrodingerEquation{BloqadeExpr.RydbergHamiltonian, BloqadeExpr.Hamiltonian{Tuple{BloqadeExpr.DivByTwo{BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}}, BloqadeWaveforms.Waveform{BloqadeWaveforms.PiecewiseLinear{Float64, Interpolations.Extrapolation{Float64, 1, Interpolations.GriddedInterpolation{Float64, 1, Float64, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Tuple{Vector{Float64}}}, Interpolations.Gridded{Interpolations.Linear{Interpolations.Throw{Interpolations.OnGrid}}}, Interpolations.Throw{Nothing}}}, Float64}, typeof(one)}, Tuple{SparseArrays.SparseMatrixCSC{Float64, Int64}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}, LinearAlgebra.Diagonal{Float64, Vector{Float64}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing}, Vector{ComplexF64}, Tuple{Float64, Float64}, OrdinaryDiffEq.DP8{typeof(OrdinaryDiffEq.trivial_limiter!), typeof(OrdinaryDiffEq.trivial_limiter!), Static.False}, Base.Pairs{Symbol, Real, NTuple{6, Symbol}, NamedTuple{(:save_everystep, :save_start, :save_on, :dense, :reltol, :abstol), Tuple{Bool, Bool, Bool, Bool, Float64, Float64}}}})
    @ BloqadeODE ~/.julia/packages/BloqadeODE/nQ7Qt/src/problem.jl:186
 [10] top-level scope
    @ ~/.julia/packages/Bloqade/x2Sfq/src/precompile.jl:18
 [11] include(mod::Module, _path::String)
    @ Base ./Base.jl:457
 [12] include(x::String)
    @ Bloqade ~/.julia/packages/Bloqade/x2Sfq/src/Bloqade.jl:1
 [13] top-level scope
    @ ~/.julia/packages/Bloqade/x2Sfq/src/Bloqade.jl:58
 [14] include
    @ ./Base.jl:457 [inlined]
 [15] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base ./loading.jl:2010
 [16] top-level scope
    @ stdin:2
in expression starting at /home/mrs504aa/.julia/packages/Bloqade/x2Sfq/src/precompile.jl:1
in expression starting at /home/mrs504aa/.julia/packages/Bloqade/x2Sfq/src/Bloqade.jl:1
in expression starting at stdin:2

@mrs504aa
Copy link
Author

mrs504aa commented Oct 23, 2023 •
edited
Loading

I checked source code of BloqadeODE and OrdinaryDiffEq.jl and found that in BloqadeODE/src/integrator_init.jl when constructing DEOptions, something called progress_id::Symbol is missing, which is required in OrdinaryDiffEq/src/integrators/type.jl.

Corresponding changelog
#SciML/OrdinaryDiffEq.jl@5a66c02

I hope this information helps.

@johnzl-777
Copy link
Collaborator

Thank you for your debugging work!

From what I've found if you bump the version of OrdinaryDiffEq to 6.57 (down one minor version), this issue seems to go away.

mrs504aa referenced this issue in SciML/OrdinaryDiffEq.jl Oct 24, 2023
log progress with configurable ID
5a66c02
@ChrisRackauckas
Copy link

Okay I see, you were relying on an internal function. Usually not a good idea 😅 . I can add a downstream test so you could be notified earlier, though note that DEOptions is an undocumented internal. We do have plans to surface a global options type but as of right now that is not the case.

@aarontrowbridge
Copy link

what's the status of this issue? I'm running into it atm.

@johnzl-777
Copy link
Collaborator

Hi @aarontrowbridge I'd just follow the advice I gave earlier and bump OrdinaryDiffEq down to 6.57.

I plan on restricting the version in the package compat until we either move away from the reliance on the internal function or find a way to stably support the higher versions of OrdinaryDiffEq.

@ChrisRackauckas
Copy link

Out of curiosity, what's requiring the direct construction of the DEOptions object? I don't know of any other usage of OrdinaryDiffEq that's doing that, and the docs don't mention or require it, so I'm a bit confused how this is coming up.

@johnzl-777
Copy link
Collaborator

I think @Roger-luo has a better idea of why?

@Roger-luo
Copy link
Member

I left some comments when I added this (I don't remember why myself after all this long)

https://github.com/QuEraComputing/Bloqade.jl/blob/master/lib/BloqadeODE/src/integrator_init.jl#L1

so IIRC, I had a gripe on slack about this function back in the day and decided to go ahead and insert some custom logic into the initialization. But the refactor never proceeded since then.

@ChrisRackauckas
Copy link

This is quite odd 😅. I'd be happy to have an issue opened about anything to improve in init, but I don't quite get the logic here.

1. we need to let integrator modify our own preallocated state member instead of u0

3. kwargs alias_du0 and alias_u0 are removed, since we don't need them anymore

The purpose of alias_u0 is to use u0 as the preallocated state member, so this modification doesn't seem necessary.

2. we need to get rid of the interpolation

That could be made into an option.

We'd be happy to make these modifications so that you don't need to try and keep this function 1-1 with what's in the library.

@Roger-luo
Copy link
Member

I don't remember the exact reason, but it's likely something try and fail and work... We are not pursuing extreme performance anymore so this could be removed and use the default ones.

That could be made into an option.

I think I chatted with Yingbo about this a while ago, none of us had the bandwidth working on refactoring that init function, which is why I went for the quick dirty solution for the time being. So if someone can help getting rid of this that would be great!

@rgarcia-moodys
Copy link

Hello, I am facing similar problems when doing a clean installation of Bloqade as of today. Here is the report:

Describe the bug
Cannot install and use Bloqade.jl with in a new Julia environment
Operating system: Windows 10
Julia: Version 1.9.3
Bloqade v0.1.24

To reproduce

pkg> precompile Bloqade
Precompiling Bloqade
  ✗ SimpleNonlinearSolve
  ✗ NonlinearSolve
  ✗ OrdinaryDiffEq
  ✗ BloqadeODE
  ✗ Bloqade
  0 dependencies successfully precompiled in 52 seconds. 291 already precompiled.

ERROR: The following 1 direct dependency failed to precompile:

Bloqade [bd27d05e-4ce1-5e79-84dd-c5d7d508bbe1]

Failed to precompile Bloqade [bd27d05e-4ce1-5e79-84dd-c5d7d508bbe1] to "C:\\Users\\garciar\\.julia\\compiled\\v1.9\\Bloqade\\jl_690C.tmp".      
ERROR: LoadError: UndefVarError: `NonlinearLeastSquaresProblem` not defined
Stacktrace:
 [1] top-level scope
   @ C:\Users\garciar\.julia\packages\SimpleNonlinearSolve\nusbP\src\raphson.jl:66
 [2] include(mod::Module, _path::String)
   @ Base .\Base.jl:457
 [3] include(x::String)
   @ SimpleNonlinearSolve C:\Users\garciar\.julia\packages\SimpleNonlinearSolve\nusbP\src\SimpleNonlinearSolve.jl:1
 [4] top-level scope
   @ C:\Users\garciar\.julia\packages\SimpleNonlinearSolve\nusbP\src\SimpleNonlinearSolve.jl:30
 [5] include
   @ .\Base.jl:457 [inlined]
 [6] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String)
   @ Base .\loading.jl:2049
 [7] top-level scope
   @ stdin:3
in expression starting at C:\Users\garciar\.julia\packages\SimpleNonlinearSolve\nusbP\src\raphson.jl:66
in expression starting at C:\Users\garciar\.julia\packages\SimpleNonlinearSolve\nusbP\src\SimpleNonlinearSolve.jl:1
in expression starting at stdin:3
ERROR: LoadError: Failed to precompile SimpleNonlinearSolve [727e6d20-b764-4bd8-a329-72de5adea6c7] to "C:\\Users\\garciar\\.julia\\compiled\\v1.9\\SimpleNonlinearSolve\\jl_952A.tmp".
Stacktrace:
  [1] error(s::String)
    @ Base .\error.jl:35
  [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
    @ Base .\loading.jl:2300
  [3] compilecache
    @ .\loading.jl:2167 [inlined]
  [4] _require(pkg::Base.PkgId, env::String)
    @ Base .\loading.jl:1805
  [5] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base .\loading.jl:1660
  [6] macro expansion
    @ .\loading.jl:1648 [inlined]
  [7] macro expansion
    @ .\lock.jl:267 [inlined]
  [8] require(into::Module, mod::Symbol)
    @ Base .\loading.jl:1611
  [9] include
    @ .\Base.jl:457 [inlined]
 [10] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String)
    @ Base .\loading.jl:2049
 [11] top-level scope
    @ stdin:3
in expression starting at C:\Users\garciar4\.julia\packages\OrdinaryDiffEq\JJd6g\src\OrdinaryDiffEq.jl:1
in expression starting at stdin:3
ERROR: LoadError: Failed to precompile OrdinaryDiffEq [1dea7af3-3e70-54e6-95c3-0bf5283fa5ed] to "C:\\Users\\garciar\\.julia\\compiled\\v1.9\\OrdinaryDiffEq\\jl_87EB.tmp".
Stacktrace:
  [1] error(s::String)
    @ Base .\error.jl:35
  [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
    @ Base .\loading.jl:2300
  [3] compilecache
    @ .\loading.jl:2167 [inlined]
  [4] _require(pkg::Base.PkgId, env::String)
    @ Base .\loading.jl:1805
  [5] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base .\loading.jl:1660
  [6] macro expansion
    @ .\loading.jl:1648 [inlined]
  [7] macro expansion
    @ .\lock.jl:267 [inlined]
  [8] require(into::Module, mod::Symbol)
    @ Base .\loading.jl:1611
  [9] include
    @ .\Base.jl:457 [inlined]
 [10] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::String)
    @ Base .\loading.jl:2049
 [11] top-level scope
    @ stdin:3
in expression starting at C:\Users\garciar4\.julia\packages\BloqadeODE\nQ7Qt\src\BloqadeODE.jl:1
in expression starting at stdin:3
ERROR: LoadError: Failed to precompile BloqadeODE [bd27d05e-4ce1-5e79-84dd-c5d7d508bbe5] to "C:\\Users\\garciar\\.julia\\compiled\\v1.9\\BloqadeODE\\jl_7722.tmp".
Stacktrace:
  [1] error(s::String)
    @ Base .\error.jl:35
  [2] compilecache(pkg::Base.PkgId, path::String, internal_stderr::IO, internal_stdout::IO, keep_loaded_modules::Bool)
    @ Base .\loading.jl:2300
  [3] compilecache
    @ .\loading.jl:2167 [inlined]
  [4] _require(pkg::Base.PkgId, env::String)
    @ Base .\loading.jl:1805
  [5] _require_prelocked(uuidkey::Base.PkgId, env::String)
    @ Base .\loading.jl:1660
  [6] macro expansion
    @ .\loading.jl:1648 [inlined]
  [7] macro expansion
    @ .\lock.jl:267 [inlined]
  [8] require(into::Module, mod::Symbol)
    @ Base .\loading.jl:1611
  [9] include
    @ .\Base.jl:457 [inlined]
 [10] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt128}}, source::Nothing)
    @ Base .\loading.jl:2049
 [11] top-level scope
    @ stdin:3
in expression starting at C:\Users\garciar\.julia\packages\Bloqade\gpndc\src\Bloqade.jl:1
in expression starting at stdin:3

I have not tried fixing Measurements.jl or downgrading OrdinaryDiffEq as I am not sure this could the root of the problem.

@mrs504aa
Copy link
Author

mrs504aa commented Nov 6, 2023

Hi @rgarcia-moodys. I met the same problem this morning. I solved this problem by bumping SimpleNonlinearSolve down to v0.1.23. But I don't know what is wrong.

@ryanhill1 ryanhill1 mentioned this issue Nov 10, 2023
Closed
@mrs504aa
Copy link
Author

It seems that v0.2.1 has fixed these issues and this package works on julia 1.10.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Assignees
No one assigned
Labels
bug Something isn't working
Projects
None yet
Milestone
No milestone
Development

No branches or pull requests
6 participants
@ChrisRackauckas @Roger-luo @mrs504aa @johnzl-777 @aarontrowbridge @rgarcia-moodys