Struct DiscreteLehmannRepresentation 

pub struct DiscreteLehmannRepresentation<S>
where
    S: StatisticsType,
{ /* private fields */ }

Discrete Lehmann Representation (DLR)

The DLR is a variant of the IR basis based on a “sketching” of the analytic continuation kernel K. Instead of using singular value expansion, it represents Green’s functions as a linear combination of poles on the real-frequency axis:

G(iν) = Σ_i a[i] * reg[i] / (iν - ω[i])

where:

• ω[i] are pole positions on the real axis
• a[i] are expansion coefficients
• reg[i] are the kernel regularizers w(β, ω_i)

regularizers() returns w(β, ω_i): 1 for fermions and tanh(βω_i/2) for bosons with LogisticKernel, and ω_i for RegularizedBoseKernel. The DLR functions are -K(τ, ω_i) and its Fourier transform for the physical kernel K(τ, ω) = Σ_l u_l(τ) s_l v_l(ω) of the source basis.

Two constructions are available:

• independent (default): DiscreteLehmannRepresentation::new / DlrBuilder select the poles by an interpolative decomposition of the discretized logistic kernel (Kaye, Chen, Parcollet, PRB 105, 235115), without building an IR basis;
• IR-derived: DiscreteLehmannRepresentation::from_ir (trait DlrFromIr of the IR crate) uses the default real-frequency sampling points of an IR basis as poles, and from_ir_with_poles takes the poles.

Conversions to and from an IR basis are provided by IrDlrTransform; an IR-derived DLR carries one for its source basis.

Imaginary-time and Matsubara nodes for square interpolation are selected by a row interpolative decomposition and are exposed through Basis::default_tau_sampling_points and Basis::default_matsubara_sampling_points, so TauSampling::new and MatsubaraSampling::new work on a DLR.

Type Parameters

• S - Statistics type (Fermionic or Bosonic)

Implementations

impl<S> DiscreteLehmannRepresentation<S>

where S: StatisticsType,

pub fn kernel_ypower(&self) -> i32

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

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

Pole positions on the real-frequency axis, in the order they were given to from_ir_with_poles (sorted ascending when chosen by Self::new or from_ir)

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

Regularizers of the poles: regularizers[i] = w(β, poles[i]) of the kernel of the IR basis this DLR was built from (of the logistic kernel for an independent DLR)

pub fn ir_basis_size(&self) -> Option<usize>

Number of functions of the IR basis this DLR was built from: the extent of the IR axis of Self::from_ir_nd and Self::to_ir_nd. None for a DLR built independently of an IR basis.

pub fn ir_transform(&self) -> Option<&IrDlrTransform>

IR <-> DLR transform of the source basis (IR-derived DLR only).

pub fn new( beta: f64, wmax: f64, accuracy: f64, ) -> Result<DiscreteLehmannRepresentation<S>, Error>

where S: 'static,

Build a DLR independently of any IR basis (default construction).

Equivalent to DlrBuilder::new(beta, wmax).accuracy(accuracy).build(). An accuracy below about 1e-14 is beyond double-precision resolution and makes the DLR larger without making it more accurate; see DlrBuilder::DEFAULT_ACCURACY.

Errors

See DlrBuilder::build.

pub fn from_ir_nd<T>( &self, backend: Option<&GemmBackendHandle>, gl: &TypedTensor<T>, dim: usize, ) -> Result<TypedTensor<T>, Error>

where T: FitScalar,

Convert IR coefficients to DLR (N-dimensional, generic over real/complex)

Type Parameters

• T - Element type (f64 or Complex<f64>)

Arguments

• gl - IR coefficients as N-D tensor
• dim - Dimension along which to transform

Returns

DLR coefficients as N-D tensor, with Basis::size (the number of poles) entries along dim. An empty batch (a zero extent on another axis) gives an empty result.

Errors

• Error::AxisOutOfRange if dim is not an axis of gl
• Error::ShapeMismatch of the input if gl does not have Self::ir_basis_size entries along dim
• Error::DecompositionFailed if the SVD of the fitting matrix fails (its entries are finite, since the poles are)

pub fn to_ir_nd<T>( &self, backend: Option<&GemmBackendHandle>, g_dlr: &TypedTensor<T>, dim: usize, ) -> Result<TypedTensor<T>, Error>

where T: FitScalar,

Convert DLR coefficients to IR (N-dimensional, generic over real/complex)

Type Parameters

• T - Element type (f64 or Complex<f64>)

Arguments

• g_dlr - DLR coefficients as N-D tensor
• dim - Dimension along which to transform

Returns

IR coefficients as N-D tensor, with Self::ir_basis_size entries along dim. An empty batch gives an empty result.

Errors

• Error::AxisOutOfRange if dim is not an axis of g_dlr
• Error::ShapeMismatch of the input if g_dlr does not have Basis::size (the number of poles) entries along dim

impl<S> DiscreteLehmannRepresentation<S>

where S: StatisticsType + 'static,

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

Imaginary-time interpolation nodes (sorted), one per pole.

pub fn matsubara_nodes(&self, positive_only: bool) -> &[i64]

Matsubara interpolation nodes as indices n (ν = nπ/β, sorted).

With positive_only, nodes are chosen among n >= 0 so that the stacked real and imaginary parts determine the coefficients of a Green’s function with G(-iν) = conj(G(iν)).

Trait Implementations

impl<S> Basis<S> for DiscreteLehmannRepresentation<S>

where 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<S> DlrFromIr<S> for DiscreteLehmannRepresentation<S>

where S: StatisticsType + 'static,

fn from_ir_with_poles<B>( basis: &B, poles: Vec<f64>, ) -> Result<DiscreteLehmannRepresentation<S>, Error>

where B: IrBasis<S>,

Create a DLR from an IR basis with custom poles

fn from_ir<B>(basis: &B) -> Result<DiscreteLehmannRepresentation<S>, Error>

where B: IrBasis<S>,

Create a DLR from an IR basis with its default pole locations