Abyssmal lindblad_op performance for larger systems

[dnadlinger]

The performance of the lindblad equation implementation for non-tiny systems is … not great. For example, just do lindblad_op(Δ * a'a , [sqrt(κ) * a]) (e.g. through QuPropagator) on a Fock space of dimension 80 and watch it take a very non-negligible amount of time even though the resulting matrix is very sparse.

Even this very straightforward implementation seems to run circles around it:

super_pre_post(pre, post) = kron(transpose(post), pre)

dissipator(a) = super_pre_post(a, a') - 0.5 * super_pre_post(a'a, speye(size(a)...)) - 0.5 * super_pre_post(speye(size(a)...), a'a)

hamiltonian(h) = -1im * (super_pre_post(h, speye(size(h)...)) - super_pre_post(speye(size(h)...), h))

function lindblad_op(h::QuBase.AbstractQuMatrix, collapse_ops::Vector)
    super = hamiltonian(coeffs(h))
    for c_op in collapse_ops
       super += dissipator(coeffs(c_op))
    end
    super
end

(the result of this piece of code is a raw matrix instead of a QuBase object, but that's inconsequential)

[acroy]

I can't check it right now, but you are probably right that the performance
is not great. In particular the sparsity of the input operators is not used
at all. It would also be good to have a mutating version, which works on a
preallocated matrix and only allocates little memory.
On So., 18. Okt. 2015 at 13:25, David Nadlinger notifications@github.com
wrote:

The performance of the lindblad equation implementation for non-tiny
systems is … not great. For example, just do lindblad_op(Δ * a'a ,
[sqrt(κ) * a]) (e.g. through QuPropagator) on a fock space of dimension
80 and watch it take a very non-negligible amount of time even though the
resulting matrix is very sparse.

Even this very straightforward implementation seems to run circles around
it:

super_pre_post(pre, post) = kron(transpose(post), pre)
dissipator(a) = super_pre_post(a, a') - 0.5 * super_pre_post(a'a, speye(size(a)...)) - 0.5 * super_pre_post(speye(size(a)...), a'a)
hamiltonian(h) = -1im * (super_pre_post(h,speye(size(h)...)) - super_pre_post(speye(size(h)...), h))
function lindblad_op(h::QuBase.AbstractQuMatrix, collapse_ops::Vector)
super = hamiltonian(coeffs(h))
for c_op in collapse_ops
super += dissipator(coeffs(c_op))
end
superend

—
Reply to this email directly or view it on GitHub
#32.

[amitjamadagni]

@klickverbot, the changes you have suggested make the performance better

julia> super_pre_post(pre, post) = kron(transpose(post), pre)
super_pre_post (generic function with 1 method)

julia> dissipator(a) = super_pre_post(a, a') - 0.5 * super_pre_post(a'a, speye(size(a)...)) - 0.5 * super_pre_post(speye(size(a)...), a'a)
dissipator (generic function with 1 method)

julia> hamiltonian(h) = -1im * (super_pre_post(h, speye(size(h)...)) - super_pre_post(speye(size(h)...), h))
hamiltonian (generic function with 1 method)

julia> function lindblad_op(h::QuBase.AbstractQuMatrix, collapse_ops::Vector)
           super = hamiltonian(coeffs(h))
           for c_op in collapse_ops
              super += dissipator(coeffs(c_op))
           end
           super
       end
lindblad_op (generic function with 1 method)

julia> Base.dense(qarr::QuBase.QuArray) = QuArray(dense(coeffs(qarr)))
dense (generic function with 2 methods)

julia> @elapsed lindblad_op(dense(raiseop(80)), [dense(lowerop(80))])
2.414717045

julia> @elapsed lindblad_op(raiseop(80), [lowerop(80)])
0.042128692


julia> @elapsed QuDynamics.lindblad_op(dense(raiseop(80)),  [dense(lowerop(80))])
65.036064883

julia> @elapsed QuDynamics.lindblad_op(raiseop(80),  [lowerop(80)])
238.594115812

it would be really helpful to know if you could send in a PR with the suggested changes. Thanks !