minor changes

Author: ytdHuang

src/qobj/energy_restricted.jl

@@ -56,12 +56,12 @@ struct EnrSpace{N} <: AbstractSpace
     state2idx::Dict{SVector{N,Int},Int}
     idx2state::Dict{Int,SVector{N,Int}}
 
-    function EnrSpace(dims::Union{AbstractVector{T},NTuple{N,T}}, excitations::Int) where {T<:Integer,N}
+    function EnrSpace(dims::Union{AbstractVector{T},NTuple{N,T}}, n_excitations::Int) where {T<:Integer,N}
         # all arguments will be checked in `enr_state_dictionaries`
-        size, state2idx, idx2state = enr_state_dictionaries(dims, excitations)
+        size, state2idx, idx2state = enr_state_dictionaries(dims, n_excitations)
 
         L = length(dims)
-        return new{L}(size, SVector{L}(dims), excitations, state2idx, idx2state)
+        return new{L}(size, SVector{L}(dims), n_excitations, state2idx, idx2state)
     end
 end
 
@@ -75,26 +75,26 @@ Base.:(==)(s_enr1::EnrSpace, s_enr2::EnrSpace) = (s_enr1.size == s_enr2.size) &&
 dimensions_to_dims(s_enr::EnrSpace) = s_enr.dims
 
 @doc raw"""
-    enr_state_dictionaries(dims, excitations)
+    enr_state_dictionaries(dims, n_excitations)
 
 Return the number of states, and lookup-dictionaries for translating a state (`SVector`) to a state index, and vice versa, for a system with a given number of components and maximum number of excitations.
 
 # Arguments
 - `dims::Union{AbstractVector,Tuple}`: A list of the number of states in each sub-system
-- `excitations::Int`: Maximum number of excitations
+- `n_excitations::Int`: Maximum number of excitations
 
 # Returns
 - `nstates`: Number of states
 - `state2idx`: A dictionary for looking up a state index from a state (`SVector`)
 - `idx2state`: A dictionary for looking up state (`SVector`) from a state index
 """
-function enr_state_dictionaries(dims::Union{AbstractVector{T},NTuple{N,T}}, excitations::Int) where {T<:Integer,N}
+function enr_state_dictionaries(dims::Union{AbstractVector{T},NTuple{N,T}}, n_excitations::Int) where {T<:Integer,N}
     # argument checks
     _non_static_array_warning("dims", dims)
     L = length(dims)
     (L > 0) || throw(DomainError(dims, "The argument dims must be of non-zero length"))
     all(>=(1), dims) || throw(DomainError(dims, "All the elements of dims must be non-zero integers (≥ 1)"))
-    (excitations > 0) || throw(DomainError(excitations, "The argument excitations must be a non-zero integer (≥ 1)"))
+    (n_excitations > 0) || throw(DomainError(n_excitations, "The argument n_excitations must be a non-zero integer (≥ 1)"))
 
     nvec = zeros(Int, L) # Vector
     nexc = 0
@@ -106,7 +106,7 @@ function enr_state_dictionaries(dims::Union{AbstractVector{T},NTuple{N,T}}, exci
         nvec[end] += 1
         nexc += 1
         (nvec[idx] < dims[idx]) && push!(result, nvec)
-        while (nexc == excitations) || (nvec[idx] == dims[idx])
+        while (nexc == n_excitations) || (nvec[idx] == dims[idx])
             idx -= 1
 
             # if idx < 1, break while-loop and return
@@ -124,25 +124,25 @@ function enr_state_dictionaries(dims::Union{AbstractVector{T},NTuple{N,T}}, exci
 end
 
 @doc raw"""
-    enr_fock(dims::Union{AbstractVector,Tuple}, excitations::Int, state::AbstractVector; sparse::Union{Bool,Val}=Val(false))
+    enr_fock(dims::Union{AbstractVector,Tuple}, n_excitations::Int, state::AbstractVector; sparse::Union{Bool,Val}=Val(false))
     enr_fock(s_enr::EnrSpace, state::AbstractVector; sparse::Union{Bool,Val}=Val(false))
 
 Generate the Fock state representation ([`Ket`](@ref)) in an excitation number restricted state space ([`EnrSpace`](@ref)).
 
-The arguments `dims` and `excitations` are used to generate [`EnrSpace`](@ref).
+The arguments `dims` and `n_excitations` are used to generate [`EnrSpace`](@ref).
 
 The `state` argument is a list of integers that specifies the state (in the number basis representation) for which to generate the Fock state representation.
 
 !!! warning "Beware of type-stability!"
-    It is highly recommended to use `enr_fock(dims, excitations, state)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
+    It is highly recommended to use `enr_fock(dims, n_excitations, state)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
 """
 function enr_fock(
     dims::Union{AbstractVector{T},NTuple{N,T}},
-    excitations::Int,
+    n_excitations::Int,
     state::AbstractVector{T};
     sparse::Union{Bool,Val} = Val(false),
 ) where {T<:Integer,N}
-    s_enr = EnrSpace(dims, excitations)
+    s_enr = EnrSpace(dims, n_excitations)
     return enr_fock(s_enr, state, sparse = sparse)
 end
 function enr_fock(s_enr::EnrSpace, state::AbstractVector{T}; sparse::Union{Bool,Val} = Val(false)) where {T<:Integer}
@@ -157,25 +157,25 @@ function enr_fock(s_enr::EnrSpace, state::AbstractVector{T}; sparse::Union{Bool,
 end
 
 @doc raw"""
-    enr_thermal_dm(dims::Union{AbstractVector,Tuple}, excitations::Int, n::Union{Real,AbstractVector}; sparse::Union{Bool,Val}=Val(false))
+    enr_thermal_dm(dims::Union{AbstractVector,Tuple}, n_excitations::Int, n::Union{Real,AbstractVector}; sparse::Union{Bool,Val}=Val(false))
     enr_thermal_dm(s_enr::EnrSpace, n::Union{Real,AbstractVector}; sparse::Union{Bool,Val}=Val(false))
 
 Generate the thermal state (density [`Operator`](@ref)) in an excitation number restricted state space ([`EnrSpace`](@ref)).
 
-The arguments `dims` and `excitations` are used to generate [`EnrSpace`](@ref).
+The arguments `dims` and `n_excitations` are used to generate [`EnrSpace`](@ref).
 
 The argument `n` is a list that specifies the expectation values for number of particles in each sub-system. If `n` is specified as a real number, it will apply to each sub-system.
 
 !!! warning "Beware of type-stability!"
-    It is highly recommended to use `enr_thermal_dm(dims, excitations, n)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
+    It is highly recommended to use `enr_thermal_dm(dims, n_excitations, n)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
 """
 function enr_thermal_dm(
     dims::Union{AbstractVector{T1},NTuple{N,T1}},
-    excitations::Int,
+    n_excitations::Int,
     n::Union{T2,AbstractVector{T2}};
     sparse::Union{Bool,Val} = Val(false),
 ) where {T1<:Integer,T2<:Real,N}
-    s_enr = EnrSpace(dims, excitations)
+    s_enr = EnrSpace(dims, n_excitations)
     return enr_thermal_dm(s_enr, n; sparse = sparse)
 end
 function enr_thermal_dm(
@@ -204,26 +204,28 @@ function enr_thermal_dm(
 end
 
 @doc raw"""
-    enr_destroy(dims::Union{AbstractVector,Tuple}, excitations::Int)
+    enr_destroy(dims::Union{AbstractVector,Tuple}, n_excitations::Int)
     enr_destroy(s_enr::EnrSpace)
 
 Generate a `Tuple` of annihilation operators for each sub-system in an excitation number restricted state space ([`EnrSpace`](@ref)). Thus, the return `Tuple` will have the same length as `dims`.
 
-The arguments `dims` and `excitations` are used to generate [`EnrSpace`](@ref).
+The arguments `dims` and `n_excitations` are used to generate [`EnrSpace`](@ref).
 
 !!! warning "Beware of type-stability!"
-    It is highly recommended to use `enr_destroy(dims, excitations)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
+    It is highly recommended to use `enr_destroy(dims, n_excitations)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
 """
-function enr_destroy(dims::Union{AbstractVector{T},NTuple{N,T}}, excitations::Int) where {T<:Integer,N}
-    s_enr = EnrSpace(dims, excitations)
+function enr_destroy(dims::Union{AbstractVector{T},NTuple{N,T}}, n_excitations::Int) where {T<:Integer,N}
+    s_enr = EnrSpace(dims, n_excitations)
     return enr_destroy(s_enr)
 end
 function enr_destroy(s_enr::EnrSpace{N}) where {N}
     D = s_enr.size
     idx2state = s_enr.idx2state
     state2idx = s_enr.state2idx
 
-    a_ops = ntuple(i -> QuantumObject(spzeros(ComplexF64, D, D), Operator(), s_enr), N)
+    I_list = [Int64[] for _ in 1:N]
+    J_list = [Int64[] for _ in 1:N]
+    V_list = [ComplexF64[] for _ in 1:N]
 
     for (n1, state1) in idx2state
         for (idx, s) in pairs(state1)
@@ -233,27 +235,29 @@ function enr_destroy(s_enr::EnrSpace{N}) where {N}
                 state2 = Vector(state1)
                 state2[idx] -= 1
                 n2 = state2idx[state2]
-                a_ops[idx][n2, n1] = √s
+                push!(I_list[idx], n2)
+                push!(J_list[idx], n1)
+                push!(V_list[idx], √s)
             end
         end
     end
 
-    return a_ops
+    return ntuple(i -> QuantumObject(sparse(I_list[i], J_list[i], V_list[i], D, D), Operator(), s_enr), Val(N))
 end
 
 @doc raw"""
-    enr_identity(dims::Union{AbstractVector,Tuple}, excitations::Int)
+    enr_identity(dims::Union{AbstractVector,Tuple}, n_excitations::Int)
     enr_identity(s_enr::EnrSpace)
 
 Generate the identity operator in an excitation number restricted state space ([`EnrSpace`](@ref)).
 
-The arguments `dims` and `excitations` are used to generate [`EnrSpace`](@ref).
+The arguments `dims` and `n_excitations` are used to generate [`EnrSpace`](@ref).
 
 !!! warning "Beware of type-stability!"
-    It is highly recommended to use `enr_identity(dims, excitations)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
+    It is highly recommended to use `enr_identity(dims, n_excitations)` with `dims` as `Tuple` or `SVector` from [StaticArrays.jl](https://github.com/JuliaArrays/StaticArrays.jl) to keep type stability. See [this link](https://docs.julialang.org/en/v1/manual/performance-tips/#man-performance-value-type) and the [related Section](@ref doc:Type-Stability) about type stability for more details.
 """
-function enr_identity(dims::Union{AbstractVector{T},NTuple{N,T}}, excitations::Int) where {T<:Integer,N}
-    s_enr = EnrSpace(dims, excitations)
+function enr_identity(dims::Union{AbstractVector{T},NTuple{N,T}}, n_excitations::Int) where {T<:Integer,N}
+    s_enr = EnrSpace(dims, n_excitations)
     return enr_identity(s_enr)
 end
 enr_identity(s_enr::EnrSpace) = QuantumObject(Diagonal(ones(ComplexF64, s_enr.size)), Operator(), s_enr)