QuantumClusterTheories

const qcttimer

Default shared timer for all quantum cluster theory methods.

CPT{U<:AbstractLattice, L<:AbstractLattice, I<:ImpuritySolver, V<:CPTPerturbation, P<:Periodization}

Alias for QCT with V<:CPTPerturbation, representing cluster perturbation theory.

CPTPerturbation{V<:TBA} <: Perturbation

CPT (cluster perturbation theory) perturbation containing the intercluster quadratic terms of a system.

DynamicalSpectra{R<:ReciprocalSpace} <: Action

Dynamical spectra.

DynamicalSpectraData{R<:ReciprocalSpace} <: Data

Data of dynamical spectra computed from quantum cluster theory, including:

1. reciprocalspace::R: reciprocal space on which the spectra are computed.
2. energies::Vector{Float64}: energy sample points.
3. values::Matrix{Float64}: spectral function A(ω,k) = -Im[Tr[G(ω,k)]] at each energy-momentum point.

ImpuritySolver <: Frontend

Abstract type for impurity solvers used in quantum cluster theory calculations. Subtypes must implement the call syntax solver(ω) to return the solver's response function at frequency ω.

Periodization{N}

Structure for crystallographic periodization in quantum cluster theory. Stores the coordinates of lattice operators and groups them by equivalence under lattice translations.

(periodization::Periodization)(data::AbstractMatrix{<:Number}, k::AbstractVector{<:Number}) -> Matrix{ComplexF64}

Apply crystallographic periodization to data at a given crystal momentum k.

Periodization(
    ops_lattice::AbstractVector{<:CoordinatedIndex}, ops_unitcell::AbstractVector{<:CoordinatedIndex}, vectors::AbstractVector{<:AbstractVector{<:Number}};
    atol=atol, rtol=rtol
) -> Periodization

Construct a Periodization object by grouping lattice operators into translation-equivalent sets.

Perturbation

Abstract type for perturbations in quantum cluster theory. Subtypes must implement kind, update!, and the call syntax perturbation(k) returning the perturbation matrix at momentum k.

Perturbation(intercluster::TBA, weiss::TBA) -> VCAPerturbation
Perturbation(
    lattice::AbstractLattice, hilbert::Hilbert, terms::OneOrMore{Term}, weiss::OneOrMore{Term};
    neighbors::Union{Int, Neighbors}=max(nneighbor(terms), nneighbor(weiss))
) -> VCAPerturbation
Perturbation(
    bonds₁::AbstractVector{<:Bond}, bonds₂::AbstractVector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}, weiss::OneOrMore{Term}
) -> VCAPerturbation

Construct a VCA perturbation from pre-built TBA objects, or from lattice/hilbert/terms/weiss terms, or from separated bonds.

Perturbation(intercluster::TBA) -> CPTPerturbation
Perturbation(lattice::AbstractLattice, hilbert::Hilbert, terms::OneOrMore{Term}; neighbors::Union{Int, Neighbors}=nneighbor(terms)) -> CPTPerturbation
Perturbation(bonds::AbstractVector{<:Bond}, hilbert::Hilbert, terms::OneOrMore{Term}) -> CPTPerturbation

Construct a CPT perturbation from a pre-built TBA, or from a lattice/hilbert/terms, or from bonds/hilbert/terms.

QCT{U<:AbstractLattice, L<:AbstractLattice, I<:ImpuritySolver, V<:Perturbation, P<:Periodization} <: Frontend

Quantum cluster theory frontend that combines an impurity solver, perturbation, and crystallographic periodization to compute the Green's function of a system.

VCA{U<:AbstractLattice, L<:AbstractLattice, I<:ImpuritySolver, V<:VCAPerturbation, P<:Periodization}

Alias for QCT with V<:VCAPerturbation, representing the Variational Cluster Approach (VCA).

VCAPerturbation{V<:TBA, W<:TBA} <: Perturbation

VCA (Variational Cluster Approach) perturbation containing both intercluster quadratic terms and Weiss field terms of a system.

(qct::Union{QCT, Algorithm{<:QCT}})(ω::Number, k::Union{AbstractVector{<:Number}, Nothing}=nothing; periodization::Bool=true)

Evaluate the Green's function at frequency ω and momentum k by use of quantum cluster theory. When k is nothing, no periodization is performed even if periodization=true.

count(periodization::Periodization) -> Int

Return the number of unit cells in the cluster (i.e., the ratio of cluster size to unitcell size).

inv(solver::ImpuritySolver, ω::Number) -> Matrix{ComplexF64}

Get the inverse of the retarded Green's function at frequency ω

expectation(qct::Algorithm{<:QCT}, m::Union{AbstractMatrix{<:Number}, Function, Symbol}; kwargs...) -> Float64
expectation(
    qct::QCT, m::Union{AbstractMatrix{<:Number}, Function, Symbol};
    brillouinzone::BrillouinZone=BrillouinZone(qct.lattice, 100), μ::Real=0.0, p::Real=1.0, atol::Real=1e-6, rtol::Real=1e-6, maxevals::Int=10^6
) -> Float64

Compute the expectation value of an operator m (matrix, or function of k, or the symbol specifies the Weiss term in VCA) over the quantum cluster theory system by integrating over the Brillouin zone and frequency.

For Algorithm{<:QCT}, this delegates to the second method.

operators(tbakind::TBAKind{:TBA}, lattice::AbstractLattice, hilbert::Hilbert{<:Fock}, table::Table=Table(hilbert, Metric(tbakind, hilbert))) -> Vector{<:CoordinatedIndex}
operators(tbakind::TBAKind{:BdG}, lattice::AbstractLattice, hilbert::Hilbert{<:Fock}, table::Table=Table(hilbert, Metric(tbakind, hilbert))) -> Vector{<:CoordinatedIndex}

Get the single-particle operators sorted by table index. For TBA kind, returns only annihilation operators; for BdG kind, returns all operators.

quadratic(terms::ZeroAtLeast{Term}) -> Tuple

Extract the quadratic (rank-2) terms from a collection of terms.

Ω(qct::Algorithm{<:QCT}; kwargs...) -> Float64
Ω(
    qct::QCT;
    brillouinzone::BrillouinZone=BrillouinZone(qct.lattice, 100), μ::Real=0.0, atol::Real=1e-6, rtol::Real=1e-6, maxevals::Int=10^6
) -> Float64

Compute the grand potential per unit cell of the quantum cluster theory system.

For Algorithm{<:VCA}, this delegates to the second method.

optimize!(vca::Algorithm{<:VCA}; kwargs...)
optimize!(
    vca::VCA;
    verbose=false, method=LBFGS(), options=Options(x_abstol=1e-4, x_reltol=1e-4, f_abstol=2e-6, f_reltol=2e-6),
    Ω_options=(brillouinzone=BrillouinZone(vca.lattice, 100), μ=0.0, atol=1e-6, rtol=1e-6, maxevals=10^6)
)

Optimize the variational cluster approximation to find the stationary point of the grand potential.

For Algorithm{<:VCA}, this delegates to the second method. For VCA, the parameters are optimized using the specified method.