Minor changes

Author: albertomercurio

src/qobj/arithmetic_and_attributes.jl

@@ -37,8 +37,7 @@ end
 for op in (:(+), :(-), :(*))
     @eval begin
         function LinearAlgebra.$op(A::AbstractQuantumObject, B::AbstractQuantumObject)
-            A.dims != B.dims &&
-                throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+            check_dims(A, B)
             if A isa QuantumObjectEvolution || B isa QuantumObjectEvolution
                 return QuantumObjectEvolution($(op)(A.data, B.data), A.type, A.dims)
             end
@@ -57,56 +56,56 @@ function LinearAlgebra.:(*)(
     A::AbstractQuantumObject{DT1,OperatorQuantumObject},
     B::QuantumObject{DT2,KetQuantumObject},
 ) where {DT1,DT2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return QuantumObject(A.data * B.data, Ket, A.dims)
 end
 function LinearAlgebra.:(*)(
     A::QuantumObject{DT1,BraQuantumObject},
     B::AbstractQuantumObject{DT2,OperatorQuantumObject},
 ) where {DT1,DT2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return QuantumObject(A.data * B.data, Bra, A.dims)
 end
 function LinearAlgebra.:(*)(
     A::QuantumObject{DT1,KetQuantumObject},
     B::QuantumObject{DT2,BraQuantumObject},
 ) where {DT1,DT2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return QuantumObject(A.data * B.data, Operator, A.dims)
 end
 function LinearAlgebra.:(*)(
     A::QuantumObject{DT1,BraQuantumObject},
     B::QuantumObject{DT2,KetQuantumObject},
 ) where {DT1,DT2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return A.data * B.data
 end
 function LinearAlgebra.:(*)(
     A::AbstractQuantumObject{DT1,SuperOperatorQuantumObject},
     B::QuantumObject{DT2,OperatorQuantumObject},
 ) where {DT1,DT2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return QuantumObject(vec2mat(A.data * mat2vec(B.data)), Operator, A.dims)
 end
 function LinearAlgebra.:(*)(
     A::QuantumObject{DT1,OperatorBraQuantumObject},
     B::QuantumObject{DT2,OperatorKetQuantumObject},
 ) where {DT1,DT2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return A.data * B.data
 end
 function LinearAlgebra.:(*)(
     A::AbstractQuantumObject{DT1,SuperOperatorQuantumObject},
     B::QuantumObject{DT2,OperatorKetQuantumObject},
 ) where {DT1,DT2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return QuantumObject(A.data * B.data, OperatorKet, A.dims)
 end
 function LinearAlgebra.:(*)(
     A::QuantumObject{<:AbstractArray{T1},OperatorBraQuantumObject},
     B::AbstractQuantumObject{<:AbstractArray{T2},SuperOperatorQuantumObject},
 ) where {T1,T2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum object don't have the same Hilbert dimension."))
+    check_dims(A, B)
     return QuantumObject(A.data * B.data, OperatorBra, A.dims)
 end
 
@@ -445,8 +444,8 @@ Matrix cosine of [`QuantumObject`](@ref), defined as
 Note that this function only supports for [`Operator`](@ref) and [`SuperOperator`](@ref)
 """
 LinearAlgebra.cos(
-    A::QuantumObject{<:AbstractMatrix{T},ObjType},
-) where {T,ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} = (exp(1im * A) + exp(-1im * A)) / 2
+    A::QuantumObject{DT,ObjType},
+) where {DT,ObjType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} = (exp(1im * A) + exp(-1im * A)) / 2
 
 @doc raw"""
     diag(A::QuantumObject, k::Int=0)

src/qobj/quantum_object.jl

@@ -232,6 +232,11 @@ _check_dims(dims::Any) = throw(
     ),
 )
 
+function check_dims(A::AbstractQuantumObject, B::AbstractQuantumObject)
+    A.dims != B.dims && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
+    return nothing
+end
+
 function _check_QuantumObject(type::KetQuantumObject, dims, m::Int, n::Int)
     (n != 1) && throw(DomainError((m, n), "The size of the array is not compatible with Ket"))
     (prod(dims) != m) && throw(DimensionMismatch("Ket with dims = $(dims) does not fit the array size = $((m, n))."))

src/qobj/superoperators.jl

@@ -69,7 +69,7 @@ function sprepost(
     A::QuantumObject{<:AbstractArray{T1},OperatorQuantumObject},
     B::QuantumObject{<:AbstractArray{T2},OperatorQuantumObject},
 ) where {T1,T2}
-    A.dims != B.dims && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
+    check_dims(A, B)
 
     return QuantumObject(_sprepost(A.data, B.data), SuperOperator, A.dims)
 end
@@ -90,12 +90,50 @@ the same function is applied multiple times with a known Hilbert space dimension
 See also [`spre`](@ref) and [`spost`](@ref).
 """
 function lindblad_dissipator(
-    O::QuantumObject{<:AbstractArray{T},OperatorQuantumObject},
+    O::QuantumObject{DT,OperatorQuantumObject},
     Id_cache = I(size(O, 1)),
-) where {T}
+) where {DT}
     Od_O = O' * O
     return sprepost(O, O') - spre(Od_O, Id_cache) / 2 - spost(Od_O, Id_cache) / 2
 end
 
 # It is already a SuperOperator
-lindblad_dissipator(O::QuantumObject{<:AbstractArray{T},SuperOperatorQuantumObject}, Id_cache) where {T} = O
+lindblad_dissipator(O::QuantumObject{DT,SuperOperatorQuantumObject}, Id_cache=nothing) where {DT} = O
+
+@doc raw"""
+    liouvillian(H::QuantumObject, c_ops::Union{Nothing,AbstractVector,Tuple}=nothing, Id_cache=I(prod(H.dims)))
+
+Construct the Liouvillian [`SuperOperator`](@ref) for a system Hamiltonian ``\hat{H}`` and a set of collapse operators ``\{\hat{C}_n\}_n``:
+
+```math
+\mathcal{L} [\cdot] = -i[\hat{H}, \cdot] + \sum_n \mathcal{D}(\hat{C}_n) [\cdot]
+```
+
+where 
+
+```math
+\mathcal{D}(\hat{C}_n) [\cdot] = \hat{C}_n [\cdot] \hat{C}_n^\dagger - \frac{1}{2} \hat{C}_n^\dagger \hat{C}_n [\cdot] - \frac{1}{2} [\cdot] \hat{C}_n^\dagger \hat{C}_n
+```
+
+The optional argument `Id_cache` can be used to pass a precomputed identity matrix. This can be useful when the same function is applied multiple times with a known Hilbert space dimension.
+
+See also [`spre`](@ref), [`spost`](@ref), and [`lindblad_dissipator`](@ref).
+"""
+function liouvillian(
+    H::QuantumObject{MT1,OpType1},
+    c_ops::Union{Nothing,AbstractVector,Tuple} = nothing,
+    Id_cache = I(prod(H.dims)),
+) where {MT1<:AbstractMatrix,OpType1<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}}
+    L = liouvillian(H, Id_cache)
+    if !(c_ops isa Nothing)
+        for c_op in c_ops
+            L += lindblad_dissipator(c_op, Id_cache)
+        end
+    end
+    return L
+end
+
+liouvillian(H::QuantumObject{<:AbstractMatrix,OperatorQuantumObject}, Id_cache::Diagonal = I(prod(H.dims))) =
+    -1im * (spre(H, Id_cache) - spost(H, Id_cache))
+
+liouvillian(H::QuantumObject{<:AbstractMatrix,SuperOperatorQuantumObject}, Id_cache::Diagonal) = H

src/steadystate.jl

@@ -234,7 +234,7 @@ function steadystate(
     HOpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject},
     StateOpType<:Union{KetQuantumObject,OperatorQuantumObject},
 }
-    (H.dims != ψ0.dims) && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
+    check_dims(H, ψ0)
 
     N = prod(H.dims)
     u0 = sparse_to_dense(_CType(ψ0), mat2vec(ket2dm(ψ0).data))

src/time_evolution/mcsolve.jl

@@ -202,7 +202,7 @@ function mcsolveProblem(
     jump_callback::TJC = ContinuousLindbladJumpCallback(),
     kwargs...,
 ) where {MT1<:AbstractMatrix,TJC<:LindbladJumpCallbackType}
-    H.dims != ψ0.dims && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
+    check_dims(H, ψ0)
 
     haskey(kwargs, :save_idxs) &&
         throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox."))

src/time_evolution/mesolve.jl

@@ -114,7 +114,7 @@ function mesolveProblem(
     HOpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject},
     StateOpType<:Union{KetQuantumObject,OperatorQuantumObject},
 }
-    H.dims != ψ0.dims && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
+    check_dims(H, ψ0)
 
     haskey(kwargs, :save_idxs) &&
         throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox."))

src/time_evolution/sesolve.jl

@@ -95,7 +95,7 @@ function sesolveProblem(
     progress_bar::Union{Val,Bool} = Val(true),
     kwargs...,
 ) where {MT1<:AbstractMatrix,T2}
-    H.dims != ψ0.dims && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
+    check_dims(H, ψ0)
 
     haskey(kwargs, :save_idxs) &&
         throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox."))

src/time_evolution/ssesolve.jl

@@ -156,7 +156,7 @@ function ssesolveProblem(
     rng::AbstractRNG = default_rng(),
     kwargs...,
 ) where {MT1<:AbstractMatrix,T2}
-    H.dims != ψ0.dims && throw(DimensionMismatch("The two quantum objects don't have the same Hilbert dimension."))
+    check_dims(H, ψ0)
 
     haskey(kwargs, :save_idxs) &&
         throw(ArgumentError("The keyword argument \"save_idxs\" is not supported in QuantumToolbox."))

src/time_evolution/time_evolution.jl

@@ -196,45 +196,6 @@ end
 
 #######################################
 
-### LIOUVILLIAN ###
-@doc raw"""
-    liouvillian(H::QuantumObject, c_ops::Union{Nothing,AbstractVector,Tuple}=nothing, Id_cache=I(prod(H.dims)))
-
-Construct the Liouvillian [`SuperOperator`](@ref) for a system Hamiltonian ``\hat{H}`` and a set of collapse operators ``\{\hat{C}_n\}_n``:
-
-```math
-\mathcal{L} [\cdot] = -i[\hat{H}, \cdot] + \sum_n \mathcal{D}(\hat{C}_n) [\cdot]
-```
-
-where 
-
-```math
-\mathcal{D}(\hat{C}_n) [\cdot] = \hat{C}_n [\cdot] \hat{C}_n^\dagger - \frac{1}{2} \hat{C}_n^\dagger \hat{C}_n [\cdot] - \frac{1}{2} [\cdot] \hat{C}_n^\dagger \hat{C}_n
-```
-
-The optional argument `Id_cache` can be used to pass a precomputed identity matrix. This can be useful when the same function is applied multiple times with a known Hilbert space dimension.
-
-See also [`spre`](@ref), [`spost`](@ref), and [`lindblad_dissipator`](@ref).
-"""
-function liouvillian(
-    H::QuantumObject{MT1,OpType1},
-    c_ops::Union{Nothing,AbstractVector,Tuple} = nothing,
-    Id_cache = I(prod(H.dims)),
-) where {MT1<:AbstractMatrix,OpType1<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}}
-    L = liouvillian(H, Id_cache)
-    if !(c_ops isa Nothing)
-        for c_op in c_ops
-            L += lindblad_dissipator(c_op, Id_cache)
-        end
-    end
-    return L
-end
-
-liouvillian(H::QuantumObject{<:AbstractMatrix,OperatorQuantumObject}, Id_cache::Diagonal = I(prod(H.dims))) =
-    -1im * (spre(H, Id_cache) - spost(H, Id_cache))
-
-liouvillian(H::QuantumObject{<:AbstractMatrix,SuperOperatorQuantumObject}, Id_cache::Diagonal) = H
-
 function liouvillian_floquet(
     L₀::QuantumObject{<:AbstractArray{T1},SuperOperatorQuantumObject},
     Lₚ::QuantumObject{<:AbstractArray{T2},SuperOperatorQuantumObject},