Fix type-instabilities error

Author: albertomercurio

src/qobj/quantum_object_evo.jl

@@ -349,77 +349,11 @@ Parse the `op_func_list` and generate the data for the `QuantumObjectEvolution`
 # Arguments
 - `op_func_list::Tuple`: A tuple of tuples or operators.
 =#
-# @generated function _QobjEvo_generate_data(op_func_list::Tuple)
-#     op_func_list_types = op_func_list.parameters
-#     N = length(op_func_list_types)
-
-#     dims_expr = ()
-#     func_methods_expr = ()
-#     first_op = nothing
-#     data_expr = :(0)
-#     qobj_expr_const = :(0)
-
-#     for i in 1:N
-#         op_func_type = op_func_list_types[i]
-#         if op_func_type <: Tuple
-#             # check the structure of the tuple
-#             length(op_func_type.parameters) == 2 || throw(ArgumentError("The tuple must have two elements."))
-#             op_type = op_func_type.parameters[1]
-#             func_type = op_func_type.parameters[2]
-#             ((isoper(op_type) || issuper(op_type)) && func_type <: Function) || throw(
-#                 ArgumentError(
-#                     "The first element must be a Operator or SuperOperator, and the second element must be a function.",
-#                 ),
-#             )
-
-#             op = :(op_func_list[$i][1])
-#             dims_expr = (dims_expr..., :($op.dimensions))
-#             func_methods_expr = (func_methods_expr..., :(methods(op_func_list[$i][2], [Any, Real]).ms)) # [Any, Real] means each func must accept 2 arguments
-#             if i == 1
-#                 first_op = :($op)
-#             end
-#             data_expr = :($data_expr + _make_SciMLOperator(op_func_list[$i]))
-#         else
-#             op_type = op_func_type
-#             (isoper(op_type) || issuper(op_type)) ||
-#                 throw(ArgumentError("The element must be a Operator or SuperOperator."))
-
-#             dims_expr = (dims_expr..., :(op_func_list[$i].dimensions))
-#             if i == 1
-#                 first_op = :(op_func_list[$i])
-#             end
-#             qobj_expr_const = :($qobj_expr_const + op_func_list[$i])
-#         end
-#     end
-
-#     quote
-#         # check the dims of the operators
-#         dims = tuple($(dims_expr...))
-#         allequal(dims) || throw(ArgumentError("The dimensions of the operators must be the same."))
-
-#         # check if each func accepts 2 arguments
-#         func_methods = tuple($(func_methods_expr...))
-#         for i in eachindex(func_methods)
-#             length(func_methods[i]) == 0 && throw(
-#                 ArgumentError(
-#                     "The following function must only accept two arguments: `$(nameof(op_func_list[i][2]))(p, t)` with t<:Real",
-#                 ),
-#             )
-#         end
-
-#         data_expr_const = $qobj_expr_const isa Integer ? $qobj_expr_const : _make_SciMLOperator($qobj_expr_const)
-
-#         data_expr = data_expr_const + $data_expr
-
-#         return $first_op, data_expr
-#     end
-# end
-
-Base.@constprop :aggressive function _QobjEvo_generate_data(op_func_list::Tuple)
+function _QobjEvo_generate_data(op_func_list::Tuple)
     first_op = _QobjEvo_get_first_op(op_func_list[1])
 
     ops_constant = filter(op_func_list) do x
-        if x isa AbstractQuantumObject
+        if x isa QuantumObject
             x.type == first_op.type || throw(ArgumentError("The types of the operators must be the same."))
             x.dimensions == first_op.dimensions ||
                 throw(ArgumentError("The dimensions of the operators must be the same."))
@@ -440,18 +374,18 @@ Base.@constprop :aggressive function _QobjEvo_generate_data(op_func_list::Tuple)
             op.dimensions == first_op.dimensions ||
                 throw(ArgumentError("The dimensions of the operators must be the same."))
             return true
-        elseif x isa AbstractQuantumObject
+        elseif x isa QuantumObject
             return false
         else
             throw(ArgumentError("Each element of the tuple must be either a QuantumObject or a Tuple."))
         end
     end
 
-    data_const = sum(_make_SciMLOperator, ops_constant; init = zero(eltype(first_op))*I)
+    data_const = isempty(ops_constant) ? zero(eltype(first_op)) : _make_SciMLOperator(sum(ops_constant))
     data_td =
         length(ops_time_dep) == 1 ? _make_SciMLOperator(ops_time_dep[1]) :
         AddedOperator(map(_make_SciMLOperator, ops_time_dep))
-    data = isempty(ops_constant) ? data_td : data_const + data_td
+    data = data_const + data_td
 
     return first_op, data
 end

src/time_evolution/mcsolve.jl

@@ -26,16 +26,16 @@ function _normalize_state!(u, dims, normalize_states)
 end
 
 function _mcsolve_make_Heff_QobjEvo(H::QuantumObject, c_ops)
-    c_ops isa Nothing && return QobjEvo(H)
-    return QobjEvo(H - 1im * mapreduce(op -> op' * op, +, c_ops) / 2)
+    c_ops isa Nothing && return QuantumObjectEvolution(H)
+    return QuantumObjectEvolution(H - 1im * mapreduce(op -> op' * op, +, c_ops) / 2)
 end
 function _mcsolve_make_Heff_QobjEvo(H::Tuple, c_ops)
-    c_ops isa Nothing && return QobjEvo(H)
-    return QobjEvo((H..., -1im * sum(op -> op' * op, c_ops) / 2))
+    c_ops isa Nothing && return QuantumObjectEvolution(H)
+    return QuantumObjectEvolution((H..., -1im * sum(op -> op' * op, c_ops) / 2))
 end
 function _mcsolve_make_Heff_QobjEvo(H::QuantumObjectEvolution, c_ops)
     c_ops isa Nothing && return H
-    return H + QobjEvo(sum(op -> -1im * op' * op / 2, c_ops))
+    return H + QuantumObjectEvolution(sum(op -> -1im * op' * op / 2, c_ops))
 end
 
 @doc raw"""

src/time_evolution/smesolve.jl

@@ -119,7 +119,7 @@ function smesolveProblem(
         # TODO: # Currently, we are assuming a time-independent MatrixOperator
         # Also, the u state may become non-hermitian, so Tr[Sn * ρ + ρ * Sn'] != real(Tr[Sn * ρ]) / 2
         op_vec = mat2vec(adjoint(op.A))
-        return _spre(op, Id) + _spost(op', Id) + _smesolve_ScalarOperator(op_vec) * Id_op
+        return AddedOperator(_spre(op, Id), _spost(op', Id), _smesolve_ScalarOperator(op_vec) * Id_op)
     end
     D = DiffusionOperator(D_l)
 

src/time_evolution/ssesolve.jl

@@ -113,7 +113,7 @@ function ssesolveProblem(
         sc_ops_evo_data,
     )
 
-    K = get_data(-1im * QobjEvo(H_eff_evo)) + K_l
+    K = get_data(-1im * QuantumObjectEvolution(H_eff_evo)) + K_l
 
     D_l = map(op -> op + _ScalarOperator_e(op, -) * IdentityOperator(prod(dims)), sc_ops_evo_data)
     D = DiffusionOperator(D_l)