Struct FiniteTempBasis 

pub struct FiniteTempBasis<K, S>
where
    K: KernelProperties + CentrosymmKernel + Clone + 'static,
    S: StatisticsType,
{ /* private fields */ }

Finite temperature basis for imaginary time/frequency Green’s functions

For a continuation kernel K from real frequencies ω ∈ [-ωmax, ωmax] to imaginary time τ ∈ [0, β], this type stores the truncated singular value expansion or IR basis:

K(τ, ω) ≈ sum(u[l](τ) * s[l] * v[l](ω) for l in 0..L)

This basis is inferred from a reduced form by appropriate scaling of the variables.

Type Parameters

• K - Kernel type implementing KernelProperties + CentrosymmKernel
• S - Statistics type (Fermionic or Bosonic)

Implementations

impl<K, S> FiniteTempBasis<K, S>

where K: KernelProperties + CentrosymmKernel + Clone + 'static, S: StatisticsType,

pub fn kernel(&self) -> &K

Get a reference to the kernel

pub fn sve_result(&self) -> &Arc<SVEResult>

Get the SVE result the basis was built from

It is not truncated to the basis size: a basis limited by max_size or epsilon keeps all singular functions of the SVE.

pub fn accuracy(&self) -> f64

Get the accuracy of the basis

pub fn beta(&self) -> f64

Get the inverse temperature β

pub fn u(&self) -> &Arc<PiecewiseLegendrePolyVector>

Get the left singular functions (u) on imaginary time axis

pub fn v(&self) -> &Arc<PiecewiseLegendrePolyVector>

Get the right singular functions (v) on real frequency axis

pub fn s(&self) -> &[f64]

Get the singular values

pub fn uhat(&self) -> &Arc<PiecewiseLegendreFTVector<S>>

Get the left singular functions on Matsubara frequency axis (uhat)

pub fn uhat_full(&self) -> &Arc<PiecewiseLegendreFTVector<S>>

Get the full uhat (before truncation)

Holds the Matsubara transforms of all singular functions of sve_result, not only of the size() basis functions; the default Matsubara sampling points use them.

pub fn wmax(&self) -> f64

Get the frequency cutoff ωmax

pub fn default_matsubara_sampling_points_i64( &self, positive_only: bool, ) -> Result<Vec<i64>, Error>

where S: 'static,

Get default Matsubara sampling points as i64 indices (for C-API)

Errors

Error::NotSupported if the basis functions have no definite parity (an SVE that is not centrosymmetric, e.g. from compute_sve_general; #183)

pub fn default_matsubara_sampling_points_i64_with_mitigate( &self, positive_only: bool, mitigate: bool, n_points: usize, ) -> Result<Vec<i64>, Error>

where S: 'static,

Get default Matsubara sampling points as i64 indices with mitigate parameter (for C-API)

Errors

Error::NotSupported if the basis functions have no definite parity (an SVE that is not centrosymmetric, e.g. from compute_sve_general; #183)

pub fn new( kernel: K, beta: f64, epsilon: Option<f64>, max_size: Option<usize>, ) -> Result<FiniteTempBasis<K, S>, Error>

Create a new FiniteTempBasis

Arguments

• kernel - Kernel implementing KernelProperties + CentrosymmKernel
• beta - Inverse temperature (β > 0)
• epsilon - Accuracy of the basis, in (0, 1). None selects the best accuracy of the working precision (about 1.6e-16).
• max_size - Maximum number of basis functions (optional). It limits the basis, not the SVE: the SVE is computed and kept in full, as in from_sve_result with an untruncated SVE. The default sampling points and accuracy of the basis use the singular functions beyond it.

Returns

A new FiniteTempBasis

Errors

• Error::InvalidParameter if beta is not positive and finite, epsilon is not in (0, 1), or max_size is Some(0). These are checked before the SVE is computed.
• The errors of compute_sve: Error::NonFiniteInput if the discretized kernel has a non-finite entry, Error::DecompositionFailed if an SVD of the SVE fails
• The errors of from_sve_result

pub fn from_sve_result( kernel: K, beta: f64, sve_result: SVEResult, epsilon: Option<f64>, max_size: Option<usize>, ) -> Result<FiniteTempBasis<K, S>, Error>

Create basis from existing SVE result

This is useful when you want to reuse the same SVE computation for both fermionic and bosonic bases.

max_size (and epsilon) truncate the basis functions and singular values only. sve_result is kept as given: the default sampling points and accuracy use its singular functions beyond the basis, so pass an untruncated SVE to get the points of SparseIR.jl.

Errors

• Error::InvalidParameter if beta is not positive and finite, epsilon is not in [0, 1) (0 keeps every singular value), max_size is Some(0), or sve_result is not an SVE on [-1, 1] × [-1, 1]
• Error::EmptyInput if sve_result has no singular functions
• The errors of SVEResult::part (for an SVEResult whose public fields break its invariants)

pub fn size(&self) -> usize

Get the size of the basis (number of basis functions)

pub fn lambda(&self) -> f64

Get the cutoff parameter Λ = β * ωmax

pub fn omega_max(&self) -> f64

Get the frequency cutoff ωmax

pub fn significance(&self) -> Vec<f64>

Get significance of each singular value (s[i] / s[0])

pub fn default_tau_sampling_points(&self) -> Result<Vec<f64>, Error>

Get default tau sampling points

Returns sampling points in imaginary time τ ∈ [-β/2, β/2].

Roots are found with symmetry exploitation (matching Python 1.x / Julia v1), then mapped to [-β/2, β/2] by folding τ_physical ∈ [0, β] around β/2.

Errors

• Error::NotSupported if the default points are not defined for this basis: its SVE has so few singular functions that the last one has no extrema (e.g. compute_sve with max_num_svals = Some(2))

pub fn default_tau_sampling_points_size_requested( &self, size_requested: usize, ) -> Result<Vec<f64>, Error>

Get default tau sampling points with a requested size

Returns sampling points in τ ∈ [-β/2, β/2].

Errors

• Error::NotSupported if the default points are not defined for this basis: its SVE has so few singular functions that the last one has no extrema (e.g. compute_sve with max_num_svals = Some(2))

pub fn default_matsubara_sampling_points( &self, positive_only: bool, ) -> Result<Vec<MatsubaraFreq<S>>, Error>

where S: 'static,

Get default Matsubara frequency sampling points

Returns sampling points as MatsubaraFreq objects: the sign changes of the first discarded Matsubara basis function (its extrema when that function is not available); bosonic sets always include n = 0.

Arguments

• positive_only - If true, returns only non-negative frequencies

Returns

Vector of Matsubara frequency sampling points

Errors

Error::NotSupported if the basis functions have no definite parity (an SVE that is not centrosymmetric, e.g. from compute_sve_general; #183)

pub fn default_omega_sampling_points(&self) -> Result<Vec<f64>, Error>

Get default omega (real frequency) sampling points

Returns sampling points on the real-frequency axis ω ∈ [-ωmax, ωmax]. These are used as pole locations for the Discrete Lehmann Representation (DLR).

The sampling points are chosen as the roots of the L-th basis function in the spectral domain (v), which provides near-optimal conditioning.

Returns

Vector of real-frequency sampling points in [-ωmax, ωmax]

Errors

• Error::NotSupported if the default points are not defined for this basis: its SVE has so few singular functions that the last one has no extrema (e.g. compute_sve with max_num_svals = Some(2))

Trait Implementations

impl<K, S> Basis<S> for FiniteTempBasis<K, S>

where K: KernelProperties + CentrosymmKernel + Clone + 'static, S: StatisticsType + 'static,

fn beta(&self) -> f64

Inverse temperature β

fn wmax(&self) -> f64

Maximum frequency ωmax

fn lambda(&self) -> f64

Kernel parameter Λ = β × ωmax

fn size(&self) -> usize

Number of basis functions

fn accuracy(&self) -> f64

Accuracy of the basis

fn significance(&self) -> Vec<f64>

Significance of each basis function

fn svals(&self) -> Vec<f64>

Get singular values (non-normalized)

fn default_tau_sampling_points(&self) -> Result<Vec<f64>, Error>

Get default tau sampling points

fn default_matsubara_sampling_points( &self, positive_only: bool, ) -> Result<Vec<MatsubaraFreq<S>>, Error>

Get default Matsubara sampling points

fn evaluate_tau(&self, tau: &[f64]) -> Result<TypedTensor<f64, Rank<2>>, Error>

Evaluate basis functions at imaginary time points

fn evaluate_matsubara( &self, freqs: &[MatsubaraFreq<S>], ) -> Result<TypedTensor<Complex<f64>, Rank<2>>, Error>

Evaluate basis functions at Matsubara frequencies

fn evaluate_omega( &self, omega: &[f64], ) -> Result<TypedTensor<f64, Rank<2>>, Error>

Evaluate spectral basis functions at real frequencies

fn default_omega_sampling_points(&self) -> Result<Vec<f64>, Error>

Get default omega (real frequency) sampling points

impl<K, S> Clone for FiniteTempBasis<K, S>

where K: Clone + KernelProperties + CentrosymmKernel + 'static, S: Clone + StatisticsType,

fn clone(&self) -> FiniteTempBasis<K, S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, S> IrBasis<S> for FiniteTempBasis<K, S>

where K: KernelProperties + CentrosymmKernel + Clone + 'static, S: StatisticsType + 'static,

type Kernel = K

Kernel type

fn kernel(&self) -> &K

The kernel the basis was built from

fn dlr_transform( &self, dlr: &DiscreteLehmannRepresentation<S>, ) -> Result<IrDlrTransform, Error>

where S: 'static,

The linear map between the coefficients of this basis and of dlr.