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<Self, 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: FitScalar>( &self, backend: Option<&GemmBackendHandle>, gl: &TypedTensor<T>, dim: usize, ) -> Result<TypedTensor<T>, Error>

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)

The mathematical transform does not depend on the axis placement or the memory order of the arrays, but the floating-point result can: a different axis placement selects a different contraction geometry, and the GEMM backend decides how that geometry is blocked. Bitwise agreement across axis placements is not guaranteed, and conditioning or cancellation can amplify the difference (SpM-lab/sparse-ir-rs#326).

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

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

The mathematical transform does not depend on the axis placement or the memory order of the arrays, but the floating-point result can: a different axis placement selects a different contraction geometry, and the GEMM backend decides how that geometry is blocked. Bitwise agreement across axis placements is not guaranteed, and conditioning or cancellation can amplify the difference (SpM-lab/sparse-ir-rs#326).

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<Matrix<f64>, Error>

Evaluate basis functions at imaginary time points

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

Evaluate basis functions at Matsubara frequencies

fn evaluate_omega(&self, _omega: &[f64]) -> Result<Matrix<f64>, 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