First working runtests

Author: albertomercurio

src/qobj/arithmetic_and_attributes.jl

@@ -108,7 +108,8 @@ function LinearAlgebra.:(*)(
 end
 
 LinearAlgebra.:(^)(A::QuantumObject{DT}, n::T) where {DT,T<:Number} = QuantumObject(^(A.data, n), A.type, A.dims)
-LinearAlgebra.:(/)(A::QuantumObject{DT}, n::T) where {DT,T<:Number} = QuantumObject(/(A.data, n), A.type, A.dims)
+LinearAlgebra.:(/)(A::AbstractQuantumObject{DT}, n::T) where {DT,T<:Number} =
+    get_typename_wrapper(A)(A.data / n, A.type, A.dims)
 
 @doc raw"""
     dot(A::QuantumObject, B::QuantumObject)

src/qobj/quantum_object.jl

@@ -112,57 +112,6 @@ function QuantumObject(
     throw(DomainError(size(A), "The size of the array is not compatible with vector or matrix."))
 end
 
-function _check_dims(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N}
-    _non_static_array_warning("dims", dims)
-    return (all(>(0), dims) && length(dims) > 0) ||
-           throw(DomainError(dims, "The argument dims must be of non-zero length and contain only positive integers."))
-end
-_check_dims(dims::Any) = throw(
-    ArgumentError(
-        "The argument dims must be a Tuple or a StaticVector of non-zero length and contain only positive integers.",
-    ),
-)
-
-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))."))
-    return nothing
-end
-
-function _check_QuantumObject(type::BraQuantumObject, dims, m::Int, n::Int)
-    (m != 1) && throw(DomainError((m, n), "The size of the array is not compatible with Bra"))
-    (prod(dims) != n) && throw(DimensionMismatch("Bra with dims = $(dims) does not fit the array size = $((m, n))."))
-    return nothing
-end
-
-function _check_QuantumObject(type::OperatorQuantumObject, dims, m::Int, n::Int)
-    (m != n) && throw(DomainError((m, n), "The size of the array is not compatible with Operator"))
-    (prod(dims) != m) &&
-        throw(DimensionMismatch("Operator with dims = $(dims) does not fit the array size = $((m, n))."))
-    return nothing
-end
-
-function _check_QuantumObject(type::SuperOperatorQuantumObject, dims, m::Int, n::Int)
-    (m != n) && throw(DomainError((m, n), "The size of the array is not compatible with SuperOperator"))
-    (prod(dims) != sqrt(m)) &&
-        throw(DimensionMismatch("SuperOperator with dims = $(dims) does not fit the array size = $((m, n))."))
-    return nothing
-end
-
-function _check_QuantumObject(type::OperatorKetQuantumObject, dims, m::Int, n::Int)
-    (n != 1) && throw(DomainError((m, n), "The size of the array is not compatible with OperatorKet"))
-    (prod(dims) != sqrt(m)) &&
-        throw(DimensionMismatch("OperatorKet with dims = $(dims) does not fit the array size = $((m, n))."))
-    return nothing
-end
-
-function _check_QuantumObject(type::OperatorBraQuantumObject, dims, m::Int, n::Int)
-    (m != 1) && throw(DomainError((m, n), "The size of the array is not compatible with OperatorBra"))
-    (prod(dims) != sqrt(n)) &&
-        throw(DimensionMismatch("OperatorBra with dims = $(dims) does not fit the array size = $((m, n))."))
-    return nothing
-end
-
 function QuantumObject(
     A::QuantumObject{<:AbstractArray{T,N}};
     type::ObjType = A.type,

src/qobj/quantum_object_base.jl

@@ -152,6 +152,57 @@ function check_dims(A::AbstractQuantumObject, B::AbstractQuantumObject)
     return nothing
 end
 
+function _check_dims(dims::Union{AbstractVector{T},NTuple{N,T}}) where {T<:Integer,N}
+    _non_static_array_warning("dims", dims)
+    return (all(>(0), dims) && length(dims) > 0) ||
+           throw(DomainError(dims, "The argument dims must be of non-zero length and contain only positive integers."))
+end
+_check_dims(dims::Any) = throw(
+    ArgumentError(
+        "The argument dims must be a Tuple or a StaticVector of non-zero length and contain only positive integers.",
+    ),
+)
+
+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))."))
+    return nothing
+end
+
+function _check_QuantumObject(type::BraQuantumObject, dims, m::Int, n::Int)
+    (m != 1) && throw(DomainError((m, n), "The size of the array is not compatible with Bra"))
+    (prod(dims) != n) && throw(DimensionMismatch("Bra with dims = $(dims) does not fit the array size = $((m, n))."))
+    return nothing
+end
+
+function _check_QuantumObject(type::OperatorQuantumObject, dims, m::Int, n::Int)
+    (m != n) && throw(DomainError((m, n), "The size of the array is not compatible with Operator"))
+    (prod(dims) != m) &&
+        throw(DimensionMismatch("Operator with dims = $(dims) does not fit the array size = $((m, n))."))
+    return nothing
+end
+
+function _check_QuantumObject(type::SuperOperatorQuantumObject, dims, m::Int, n::Int)
+    (m != n) && throw(DomainError((m, n), "The size of the array is not compatible with SuperOperator"))
+    (prod(dims) != sqrt(m)) &&
+        throw(DimensionMismatch("SuperOperator with dims = $(dims) does not fit the array size = $((m, n))."))
+    return nothing
+end
+
+function _check_QuantumObject(type::OperatorKetQuantumObject, dims, m::Int, n::Int)
+    (n != 1) && throw(DomainError((m, n), "The size of the array is not compatible with OperatorKet"))
+    (prod(dims) != sqrt(m)) &&
+        throw(DimensionMismatch("OperatorKet with dims = $(dims) does not fit the array size = $((m, n))."))
+    return nothing
+end
+
+function _check_QuantumObject(type::OperatorBraQuantumObject, dims, m::Int, n::Int)
+    (m != 1) && throw(DomainError((m, n), "The size of the array is not compatible with OperatorBra"))
+    (prod(dims) != sqrt(n)) &&
+        throw(DimensionMismatch("OperatorBra with dims = $(dims) does not fit the array size = $((m, n))."))
+    return nothing
+end
+
 get_typename_wrapper(A::AbstractQuantumObject) = Base.typename(typeof(A)).wrapper
 
 # functions for getting Float or Complex element type

src/qobj/quantum_object_evo.jl

@@ -92,13 +92,61 @@ struct QuantumObjectEvolution{
     data::DT
     type::ObjType
     dims::SVector{N,Int}
+
+    function QuantumObjectEvolution(
+        data::DT,
+        type::ObjType,
+        dims,
+    ) where {DT<:AbstractSciMLOperator,ObjType<:QuantumObjectType}
+        (type == Operator || type == SuperOperator) ||
+            throw(ArgumentError("The type $type is not supported for QuantumObjectEvolution."))
+
+        _check_dims(dims)
+
+        _size = _get_size(data)
+        _check_QuantumObject(type, dims, _size[1], _size[2])
+
+        N = length(dims)
+
+        return new{DT,ObjType,N}(data, type, SVector{N,Int}(dims))
+    end
+end
+
+function QuantumObjectEvolution(data::AbstractSciMLOperator, type::QuantumObjectType, dims::Integer)
+    return QuantumObjectEvolution(data, type, SVector{1,Int}(dims))
+end
+
+"""
+    QuantumObjectEvolution(data::AbstractSciMLOperator; type::QuantumObjectType = Operator, dims = nothing)
+
+Generate a [`QuantumObjectEvolution`](@ref) object from a [`SciMLOperator`](https://github.com/SciML/SciMLOperators.jl), in the same way as [`QuantumObject`](@ref) for `AbstractArray` inputs.
+"""
+function QuantumObjectEvolution(data::AbstractSciMLOperator; type::QuantumObjectType = Operator, dims = nothing)
+    _size = _get_size(data)
+
+    if dims isa Nothing
+        if type == Operator
+            dims = SVector{1,Int}(_size[2])
+        elseif type == SuperOperator
+            dims = SVector{1,Int}(isqrt(_size[2]))
+        end
+    end
+
+    return QuantumObjectEvolution(data, type, dims)
 end
 
 # Make the QuantumObjectEvolution, with the option to pre-multiply by a scalar
-function QuantumObjectEvolution(op_func_list::Tuple, α::Union{Nothing,Number} = nothing; f::Function = identity)
+function QuantumObjectEvolution(
+    op_func_list::Tuple,
+    α::Union{Nothing,Number} = nothing;
+    type::Union{Nothing,QuantumObjectType} = nothing,
+    f::Function = identity,
+)
     op, data = _QobjEvo_generate_data(op_func_list, α; f = f)
     dims = op.dims
-    type = op.type
+    if type isa Nothing
+        type = op.type
+    end
 
     # Preallocate the SciMLOperator cache using a dense vector as a reference
     v0 = sparse_to_dense(similar(op.data, size(op, 1)))
@@ -107,15 +155,38 @@ function QuantumObjectEvolution(op_func_list::Tuple, α::Union{Nothing,Number} =
     return QuantumObjectEvolution(data, type, dims)
 end
 
-QuantumObjectEvolution(op::QuantumObject, α::Union{Nothing,Number} = nothing; f::Function = identity) =
-    QuantumObjectEvolution(_make_SciMLOperator(op, α), op.type, op.dims)
+function QuantumObjectEvolution(
+    op::QuantumObject,
+    α::Union{Nothing,Number} = nothing;
+    type::Union{Nothing,QuantumObjectType} = nothing,
+    f::Function = identity,
+)
+    if type isa Nothing
+        type = op.type
+    end
+    return QuantumObjectEvolution(_make_SciMLOperator(op, α, f = f), type, op.dims)
+end
 
-function QuantumObjectEvolution(op::QuantumObjectEvolution, α::Union{Nothing,Number} = nothing; f::Function = identity)
+function QuantumObjectEvolution(
+    op::QuantumObjectEvolution,
+    α::Union{Nothing,Number} = nothing;
+    type::Union{Nothing,QuantumObjectType} = nothing,
+    f::Function = identity,
+)
     f !== identity && throw(ArgumentError("The function `f` is not supported for QuantumObjectEvolution inputs."))
+    if type isa Nothing
+        type = op.type
+    else
+        throw(
+            ArgumentError(
+                "The type of the QuantumObjectEvolution object cannot be changed when using another QuantumObjectEvolution object as input.",
+            ),
+        )
+    end
     if α isa Nothing
-        return QuantumObjectEvolution(op.data, op.type, op.dims)
+        return QuantumObjectEvolution(op.data, type, op.dims)
     end
-    return QuantumObjectEvolution(α * op.data, op.type, op.dims)
+    return QuantumObjectEvolution(α * op.data, type, op.dims)
 end
 
 #=
@@ -170,14 +241,14 @@ Parse the `op_func_list` and generate the data for the `QuantumObjectEvolution`
         end
     end
 
-    data_expr_const = :(_make_SciMLOperator($qobj_expr_const, α))
-
     quote
         dims = tuple($(dims_expr...))
 
         length(unique(dims)) == 1 || throw(ArgumentError("The dimensions of the operators must be the same."))
 
-        data_expr = $data_expr_const + $data_expr
+        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

src/qobj/synonyms.jl

@@ -18,11 +18,11 @@ Note that this functions is same as `QuantumObject(A; type=type, dims=dims)`.
 Qobj(A; kwargs...) = QuantumObject(A; kwargs...)
 
 @doc raw"""
-    QobjEvo(op_func_list::Union{Tuple,AbstractQuantumObject}, α::Union{Nothing,Number}=nothing; f::Function=identity)
+    QobjEvo(op_func_list::Union{Tuple,AbstractQuantumObject}, α::Union{Nothing,Number}=nothing; type::Union{Nothing, QuantumObjectType}=nothing, f::Function=identity)
 
 Generate [`QuantumObjectEvolution`](@ref)
 
-Note that this functions is same as `QuantumObjectEvolution(op_func_list)`. If `α` is provided, all the operators in `op_func_list` will be pre-multiplied by `α`. The `f` parameter is used to pre-apply a function to the operators before converting them to SciML operators.
+Note that this functions is same as `QuantumObjectEvolution(op_func_list)`. If `α` is provided, all the operators in `op_func_list` will be pre-multiplied by `α`. The `type` parameter is used to specify the type of the [`QuantumObject`](@ref), either `Operator` or `SuperOperator`. The `f` parameter is used to pre-apply a function to the operators before converting them to SciML operators.
 
 # Arguments
 - `op_func_list::Union{Tuple,AbstractQuantumObject}`: A tuple of tuples or operators.
@@ -101,46 +101,60 @@ Quantum Object:   type=Operator   dims=[10, 2]   size=(20, 20)   ishermitian=fal
 ⎣⠀⠀⠀⠀⠀⠀⠀⠀⠂⡑⎦
 ````
 """
-QobjEvo(op_func_list::Union{Tuple,AbstractQuantumObject}, α::Union{Nothing,Number} = nothing; f::Function = identity) =
-    QuantumObjectEvolution(op_func_list, α; f = f)
+QobjEvo(
+    op_func_list::Union{Tuple,AbstractQuantumObject},
+    α::Union{Nothing,Number} = nothing;
+    type::Union{Nothing,QuantumObjectType} = nothing,
+    f::Function = identity,
+) = QuantumObjectEvolution(op_func_list, α; type = type, f = f)
+
+QobjEvo(data::AbstractSciMLOperator, type::QuantumObjectType, dims::Integer) =
+    QuantumObjectEvolution(data, type, SVector{1,Int}(dims))
+
+"""
+    QobjEvo(data::AbstractSciMLOperator; type::QuantumObjectType = Operator, dims = nothing)
+
+Synonym of [`QuantumObjectEvolution`](@ref) object from a [`SciMLOperator`](https://github.com/SciML/SciMLOperators.jl).  See the documentation for [`QuantumObjectEvolution`](@ref) for more information.
+"""
+QobjEvo(data::AbstractSciMLOperator; type::QuantumObjectType = Operator, dims = nothing) =
+    QuantumObjectEvolution(data; type = type, dims = dims)
 
 @doc raw"""
-    shape(A::QuantumObject)
+    shape(A::AbstractQuantumObject)
 
-Returns a tuple containing each dimensions of the array in the [`QuantumObject`](@ref).
+Returns a tuple containing each dimensions of the array in the [`AbstractQuantumObject`](@ref).
 
 Note that this function is same as `size(A)`.
 """
-shape(A::QuantumObject{<:AbstractArray{T}}) where {T} = size(A.data)
+shape(A::AbstractQuantumObject) = size(A.data)
 
 @doc raw"""
-    isherm(A::QuantumObject)
+    isherm(A::AbstractQuantumObject)
 
-Test whether the [`QuantumObject`](@ref) is Hermitian.
+Test whether the [`AbstractQuantumObject`](@ref) is Hermitian.
 
 Note that this functions is same as `ishermitian(A)`.
 """
-isherm(A::QuantumObject{<:AbstractArray{T}}) where {T} = ishermitian(A)
+isherm(A::AbstractQuantumObject) = ishermitian(A)
 
 @doc raw"""
-    trans(A::QuantumObject)
+    trans(A::AbstractQuantumObject)
 
-Lazy matrix transpose of the [`QuantumObject`](@ref).
+Lazy matrix transpose of the [`AbstractQuantumObject`](@ref).
 
 Note that this function is same as `transpose(A)`.
 """
-trans(
-    A::QuantumObject{<:AbstractArray{T},OpType},
-) where {T,OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} = transpose(A)
+trans(A::AbstractQuantumObject{DT,OpType}) where {DT,OpType<:Union{OperatorQuantumObject,SuperOperatorQuantumObject}} =
+    transpose(A)
 
 @doc raw"""
-    dag(A::QuantumObject)
+    dag(A::AbstractQuantumObject)
 
-Lazy adjoint (conjugate transposition) of the [`QuantumObject`](@ref)
+Lazy adjoint (conjugate transposition) of the [`AbstractQuantumObject`](@ref)
 
 Note that this function is same as `adjoint(A)`.
 """
-dag(A::QuantumObject{<:AbstractArray{T}}) where {T} = adjoint(A)
+dag(A::AbstractQuantumObject) = adjoint(A)
 
 @doc raw"""
     matrix_element(i::QuantumObject, A::QuantumObject j::QuantumObject)

src/time_evolution/mesolve.jl

@@ -41,10 +41,10 @@ function _generate_mesolve_kwargs(e_ops, progress_bar::Val{false}, tlist, kwargs
     return _generate_mesolve_kwargs_with_callback(tlist, kwargs)
 end
 
-_mesolve_make_L_QobjEvo(H::QuantumObject, c_ops) = QobjEvo(liouvillian(H, c_ops))
+_mesolve_make_L_QobjEvo(H::QuantumObject, c_ops) = QobjEvo(liouvillian(H, c_ops); type = SuperOperator)
 function _mesolve_make_L_QobjEvo(H::Tuple, c_ops)
     c_ops isa Nothing && return QobjEvo(H)
-    return QobjEvo((H..., mapreduce(op -> lindblad_dissipator(op), +, c_ops)); f = liouvillian)
+    return QobjEvo((H..., mapreduce(op -> lindblad_dissipator(op), +, c_ops)); type = SuperOperator, f = liouvillian)
 end
 # TODO: Add support for Operator type QobEvo
 function _mesolve_make_L_QobjEvo(H::QuantumObjectEvolution, c_ops)

src/utilities.jl

@@ -141,6 +141,7 @@ getVal(x) = x # getVal for any other type
 
 _get_size(A::AbstractMatrix) = size(A)
 _get_size(A::AbstractVector) = (length(A), 1)
+_get_size(A::AbstractSciMLOperator) = size(A)
 
 _non_static_array_warning(argname, arg::Tuple{}) =
     throw(ArgumentError("The argument $argname must be a Tuple or a StaticVector of non-zero length."))