From 571abc9a885f5eb30c32ce3739fa5380e8277c7a Mon Sep 17 00:00:00 2001 From: Gavin Date: Sun, 30 Nov 2025 22:25:09 +0000 Subject: [PATCH 1/7] 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 2/7] 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 3/7] 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 4/7] 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 5/7] 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 6/7] 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 7/7] 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, )