Semiclassical Approaches to Reduced Density Matrix Propagation

General description of the system, particularly for trajectory based methods.

Abstract phase space for methods that use a linearised semiclassical approximation.

Abstract phase space for methods that use a partially linearised semiclassical approximation.

Abstract type for methods that propagate system and bath together. All such systems must implement Base.iterate which returns the next sample point of the system and the solvent.

    Fbath!(sys::MappedSystem, ps::LinearisedSysPhaseSpace, f::Vector{<:AbstractVector{<:Real}})

Calculate the system sys's force on the bath and write it to f.

This function assumes that the system-bath interaction is of the form

\[H_{sb} = \sum\limits_b^{N_{\rm bath}} \sum\limits_j^{N_{\rm osc, j}} - c_{bj} \omega_{bj} s_b.\]

    Fbath!(sys::MappedSystem, ps::PartialLinearisedSysPhaseSpace, f::Vector{<:AbstractVector{<:Real}})

Write the average force exerted by the system sys on the bath to f.

This method calculates the force as the average of the force from the forward and the backward path of the system.

Abstract type for mapping Hamiltonian methods.

Abstract type for all spin-mapped systems. It should contain the following elements always:

• transform: the Stratonovich–Weyl transform
• d: the dimensionality of the system
• γₛ: the zero-point energy parameter of the Stratonovich–Weyl transform
• R²: the squared-radius parameter for the Stratonovich–Weyl transform

γ(::MappedSystem)

Return the zero-point energy parameter for system with mapped Hamiltonian.

 sample_XP(sys::SpinMappedSystem)

Draw a random sample of the pseudo position and momentum for sys. This draws a sample from the hypersphere surface associated with the system's Stratonovich–Weyl transform.

propagate(; Hamiltonian::Matrix{<:Complex}, Jw::Vector{T},
          β::Real, num_osc::Vector{<:Integer}, svec::Matrix{<:Real},
          ρ0::Matrix{<:Complex}, dt::Real,
          ntimes::Integer, nmc::Integer, verbose::Bool=false,
          kwargs...) where {T<:SpectralDensities.SpectralDensity}

Propagate the system using the spin-mapped PLDM method.

Arguments:

• ρ0: initial reduced density matrix
• Hamiltonian: the Hamiltonian of the sub-system
• Jw: list of spectral densities
• β: the inverse temperature of the bath
• num_osc: the number of oscillators for each bath
• svec: diagonal elements of system operators through which the corresponding baths interact
• dt: the time step for the propagation
• nmc: the number of Monte-Carlo samples

Propagate the reduced density matrix ρ0 using the partial linearized density matrix propagation scheme.

propagate(; Hamiltonian::Matrix{<:Complex}, Jw::Vector{T},
          β::Real, num_osc::Vector{<:Integer}, svec::Matrix{<:Real},
          ρ0::Matrix{<:Complex}, dt::Real,
          ntimes::Real, transform::Type{<:Systems.SWTransform},
          nmc::Integer, verbose::Bool=false,
          kwargs...) where {T<:SpectralDensities.SpectralDensity}

Propagate the system using the spin-mapped PLDM method.

Arguments:

• ρ0: initial reduced density matrix
• Hamiltonian: the Hamiltonian of the sub-system
• Jw: list of spectral densities
• β: the inverse temperature of the bath
• num_osc: the number of oscillator for each bath
• svec: diagonal elements of system operators through which the corresponding baths interact
• transform: the Stratonovich–Weyl transformation to use for the Hamiltonian
• dt: the time step for the propagation
• nmc: the number of Monte-Carlo samples

Propagate the density matrix using a partially linearised propagator for the system-bath problem, using the given Stratonovich–Weyl transform for the Hamiltonian.

propagate(; Hamiltonian::AbstractMatrix{<:Complex}, Jw::Vector{T},
          β::Real, num_osc::Vector{<:Integer}, svec::Matrix{<:Real},
          ρ0::AbstractMatrix{<:Complex}, dt::Real,
          ntimes::Integer, nmc::Integer, verbose::Bool=false,
          kwargs...) where {T<:SpectralDensities.SpectralDensity}

Propagate the system via linearised semiclassics after MMST mapping.

Arguments:

• ρ0: initial reduced density matrix
• Hamiltonian: the Hamiltonian of the sub-system
• Jw0: list of spectral densities
• β: the inverse temperature of the bath
• num_osc: the number of oscillators for each bath
• svec: diagonal elements of system operators through which the corresponding bath interact
• dt: the time step for the propagation
• nmc: the number of Monte-Carlo samples

Propagate the reduced density matrix ρ0 by doing fully linearised semiclassics on the system space, after transforming the Hamiltonian with the Meyer-Miller-Stock-Thoss mapping procedure.

propagate(; Hamiltonian::Matrix{<:Complex}, Jw::Vector{T},
         β::Real, num_osc::Vector{<:Integer}, svec::Matrix{<:Real},
         ρ0::Union{Nothing,Matrix{<:Complex}}, dt::Real,
         ntimes::Real, transform::Type{<:Systems.SWTransform},
         nmc::Integer, focused::Bool=false, verbose::Bool=false,
         build_dynamical_map::Bool=false, kwargs...) where {T<:SpectralDensities.SpectralDensity}

Propagate the system using the spin-mapped LSC method.

Arguments:

• ρ0: the initial density matrix. If it is nothing, then build only the dynamical map
• Hamiltonian: the Hamiltonian of the sub-system
• Jw: list of spectral densities
• β: the inverse temperature of the baths
• num_osc: the number of oscillators for each bath
• svec: diagonal elements of system operators through which the corresponding baths interact
• transform: the Stratonovich–Weyl transform to use for the Hamiltonian
• dt: the time step for the propagation
• focused: should focused initial sampling be used
• nmc: the number of Monte-Carlo samples

Propagate the density matrix and build the dynamical map by doing linearised semiclassical propagator using the given Stratonovich–Weyl transform for the Hamiltonian of the system.

sampling_weight(sys::SpinLSCSys, ρ₀::AbstractMatrix{<:Complex}, ps::SpinLSCSysPhaseSpace)

Return the sampling weight for sys with initial density matrix ρ₀.

This returns d × [ρ₀]ₛ for full-sphere sampling, 1 for focused sampling.

sampling_func_mult(sys::SpinLSCSys)

Return the sampling function's constant multipler for sys.

This returns 1 for focused sampling, and the number of dof of the system for full-sphere sampling.

reconstruct_bare_ρ(sys::SpinLSCSys, sps::SpinLSCSysPhaseSpace)

Reconstruct the bare density matrix for the phase space point.

This does NOT multiply by the number of system's dof nor the Stratonovich–Weyl transform of the initial density matrix.

transform_op(sys::MappedSystem, op::AbstractVector{<:Number},
             X::AbstractVector{<:Real}, P::AbstractVector{<:Real})

Return the mapped form of the diagonal operator op.

This function assumes that the mapping formalism can be put in the following general form for an arbitrary operator Ω

\[\Omega_{\rm mapped} = \sum_j \Omega_{jj} \frac{X_j^2 + P_j^2 - \gamma}{2}\]

where γ is the zero-point energy parameter, which is obtained using the system sys's QuantumDynamics.Systems.γ method.

transform_op(sys::MappedSystem, op::AbstractMatrix{<:Number},
             X::AbstractVector{<:Real}, P::AbstractVector{<:Real})

Return the mapped form of the general operator op.

This function assumes that the mapped operator has the following general form

\[\Omega_{\rm mapped} = \sum_jk \Omega_{jk} \frac{(X_j - i P_j)(X_k + i P_k) - \delta_{jk} \gamma}{2}\]

where γ and δⱼₖ are the zero-point energy parameter and the Kronecker delta respectively. The former is obtained using the system sys's QuantumDynamics.Systems.γ method.

transform_op(sys::MappedSystem, op::Union{AbstractMatrix,AbstractVector},
             ps::PartialLinearisedSysPhaseSpace, path::Symbol)

Return the mapped form of operator op for the phase space point in specified path.

The argument path can be either :forward or :backward depending on whether the operator should be mapped for the forward or backward path respectively.

Perform the relevant SW transform of the operator op.

Abstract type for all Stratonovich–Weyl transforms.