mini-pole 0.2__py3-none-any.whl

mini_pole/__init__.py

@@ -0,0 +1,5 @@
+from .con_map import *
+from .esprit import *
+from .green_func import *
+from .mini_pole_dlr import *
+from .mini_pole import *

mini_pole/con_map.py

@@ -0,0 +1,167 @@
+import numpy as np
+
+class ConMapGeneric:
+    '''
+    Generic holomorphic mapping which works for any cases.
+    '''
+    def __init__(self, w_m, dw_h, branch_in = True):
+        '''
+        Initialize the class with w_m and dw_h, which correspond to $\omega_{\rm m}$ and $\Delta \omega_{\rm h}$ in the paper, respectively.
+        Points in the z plane are mapped to the inside (outside) of the unit disk in the w plane when branch_in is True (False).
+        '''
+        assert dw_h.real > 0.0 and dw_h.imag == 0.0
+        self.w_m = w_m
+        self.dw_h = dw_h
+        self.branch_in = branch_in
+        self.w_inf = [0.0]
+    
+    def cal_z(self, w):
+        '''
+        Intermediate function of z(w) which only works for a single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (w - 1.0 / w) + 1j * self.w_m
+    
+    def cal_w(self, z):
+        '''
+        Intermediate function of w(z) which only works for a single point.
+        '''
+        x = (z - 1j * self.w_m) / self.dw_h
+        w = x - np.sqrt(x ** 2.0 + 1.0)
+        if self.branch_in:
+            if np.absolute(w) > 1.0:
+                w = 2.0 * x - w
+        else:
+            if np.absolute(w) < 1.0:
+                w = 2.0 * x - w
+        return w
+    
+    def cal_dz(self, w):
+        '''
+        Intermediate function of dz(w) which only works for single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (1.0 + 1.0 / w ** 2.0)
+    
+    def z(self, w):
+        '''
+        Calculate z from w.
+        '''
+        return np.vectorize(self.cal_z)(w)
+    
+    def w(self, z):
+        '''
+        Calculate w from z.
+        '''
+        return np.vectorize(self.cal_w)(z)
+    
+    def dz(self, w):
+        '''
+        Calculate dz/dw at value w.
+        '''
+        return np.vectorize(self.cal_dz)(w)
+
+class ConMapGapless:
+    '''
+    conformal mapping which works for both gapless and gapped cases
+    '''
+    def __init__(self, w_min):
+        assert w_min > 0.0
+        self.w_min = w_min
+        self.w_inf = [-1.0, 1.0]
+    
+    def cal_z(self, w):
+        assert np.abs(w) < 1.0 + 1.e-15
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 2.0 * self.w_min * w / (1.0 - w * w)
+    
+    def cal_w(self, z):
+        if z == 0.0:
+            w = 0.0
+        else:
+            w = self.w_min * (np.sqrt(1.0 / (z * z) + 1.0 / (self.w_min * self.w_min)) - 1.0 / z)
+            if np.absolute(w) > 1.0:
+                w = -w - 2.0 * self.w_min / z
+        return w
+    
+    def cal_dz(self, w):
+        assert np.abs(w) < 1.0 + 1.e-15
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 2.0 * self.w_min * (1.0 + w ** 2) / (1.0 - w ** 2) ** 2
+    
+    def z(self, w):
+        return np.vectorize(self.cal_z)(w)
+    
+    def w(self, z):
+        return np.vectorize(self.cal_w)(z)
+    
+    def dz(self, w):
+        return np.vectorize(self.cal_dz)(w)
+
+class ConMapRet:
+    '''
+    Holomorphic mapping for the retarded Green's function.
+    '''
+    def __init__(self, w_m, dw_h):
+        '''
+        Initialize the class with w_m and dw_h.
+        Points in the z plane are mapped to the inside of the unit disk in the w plane.
+        '''
+        assert dw_h.real > 0.0 and dw_h.imag == 0.0
+        self.w_m = w_m
+        self.dw_h = dw_h
+        self.w_inf = [0.0]
+    
+    def cal_z(self, w):
+        '''
+        Intermediate function of z(w) which only works for a single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (w + 1.0 / w) + self.w_m
+    
+    def cal_w(self, z):
+        '''
+        Intermediate function of w(z) which only works for a single point.
+        '''
+        x = (z - self.w_m) / self.dw_h
+        w = x + np.sqrt(x ** 2.0 - 1.0 + 0j)
+        if np.absolute(w) > 1.0:
+            w = 2.0 * x - w
+        return w
+    
+    def cal_dz(self, w):
+        '''
+        Intermediate function of dz(w) which only works for single point.
+        '''
+        if w in self.w_inf:
+            return np.inf
+        else:
+            return 0.5 * self.dw_h * (1.0 - 1.0 / w ** 2.0)
+    
+    def z(self, w):
+        '''
+        Calculate z from w.
+        '''
+        return np.vectorize(self.cal_z)(w)
+    
+    def w(self, z):
+        '''
+        Calculate w from z.
+        '''
+        return np.vectorize(self.cal_w)(z)
+    
+    def dz(self, w):
+        '''
+        Calculate dz/dw at value w.
+        '''
+        return np.vectorize(self.cal_dz)(w)

mini_pole/esprit.py

@@ -0,0 +1,160 @@
+import numpy as np
+import warnings
+
+class ESPRIT:
+    '''
+    Matrix version of the ESPRIT method for approximating functions with complex exponentials.
+    '''
+    def __init__(self, h_k, x_min = 0, x_max = 1, err = None, err_type = "abs", M = None, Lfactor = 0.4, tol = 1.e-15, ctrl_ratio = 10):
+        '''
+        Initialize with function values sampled on a uniform grid from x_min to x_max.
+        '''
+        h_k = h_k.reshape(h_k.shape[0], -1)
+        self.N = h_k.shape[0]
+        self.dim = h_k.shape[1]
+        if Lfactor < 1.0 / 3.0 or Lfactor > 0.5:
+            warnings.warn("It is suggested to set 1 / 3 <= Lfactor <= 1 / 2.")
+        self.L = int(Lfactor * (self.N - 1))
+        assert (self.N - self.L) >= (self.L + 1)
+        assert x_min < x_max
+        assert err_type in ["abs", "rel"]
+        
+        if np.max(np.abs(h_k.imag)) < tol:
+            self.type = "real"
+            self.h_k = np.array(h_k.real)
+        elif np.max(np.abs(h_k.real)) < tol:
+            self.type = "imag"
+            self.h_k = np.array(1j * h_k.imag)
+        else:
+            self.type = "cplx"
+            self.h_k = np.array(h_k)
+        self.x_min = x_min
+        self.x_max = x_max
+        self.x_k = np.linspace(self.x_min, self.x_max, self.N)
+        self.err = err
+        self.err_type = err_type
+        self.M = M
+        self.tol = tol
+        
+        #note to set data type to be complex even if the input is real! Otherwise the result might be unstable!
+        self.H = np.zeros((self.dim * (self.N - self.L), self.L + 1), dtype=np.complex_)
+        for l in range(self.N - self.L):
+            self.H[(self.dim * l):(self.dim * (l + 1)), :] = self.h_k[l:(l + self.L + 1)].T
+        
+        #there is a very low chance that SVD does not converge
+        while True:
+            try:
+                _, self.S, self.W = np.linalg.svd(self.H, full_matrices=False)
+                break
+            except:
+                self.H = self.H[:, :-1]
+        
+        if self.M is None:
+            self.find_M_with_err() if self.err is not None else self.find_M_with_exp_decay()
+        else:
+            self.M = min(self.M, self.S.size - 1)
+        while True:
+            self.sigma = self.S[self.M]
+            self.W_0 = self.W[:self.M, :-1]
+            self.W_1 = self.W[:self.M, 1:]
+            self.F_M = np.linalg.pinv(self.W_0.T) @ self.W_1.T
+            
+            self.gamma = np.linalg.eigvals(self.F_M)
+            self.find_omega()
+            self.cal_err()
+            
+            if self.err_max < max(ctrl_ratio * self.sigma, 1.e-14 * self.S[0]):
+                break
+            else:
+                self.M -= 1
+            if self.M == 0:
+                raise Exception("Could not find controlled approximation!")
+    
+    def find_M_with_err(self):
+        '''
+        Find the rank M for the given error tolerance.
+        '''
+        cutoff = self.err if self.err_type == "abs" else self.S[0] * self.err
+        for idx in range(self.S.size):
+            if self.S[idx] < cutoff:
+                break
+        if self.S[idx] >= cutoff:
+            print("err is set to be too small!")
+        self.M = idx
+    
+    '''
+    def find_M_with_exp_decay(self):
+        ''
+        Find the maximum index for the exponentially decaying region.
+        ''
+        log_S = -np.log(self.S)
+        dS = log_S[1] - log_S[0]
+        self.M = np.where((np.diff(log_S) < 0.2 * dS) == True)[0][0]
+    '''
+    
+    def find_M_with_exp_decay(self):
+        '''
+        Find the maximum index for the exponentially decaying region.
+        '''
+        n_max = min(3 * int(np.log(1.e12)), int(0.8 * self.S.size))
+        idx_fit = np.arange(int(0.5 * n_max), n_max)
+        val_fit = self.S[idx_fit]
+        
+        A = np.vstack((idx_fit, np.ones_like(idx_fit))).T
+        a, b = np.linalg.pinv(A) @ np.log(val_fit)
+        self.S_approx = np.exp(a * np.arange(n_max) + b)
+        self.M = sum(self.S[:n_max] > 3.0 * self.S_approx) + 1
+    
+    def find_omega(self):
+        '''
+        Find weights of corresponding nodes gamma.
+        '''
+        V = np.zeros((self.h_k.shape[0], self.M), dtype=np.complex_)
+        for i in range(V.shape[0]):
+            V[i, :] = self.gamma ** i
+        #using least-squares solution is more stable than using pseudo-inverse
+        #setting rcond=None (default) sometimes leads to incorrect result for high-precision input
+        self.omega, residuals, rank, s = np.linalg.lstsq(V, self.h_k, rcond=-1)
+        self.lstsq_quality = (residuals, rank, s)
+    
+    def cal_err(self):
+        h_k_approx = self.get_value(self.x_k)
+        self.err_max = np.abs(h_k_approx - self.h_k).max(axis=0).max()
+        self.err_ave = np.abs(h_k_approx - self.h_k).mean(axis=0).max()
+    
+    def get_value_indiv(self, x, col):
+        '''
+        Get the approximated function value at point x for column col.
+        '''
+        assert col >= 0 and col < self.dim
+        x0 = (x - self.x_min) / (self.x_max - self.x_min)
+        if np.any(x0 < -1.e-12) or np.any(x0 > 1.0 + 1.e-12):
+            raise Exception("This approximation only has error control for x in [x_min, x_max]!")
+        
+        if np.isscalar(x0):
+            V = self.gamma ** ((self.h_k.shape[0] - 1) * x0)
+            value = np.dot(V, self.omega[:, col])
+        else:
+            V = np.zeros((x0.size, self.gamma.size), dtype=np.complex_)
+            for i in range(V.shape[0]):
+                V[i, :] = self.gamma ** ((self.h_k.shape[0] - 1) * x0[i])
+            value = np.dot(V, self.omega[:, col])
+        return value if self.type == "cplx" else value.real if self.type == "real" else 1j * value.imag
+    
+    def get_value(self, x):
+        '''
+        Get the approximated function value at point x.
+        '''
+        x0 = (x - self.x_min) / (self.x_max - self.x_min)
+        if np.any(x0 < -1.e-12) or np.any(x0 > 1.0 + 1.e-12):
+            raise Exception("This approximation only has error control for x in [x_min, x_max]!")
+        
+        if np.isscalar(x0):
+            V = self.gamma ** ((self.h_k.shape[0] - 1) * x0)
+            value = np.dot(V, self.omega)
+        else:
+            V = np.zeros((x0.size, self.gamma.size), dtype=np.complex_)
+            for i in range(V.shape[0]):
+                V[i, :] = self.gamma ** ((self.h_k.shape[0] - 1) * x0[i])
+            value = np.dot(V, self.omega)
+        return value if self.type == "cplx" else value.real if self.type == "real" else 1j * value.imag

mini_pole/green_func.py

@@ -0,0 +1,101 @@
+import numpy as np
+import scipy.integrate as integrate
+
+class GreenFunc:
+    '''
+    Green's function class which works for both discrete and continuous cases.
+    '''
+    def __init__(self, statistics, beta, flag = "discrete", A_i = None, x_i = None, A_x = None, x_min = -10, x_max = 10, tol = 0.01):
+        '''
+        Meaning of each parameter:
+        1. statistics stands for the statistics of the system, which is either "F" (for fermions) or "B" (for bosons);
+        2. beta is the inverse temperature in Hartree atomic units;
+        3. flag is "discrete" for discrete cases (with delta peaks) or "continuous" for continuous cases (with broadened peaks);
+        4. For discrete cases, an array of pole weights A_i and pole locations x_i should be provided,
+           while for continuous cases, the function form A_x should be provided, along with non-zero range. 
+           If A_x is non-zero everywhere, x_min should be -np.inf and x_max should be np.inf.
+        5. tol is the value to distinguish delta peaks and broadened peaks for discrete cases, according to the imaginary part of pole locations.
+        '''
+        assert statistics.upper() in ["F", "B"]
+        assert flag.lower() in ["discrete", "continuous"]
+        
+        self.statistics = statistics.upper()
+        self.beta = beta
+        self.flag = flag.lower()
+        if self.flag == "discrete":
+            assert A_i is not None and x_i is not None
+            assert A_i.size == x_i.size
+            #pole locations and weights can both be complex-valued
+            self.A_i = A_i
+            if np.max(np.abs(x_i.imag)) < 1.e-15:
+                self.x_i = x_i.real
+            else:
+                self.x_i = x_i
+            self.tol = tol
+        else:
+            #A_x(x) is a continuous function of x
+            assert A_x is not None
+            self.A_x = A_x
+            self.x_min = x_min
+            self.x_max = x_max
+    
+    def get_matsubara(self, N_up = 1000, lower = False):
+        '''
+        Calculate the Matsubara data. 
+        N_up is the number of non-negative frequencies. 
+        lower controls whether data on negative frequencies is calculated or not.
+        '''
+        if self.statistics == "F":
+            if lower is False:
+                n_sample = np.arange(N_up)
+            else:
+                n_sample = np.arange(-N_up, N_up)
+            self.w = (2 * n_sample + 1) * np.pi / self.beta
+        else:
+            if lower is False:
+                n_sample = np.arange(N_up)
+            else:
+                n_sample = np.arange(-(N_up - 1), N_up)
+            self.w = 2 * n_sample * np.pi / self.beta
+        
+        self.N_tot = self.w.size
+        self.w_min = self.w[0]
+        self.w_max = self.w[-1]
+        self.G_w   = self.get_G(1j * self.w)
+    
+    def cal_G(self, z, err=1.e-13):
+        '''
+        Calculate G(z) at point z. err is the accuracy of the integration we want to achieve.
+        If err is chosen to be too small, there will be some warnings.
+        '''
+        if self.flag == "discrete":
+            G_z = 0.0
+            for i in range(self.x_i.size):
+                G_z += self.A_i[i] / (z - self.x_i[i])
+        else:
+            G_z = integrate.quad(lambda x: self.A_x(x) * (1.0 / (z - x)).real, self.x_min, self.x_max, epsabs=err, epsrel=err, limit=10000)[0] \
+           + 1j * integrate.quad(lambda x: self.A_x(x) * (1.0 / (z - x)).imag, self.x_min, self.x_max, epsabs=err, epsrel=err, limit=10000)[0]
+
+        return G_z
+    
+    def get_G(self, z, err=1.e-13):
+        '''
+        Vectorized version of G(z) which can deal with an array.
+        '''
+        return np.vectorize(lambda x: self.cal_G(x, err))(z)
+
+    def get_spectral(self, x, epsilon = 0.01):
+        '''
+        epsilon is the broadening parameter for delta peaks.
+        '''
+        if self.flag == "discrete":
+            A_w = 0.0
+            for i in range(self.x_i.size):
+                if np.abs(self.x_i[i].imag) < self.tol:
+                    A_w += (1.0 / np.pi) * self.A_i[i].real * np.abs(epsilon) / ((x - self.x_i[i].real)**2.0 + epsilon**2.0)
+                else:
+                    A_w += -1.0 / np.pi * (self.A_i[i] / (x - self.x_i[i])).imag
+        else:
+            A_w = np.vectorize(self.A_x)(x)
+        
+        return A_w

mini_pole/mini_pole.py

@@ -0,0 +1,420 @@
+import numpy as np
+import scipy.integrate as integrate
+from .esprit import ESPRIT
+from .con_map import ConMapGeneric, ConMapGapless
+from .green_func import GreenFunc
+
+class MiniPole:
+    def __init__(self, G_w, w, n0 = "auto", n0_shift = 0, err = None, err_type = "abs", M = None, symmetry = False, G_symmetric = False, compute_const = False, plane = None, include_n0 = False, k_max = 999, ratio_max = 10):
+        '''
+        A Python program for obtaining the matrix-valued minimal pole representation.
+
+        Parameters
+        ----------
+        G_w : ndarray
+            An (n_w, n_orb, n_orb) or (n_w,) array containing the Matsubara data.
+        w : ndarray
+            An (n_w,) array containing the corresponding real-valued Matsubara grid.
+        n0 : int or str, default="auto"
+            If "auto", n0 is automatically selected with an additional shift specified by n0_shift.
+            If a non-negative integer is provided, n0 is fixed at that value.
+        n0_shift : int, default=0
+            The shift applied to the automatically determined n0.
+        err : float
+            Error tolerance for calculations.
+        err_type : str, default="abs"
+            Specifies the type of error: "abs" for absolute error or "rel" for relative error.
+        M : int, optional
+            The number of poles in the final result. If not specified, the precision from the first ESPRIT is used to extract poles in the second ESPRIT.
+        symmetry : bool, default=False
+            Determines whether to preserve up-down symmetry.
+        G_symmetric : bool, default=False
+            If True, the Matsubara data will be symmetrized such that G_{ij}(z) = G_{ji}(z).
+        compute_const : bool, default=False
+            Determines whether to compute the constant term in G(z) = sum_l Al / (z - xl) + const.
+            If False, the constant term is fixed at 0.
+        plane : str, optional
+            Specifies whether to use the original z-plane or the mapped w-plane to compute pole weights.
+        include_n0 : bool, default=True
+            Determines whether to include the first n0 input points when weights are calculated in the z-plane.
+        k_max : int, default=999
+            The maximum number of contour integrals.
+        ratio_max : float, default=10
+            The maximum ratio of oscillation when automatically choosing n0.
+        
+        Returns
+        -------
+        Minimal pole representation of the given data.
+        Pole weights are stored in `self.pole_weight', a numpy array of shape (M, n_orb, n_orb).
+        Shared pole locations are stored in `self.pole_location', a numpy array of shape (M,).
+        '''
+        if G_w.ndim == 1:
+            G_w = G_w.reshape(-1, 1, 1)
+        assert G_w.ndim == 3
+        assert G_w.shape[0] == w.size and G_w.shape[1] == G_w.shape[2]
+        assert w[0] >= 0.0
+        assert np.linalg.norm(np.diff(np.diff(w)), ord=np.inf) < 1.e-10
+        
+        self.n_w = w.size
+        self.n_orb = G_w.shape[1]
+        if G_symmetric is True:
+            self.G_w = 0.5 * (G_w + np.transpose(G_w, axes=(0, 2, 1)))
+        else:
+            self.G_w = G_w
+        self.w = w
+        self.G_symmetric = G_symmetric
+        self.err = err
+        self.err_type = err_type
+        self.M = M
+        self.symmetry = symmetry
+        if symmetry is True and compute_const == True:
+            raise Exception("Set symmetry to be False to calculate the overall constant!")
+        self.compute_const = compute_const
+        if plane is not None:
+            self.plane = plane
+        elif self.symmetry is False:
+            self.plane = "z"
+        else:
+            self.plane = "w"
+        assert self.plane in ["z", "w"]
+        self.include_n0 = include_n0
+        self.k_max = k_max
+        self.ratio_max = ratio_max
+        
+        #perform the first ESPRIT approximation to approximate Matsubara data
+        G_w_vector = self.G_w.reshape(-1, self.n_orb ** 2)
+        self.p_o = [ESPRIT(G_w_vector[:, i], self.w[0], self.w[-1], err=self.err, err_type=self.err_type, Lfactor=0.4) for i in range(self.n_orb ** 2)]
+        self.G_approx = [lambda x, idx=i: self.p_o[idx].get_value(x) for i in range(self.n_orb ** 2)]
+        idx_sigma = np.argmax([self.p_o[i].sigma for i in range(self.n_orb ** 2)])
+        self.S = self.p_o[idx_sigma].S
+        self.sigma   = self.p_o[idx_sigma].sigma
+        if n0 == "auto":
+            assert isinstance(n0_shift, int) and n0_shift >= 0
+            p_o2 = [ESPRIT(G_w_vector[:, i], self.w[0], self.w[-1], err=self.err, err_type=self.err_type, Lfactor=0.5) for i in range(self.n_orb ** 2)]
+            w_cont = np.linspace(self.w[0], self.w[-1], 10 * self.w.size - 9)
+            G_L1 = [self.p_o[i].get_value(w_cont)[:-1].reshape(self.w.size - 1, 10) for i in range(self.n_orb ** 2)]
+            G_L2 = [    p_o2[i].get_value(w_cont)[:-1].reshape(self.w.size - 1, 10) for i in range(self.n_orb ** 2)]
+            self.err_max = max(max([self.p_o[i].err_max for i in range(self.n_orb ** 2)]), max([p_o2[i].err_max for i in range(self.n_orb ** 2)]))
+            G_L_diff = [np.abs(G_L2[i] - G_L1[i]).max(axis=1) for i in range(self.n_orb ** 2)]
+            ctrl_interval = [np.logical_and(G_L_diff[i][:-1] <= self.err_max, G_L_diff[i][0:-1] / G_L_diff[i][1:] < ratio_max) for i in range(self.n_orb ** 2)]
+            self.n0 = max([np.argmax(ctrl_interval[i]) for i in range(self.n_orb ** 2)]) + n0_shift
+        else:
+            assert isinstance(n0, int) and n0 >= 0
+            self.err_max = max([self.p_o[i].err_max for i in range(self.n_orb ** 2)])
+            self.n0 = n0
+        
+        if self.symmetry is False:
+            #get the corresponding conformal mapping
+            w_m = 0.5 * (self.w[self.n0] + self.w[-1])
+            dw_h = 0.5 * (self.w[-1] - self.w[self.n0])
+            self.con_map = ConMapGeneric(w_m, dw_h)
+            #calculate contour integrals
+            self.cal_hk_generic(self.G_approx, k_max)
+        else:
+            #use complex poles to approximate Matsubara data in [1j * w[-1], +inf)
+            p = MiniPole(G_w, w, n0=n0, n0_shift=n0_shift, err=err, err_type=err_type, G_symmetric=G_symmetric, compute_const=compute_const, include_n0=False, k_max=k_max, ratio_max=ratio_max)
+            self.G_approx_tail = [lambda x, Al=p.pole_weight.reshape(-1, self.n_orb ** 2)[:, i], xl=p.pole_location: self.cal_G_scalar(1j * x, Al, xl) for i in range(self.n_orb ** 2)]
+            self.const = p.const
+            #get the corresponding conformal mapping
+            self.con_map = ConMapGapless(self.w[self.n0])
+            #calculate contour integrals
+            if G_symmetric is True:
+                self.cal_hk_gapless_symmetric(self.G_approx, self.G_approx_tail, k_max)
+            else:
+                self.cal_hk_gapless(self.G_approx, self.G_approx_tail, k_max)
+        
+        #apply the second ESPRIT approximation to recover poles
+        self.find_poles()
+    
+    def cal_hk_generic(self, G_approx, k_max = 999):
+        '''
+        Calculate the contour integrals.
+        '''
+        cutoff = self.err_max
+        err = 0.01 * cutoff
+        
+        self.h_k = np.zeros((k_max, len(G_approx)), dtype=np.complex_)
+        for k in range(self.h_k.shape[0]):
+            for i in range(self.h_k.shape[1]):
+                self.h_k[k, i] = self.cal_hk_generic_indiv(G_approx[i], k, err)
+            if k >= 1:
+                cutoff_matrix = np.logical_and(np.abs(self.h_k[k]) < cutoff, np.abs(self.h_k[k - 1]) < cutoff)
+                if np.all(cutoff_matrix):
+                    break
+        self.h_k = self.h_k[:(k + 1)]
+    
+    def cal_hk_generic_indiv(self, G_approx, k, err):
+        if k % 2 == 0:
+            return (1.0j / np.pi) * integrate.quad(lambda x: G_approx(self.con_map.w_m + self.con_map.dw_h * np.sin(x)), -0.5 * np.pi, 0.5 * np.pi, weight="sin", wvar=k + 1, complex_func=True, epsabs=err, epsrel=err, limit=10000)[0]
+        else:
+            return (1.0  / np.pi) * integrate.quad(lambda x: G_approx(self.con_map.w_m + self.con_map.dw_h * np.sin(x)), -0.5 * np.pi, 0.5 * np.pi, weight="cos", wvar=k + 1, complex_func=True, epsabs=err, epsrel=err, limit=10000)[0]
+    
+    def cal_hk_gapless_symmetric(self, G_approx_head, G_approx_tail, k_max = 999):
+        '''
+        Calculate the contour integrals.
+        '''
+        cutoff = self.err_max
+        err = 0.01 * cutoff
+        
+        theta0 = np.arcsin(self.con_map.w_min / self.w[-1])
+        self.h_k = np.zeros((k_max, len(G_approx_head)), dtype=np.float_)
+        for k in range(self.h_k.shape[0]):
+            for i in range(self.h_k.shape[1]):
+                    self.h_k[k, i] = self.cal_hk_gapless_symmetric_indiv(G_approx_head[i], k, err, theta0 + 1.e-12, 0.5 * np.pi) + \
+                                     self.cal_hk_gapless_symmetric_indiv(G_approx_tail[i], k, err, 1.e-6, theta0 - 1.e-12)
+            if k >= 1:
+                cutoff_matrix = np.logical_and(np.abs(self.h_k[k]) < cutoff, np.abs(self.h_k[k - 1]) < cutoff)
+                if np.all(cutoff_matrix):
+                    break
+        self.h_k = self.h_k[:(k + 1)]
+    
+    def cal_hk_gapless_symmetric_indiv(self, G_approx, k, err, theta_min, theta_max):
+        if k % 2 == 0:
+            return (-2.0 / np.pi) * integrate.quad(lambda x: G_approx(self.con_map.w_min / np.sin(x)).imag, theta_min, theta_max, weight="sin", wvar=k + 1, epsabs=err, epsrel=err, limit=10000)[0]
+        else:
+            return (+2.0 / np.pi) * integrate.quad(lambda x: G_approx(self.con_map.w_min / np.sin(x)).real, theta_min, theta_max, weight="cos", wvar=k + 1, epsabs=err, epsrel=err, limit=10000)[0]
+    
+    def cal_hk_gapless(self, G_approx_head, G_approx_tail, k_max = 999):
+        '''
+        Calculate the contour integrals.
+        '''
+        cutoff = self.err_max
+        err = 0.01 * cutoff
+        
+        theta0 = np.arcsin(self.con_map.w_min / self.w[-1])
+        self.h_k = np.zeros((k_max, len(G_approx_head)), dtype=np.complex_)
+        for k in range(self.h_k.shape[0]):
+            for i in range(self.n_orb):
+                for j in range(i, self.n_orb):
+                    if i == j:
+                        idx = i * self.n_orb + j
+                        self.h_k[k, idx] = self.cal_hk_gapless_symmetric_indiv(G_approx_head[idx], k, err, theta0 + 1.e-12, 0.5 * np.pi) + \
+                                           self.cal_hk_gapless_symmetric_indiv(G_approx_tail[idx], k, err, 1.e-6, theta0 - 1.e-12)
+                    else:
+                        idx1 = i * self.n_orb + j
+                        idx2 = j * self.n_orb + i
+                        h1 = self.cal_hk_gapless_indiv(G_approx_head[idx1], k, err, theta0 + 1.e-12, 0.5 * np.pi) + \
+                             self.cal_hk_gapless_indiv(G_approx_tail[idx1], k, err, 1.e-6, theta0 - 1.e-12)
+                        h2 = self.cal_hk_gapless_indiv(G_approx_head[idx2], k, err, theta0 + 1.e-12, 0.5 * np.pi) + \
+                             self.cal_hk_gapless_indiv(G_approx_tail[idx2], k, err, 1.e-6, theta0 - 1.e-12)
+                        if k % 2 == 0:
+                            self.h_k[k, idx1] = 1.0j / np.pi * (h1 - np.conjugate(h2))
+                            self.h_k[k, idx2] = 1.0j / np.pi * (h2 - np.conjugate(h1))
+                        else:
+                            self.h_k[k, idx1] = 1.0 / np.pi * (h1 + np.conjugate(h2))
+                            self.h_k[k, idx2] = 1.0 / np.pi * (h2 + np.conjugate(h1))
+            if k >= 1:
+                cutoff_matrix = np.logical_and(np.abs(self.h_k[k]) < cutoff, np.abs(self.h_k[k - 1]) < cutoff)
+                if np.all(cutoff_matrix):
+                    break
+        self.h_k = self.h_k[:(k + 1)]
+    
+    def cal_hk_gapless_indiv(self, G_approx, k, err, theta_min, theta_max):
+        if k % 2 == 0:
+            return integrate.quad(lambda x: G_approx(self.con_map.w_min / np.sin(x)), theta_min, theta_max, weight="sin", wvar=k + 1, complex_func=True, epsabs=err, epsrel=err, limit=10000)[0]
+        else:
+            return integrate.quad(lambda x: G_approx(self.con_map.w_min / np.sin(x)), theta_min, theta_max, weight="cos", wvar=k + 1, complex_func=True, epsabs=err, epsrel=err, limit=10000)[0]
+    
+    def find_poles(self):
+        '''
+        Recover poles from contour integrals h_k.
+        '''
+        #apply the second ESPRIT
+        if self.M is None:
+            self.p_f = ESPRIT(self.h_k, err=self.err_max)
+        else:
+            self.p_f = ESPRIT(self.h_k, M=self.M)
+        
+        #make sure all mapped poles are inside the unit disk
+        idx0 = np.abs(self.p_f.gamma) < 1.0
+        #tranform poles from w-plane to z-plane
+        location = self.con_map.z(self.p_f.gamma[idx0])
+        weight = self.p_f.omega[idx0] * self.con_map.dz(self.p_f.gamma[idx0]).reshape(-1, 1)
+        
+        if self.compute_const is False:
+            self.const = 0.0
+        else:
+            G_w_approx = self.cal_G_vector(1j * self.w[self.n0:], weight, location)
+            const = (self.G_w[self.n0:] - G_w_approx.reshape(-1, self.n_orb, self.n_orb)).mean(axis=0)
+            self.const = const if np.abs(const).max() > 100.0 * self.err_max else 0.0
+        
+        if self.plane == "z":
+            w_tmp   = self.w   if self.include_n0 else self.w[self.n0:]
+            G_w_tmp = self.G_w if self.include_n0 else self.G_w[self.n0:]
+            if self.symmetry is False:
+                w = w_tmp
+                G_w = G_w_tmp
+            else:
+                w = np.hstack((-w_tmp[::-1], w_tmp))
+                G_w = np.concatenate((np.conjugate(np.transpose(G_w_tmp, axes=(0, 2, 1)))[::-1], G_w_tmp), axis=0)
+            A = np.zeros((w.size, location.size), dtype=np.complex_)
+            for i in range(location.size):
+                A[:, i] = 1.0 / (1j * w - location[i])
+            weight, residuals, rank, s = np.linalg.lstsq(A, (G_w - self.const).reshape(-1, self.n_orb ** 2), rcond=-1)
+            self.lstsq_quality = (residuals, rank, s)
+        
+        #discard poles with negligible weights
+        idx1 = np.abs(weight).max(axis=1) > self.err_max
+        weight   = weight[idx1]
+        location = location[idx1]
+        
+        #rearrange poles so that \xi_1.real <= \xi_2.real <= ... <= \xi_M.real
+        idx2 = np.argsort(location.real)
+        self.pole_weight   = weight[idx2].reshape(-1, self.n_orb, self.n_orb)
+        self.pole_location = location[idx2]
+    
+    @staticmethod
+    def cal_G_scalar(z, Al, xl):
+        G_z = 0.0
+        for i in range(xl.size):
+            G_z += Al[i] / (z - xl[i])
+        return G_z
+    
+    @staticmethod
+    def cal_G_vector(z, Al, xl):
+        G_z = 0.0
+        for i in range(xl.size):
+            G_z += Al[[i]] / (z.reshape(-1, 1) - xl[i])
+        return G_z
+    
+    def plot_spectrum(self, orb_list = None, w_min = -10, w_max = 10, epsilon = 0.01):
+        import matplotlib.pyplot as plt
+        
+        w = np.linspace(w_min, w_max, 10000)
+        if orb_list is None:
+            orb_list = [(i, j) for i in range(self.n_orb) for j in range(self.n_orb)]
+        #dynamically generate colors, line styles, and markers based on the number of curves
+        num_curves = len(orb_list)
+        line_styles = ['-', '-.', ':', '--'] * (num_curves // 4 + 1)
+        plt.figure()
+        for idx, orb in enumerate(orb_list):
+            i, j = orb
+            gf = GreenFunc('F', 1.0, "discrete", A_i=self.pole_weight[:, i, j], x_i=self.pole_location)
+            A_r = gf.get_spectral(w, epsilon=epsilon)
+            plt.plot(w, A_r, linestyle=line_styles[idx], label="element (" + str(i) + ", " + str(j) + ")")
+        if self.h_k.shape[1] <= 16:
+            plt.legend()
+        plt.xlabel(r"$\omega$")
+        plt.ylabel(r"$A(\omega)$")
+        plt.show()
+    
+    def check_valid(self):
+        import matplotlib.pyplot as plt
+        #dynamically generate colors, line styles, and markers based on the number of curves
+        num_curves = self.n_orb ** 2
+        line_styles = ['-', '-.', ':', '--'] * (num_curves // 4 + 1)
+        
+        #check svd of the input data
+        plt.figure()
+        plt.semilogy(self.S, ".")
+        plt.semilogy([0, self.S.size - 1], [self.sigma, self.sigma], color="gray", linestyle="--", label="singular value")
+        plt.semilogy([0, self.S.size - 1], [self.err_max, self.err_max], color="k", label="precision")
+        plt.legend()
+        plt.xlabel(r"$n$")
+        plt.ylabel(r"$\sigma_n$")
+        plt.title("SVD of the input data")
+        plt.show()
+        
+        #check the first approximation
+        plt.figure()
+        for i in range(self.n_orb ** 2):
+            row, col = i // self.n_orb, i % self.n_orb
+            G_w1 = self.G_approx[i](self.w) if self.symmetry is False else self.G_approx[i](self.w) + (self.const + np.zeros((self.n_orb, self.n_orb))).reshape(-1)[i]
+            plt.semilogy(self.w, np.abs(np.squeeze(G_w1) - self.G_w[:, row, col]), linestyle=line_styles[i], label="element (" + str(row) + ", " + str(col) + ")")
+        plt.semilogy([self.w[0], self.w[-1]], [self.err_max, self.err_max], color="k", label="precision")
+        if self.h_k.shape[1] <= 16:
+            plt.legend()
+        plt.xlabel(r"$\omega_n$")
+        plt.ylabel(r"$|\hat{G}(i\omega_n) - G(i\omega_n)|$")
+        plt.title("First approximation")
+        plt.show()
+        
+        #check h_k
+        #part 1
+        plt.figure()
+        for i in range(self.n_orb ** 2):
+            row, col = i // self.n_orb, i % self.n_orb
+            plt.semilogy(np.abs(self.h_k[:, i]), '.', label="element (" + str(row) + ", " + str(col) + ")")
+        plt.semilogy([0, self.h_k.shape[0] - 1], [self.err_max, self.err_max], color="k", label="precision")
+        if self.h_k.shape[1] <= 16:
+            plt.legend()
+        plt.xlabel(r"$k$")
+        plt.ylabel(r"$h_k$")
+        plt.title("Contour integrals: value")
+        plt.show()
+        #part 2
+        plt.figure()
+        plt.semilogy(self.p_f.S, ".")
+        if self.M is not None:
+            plt.semilogy([0, self.p_f.S.size - 1], [self.p_f.S[self.M], self.p_f.S[self.M]], color="gray", linestyle="--", label="M poles")
+        plt.semilogy([0, self.p_f.S.size - 1], [self.err_max, self.err_max], color="k", label="precision")
+        plt.legend()
+        plt.xlabel(r"$n$")
+        plt.ylabel(r"$\sigma_n$")
+        plt.title("Contour integrals: SVD")
+        plt.show()
+        #part 3
+        plt.figure()
+        h_k_approx = self.p_f.get_value(np.linspace(0, 1, self.h_k.shape[0]))
+        for i in range(self.n_orb ** 2):
+            row, col = i // self.n_orb, i % self.n_orb
+            plt.semilogy(np.abs(h_k_approx[:, i] - self.h_k[:, i]), '.', label="element (" + str(row) + ", " + str(col) + ")")
+        if self.M is not None:
+            plt.semilogy([0, self.h_k.shape[0] - 1], [self.p_f.S[self.M], self.p_f.S[self.M]], color="gray", linestyle="--", label="M poles")
+        else:
+            plt.semilogy([0, self.h_k.shape[0] - 1], [self.err_max, self.err_max], color="k", label="precision")
+        if self.h_k.shape[1] <= 16:
+            plt.legend()
+        plt.xlabel(r"$k$")
+        plt.ylabel(r"$|\hat{h}_k - h_k|$")
+        plt.title("Contour integrals: approximation")
+        plt.show()
+        
+        #check the final approximation
+        plt.figure()
+        G_w2 = self.cal_G_vector(1j * self.w, self.pole_weight.reshape(-1, self.n_orb ** 2), self.pole_location).reshape(-1, self.n_orb, self.n_orb) + self.const
+        for i in range(self.n_orb ** 2):
+            row, col = i // self.n_orb, i % self.n_orb
+            plt.semilogy(self.w, np.abs(G_w2[:, row, col] - self.G_w[:, row, col]), linestyle=line_styles[i], label="element (" + str(row) + ", " + str(col) + ")")
+        if self.M is not None:
+            plt.semilogy([self.w[0], self.w[-1]], [self.p_f.S[self.M], self.p_f.S[self.M]], color="gray", linestyle="--", label="M poles")
+        else:
+            plt.semilogy([self.w[0], self.w[-1]], [self.err_max, self.err_max], color="k", label="precision")
+        if self.h_k.shape[1] <= 16:
+            plt.legend()
+        plt.xlabel(r"$\omega_n$")
+        plt.ylabel(r"$|\hat{G}(i\omega_n) - G(i\omega_n)|$")
+        plt.title("Final approximation")
+        plt.show()
+        
+        from matplotlib.colors import LinearSegmentedColormap
+        colors = [(1, 1, 1), (0, 0, 1)] #(R, G, B) tuples for white and blue
+        n_bins = 100 #Discretize the interpolation into bins
+        cmap_name = "WtBu"
+        cmap = LinearSegmentedColormap.from_list(cmap_name, colors, N=n_bins) #Create the colormap
+        
+        #check pole locations
+        pts = self.pole_location
+        scatter = plt.scatter(pts.real, pts.imag, c=np.linalg.norm(self.pole_weight.reshape(-1, self.n_orb ** 2), axis=1), vmin=0, vmax=1, cmap=cmap)
+        cbar = plt.colorbar(scatter)
+        cbar.set_label('weight')
+        x_max = np.abs(self.pole_location.real).max() * 1.2
+        y_max = max(np.abs(self.pole_location.imag).max() * 1.2, 1.0)
+        plt.xlim([-x_max, x_max])
+        plt.ylim([-y_max, y_max])
+        plt.xlabel(r"Real($z$)")
+        plt.ylabel(r"Imag($z$)")
+        plt.show()
+        
+        #check mapped pole locations
+        theta = np.arange(1001) * 2.0 * np.pi / 1000
+        pts = self.con_map.w(self.pole_location)
+        plt.plot(np.cos(theta), np.sin(theta), color="tab:orange")
+        scatter = plt.scatter(pts.real, pts.imag, c=np.linalg.norm(self.pole_weight.reshape(-1, self.n_orb ** 2), axis=1), vmin=0, vmax=1, cmap=cmap)
+        cbar = plt.colorbar(scatter)
+        cbar.set_label('weight')
+        plt.xlim([-1.05, 1.05])
+        plt.ylim([-1.05, 1.05])
+        plt.xlabel(r"Real($w$)")
+        plt.ylabel(r"Imag($w$)")
+        plt.show()

mini_pole/mini_pole_dlr.py

@@ -0,0 +1,62 @@
+import numpy as np
+from .esprit import ESPRIT
+from .con_map import ConMapGeneric, ConMapGapless
+
+class MiniPoleDLR:
+    '''
+    A Python program implementing the MPM-DLR algorithm.
+    '''
+    def __init__(self, Al_dlr, xl_dlr, beta, n0, nmax = None, err = None, err_type = "abs", M = None, symmetry = False, k_max=200, Lfactor = 0.4):
+        '''
+        Al_dlr (numpy.ndarray): DLR coefficients, either of shape (r,) or (r, n_orb, n_orb).
+        xl_dlr (numpy.ndarray): DLR grid for the real frequency, an array of shape (r,).
+        beta (float): Inverse temperature of the system (1/kT).
+        n0 (int): Number of initial points to discard, typically in the range (0, 10).
+        nmax (int): Cutoff for the Matsubara frequency when symmetry is False.
+        err (float): Error tolerance for calculations.
+        err_type (str): Specifies the type of error, "abs" for absolute error or "rel" for relative error.
+        M (int): Specifies the number of poles to be recovered.
+        symmetry (bool): Whether to impose up-down symmetry (True or False).
+        k_max (int): Number of moments to be calculated.
+        Lfactor (float): Ratio of L/N in the ESPRIT algorithm.
+        '''
+        #make sure Al_dlr is of size (r, n_orb, n_orb)
+        if Al_dlr.ndim == 1:
+            Al_dlr = Al_dlr.reshape(-1, 1, 1)
+        assert Al_dlr.ndim == 3
+        assert Al_dlr.shape[0] == xl_dlr.size and Al_dlr.shape[1] == Al_dlr.shape[2]
+        n_orb = Al_dlr.shape[1]
+        
+        # Construct holomorphic mapping
+        w_n0 = (2 * n0 + 1) * np.pi / beta
+        if symmetry is False:
+            nmax = beta if nmax is None else nmax
+            w_nmax = (2 * nmax + 1) * np.pi / beta
+            w_m = 0.5 * (w_n0 + w_nmax)
+            dw_h = 0.5 * (w_nmax - w_n0)
+            self.con_map = ConMapGeneric(w_m, dw_h)
+        else:
+            self.con_map = ConMapGapless(w_n0)
+        
+        # Calculate contour integral
+        self.xl_p = self.con_map.w(xl_dlr)
+        V = np.vander(self.xl_p, N = min(int((self.xl_p.size + 1) / Lfactor), k_max), increasing=True).T
+        self.Al_p =  Al_dlr.reshape(-1, n_orb ** 2) / self.con_map.dz(self.xl_p).reshape(-1, 1)
+        self.h_k = V @ self.Al_p
+        
+        # Extract pole information:
+        # 1) Pole weights are stored in a numpy array of shape (M,) for single-orbital systems,
+        #    or in an array of shape (M, n_orb, n_orb) for multi-orbital systems.
+        # 2) Pole locations are stored in a numpy array of shape (M,).
+        self.p = ESPRIT(self.h_k, err=err, err_type=err_type, M=M, Lfactor=Lfactor)
+        idx = np.abs(self.p.gamma) < 1
+        Al = self.p.omega[idx] * self.con_map.dz(self.p.gamma[idx]).reshape(-1, 1)
+        if n_orb == 1:
+            weight = Al[:, 0]
+        else:
+            weight = Al.reshape(-1, n_orb, n_orb)
+        location = self.con_map.z(self.p.gamma[idx])
+        #rearrange poles so that \xi_1.real <= \xi_2.real <= ... <= \xi_M.real
+        idx2 = np.argsort(location.real)
+        self.pole_weight   = weight[idx2]
+        self.pole_location = location[idx2]

mini_pole/spectrum_example.py

@@ -0,0 +1,132 @@
+import numpy as np
+from scipy.special import ellipk
+
+'''
+Function tools for testing the performance of Prony Analytic Continuation.
+'''
+def semi_circle(w, w0 = 0.0, r = 1.0):
+    '''
+    A semicircle function with the center being w0 and the radius being r.
+    '''
+    assert r > 0.0
+    if np.abs(w - w0) >= r:
+        return 0.0
+    else:
+        return (2.0 / (np.pi * r**2.0)) * np.sqrt(r**2.0 - (w - w0)**2.0)
+
+def rectangle(w, w0 = 0.0, dw_h = 0.5):
+    '''
+    A rectangle function with the center being w0 and the half-width being dw_h.
+    '''
+    assert dw_h > 0.0
+    if np.abs(w - w0) >= dw_h:
+        return 0.0
+    else:
+        return 1.0 / (2.0 * dw_h)
+
+def triangle(w, w0 = 0.0, dw_h = 1.0):
+    '''
+    A triangle function with the center being w0 and the half-length of the bottom edge being dw_h.
+    '''
+    assert dw_h > 0.0
+    if np.abs(w - w0) >= dw_h:
+        return 0.0
+    else:
+        h = 1.0 / dw_h
+        return h * (1.0 - np.abs(w - w0) / dw_h)
+
+def gaussian(w, mu = 0.0, sigma = 1.0):
+    '''
+    A Gaussian function with the expected value mu and the standard deviation sigma.
+    '''
+    return 1.0 / (np.sqrt(2.0 * np.pi) * sigma) * np.exp(-0.5 * ((w - mu) / sigma)**2.0)
+
+def lorentzian(w, w0 = 0.0, half_width = 1.0):
+    '''
+    A Lorentzian function with the center being w0 and the half-width at half-maximum being half-width.
+    '''
+    return 1.0 / np.pi * half_width / ((w - w0)**2.0 + half_width**2.0)
+
+def bethe_lattice_dos_indiv(x, t = 1.0):
+    '''
+    Intermediate function of bethe_lattice_dos(w, t) which only works for a single point.
+    '''
+    if np.abs(x) > 2 * t:
+        return 0.0
+    else:
+        return 1.0 / (2.0 * np.pi * t**2.0) * np.sqrt(4 * t**2.0 - x**2.0)
+
+def bethe_lattice_dos(w, t = 1.0):
+    '''
+    Density of states for the tight-binding model in Bethe lattice with interaction t.
+    '''
+    return np.vectorize(lambda x: bethe_lattice_dos_indiv(x, t))(w)
+
+def bethe_lattice_G(w_n, t = 1.0):
+    '''
+    Matsubara Green's function for the tight-binding model in Bethe lattice with interaction t. 
+    w_n is the imaginary part of the Matsubara Green's function.
+    '''
+    assert np.linalg.norm(w_n.imag) == 0.0
+    assert np.all(w_n > 0.0)    
+    return 1.0j / (2.0 * t**2.0) * (w_n - np.sqrt(w_n**2.0 + 4.0 * t**2.0))
+
+def square_lattice_dos_indiv(x, t = 1.0):
+    '''
+    Intermediate function of square_lattice_dos(w, t) which only works for a single point.
+    '''
+    if np.abs(x) > 4 * t:
+        return 0.0
+    else:
+        return 1.0 / (2.0 * np.pi**2 * t) * ellipk(1 - (x / (4 * t))**2)
+
+def square_lattice_dos(w, t = 1.0):
+    '''
+    Density of states for the tight-binding model in square lattice with nearest-neighbor interaction t.
+    '''
+    return np.vectorize(lambda x: square_lattice_dos_indiv(x, t))(w) 
+
+def square_lattice_G(w_n, t = 1.0):
+    '''
+    Matsubara Green's function for the tight-binding model in square lattice with nearest-neighbor interaction t. 
+    w_n is the imaginary part of the Matsubara Green's function.
+    '''
+    assert np.linalg.norm(w_n.imag) == 0.0
+    return -1.0j / (2.0 * np.pi * t * np.sqrt(1 + (w_n / (4.0 * t))**2.0)) * ellipk(1.0 / (1.0 + (w_n / (4.0 * t))**2.0))
+
+def triangle_lattice_dos_indiv(x, t = 1.0, tp = 0.5):
+    '''
+    Intermediate function of triangle_lattice_dos(w, t, tp) which only works for a single point.
+    '''
+    assert tp != 0.0
+    u = t / tp
+    E = x / t
+    assert u >= 0.0
+    
+    w_min = -4.0 - 2.0 / u
+    w_max = (u + 2.0 / u if u <= 2.0 else 4.0 - 2.0 / u)
+    
+    if E < w_min or E > w_max:
+        return 0.0
+    
+    r = u * np.sqrt(u**2.0 - E * u + 2.0)
+    p = 4.0 * r
+    q = (r - u**2.0)**2.0 * (r**2.0 - 4.0 * u**2.0 + 2.0 * r * u**2.0 + u ** 4.0) / (4.0 * u**4.0)
+    
+    if q < 0.0:
+        z0 = p - q
+        z1 = p
+    elif q < p:
+        z0 = p
+        z1 = p - q
+    else:
+        z0 = q
+        z1 = q - p
+    
+    return 1.0 / (np.pi**2.0 * tp * np.sqrt(z0)) * ellipk(z1 / z0)
+
+def triangle_lattice_dos(w, t = 1.0, tp = 0.5):
+    '''
+    Density of states for the tight-binding model in triangular lattice with anisotropic nearest-neighbor interactions t and tp.
+    '''
+    return np.vectorize(lambda x: triangle_lattice_dos_indiv(x, t, tp))(w)

mini_pole-0.2.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 lzphy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mini_pole-0.2.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.1
+Name: mini_pole
+Version: 0.2
+Summary: The Python code provided implements the matrix-valued version of the Minimal Pole Method (MPM) as described in arXiv:2410.14000.
+Home-page: https://github.com/Green-Phys/MiniPole
+Author: Lei Zhang
+Author-email: lzphy@umich.edu
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: scipy>=1.7.0
+
+# 1. MiniPole
+The Python code provided implements the matrix-valued version of the Minimal Pole Method (MPM) as described in [arXiv:2410.14000](https://arxiv.org/abs/2410.14000), extending the scalar-valued method introduced in [Phys. Rev. B 110, 035154 (2024)](https://doi.org/10.1103/PhysRevB.110.035154).
+
+The input of the simulation is the Matsubara data $G(i \omega_n)$ sampled on a uniform grid $\lbrace i\omega_{0}, i\omega_{1}, \cdots, i\omega_{n_{\omega}-1} \rbrace$, where  $\omega_n=\frac{(2n+1)\pi}{\beta}$ for fermions and $\frac{2n\pi}{\beta}$ for bosons, and $n_{\omega}$ is the total number of sampling points.
+
+## i) The standard MPM is performed using the following command:
+
+**p = MiniPole(G_w, w, n0 = "auto", n0_shift = 0, err = None, err_type = "abs", M = None, symmetry = False, G_symmetric = False, compute_const = False, plane = None, include_n0 = True, k_max = 999, ratio_max = 10)**
+        
+    Parameters
+    ----------
+    1. G_w : ndarray
+        An (n_w, n_orb, n_orb) or (n_w,) array containing the Matsubara data.
+    2. w : ndarray
+        An (n_w,) array containing the corresponding real-valued Matsubara grid.
+    3. n0 : int or str, default="auto"
+        If "auto", n0 is automatically selected with an additional shift specified by n0_shift.
+        If a non-negative integer is provided, n0 is fixed at that value.
+    4. n0_shift : int, default=0
+        The shift applied to the automatically determined n0.
+    5. err : float
+        Error tolerance for calculations.
+    6. err_type : str, default="abs"
+        Specifies the type of error: "abs" for absolute error or "rel" for relative error.
+    7. M : int, optional
+        The number of poles in the final result. If not specified, the precision from the first ESPRIT is used to extract poles in the second ESPRIT.
+    8. symmetry : bool, default=False
+        Determines whether to preserve up-down symmetry.
+    9. G_symmetric : bool, default=False
+        If True, the Matsubara data will be symmetrized such that G_{ij}(z) = G_{ji}(z).
+    10. compute_const : bool, default=False
+        Determines whether to compute the constant term in G(z) = sum_l Al / (z - xl) + const.
+        If False, the constant term is fixed at 0.
+    11. plane : str, optional
+        Specifies whether to use the original z-plane or the mapped w-plane to compute pole weights.
+    12. include_n0 : bool, default=True
+        Determines whether to include the first n0 input points when weights are calculated in the z-plane.
+    13. k_max : int, default=999
+        The maximum number of contour integrals.
+    14. ratio_max : float, default=10
+        The maximum ratio of oscillation when automatically choosing n0.
+    
+    Returns
+    -------
+    Minimal pole representation of the given data.
+    Pole weights are stored in p.pole_weight, a numpy array of shape (M, n_orb, n_orb).
+    Shared pole locations are stored in p.pole_location, a numpy array of shape (M,).
+
+## ii) The MPM-DLR algorithm is performed using the following command:
+
+**p = MiniPoleDLR(Al_dlr, xl_dlr, beta, n0, nmax = None, err = None, err_type = "abs", M = None, symmetry = False, k_max=200, Lfactor = 0.4)**
+
+    Parameters
+    ----------
+    1. Al_dlr (numpy.ndarray): DLR coefficients, either of shape (r,) or (r, n_orb, n_orb).
+    2. xl_dlr (numpy.ndarray): DLR grid for the real frequency, an array of shape (r,).
+    3. beta (float): Inverse temperature of the system (1/kT).
+    4. n0 (int): Number of initial points to discard, typically in the range (0, 10).
+    5. nmax (int): Cutoff for the Matsubara frequency when symmetry is False.
+    6. err (float): Error tolerance for calculations.
+    7. err_type (str): Specifies the type of error, "abs" for absolute error or "rel" for relative error.
+    8. M (int): Specifies the number of poles to be recovered.
+    9. symmetry (bool): Whether to impose up-down symmetry (True or False).
+    10. k_max (int): Number of moments to be calculated.
+    11. Lfactor (float): Ratio of L/N in the ESPRIT algorithm.
+    
+    Returns
+    -------
+    Minimal pole representation of the given data.
+    Pole weights are stored in p.pole_weight, a numpy array of shape (M, n_orb, n_orb).
+    Shared pole locations are stored in p.pole_location, a numpy array of shape (M,).
+
+# 2. Examples
+
+The scripts in the *examples* folder demonstrate the usage of MPM and MPM-DLR.
+
+## i) MPM-DLR Algorithm
+
+The *examples/MPM_DLR* folder contains scripts to recover the band structure of Si, as shown in the middle panel of Fig. 8 in [arXiv:2410.14000](https://arxiv.org/abs/2410.14000).
+
+### Steps:
+
+a) Download the input data file [Si_dlr.h5](https://drive.google.com/file/d/1_bNvbgOHewiujHYEcf-CCpGxlZP9cRw_/view?usp=drive_link) to the *examples/MPM_DLR/* directory.
+
+b) Obtain the recovered poles by running **python3 cal_band_dlr.py --obs=`<option>`**, where **`<option>`** can be "S" (self-energy), "Gii" (scalar-valued Green's function), or "G" (matrix-valued Green's function).
+
+c) Plot the band structure by running **python3 plt_band_dlr.py --obs=`<option>`**.
+
+### Note:
+
+a) Reference runtime on a single core of a laptop (using the M1 Max Apple chip as an example): 13 seconds for "Gii" and 160 seconds for both "G" and "S".
+
+b) Parallel computation is supported in **cal_band_dlr.py** to speed up the process on multiple cores. Use the following command: **mpirun -n `<num_cores>` python3 cal_band_dlr.py --obs=`<option>`**, where **`<num_cores>`** is the number of cores and **`<option>`** is "S," "Gii," or "G".
+
+c) Full Parameters for **cal_band_dlr.py**:
+
+   - `--obs` (str): Observation type used in the script. Default is `"S"`.
+   - `--n0` (int): Parameter $n_0$ as described in [arXiv:2410.14000](https://arxiv.org/abs/2410.14000).
+   - `--err` (float): Error tolerance for computations. Default is `1.e-10`.
+   - `--symmetry` (bool): Specifies whether to preserve up-down symmetry in calculations.
+
+d) Full Parameters for **plt_band_dlr.py**:
+
+   - `--obs` (str): Observation type used in the script. Default is `"S"`.
+   - `--w_min` (float): Lower bound of the real frequency in eV. Default is `-12`.
+   - `--w_max` (float): Upper bound of the real frequency in eV. Default is `12`.
+   - `--n_w` (int): Number of frequencies between `w_min` and `w_max`. Default is `200`.
+   - `--eta` (float): Broadening parameter. Default is `0.005`.

mini_pole-0.2.dist-info/RECORD

@@ -0,0 +1,12 @@
+mini_pole/__init__.py,sha256=mC5Npdatb7XBt_fcvpiHu2HBQozTdkIYE6OygQI_74E,125
+mini_pole/con_map.py,sha256=TfrYc713gR0P9-zWuZ2m8f4r_0bPHd7dFewRysoNPxk,4629
+mini_pole/esprit.py,sha256=8yijPCwXax-RTgUDzpqhx5hW3XdMP18JI1VH_BaKOzI,6458
+mini_pole/green_func.py,sha256=SqeUveDelETGVFZDqFahhbTMS2-HjCV_6KPvk9VT-Jc,4292
+mini_pole/mini_pole.py,sha256=LxFYyINjLQ4Ncv2LwYTYkUYbaXBFVFbNvq9E9ZYa5iE,21704
+mini_pole/mini_pole_dlr.py,sha256=AExes9x_2_yNNNRmdqdXG-f07dvxXT1so6_xMRWO1ag,3090
+mini_pole/spectrum_example.py,sha256=TM_hCyi8BZaSYxMBQHfqdThDKCJJoNlZZlAODuMl9Kc,4240
+mini_pole-0.2.dist-info/LICENSE,sha256=fX-FwYOyRqGGw9goJuT-s31vziK6_uKlEaYoPqc-NZE,1062
+mini_pole-0.2.dist-info/METADATA,sha256=EoP_oa3l20E8i9gHP1hBkKXLhOReDWIGfJjRZbd5Scc,6945
+mini_pole-0.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+mini_pole-0.2.dist-info/top_level.txt,sha256=5dwIWQGLxZqDey12gK5BkbMMNGrykqXAcBWf0Cx48Ds,10
+mini_pole-0.2.dist-info/RECORD,,

mini_pole-0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.6.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mini_pole-0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+mini_pole