upgrades and consistently using itensormps

Author: amartyabose

Project.toml

@@ -1,7 +1,7 @@
 name = "QuantumDynamics"
 uuid = "5a40c529-53c2-4483-a223-e00c1cee8134"
 authors = ["Amartya Bose <[email protected]> and contributors"]
-version = "0.2.27"
+version = "0.2.28"
 
 [deps]
 AtomsIO = "1692102d-eeb4-4df9-807b-c9517f998d44"
@@ -34,8 +34,8 @@ DelimitedFiles = "1"
 Distributions = "0.25"
 FLoops = "0.2"
 HDF5 = "0.17"
-ITensorMPS = "0.2.1"
-ITensors = "0.6"
+ITensorMPS = "0.3"
+ITensors = "0.7"
 Interpolations = "0.15"
 JSON3 = "1"
 OrdinaryDiffEq = "6"

docs/src/documentation/Utilities.md

@@ -21,7 +21,7 @@ Utilities.MPS_to_MPO
 ```
 
 ```@docs
-ITensors.expect
+ITensorMPS.expect
 ```
 
 ## HDF5 Utilities

src/PathIntegral/PCTNPI.jl

@@ -2,7 +2,7 @@ module PCTNPI
 
 using LinearAlgebra
 using HDF5
-using ITensors
+using ITensors, ITensorMPS
 using FLoops
 using ..EtaCoefficients, ..Propagators, ..SpectralDensities, ..Blip, ..Utilities, ..TTM
 
@@ -12,15 +12,15 @@ const references = """
 const PCTNPIArgs = Utilities.TensorNetworkArgs
 
 function generate_bottom_right_tensor(ηs, sites, blip_sites, state_to_blip, fbU, k::Int, Δs, sbar)
-    ind1 = sites[k-1]
-    ind2 = sites[k]
-    ind3 = blip_sites[k]'
-    η11 = [η.η00 for η in ηs]
-    η10 = [η.η0m[1] for η in ηs]
+    @inbounds ind1 = sites[k-1]
+    @inbounds ind2 = sites[k]
+    @inbounds ind3 = blip_sites[k]'
+    @inbounds η11 = [η.η00 for η in ηs]
+    @inbounds η10 = [η.η0m[1] for η in ηs]
     tens = ITensor(ind1, ind2, ind3)
     for skp = 1:dim(ind1)
         for sk = 1:dim(ind2)
-            tens[ind1=>skp, ind2=>sk, ind3=>state_to_blip[sk]] = fbU[sk, skp] *
+            @inbounds tens[ind1=>skp, ind2=>sk, ind3=>state_to_blip[sk]] = fbU[sk, skp] *
                                                                  exp.(-sum(Δs[:, sk] .* (real(η11) .* Δs[:, sk] + 2im * imag(η11) .* sbar[:, sk]))) *
                                                                  exp.(-sum(Δs[:, sk] .* (real(η10) .* Δs[:, skp] + 2im * imag(η10) .* sbar[:, skp])))
         end
@@ -29,16 +29,16 @@ function generate_bottom_right_tensor(ηs, sites, blip_sites, state_to_blip, fbU
 end
 
 function generate_bottom_left_tensor(ηs, sites, fbU, k::Int, Δs, sbar)
-    ind1 = sites[k-1]
-    ind2 = sites[k]
-    ind3 = sites[k-1]'
-    η00 = [η.η00 for η in ηs]
-    η11 = [η.ηmm for η in ηs]
-    η10 = [η.η0m[1] for η in ηs]
+    @inbounds ind1 = sites[k-1]
+    @inbounds ind2 = sites[k]
+    @inbounds ind3 = sites[k-1]'
+    @inbounds η00 = [η.η00 for η in ηs]
+    @inbounds η11 = [η.ηmm for η in ηs]
+    @inbounds η10 = [η.η0m[1] for η in ηs]
     tens = ITensor(ind1, ind2, ind3)
     for skp = 1:dim(ind1)
         for sk = 1:dim(ind2)
-            tens[ind1=>skp, ind2=>sk, ind3=>skp] = fbU[sk, skp] *
+            @inbounds tens[ind1=>skp, ind2=>sk, ind3=>skp] = fbU[sk, skp] *
                                                    exp.(-sum(Δs[:, skp] .* (real(η00) .* Δs[:, skp] + 2im * imag(η00) .* sbar[:, skp]))) *
                                                    exp.(-sum(Δs[:, sk] .* (real(η11) .* Δs[:, sk] + 2im * imag(η11) .* sbar[:, sk]))) *
                                                    exp.(-sum(Δs[:, sk] .* (real(η10) .* Δs[:, skp] + 2im * imag(η10) .* sbar[:, skp])))
@@ -48,16 +48,16 @@ function generate_bottom_left_tensor(ηs, sites, fbU, k::Int, Δs, sbar)
 end
 
 function generate_bottom_center_tensor(ηs, sites, blip_sites, state_to_blip, fbU, k::Int, Δs, sbar)
-    ind1 = sites[k-1]
-    ind2 = sites[k]
-    ind3 = sites[k-1]'
-    ind4 = blip_sites[k]'
-    η11 = [η.ηmm for η in ηs]
-    η10 = [η.ηmn[1] for η in ηs]
+    @inbounds ind1 = sites[k-1]
+    @inbounds ind2 = sites[k]
+    @inbounds ind3 = sites[k-1]'
+    @inbounds ind4 = blip_sites[k]'
+    @inbounds η11 = [η.ηmm for η in ηs]
+    @inbounds η10 = [η.ηmn[1] for η in ηs]
     tens = ITensor(ind1, ind2, ind3, ind4)
     for skp = 1:dim(ind1)
         for sk = 1:dim(ind2)
-            tens[ind1=>skp, ind2=>sk, ind3=>skp, ind4=>state_to_blip[sk]] = fbU[sk, skp] *
+            @inbounds tens[ind1=>skp, ind2=>sk, ind3=>skp, ind4=>state_to_blip[sk]] = fbU[sk, skp] *
                                                                             exp.(-sum(Δs[:, sk] .* (real(η11) .* Δs[:, sk] + 2im * imag(η11) .* sbar[:, sk]))) *
                                                                             exp.(-sum(Δs[:, sk] .* (real(η10) .* Δs[:, skp] + 2im * imag(η10) .* sbar[:, skp])))
         end
@@ -67,59 +67,59 @@ end
 
 function generate_center_tensor(ηs, sites, blip_sites, k::Int, kp::Int, group_Δs, Δs, sbar)
     kkp = k - kp
-    ind1 = prime(sites[kp], kkp - 1)
-    ind2 = prime(blip_sites[k], kkp - 1)
-    ind3 = prime(sites[kp], kkp)
-    ind4 = prime(blip_sites[k], kkp)
-    η = [η.ηmn[kkp] for η in ηs]
+    @inbounds ind1 = prime(sites[kp], kkp - 1)
+    @inbounds ind2 = prime(blip_sites[k], kkp - 1)
+    @inbounds ind3 = prime(sites[kp], kkp)
+    @inbounds ind4 = prime(blip_sites[k], kkp)
+    @inbounds η = [η.ηmn[kkp] for η in ηs]
     tens = ITensor(ind1, ind2, ind3, ind4)
     for skp = 1:dim(ind1)
         for sk = 1:dim(ind2)
-            tens[ind1=>skp, ind2=>sk, ind3=>skp, ind4=>sk] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
+            @inbounds tens[ind1=>skp, ind2=>sk, ind3=>skp, ind4=>sk] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
         end
     end
     tens
 end
 
 function generate_left_tensor(ηs, sites, blip_sites, k::Int, kp::Int, group_Δs, Δs, sbar)
     kkp = k - kp
-    ind1 = prime(sites[kp], kkp - 1)
-    ind2 = prime(blip_sites[k], kkp - 1)
-    ind3 = prime(sites[kp], kkp)
-    η = [η.η0m[kkp] for η in ηs]
+    @inbounds ind1 = prime(sites[kp], kkp - 1)
+    @inbounds ind2 = prime(blip_sites[k], kkp - 1)
+    @inbounds ind3 = prime(sites[kp], kkp)
+    @inbounds η = [η.η0m[kkp] for η in ηs]
     tens = ITensor(ind1, ind2, ind3)
     for skp = 1:dim(ind1)
         for sk = 1:dim(ind2)
-            tens[ind1=>skp, ind2=>sk, ind3=>skp] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
+            @inbounds tens[ind1=>skp, ind2=>sk, ind3=>skp] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
         end
     end
     tens
 end
 
 function generate_right_tensor(ηs, sites, blip_sites, k::Int, kp::Int, group_Δs, Δs, sbar)
     kkp = k - kp
-    ind1 = prime(sites[kp], kkp - 1)
-    ind2 = prime(blip_sites[k], kkp - 1)
-    ind3 = prime(blip_sites[k], kkp)
-    η = [η.η0m[kkp] for η in ηs]
+    @inbounds ind1 = prime(sites[kp], kkp - 1)
+    @inbounds ind2 = prime(blip_sites[k], kkp - 1)
+    @inbounds ind3 = prime(blip_sites[k], kkp)
+    @inbounds η = [η.η0m[kkp] for η in ηs]
     tens = ITensor(ind1, ind2, ind3)
     for skp = 1:dim(ind1)
         for sk = 1:dim(ind2)
-            tens[ind1=>skp, ind2=>sk, ind3=>sk] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
+            @inbounds tens[ind1=>skp, ind2=>sk, ind3=>sk] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
         end
     end
     tens
 end
 
 function generate_top_tensor(ηs, sites, blip_sites, k::Int, kp::Int, group_Δs, Δs, sbar)
     kkp = k - kp
-    ind1 = prime(sites[kp], kkp - 1)
-    ind2 = prime(blip_sites[k], kkp - 1)
-    η = [η.η0e[kkp] for η in ηs]
+    @inbounds ind1 = prime(sites[kp], kkp - 1)
+    @inbounds ind2 = prime(blip_sites[k], kkp - 1)
+    @inbounds η = [η.η0e[kkp] for η in ηs]
     tens = ITensor(ind1, ind2)
     for skp = 1:dim(ind1)
         for sk = 1:dim(ind2)
-            tens[ind1=>skp, ind2=>sk] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
+            @inbounds tens[ind1=>skp, ind2=>sk] = exp.(-sum(group_Δs[:, sk] .* (real(η) .* Δs[:, skp] + 2im * imag(η) .* sbar[:, skp])))
         end
     end
     tens
@@ -151,63 +151,74 @@ function build_augmented_propagator(; fbU::AbstractArray{ComplexF64,3}, Jw::Abst
     U0e = zeros(ComplexF64, ntimes, sdim2, sdim2)
     T0e = zero(U0e)
 
-    # calculate for the first time step separately, s1->s2
-    U0e[1, :, :] = fbU[1, :, :]
-    for (bn, η) in enumerate(ηs)
-        infl = exp.(-Δs[bn, :] .* (real(η.η00) * Δs[bn, :] + 2im * imag(η.η00) * sbar[bn, :]))
-        for t = 1:sdim2
-            U0e[1, t, :] .*= infl
-            U0e[1, :, t] .*= infl
-            infl1 = exp.(-Δs[bn, t] .* (real(η.η0e[1]) * Δs[bn, :] + 2im * imag(η.η0e[1]) * sbar[bn, :]))
-            U0e[1, t, :] .*= infl1
+    @inbounds begin
+        # calculate for the first time step separately, s1->s2
+        U0e[1, :, :] = fbU[1, :, :]
+        for (bn, η) in enumerate(ηs)
+            infl = exp.(-Δs[bn, :] .* (real(η.η00) * Δs[bn, :] + 2im * imag(η.η00) * sbar[bn, :]))
+            for t = 1:sdim2
+                U0e[1, t, :] .*= infl
+                U0e[1, :, t] .*= infl
+                infl1 = exp.(-Δs[bn, t] .* (real(η.η0e[1]) * Δs[bn, :] + 2im * imag(η.η0e[1]) * sbar[bn, :]))
+                U0e[1, t, :] .*= infl1
+            end
         end
-    end
-    TTM.update_Ts!(T0e, U0e, 1)
-    if !isnothing(output)
-        if !from_TTM
-            Utilities.check_or_insert_value(output, "U0e", U0e)
+        TTM.update_Ts!(T0e, U0e, 1)
+        if !isnothing(output)
+            if !from_TTM
+                Utilities.check_or_insert_value(output, "U0e", U0e)
+            end
+            Utilities.check_or_insert_value(output, "T0e", T0e)
+            output["U0e"][1, :, :] = U0e[1, :, :]
+            output["T0e"][1, :, :] = T0e[1, :, :]
+            flush(output)
         end
-        Utilities.check_or_insert_value(output, "T0e", T0e)
-        output["U0e"][1, :, :] = U0e[1, :, :]
-        output["T0e"][1, :, :] = T0e[1, :, :]
-        flush(output)
-    end
 
-    sites = siteinds(sdim2, ntimes + 1)
-    blip_sites = siteinds(size(group_Δs, 2), ntimes + 1; add_tags="blip_sites")
-    for j = 2:ntimes
-        if verbose
-            @info "Step = $(j)"
-        end
-        # calculation for s1->s_{j+1}
-        tens = [generate_top_tensor(ηs, sites, blip_sites, j + 1, 1, group_Δs, Δs, sbar)]
-        for l = j:-1:3
-            push!(tens, generate_left_tensor(ηs, sites, blip_sites, l, 1, group_Δs, Δs, sbar))
-        end
-        push!(tens, generate_bottom_left_tensor(ηs, sites, fbU[1, :, :], 2, Δs, sbar))
+        sites = siteinds(sdim2, ntimes + 1)
+        blip_sites = siteinds(size(group_Δs, 2), ntimes + 1; add_tags="blip_sites")
+        for j = 2:ntimes
+            if verbose
+                @info "Step = $(j)"
+            end
+            tens = Vector{ITensor}(undef, j * (j+1) ÷ 2)
+            # calculation for s1->s_{j+1}
+            k = 1
+            tens[k] = generate_top_tensor(ηs, sites, blip_sites, j + 1, 1, group_Δs, Δs, sbar)
+            k += 1
+            for l = j:-1:3
+                tens[k] = generate_left_tensor(ηs, sites, blip_sites, l, 1, group_Δs, Δs, sbar)
+                k += 1
+            end
+            tens[k] = generate_bottom_left_tensor(ηs, sites, fbU[1, :, :], 2, Δs, sbar)
+            k += 1
 
-        for p = 3:j
-            push!(tens, generate_bottom_center_tensor(ηs, sites, blip_sites, state_to_blip, fbU[p-1, :, :], p, Δs, sbar))
+            for p = 3:j
+                tens[k] = generate_bottom_center_tensor(ηs, sites, blip_sites, state_to_blip, fbU[p-1, :, :], p, Δs, sbar)
+                k += 1
 
-            for h = 1:j-p
-                push!(tens, generate_center_tensor(ηs, sites, blip_sites, p + h, p - 1, group_Δs, Δs, sbar))
-            end
+                for h = 1:j-p
+                    tens[k] = generate_center_tensor(ηs, sites, blip_sites, p + h, p - 1, group_Δs, Δs, sbar)
+                    k += 1
+                end
 
-            push!(tens, generate_right_tensor(ηs, sites, blip_sites, j + 1, p - 1, group_Δs, Δs, sbar))
-        end
+                tens[k] = generate_right_tensor(ηs, sites, blip_sites, j + 1, p - 1, group_Δs, Δs, sbar)
+                k += 1
+            end
 
-        push!(tens, generate_bottom_right_tensor(ηs, sites, blip_sites, state_to_blip, fbU[j, :, :], j + 1, Δs, sbar))
+            tens[k] = generate_bottom_right_tensor(ηs, sites, blip_sites, state_to_blip, fbU[j, :, :], j + 1, Δs, sbar)
+            k += 1
 
-        prop = deepcopy(tens[1])
-        for tensor in tens[2:end]
-            prop *= tensor
-        end
-        U0e[j, :, :] = Utilities.convert_ITensor_to_matrix(prop, sites[1], sites[j+1])
-        TTM.update_Ts!(T0e, U0e, j)
-        if !isnothing(output)
-            output["U0e"][j, :, :] = U0e[j, :, :]
-            output["T0e"][j, :, :] = T0e[j, :, :]
-            flush(output)
+            prop = deepcopy(tens[1])
+            for tensor in tens[2:end]
+                prop *= tensor
+            end
+            U0e[j, :, :] = Utilities.convert_ITensor_to_matrix(prop, sites[1], sites[j+1])
+            TTM.update_Ts!(T0e, U0e, j)
+            if !isnothing(output)
+                output["U0e"][j, :, :] = U0e[j, :, :]
+                output["T0e"][j, :, :] = T0e[j, :, :]
+                flush(output)
+            end
         end
     end
     U0e

src/Utilities/ITensorUtils.jl

@@ -1,5 +1,5 @@
 using LinearAlgebra
-using ITensors
+using ITensors, ITensorMPS
 
 """
     calculate_Liouvillian(H::OpSum, sites)
@@ -72,10 +72,10 @@ function MPS_to_MPO(ρ::MPS, fbcombiner)
 end
 
 """
-    ITensors.expect(ρ::MPO, ops; kwargs...)
-Extends ITensors' `expect` function to handle density matrices in the form of MPOs.
+    ITensorMPS.expect(ρ::MPO, ops; kwargs...)
+Extends the ITensorMPS `expect` function to handle density matrices in the form of MPOs.
 """
-function ITensors.expect(ρ::MPO, ops::Tuple; kwargs...)
+function ITensorMPS.expect(ρ::MPO, ops::Tuple; kwargs...)
     ρtmp = deepcopy(ρ)
     N = length(ρ)
     s = Vector{Index{Int64}}()
@@ -134,19 +134,19 @@ function ITensors.expect(ρ::MPO, ops::Tuple; kwargs...)
     return ex
 end
 
-function ITensors.expect(psi::MPO, op::AbstractString; kwargs...)
+function ITensorMPS.expect(psi::MPO, op::AbstractString; kwargs...)
     return first(expect(psi, (op,); kwargs...))
 end
 
-function ITensors.expect(psi::MPO, op::Matrix{<:Number}; kwargs...)
+function ITensorMPS.expect(psi::MPO, op::Matrix{<:Number}; kwargs...)
     return first(expect(psi, (op,); kwargs...))
 end
 
-function ITensors.expect(psi::MPO, op1::AbstractString, ops::AbstractString...; kwargs...)
+function ITensorMPS.expect(psi::MPO, op1::AbstractString, ops::AbstractString...; kwargs...)
     return expect(psi, (op1, ops...); kwargs...)
 end
 
-function ITensors.expect(psi::MPO, op1::Matrix{<:Number}, ops::Matrix{<:Number}...; kwargs...)
+function ITensorMPS.expect(psi::MPO, op1::Matrix{<:Number}, ops::Matrix{<:Number}...; kwargs...)
     return expect(psi, (op1, ops...); kwargs...)
 end
 
@@ -255,7 +255,7 @@ function convert_ITensor_to_matrix(tens, sinit, sterm)
     matrix
 end
 
-function ITensors.:+(::ITensors.Algorithm"approx", ψ::MPST...; cutoff::Float64, maxdim::Int64) where {MPST<:ITensors.AbstractMPS}
+function ITensors.:+(::ITensors.Algorithm"approx", ψ::MPST...; cutoff::Float64, maxdim::Int64) where {MPST<:ITensorMPS.AbstractMPS}
     @error "This approximate function needs to be implemented"
     n = length(first(ψ))
     @assert all(ψᵢ -> length(first(ψ)) == length(ψᵢ), ψ)