From 571abc9a885f5eb30c32ce3739fa5380e8277c7a Mon Sep 17 00:00:00 2001 From: Gavin Date: Sun, 30 Nov 2025 22:25:09 +0000 Subject: [PATCH 01/20] made most of the changes. Look at testing.ipynb ##Testing Solver Extensions for examples. --- .gitignore | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index b07886a94..d001e0f77 100644 --- a/.gitignore +++ b/.gitignore @@ -10,4 +10,5 @@ Manifest.toml benchmarks/benchmarks_output.json .ipynb_checkpoints -*.ipynb \ No newline at end of file +*.ipynb +.devcontainer/* From 9665194980930474214646e63211aea4d51e3544 Mon Sep 17 00:00:00 2001 From: Gavin Date: Sun, 30 Nov 2025 22:26:13 +0000 Subject: [PATCH 02/20] Added operator support. Look at testing.ipynb ##Testing Solver Extensions for usage. --- .gitignore | 1 - src/qobj/functions.jl | 2 + .../mcsolve_callback_helpers.jl | 2 +- src/time_evolution/mcsolve.jl | 23 +- src/time_evolution/mesolve.jl | 72 +- src/time_evolution/sesolve.jl | 37 +- src/time_evolution/smesolve.jl | 2 +- src/time_evolution/ssesolve.jl | 15 +- src/time_evolution/time_evolution.jl | 5 +- testing.ipynb | 1075 +++++++++++++++++ 10 files changed, 1172 insertions(+), 62 deletions(-) create mode 100644 testing.ipynb diff --git a/.gitignore b/.gitignore index d001e0f77..332d6969b 100644 --- a/.gitignore +++ b/.gitignore @@ -10,5 +10,4 @@ Manifest.toml benchmarks/benchmarks_output.json .ipynb_checkpoints -*.ipynb .devcontainer/* diff --git a/src/qobj/functions.jl b/src/qobj/functions.jl index 1d2cf5689..219bd5854 100644 --- a/src/qobj/functions.jl +++ b/src/qobj/functions.jl @@ -119,10 +119,12 @@ Converts a sparse QuantumObject to a dense QuantumObject. to_dense(A::QuantumObject) = QuantumObject(to_dense(A.data), A.type, A.dimensions) to_dense(A::MT) where {MT<:AbstractSparseArray} = Array(A) to_dense(A::MT) where {MT<:AbstractArray} = A +to_dense(A::Diagonal) = diagm(A.diag) to_dense(::Type{T}, A::AbstractSparseArray) where {T<:Number} = Array{T}(A) to_dense(::Type{T1}, A::AbstractArray{T2}) where {T1<:Number,T2<:Number} = Array{T1}(A) to_dense(::Type{T}, A::AbstractArray{T}) where {T<:Number} = A +to_dense(::Type{T}, A::Diagonal{T}) where {T<:Number} = diagm(A.diag) function to_dense(::Type{M}) where {M<:Union{Diagonal,SparseMatrixCSC}} T = M diff --git a/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl b/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl index e7c9837cc..499140fff 100644 --- a/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl +++ b/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl @@ -18,7 +18,7 @@ struct LindbladJump{ T2, RNGType<:AbstractRNG, RandT, - CT<:AbstractVector, + CT<:AbstractArray, WT<:AbstractVector, JTT<:AbstractVector, JWT<:AbstractVector, diff --git a/src/time_evolution/mcsolve.jl b/src/time_evolution/mcsolve.jl index 8630810c7..5dbf84be4 100644 --- a/src/time_evolution/mcsolve.jl +++ b/src/time_evolution/mcsolve.jl @@ -20,9 +20,9 @@ function _mcsolve_output_func(sol, i) return (sol, false) end -function _normalize_state!(u, dims, normalize_states) +function _normalize_state!(u, dims, normalize_states, type) getVal(normalize_states) && normalize!(u) - return QuantumObject(u, Ket(), dims) + return QuantumObject(u, type(), dims) end function _mcsolve_make_Heff_QobjEvo(H::QuantumObject, c_ops) @@ -110,7 +110,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -118,7 +118,7 @@ function mcsolveProblem( rng::AbstractRNG = default_rng(), jump_callback::TJC = ContinuousLindbladJumpCallback(), kwargs..., -) where {TJC<:LindbladJumpCallbackType} +) where {TJC<:LindbladJumpCallbackType,X<:Union{Ket,Operator}} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -221,7 +221,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolveEnsembleProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -234,7 +234,7 @@ function mcsolveEnsembleProblem( prob_func::Union{Function,Nothing} = nothing, output_func::Union{Tuple,Nothing} = nothing, kwargs..., -) where {TJC<:LindbladJumpCallbackType} +) where {TJC<:LindbladJumpCallbackType,X<:Union{Ket,Operator}} _prob_func = isnothing(prob_func) ? _ensemble_dispatch_prob_func(rng, ntraj, tlist, _mcsolve_prob_func) : prob_func _output_func = output_func isa Nothing ? @@ -261,6 +261,7 @@ function mcsolveEnsembleProblem( ensemble_prob = TimeEvolutionProblem( EnsembleProblem(prob_mc.prob, prob_func = _prob_func, output_func = _output_func[1], safetycopy = false), prob_mc.times, + X, prob_mc.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) @@ -358,7 +359,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; alg::AbstractODEAlgorithm = DP5(), @@ -374,7 +375,7 @@ function mcsolve( keep_runs_results::Union{Val,Bool} = Val(false), normalize_states::Union{Val,Bool} = Val(true), kwargs..., -) where {TJC<:LindbladJumpCallbackType} +) where {TJC<:LindbladJumpCallbackType} where {X<:Union{Ket,Operator}} ens_prob_mc = mcsolveEnsembleProblem( H, ψ0, @@ -415,7 +416,11 @@ function mcsolve( expvals_all = _expvals_all isa Nothing ? nothing : stack(_expvals_all, dims = 2) # Stack on dimension 2 to align with QuTiP # stack to transform Vector{Vector{QuantumObject}} -> Matrix{QuantumObject} - states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states), eachindex(sol)), dims = 1) + # states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states), eachindex(sol)), dims = 1) + states_all = stack( + map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states, ens_prob_mc.states_type), eachindex(sol)), + dims = 1, + ) col_times = map(i -> _mc_get_jump_callback(sol[:, i]).affect!.col_times, eachindex(sol)) col_which = map(i -> _mc_get_jump_callback(sol[:, i]).affect!.col_which, eachindex(sol)) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index b9aee6595..2f2eef109 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -6,17 +6,17 @@ _mesolve_make_L_QobjEvo(H::Union{QuantumObjectEvolution,Tuple}, c_ops) = liouvil _mesolve_make_L_QobjEvo(H::Nothing, c_ops::Nothing) = throw(ArgumentError("Both H and c_ops are Nothing. You are probably running the wrong function.")) -function _gen_mesolve_solution(sol, times, dimensions, isoperket::Val) - if getVal(isoperket) - ρt = map(ϕ -> QuantumObject(ϕ, type = OperatorKet(), dims = dimensions), sol.u) +function _gen_mesolve_solution(sol, prob::TimeEvolutionProblem{X}) where {X<:Union{Operator,OperatorKet,SuperOperator}} + if X() == Operator() + ρt = map(ϕ -> QuantumObject(vec2mat(ϕ), type = X(), dims = prob.dimensions), sol.u) else - ρt = map(ϕ -> QuantumObject(vec2mat(ϕ), type = Operator(), dims = dimensions), sol.u) + ρt = map(ϕ -> QuantumObject(ϕ, type = X(), dims = prob.dimensions), sol.u) end kwargs = NamedTuple(sol.prob.kwargs) # Convert to NamedTuple for Zygote.jl compatibility return TimeEvolutionSol( - times, + prob.times, sol.t, ρt, _get_expvals(sol, SaveFuncMESolve), @@ -86,8 +86,8 @@ function mesolveProblem( progress_bar::Union{Val,Bool} = Val(true), inplace::Union{Val,Bool} = Val(true), kwargs..., -) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet}} - (isoper(H) && isket(ψ0) && isnothing(c_ops)) && return sesolveProblem( +) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} + (isoper(H) && (isket(ψ0) || isoper(ψ0)) && isnothing(c_ops)) && return sesolveProblem( H, ψ0, tlist; @@ -107,11 +107,27 @@ function mesolveProblem( check_dimensions(L_evo, ψ0) T = Base.promote_eltype(L_evo, ψ0) - ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type - to_dense(_complex_float_type(T), copy(ψ0.data)) + # ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type + # to_dense(_complex_float_type(T), copy(ψ0.data)) + # else + # to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) + # end + if isoper(ψ0) + ρ0 = to_dense(_complex_float_type(T), mat2vec(ψ0.data)) + state_type = Operator() + elseif isoperket(ψ0) + ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) + state_type = OperatorKet() + elseif isket(ψ0) + ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) + state_type = Operator() + elseif issuper(ψ0) + ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) + state_type = SuperOperator() else - to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) + throw(ArgumentError("Unsupported state type for ψ0 in mesolveProblem.")) end + L = cache_operator(L_evo.data, ρ0) kwargs2 = _merge_saveat(tlist, e_ops, DEFAULT_ODE_SOLVER_OPTIONS; kwargs...) @@ -122,7 +138,7 @@ function mesolveProblem( prob = ODEProblem{getVal(inplace),FullSpecialize}(L, ρ0, tspan, params; kwargs4...) - return TimeEvolutionProblem(prob, tlist, L_evo.dimensions, (isoperket = Val(isoperket(ψ0)),)) + return TimeEvolutionProblem(prob, tlist, state_type, L_evo.dimensions)#, (isoperket = Val(isoperket(ψ0)),)) end @doc raw""" @@ -188,8 +204,8 @@ function mesolve( progress_bar::Union{Val,Bool} = Val(true), inplace::Union{Val,Bool} = Val(true), kwargs..., -) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet}} - (isoper(H) && isket(ψ0) && isnothing(c_ops)) && return sesolve( +) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} + (isoper(H) && (isket(ψ0) || isoper(ψ0)) && isnothing(c_ops)) && return sesolve( H, ψ0, tlist; @@ -230,7 +246,7 @@ end function mesolve(prob::TimeEvolutionProblem, alg::AbstractODEAlgorithm = DP5(); kwargs...) sol = solve(prob.prob, alg; kwargs...) - return _gen_mesolve_solution(sol, prob.times, prob.dimensions, prob.kwargs.isoperket) + return _gen_mesolve_solution(sol, prob)#, prob.kwargs.isoperket) end @doc raw""" @@ -298,8 +314,8 @@ function mesolve_map( params::Union{NullParameters,Tuple} = NullParameters(), progress_bar::Union{Val,Bool} = Val(true), kwargs..., -) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet}} - (isoper(H) && all(isket, ψ0) && isnothing(c_ops)) && return sesolve_map( +) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} + (isoper(H) && (all(isket, ψ0) || all(isoper, ψ0)) && isnothing(c_ops)) && return sesolve_map( H, ψ0, tlist; @@ -315,10 +331,16 @@ function mesolve_map( # Convert to appropriate format based on state type ψ0_iter = map(ψ0) do state T = _complex_float_type(eltype(state)) - if isoperket(state) - to_dense(T, copy(state.data)) + if isoper(state) + to_dense(_complex_float_type(T), mat2vec(state.data)) + elseif isoperket(state) + to_dense(_complex_float_type(T), copy(state.data)) + elseif isket(state) + to_dense(_complex_float_type(T), mat2vec(ket2dm(state).data)) + elseif issuper(state) + to_dense(_complex_float_type(T), copy(state.data)) else - to_dense(T, mat2vec(ket2dm(state).data)) + throw(ArgumentError("Unsupported state type for ψ0 in mesolveProblem.")) end end if params isa NullParameters @@ -347,7 +369,7 @@ mesolve_map( tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; kwargs..., -) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet}} = +) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} = mesolve_map(H, [ψ0], tlist, c_ops; kwargs...) # this method is for advanced usage @@ -357,14 +379,14 @@ mesolve_map( # # Return: An array of TimeEvolutionSol objects with the size same as the given iter. function mesolve_map( - prob::TimeEvolutionProblem{<:ODEProblem}, + prob::TimeEvolutionProblem{StateOpType,<:ODEProblem}, iter::AbstractArray, alg::AbstractODEAlgorithm = DP5(), ensemblealg::EnsembleAlgorithm = EnsembleThreads(); prob_func::Union{Function,Nothing} = nothing, output_func::Union{Tuple,Nothing} = nothing, progress_bar::Union{Val,Bool} = Val(true), -) +) where {StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} # generate ensemble problem ntraj = length(iter) _prob_func = isnothing(prob_func) ? (prob, i, repeat) -> _se_me_map_prob_func(prob, i, repeat, iter) : prob_func @@ -380,14 +402,14 @@ function mesolve_map( ens_prob = TimeEvolutionProblem( EnsembleProblem(prob.prob, prob_func = _prob_func, output_func = _output_func[1], safetycopy = false), prob.times, + StateOpType(), prob.dimensions, - (progr = _output_func[2], channel = _output_func[3], isoperket = prob.kwargs.isoperket), + (progr = _output_func[2], channel = _output_func[3]), ) sol = _ensemble_dispatch_solve(ens_prob, alg, ensemblealg, ntraj) # handle solution and make it become an Array of TimeEvolutionSol - sol_vec = - [_gen_mesolve_solution(sol[:, i], prob.times, prob.dimensions, prob.kwargs.isoperket) for i in eachindex(sol)] # map is type unstable + sol_vec = [_gen_mesolve_solution(sol[:, i], prob) for i in eachindex(sol)] # map is type unstable return reshape(sol_vec, size(iter)) end diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index df0b2cd93..343ccde1c 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -2,13 +2,13 @@ export sesolveProblem, sesolve, sesolve_map _sesolve_make_U_QobjEvo(H) = -1im * QuantumObjectEvolution(H, type = Operator()) -function _gen_sesolve_solution(sol, times, dimensions) - ψt = map(ϕ -> QuantumObject(ϕ, type = Ket(), dims = dimensions), sol.u) +function _gen_sesolve_solution(sol, prob::TimeEvolutionProblem{X}) where {X<:Union{Ket,Operator}} + ψt = map(ϕ -> QuantumObject(ϕ, type = X(), dims = prob.dimensions), sol.u) kwargs = NamedTuple(sol.prob.kwargs) # Convert to NamedTuple for Zygote.jl compatibility return TimeEvolutionSol( - times, + prob.times, sol.t, ψt, _get_expvals(sol, SaveFuncSESolve), @@ -61,14 +61,14 @@ Generate the ODEProblem for the Schrödinger time evolution of a quantum system: """ function sesolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, params = NullParameters(), progress_bar::Union{Val,Bool} = Val(true), inplace::Union{Val,Bool} = Val(true), kwargs..., -) +) where {X<:Union{Ket,Operator}} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -90,7 +90,7 @@ function sesolveProblem( prob = ODEProblem{getVal(inplace),FullSpecialize}(U, ψ0, tspan, params; kwargs4...) - return TimeEvolutionProblem(prob, tlist, H_evo.dimensions) + return TimeEvolutionProblem(prob, tlist, X(), H_evo.dimensions) end @doc raw""" @@ -138,7 +138,7 @@ Time evolution of a closed quantum system using the Schrödinger equation: """ function sesolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector; alg::AbstractODEAlgorithm = Vern7(lazy = false), e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -146,7 +146,7 @@ function sesolve( progress_bar::Union{Val,Bool} = Val(true), inplace::Union{Val,Bool} = Val(true), kwargs..., -) +) where {X<:Union{Ket,Operator}} # Move sensealg argument to solve for Enzyme.jl support. # TODO: Remove it when https://github.com/SciML/SciMLSensitivity.jl/issues/1225 is fixed. @@ -175,7 +175,7 @@ end function sesolve(prob::TimeEvolutionProblem, alg::AbstractODEAlgorithm = Vern7(lazy = false); kwargs...) sol = solve(prob.prob, alg; kwargs...) - return _gen_sesolve_solution(sol, prob.times, prob.dimensions) + return _gen_sesolve_solution(sol, prob) end @doc raw""" @@ -225,7 +225,7 @@ for each combination in the ensemble. """ function sesolve_map( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::AbstractVector{<:QuantumObject{Ket}}, + ψ0::AbstractVector{<:QuantumObject{X}}, tlist::AbstractVector; alg::AbstractODEAlgorithm = Vern7(lazy = false), ensemblealg::EnsembleAlgorithm = EnsembleThreads(), @@ -233,7 +233,7 @@ function sesolve_map( params::Union{NullParameters,Tuple} = NullParameters(), progress_bar::Union{Val,Bool} = Val(true), kwargs..., -) +) where {X<:Union{Ket,Operator}} # mapping initial states and parameters ψ0_iter = map(get_data, ψ0) if params isa NullParameters @@ -255,8 +255,12 @@ function sesolve_map( return sesolve_map(prob, iter, alg, ensemblealg; progress_bar = progress_bar) end -sesolve_map(H::Union{AbstractQuantumObject{Operator},Tuple}, ψ0::QuantumObject{Ket}, tlist::AbstractVector; kwargs...) = - sesolve_map(H, [ψ0], tlist; kwargs...) +sesolve_map( + H::Union{AbstractQuantumObject{Operator},Tuple}, + ψ0::QuantumObject{X}, + tlist::AbstractVector; + kwargs..., +) where {X<:Union{Ket,Operator}} = sesolve_map(H, [ψ0], tlist; kwargs...) # this method is for advanced usage # User can define their own iterator structure, prob_func and output_func @@ -265,14 +269,14 @@ sesolve_map(H::Union{AbstractQuantumObject{Operator},Tuple}, ψ0::QuantumObject{ # # Return: An array of TimeEvolutionSol objects with the size same as the given iter. function sesolve_map( - prob::TimeEvolutionProblem{<:ODEProblem}, + prob::TimeEvolutionProblem{X,<:ODEProblem}, iter::AbstractArray, alg::AbstractODEAlgorithm = Vern7(lazy = false), ensemblealg::EnsembleAlgorithm = EnsembleThreads(); prob_func::Union{Function,Nothing} = nothing, output_func::Union{Tuple,Nothing} = nothing, progress_bar::Union{Val,Bool} = Val(true), -) +) where {X<:Union{Ket,Operator}} # generate ensemble problem ntraj = length(iter) _prob_func = isnothing(prob_func) ? (prob, i, repeat) -> _se_me_map_prob_func(prob, i, repeat, iter) : prob_func @@ -288,6 +292,7 @@ function sesolve_map( ens_prob = TimeEvolutionProblem( EnsembleProblem(prob.prob, prob_func = _prob_func, output_func = _output_func[1], safetycopy = false), prob.times, + prob.states_type, prob.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) @@ -295,6 +300,6 @@ function sesolve_map( sol = _ensemble_dispatch_solve(ens_prob, alg, ensemblealg, ntraj) # handle solution and make it become an Array of TimeEvolutionSol - sol_vec = [_gen_sesolve_solution(sol[:, i], prob.times, prob.dimensions) for i in eachindex(sol)] # map is type unstable + sol_vec = [_gen_sesolve_solution(sol[:, i], prob) for i in eachindex(sol)] # map is type unstable return reshape(sol_vec, size(iter)) end diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index 1560de45f..113cfc9df 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -146,7 +146,7 @@ function smesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist, dims, (isoperket = Val(isoperket(ψ0)),)) + return TimeEvolutionProblem(prob, tlist, X(), dims) end @doc raw""" diff --git a/src/time_evolution/ssesolve.jl b/src/time_evolution/ssesolve.jl index df3372858..15dee2d6e 100644 --- a/src/time_evolution/ssesolve.jl +++ b/src/time_evolution/ssesolve.jl @@ -76,7 +76,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is th """ function ssesolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -85,7 +85,7 @@ function ssesolveProblem( progress_bar::Union{Val,Bool} = Val(true), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) +) where {X<:Union{Ket,Operator}} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -142,7 +142,7 @@ function ssesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist, dims) + return TimeEvolutionProblem(prob, tlist, X(), dims) end @doc raw""" @@ -218,7 +218,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is t """ function ssesolveEnsembleProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -231,7 +231,7 @@ function ssesolveEnsembleProblem( progress_bar::Union{Val,Bool} = Val(true), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) +) where {X<:Union{Ket,Operator}} _prob_func = isnothing(prob_func) ? _ensemble_dispatch_prob_func( @@ -268,6 +268,7 @@ function ssesolveEnsembleProblem( ensemble_prob = TimeEvolutionProblem( EnsembleProblem(prob_sme, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), prob_sme.times, + X(), prob_sme.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) @@ -355,7 +356,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is th """ function ssesolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{Ket}, + ψ0::QuantumObject{X}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; alg::Union{Nothing,AbstractSDEAlgorithm} = nothing, @@ -370,7 +371,7 @@ function ssesolve( keep_runs_results::Union{Val,Bool} = Val(false), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) +) where {X<:Union{Ket,Operator}} ens_prob = ssesolveEnsembleProblem( H, ψ0, diff --git a/src/time_evolution/time_evolution.jl b/src/time_evolution/time_evolution.jl index e7c3791d3..1aa375a97 100644 --- a/src/time_evolution/time_evolution.jl +++ b/src/time_evolution/time_evolution.jl @@ -25,9 +25,10 @@ A Julia constructor for handling the `ODEProblem` of the time evolution of quant !!! note "`dims` property" For a given `prob::TimeEvolutionProblem`, `prob.dims` or `getproperty(prob, :dims)` returns its `dimensions` in the type of integer-vector. """ -struct TimeEvolutionProblem{PT<:AbstractSciMLProblem,TT<:AbstractVector,DT<:AbstractDimensions,KWT} +struct TimeEvolutionProblem{ST,PT<:AbstractSciMLProblem,TT<:AbstractVector,DT<:AbstractDimensions,KWT} prob::PT times::TT + states_type::ST dimensions::DT kwargs::KWT end @@ -41,7 +42,7 @@ function Base.getproperty(prob::TimeEvolutionProblem, key::Symbol) end end -TimeEvolutionProblem(prob, times, dims) = TimeEvolutionProblem(prob, times, dims, nothing) +TimeEvolutionProblem(prob, times, states_type, dims) = TimeEvolutionProblem(prob, times, states_type, dims, nothing) @doc raw""" struct TimeEvolutionSol diff --git a/testing.ipynb b/testing.ipynb new file mode 100644 index 000000000..07560459a --- /dev/null +++ b/testing.ipynb @@ -0,0 +1,1075 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "5bbd7370", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `/workspaces/QuantumToolbox.jl`\n", + "\n", + "SYSTEM: caught exception of type :MethodError while trying to print a failed Task notice; giving up\n", + "\n", + "SYSTEM: caught exception of type :MethodError while trying to print a failed Task notice; giving up\n" + ] + } + ], + "source": [ + "using Pkg\n", + "Pkg.activate(\".\")\n", + "using Revise\n", + "using Test\n", + "using InteractiveUtils\n", + "using QuantumToolbox\n", + "using QuantumToolbox: check_dimensions, check_mul_dimensions, get_dimensions_from, get_dimensions_to" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "aafc2649", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " QuantumToolbox.jl: Quantum Toolbox in Julia\n", + "≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡\n", + "Copyright © QuTiP team 2022 and later.\n", + "Current admin team:\n", + " Alberto Mercurio and Yi-Te Huang\n", + "\n", + "Package information:\n", + "====================================\n", + "Julia Ver. 1.12.1\n", + "QuantumToolbox Ver. nothing\n", + "SciMLOperators Ver. 1.13.0\n", + "LinearSolve Ver. 3.47.0\n", + "OrdinaryDiffEqCore Ver. 1.36.0\n", + "\n", + "System information:\n", + "====================================\n", + "OS : Linux (aarch64-linux-gnu)\n", + "CPU : 14 × unknown\n", + "Memory : 7.653 GB\n", + "WORD_SIZE: 64\n", + "LIBM : libopenlibm\n", + "LLVM : libLLVM-18.1.7 (ORCJIT, generic)\n", + "BLAS : libopenblas64_.so (ilp64)\n", + "Threads : 14 (on 14 virtual cores)\n", + "\n", + "+---------------------------------------------------+\n", + "| Please cite QuantumToolbox.jl in your publication |\n", + "+---------------------------------------------------+\n", + "For your convenience, a bibtex reference can be easily generated using `QuantumToolbox.cite()`.\n", + "\n" + ] + } + ], + "source": [ + "QuantumToolbox.versioninfo()\n" + ] + }, + { + "cell_type": "markdown", + "id": "482d1b52", + "metadata": {}, + "source": [ + "## Cat Definitions" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "cd4b2801", + "metadata": {}, + "outputs": [], + "source": [ + "function Base.cat(x::QuantumObject{Ket}...)\n", + " cat(x)\n", + "end\n", + "function Base.cat(x::Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{Ket} where N\n", + " check_dimensions(x)\n", + " to_stack = [x[i].data for i in 1:length(x)]\n", + " stacked_data = hcat(to_stack...)\n", + " new_dims = (x[1].dims, (length(x),))\n", + " return QuantumObject(stacked_data, dims=new_dims)\n", + "end\n", + "\n", + "function Base.cat(x :: QuantumObject{Bra}...)\n", + " cat(x)\n", + "end\n", + "\n", + "function Base.cat(x :: Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{Bra} where N\n", + " check_dimensions(x)\n", + " to_stack = [x[i].data for i in 1:length(x)]\n", + " stacked_data = vcat(to_stack...)\n", + " new_dims = ((length(x),), x[1].dims)\n", + " return QuantumObject(stacked_data, dims=new_dims)\n", + "end\n", + "\n", + "\n", + "\n", + "function Base.cat(x::QuantumObject{OperatorKet}...)\n", + " cat(x)\n", + "end\n", + "function Base.cat(x::Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{OperatorKet} where N\n", + " check_dimensions(x)\n", + " to_stack = [x[i].data for i in 1:length(x)]\n", + " stacked_data = hcat(to_stack...)\n", + " new_dims = (x[1].dims, (length(x),))\n", + " return QuantumObject(stacked_data, dims=new_dims, type=SuperOperator())\n", + "end\n", + "\n", + "function Base.cat(x :: QuantumObject{OperatorBra}...)\n", + " cat(x)\n", + "end\n", + "\n", + "function Base.cat(x :: Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{OperatorBra} where N\n", + " check_dimensions(x)\n", + " to_stack = [x[i].data for i in 1:length(x)]\n", + " stacked_data = vcat(to_stack...)\n", + " new_dims = ((length(x),), x[1].dims)\n", + " return QuantumObject(stacked_data, dims=new_dims, type=SuperOperator())\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4a6938d8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "Quantum Object: type=Operator() dims=[[3, 2], [2]] size=(6, 2) ishermitian=false\n", + "6×2 Matrix{ComplexF64}:\n", + " 0.0+0.0im 0.0+0.0im\n", + " 1.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 1.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "states = [fock(3,0)⊗fock(2,1), fock(3,1)⊗fock(2,1)];\n", + "a = cat(states...)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "93c6c627", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "Quantum Object: type=Operator() dims=[[3, 2], [2]] size=(6, 2) ishermitian=false\n", + "6×2 Matrix{ComplexF64}:\n", + " 0.0+0.0im 0.0+0.0im\n", + " 1.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 1.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "O = qeye(3)⊗qeye(2);\n", + "O*a" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "0c81591a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "Quantum Object: type=Operator() dims=[[3, 2], [2]] size=(6, 2) ishermitian=false\n", + "6×2 Matrix{ComplexF64}:\n", + " 0.0+0.0im 0.0+0.0im\n", + " 1.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 1.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "check_mul_dimensions(get_dimensions_from(O), get_dimensions_to(a))\n", + "O*a" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "508471b9", + "metadata": {}, + "outputs": [ + { + "ename": "DomainError", + "evalue": "DomainError with (4, 2):\nThe size of the array is not compatible with SuperOperator", + "output_type": "error", + "traceback": [ + "DomainError with (4, 2):\n", + "The size of the array is not compatible with SuperOperator\n", + "\n", + "Stacktrace:\n", + " [1] _check_QuantumObject\n", + " @ /workspaces/QuantumToolbox.jl/src/qobj/quantum_object_base.jl:180 [inlined]\n", + " [2] QuantumObject\n", + " @ /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:59 [inlined]\n", + " [3] QuantumObject(A::Matrix{Float64}; type::SuperOperator, dims::Nothing)\n", + " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:101\n", + " [4] top-level scope\n", + " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X11sdnNjb2RlLXJlbW90ZQ==.jl:1" + ] + } + ], + "source": [ + "Qobj(rand(4,2), type = SuperOperator())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eed4016c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "Quantum Object: type=Operator() dims=[[3], [3]] size=(3, 3) ishermitian=true\n", + "3×3 Matrix{ComplexF64}:\n", + " 1.0-0.0im 0.0-0.0im 0.0-0.0im\n", + " 0.0-0.0im 1.0-0.0im 0.0-0.0im\n", + " 0.0-0.0im 0.0-0.0im 1.0-0.0im" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "states = [fock(3,0)', fock(3,1)', fock(3,2)'];\n", + "b = cat(states...)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0c6143fa", + "metadata": {}, + "outputs": [ + { + "ename": "DomainError", + "evalue": "DomainError with [[3], [3]]:\nThe given `dims` is not compatible with type = SuperOperator(), should be a single list of integers.", + "output_type": "error", + "traceback": [ + "DomainError with [[3], [3]]:\n", + "The given `dims` is not compatible with type = SuperOperator(), should be a single list of integers.\n", + "\n", + "Stacktrace:\n", + " [1] _check_QuantumObject(type::SuperOperator, dimensions::GeneralDimensions{1, 1, Tuple{Space}, Tuple{Space}}, m::Int64, n::Int64)\n", + " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object_base.jl:131\n", + " [2] QuantumObject(data::Matrix{ComplexF64}, type::SuperOperator, dims::Tuple{StaticArraysCore.SVector{1, Int64}, Tuple{Int64}})\n", + " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:59\n", + " [3] QuantumObject(A::Matrix{ComplexF64}; type::SuperOperator, dims::Tuple{StaticArraysCore.SVector{1, Int64}, Tuple{Int64}})\n", + " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:101\n", + " [4] cat(x::Tuple{QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}})\n", + " @ Main /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_W4sdnNjb2RlLXJlbW90ZQ==.jl:34\n", + " [5] cat(::QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, ::QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, ::Vararg{QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}})\n", + " @ Main /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_W4sdnNjb2RlLXJlbW90ZQ==.jl:27\n", + " [6] top-level scope\n", + " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X13sdnNjb2RlLXJlbW90ZQ==.jl:2" + ] + } + ], + "source": [ + "states = [mat2vec(ket2dm(fock(3,0))), mat2vec(ket2dm(fock(3,1))), mat2vec(ket2dm(fock(3,2)))];\n", + "c = cat(states...)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e6c966a8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "check_right_multiplication (generic function with 1 method)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "function check_left_multiplication(A, x)\n", + " A_dims = A.dims[1]\n", + " x_dims = []\n", + " for dim in x.dims[1]\n", + " push!(x_dims, dim)\n", + " end\n", + "\n", + " println(\"A_dims: \", A_dims)\n", + " println(\"x_dims: \", x_dims)\n", + " A_size = size(A)[1]\n", + " x_size = size(x)[1]\n", + " println(\"A_size: \", A_size)\n", + " println(\"x_size: \", x_size)\n", + " return A_dims == x_dims && A_size == x_size\n", + "end\n", + "\n", + "function check_right_multiplication(A, x)\n", + " A_dims = A.dims[1]\n", + " x_dims = []\n", + " for dim in x.dims[1]\n", + " push!(x_dims, dim)\n", + " end\n", + " \n", + " println(\"A_dims: \", A_dims)\n", + " println(\"x_dims: \", x_dims)\n", + " A_size = size(A)[1]\n", + " if length(x.dims) > 1\n", + " x_size = size(x)[2]\n", + " else\n", + " x_size = 1\n", + " end\n", + " println(\"A_size: \", A_size)\n", + " println(\"x_size: \", x_size)\n", + " return A_dims == x_dims && A_size == x_size\n", + "end" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "951d89e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Quantum Object: type=Operator() dims=[[3], [2]] size=(3, 2) ishermitian=false\n", + "3×2 Matrix{ComplexF64}:\n", + " 1.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 1.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im\n" + ] + } + ], + "source": [ + "a = cat(fock(3,0), fock(3,1));\n", + "println(a)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "89da9528", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_dims: [3]\n", + "x_dims: Any[3]\n", + "A_size: 3\n", + "x_size: 1\n" + ] + }, + { + "data": { + "text/plain": [ + "false" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "check_left_multiplication(a, fock(3,1)')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "93c795e7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A_dims: [3]\n", + "x_dims: Any[3]\n", + "A_size: 3\n", + "x_size: 1\n" + ] + }, + { + "data": { + "text/plain": [ + "false" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "check_right_multiplication(a, fock(3,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "13526a28", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "Quantum Object: type=Bra() dims=[2] size=(1, 2)\n", + "1×2 adjoint(::Vector{ComplexF64}) with eltype ComplexF64:\n", + " 0.0-0.0im 1.0-0.0im" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fock(3,1)'*a" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "1c0e2909", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 3)" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "size(a')" + ] + }, + { + "cell_type": "markdown", + "id": "f9c34c65", + "metadata": {}, + "source": [ + "## Testing Solver Extensions" + ] + }, + { + "cell_type": "markdown", + "id": "b67cdac7", + "metadata": {}, + "source": [ + "### Sesolve" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d90f8989", + "metadata": {}, + "outputs": [], + "source": [ + "H = sigmax()\n", + "ψ0 = qeye(2) # <- does not work\n", + "tlist = 0:0.1:10.0\n", + "sol = sesolve(H, ψ0, tlist)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "126d75af", + "metadata": {}, + "outputs": [], + "source": [ + "H = sigmax()\n", + "ψ0 = qeye(2) # <- does not work\n", + "ψ0 = fock(2,1)\n", + "tlist = 0:0.1:10.0\n", + "sol = sesolve_map(H, [ψ0,ψ0], tlist)" + ] + }, + { + "cell_type": "markdown", + "id": "28a4905b", + "metadata": {}, + "source": [ + "### ssesolve" + ] + }, + { + "cell_type": "markdown", + "id": "09acc3ce", + "metadata": {}, + "source": [ + "I made the changes but i need to look at the documentation for an example" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7400fa5d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1-element Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}:\n", + " \n", + "Quantum Object: type=Operator() dims=[4] size=(4, 4) ishermitian=false\n", + "4×4 SparseArrays.SparseMatrixCSC{ComplexF64, Int64} with 3 stored entries:\n", + " ⋅ 1.41421+0.0im ⋅ ⋅ \n", + " ⋅ ⋅ 2.0+0.0im ⋅ \n", + " ⋅ ⋅ ⋅ 2.44949+0.0im\n", + " ⋅ ⋅ ⋅ ⋅ " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# parameters\n", + "N = 4 # Fock space dimension\n", + "Δ = 5 * 2 * π # cavity detuning\n", + "κ = 2 # cavity decay rate\n", + "α = 4 # intensity of initial state\n", + "ntraj = 500 # number of trajectories\n", + "\n", + "tlist = 0:0.0025:1\n", + "\n", + "# operators\n", + "a = destroy(N)\n", + "x = a + a'\n", + "H = Δ * a' * a\n", + "\n", + "# initial state\n", + "ψ0 = coherent(N, √α)\n", + "ψ0 = ψ0 * ψ0'\n", + "# temperature with average of 0 excitations (absolute zero)\n", + "n_th = 0\n", + "# c_ops = [√(κ * n_th) * a'] -> nothing\n", + "sc_ops = [√(κ * (n_th + 1)) * a]" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fd66e3e6", + "metadata": {}, + "outputs": [ + { + "ename": "CompositeException", + "evalue": "TaskFailedException\n\n nested task error: MethodError: no method matching mul!(::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, ::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, ::Matrix{ComplexF64}, ::Bool, ::Bool)\n The function `mul!` exists, but no method is defined for this combination of argument types.\n \n Closest candidates are:\n mul!(!Matched::ChainRulesCore.AbstractThunk, ::Any, ::Any, ::Any, ::Any)\n @ ChainRulesCore ~/.julia/packages/ChainRulesCore/Vsbj9/src/tangent_types/thunks.jl:103\n mul!(::AbstractVecOrMat, !Matched::SciMLOperators.IdentityOperator, ::AbstractVecOrMat, ::Any, ::Any)\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:56\n mul!(::AbstractVecOrMat, !Matched::SciMLOperators.NullOperator, ::AbstractVecOrMat, ::Any, ::Any)\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:167\n ...\n \n Stacktrace:\n [1] mul!(C::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, A::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, B::Matrix{ComplexF64})\n @ LinearAlgebra ~/.julia/juliaup/julia-1.12.1+0.aarch64.linux.gnu/share/julia/stdlib/v1.12/LinearAlgebra/src/matmul.jl:265\n [2] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:213\n [3] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:211\n [4] macro expansion\n @ ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:666 [inlined]\n [5] (::SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:658\n [6] macro expansion\n @ /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:513 [inlined]\n [7] (::QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}})(w::Matrix{ComplexF64}, v::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:504\n [8] sde_determine_initdt(u0::Matrix{ComplexF64}, t::Float64, tdir::Float64, dtmax::Float64, abstol::Float64, reltol::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, order::Rational{Int64}, integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/initdt.jl:36\n [9] auto_dt_reset!(integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/integrators/integrator_interface.jl:383\n [10] handle_dt!\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:752 [inlined]\n [11] __init(_prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, alg::StochasticDiffEq.SRA2, timeseries_init::Vector{Any}, ts_init::Vector{Any}, ks_init::Type, recompile::Type{Val{true}}; saveat::Vector{Float64}, tstops::Vector{Float64}, d_discontinuities::Tuple{}, save_idxs::Nothing, save_everystep::Bool, save_noise::Bool, save_on::Bool, save_start::Bool, save_end::Bool, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}, dense::Bool, calck::Bool, dt::Float64, adaptive::Bool, gamma::Rational{Int64}, abstol::Float64, reltol::Float64, qmin::Rational{Int64}, qmax::Rational{Int64}, qsteady_min::Int64, qsteady_max::Int64, beta2::Nothing, beta1::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, delta::Rational{Int64}, maxiters::Int64, dtmax::Float64, dtmin::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, force_dtmin::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), progress_id::Symbol, userdata::Nothing, initialize_integrator::Bool, seed::UInt64, alias::Nothing, initializealg::DiffEqBase.DefaultInit, kwargs::@Kwargs{})\n @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:703\n [12] __init\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:20 [inlined]\n [13] #__solve#69\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:6 [inlined]\n [14] __solve (repeats 5 times)\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:1 [inlined]\n [15] #solve_call#23\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:127 [inlined]\n [16] solve_call\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:84 [inlined]\n [17] solve_up(prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, sensealg::Nothing, u0::Matrix{ComplexF64}, p::SciMLBase.NullParameters, args::StochasticDiffEq.SRA2; originator::SciMLBase.ChainRulesOriginator, kwargs::@Kwargs{})\n @ DiffEqBase ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:563\n [18] solve_up\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:540 [inlined]\n [19] #solve#29\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:530 [inlined]\n [20] solve\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:520 [inlined]\n [21] batch_func(i::Int64, prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2; kwargs::@Kwargs{})\n @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:235\n [22] batch_func\n @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:222 [inlined]\n [23] #818\n @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:313 [inlined]\n [24] macro expansion\n @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:323 [inlined]\n [25] (::SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}})(tid::Int64; onethread::Bool)\n @ SciMLBase ./threadingconstructs.jl:276\n [26] #tmap##0\n @ ./threadingconstructs.jl:243 [inlined]\n [27] (::Base.Threads.var\"#threading_run##0#threading_run##1\"{SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}}, Int64})()\n @ Base.Threads ./threadingconstructs.jl:177\n\n...and 13 more exceptions.\n", + "output_type": "error", + "traceback": [ + "TaskFailedException\n", + "\n", + " nested task error: MethodError: no method matching mul!(::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, ::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, ::Matrix{ComplexF64}, ::Bool, ::Bool)\n", + " The function `mul!` exists, but no method is defined for this combination of argument types.\n", + " \n", + " Closest candidates are:\n", + " mul!(!Matched::ChainRulesCore.AbstractThunk, ::Any, ::Any, ::Any, ::Any)\n", + " @ ChainRulesCore ~/.julia/packages/ChainRulesCore/Vsbj9/src/tangent_types/thunks.jl:103\n", + " mul!(::AbstractVecOrMat, !Matched::SciMLOperators.IdentityOperator, ::AbstractVecOrMat, ::Any, ::Any)\n", + " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:56\n", + " mul!(::AbstractVecOrMat, !Matched::SciMLOperators.NullOperator, ::AbstractVecOrMat, ::Any, ::Any)\n", + " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:167\n", + " ...\n", + " \n", + " Stacktrace:\n", + " [1] mul!(C::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, A::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, B::Matrix{ComplexF64})\n", + " @ LinearAlgebra ~/.julia/juliaup/julia-1.12.1+0.aarch64.linux.gnu/share/julia/stdlib/v1.12/LinearAlgebra/src/matmul.jl:265\n", + " [2] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n", + " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:213\n", + " [3] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n", + " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:211\n", + " [4] macro expansion\n", + " @ ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:666 [inlined]\n", + " [5] (::SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n", + " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:658\n", + " [6] macro expansion\n", + " @ /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:513 [inlined]\n", + " [7] (::QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}})(w::Matrix{ComplexF64}, v::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n", + " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:504\n", + " [8] sde_determine_initdt(u0::Matrix{ComplexF64}, t::Float64, tdir::Float64, dtmax::Float64, abstol::Float64, reltol::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, order::Rational{Int64}, integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n", + " @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/initdt.jl:36\n", + " [9] auto_dt_reset!(integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n", + " @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/integrators/integrator_interface.jl:383\n", + " [10] handle_dt!\n", + " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:752 [inlined]\n", + " [11] __init(_prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, alg::StochasticDiffEq.SRA2, timeseries_init::Vector{Any}, ts_init::Vector{Any}, ks_init::Type, recompile::Type{Val{true}}; saveat::Vector{Float64}, tstops::Vector{Float64}, d_discontinuities::Tuple{}, save_idxs::Nothing, save_everystep::Bool, save_noise::Bool, save_on::Bool, save_start::Bool, save_end::Bool, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}, dense::Bool, calck::Bool, dt::Float64, adaptive::Bool, gamma::Rational{Int64}, abstol::Float64, reltol::Float64, qmin::Rational{Int64}, qmax::Rational{Int64}, qsteady_min::Int64, qsteady_max::Int64, beta2::Nothing, beta1::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, delta::Rational{Int64}, maxiters::Int64, dtmax::Float64, dtmin::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, force_dtmin::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), progress_id::Symbol, userdata::Nothing, initialize_integrator::Bool, seed::UInt64, alias::Nothing, initializealg::DiffEqBase.DefaultInit, kwargs::@Kwargs{})\n", + " @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:703\n", + " [12] __init\n", + " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:20 [inlined]\n", + " [13] #__solve#69\n", + " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:6 [inlined]\n", + " [14] __solve (repeats 5 times)\n", + " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:1 [inlined]\n", + " [15] #solve_call#23\n", + " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:127 [inlined]\n", + " [16] solve_call\n", + " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:84 [inlined]\n", + " [17] solve_up(prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, sensealg::Nothing, u0::Matrix{ComplexF64}, p::SciMLBase.NullParameters, args::StochasticDiffEq.SRA2; originator::SciMLBase.ChainRulesOriginator, kwargs::@Kwargs{})\n", + " @ DiffEqBase ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:563\n", + " [18] solve_up\n", + " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:540 [inlined]\n", + " [19] #solve#29\n", + " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:530 [inlined]\n", + " [20] solve\n", + " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:520 [inlined]\n", + " [21] batch_func(i::Int64, prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2; kwargs::@Kwargs{})\n", + " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:235\n", + " [22] batch_func\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:222 [inlined]\n", + " [23] #818\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:313 [inlined]\n", + " [24] macro expansion\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:323 [inlined]\n", + " [25] (::SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}})(tid::Int64; onethread::Bool)\n", + " @ SciMLBase ./threadingconstructs.jl:276\n", + " [26] #tmap##0\n", + " @ ./threadingconstructs.jl:243 [inlined]\n", + " [27] (::Base.Threads.var\"#threading_run##0#threading_run##1\"{SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}}, Int64})()\n", + " @ Base.Threads ./threadingconstructs.jl:177\n", + "\n", + "...and 13 more exceptions.\n", + "\n", + "\n", + "Stacktrace:\n", + " [1] threading_run(fun::SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}}, static::Bool)\n", + " @ Base.Threads ./threadingconstructs.jl:196\n", + " [2] macro expansion\n", + " @ ./threadingconstructs.jl:213 [inlined]\n", + " [3] tmap\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:322 [inlined]\n", + " [4] solve_batch(prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2, ensemblealg::SciMLBase.EnsembleThreads, II::UnitRange{Int64}, pmap_batch_size::Int64; kwargs::@Kwargs{})\n", + " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:312\n", + " [5] solve_batch\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:299 [inlined]\n", + " [6] macro expansion\n", + " @ ./timing.jl:461 [inlined]\n", + " [7] (::SciMLBase.var\"#800#801\"{Int64, Int64, Int64, @Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2, SciMLBase.EnsembleThreads})()\n", + " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:188\n", + " [8] with_logstate(f::SciMLBase.var\"#800#801\"{Int64, Int64, Int64, @Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2, SciMLBase.EnsembleThreads}, logstate::Base.CoreLogging.LogState)\n", + " @ Base.CoreLogging ./logging/logging.jl:540\n", + " [9] with_logger\n", + " @ ./logging/logging.jl:651 [inlined]\n", + " [10] __solve(prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2, ensemblealg::SciMLBase.EnsembleThreads; trajectories::Int64, batch_size::Int64, progress_aggregate::Bool, pmap_batch_size::Int64, kwargs::@Kwargs{})\n", + " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:172\n", + " [11] __solve\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:164 [inlined]\n", + " [12] #solve#825\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:359 [inlined]\n", + " [13] solve\n", + " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:356 [inlined]\n", + " [14] _ensemble_dispatch_solve\n", + " @ /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:435 [inlined]\n", + " [15] ssesolve(ens_prob::QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, Vector{Float64}, Dimensions{1, Tuple{Space}}, @NamedTuple{progr::ProgressMeter.Progress, channel::Nothing}}, alg::StochasticDiffEq.SRA2, ntraj::Int64, ensemblealg::SciMLBase.EnsembleThreads, keep_runs_results::Val{false})\n", + " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/ssesolve.jl:408\n", + " [16] ssesolve(H::QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, ψ0::QuantumObject{Operator, Dimensions{1, Tuple{Space}}, Matrix{ComplexF64}}, tlist::StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}; alg::Nothing, e_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, params::SciMLBase.NullParameters, rng::Random.TaskLocalRNG, ntraj::Int64, ensemblealg::SciMLBase.EnsembleThreads, prob_func::Nothing, output_func::Nothing, progress_bar::Val{true}, keep_runs_results::Val{false}, store_measurement::Val{true}, kwargs::@Kwargs{})\n", + " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/ssesolve.jl:398\n", + " [17] top-level scope\n", + " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X32sdnNjb2RlLXJlbW90ZQ==.jl:1" + ] + } + ], + "source": [ + "sse_sol = ssesolve(\n", + " H,\n", + " ψ0,\n", + " tlist,\n", + " sc_ops,\n", + " e_ops=[x],\n", + " ntraj=ntraj,\n", + " store_measurement=Val(true),\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "32e57f1a", + "metadata": {}, + "source": [ + "### mesolve" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6fb34e55", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[mesolve] 100%|███████████████████████████| Time: 0:00:00 (65.90 μs/it)\u001b[39m\u001b[K\n" + ] + }, + { + "data": { + "text/plain": [ + "Solution of time evolution\n", + "(return code: Success)\n", + "--------------------------\n", + "num_states = 101\n", + "num_expect = 0\n", + "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", + "abstol = 1.0e-8\n", + "reltol = 1.0e-6\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ψ0 = fock(2)#qeye(4, type = SuperOperator())\n", + "ψ0 = qeye(4, type = SuperOperator())\n", + "H = sigmaz()\n", + "C = 0.001*sigmam()\n", + "tlist = 0:0.1:10.0\n", + "@inferred mesolve(H, ψ0, tlist, [C])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "894e9dd0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[mesolve_map] 100%|███████████████████████| Time: 0:00:00 (14.98 ms/it)\u001b[39m\u001b[K\n" + ] + }, + { + "data": { + "text/plain": [ + "2-element Vector{TimeEvolutionSol{Vector{Float64}, Vector{Float64}, Vector{QuantumObject{SuperOperator, Dimensions{1, Tuple{Space}}, Matrix{ComplexF64}}}, Nothing, SciMLBase.ReturnCode.T, OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, Float64}}:\n", + " Solution of time evolution\n", + "(return code: Success)\n", + "--------------------------\n", + "num_states = 101\n", + "num_expect = 0\n", + "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", + "abstol = 1.0e-8\n", + "reltol = 1.0e-6\n", + "\n", + " Solution of time evolution\n", + "(return code: Success)\n", + "--------------------------\n", + "num_states = 101\n", + "num_expect = 0\n", + "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", + "abstol = 1.0e-8\n", + "reltol = 1.0e-6\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ψ0 = fock(2)\n", + "# ψ1 = fock(2,1)\n", + "H = sigmaz()\n", + "C = 0.001 * sigmam()\n", + "tlist = 0:0.1:10.0\n", + "@inferred mesolve_map(H, [ψ0, ψ0], tlist, [C])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "e3b995bd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "Quantum Object: type=SuperOperator() dims=[2] size=(4, 4)\n", + "4×4 Matrix{ComplexF64}:\n", + " 1.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 1.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 1.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0+0.0im 1.0+0.0im" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sol[1].states[1]" + ] + }, + { + "cell_type": "markdown", + "id": "235b469f", + "metadata": {}, + "source": [ + "### smsolve" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c58a7165", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1-element Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}:\n", + " \n", + "Quantum Object: type=Operator() dims=[20] size=(20, 20) ishermitian=false\n", + "20×20 SparseArrays.SparseMatrixCSC{ComplexF64, Int64} with 19 stored entries:\n", + "⎡⠈⠢⡀⠀⠀⠀⠀⠀⠀⠀⎤\n", + "⎢⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⎥\n", + "⎢⠀⠀⠀⠀⠈⠢⡀⠀⠀⠀⎥\n", + "⎢⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⎥\n", + "⎣⠀⠀⠀⠀⠀⠀⠀⠀⠈⠢⎦" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# parameters\n", + "N = 20 # Fock space dimension\n", + "Δ = 5 * 2 * π # cavity detuning\n", + "κ = 2 # cavity decay rate\n", + "α = 4 # intensity of initial state\n", + "ntraj = 500 # number of trajectories\n", + "\n", + "tlist = 0:0.0025:1\n", + "\n", + "# operators\n", + "a = destroy(N)\n", + "x = a + a'\n", + "H = Δ * a' * a\n", + "\n", + "# initial state\n", + "ψ0 = coherent(N, √α)\n", + "\n", + "# temperature with average of 0 excitations (absolute zero)\n", + "n_th = 0\n", + "# c_ops = [√(κ * n_th) * a'] -> nothing\n", + "sc_ops = [√(κ * (n_th + 1)) * a]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cdb6dd9b", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[ssesolve] 100%|██████████████████████████| Time: 0:00:08 (17.56 ms/it)\u001b[39m\u001b[K\n" + ] + }, + { + "ename": "UndefVarError", + "evalue": "UndefVarError: `Figure` not defined in `Main`\nSuggestion: check for spelling errors or missing imports.", + "output_type": "error", + "traceback": [ + "UndefVarError: `Figure` not defined in `Main`\n", + "Suggestion: check for spelling errors or missing imports.\n", + "\n", + "Stacktrace:\n", + " [1] top-level scope\n", + " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X42sdnNjb2RlLXJlbW90ZQ==.jl:15" + ] + } + ], + "source": [ + "sse_sol = ssesolve(\n", + " H,\n", + " ψ0,\n", + " tlist,\n", + " sc_ops,\n", + " e_ops=[x],\n", + " ntraj=ntraj,\n", + " store_measurement=Val(true),\n", + ")\n", + "\n", + "measurement_avg = sum(sse_sol.measurement, dims=2) / size(sse_sol.measurement, 2)\n", + "measurement_avg = dropdims(measurement_avg, dims=2)\n", + "\n", + "\n", + "fig" + ] + }, + { + "cell_type": "markdown", + "id": "ce710f6e", + "metadata": {}, + "source": [ + "### mcsolve" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5fcfab9a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[mcsolve] 100%|███████████████████████████| Time: 0:00:00 ( 0.85 ms/it)\u001b[39m\u001b[K\n" + ] + }, + { + "data": { + "text/plain": [ + "Solution of quantum trajectories\n", + "(converged: true)\n", + "--------------------------------\n", + "num_trajectories = 500\n", + "num_states = 1\n", + "num_expect = 2\n", + "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", + "abstol = 1.0e-8\n", + "reltol = 1.0e-6\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "tlist = LinRange(0.0, 10.0, 200)\n", + "\n", + "ψ0 = tensor(fock(2, 0), fock(5, 8))\n", + "ψ0 = to_dense(qeye(2) ⊗ qeye(5))\n", + "a = tensor(qeye(2), destroy(5))\n", + "σm = tensor(destroy(2), qeye(5))\n", + "H = 2 * π * a' * a + 2 * π * σm' * σm + 2 * π * 0.25 * (σm * a' + σm' * a)\n", + "\n", + "c_ops = [sqrt(0.1) * a]\n", + "e_ops = [a' * a, σm' * σm]\n", + "\n", + "sol_500 = mcsolve(H, ψ0, tlist, c_ops, e_ops=e_ops)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "472b2c21", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\n", + "Quantum Object: type=Operator() dims=[2, 5] size=(10, 10) ishermitian=false\n", + "10×10 Matrix{ComplexF64}:\n", + " 0.586998+0.0im 0.0+0.0im … 0.0+0.0im\n", + " 0.0+0.0im -0.457168+1.78283e-9im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 1.55724e-8-0.000909649im … 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", + " 0.0+0.0im 0.0+0.0im 0.0794203-1.18377e-5im" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sol_500.states[1]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "090fb9c7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Julia 1.12.1", + "language": "julia", + "name": "julia-1.12" + }, + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 01baa168c0952354c1f53f968838020fcffedc1e Mon Sep 17 00:00:00 2001 From: Gavin Date: Sun, 30 Nov 2025 22:40:02 +0000 Subject: [PATCH 03/20] updated testing.ipynb --- testing.ipynb | 78 ++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 68 insertions(+), 10 deletions(-) diff --git a/testing.ipynb b/testing.ipynb index 07560459a..35c1c5283 100644 --- a/testing.ipynb +++ b/testing.ipynb @@ -517,10 +517,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "d90f8989", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[sesolve] 100%|███████████████████████████| Time: 0:00:00 ( 0.51 μs/it)\u001b[39m\u001b[K\n" + ] + }, + { + "data": { + "text/plain": [ + "Solution of time evolution\n", + "(return code: Success)\n", + "--------------------------\n", + "num_states = 101\n", + "num_expect = 0\n", + "ODE alg.: OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false), false)\n", + "abstol = 1.0e-8\n", + "reltol = 1.0e-6\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "H = sigmax()\n", "ψ0 = qeye(2) # <- does not work\n", @@ -530,14 +554,48 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "126d75af", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m[sesolve_map] 100%|███████████████████████| Time: 0:00:00 ( 0.11 ms/it)\u001b[39m\u001b[K\n" + ] + }, + { + "data": { + "text/plain": [ + "2-element Vector{TimeEvolutionSol{Vector{Float64}, Vector{Float64}, Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, Matrix{ComplexF64}}}, Nothing, SciMLBase.ReturnCode.T, OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, Float64}}:\n", + " Solution of time evolution\n", + "(return code: Success)\n", + "--------------------------\n", + "num_states = 101\n", + "num_expect = 0\n", + "ODE alg.: OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false), false)\n", + "abstol = 1.0e-8\n", + "reltol = 1.0e-6\n", + "\n", + " Solution of time evolution\n", + "(return code: Success)\n", + "--------------------------\n", + "num_states = 101\n", + "num_expect = 0\n", + "ODE alg.: OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false), false)\n", + "abstol = 1.0e-8\n", + "reltol = 1.0e-6\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "H = sigmax()\n", - "ψ0 = qeye(2) # <- does not work\n", - "ψ0 = fock(2,1)\n", + "ψ0 = to_dense(qeye(2))\n", + "#ψ0 = fock(2,1)\n", "tlist = 0:0.1:10.0\n", "sol = sesolve_map(H, [ψ0,ψ0], tlist)" ] @@ -749,7 +807,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "id": "6fb34e55", "metadata": {}, "outputs": [ @@ -757,7 +815,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m[mesolve] 100%|███████████████████████████| Time: 0:00:00 (65.90 μs/it)\u001b[39m\u001b[K\n" + "\u001b[32m[mesolve] 100%|███████████████████████████| Time: 0:00:00 ( 0.86 μs/it)\u001b[39m\u001b[K\n" ] }, { @@ -788,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "id": "894e9dd0", "metadata": {}, "outputs": [ @@ -796,7 +854,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m[mesolve_map] 100%|███████████████████████| Time: 0:00:00 (14.98 ms/it)\u001b[39m\u001b[K\n" + "\u001b[32m[mesolve_map] 100%|███████████████████████| Time: 0:00:00 ( 8.77 ms/it)\u001b[39m\u001b[K\n" ] }, { From e575f7d711f2c9b5e064cfa1a77d1ff3652b083e Mon Sep 17 00:00:00 2001 From: Gavin Date: Sun, 30 Nov 2025 22:44:40 +0000 Subject: [PATCH 04/20] added to_dense call to sesolve_map to ensure all initial states are dense. --- src/time_evolution/sesolve.jl | 3 +++ testing.ipynb | 10 +++++----- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index 343ccde1c..ac3a1be58 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -235,6 +235,9 @@ function sesolve_map( kwargs..., ) where {X<:Union{Ket,Operator}} # mapping initial states and parameters + + ψ0 = map(to_dense, ψ0) # Convert all initial states to dense vectors + ψ0_iter = map(get_data, ψ0) if params isa NullParameters iter = collect(Iterators.product(ψ0_iter, [params])) |> vec # convert nx1 Matrix into Vector diff --git a/testing.ipynb b/testing.ipynb index 35c1c5283..5a0186580 100644 --- a/testing.ipynb +++ b/testing.ipynb @@ -517,7 +517,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 3, "id": "d90f8989", "metadata": {}, "outputs": [ @@ -525,7 +525,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m[sesolve] 100%|███████████████████████████| Time: 0:00:00 ( 0.51 μs/it)\u001b[39m\u001b[K\n" + "\u001b[32m[sesolve] 100%|███████████████████████████| Time: 0:00:00 (64.34 μs/it)\u001b[39m\u001b[K\n" ] }, { @@ -554,7 +554,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "id": "126d75af", "metadata": {}, "outputs": [ @@ -562,7 +562,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "\u001b[32m[sesolve_map] 100%|███████████████████████| Time: 0:00:00 ( 0.11 ms/it)\u001b[39m\u001b[K\n" + "\u001b[32m[sesolve_map] 100%|███████████████████████| Time: 0:00:00 ( 0.66 ms/it)\u001b[39m\u001b[K\n" ] }, { @@ -594,7 +594,7 @@ ], "source": [ "H = sigmax()\n", - "ψ0 = to_dense(qeye(2))\n", + "ψ0 = (qeye(2))\n", "#ψ0 = fock(2,1)\n", "tlist = 0:0.1:10.0\n", "sol = sesolve_map(H, [ψ0,ψ0], tlist)" From 71842a76194892e92b7d433450a16966d4d49dda Mon Sep 17 00:00:00 2001 From: Gavin Date: Tue, 2 Dec 2025 18:40:22 +0000 Subject: [PATCH 05/20] fixed .gitignore and removed testing.ipynb --- .gitignore | 1 + testing.ipynb | 1133 ------------------------------------------------- 2 files changed, 1 insertion(+), 1133 deletions(-) delete mode 100644 testing.ipynb diff --git a/.gitignore b/.gitignore index 332d6969b..27bcfc910 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,4 @@ benchmarks/benchmarks_output.json .ipynb_checkpoints .devcontainer/* +*.ipynb diff --git a/testing.ipynb b/testing.ipynb deleted file mode 100644 index 5a0186580..000000000 --- a/testing.ipynb +++ /dev/null @@ -1,1133 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "5bbd7370", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m\u001b[1m Activating\u001b[22m\u001b[39m project at `/workspaces/QuantumToolbox.jl`\n", - "\n", - "SYSTEM: caught exception of type :MethodError while trying to print a failed Task notice; giving up\n", - "\n", - "SYSTEM: caught exception of type :MethodError while trying to print a failed Task notice; giving up\n" - ] - } - ], - "source": [ - "using Pkg\n", - "Pkg.activate(\".\")\n", - "using Revise\n", - "using Test\n", - "using InteractiveUtils\n", - "using QuantumToolbox\n", - "using QuantumToolbox: check_dimensions, check_mul_dimensions, get_dimensions_from, get_dimensions_to" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "aafc2649", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " QuantumToolbox.jl: Quantum Toolbox in Julia\n", - "≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡≡\n", - "Copyright © QuTiP team 2022 and later.\n", - "Current admin team:\n", - " Alberto Mercurio and Yi-Te Huang\n", - "\n", - "Package information:\n", - "====================================\n", - "Julia Ver. 1.12.1\n", - "QuantumToolbox Ver. nothing\n", - "SciMLOperators Ver. 1.13.0\n", - "LinearSolve Ver. 3.47.0\n", - "OrdinaryDiffEqCore Ver. 1.36.0\n", - "\n", - "System information:\n", - "====================================\n", - "OS : Linux (aarch64-linux-gnu)\n", - "CPU : 14 × unknown\n", - "Memory : 7.653 GB\n", - "WORD_SIZE: 64\n", - "LIBM : libopenlibm\n", - "LLVM : libLLVM-18.1.7 (ORCJIT, generic)\n", - "BLAS : libopenblas64_.so (ilp64)\n", - "Threads : 14 (on 14 virtual cores)\n", - "\n", - "+---------------------------------------------------+\n", - "| Please cite QuantumToolbox.jl in your publication |\n", - "+---------------------------------------------------+\n", - "For your convenience, a bibtex reference can be easily generated using `QuantumToolbox.cite()`.\n", - "\n" - ] - } - ], - "source": [ - "QuantumToolbox.versioninfo()\n" - ] - }, - { - "cell_type": "markdown", - "id": "482d1b52", - "metadata": {}, - "source": [ - "## Cat Definitions" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "cd4b2801", - "metadata": {}, - "outputs": [], - "source": [ - "function Base.cat(x::QuantumObject{Ket}...)\n", - " cat(x)\n", - "end\n", - "function Base.cat(x::Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{Ket} where N\n", - " check_dimensions(x)\n", - " to_stack = [x[i].data for i in 1:length(x)]\n", - " stacked_data = hcat(to_stack...)\n", - " new_dims = (x[1].dims, (length(x),))\n", - " return QuantumObject(stacked_data, dims=new_dims)\n", - "end\n", - "\n", - "function Base.cat(x :: QuantumObject{Bra}...)\n", - " cat(x)\n", - "end\n", - "\n", - "function Base.cat(x :: Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{Bra} where N\n", - " check_dimensions(x)\n", - " to_stack = [x[i].data for i in 1:length(x)]\n", - " stacked_data = vcat(to_stack...)\n", - " new_dims = ((length(x),), x[1].dims)\n", - " return QuantumObject(stacked_data, dims=new_dims)\n", - "end\n", - "\n", - "\n", - "\n", - "function Base.cat(x::QuantumObject{OperatorKet}...)\n", - " cat(x)\n", - "end\n", - "function Base.cat(x::Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{OperatorKet} where N\n", - " check_dimensions(x)\n", - " to_stack = [x[i].data for i in 1:length(x)]\n", - " stacked_data = hcat(to_stack...)\n", - " new_dims = (x[1].dims, (length(x),))\n", - " return QuantumObject(stacked_data, dims=new_dims, type=SuperOperator())\n", - "end\n", - "\n", - "function Base.cat(x :: QuantumObject{OperatorBra}...)\n", - " cat(x)\n", - "end\n", - "\n", - "function Base.cat(x :: Union{AbstractArray{T}, NTuple{N, T}}) where T<:QuantumObject{OperatorBra} where N\n", - " check_dimensions(x)\n", - " to_stack = [x[i].data for i in 1:length(x)]\n", - " stacked_data = vcat(to_stack...)\n", - " new_dims = ((length(x),), x[1].dims)\n", - " return QuantumObject(stacked_data, dims=new_dims, type=SuperOperator())\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "4a6938d8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Quantum Object: type=Operator() dims=[[3, 2], [2]] size=(6, 2) ishermitian=false\n", - "6×2 Matrix{ComplexF64}:\n", - " 0.0+0.0im 0.0+0.0im\n", - " 1.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 1.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "states = [fock(3,0)⊗fock(2,1), fock(3,1)⊗fock(2,1)];\n", - "a = cat(states...)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "93c6c627", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Quantum Object: type=Operator() dims=[[3, 2], [2]] size=(6, 2) ishermitian=false\n", - "6×2 Matrix{ComplexF64}:\n", - " 0.0+0.0im 0.0+0.0im\n", - " 1.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 1.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "O = qeye(3)⊗qeye(2);\n", - "O*a" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "0c81591a", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Quantum Object: type=Operator() dims=[[3, 2], [2]] size=(6, 2) ishermitian=false\n", - "6×2 Matrix{ComplexF64}:\n", - " 0.0+0.0im 0.0+0.0im\n", - " 1.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 1.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "check_mul_dimensions(get_dimensions_from(O), get_dimensions_to(a))\n", - "O*a" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "508471b9", - "metadata": {}, - "outputs": [ - { - "ename": "DomainError", - "evalue": "DomainError with (4, 2):\nThe size of the array is not compatible with SuperOperator", - "output_type": "error", - "traceback": [ - "DomainError with (4, 2):\n", - "The size of the array is not compatible with SuperOperator\n", - "\n", - "Stacktrace:\n", - " [1] _check_QuantumObject\n", - " @ /workspaces/QuantumToolbox.jl/src/qobj/quantum_object_base.jl:180 [inlined]\n", - " [2] QuantumObject\n", - " @ /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:59 [inlined]\n", - " [3] QuantumObject(A::Matrix{Float64}; type::SuperOperator, dims::Nothing)\n", - " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:101\n", - " [4] top-level scope\n", - " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X11sdnNjb2RlLXJlbW90ZQ==.jl:1" - ] - } - ], - "source": [ - "Qobj(rand(4,2), type = SuperOperator())" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "eed4016c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Quantum Object: type=Operator() dims=[[3], [3]] size=(3, 3) ishermitian=true\n", - "3×3 Matrix{ComplexF64}:\n", - " 1.0-0.0im 0.0-0.0im 0.0-0.0im\n", - " 0.0-0.0im 1.0-0.0im 0.0-0.0im\n", - " 0.0-0.0im 0.0-0.0im 1.0-0.0im" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "states = [fock(3,0)', fock(3,1)', fock(3,2)'];\n", - "b = cat(states...)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "0c6143fa", - "metadata": {}, - "outputs": [ - { - "ename": "DomainError", - "evalue": "DomainError with [[3], [3]]:\nThe given `dims` is not compatible with type = SuperOperator(), should be a single list of integers.", - "output_type": "error", - "traceback": [ - "DomainError with [[3], [3]]:\n", - "The given `dims` is not compatible with type = SuperOperator(), should be a single list of integers.\n", - "\n", - "Stacktrace:\n", - " [1] _check_QuantumObject(type::SuperOperator, dimensions::GeneralDimensions{1, 1, Tuple{Space}, Tuple{Space}}, m::Int64, n::Int64)\n", - " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object_base.jl:131\n", - " [2] QuantumObject(data::Matrix{ComplexF64}, type::SuperOperator, dims::Tuple{StaticArraysCore.SVector{1, Int64}, Tuple{Int64}})\n", - " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:59\n", - " [3] QuantumObject(A::Matrix{ComplexF64}; type::SuperOperator, dims::Tuple{StaticArraysCore.SVector{1, Int64}, Tuple{Int64}})\n", - " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/qobj/quantum_object.jl:101\n", - " [4] cat(x::Tuple{QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}})\n", - " @ Main /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_W4sdnNjb2RlLXJlbW90ZQ==.jl:34\n", - " [5] cat(::QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, ::QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}, ::Vararg{QuantumObject{OperatorKet, Dimensions{1, Tuple{Space}}, Vector{ComplexF64}}})\n", - " @ Main /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_W4sdnNjb2RlLXJlbW90ZQ==.jl:27\n", - " [6] top-level scope\n", - " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X13sdnNjb2RlLXJlbW90ZQ==.jl:2" - ] - } - ], - "source": [ - "states = [mat2vec(ket2dm(fock(3,0))), mat2vec(ket2dm(fock(3,1))), mat2vec(ket2dm(fock(3,2)))];\n", - "c = cat(states...)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "e6c966a8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "check_right_multiplication (generic function with 1 method)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "function check_left_multiplication(A, x)\n", - " A_dims = A.dims[1]\n", - " x_dims = []\n", - " for dim in x.dims[1]\n", - " push!(x_dims, dim)\n", - " end\n", - "\n", - " println(\"A_dims: \", A_dims)\n", - " println(\"x_dims: \", x_dims)\n", - " A_size = size(A)[1]\n", - " x_size = size(x)[1]\n", - " println(\"A_size: \", A_size)\n", - " println(\"x_size: \", x_size)\n", - " return A_dims == x_dims && A_size == x_size\n", - "end\n", - "\n", - "function check_right_multiplication(A, x)\n", - " A_dims = A.dims[1]\n", - " x_dims = []\n", - " for dim in x.dims[1]\n", - " push!(x_dims, dim)\n", - " end\n", - " \n", - " println(\"A_dims: \", A_dims)\n", - " println(\"x_dims: \", x_dims)\n", - " A_size = size(A)[1]\n", - " if length(x.dims) > 1\n", - " x_size = size(x)[2]\n", - " else\n", - " x_size = 1\n", - " end\n", - " println(\"A_size: \", A_size)\n", - " println(\"x_size: \", x_size)\n", - " return A_dims == x_dims && A_size == x_size\n", - "end" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "951d89e2", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Quantum Object: type=Operator() dims=[[3], [2]] size=(3, 2) ishermitian=false\n", - "3×2 Matrix{ComplexF64}:\n", - " 1.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 1.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im\n" - ] - } - ], - "source": [ - "a = cat(fock(3,0), fock(3,1));\n", - "println(a)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "89da9528", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "A_dims: [3]\n", - "x_dims: Any[3]\n", - "A_size: 3\n", - "x_size: 1\n" - ] - }, - { - "data": { - "text/plain": [ - "false" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "check_left_multiplication(a, fock(3,1)')" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "93c795e7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "A_dims: [3]\n", - "x_dims: Any[3]\n", - "A_size: 3\n", - "x_size: 1\n" - ] - }, - { - "data": { - "text/plain": [ - "false" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "check_right_multiplication(a, fock(3,1))" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "13526a28", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Quantum Object: type=Bra() dims=[2] size=(1, 2)\n", - "1×2 adjoint(::Vector{ComplexF64}) with eltype ComplexF64:\n", - " 0.0-0.0im 1.0-0.0im" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fock(3,1)'*a" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "1c0e2909", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(2, 3)" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "size(a')" - ] - }, - { - "cell_type": "markdown", - "id": "f9c34c65", - "metadata": {}, - "source": [ - "## Testing Solver Extensions" - ] - }, - { - "cell_type": "markdown", - "id": "b67cdac7", - "metadata": {}, - "source": [ - "### Sesolve" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "d90f8989", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m[sesolve] 100%|███████████████████████████| Time: 0:00:00 (64.34 μs/it)\u001b[39m\u001b[K\n" - ] - }, - { - "data": { - "text/plain": [ - "Solution of time evolution\n", - "(return code: Success)\n", - "--------------------------\n", - "num_states = 101\n", - "num_expect = 0\n", - "ODE alg.: OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false), false)\n", - "abstol = 1.0e-8\n", - "reltol = 1.0e-6\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "H = sigmax()\n", - "ψ0 = qeye(2) # <- does not work\n", - "tlist = 0:0.1:10.0\n", - "sol = sesolve(H, ψ0, tlist)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "126d75af", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m[sesolve_map] 100%|███████████████████████| Time: 0:00:00 ( 0.66 ms/it)\u001b[39m\u001b[K\n" - ] - }, - { - "data": { - "text/plain": [ - "2-element Vector{TimeEvolutionSol{Vector{Float64}, Vector{Float64}, Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, Matrix{ComplexF64}}}, Nothing, SciMLBase.ReturnCode.T, OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, Float64}}:\n", - " Solution of time evolution\n", - "(return code: Success)\n", - "--------------------------\n", - "num_states = 101\n", - "num_expect = 0\n", - "ODE alg.: OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false), false)\n", - "abstol = 1.0e-8\n", - "reltol = 1.0e-6\n", - "\n", - " Solution of time evolution\n", - "(return code: Success)\n", - "--------------------------\n", - "num_states = 101\n", - "num_expect = 0\n", - "ODE alg.: OrdinaryDiffEqVerner.Vern7{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false), false)\n", - "abstol = 1.0e-8\n", - "reltol = 1.0e-6\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "H = sigmax()\n", - "ψ0 = (qeye(2))\n", - "#ψ0 = fock(2,1)\n", - "tlist = 0:0.1:10.0\n", - "sol = sesolve_map(H, [ψ0,ψ0], tlist)" - ] - }, - { - "cell_type": "markdown", - "id": "28a4905b", - "metadata": {}, - "source": [ - "### ssesolve" - ] - }, - { - "cell_type": "markdown", - "id": "09acc3ce", - "metadata": {}, - "source": [ - "I made the changes but i need to look at the documentation for an example" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "7400fa5d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1-element Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}:\n", - " \n", - "Quantum Object: type=Operator() dims=[4] size=(4, 4) ishermitian=false\n", - "4×4 SparseArrays.SparseMatrixCSC{ComplexF64, Int64} with 3 stored entries:\n", - " ⋅ 1.41421+0.0im ⋅ ⋅ \n", - " ⋅ ⋅ 2.0+0.0im ⋅ \n", - " ⋅ ⋅ ⋅ 2.44949+0.0im\n", - " ⋅ ⋅ ⋅ ⋅ " - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# parameters\n", - "N = 4 # Fock space dimension\n", - "Δ = 5 * 2 * π # cavity detuning\n", - "κ = 2 # cavity decay rate\n", - "α = 4 # intensity of initial state\n", - "ntraj = 500 # number of trajectories\n", - "\n", - "tlist = 0:0.0025:1\n", - "\n", - "# operators\n", - "a = destroy(N)\n", - "x = a + a'\n", - "H = Δ * a' * a\n", - "\n", - "# initial state\n", - "ψ0 = coherent(N, √α)\n", - "ψ0 = ψ0 * ψ0'\n", - "# temperature with average of 0 excitations (absolute zero)\n", - "n_th = 0\n", - "# c_ops = [√(κ * n_th) * a'] -> nothing\n", - "sc_ops = [√(κ * (n_th + 1)) * a]" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "fd66e3e6", - "metadata": {}, - "outputs": [ - { - "ename": "CompositeException", - "evalue": "TaskFailedException\n\n nested task error: MethodError: no method matching mul!(::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, ::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, ::Matrix{ComplexF64}, ::Bool, ::Bool)\n The function `mul!` exists, but no method is defined for this combination of argument types.\n \n Closest candidates are:\n mul!(!Matched::ChainRulesCore.AbstractThunk, ::Any, ::Any, ::Any, ::Any)\n @ ChainRulesCore ~/.julia/packages/ChainRulesCore/Vsbj9/src/tangent_types/thunks.jl:103\n mul!(::AbstractVecOrMat, !Matched::SciMLOperators.IdentityOperator, ::AbstractVecOrMat, ::Any, ::Any)\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:56\n mul!(::AbstractVecOrMat, !Matched::SciMLOperators.NullOperator, ::AbstractVecOrMat, ::Any, ::Any)\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:167\n ...\n \n Stacktrace:\n [1] mul!(C::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, A::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, B::Matrix{ComplexF64})\n @ LinearAlgebra ~/.julia/juliaup/julia-1.12.1+0.aarch64.linux.gnu/share/julia/stdlib/v1.12/LinearAlgebra/src/matmul.jl:265\n [2] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:213\n [3] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:211\n [4] macro expansion\n @ ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:666 [inlined]\n [5] (::SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:658\n [6] macro expansion\n @ /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:513 [inlined]\n [7] (::QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}})(w::Matrix{ComplexF64}, v::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:504\n [8] sde_determine_initdt(u0::Matrix{ComplexF64}, t::Float64, tdir::Float64, dtmax::Float64, abstol::Float64, reltol::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, order::Rational{Int64}, integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/initdt.jl:36\n [9] auto_dt_reset!(integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/integrators/integrator_interface.jl:383\n [10] handle_dt!\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:752 [inlined]\n [11] __init(_prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, alg::StochasticDiffEq.SRA2, timeseries_init::Vector{Any}, ts_init::Vector{Any}, ks_init::Type, recompile::Type{Val{true}}; saveat::Vector{Float64}, tstops::Vector{Float64}, d_discontinuities::Tuple{}, save_idxs::Nothing, save_everystep::Bool, save_noise::Bool, save_on::Bool, save_start::Bool, save_end::Bool, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}, dense::Bool, calck::Bool, dt::Float64, adaptive::Bool, gamma::Rational{Int64}, abstol::Float64, reltol::Float64, qmin::Rational{Int64}, qmax::Rational{Int64}, qsteady_min::Int64, qsteady_max::Int64, beta2::Nothing, beta1::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, delta::Rational{Int64}, maxiters::Int64, dtmax::Float64, dtmin::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, force_dtmin::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), progress_id::Symbol, userdata::Nothing, initialize_integrator::Bool, seed::UInt64, alias::Nothing, initializealg::DiffEqBase.DefaultInit, kwargs::@Kwargs{})\n @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:703\n [12] __init\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:20 [inlined]\n [13] #__solve#69\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:6 [inlined]\n [14] __solve (repeats 5 times)\n @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:1 [inlined]\n [15] #solve_call#23\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:127 [inlined]\n [16] solve_call\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:84 [inlined]\n [17] solve_up(prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, sensealg::Nothing, u0::Matrix{ComplexF64}, p::SciMLBase.NullParameters, args::StochasticDiffEq.SRA2; originator::SciMLBase.ChainRulesOriginator, kwargs::@Kwargs{})\n @ DiffEqBase ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:563\n [18] solve_up\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:540 [inlined]\n [19] #solve#29\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:530 [inlined]\n [20] solve\n @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:520 [inlined]\n [21] batch_func(i::Int64, prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2; kwargs::@Kwargs{})\n @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:235\n [22] batch_func\n @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:222 [inlined]\n [23] #818\n @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:313 [inlined]\n [24] macro expansion\n @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:323 [inlined]\n [25] (::SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}})(tid::Int64; onethread::Bool)\n @ SciMLBase ./threadingconstructs.jl:276\n [26] #tmap##0\n @ ./threadingconstructs.jl:243 [inlined]\n [27] (::Base.Threads.var\"#threading_run##0#threading_run##1\"{SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}}, Int64})()\n @ Base.Threads ./threadingconstructs.jl:177\n\n...and 13 more exceptions.\n", - "output_type": "error", - "traceback": [ - "TaskFailedException\n", - "\n", - " nested task error: MethodError: no method matching mul!(::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, ::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, ::Matrix{ComplexF64}, ::Bool, ::Bool)\n", - " The function `mul!` exists, but no method is defined for this combination of argument types.\n", - " \n", - " Closest candidates are:\n", - " mul!(!Matched::ChainRulesCore.AbstractThunk, ::Any, ::Any, ::Any, ::Any)\n", - " @ ChainRulesCore ~/.julia/packages/ChainRulesCore/Vsbj9/src/tangent_types/thunks.jl:103\n", - " mul!(::AbstractVecOrMat, !Matched::SciMLOperators.IdentityOperator, ::AbstractVecOrMat, ::Any, ::Any)\n", - " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:56\n", - " mul!(::AbstractVecOrMat, !Matched::SciMLOperators.NullOperator, ::AbstractVecOrMat, ::Any, ::Any)\n", - " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:167\n", - " ...\n", - " \n", - " Stacktrace:\n", - " [1] mul!(C::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, A::SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, B::Matrix{ComplexF64})\n", - " @ LinearAlgebra ~/.julia/juliaup/julia-1.12.1+0.aarch64.linux.gnu/share/julia/stdlib/v1.12/LinearAlgebra/src/matmul.jl:265\n", - " [2] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n", - " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:213\n", - " [3] (::SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n", - " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/matrix.jl:211\n", - " [4] macro expansion\n", - " @ ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:666 [inlined]\n", - " [5] (::SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}})(w::SubArray{ComplexF64, 1, Matrix{ComplexF64}, Tuple{Base.Slice{Base.OneTo{Int64}}, Int64}, true}, v::Matrix{ComplexF64}, u::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64; kwargs::@Kwargs{})\n", - " @ SciMLOperators ~/.julia/packages/SciMLOperators/gJ83E/src/basic.jl:658\n", - " [6] macro expansion\n", - " @ /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:513 [inlined]\n", - " [7] (::QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}})(w::Matrix{ComplexF64}, v::Matrix{ComplexF64}, p::SciMLBase.NullParameters, t::Float64)\n", - " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:504\n", - " [8] sde_determine_initdt(u0::Matrix{ComplexF64}, t::Float64, tdir::Float64, dtmax::Float64, abstol::Float64, reltol::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, order::Rational{Int64}, integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n", - " @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/initdt.jl:36\n", - " [9] auto_dt_reset!(integrator::StochasticDiffEq.SDEIntegrator{StochasticDiffEq.SRA2, true, Matrix{ComplexF64}, ComplexF64, Float64, Float64, SciMLBase.NullParameters, Float64, Float64, ComplexF64, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, Matrix{ComplexF64}, SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}, StochasticDiffEq.SRA2Cache{Matrix{ComplexF64}, Vector{Float64}, StochasticDiffEq.SRA2ConstantCache{Float64, Float64}, Matrix{ComplexF64}, Matrix{ComplexF64}}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, Nothing, StochasticDiffEq.SDEOptions{Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), Bool, SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, 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, Float64, Float64, ComplexF64, Vector{Float64}, Vector{Float64}, Tuple{}}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, ComplexF64, Nothing, Nothing, DiffEqBase.DefaultInit})\n", - " @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/integrators/integrator_interface.jl:383\n", - " [10] handle_dt!\n", - " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:752 [inlined]\n", - " [11] __init(_prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, alg::StochasticDiffEq.SRA2, timeseries_init::Vector{Any}, ts_init::Vector{Any}, ks_init::Type, recompile::Type{Val{true}}; saveat::Vector{Float64}, tstops::Vector{Float64}, d_discontinuities::Tuple{}, save_idxs::Nothing, save_everystep::Bool, save_noise::Bool, save_on::Bool, save_start::Bool, save_end::Bool, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}, dense::Bool, calck::Bool, dt::Float64, adaptive::Bool, gamma::Rational{Int64}, abstol::Float64, reltol::Float64, qmin::Rational{Int64}, qmax::Rational{Int64}, qsteady_min::Int64, qsteady_max::Int64, beta2::Nothing, beta1::Nothing, qoldinit::Rational{Int64}, controller::Nothing, fullnormalize::Bool, failfactor::Int64, delta::Rational{Int64}, maxiters::Int64, dtmax::Float64, dtmin::Float64, internalnorm::typeof(DiffEqBase.ODE_DEFAULT_NORM), isoutofdomain::typeof(DiffEqBase.ODE_DEFAULT_ISOUTOFDOMAIN), unstable_check::typeof(DiffEqBase.ODE_DEFAULT_UNSTABLE_CHECK), verbose::Bool, force_dtmin::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), progress_id::Symbol, userdata::Nothing, initialize_integrator::Bool, seed::UInt64, alias::Nothing, initializealg::DiffEqBase.DefaultInit, kwargs::@Kwargs{})\n", - " @ StochasticDiffEq ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:703\n", - " [12] __init\n", - " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:20 [inlined]\n", - " [13] #__solve#69\n", - " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:6 [inlined]\n", - " [14] __solve (repeats 5 times)\n", - " @ ~/.julia/packages/StochasticDiffEq/yBKxa/src/solve.jl:1 [inlined]\n", - " [15] #solve_call#23\n", - " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:127 [inlined]\n", - " [16] solve_call\n", - " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:84 [inlined]\n", - " [17] solve_up(prob::SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, sensealg::Nothing, u0::Matrix{ComplexF64}, p::SciMLBase.NullParameters, args::StochasticDiffEq.SRA2; originator::SciMLBase.ChainRulesOriginator, kwargs::@Kwargs{})\n", - " @ DiffEqBase ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:563\n", - " [18] solve_up\n", - " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:540 [inlined]\n", - " [19] #solve#29\n", - " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:530 [inlined]\n", - " [20] solve\n", - " @ ~/.julia/packages/DiffEqBase/aB45d/src/solve.jl:520 [inlined]\n", - " [21] batch_func(i::Int64, prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2; kwargs::@Kwargs{})\n", - " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:235\n", - " [22] batch_func\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:222 [inlined]\n", - " [23] #818\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:313 [inlined]\n", - " [24] macro expansion\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:323 [inlined]\n", - " [25] (::SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}})(tid::Int64; onethread::Bool)\n", - " @ SciMLBase ./threadingconstructs.jl:276\n", - " [26] #tmap##0\n", - " @ ./threadingconstructs.jl:243 [inlined]\n", - " [27] (::Base.Threads.var\"#threading_run##0#threading_run##1\"{SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}}, Int64})()\n", - " @ Base.Threads ./threadingconstructs.jl:177\n", - "\n", - "...and 13 more exceptions.\n", - "\n", - "\n", - "Stacktrace:\n", - " [1] threading_run(fun::SciMLBase.var\"#tmap##0#tmap##1\"{SciMLBase.var\"#tmap##2#tmap##3\"{SciMLBase.var\"#818#819\"{@Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2}, Tuple{UnitRange{Int64}}, Vector{SciMLBase.RODESolution{ComplexF64, 3, Vector{Matrix{ComplexF64}}, Nothing, Nothing, Vector{Float64}, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, Nothing, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, StochasticDiffEq.SRA2, StochasticDiffEq.LinearInterpolationData{Vector{Matrix{ComplexF64}}, Vector{Float64}}, SciMLBase.DEStats, Nothing, Nothing}}, UnitRange{Int64}}}, static::Bool)\n", - " @ Base.Threads ./threadingconstructs.jl:196\n", - " [2] macro expansion\n", - " @ ./threadingconstructs.jl:213 [inlined]\n", - " [3] tmap\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:322 [inlined]\n", - " [4] solve_batch(prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2, ensemblealg::SciMLBase.EnsembleThreads, II::UnitRange{Int64}, pmap_batch_size::Int64; kwargs::@Kwargs{})\n", - " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:312\n", - " [5] solve_batch\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:299 [inlined]\n", - " [6] macro expansion\n", - " @ ./timing.jl:461 [inlined]\n", - " [7] (::SciMLBase.var\"#800#801\"{Int64, Int64, Int64, @Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2, SciMLBase.EnsembleThreads})()\n", - " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:188\n", - " [8] with_logstate(f::SciMLBase.var\"#800#801\"{Int64, Int64, Int64, @Kwargs{}, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, StochasticDiffEq.SRA2, SciMLBase.EnsembleThreads}, logstate::Base.CoreLogging.LogState)\n", - " @ Base.CoreLogging ./logging/logging.jl:540\n", - " [9] with_logger\n", - " @ ./logging/logging.jl:651 [inlined]\n", - " [10] __solve(prob::SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, alg::StochasticDiffEq.SRA2, ensemblealg::SciMLBase.EnsembleThreads; trajectories::Int64, batch_size::Int64, progress_aggregate::Bool, pmap_batch_size::Int64, kwargs::@Kwargs{})\n", - " @ SciMLBase ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:172\n", - " [11] __solve\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:164 [inlined]\n", - " [12] #solve#825\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:359 [inlined]\n", - " [13] solve\n", - " @ ~/.julia/packages/SciMLBase/TZ9Rx/src/ensemble/basic_ensemble_solve.jl:356 [inlined]\n", - " [14] _ensemble_dispatch_solve\n", - " @ /workspaces/QuantumToolbox.jl/src/time_evolution/time_evolution.jl:435 [inlined]\n", - " [15] ssesolve(ens_prob::QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.EnsembleProblem{QuantumToolbox.TimeEvolutionProblem{Operator, SciMLBase.SDEProblem{Matrix{ComplexF64}, Tuple{Float64, Float64}, true, SciMLBase.NullParameters, DiffEqNoiseProcess.NoiseProcess{Float64, 2, Float64, Vector{Float64}, Vector{Float64}, Vector{Vector{Float64}}, typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_DIST), typeof(DiffEqNoiseProcess.REAL_INPLACE_WHITE_NOISE_BRIDGE), Nothing, true, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, ResettableStacks.ResettableStack{Tuple{Float64, Vector{Float64}, Vector{Float64}}, true}, DiffEqNoiseProcess.RSWM{Float64}, Nothing, Random.TaskLocalRNG}, SciMLBase.SDEFunction{true, SciMLBase.FullSpecialize, SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, SciMLOperators.FilterKwargs{typeof(SciMLOperators.DEFAULT_UPDATE_FUNC), Val{()}}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(+)}}, SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e2_2##0#_ScalarOperator_e2_2##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, typeof(SciMLBase.DEFAULT_OBSERVED), Nothing, Nothing, Nothing}, QuantumToolbox.DiffusionOperator{ComplexF64, Tuple{SciMLOperators.AddedOperator{ComplexF64, Tuple{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, SciMLOperators.ScaledOperator{ComplexF64, SciMLOperators.ScalarOperator{ComplexF64, QuantumToolbox.var\"#_ScalarOperator_e##0#_ScalarOperator_e##1\"{SciMLOperators.MatrixOperator{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}, SciMLOperators.FilterKwargs{Nothing, Val{()}}, SciMLOperators.FilterKwargs{Nothing, Val{()}}}, typeof(-)}}, SciMLOperators.IdentityOperator}}}}}, @Kwargs{abstol::Float64, reltol::Float64, save_everystep::Bool, save_end::Bool, saveat::Vector{Float64}, tstops::Vector{Float64}, callback::SciMLBase.CallbackSet{Tuple{}, Tuple{SciMLBase.DiscreteCallback{QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##0#_ssesolve_generate_normalize_cb##1\", QuantumToolbox.var\"#_ssesolve_generate_normalize_cb##2#_ssesolve_generate_normalize_cb##3\", typeof(SciMLBase.INITIALIZE_DEFAULT), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}, SciMLBase.DiscreteCallback{typeof(DiffEqCallbacks.true_condition), DiffEqCallbacks.FunctionCallingAffect{QuantumToolbox.SaveFuncSSESolve{true, Vector{SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, Vector{Hermitian{ComplexF64, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, Nothing, Base.RefValue{Int64}, Matrix{ComplexF64}, Matrix{Float64}, Vector{Float64}, Vector{Float64}}, Vector{Float64}, Vector{Float64}}, typeof(DiffEqCallbacks.functioncalling_initialize), typeof(SciMLBase.FINALIZE_DEFAULT), Nothing, Tuple{}}}}}, Matrix{ComplexF64}}, Vector{Float64}, Dimensions{1, Tuple{Space}}, Nothing}, QuantumToolbox.var\"#117#118\"{@Kwargs{sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, store_measurement::Val{true}}, Random.TaskLocalRNG, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, typeof(QuantumToolbox._stochastic_prob_func), Vector{UInt64}}, QuantumToolbox.var\"#103#104\"{typeof(QuantumToolbox._standard_output_func), ProgressMeter.Progress}, typeof(SciMLBase.DEFAULT_REDUCTION), Nothing}, Vector{Float64}, Dimensions{1, Tuple{Space}}, @NamedTuple{progr::ProgressMeter.Progress, channel::Nothing}}, alg::StochasticDiffEq.SRA2, ntraj::Int64, ensemblealg::SciMLBase.EnsembleThreads, keep_runs_results::Val{false})\n", - " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/ssesolve.jl:408\n", - " [16] ssesolve(H::QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}, ψ0::QuantumObject{Operator, Dimensions{1, Tuple{Space}}, Matrix{ComplexF64}}, tlist::StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, sc_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}; alg::Nothing, e_ops::Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}, params::SciMLBase.NullParameters, rng::Random.TaskLocalRNG, ntraj::Int64, ensemblealg::SciMLBase.EnsembleThreads, prob_func::Nothing, output_func::Nothing, progress_bar::Val{true}, keep_runs_results::Val{false}, store_measurement::Val{true}, kwargs::@Kwargs{})\n", - " @ QuantumToolbox /workspaces/QuantumToolbox.jl/src/time_evolution/ssesolve.jl:398\n", - " [17] top-level scope\n", - " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X32sdnNjb2RlLXJlbW90ZQ==.jl:1" - ] - } - ], - "source": [ - "sse_sol = ssesolve(\n", - " H,\n", - " ψ0,\n", - " tlist,\n", - " sc_ops,\n", - " e_ops=[x],\n", - " ntraj=ntraj,\n", - " store_measurement=Val(true),\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "32e57f1a", - "metadata": {}, - "source": [ - "### mesolve" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "6fb34e55", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m[mesolve] 100%|███████████████████████████| Time: 0:00:00 ( 0.86 μs/it)\u001b[39m\u001b[K\n" - ] - }, - { - "data": { - "text/plain": [ - "Solution of time evolution\n", - "(return code: Success)\n", - "--------------------------\n", - "num_states = 101\n", - "num_expect = 0\n", - "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", - "abstol = 1.0e-8\n", - "reltol = 1.0e-6\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ψ0 = fock(2)#qeye(4, type = SuperOperator())\n", - "ψ0 = qeye(4, type = SuperOperator())\n", - "H = sigmaz()\n", - "C = 0.001*sigmam()\n", - "tlist = 0:0.1:10.0\n", - "@inferred mesolve(H, ψ0, tlist, [C])\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "894e9dd0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m[mesolve_map] 100%|███████████████████████| Time: 0:00:00 ( 8.77 ms/it)\u001b[39m\u001b[K\n" - ] - }, - { - "data": { - "text/plain": [ - "2-element Vector{TimeEvolutionSol{Vector{Float64}, Vector{Float64}, Vector{QuantumObject{SuperOperator, Dimensions{1, Tuple{Space}}, Matrix{ComplexF64}}}, Nothing, SciMLBase.ReturnCode.T, OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, Float64}}:\n", - " Solution of time evolution\n", - "(return code: Success)\n", - "--------------------------\n", - "num_states = 101\n", - "num_expect = 0\n", - "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", - "abstol = 1.0e-8\n", - "reltol = 1.0e-6\n", - "\n", - " Solution of time evolution\n", - "(return code: Success)\n", - "--------------------------\n", - "num_states = 101\n", - "num_expect = 0\n", - "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", - "abstol = 1.0e-8\n", - "reltol = 1.0e-6\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# ψ0 = fock(2)\n", - "# ψ1 = fock(2,1)\n", - "H = sigmaz()\n", - "C = 0.001 * sigmam()\n", - "tlist = 0:0.1:10.0\n", - "@inferred mesolve_map(H, [ψ0, ψ0], tlist, [C])" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "e3b995bd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Quantum Object: type=SuperOperator() dims=[2] size=(4, 4)\n", - "4×4 Matrix{ComplexF64}:\n", - " 1.0+0.0im 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 1.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 1.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0+0.0im 1.0+0.0im" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sol[1].states[1]" - ] - }, - { - "cell_type": "markdown", - "id": "235b469f", - "metadata": {}, - "source": [ - "### smsolve" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "c58a7165", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1-element Vector{QuantumObject{Operator, Dimensions{1, Tuple{Space}}, SparseArrays.SparseMatrixCSC{ComplexF64, Int64}}}:\n", - " \n", - "Quantum Object: type=Operator() dims=[20] size=(20, 20) ishermitian=false\n", - "20×20 SparseArrays.SparseMatrixCSC{ComplexF64, Int64} with 19 stored entries:\n", - "⎡⠈⠢⡀⠀⠀⠀⠀⠀⠀⠀⎤\n", - "⎢⠀⠀⠈⠢⡀⠀⠀⠀⠀⠀⎥\n", - "⎢⠀⠀⠀⠀⠈⠢⡀⠀⠀⠀⎥\n", - "⎢⠀⠀⠀⠀⠀⠀⠈⠢⡀⠀⎥\n", - "⎣⠀⠀⠀⠀⠀⠀⠀⠀⠈⠢⎦" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# parameters\n", - "N = 20 # Fock space dimension\n", - "Δ = 5 * 2 * π # cavity detuning\n", - "κ = 2 # cavity decay rate\n", - "α = 4 # intensity of initial state\n", - "ntraj = 500 # number of trajectories\n", - "\n", - "tlist = 0:0.0025:1\n", - "\n", - "# operators\n", - "a = destroy(N)\n", - "x = a + a'\n", - "H = Δ * a' * a\n", - "\n", - "# initial state\n", - "ψ0 = coherent(N, √α)\n", - "\n", - "# temperature with average of 0 excitations (absolute zero)\n", - "n_th = 0\n", - "# c_ops = [√(κ * n_th) * a'] -> nothing\n", - "sc_ops = [√(κ * (n_th + 1)) * a]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "cdb6dd9b", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m[ssesolve] 100%|██████████████████████████| Time: 0:00:08 (17.56 ms/it)\u001b[39m\u001b[K\n" - ] - }, - { - "ename": "UndefVarError", - "evalue": "UndefVarError: `Figure` not defined in `Main`\nSuggestion: check for spelling errors or missing imports.", - "output_type": "error", - "traceback": [ - "UndefVarError: `Figure` not defined in `Main`\n", - "Suggestion: check for spelling errors or missing imports.\n", - "\n", - "Stacktrace:\n", - " [1] top-level scope\n", - " @ /workspaces/QuantumToolbox.jl/jl_notebook_cell_df34fa98e69747e1a8f8a730347b8e2f_X42sdnNjb2RlLXJlbW90ZQ==.jl:15" - ] - } - ], - "source": [ - "sse_sol = ssesolve(\n", - " H,\n", - " ψ0,\n", - " tlist,\n", - " sc_ops,\n", - " e_ops=[x],\n", - " ntraj=ntraj,\n", - " store_measurement=Val(true),\n", - ")\n", - "\n", - "measurement_avg = sum(sse_sol.measurement, dims=2) / size(sse_sol.measurement, 2)\n", - "measurement_avg = dropdims(measurement_avg, dims=2)\n", - "\n", - "\n", - "fig" - ] - }, - { - "cell_type": "markdown", - "id": "ce710f6e", - "metadata": {}, - "source": [ - "### mcsolve" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5fcfab9a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[32m[mcsolve] 100%|███████████████████████████| Time: 0:00:00 ( 0.85 ms/it)\u001b[39m\u001b[K\n" - ] - }, - { - "data": { - "text/plain": [ - "Solution of quantum trajectories\n", - "(converged: true)\n", - "--------------------------------\n", - "num_trajectories = 500\n", - "num_states = 1\n", - "num_expect = 2\n", - "ODE alg.: OrdinaryDiffEqLowOrderRK.DP5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}(OrdinaryDiffEqCore.trivial_limiter!, OrdinaryDiffEqCore.trivial_limiter!, static(false))\n", - "abstol = 1.0e-8\n", - "reltol = 1.0e-6\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "tlist = LinRange(0.0, 10.0, 200)\n", - "\n", - "ψ0 = tensor(fock(2, 0), fock(5, 8))\n", - "ψ0 = to_dense(qeye(2) ⊗ qeye(5))\n", - "a = tensor(qeye(2), destroy(5))\n", - "σm = tensor(destroy(2), qeye(5))\n", - "H = 2 * π * a' * a + 2 * π * σm' * σm + 2 * π * 0.25 * (σm * a' + σm' * a)\n", - "\n", - "c_ops = [sqrt(0.1) * a]\n", - "e_ops = [a' * a, σm' * σm]\n", - "\n", - "sol_500 = mcsolve(H, ψ0, tlist, c_ops, e_ops=e_ops)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "472b2c21", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "\n", - "Quantum Object: type=Operator() dims=[2, 5] size=(10, 10) ishermitian=false\n", - "10×10 Matrix{ComplexF64}:\n", - " 0.586998+0.0im 0.0+0.0im … 0.0+0.0im\n", - " 0.0+0.0im -0.457168+1.78283e-9im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 1.55724e-8-0.000909649im … 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0+0.0im\n", - " 0.0+0.0im 0.0+0.0im 0.0794203-1.18377e-5im" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "sol_500.states[1]" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "090fb9c7", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Julia 1.12.1", - "language": "julia", - "name": "julia-1.12" - }, - "language_info": { - "file_extension": ".jl", - "mimetype": "application/julia", - "name": "julia", - "version": "1.12.1" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 5a354feb0665b422733a6513217f2c75301e08d0 Mon Sep 17 00:00:00 2001 From: Gavin Date: Tue, 2 Dec 2025 21:23:40 +0000 Subject: [PATCH 06/20] Updated the state type variable to ST and made the other changes discussed in the PR comments. --- src/time_evolution/mcsolve.jl | 21 ++++++++++----------- src/time_evolution/mesolve.jl | 18 +++++++----------- src/time_evolution/sesolve.jl | 26 +++++++++++++------------- src/time_evolution/smesolve.jl | 2 +- src/time_evolution/ssesolve.jl | 18 +++++++++--------- src/time_evolution/time_evolution.jl | 3 ++- 6 files changed, 42 insertions(+), 46 deletions(-) diff --git a/src/time_evolution/mcsolve.jl b/src/time_evolution/mcsolve.jl index 5dbf84be4..026d0107e 100644 --- a/src/time_evolution/mcsolve.jl +++ b/src/time_evolution/mcsolve.jl @@ -22,7 +22,7 @@ end function _normalize_state!(u, dims, normalize_states, type) getVal(normalize_states) && normalize!(u) - return QuantumObject(u, type(), dims) + return QuantumObject(u, type, dims) end function _mcsolve_make_Heff_QobjEvo(H::QuantumObject, c_ops) @@ -110,7 +110,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -118,7 +118,7 @@ function mcsolveProblem( rng::AbstractRNG = default_rng(), jump_callback::TJC = ContinuousLindbladJumpCallback(), kwargs..., -) where {TJC<:LindbladJumpCallbackType,X<:Union{Ket,Operator}} +) where {TJC<:LindbladJumpCallbackType,ST<:Union{Ket,Operator}} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -221,7 +221,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolveEnsembleProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -234,7 +234,7 @@ function mcsolveEnsembleProblem( prob_func::Union{Function,Nothing} = nothing, output_func::Union{Tuple,Nothing} = nothing, kwargs..., -) where {TJC<:LindbladJumpCallbackType,X<:Union{Ket,Operator}} +) where {TJC<:LindbladJumpCallbackType,ST<:Union{Ket,Operator}} _prob_func = isnothing(prob_func) ? _ensemble_dispatch_prob_func(rng, ntraj, tlist, _mcsolve_prob_func) : prob_func _output_func = output_func isa Nothing ? @@ -261,7 +261,7 @@ function mcsolveEnsembleProblem( ensemble_prob = TimeEvolutionProblem( EnsembleProblem(prob_mc.prob, prob_func = _prob_func, output_func = _output_func[1], safetycopy = false), prob_mc.times, - X, + ST(), prob_mc.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) @@ -359,7 +359,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; alg::AbstractODEAlgorithm = DP5(), @@ -375,7 +375,7 @@ function mcsolve( keep_runs_results::Union{Val,Bool} = Val(false), normalize_states::Union{Val,Bool} = Val(true), kwargs..., -) where {TJC<:LindbladJumpCallbackType} where {X<:Union{Ket,Operator}} +) where {TJC<:LindbladJumpCallbackType} where {ST<:Union{Ket,Operator}} ens_prob_mc = mcsolveEnsembleProblem( H, ψ0, @@ -415,10 +415,9 @@ function mcsolve( _expvals_sol_1 isa Nothing ? nothing : map(i -> _get_expvals(sol[:, i], SaveFuncMCSolve), eachindex(sol)) expvals_all = _expvals_all isa Nothing ? nothing : stack(_expvals_all, dims = 2) # Stack on dimension 2 to align with QuTiP - # stack to transform Vector{Vector{QuantumObject}} -> Matrix{QuantumObject} - # states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states), eachindex(sol)), dims = 1) + states_all = stack( - map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states, ens_prob_mc.states_type), eachindex(sol)), + map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states, [ens_prob_mc.states_type]), eachindex(sol)), # Unsure why ens_prob_mc.states_type needs to be in an array but the other two arguments don't! dims = 1, ) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 2f2eef109..20234d4d7 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -6,11 +6,11 @@ _mesolve_make_L_QobjEvo(H::Union{QuantumObjectEvolution,Tuple}, c_ops) = liouvil _mesolve_make_L_QobjEvo(H::Nothing, c_ops::Nothing) = throw(ArgumentError("Both H and c_ops are Nothing. You are probably running the wrong function.")) -function _gen_mesolve_solution(sol, prob::TimeEvolutionProblem{X}) where {X<:Union{Operator,OperatorKet,SuperOperator}} - if X() == Operator() - ρt = map(ϕ -> QuantumObject(vec2mat(ϕ), type = X(), dims = prob.dimensions), sol.u) +function _gen_mesolve_solution(sol, prob::TimeEvolutionProblem{ST}) where {ST<:Union{Operator,OperatorKet,SuperOperator}} + if ST == Operator + ρt = map(ϕ -> QuantumObject(vec2mat(ϕ), type = prob.states_type, dims = prob.dimensions), sol.u) else - ρt = map(ϕ -> QuantumObject(ϕ, type = X(), dims = prob.dimensions), sol.u) + ρt = map(ϕ -> QuantumObject(ϕ, type = prob.states_type, dims = prob.dimensions), sol.u) end kwargs = NamedTuple(sol.prob.kwargs) # Convert to NamedTuple for Zygote.jl compatibility @@ -124,8 +124,6 @@ function mesolveProblem( elseif issuper(ψ0) ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) state_type = SuperOperator() - else - throw(ArgumentError("Unsupported state type for ψ0 in mesolveProblem.")) end L = cache_operator(L_evo.data, ρ0) @@ -138,7 +136,7 @@ function mesolveProblem( prob = ODEProblem{getVal(inplace),FullSpecialize}(L, ρ0, tspan, params; kwargs4...) - return TimeEvolutionProblem(prob, tlist, state_type, L_evo.dimensions)#, (isoperket = Val(isoperket(ψ0)),)) + return TimeEvolutionProblem(prob, tlist, state_type, L_evo.dimensions) end @doc raw""" @@ -246,7 +244,7 @@ end function mesolve(prob::TimeEvolutionProblem, alg::AbstractODEAlgorithm = DP5(); kwargs...) sol = solve(prob.prob, alg; kwargs...) - return _gen_mesolve_solution(sol, prob)#, prob.kwargs.isoperket) + return _gen_mesolve_solution(sol, prob) end @doc raw""" @@ -339,8 +337,6 @@ function mesolve_map( to_dense(_complex_float_type(T), mat2vec(ket2dm(state).data)) elseif issuper(state) to_dense(_complex_float_type(T), copy(state.data)) - else - throw(ArgumentError("Unsupported state type for ψ0 in mesolveProblem.")) end end if params isa NullParameters @@ -379,7 +375,7 @@ mesolve_map( # # Return: An array of TimeEvolutionSol objects with the size same as the given iter. function mesolve_map( - prob::TimeEvolutionProblem{StateOpType,<:ODEProblem}, + prob::TimeEvolutionProblem{StateOpType, <:AbstractDimensions, <:ODEProblem}, iter::AbstractArray, alg::AbstractODEAlgorithm = DP5(), ensemblealg::EnsembleAlgorithm = EnsembleThreads(); diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index ac3a1be58..c807e774c 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -2,8 +2,8 @@ export sesolveProblem, sesolve, sesolve_map _sesolve_make_U_QobjEvo(H) = -1im * QuantumObjectEvolution(H, type = Operator()) -function _gen_sesolve_solution(sol, prob::TimeEvolutionProblem{X}) where {X<:Union{Ket,Operator}} - ψt = map(ϕ -> QuantumObject(ϕ, type = X(), dims = prob.dimensions), sol.u) +function _gen_sesolve_solution(sol, prob::TimeEvolutionProblem{ST}) where {ST<:Union{Ket,Operator}} + ψt = map(ϕ -> QuantumObject(ϕ, type = prob.states_type, dims = prob.dimensions), sol.u) kwargs = NamedTuple(sol.prob.kwargs) # Convert to NamedTuple for Zygote.jl compatibility @@ -61,14 +61,14 @@ Generate the ODEProblem for the Schrödinger time evolution of a quantum system: """ function sesolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, params = NullParameters(), progress_bar::Union{Val,Bool} = Val(true), inplace::Union{Val,Bool} = Val(true), kwargs..., -) where {X<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -90,7 +90,7 @@ function sesolveProblem( prob = ODEProblem{getVal(inplace),FullSpecialize}(U, ψ0, tspan, params; kwargs4...) - return TimeEvolutionProblem(prob, tlist, X(), H_evo.dimensions) + return TimeEvolutionProblem(prob, tlist, ST(), H_evo.dimensions) end @doc raw""" @@ -138,7 +138,7 @@ Time evolution of a closed quantum system using the Schrödinger equation: """ function sesolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector; alg::AbstractODEAlgorithm = Vern7(lazy = false), e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -146,7 +146,7 @@ function sesolve( progress_bar::Union{Val,Bool} = Val(true), inplace::Union{Val,Bool} = Val(true), kwargs..., -) where {X<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}} # Move sensealg argument to solve for Enzyme.jl support. # TODO: Remove it when https://github.com/SciML/SciMLSensitivity.jl/issues/1225 is fixed. @@ -225,7 +225,7 @@ for each combination in the ensemble. """ function sesolve_map( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::AbstractVector{<:QuantumObject{X}}, + ψ0::AbstractVector{<:QuantumObject{ST}}, tlist::AbstractVector; alg::AbstractODEAlgorithm = Vern7(lazy = false), ensemblealg::EnsembleAlgorithm = EnsembleThreads(), @@ -233,7 +233,7 @@ function sesolve_map( params::Union{NullParameters,Tuple} = NullParameters(), progress_bar::Union{Val,Bool} = Val(true), kwargs..., -) where {X<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}} # mapping initial states and parameters ψ0 = map(to_dense, ψ0) # Convert all initial states to dense vectors @@ -260,10 +260,10 @@ function sesolve_map( end sesolve_map( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector; kwargs..., -) where {X<:Union{Ket,Operator}} = sesolve_map(H, [ψ0], tlist; kwargs...) +) where {ST<:Union{Ket,Operator}} = sesolve_map(H, [ψ0], tlist; kwargs...) # this method is for advanced usage # User can define their own iterator structure, prob_func and output_func @@ -272,14 +272,14 @@ sesolve_map( # # Return: An array of TimeEvolutionSol objects with the size same as the given iter. function sesolve_map( - prob::TimeEvolutionProblem{X,<:ODEProblem}, + prob::TimeEvolutionProblem{ST, <:AbstractDimensions, <:ODEProblem}, iter::AbstractArray, alg::AbstractODEAlgorithm = Vern7(lazy = false), ensemblealg::EnsembleAlgorithm = EnsembleThreads(); prob_func::Union{Function,Nothing} = nothing, output_func::Union{Tuple,Nothing} = nothing, progress_bar::Union{Val,Bool} = Val(true), -) where {X<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}} # generate ensemble problem ntraj = length(iter) _prob_func = isnothing(prob_func) ? (prob, i, repeat) -> _se_me_map_prob_func(prob, i, repeat, iter) : prob_func diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index 113cfc9df..7beac45e4 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -146,7 +146,7 @@ function smesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist, X(), dims) + return TimeEvolutionProblem(prob, tlist,StateOpType(), dims) end @doc raw""" diff --git a/src/time_evolution/ssesolve.jl b/src/time_evolution/ssesolve.jl index 15dee2d6e..f56396b5a 100644 --- a/src/time_evolution/ssesolve.jl +++ b/src/time_evolution/ssesolve.jl @@ -76,7 +76,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is th """ function ssesolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -85,7 +85,7 @@ function ssesolveProblem( progress_bar::Union{Val,Bool} = Val(true), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) where {X<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -142,7 +142,7 @@ function ssesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist, X(), dims) + return TimeEvolutionProblem(prob, tlist, ST(), dims) end @doc raw""" @@ -218,7 +218,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is t """ function ssesolveEnsembleProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -231,7 +231,7 @@ function ssesolveEnsembleProblem( progress_bar::Union{Val,Bool} = Val(true), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) where {X<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}} _prob_func = isnothing(prob_func) ? _ensemble_dispatch_prob_func( @@ -268,7 +268,7 @@ function ssesolveEnsembleProblem( ensemble_prob = TimeEvolutionProblem( EnsembleProblem(prob_sme, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), prob_sme.times, - X(), + ST(), prob_sme.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) @@ -356,7 +356,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is th """ function ssesolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{X}, + ψ0::QuantumObject{ST}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; alg::Union{Nothing,AbstractSDEAlgorithm} = nothing, @@ -371,7 +371,7 @@ function ssesolve( keep_runs_results::Union{Val,Bool} = Val(false), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) where {X<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}} ens_prob = ssesolveEnsembleProblem( H, ψ0, @@ -418,7 +418,7 @@ function ssesolve( expvals_all = _expvals_all isa Nothing ? nothing : stack(_expvals_all, dims = 2) # Stack on dimension 2 to align with QuTiP # stack to transform Vector{Vector{QuantumObject}} -> Matrix{QuantumObject} - states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states), eachindex(sol)), dims = 1) + states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states, [ens_prob.states_type]), eachindex(sol)), dims = 1) _m_expvals = _m_expvals_sol_1 isa Nothing ? nothing : map(i -> _get_m_expvals(sol[:, i], SaveFuncSSESolve), eachindex(sol)) diff --git a/src/time_evolution/time_evolution.jl b/src/time_evolution/time_evolution.jl index 1aa375a97..a855c34ac 100644 --- a/src/time_evolution/time_evolution.jl +++ b/src/time_evolution/time_evolution.jl @@ -19,13 +19,14 @@ A Julia constructor for handling the `ODEProblem` of the time evolution of quant - `prob::AbstractSciMLProblem`: The `ODEProblem` of the time evolution. - `times::AbstractVector`: The time list of the evolution. +- `states_type::QuantumObjectType`: The type of the quantum states during the evolution (e.g., `Ket`, `Operator`, `OperatorKet` or `SuperOperator`). - `dimensions::AbstractDimensions`: The dimensions of the Hilbert space. - `kwargs::KWT`: Generic keyword arguments. !!! note "`dims` property" For a given `prob::TimeEvolutionProblem`, `prob.dims` or `getproperty(prob, :dims)` returns its `dimensions` in the type of integer-vector. """ -struct TimeEvolutionProblem{ST,PT<:AbstractSciMLProblem,TT<:AbstractVector,DT<:AbstractDimensions,KWT} +struct TimeEvolutionProblem{ST<:QuantumObjectType, DT<:AbstractDimensions,PT<:AbstractSciMLProblem,TT<:AbstractVector,KWT} prob::PT times::TT states_type::ST From d8d26a3158b5d119a6d53e0ada021be240d92fe6 Mon Sep 17 00:00:00 2001 From: Gavin Date: Tue, 2 Dec 2025 22:24:23 +0000 Subject: [PATCH 07/20] fixed a bug with smesolve! --- src/time_evolution/mesolve.jl | 2 +- src/time_evolution/smesolve.jl | 18 +++++++++++++----- 2 files changed, 14 insertions(+), 6 deletions(-) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 20234d4d7..ebc4481cb 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -7,7 +7,7 @@ _mesolve_make_L_QobjEvo(H::Nothing, c_ops::Nothing) = throw(ArgumentError("Both c_ops are Nothing. You are probably running the wrong function.")) function _gen_mesolve_solution(sol, prob::TimeEvolutionProblem{ST}) where {ST<:Union{Operator,OperatorKet,SuperOperator}} - if ST == Operator + if prob.states_type == Operator ρt = map(ϕ -> QuantumObject(vec2mat(ϕ), type = prob.states_type, dims = prob.dimensions), sol.u) else ρt = map(ϕ -> QuantumObject(ϕ, type = prob.states_type, dims = prob.dimensions), sol.u) diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index 7beac45e4..207ff9ba2 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -1,7 +1,14 @@ export smesolveProblem, smesolveEnsembleProblem, smesolve -_smesolve_generate_state(u, dims, isoperket::Val{false}) = QuantumObject(vec2mat(u), type = Operator(), dims = dims) -_smesolve_generate_state(u, dims, isoperket::Val{true}) = QuantumObject(u, type = OperatorKet(), dims = dims) +#_smesolve_generate_state(u, dims, isoperket::Val{false}) = QuantumObject(vec2mat(u), type = Operator(), dims = dims) +#_smesolve_generate_state(u, dims, isoperket::Val{true}) = QuantumObject(u, type = OperatorKet(), dims = dims) +function _smesolve_generate_state(u, dims, type) + if type == OperatorKet + return QuantumObject(u, type = type, dims = dims) + else + return QuantumObject(vec2mat(u), type = Operator(), dims = dims) + end +end function _smesolve_update_coeff(u, p, t, op_vec) return 2 * real(dot(op_vec, u)) #this is Tr[Sn * ρ + ρ * Sn'] @@ -146,7 +153,7 @@ function smesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist,StateOpType(), dims) + return TimeEvolutionProblem(prob, tlist,StateOpType(), dims, ()) end @doc raw""" @@ -274,8 +281,9 @@ function smesolveEnsembleProblem( ensemble_prob = TimeEvolutionProblem( EnsembleProblem(prob_sme, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), prob_sme.times, + StateOpType(), prob_sme.dimensions, - merge(prob_sme.kwargs, (progr = _output_func[2], channel = _output_func[3])), + (progr = _output_func[2], channel = _output_func[3]), ) return ensemble_prob @@ -422,7 +430,7 @@ function smesolve( # stack to transform Vector{Vector{QuantumObject}} -> Matrix{QuantumObject} states_all = stack( - map(i -> _smesolve_generate_state.(sol[:, i].u, Ref(dims), ens_prob.kwargs.isoperket), eachindex(sol)), + map(i -> _smesolve_generate_state.(sol[:, i].u, Ref(dims), [ens_prob.states_type]), eachindex(sol)), dims = 1, ) From db3422ec5c26a2f247649dbbf279a4b3d0fce116 Mon Sep 17 00:00:00 2001 From: Gavin Date: Tue, 9 Dec 2025 00:31:35 +0000 Subject: [PATCH 08/20] Updated ssesolve, smesolve and mcsolve to be minimal changes along with a few other changes. --- src/time_evolution/mcsolve.jl | 8 ++++---- src/time_evolution/mesolve.jl | 12 ++++++------ src/time_evolution/sesolve.jl | 3 ++- src/time_evolution/smesolve.jl | 12 +++++++----- src/time_evolution/ssesolve.jl | 13 +++++++------ 5 files changed, 26 insertions(+), 22 deletions(-) diff --git a/src/time_evolution/mcsolve.jl b/src/time_evolution/mcsolve.jl index 026d0107e..7ef0c667c 100644 --- a/src/time_evolution/mcsolve.jl +++ b/src/time_evolution/mcsolve.jl @@ -118,7 +118,7 @@ function mcsolveProblem( rng::AbstractRNG = default_rng(), jump_callback::TJC = ContinuousLindbladJumpCallback(), kwargs..., -) where {TJC<:LindbladJumpCallbackType,ST<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}, TJC<:LindbladJumpCallbackType} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -234,7 +234,7 @@ function mcsolveEnsembleProblem( prob_func::Union{Function,Nothing} = nothing, output_func::Union{Tuple,Nothing} = nothing, kwargs..., -) where {TJC<:LindbladJumpCallbackType,ST<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}, TJC<:LindbladJumpCallbackType} _prob_func = isnothing(prob_func) ? _ensemble_dispatch_prob_func(rng, ntraj, tlist, _mcsolve_prob_func) : prob_func _output_func = output_func isa Nothing ? @@ -261,7 +261,7 @@ function mcsolveEnsembleProblem( ensemble_prob = TimeEvolutionProblem( EnsembleProblem(prob_mc.prob, prob_func = _prob_func, output_func = _output_func[1], safetycopy = false), prob_mc.times, - ST(), + prob_mc.states_type, prob_mc.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) @@ -375,7 +375,7 @@ function mcsolve( keep_runs_results::Union{Val,Bool} = Val(false), normalize_states::Union{Val,Bool} = Val(true), kwargs..., -) where {TJC<:LindbladJumpCallbackType} where {ST<:Union{Ket,Operator}} +) where {ST<:Union{Ket,Operator}, TJC<:LindbladJumpCallbackType} ens_prob_mc = mcsolveEnsembleProblem( H, ψ0, diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index ebc4481cb..183a83d79 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -114,16 +114,16 @@ function mesolveProblem( # end if isoper(ψ0) ρ0 = to_dense(_complex_float_type(T), mat2vec(ψ0.data)) - state_type = Operator() + states_type = Operator() elseif isoperket(ψ0) ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) - state_type = OperatorKet() + states_type = OperatorKet() elseif isket(ψ0) ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) - state_type = Operator() + states_type = Operator() elseif issuper(ψ0) ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) - state_type = SuperOperator() + states_type = SuperOperator() end L = cache_operator(L_evo.data, ρ0) @@ -136,7 +136,7 @@ function mesolveProblem( prob = ODEProblem{getVal(inplace),FullSpecialize}(L, ρ0, tspan, params; kwargs4...) - return TimeEvolutionProblem(prob, tlist, state_type, L_evo.dimensions) + return TimeEvolutionProblem(prob, tlist, states_type, L_evo.dimensions) end @doc raw""" @@ -398,7 +398,7 @@ function mesolve_map( ens_prob = TimeEvolutionProblem( EnsembleProblem(prob.prob, prob_func = _prob_func, output_func = _output_func[1], safetycopy = false), prob.times, - StateOpType(), + prob.states_type, prob.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index c807e774c..03c77cd4f 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -73,6 +73,7 @@ function sesolveProblem( throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) tlist = _check_tlist(tlist, _float_type(ψ0)) + states_type = ψ0.type H_evo = _sesolve_make_U_QobjEvo(H) # Multiply by -i isoper(H_evo) || throw(ArgumentError("The Hamiltonian must be an Operator.")) @@ -90,7 +91,7 @@ function sesolveProblem( prob = ODEProblem{getVal(inplace),FullSpecialize}(U, ψ0, tspan, params; kwargs4...) - return TimeEvolutionProblem(prob, tlist, ST(), H_evo.dimensions) + return TimeEvolutionProblem(prob, tlist, states_type, H_evo.dimensions) end @doc raw""" diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index 207ff9ba2..689505410 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -108,10 +108,12 @@ function smesolveProblem( dims = L_evo.dimensions T = Base.promote_eltype(L_evo, ψ0) - ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type - to_dense(_complex_float_type(T), copy(ψ0.data)) + if isoperket(ψ0) # Convert it to dense vector with complex element type + ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) + states_type = OperatorKet() else - to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) + ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) + states_type = Operator() end sc_ops_evo_data = Tuple(map(get_data ∘ QobjEvo, sc_ops_list)) @@ -153,7 +155,7 @@ function smesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist,StateOpType(), dims, ()) + return TimeEvolutionProblem(prob, tlist, states_type, dims, ()) end @doc raw""" @@ -281,7 +283,7 @@ function smesolveEnsembleProblem( ensemble_prob = TimeEvolutionProblem( EnsembleProblem(prob_sme, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), prob_sme.times, - StateOpType(), + prob_sme.states_type, prob_sme.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) diff --git a/src/time_evolution/ssesolve.jl b/src/time_evolution/ssesolve.jl index f56396b5a..19d0b8abb 100644 --- a/src/time_evolution/ssesolve.jl +++ b/src/time_evolution/ssesolve.jl @@ -95,6 +95,7 @@ function ssesolveProblem( sc_ops_isa_Qobj = sc_ops isa AbstractQuantumObject # We can avoid using non-diagonal noise if sc_ops is just an AbstractQuantumObject tlist = _check_tlist(tlist, _float_type(ψ0)) + states_type = ψ0.type H_eff_evo = _mcsolve_make_Heff_QobjEvo(H, sc_ops_list) isoper(H_eff_evo) || throw(ArgumentError("The Hamiltonian must be an Operator.")) @@ -142,7 +143,7 @@ function ssesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist, ST(), dims) + return TimeEvolutionProblem(prob, tlist, states_type, dims) end @doc raw""" @@ -252,7 +253,7 @@ function ssesolveEnsembleProblem( progr_desc = "[ssesolve] ", ) : output_func - prob_sme = ssesolveProblem( + prob_sse = ssesolveProblem( H, ψ0, tlist, @@ -266,10 +267,10 @@ function ssesolveEnsembleProblem( ) ensemble_prob = TimeEvolutionProblem( - EnsembleProblem(prob_sme, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), - prob_sme.times, - ST(), - prob_sme.dimensions, + EnsembleProblem(prob_sse, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), + prob_sse.times, + prob_sse.states_type, + prob_sse.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) From 01a205cec1fb59022d25380f29b2a05a472ee584 Mon Sep 17 00:00:00 2001 From: Gavin Date: Tue, 9 Dec 2025 00:31:36 +0000 Subject: [PATCH 09/20] Updated ssesolve, smesolve and mcsolve to be minmial working changes. --- src/time_evolution/mcsolve.jl | 25 +++++++++----------- src/time_evolution/mesolve.jl | 42 +++++++++++++--------------------- src/time_evolution/sesolve.jl | 7 ++++-- src/time_evolution/smesolve.jl | 23 +++++++------------ src/time_evolution/ssesolve.jl | 28 +++++++++++------------ 5 files changed, 54 insertions(+), 71 deletions(-) diff --git a/src/time_evolution/mcsolve.jl b/src/time_evolution/mcsolve.jl index 7ef0c667c..e821ab215 100644 --- a/src/time_evolution/mcsolve.jl +++ b/src/time_evolution/mcsolve.jl @@ -20,9 +20,9 @@ function _mcsolve_output_func(sol, i) return (sol, false) end -function _normalize_state!(u, dims, normalize_states, type) +function _normalize_state!(u, dims, normalize_states) getVal(normalize_states) && normalize!(u) - return QuantumObject(u, type, dims) + return QuantumObject(u, Ket(), dims) end function _mcsolve_make_Heff_QobjEvo(H::QuantumObject, c_ops) @@ -110,7 +110,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{ST}, + ψ0::QuantumObject{Ket}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -118,7 +118,7 @@ function mcsolveProblem( rng::AbstractRNG = default_rng(), jump_callback::TJC = ContinuousLindbladJumpCallback(), kwargs..., -) where {ST<:Union{Ket,Operator}, TJC<:LindbladJumpCallbackType} +) where {TJC<:LindbladJumpCallbackType} haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -221,7 +221,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolveEnsembleProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{ST}, + ψ0::QuantumObject{Ket}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -234,7 +234,7 @@ function mcsolveEnsembleProblem( prob_func::Union{Function,Nothing} = nothing, output_func::Union{Tuple,Nothing} = nothing, kwargs..., -) where {ST<:Union{Ket,Operator}, TJC<:LindbladJumpCallbackType} +) where {TJC<:LindbladJumpCallbackType} _prob_func = isnothing(prob_func) ? _ensemble_dispatch_prob_func(rng, ntraj, tlist, _mcsolve_prob_func) : prob_func _output_func = output_func isa Nothing ? @@ -359,7 +359,7 @@ If the environmental measurements register a quantum jump, the wave function und """ function mcsolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{ST}, + ψ0::QuantumObject{Ket}, tlist::AbstractVector, c_ops::Union{Nothing,AbstractVector,Tuple} = nothing; alg::AbstractODEAlgorithm = DP5(), @@ -375,7 +375,7 @@ function mcsolve( keep_runs_results::Union{Val,Bool} = Val(false), normalize_states::Union{Val,Bool} = Val(true), kwargs..., -) where {ST<:Union{Ket,Operator}, TJC<:LindbladJumpCallbackType} +) where {TJC<:LindbladJumpCallbackType} ens_prob_mc = mcsolveEnsembleProblem( H, ψ0, @@ -415,11 +415,8 @@ function mcsolve( _expvals_sol_1 isa Nothing ? nothing : map(i -> _get_expvals(sol[:, i], SaveFuncMCSolve), eachindex(sol)) expvals_all = _expvals_all isa Nothing ? nothing : stack(_expvals_all, dims = 2) # Stack on dimension 2 to align with QuTiP - - states_all = stack( - map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states, [ens_prob_mc.states_type]), eachindex(sol)), # Unsure why ens_prob_mc.states_type needs to be in an array but the other two arguments don't! - dims = 1, - ) + # stack to transform Vector{Vector{QuantumObject}} -> Matrix{QuantumObject} + states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states), eachindex(sol)), dims = 1) col_times = map(i -> _mc_get_jump_callback(sol[:, i]).affect!.col_times, eachindex(sol)) col_which = map(i -> _mc_get_jump_callback(sol[:, i]).affect!.col_which, eachindex(sol)) @@ -439,4 +436,4 @@ function mcsolve( kwargs.abstol, kwargs.reltol, ) -end +end \ No newline at end of file diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 183a83d79..3ae4813f6 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -7,7 +7,7 @@ _mesolve_make_L_QobjEvo(H::Nothing, c_ops::Nothing) = throw(ArgumentError("Both c_ops are Nothing. You are probably running the wrong function.")) function _gen_mesolve_solution(sol, prob::TimeEvolutionProblem{ST}) where {ST<:Union{Operator,OperatorKet,SuperOperator}} - if prob.states_type == Operator + if prob.states_type isa Operator ρt = map(ϕ -> QuantumObject(vec2mat(ϕ), type = prob.states_type, dims = prob.dimensions), sol.u) else ρt = map(ϕ -> QuantumObject(ϕ, type = prob.states_type, dims = prob.dimensions), sol.u) @@ -66,6 +66,7 @@ where # Notes +- The initial state can also be [`SuperOperator`](@ref) (such as a super-identity). This is useful for simulating many density matrices simultaneously or calculating process matrices. Currently must be Square. - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolveProblem`](@ref) instead. @@ -106,24 +107,15 @@ function mesolveProblem( L_evo = _mesolve_make_L_QobjEvo(H, c_ops) check_dimensions(L_evo, ψ0) - T = Base.promote_eltype(L_evo, ψ0) - # ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type - # to_dense(_complex_float_type(T), copy(ψ0.data)) - # else - # to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) - # end - if isoper(ψ0) - ρ0 = to_dense(_complex_float_type(T), mat2vec(ψ0.data)) - states_type = Operator() - elseif isoperket(ψ0) - ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) - states_type = OperatorKet() - elseif isket(ψ0) - ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) + # Convert to dense vector with complex element type + + T = _complex_float_type(Base.promote_eltype(L_evo, ψ0)) + if isoperket(ψ0) || issuper(ψ0) + ρ0 = to_dense(T, copy(ψ0.data)) + states_type = ψ0.type + else + ρ0 = to_dense(T, mat2vec(ket2dm(ψ0).data)) states_type = Operator() - elseif issuper(ψ0) - ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) - states_type = SuperOperator() end L = cache_operator(L_evo.data, ρ0) @@ -180,6 +172,7 @@ where # Notes +- The initial state can also be [`SuperOperator`](@ref) (such as a super-identity). This is useful for simulating many density matrices simultaneously or calculating process matrices. Currently must be Square. - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolve`](@ref) instead. @@ -292,6 +285,7 @@ for each combination in the ensemble. # Notes +- The initial state can also be [`SuperOperator`](@ref) (such as a super-identity). This is useful for simulating many density matrices simultaneously or calculating process matrices. Currently must be Square. - The function returns an array of solutions with dimensions matching the Cartesian product of initial states and parameter sets. - If `ψ0` is a vector of `m` states and `params = (p1, p2, ...)` where `p1` has length `n1`, `p2` has length `n2`, etc., the output will be of size `(m, n1, n2, ...)`. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolve_map`](@ref) instead. @@ -329,14 +323,10 @@ function mesolve_map( # Convert to appropriate format based on state type ψ0_iter = map(ψ0) do state T = _complex_float_type(eltype(state)) - if isoper(state) - to_dense(_complex_float_type(T), mat2vec(state.data)) - elseif isoperket(state) - to_dense(_complex_float_type(T), copy(state.data)) - elseif isket(state) - to_dense(_complex_float_type(T), mat2vec(ket2dm(state).data)) - elseif issuper(state) - to_dense(_complex_float_type(T), copy(state.data)) + if isoperket(state) || issuper(state) + to_dense(T, copy(state.data)) + else + to_dense(T, mat2vec(ket2dm(state).data)) end end if params isa NullParameters diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index 03c77cd4f..4f9b6ea60 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -50,6 +50,7 @@ Generate the ODEProblem for the Schrödinger time evolution of a quantum system: # Notes +- Initial state can also be [`Operator`](@ref)s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate the propagator. - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - The default tolerances in `kwargs` are given as `reltol=1e-6` and `abstol=1e-8`. @@ -127,6 +128,7 @@ Time evolution of a closed quantum system using the Schrödinger equation: # Notes +- Initial state can also be [`Operator`](@ref)s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate the propagator. - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - The default tolerances in `kwargs` are given as `reltol=1e-6` and `abstol=1e-8`. @@ -215,9 +217,10 @@ for each combination in the ensemble. - `kwargs`: The keyword arguments for the ODEProblem. # Notes - +- Initial state can also be [`Operator`](@ref)s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate the propagator. - The function returns an array of solutions with dimensions matching the Cartesian product of initial states and parameter sets. - If `ψ0` is a vector of `m` states and `params = (p1, p2, ...)` where `p1` has length `n1`, `p2` has length `n2`, etc., the output will be of size `(m, n1, n2, ...)`. +- Similarly, the initial state(s) can also be `Operator`s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate many propagators. - See [`sesolve`](@ref) for more details. # Returns @@ -239,7 +242,7 @@ function sesolve_map( ψ0 = map(to_dense, ψ0) # Convert all initial states to dense vectors - ψ0_iter = map(get_data, ψ0) + ψ0_iter = map(state -> to_dense(_complex_float_type(eltype(state)), copy(state.data)), ψ0) if params isa NullParameters iter = collect(Iterators.product(ψ0_iter, [params])) |> vec # convert nx1 Matrix into Vector else diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index 689505410..cfde5469d 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -1,14 +1,7 @@ export smesolveProblem, smesolveEnsembleProblem, smesolve -#_smesolve_generate_state(u, dims, isoperket::Val{false}) = QuantumObject(vec2mat(u), type = Operator(), dims = dims) -#_smesolve_generate_state(u, dims, isoperket::Val{true}) = QuantumObject(u, type = OperatorKet(), dims = dims) -function _smesolve_generate_state(u, dims, type) - if type == OperatorKet - return QuantumObject(u, type = type, dims = dims) - else - return QuantumObject(vec2mat(u), type = Operator(), dims = dims) - end -end +_smesolve_generate_state(u, dims, isoperket::Val{false}) = QuantumObject(vec2mat(u), type = Operator(), dims = dims) +_smesolve_generate_state(u, dims, isoperket::Val{true}) = QuantumObject(u, type = OperatorKet(), dims = dims) function _smesolve_update_coeff(u, p, t, op_vec) return 2 * real(dot(op_vec, u)) #this is Tr[Sn * ρ + ρ * Sn'] @@ -110,10 +103,10 @@ function smesolveProblem( T = Base.promote_eltype(L_evo, ψ0) if isoperket(ψ0) # Convert it to dense vector with complex element type ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) - states_type = OperatorKet() + state_type = OperatorKet() else ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) - states_type = Operator() + state_type = Operator() end sc_ops_evo_data = Tuple(map(get_data ∘ QobjEvo, sc_ops_list)) @@ -155,7 +148,7 @@ function smesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist, states_type, dims, ()) + return TimeEvolutionProblem(prob, tlist, state_type, dims, (isoperket = Val(isoperket(ψ0)),)) end @doc raw""" @@ -285,7 +278,7 @@ function smesolveEnsembleProblem( prob_sme.times, prob_sme.states_type, prob_sme.dimensions, - (progr = _output_func[2], channel = _output_func[3]), + merge(prob_sme.kwargs, (progr = _output_func[2], channel = _output_func[3])), ) return ensemble_prob @@ -432,7 +425,7 @@ function smesolve( # stack to transform Vector{Vector{QuantumObject}} -> Matrix{QuantumObject} states_all = stack( - map(i -> _smesolve_generate_state.(sol[:, i].u, Ref(dims), [ens_prob.states_type]), eachindex(sol)), + map(i -> _smesolve_generate_state.(sol[:, i].u, Ref(dims), ens_prob.kwargs.isoperket), eachindex(sol)), dims = 1, ) @@ -454,4 +447,4 @@ function smesolve( kwargs.abstol, kwargs.reltol, ) -end +end \ No newline at end of file diff --git a/src/time_evolution/ssesolve.jl b/src/time_evolution/ssesolve.jl index 19d0b8abb..2ef72a548 100644 --- a/src/time_evolution/ssesolve.jl +++ b/src/time_evolution/ssesolve.jl @@ -76,7 +76,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is th """ function ssesolveProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{ST}, + ψ0::QuantumObject{Ket}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -85,7 +85,7 @@ function ssesolveProblem( progress_bar::Union{Val,Bool} = Val(true), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) where {ST<:Union{Ket,Operator}} +) haskey(kwargs, :save_idxs) && throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox.")) @@ -95,13 +95,13 @@ function ssesolveProblem( sc_ops_isa_Qobj = sc_ops isa AbstractQuantumObject # We can avoid using non-diagonal noise if sc_ops is just an AbstractQuantumObject tlist = _check_tlist(tlist, _float_type(ψ0)) - states_type = ψ0.type H_eff_evo = _mcsolve_make_Heff_QobjEvo(H, sc_ops_list) isoper(H_eff_evo) || throw(ArgumentError("The Hamiltonian must be an Operator.")) check_dimensions(H_eff_evo, ψ0) dims = H_eff_evo.dimensions + states_type = ψ0.type ψ0 = to_dense(_complex_float_type(ψ0), get_data(ψ0)) sc_ops_evo_data = Tuple(map(get_data ∘ QobjEvo, sc_ops_list)) @@ -219,7 +219,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is t """ function ssesolveEnsembleProblem( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{ST}, + ψ0::QuantumObject{Ket}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; e_ops::Union{Nothing,AbstractVector,Tuple} = nothing, @@ -232,7 +232,7 @@ function ssesolveEnsembleProblem( progress_bar::Union{Val,Bool} = Val(true), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) where {ST<:Union{Ket,Operator}} +) _prob_func = isnothing(prob_func) ? _ensemble_dispatch_prob_func( @@ -253,7 +253,7 @@ function ssesolveEnsembleProblem( progr_desc = "[ssesolve] ", ) : output_func - prob_sse = ssesolveProblem( + prob_sme = ssesolveProblem( H, ψ0, tlist, @@ -267,10 +267,10 @@ function ssesolveEnsembleProblem( ) ensemble_prob = TimeEvolutionProblem( - EnsembleProblem(prob_sse, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), - prob_sse.times, - prob_sse.states_type, - prob_sse.dimensions, + EnsembleProblem(prob_sme, prob_func = _prob_func, output_func = _output_func[1], safetycopy = true), + prob_sme.times, + prob_sme.states_type, + prob_sme.dimensions, (progr = _output_func[2], channel = _output_func[3]), ) @@ -357,7 +357,7 @@ Above, ``\hat{S}_n`` are the stochastic collapse operators and ``dW_n(t)`` is th """ function ssesolve( H::Union{AbstractQuantumObject{Operator},Tuple}, - ψ0::QuantumObject{ST}, + ψ0::QuantumObject{Ket}, tlist::AbstractVector, sc_ops::Union{Nothing,AbstractVector,Tuple,AbstractQuantumObject} = nothing; alg::Union{Nothing,AbstractSDEAlgorithm} = nothing, @@ -372,7 +372,7 @@ function ssesolve( keep_runs_results::Union{Val,Bool} = Val(false), store_measurement::Union{Val,Bool} = Val(false), kwargs..., -) where {ST<:Union{Ket,Operator}} +) ens_prob = ssesolveEnsembleProblem( H, ψ0, @@ -419,7 +419,7 @@ function ssesolve( expvals_all = _expvals_all isa Nothing ? nothing : stack(_expvals_all, dims = 2) # Stack on dimension 2 to align with QuTiP # stack to transform Vector{Vector{QuantumObject}} -> Matrix{QuantumObject} - states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states, [ens_prob.states_type]), eachindex(sol)), dims = 1) + states_all = stack(map(i -> _normalize_state!.(sol[:, i].u, Ref(dims), normalize_states), eachindex(sol)), dims = 1) _m_expvals = _m_expvals_sol_1 isa Nothing ? nothing : map(i -> _get_m_expvals(sol[:, i], SaveFuncSSESolve), eachindex(sol)) @@ -439,4 +439,4 @@ function ssesolve( kwargs.abstol, kwargs.reltol, ) -end +end \ No newline at end of file From aa176c5abf0e58118ff7bb16e91637d90f70b9f7 Mon Sep 17 00:00:00 2001 From: Gavin Date: Tue, 9 Dec 2025 17:04:10 +0000 Subject: [PATCH 10/20] Modified the docs and added a new `vec2mat(A::AbstractMatrix) = x` to sort out an issue that came up in the tests. Now all core tests pass. --- src/qobj/functions.jl | 3 +++ src/time_evolution/mesolve.jl | 3 +-- src/time_evolution/sesolve.jl | 6 ++---- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/qobj/functions.jl b/src/qobj/functions.jl index 219bd5854..2ee0e67a1 100644 --- a/src/qobj/functions.jl +++ b/src/qobj/functions.jl @@ -259,6 +259,9 @@ function vec2mat(A::AbstractVector) newsize = isqrt(length(A)) return reshape(A, newsize, newsize) end +function vec2mat(A::AbstractMatrix) + return A +end @doc raw""" vec2mat(A::QuantumObject) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 3ae4813f6..0508b0b41 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -160,7 +160,7 @@ where # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref), [`Operator`](@ref) or [`OperatorKet`](@ref). +- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref) or [`SuperOperator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `c_ops`: List of collapse operators ``\{\hat{C}_n\}_n``. It can be either a `Vector` or a `Tuple`. - `alg`: The algorithm for the ODE solver. The default value is `DP5()`. @@ -172,7 +172,6 @@ where # Notes -- The initial state can also be [`SuperOperator`](@ref) (such as a super-identity). This is useful for simulating many density matrices simultaneously or calculating process matrices. Currently must be Square. - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolve`](@ref) instead. diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index 4f9b6ea60..f65704815 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -117,7 +117,7 @@ Time evolution of a closed quantum system using the Schrödinger equation: # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. +- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref) or a [`Operator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `alg`: The algorithm for the ODE solver. The default is `Vern7(lazy=false)`. - `e_ops`: List of operators for which to calculate expectation values. It can be either a `Vector` or a `Tuple`. @@ -128,7 +128,6 @@ Time evolution of a closed quantum system using the Schrödinger equation: # Notes -- Initial state can also be [`Operator`](@ref)s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate the propagator. - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - The default tolerances in `kwargs` are given as `reltol=1e-6` and `abstol=1e-8`. @@ -217,10 +216,9 @@ for each combination in the ensemble. - `kwargs`: The keyword arguments for the ODEProblem. # Notes -- Initial state can also be [`Operator`](@ref)s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate the propagator. + - The function returns an array of solutions with dimensions matching the Cartesian product of initial states and parameter sets. - If `ψ0` is a vector of `m` states and `params = (p1, p2, ...)` where `p1` has length `n1`, `p2` has length `n2`, etc., the output will be of size `(m, n1, n2, ...)`. -- Similarly, the initial state(s) can also be `Operator`s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate many propagators. - See [`sesolve`](@ref) for more details. # Returns From 8bc6422897095c9d3541ac9c8fab7cf38b3d784b Mon Sep 17 00:00:00 2001 From: Gavin Date: Thu, 11 Dec 2025 20:49:34 +0000 Subject: [PATCH 11/20] updated docs, changelog, propagators.jl test and a few other small things. --- CHANGELOG.md | 1 + src/qobj/functions.jl | 3 --- .../mcsolve_callback_helpers.jl | 2 +- src/time_evolution/mesolve.jl | 6 +++--- src/time_evolution/sesolve.jl | 1 + src/time_evolution/smesolve.jl | 10 ++++------ test/core-test/propagator.jl | 20 +++++++++++++++++++ 7 files changed, 30 insertions(+), 13 deletions(-) create mode 100644 test/core-test/propagator.jl diff --git a/CHANGELOG.md b/CHANGELOG.md index 84bc5139e..b1424096e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ## [Unreleased](https://github.com/qutip/QuantumToolbox.jl/tree/main) - Add error message for bad input in state/operator generating functions ([#603]) +- Extend `sesolve` and `mesolve` to handle `Operator` and `SuperOperator` as initial conditions for propagator calculation. This introduces a `states_type` field to `TimeEvolutionProblem`. ([#606]) ## [v0.39.1] Release date: 2025-11-19 diff --git a/src/qobj/functions.jl b/src/qobj/functions.jl index 2ee0e67a1..219bd5854 100644 --- a/src/qobj/functions.jl +++ b/src/qobj/functions.jl @@ -259,9 +259,6 @@ function vec2mat(A::AbstractVector) newsize = isqrt(length(A)) return reshape(A, newsize, newsize) end -function vec2mat(A::AbstractMatrix) - return A -end @doc raw""" vec2mat(A::QuantumObject) diff --git a/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl b/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl index 499140fff..e7c9837cc 100644 --- a/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl +++ b/src/time_evolution/callback_helpers/mcsolve_callback_helpers.jl @@ -18,7 +18,7 @@ struct LindbladJump{ T2, RNGType<:AbstractRNG, RandT, - CT<:AbstractArray, + CT<:AbstractVector, WT<:AbstractVector, JTT<:AbstractVector, JWT<:AbstractVector, diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 0508b0b41..fe63bd5d7 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -55,7 +55,7 @@ where # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref), [`Operator`](@ref) or [`OperatorKet`](@ref). +- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref), or [`SuperOperator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `c_ops`: List of collapse operators ``\{\hat{C}_n\}_n``. It can be either a `Vector` or a `Tuple`. - `e_ops`: List of operators for which to calculate expectation values. It can be either a `Vector` or a `Tuple`. @@ -66,7 +66,7 @@ where # Notes -- The initial state can also be [`SuperOperator`](@ref) (such as a super-identity). This is useful for simulating many density matrices simultaneously or calculating process matrices. Currently must be Square. +The initial state `ψ0` can also be [`SuperOperator`](@ref). This is useful for simulating many density matrices simultaneously or calculating propagator. For example, when `H` is a [`SuperOperator`](@ref), `ψ0` can be given as `qeye_like(H)` (an identity [`SuperOperator`](@ref) matrix). - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolveProblem`](@ref) instead. @@ -88,7 +88,7 @@ function mesolveProblem( inplace::Union{Val,Bool} = Val(true), kwargs..., ) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} - (isoper(H) && (isket(ψ0) || isoper(ψ0)) && isnothing(c_ops)) && return sesolveProblem( + (isoper(H) && isket(ψ0) && isnothing(c_ops)) && return sesolveProblem( H, ψ0, tlist; diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index f65704815..232d863a3 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -128,6 +128,7 @@ Time evolution of a closed quantum system using the Schrödinger equation: # Notes +- The initial state `ψ0` can also be [`Operator`](@ref). This is useful for simulating many states simultaneously or calculating propagator. For example, `ψ0` can be given as `qeye_like(H)` (an identity [`Operator`](@ref) matrix). - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - The default tolerances in `kwargs` are given as `reltol=1e-6` and `abstol=1e-8`. diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index cfde5469d..3ccd2be20 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -101,12 +101,10 @@ function smesolveProblem( dims = L_evo.dimensions T = Base.promote_eltype(L_evo, ψ0) - if isoperket(ψ0) # Convert it to dense vector with complex element type - ρ0 = to_dense(_complex_float_type(T), copy(ψ0.data)) - state_type = OperatorKet() + ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type + to_dense(T, copy(ψ0.data)) else - ρ0 = to_dense(_complex_float_type(T), mat2vec(ket2dm(ψ0).data)) - state_type = Operator() + to_dense(T, mat2vec(ket2dm(ψ0).data)) end sc_ops_evo_data = Tuple(map(get_data ∘ QobjEvo, sc_ops_list)) @@ -148,7 +146,7 @@ function smesolveProblem( kwargs4..., ) - return TimeEvolutionProblem(prob, tlist, state_type, dims, (isoperket = Val(isoperket(ψ0)),)) + return TimeEvolutionProblem(prob, tlist, ψ0.type, dims, (isoperket = Val(isoperket(ψ0)),)) end @doc raw""" diff --git a/test/core-test/propagator.jl b/test/core-test/propagator.jl new file mode 100644 index 000000000..8400051bd --- /dev/null +++ b/test/core-test/propagator.jl @@ -0,0 +1,20 @@ +@testitem "Propagator (by solvers)" begin + ϵ0 = 1.0 * 2π + Δ = 0.8 * 2π + H = (ϵ0/2) * sigmaz() + (Δ/2) * sigmax() + L = liouvillian(H) + ψ0 = basis(2, 0) + ρ0 = mat2vec(ket2dm(ψ0)) + + dt = π/5 + tlist = 0:dt:(2π) + ψt = sesolve(H, ψ0, tlist; progress_bar = Val(false)).states[2:end] # ignore the initial state + ρt = mesolve(H, ρ0, tlist; progress_bar = Val(false)).states[2:end] # ignore the initial state + Prop_se = sesolve(H, qeye_like(H), [0, dt]; progress_bar = Val(false)).states[end] + Prop_me = mesolve(L, qeye_like(L), [0, dt]; progress_bar = Val(false)).states[end] + + for n in 1:(length(tlist)-1) + @test isapprox(Prop_se^n * ψ0, ψt[n]; atol = 1e-5) + @test isapprox(Prop_me^n * ρ0, ρt[n]; atol = 1e-5) + end +end \ No newline at end of file From cae7ac6fb1653e206f6eb9bb97e101d088207b33 Mon Sep 17 00:00:00 2001 From: Gavin Date: Thu, 11 Dec 2025 21:01:47 +0000 Subject: [PATCH 12/20] fixed a few docs and updated .gitignore. --- .gitignore | 4 +++- src/time_evolution/mesolve.jl | 6 +++--- src/time_evolution/sesolve.jl | 7 ++++--- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/.gitignore b/.gitignore index 27bcfc910..1d017f123 100644 --- a/.gitignore +++ b/.gitignore @@ -10,5 +10,7 @@ Manifest.toml benchmarks/benchmarks_output.json .ipynb_checkpoints -.devcontainer/* *.ipynb + + +.devcontainer/* diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index fe63bd5d7..bbad0c2ff 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -66,7 +66,7 @@ where # Notes -The initial state `ψ0` can also be [`SuperOperator`](@ref). This is useful for simulating many density matrices simultaneously or calculating propagator. For example, when `H` is a [`SuperOperator`](@ref), `ψ0` can be given as `qeye_like(H)` (an identity [`SuperOperator`](@ref) matrix). +- The initial state `ψ0` can also be [`SuperOperator`](@ref). This is useful for simulating many density matrices simultaneously or calculating propagator. For example, when `H` is a [`SuperOperator`](@ref), `ψ0` can be given as `qeye_like(H)` (an identity [`SuperOperator`](@ref) matrix). - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolveProblem`](@ref) instead. @@ -171,7 +171,7 @@ where - `kwargs`: The keyword arguments for the ODEProblem. # Notes - +- The initial state `ψ0` can also be [`SuperOperator`](@ref). This is useful for simulating many density matrices simultaneously or calculating propagator. For example, when `H` is a [`SuperOperator`](@ref), `ψ0` can be given as `qeye_like(H)` (an identity [`SuperOperator`](@ref) matrix). - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolve`](@ref) instead. @@ -284,7 +284,7 @@ for each combination in the ensemble. # Notes -- The initial state can also be [`SuperOperator`](@ref) (such as a super-identity). This is useful for simulating many density matrices simultaneously or calculating process matrices. Currently must be Square. +- The initial state `ψ0` can also be [`SuperOperator`](@ref). This is useful for simulating many density matrices simultaneously or calculating propagator. For example, when `H` is a [`SuperOperator`](@ref), `ψ0` can be given as `qeye_like(H)` (an identity [`SuperOperator`](@ref) matrix). - The function returns an array of solutions with dimensions matching the Cartesian product of initial states and parameter sets. - If `ψ0` is a vector of `m` states and `params = (p1, p2, ...)` where `p1` has length `n1`, `p2` has length `n2`, etc., the output will be of size `(m, n1, n2, ...)`. - If `H` is an [`Operator`](@ref), `ψ0` is a [`Ket`](@ref) and `c_ops` is `Nothing`, the function will call [`sesolve_map`](@ref) instead. diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index 232d863a3..e7ac7db76 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -40,7 +40,7 @@ Generate the ODEProblem for the Schrödinger time evolution of a quantum system: # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. +- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref) or a [`Operator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `e_ops`: List of operators for which to calculate expectation values. It can be either a `Vector` or a `Tuple`. - `params`: Parameters to pass to the solver. This argument is usually expressed as a `NamedTuple` or `AbstractVector` of parameters. For more advanced usage, any custom struct can be used. @@ -50,7 +50,7 @@ Generate the ODEProblem for the Schrödinger time evolution of a quantum system: # Notes -- Initial state can also be [`Operator`](@ref)s where each column represents a state vector, such as the Identity operator. This can be used, for example, to calculate the propagator. +- The initial state `ψ0` can also be [`Operator`](@ref). This is useful for simulating many states simultaneously or calculating propagator. For example, `ψ0` can be given as `qeye_like(H)` (an identity [`Operator`](@ref) matrix). - The states will be saved depend on the keyword argument `saveat` in `kwargs`. - If `e_ops` is empty, the default value of `saveat=tlist` (saving the states corresponding to `tlist`), otherwise, `saveat=[tlist[end]]` (only save the final state). You can also specify `e_ops` and `saveat` separately. - The default tolerances in `kwargs` are given as `reltol=1e-6` and `abstol=1e-8`. @@ -207,7 +207,7 @@ for each combination in the ensemble. # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state(s) of the system. Can be a single [`QuantumObject`](@ref) or a `Vector` of initial states. +- `ψ0`: Initial state(s) of the system. Can be a single [`QuantumObject`](@ref) or a `Vector` of initial states. It can be either a [`Ket`](@ref) or [`Operator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `alg`: The algorithm for the ODE solver. The default is `Vern7(lazy=false)`. - `ensemblealg`: Ensemble algorithm to use for parallel computation. Default is `EnsembleThreads()`. @@ -218,6 +218,7 @@ for each combination in the ensemble. # Notes +- The initial state `ψ0` can also be [`Operator`](@ref). This is useful for simulating many states simultaneously or calculating propagator. For example, `ψ0` can be given as `qeye_like(H)` (an identity [`Operator`](@ref) matrix). - The function returns an array of solutions with dimensions matching the Cartesian product of initial states and parameter sets. - If `ψ0` is a vector of `m` states and `params = (p1, p2, ...)` where `p1` has length `n1`, `p2` has length `n2`, etc., the output will be of size `(m, n1, n2, ...)`. - See [`sesolve`](@ref) for more details. From 8a3dd42fc4d701c27edf91678fb344baaa2697cc Mon Sep 17 00:00:00 2001 From: Gavin Date: Thu, 11 Dec 2025 21:24:11 +0000 Subject: [PATCH 13/20] Ran the `make format` and `make test`. All core tests pass. --- src/time_evolution/mcsolve.jl | 2 +- src/time_evolution/mesolve.jl | 7 +++++-- src/time_evolution/sesolve.jl | 4 ++-- src/time_evolution/smesolve.jl | 2 +- src/time_evolution/ssesolve.jl | 2 +- src/time_evolution/time_evolution.jl | 8 +++++++- test/core-test/propagator.jl | 6 +++--- 7 files changed, 20 insertions(+), 11 deletions(-) diff --git a/src/time_evolution/mcsolve.jl b/src/time_evolution/mcsolve.jl index e821ab215..7a2c22449 100644 --- a/src/time_evolution/mcsolve.jl +++ b/src/time_evolution/mcsolve.jl @@ -436,4 +436,4 @@ function mcsolve( kwargs.abstol, kwargs.reltol, ) -end \ No newline at end of file +end diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index bbad0c2ff..9e7561fe4 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -6,7 +6,10 @@ _mesolve_make_L_QobjEvo(H::Union{QuantumObjectEvolution,Tuple}, c_ops) = liouvil _mesolve_make_L_QobjEvo(H::Nothing, c_ops::Nothing) = throw(ArgumentError("Both H and c_ops are Nothing. You are probably running the wrong function.")) -function _gen_mesolve_solution(sol, prob::TimeEvolutionProblem{ST}) where {ST<:Union{Operator,OperatorKet,SuperOperator}} +function _gen_mesolve_solution( + sol, + prob::TimeEvolutionProblem{ST}, +) where {ST<:Union{Operator,OperatorKet,SuperOperator}} if prob.states_type isa Operator ρt = map(ϕ -> QuantumObject(vec2mat(ϕ), type = prob.states_type, dims = prob.dimensions), sol.u) else @@ -364,7 +367,7 @@ mesolve_map( # # Return: An array of TimeEvolutionSol objects with the size same as the given iter. function mesolve_map( - prob::TimeEvolutionProblem{StateOpType, <:AbstractDimensions, <:ODEProblem}, + prob::TimeEvolutionProblem{StateOpType,<:AbstractDimensions,<:ODEProblem}, iter::AbstractArray, alg::AbstractODEAlgorithm = DP5(), ensemblealg::EnsembleAlgorithm = EnsembleThreads(); diff --git a/src/time_evolution/sesolve.jl b/src/time_evolution/sesolve.jl index e7ac7db76..8aaa13588 100644 --- a/src/time_evolution/sesolve.jl +++ b/src/time_evolution/sesolve.jl @@ -242,7 +242,7 @@ function sesolve_map( ψ0 = map(to_dense, ψ0) # Convert all initial states to dense vectors - ψ0_iter = map(state -> to_dense(_complex_float_type(eltype(state)), copy(state.data)), ψ0) + ψ0_iter = map(state -> to_dense(_complex_float_type(eltype(state)), copy(state.data)), ψ0) if params isa NullParameters iter = collect(Iterators.product(ψ0_iter, [params])) |> vec # convert nx1 Matrix into Vector else @@ -276,7 +276,7 @@ sesolve_map( # # Return: An array of TimeEvolutionSol objects with the size same as the given iter. function sesolve_map( - prob::TimeEvolutionProblem{ST, <:AbstractDimensions, <:ODEProblem}, + prob::TimeEvolutionProblem{ST,<:AbstractDimensions,<:ODEProblem}, iter::AbstractArray, alg::AbstractODEAlgorithm = Vern7(lazy = false), ensemblealg::EnsembleAlgorithm = EnsembleThreads(); diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index 3ccd2be20..b65a2137b 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -445,4 +445,4 @@ function smesolve( kwargs.abstol, kwargs.reltol, ) -end \ No newline at end of file +end diff --git a/src/time_evolution/ssesolve.jl b/src/time_evolution/ssesolve.jl index 2ef72a548..7a45c625c 100644 --- a/src/time_evolution/ssesolve.jl +++ b/src/time_evolution/ssesolve.jl @@ -439,4 +439,4 @@ function ssesolve( kwargs.abstol, kwargs.reltol, ) -end \ No newline at end of file +end diff --git a/src/time_evolution/time_evolution.jl b/src/time_evolution/time_evolution.jl index a855c34ac..815f5f8fb 100644 --- a/src/time_evolution/time_evolution.jl +++ b/src/time_evolution/time_evolution.jl @@ -26,7 +26,13 @@ A Julia constructor for handling the `ODEProblem` of the time evolution of quant !!! note "`dims` property" For a given `prob::TimeEvolutionProblem`, `prob.dims` or `getproperty(prob, :dims)` returns its `dimensions` in the type of integer-vector. """ -struct TimeEvolutionProblem{ST<:QuantumObjectType, DT<:AbstractDimensions,PT<:AbstractSciMLProblem,TT<:AbstractVector,KWT} +struct TimeEvolutionProblem{ + ST<:QuantumObjectType, + DT<:AbstractDimensions, + PT<:AbstractSciMLProblem, + TT<:AbstractVector, + KWT, +} prob::PT times::TT states_type::ST diff --git a/test/core-test/propagator.jl b/test/core-test/propagator.jl index 8400051bd..b57379e7b 100644 --- a/test/core-test/propagator.jl +++ b/test/core-test/propagator.jl @@ -5,16 +5,16 @@ L = liouvillian(H) ψ0 = basis(2, 0) ρ0 = mat2vec(ket2dm(ψ0)) - + dt = π/5 tlist = 0:dt:(2π) ψt = sesolve(H, ψ0, tlist; progress_bar = Val(false)).states[2:end] # ignore the initial state ρt = mesolve(H, ρ0, tlist; progress_bar = Val(false)).states[2:end] # ignore the initial state Prop_se = sesolve(H, qeye_like(H), [0, dt]; progress_bar = Val(false)).states[end] Prop_me = mesolve(L, qeye_like(L), [0, dt]; progress_bar = Val(false)).states[end] - + for n in 1:(length(tlist)-1) @test isapprox(Prop_se^n * ψ0, ψt[n]; atol = 1e-5) @test isapprox(Prop_me^n * ρ0, ρt[n]; atol = 1e-5) end -end \ No newline at end of file +end From ab828b51a5620979504f2340eb7cc97742a4d5bf Mon Sep 17 00:00:00 2001 From: Gavin Date: Fri, 12 Dec 2025 18:53:55 +0000 Subject: [PATCH 14/20] ard make changelog and fixed PR comments. --- CHANGELOG.md | 1 + src/time_evolution/mesolve.jl | 2 +- src/time_evolution/smesolve.jl | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b1424096e..ca788a467 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -384,3 +384,4 @@ Release date: 2024-11-13 [#591]: https://github.com/qutip/QuantumToolbox.jl/issues/591 [#596]: https://github.com/qutip/QuantumToolbox.jl/issues/596 [#603]: https://github.com/qutip/QuantumToolbox.jl/issues/603 +[#606]: https://github.com/qutip/QuantumToolbox.jl/issues/606 diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 9e7561fe4..ccdf9d000 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -275,7 +275,7 @@ for each combination in the ensemble. # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state(s) of the system. Can be a single [`QuantumObject`](@ref) or a `Vector` of initial states. It can be either a [`Ket`](@ref), [`Operator`](@ref) or [`OperatorKet`](@ref). +- `ψ0`: Initial state(s) of the system. Can be a single [`QuantumObject`](@ref) or a `Vector` of initial states. It can be either a [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref) or [`SuperOperator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `c_ops`: List of collapse operators ``\{\hat{C}_n\}_n``. It can be either a `Vector` or a `Tuple`. - `alg`: The algorithm for the ODE solver. The default is `DP5()`. diff --git a/src/time_evolution/smesolve.jl b/src/time_evolution/smesolve.jl index b65a2137b..2147f1a5f 100644 --- a/src/time_evolution/smesolve.jl +++ b/src/time_evolution/smesolve.jl @@ -100,7 +100,7 @@ function smesolveProblem( check_dimensions(L_evo, ψ0) dims = L_evo.dimensions - T = Base.promote_eltype(L_evo, ψ0) + T = _complex_float_type(Base.promote_eltype(L_evo, ψ0)) ρ0 = if isoperket(ψ0) # Convert it to dense vector with complex element type to_dense(T, copy(ψ0.data)) else From ab3074d0f427ca23c271dbcea387d6897ffa1b77 Mon Sep 17 00:00:00 2001 From: Gavin Rockwood Date: Sat, 13 Dec 2025 14:59:12 -0600 Subject: [PATCH 15/20] Update src/time_evolution/mesolve.jl Co-authored-by: Yi-Te Huang <44385685+ytdHuang@users.noreply.github.com> --- src/time_evolution/mesolve.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index ccdf9d000..82f9bc1e1 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -163,7 +163,7 @@ where # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref) or [`SuperOperator`](@ref). +- `ψ0`: Initial state of the system ``|\psi(0)\rangle``. It can be either a [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref), or [`SuperOperator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `c_ops`: List of collapse operators ``\{\hat{C}_n\}_n``. It can be either a `Vector` or a `Tuple`. - `alg`: The algorithm for the ODE solver. The default value is `DP5()`. From 8f3307d241bfac8063a53792e351e08a94f3e644 Mon Sep 17 00:00:00 2001 From: Gavin Rockwood Date: Sat, 13 Dec 2025 14:59:22 -0600 Subject: [PATCH 16/20] Update src/time_evolution/mesolve.jl Co-authored-by: Yi-Te Huang <44385685+ytdHuang@users.noreply.github.com> --- src/time_evolution/mesolve.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 82f9bc1e1..b57a71bce 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -275,7 +275,7 @@ for each combination in the ensemble. # Arguments - `H`: Hamiltonian of the system ``\hat{H}``. It can be either a [`QuantumObject`](@ref), a [`QuantumObjectEvolution`](@ref), or a `Tuple` of operator-function pairs. -- `ψ0`: Initial state(s) of the system. Can be a single [`QuantumObject`](@ref) or a `Vector` of initial states. It can be either a [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref) or [`SuperOperator`](@ref). +- `ψ0`: Initial state(s) of the system. Can be a single [`QuantumObject`](@ref) or a `Vector` of initial states. It can be either a [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref), or [`SuperOperator`](@ref). - `tlist`: List of time points at which to save either the state or the expectation values of the system. - `c_ops`: List of collapse operators ``\{\hat{C}_n\}_n``. It can be either a `Vector` or a `Tuple`. - `alg`: The algorithm for the ODE solver. The default is `DP5()`. From c76cca2e39430eee1c19e56c9e79b71f89a51fb3 Mon Sep 17 00:00:00 2001 From: Gavin Rockwood Date: Sat, 13 Dec 2025 14:59:30 -0600 Subject: [PATCH 17/20] Update src/time_evolution/time_evolution.jl Co-authored-by: Yi-Te Huang <44385685+ytdHuang@users.noreply.github.com> --- src/time_evolution/time_evolution.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/time_evolution/time_evolution.jl b/src/time_evolution/time_evolution.jl index 815f5f8fb..7e35c781a 100644 --- a/src/time_evolution/time_evolution.jl +++ b/src/time_evolution/time_evolution.jl @@ -19,7 +19,7 @@ A Julia constructor for handling the `ODEProblem` of the time evolution of quant - `prob::AbstractSciMLProblem`: The `ODEProblem` of the time evolution. - `times::AbstractVector`: The time list of the evolution. -- `states_type::QuantumObjectType`: The type of the quantum states during the evolution (e.g., `Ket`, `Operator`, `OperatorKet` or `SuperOperator`). +- `states_type::QuantumObjectType`: The type of the quantum states during the evolution (e.g., [`Ket`](@ref), [`Operator`](@ref), [`OperatorKet`](@ref), or [`SuperOperator`](@ref)). - `dimensions::AbstractDimensions`: The dimensions of the Hilbert space. - `kwargs::KWT`: Generic keyword arguments. From 29f85dcb9875186659210d56729352a9668efa87 Mon Sep 17 00:00:00 2001 From: Gavin Date: Sat, 13 Dec 2025 21:04:10 +0000 Subject: [PATCH 18/20] fixed mesolve checks for passing to sesolve. --- src/time_evolution/mesolve.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index b57a71bce..fb6a6d832 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -198,7 +198,7 @@ function mesolve( inplace::Union{Val,Bool} = Val(true), kwargs..., ) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} - (isoper(H) && (isket(ψ0) || isoper(ψ0)) && isnothing(c_ops)) && return sesolve( + (isoper(H) && isket(ψ0) && isnothing(c_ops)) && return sesolve( H, ψ0, tlist; @@ -309,7 +309,7 @@ function mesolve_map( progress_bar::Union{Val,Bool} = Val(true), kwargs..., ) where {HOpType<:Union{Operator,SuperOperator},StateOpType<:Union{Ket,Operator,OperatorKet,SuperOperator}} - (isoper(H) && (all(isket, ψ0) || all(isoper, ψ0)) && isnothing(c_ops)) && return sesolve_map( + (isoper(H) && all(isket, ψ0) && isnothing(c_ops)) && return sesolve_map( H, ψ0, tlist; From 04b37e14edf4496ad7596d3f9392c9f97062b446 Mon Sep 17 00:00:00 2001 From: Gavin Date: Thu, 18 Dec 2025 17:29:46 +0000 Subject: [PATCH 19/20] made a change to make the code-quality test happy. --- src/time_evolution/mesolve.jl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index fb6a6d832..07f6ab3bc 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -113,14 +113,15 @@ function mesolveProblem( # Convert to dense vector with complex element type T = _complex_float_type(Base.promote_eltype(L_evo, ψ0)) + states_type = ψ0.type if isoperket(ψ0) || issuper(ψ0) ρ0 = to_dense(T, copy(ψ0.data)) - states_type = ψ0.type else ρ0 = to_dense(T, mat2vec(ket2dm(ψ0).data)) states_type = Operator() end + L = cache_operator(L_evo.data, ρ0) kwargs2 = _merge_saveat(tlist, e_ops, DEFAULT_ODE_SOLVER_OPTIONS; kwargs...) From faed0b784d4d0b6a846185b66b147596e82c6d65 Mon Sep 17 00:00:00 2001 From: Gavin Date: Thu, 18 Dec 2025 21:54:27 +0000 Subject: [PATCH 20/20] updated with better fix. --- src/time_evolution/mesolve.jl | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/time_evolution/mesolve.jl b/src/time_evolution/mesolve.jl index 07f6ab3bc..e55a655af 100644 --- a/src/time_evolution/mesolve.jl +++ b/src/time_evolution/mesolve.jl @@ -113,15 +113,15 @@ function mesolveProblem( # Convert to dense vector with complex element type T = _complex_float_type(Base.promote_eltype(L_evo, ψ0)) + is_operket_or_super = isoperket(ψ0) || issuper(ψ0) + ρ0 = is_operket_or_super ? to_dense(T, copy(ψ0.data)) : to_dense(T, mat2vec(ket2dm(ψ0).data)) states_type = ψ0.type - if isoperket(ψ0) || issuper(ψ0) - ρ0 = to_dense(T, copy(ψ0.data)) - else - ρ0 = to_dense(T, mat2vec(ket2dm(ψ0).data)) + if !is_operket_or_super states_type = Operator() end + L = cache_operator(L_evo.data, ρ0) kwargs2 = _merge_saveat(tlist, e_ops, DEFAULT_ODE_SOLVER_OPTIONS; kwargs...)