adapol 0.1.0__tar.gz

adapol-0.1.0/MANIFEST.in

@@ -0,0 +1,8 @@
+prune .git
+prune .github
+prune build
+prune doc
+prune example
+prune test
+
+global-exclude .gitignore pytest.ini

adapol-0.1.0/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: adapol
+Version: 0.1.0
+Summary: Adaptive Pole Fitting for Quantum Many-Body Physics 
+Author-email: Zhen Huang <hertz@berkeley.edu>, Chia-Nan Yeh <cyeh@flatironinstitute.org>, Nils Wentzell <nwentzell@flatironinstitute.org>, Jason Kaye <jkaye@flatironinstitute.org>, Lin Lin <linlin@berkeley.edu>
+Project-URL: Homepage, https://flatironinstitute.github.io/adapol
+Project-URL: Bug Tracker, https://github.com/flatironinstitute/adapol/issues
+Keywords: Bath,Fitting,Hybridization,DMFT,Matsubara
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: cvxpy
+
+# adapol: Adaptive Pole Fitting for Quantum Many-Body Physics
+[`adapol`](https://github.com/Hertz4/Adapol) (pronounced "add a pole") is a python package for fitting Matsubara functions with the following form:
+```math
+G(\mathrm i \omega_k) = \sum_l \frac{V_lV_l^{\dagger}}{\mathrm i\omega_k - E_l}.
+```
+
+Current applications include
+(1) hybridization fitting, (2) analytic continuation.
+
+We also provide a [TRIQS](https://triqs.github.io/) interface if the Matsubara functions are stored in `triqs` Green's function container.
+
+# Installation
+`adapol` has `numpy` and `scipy` as its prerequisites. [`cvxpy`](https://www.cvxpy.org/) is also required for hybridization fitting of matrix-valued (instead of scalar-valued) Matsubara functions.
+
+To install `adapol`, run
+```terminal
+pip install adapol
+```
+
+
+
+# Documentation
+
+See the detailed [documentation](https://flatironinstitute.github.io/adapol/) for physical background, algorithms and user manual.
+
+`Adapol` is a stand-alone package. For TRIQS users, we also provide a TRIQS interface. See [user manual](https://flatironinstitute.github.io/adapol/latest/python.html#triqs-interface) for details.
+
+# Examples
+In the `tutorial` page, we provide two examples [`discrete.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/discrete.html) and [`semicircle.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/semicircle.html), showcasing how to use `adapol` for both discrete spectrum and continuous spectrum.
+
+In these notebooks, we also demonstrate how to use our code through the triqs interface.
+
+# References
+To cite this work, please include a reference to this GitHub repository, and
+cite the following references:
+
+1. Huang, Zhen, Emanuel Gull, and Lin Lin. "Robust analytic continuation of Green's functions via projection, pole estimation, and semidefinite relaxation." Physical Review B 107.7 (2023): 075151.
+2. Mejuto-Zaera, Carlos, et al. "Efficient hybridization fitting for dynamical mean-field theory via semi-definite relaxation." Physical Review B 101.3 (2020): 035143.
+3. Nakatsukasa, Yuji, Olivier Sète, and Lloyd N. Trefethen. "The AAA algorithm for rational approximation." SIAM Journal on Scientific Computing 40.3 (2018): A1494-A1522.

adapol-0.1.0/README.md

@@ -0,0 +1,39 @@
+# adapol: Adaptive Pole Fitting for Quantum Many-Body Physics
+[`adapol`](https://github.com/Hertz4/Adapol) (pronounced "add a pole") is a python package for fitting Matsubara functions with the following form:
+```math
+G(\mathrm i \omega_k) = \sum_l \frac{V_lV_l^{\dagger}}{\mathrm i\omega_k - E_l}.
+```
+
+Current applications include
+(1) hybridization fitting, (2) analytic continuation.
+
+We also provide a [TRIQS](https://triqs.github.io/) interface if the Matsubara functions are stored in `triqs` Green's function container.
+
+# Installation
+`adapol` has `numpy` and `scipy` as its prerequisites. [`cvxpy`](https://www.cvxpy.org/) is also required for hybridization fitting of matrix-valued (instead of scalar-valued) Matsubara functions.
+
+To install `adapol`, run
+```terminal
+pip install adapol
+```
+
+
+
+# Documentation
+
+See the detailed [documentation](https://flatironinstitute.github.io/adapol/) for physical background, algorithms and user manual.
+
+`Adapol` is a stand-alone package. For TRIQS users, we also provide a TRIQS interface. See [user manual](https://flatironinstitute.github.io/adapol/latest/python.html#triqs-interface) for details.
+
+# Examples
+In the `tutorial` page, we provide two examples [`discrete.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/discrete.html) and [`semicircle.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/semicircle.html), showcasing how to use `adapol` for both discrete spectrum and continuous spectrum.
+
+In these notebooks, we also demonstrate how to use our code through the triqs interface.
+
+# References
+To cite this work, please include a reference to this GitHub repository, and
+cite the following references:
+
+1. Huang, Zhen, Emanuel Gull, and Lin Lin. "Robust analytic continuation of Green's functions via projection, pole estimation, and semidefinite relaxation." Physical Review B 107.7 (2023): 075151.
+2. Mejuto-Zaera, Carlos, et al. "Efficient hybridization fitting for dynamical mean-field theory via semi-definite relaxation." Physical Review B 101.3 (2020): 035143.
+3. Nakatsukasa, Yuji, Olivier Sète, and Lloyd N. Trefethen. "The AAA algorithm for rational approximation." SIAM Journal on Scientific Computing 40.3 (2018): A1494-A1522.

adapol-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project]
+name = "adapol"
+version = "0.1.0"
+authors = [
+  { name="Zhen Huang", email="hertz@berkeley.edu" },
+  { name="Chia-Nan Yeh", email="cyeh@flatironinstitute.org"},
+  { name="Nils Wentzell", email="nwentzell@flatironinstitute.org"},
+  { name="Jason Kaye", email="jkaye@flatironinstitute.org"},
+  { name="Lin Lin", email="linlin@berkeley.edu"}
+]
+description = "Adaptive Pole Fitting for Quantum Many-Body Physics "
+readme = "README.md"
+keywords = ["Bath", "Fitting", "Hybridization", "DMFT", "Matsubara"]
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "numpy",
+    "scipy",
+    "cvxpy"
+]
+
+[project.urls]
+"Homepage" = "https://flatironinstitute.github.io/adapol"
+"Bug Tracker" = "https://github.com/flatironinstitute/adapol/issues"

adapol-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

adapol-0.1.0/src/adapol/__init__.py

@@ -0,0 +1,4 @@
+from .hybfit import hybfit, hybfit_triqs
+from .anacont import anacont
+from .fit_utils import check_psd
+__all__ = ["hybfit", "hybfit_triqs", "check_psd", "anacont"]

adapol-0.1.0/src/adapol/aaa.py

@@ -0,0 +1,123 @@
+"""
+This code implements a specific variant of the AAA algorithm.
+
+"""
+
+import numpy as np
+import scipy.linalg
+
+
+def aaa_matrix_real(F, Z, tol=1e-13, mmax=100):
+    """ """
+    Z = np.asanyarray(Z).ravel()
+
+    # only use input z that are on iR_+. Will map them to iR_- by taking conjugate of function value.
+    half_index = np.imag(Z) > 0
+    Z_half = Z[half_index]
+    F_half = F[half_index, :, :]
+    M_half = len(Z_half)
+
+    Z = np.append(Z_half, np.conjugate(Z_half))
+
+    Norb = F.shape[1]
+    F_other_half = np.zeros_like(F_half)
+    for i in range(M_half):
+        F_other_half[i, :, :] = np.conjugate(np.transpose(F_half[i, :, :]))
+    F = np.concatenate((F_half, F_other_half), axis=0)
+
+    M = M_half * 2
+
+    F_mat = np.reshape(F, (M, Norb * Norb))
+
+    J = list(range(M))
+    zj = np.empty(0, dtype=Z.dtype)
+    fj = np.empty((0, Norb * Norb), dtype=F.dtype)
+    C = np.empty([M, 0], dtype=F.dtype)
+    errors = []
+
+    reltol = tol * np.linalg.norm(F_mat, np.inf)
+
+    R = np.mean(F_mat) * np.ones_like(F_mat)
+
+    mlist = range(2, mmax + 1, 2)
+
+    for m in mlist:
+        # find largest residual
+        jj = np.argmax(np.sum(abs(F_mat - R) ** 2, 1))
+        zj = np.append(zj, (Z[jj],))
+        fj = np.concatenate((fj, F_mat[jj : jj + 1, :]), axis=0)
+        J.remove(jj)
+
+        # Cauchy matrix containing the basis functions as columns
+
+        jj2 = (jj + M_half) % M
+        zj = np.append(zj, (Z[jj2],))
+        fj = np.concatenate((fj, F_mat[jj2 : jj2 + 1, :]), axis=0)
+
+        J.remove(jj2)
+
+        C = 1.0 / (Z[J, None] - zj[None, :])
+
+        # Loewner matrix
+        Apart = np.zeros(((M - m) * Norb * Norb, m), dtype=F.dtype)
+        for i in range(Norb * Norb):
+            Fhere = F_mat[:, i]
+            fjhere = fj[:, i]
+
+            Apart[range(0 + i, i + (M - m) * Norb * Norb, Norb * Norb), :] = (
+                Fhere[J, None] - fjhere[None, :]
+            ) * C
+
+        Awidth = np.size(Apart, 1)
+        Apart_l = Apart[:, range(0, Awidth, 2)]
+        Apart_r = Apart[:, range(1, Awidth, 2)]
+        Anew = np.concatenate((Apart_l + Apart_r, (Apart_l - Apart_r) * 1j), axis=1)
+        Anew = np.concatenate((np.real(Anew), np.imag(Anew)), axis=0)
+
+        # compute weights as right singular vector for smallest singular value
+        _, _, Vh = np.linalg.svd(Anew, full_matrices=False)
+
+        wj_r = Vh[-1, :]
+
+        wj_r = np.reshape(wj_r, (2, int(m / 2)))
+        wj_c = np.zeros((2, int(m / 2)), dtype=np.complex128)
+        wj_c[0, :] = wj_r[0, :] + 1j * wj_r[1, :]
+        wj_c[1, :] = wj_r[0, :] - 1j * wj_r[1, :]
+
+        wj = np.asanyarray(wj_c.T).ravel()
+
+        # approximation: numerator / denominator
+
+        D = C.dot(wj)
+
+        # update residual
+        R = F_mat.copy()
+
+        for i in range(Norb * Norb):
+            fjhere = fj[:, i]
+            N = C.dot(wj * fjhere)  # needs to change N and R
+            R[J, i] = N / D
+
+        # check for convergence
+        errors.append(np.linalg.norm(F_mat - R, np.inf))
+        if errors[-1] <= reltol:
+            break
+
+    fj = fj.reshape(m, Norb, Norb)
+    pol = aaa_pol(zj, wj)
+    return pol, zj, fj, wj
+
+
+def aaa_pol(zj, wj):
+    """Return the poles and residues of the rational function."""
+
+    m = len(wj)
+
+    # compute poles
+    B = np.eye(m + 1)
+    B[0, 0] = 0
+    E = np.block([[0, wj], [np.ones((m, 1)), np.diag(zj)]])
+    evals = scipy.linalg.eigvals(E, B)
+    pol = np.real_if_close(evals[np.isfinite(evals)])
+
+    return pol

adapol-0.1.0/src/adapol/anacont.py

@@ -0,0 +1,210 @@
+import numpy as np
+from .fit_utils import pole_fitting, eval_with_pole
+
+def anacont(
+    Delta,
+    iwn_vec,
+    tol=None,
+    Np=None,
+    solver="lstsq",
+    maxiter=500,
+    mmin=4,
+    mmax=50,
+    verbose=False,
+):
+    """
+    The function for analytical continuation.
+
+    Examples:
+    ----------
+
+        -  Analytic continuation with :math:`N_p` poles:
+            :code:`func = anacont(Np = Np)` 
+
+        - Fitting with fixed error tolerance tol:
+            :code:`func = anacont(tol = tol)` 
+            
+        - Analytic continuation with improved accuracy:
+            :code:`fitting(Np = Np, flag = flag, solver = "sdp")`
+
+    Parameters:
+    ------------
+    :code:`Delta`: np.array, :math:`(N_w, N_\mathrm{orb}, N_\mathrm{orb})`
+        The input hybridization function in Matsubara frequency.
+
+    :code:`iwn_vec`: np.array, :math:`(N_w,)`
+        The Matsubara frequency vector, complex-valued 
+
+
+    :code:`tol`: Fitting error tolreance, float
+        If tol is specified, the fitting will be conducted with fixed error tolerance tol.
+        default: None
+
+    :code:`Np`: number of poles, integer
+        If Np is specified, the fitting will be conducted with fixed number of poles Np.
+        default: None
+        Np needs to be an odd integer, and number of supoort points is Np + 1.
+
+
+    :code:`solver`: string
+        The solver that is used for optimization.
+        choices: "lstsq", "sdp"
+        default: "lstsq"
+
+    :code:`maxiter`: int
+        maximum number of iterations
+        default: 500
+
+    :code:`mmin`, :code:`mmax`: number of minimum or maximum poles, integer
+        default: mmin = 4, mmax = 50
+        if tol is specified, mmin and mmax will be used as the minimum and maximum number of poles.
+        if Np is specified, mmin and mmax will not be used.
+
+    :code:`verbose`: bool
+        whether to display optimization details
+        default: False
+
+
+
+
+    Returns:
+    ---------
+    :code:`func`: function
+            Analytic continuation function:
+            :math:`f(z) = \sum_n \mathrm{Weight}[n]/(z-\mathrm{pol}[n]).`
+
+    :code:`fitting_error`: float
+        fitting error
+
+    :code:`pol`: np.array, :math:`(N_p,)`
+        poles obtained from fitting
+
+    :code:`weight`: np.array, :math:`(N_p, N_\mathrm{orb}, N_\mathrm{orb})`
+        weights obtained from fitting
+
+    """
+
+    # Check dimensions
+    assert len(iwn_vec.shape) == 1 or len(iwn_vec.shape) == 2
+    if len(iwn_vec.shape) == 2:
+        assert iwn_vec.shape[1] == 1
+        iwn_vec = iwn_vec.flatten()
+    assert len(Delta.shape) == 3 or len(Delta.shape) == 1
+    if len(Delta.shape) == 1:
+        assert Delta.shape[0] == iwn_vec.shape[0]
+        Delta = Delta[:, None, None]
+    if len(Delta.shape) == 3:
+        assert Delta.shape[0] == iwn_vec.shape[0]
+        assert Delta.shape[1] == Delta.shape[2]
+
+    solver = solver.lower()
+    assert solver == "lstsq" or solver == "sdp"
+
+    # Check input tol or Np
+    if tol is None and Np is None:
+        raise ValueError("Please specify either tol or Np")
+    if tol is not None and Np is not None:
+        raise ValueError(
+            "Please specify either tol or Np. One can not specify both of them."
+        )
+    
+    wn_vec = np.imag(iwn_vec)
+
+    if Np is not None:
+        pol, weight, fitting_error = pole_fitting(
+            Delta, wn_vec, Ns=Np+1, maxiter=maxiter, solver=solver, disp=verbose
+        )
+    elif tol is not None:
+        pol, weight, fitting_error = pole_fitting(
+            Delta,
+            wn_vec,
+            tol=tol,
+            mmin=mmin,
+            mmax=mmax,
+            maxiter=maxiter,
+            solver=solver,
+            disp=verbose,
+        )
+    def func(Z):
+        return eval_with_pole(pol, Z, weight)
+    return func, fitting_error, pol, weight
+
+
+def anacont_triqs(
+    Delta_triqs,
+    tol=None,
+    Np=None,
+    solver="lstsq",
+    maxiter=500,
+    mmin=4,
+    mmax=50,
+    verbose=False,
+    debug=False
+):
+    """
+    The triqs interface for analytical continuation.
+    The function requires triqs package in python.
+
+    Parameters:
+    ------------
+    :code:`Delta_triqs`: triqs Green's function container
+        The input hybridization function in Matsubara frequency
+
+    :code:`debug`: bool
+        return additional outputs for debugging.
+        Default: False
+
+    :code:`tol`, :code:`Np`, :code:`solver`, :code:`maxiter`, :code:`mmin`, :code:`mmax`, :code:`verbose`: 
+        same as in anacont
+
+
+    Returns:
+    ---------
+    :code:`func`: function
+            Analytic continuation function:
+            :math:`f(z) = \sum_n \mathrm{Weight}[n]/(z-\mathrm{pol}[n]).`
+    
+    if debug == True:
+        :code:`fitting_error`: float
+            fitting error
+
+        :code:`pol`: np.array, :math:`(N_p,)`
+            poles obtained from fitting
+
+        :code:`weight`: np.array, :math:`(N_p, N_\mathrm{orb}, N_\mathrm{orb})`
+            weights obtained from fitting
+
+    """
+    try:
+        from triqs.gf import Gf, BlockGf, MeshImFreq, MeshDLRImFreq
+    except ImportError:
+        raise ImportError("Failed to import the triqs package (https://triqs.github.io/triqs/latest/). "
+                          "Please ensure it is installed.")
+
+    if isinstance(Delta_triqs, Gf) and isinstance(Delta_triqs.mesh, (MeshImFreq, MeshDLRImFreq)):
+        iwn_vec = np.array([iw.value for iw in Delta_triqs.mesh.values()])
+        func, fit_error, pol, weight = anacont(Delta_triqs.data, iwn_vec, tol, Np, solver, maxiter,
+                                               mmin, mmax, verbose)
+        print('optimization finished with fitting error {:.3e}'.format(fit_error))
+
+        if debug:
+            return func, fit_error, pol, weight
+        else:
+            return func
+    elif isinstance(Delta_triqs, BlockGf) and isinstance(Delta_triqs.mesh, (MeshImFreq, MeshDLRImFreq)):
+        func_list, error_list, pol_list, weight_list = [], [], [], []
+        for j, (block, delta_blk) in enumerate(Delta_triqs):
+            func, fit_error, pol, weight = anacont_triqs(delta_blk, tol, Np, solver, maxiter, mmin,
+                                                         mmax, verbose)
+            func_list.append(func)
+            if debug:
+                error_list.append(fit_error)
+                pol_list.append(pol)
+                weight_list.append(weight)
+
+        if debug:
+            return func_list, error_list, pol_list, weight_list
+        else:
+            return func_list
+    else:
+        raise RuntimeError("Error: Delta_triqs.mesh must be an instance of MeshImFreq or MeshDLRImFreq.")

adapol-0.1.0/src/adapol/fit_utils.py

@@ -0,0 +1,278 @@
+# This is a python implementation for analytic continuation of Fermionic Green's functions/self energy
+# using PES (ES) method
+# Reference: PhysRevB.107.075151
+import numpy as np
+import scipy
+import scipy.optimize
+import cvxpy as cp
+from .aaa import aaa_matrix_real
+
+
+# import mosek
+def eval_with_pole(pol, Z, weight):
+    pol_t = np.reshape(pol, [pol.size, 1])
+    M = 1 / (Z - pol_t)
+    M = M.transpose()
+    if len(weight.shape) == 1:
+        return M @ weight
+    else:
+        G = M @ np.reshape(weight, (weight.shape[0], weight.shape[1] * weight.shape[2]))
+        return np.reshape(G, (G.shape[0], weight.shape[1], weight.shape[2]))
+
+
+def get_weight(
+    pol, Z, G, cleanflag=True, maxiter=1000, complex=True, fast=False, eps=1e-8
+):
+    pol_t = np.reshape(pol, [pol.size, 1])
+    M = 1 / (Z - pol_t)
+    M = M.transpose()
+    MM = np.concatenate([M.real, M.imag])
+    if len(G.shape) == 1:
+        GG = np.concatenate([G.real, G.imag])
+        if cleanflag:
+            R = np.linalg.lstsq(MM, GG, rcond=0)[0]
+        else:
+            [R, rnorm] = scipy.optimize.nnls(MM, GG, maxiter=maxiter)
+        residue = G - M @ R
+    else:
+        Np = len(pol)
+        Norb = G.shape[1]
+        R = np.zeros((Np, Norb, Norb), dtype=np.complex128)
+        if cleanflag:
+            for i in range(Norb):
+                GG = np.concatenate([G[:, i, i].real, G[:, i, i].imag])
+                R[:, i, i] = np.linalg.lstsq(MM, GG, rcond=0)[0]
+                for j in range(i + 1, Norb):
+                    g1 = (G[:, j, i] + G[:, i, j]) / 2.0
+                    g2 = (G[:, i, j] - G[:, j, i]) / 2.0
+                    GG1 = np.concatenate([g1.real, g1.imag])
+                    GG2 = np.concatenate([g2.imag, -g2.real])
+                    R1 = np.linalg.lstsq(MM, GG1, rcond=0)[0]
+                    R2 = np.linalg.lstsq(MM, GG2, rcond=0)[0]
+                    R[:, i, j] = R1 + 1j * R2
+                    R[:, j, i] = R1 - 1j * R2
+        else:
+            if not fast:
+                Nw = len(Z)
+
+                if complex:
+                    X = [cp.Variable((Norb, Norb), hermitian=True) for i in range(Np)]
+                    constraints = [X[i] >> 0 for i in range(Np)]
+                else:
+                    X = [cp.Variable((Norb, Norb), PSD=True) for i in range(Np)]
+
+            
+                Gfit = []
+                for w in range(Nw):
+                    Gfit.append(cp.sum_squares(sum([ M[w,i]*X[i] for i in range(Np)]) - G[w,:,:]))
+
+                if complex:
+                    prob = cp.Problem(cp.Minimize(sum(Gfit)), constraints)
+                else:
+                    prob = cp.Problem(cp.Minimize(sum(Gfit)))
+                prob.solve(solver="SCS", verbose=False, eps=eps)
+                #  MOSEK parameters
+                # mosek_params_dict = {"MSK_DPAR_INTPNT_CO_TOL_PFEAS": 1.e-8,\
+                #                     "MSK_DPAR_INTPNT_CO_TOL_DFEAS": 1.e-8,
+                #                     "MSK_DPAR_INTPNT_CO_TOL_REL_GAP": 1.e-8,
+                #                     "MSK_DPAR_INTPNT_CO_TOL_NEAR_REL": 1000}
+                # result = prob.solve(solver = "MOSEK", verbose=False,\
+                #                 mosek_params = mosek_params_dict)
+
+                for i in range(Np):
+                    R[i] = X[i].value
+            else:
+                for i in range(Norb):
+                    GG = np.concatenate([G[:, i, i].real, G[:, i, i].imag])
+                    Rii = scipy.optimize.nnls(MM, GG, maxiter=maxiter)[0]
+                    R[:, i, i] = Rii
+                MM2 = np.concatenate([M, np.conj(M)])
+                for i in range(Norb):
+                    for j in range(i + 1, Norb):
+                        GG = np.concatenate([G[:, i, j], np.conj(G[:, j, i])])
+                        bound = np.sqrt(np.abs(R[:, i, i] * R[:, j, j]))
+                        x = cp.Variable(MM.shape[1], complex=True)
+                        constraints = [
+                            cp.abs(x[k]) <= bound[k] for k in range(MM.shape[1])
+                        ]
+                        objective = cp.Minimize(cp.sum_squares(MM2 @ x - GG))
+                        prob = cp.Problem(objective, constraints)
+                        prob.solve(solver="SCS", verbose=False, eps=eps)
+                        # result = prob.solve(solver = cp.MOSEK,verbose = False,mosek_params = mosek_params_dict)
+                        R[:, i, j] = x.value
+                        R[:, j, i] = np.conj(x.value)
+
+        residue = 1.0 * G
+        for i in range(Np):
+            residue = residue - M[:, i, None, None] * R[i]
+    return R, M, residue
+
+
+def aaa_reduce(pol, R, eps=1e-6):
+    Np = R.shape[0]
+    Rnorm = np.zeros(Np)
+    for i in range(Np):
+        Rnorm[i] = np.linalg.norm(R[i])
+    nonz_index = Rnorm > eps
+    return pol[nonz_index], R[nonz_index]
+
+
+def erroreval(pol, Z, G, cleanflag=True, maxiter=1000, fast=False, complex=True):
+    R, M, residue = get_weight(
+        pol, Z, G, cleanflag=cleanflag, maxiter=maxiter, complex=complex, fast=fast
+    )
+    if len(G.shape) == 1:
+        y = np.linalg.norm(residue)
+        grad = np.real(np.dot(np.conj(residue), (R * (M**2))))
+    else:
+        y = np.linalg.norm(residue.flatten())
+
+        Np = len(pol)
+        grad = np.zeros(Np)
+        Nw = len(Z)
+        for k in range(Np):
+            for w in range(Nw):
+                grad[k] = grad[k] + np.real(
+                    np.sum((M[w, k] ** 2) * (np.conj(residue[w, :, :]) * R[k]))
+                )
+
+    grad = -grad / y
+    return y, grad
+
+
+def pole_fitting(
+    Delta,
+    Z,
+    tol=None,
+    Ns=None,
+    mmin=None,
+    mmax=50,
+    maxiter=50,
+    solver="lstsq",
+    fast=False,
+    disp=False,
+    complex=True,
+):
+    # set cleanflag
+    if solver == "lstsq":
+        cleanflag = True
+    if solver == "sdp":
+        cleanflag = False
+
+    # pole estimation
+    # tol needs to be fixed
+    if Ns is None and tol is None:
+        raise Exception(
+            "One needs to specify either the number of poles or the fitting error tolerance."
+        )
+    if Ns is not None and tol is not None:
+        raise Exception(
+            "One can not specify both the number of poles and the fitting error tolerance. Only specify one of them."
+        )
+    if Ns is None:
+        if mmin is None or mmin < 4:
+            mmin = 4
+        if mmin % 2 == 1:
+            mmin = mmin + 1
+        if mmax > 2 * (Z.shape[0] // 2):
+            mmax = 2 * (Z.shape[0] // 2)
+    else:
+        if Ns % 2 == 1:
+            Ns = Ns + 1
+        mmin, mmax = Ns, Ns
+    if len(Delta.shape) == 1:
+        Delta = Delta.reshape(Delta.shape[0], 1, 1)
+
+    for m in range(mmin, mmax + 1, 2):
+        pol, _, _, _ = aaa_matrix_real(Delta, 1j * Z, mmax=m)
+        pol = np.real(pol)
+        weight, _, residue = get_weight(
+            pol, 1.0j * Z, Delta, cleanflag=cleanflag, complex=complex, fast=fast
+        )
+        # print(np.max(np.abs(residue)))
+        if tol is not None:
+            if np.max(np.abs(residue)) > tol * 10:
+                continue
+        if Ns is None:
+            pol, weight = aaa_reduce(pol, weight, 1e-5)
+        # print("Number of poles is ", len(pol))
+        if cleanflag:
+            if maxiter > 0:
+
+                def fhere(pole):
+                    return erroreval(
+                        pole, 1j * Z, Delta, cleanflag=cleanflag, complex=complex
+                    )
+
+                # fhere = lambda pole: erroreval(pole,1j*Z,Delta,cleanflag=cleanflag,complex=complex)
+                res = scipy.optimize.minimize(
+                    fhere,
+                    pol,
+                    method="L-BFGS-B",
+                    jac=True,
+                    options={
+                        "disp": disp,
+                        "maxiter": maxiter,
+                        "gtol": 1e-10,
+                        "ftol": 1e-10,
+                    },
+                )
+        else:
+
+            def fhere1(pole):
+                return erroreval(pole, 1j * Z, Delta, cleanflag=True, complex=complex)
+
+            # fhere = lambda pole: erroreval(pole,1j*Z,Delta,cleanflag=True,complex=complex)
+            res = scipy.optimize.minimize(
+                fhere1,
+                pol,
+                method="L-BFGS-B",
+                jac=True,
+                options={"disp": False, "gtol": 1e-10, "ftol": 1e-10},
+            )
+            if maxiter > 0:
+
+                def fhere2(pole):
+                    return erroreval(
+                        pole, 1j * Z, Delta, cleanflag=False, complex=complex, fast=fast
+                    )
+
+                # fhere = lambda pole: erroreval(pole,1j*Z,Delta,cleanflag=False,complex= complex,fast = fast)
+                res = scipy.optimize.minimize(
+                    fhere2,
+                    res.x,
+                    method="L-BFGS-B",
+                    jac=True,
+                    options={
+                        "disp": disp,
+                        "maxiter": maxiter,
+                        "gtol": 1e-10,
+                        "ftol": 1e-10,
+                    },
+                )
+
+        weight, _, residuenew = get_weight(
+            res.x, 1j * Z, Delta, cleanflag=cleanflag, fast=fast, complex=complex
+        )
+        if not check_psd(weight):
+            weight, _, residuenew = get_weight(
+                res.x, 1j * Z, Delta, cleanflag=False, complex=complex
+            )
+        err = np.max(np.abs(residuenew))
+        if tol is not None:
+            if err < tol:
+                return res.x, weight, err
+        else:
+            return res.x, weight, err
+
+    if tol is not None:
+        print("Fail to reach desired fitting error!")
+    return res.x, weight, np.max(np.abs(residuenew))
+
+
+def check_psd(weight, atol=1e-6):
+    check_psd = True
+    for i in range(weight.shape[0]):
+        val, _ = np.linalg.eig(weight[i])
+        check_psd = check_psd and np.min(val.real) > -atol
+    return check_psd

adapol-0.1.0/src/adapol/hybfit.py

@@ -0,0 +1,229 @@
+import numpy as np
+from .fit_utils import pole_fitting, eval_with_pole
+
+def hybfit(
+    Delta,
+    iwn_vec,
+    tol=None,
+    Np=None,
+    svdtol=1e-7,
+    solver="lstsq",
+    maxiter=500,
+    mmin=4,
+    mmax=50,
+    verbose=False,
+):
+    """
+    The function for hybridization fitting.
+
+    Examples:
+    ----------
+
+        -  Fitting with :math:`N_p` poles:
+            :code:`hybfit(Delta, iwn_vec, Np = Np)` 
+
+        - Fitting with fixed error tolerance tol :
+            :code:`hybfit(Delta, iwn_vec, tol = tol)` 
+
+    Parameters:
+    ------------
+    :code:`Delta`: np.array, :math:`(N_w, N_\mathrm{orb}, N_\mathrm{orb})`
+        The input hybridization function in Matsubara frequency.
+
+    :code:`iwn_vec`: np.array, :math:`(N_w)`
+        The Matsubara frequency vector, complex-valued 
+
+    :code:`svdtol`: float, optional
+        Truncation threshold for bath orbitals while doing SVD of weight matrices in hybridization fitting
+        default:1e-7
+
+    :code:`tol`, :code:`Np`, :code:`solver`, :code:`maxiter`, :code:`mmin`, :code:`mmax`, :code:`verbose`: 
+        see below in anacont
+
+
+    Returns:
+    ---------
+
+
+    :code:`bathenergy` :math:`E`: np.array, :math:`(N_b)`
+        Bath energy
+
+    :code:`bathhyb` :math:`V`: np.array, :math:`(N_b,N_{\mathrm{orb}})` 
+        Bath hybridization
+
+    :code:`final_error`: float
+        final fitting error
+
+    :code:`func`: function
+        Hybridization function evaluator
+        :math:`f(z) = \sum_n V_{ni}V_{nj}^*/(z-E_n).`
+
+    """
+
+   
+    # Check dimensions
+    assert len(iwn_vec.shape) == 1 or len(iwn_vec.shape) == 2
+    if len(iwn_vec.shape) == 2:
+        assert iwn_vec.shape[1] == 1
+        iwn_vec = iwn_vec.flatten()
+    assert len(Delta.shape) == 3 or len(Delta.shape) == 1
+    if len(Delta.shape) == 1:
+        assert Delta.shape[0] == iwn_vec.shape[0]
+        Delta = Delta[:, None, None]
+    if len(Delta.shape) == 3:
+        assert Delta.shape[0] == iwn_vec.shape[0]
+        assert Delta.shape[1] == Delta.shape[2]
+
+    solver = solver.lower()
+    assert solver == "lstsq" or solver == "sdp"
+
+    # Check input tol or Np
+    if tol is None and Np is None:
+        raise ValueError("Please specify either tol or Np")
+    if tol is not None and Np is not None:
+        raise ValueError(
+            "Please specify either tol or Np. One can not specify both of them."
+        )
+    
+    wn_vec = np.imag(iwn_vec)
+
+    if Np is not None:
+        pol, weight, fitting_error = pole_fitting(
+            Delta, wn_vec, Ns=Np + 1, maxiter=maxiter, solver=solver, disp=verbose
+        )
+    elif tol is not None:
+        pol, weight, fitting_error = pole_fitting(
+            Delta,
+            wn_vec,
+            tol=tol,
+            mmin=mmin,
+            mmax=mmax,
+            maxiter=maxiter,
+            solver=solver,
+            disp=verbose,
+        )
+
+    bathenergy, bathhyb, bath_mat = obtain_orbitals(pol, weight, svdtol=svdtol)
+    def func(Z):
+        return eval_with_pole(bathenergy, Z, bath_mat)
+    Delta_reconstruct = func(iwn_vec)
+    final_error = np.max(np.abs(Delta - Delta_reconstruct))
+    return bathenergy, bathhyb, final_error, func
+
+
+def hybfit_triqs(
+    Delta_triqs,
+    tol=None,
+    Np=None,
+    svdtol=1e-7,
+    solver="lstsq",
+    maxiter=500,
+    mmin=4,
+    mmax=50,
+    verbose=False,
+    debug=False
+):
+    """
+    The triqs interface for hybridization fitting.
+    The function requires triqs package in python.
+
+    Examples:
+    ----------
+
+        -  Fitting with :math:`N_p` poles:
+            :code:`hybfit_triqs(delta_triqs, Np = Np)` 
+
+        - Fitting with fixed error tolerance tol :
+            :code:`hybfit_triqs(delta_triqs, tol = tol)` 
+
+
+    Parameters:
+    ------------
+    :code:`Delta_triqs`: triqs Green's function container
+        The input hybridization function in Matsubara frequency
+
+    :code:`debug`: bool
+        return additional outputs for debugging.
+        Default: False
+
+    :code:`svdtol`: float, optional
+        Truncation threshold for bath orbitals while doing SVD of weight matrices in hybridization fitting
+        default: 1e-7
+
+    :code:`tol`, :code:`Np`, :code:`solver`, :code:`maxiter`, :code:`mmin`, :code:`mmax`, :code:`verbose`: 
+        same as in hybfit
+
+    Returns:
+    ---------
+
+    :code:`bathhyb`: np.array :math:`(N_b, N_\mathrm{orb})`
+        Bath hybridization
+
+    :code:`bathenergy`: np.array :math:`(N_b,)`
+        Bath energy
+
+    :code:`Delta_fit`: triqs Gf or BlockGf
+        Discretized hybridization function
+        The input hybridization function in Matsubara frequency
+
+    if debug is True:
+        :code:`final_error`: float
+            final fitting error
+
+        :code:`weight`: np.array :math:`(N_p, N_\mathrm{orb}, N_\mathrm{orb})`
+            weights obtained from fitting
+    """
+    try:
+        from triqs.gf import Gf, BlockGf, MeshImFreq, MeshDLRImFreq
+    except ImportError:
+        raise ImportError("Failed to import the triqs package (https://triqs.github.io/triqs/latest/). "
+                          "Please ensure it is installed.")
+
+    if isinstance(Delta_triqs, Gf) and isinstance(Delta_triqs.mesh, (MeshImFreq, MeshDLRImFreq)):
+        iwn_vec = np.array([iw.value for iw in Delta_triqs.mesh.values()])
+        eps_opt, V_opt, final_error, func = hybfit(Delta_triqs.data, iwn_vec, tol, Np,
+                                                   svdtol, solver, maxiter, mmin, mmax, verbose)
+        print('optimization finished with fitting error {:.3e}'.format(final_error))
+
+        delta_fit = Gf(mesh=Delta_triqs.mesh, target_shape=Delta_triqs.target_shape)
+        delta_fit.data[:] = func(iwn_vec)
+
+        if debug:
+            return V_opt.T.conj(), eps_opt, delta_fit, final_error
+        else:
+            return V_opt.T.conj(), eps_opt, delta_fit
+    elif isinstance(Delta_triqs, BlockGf) and isinstance(Delta_triqs.mesh, (MeshImFreq, MeshDLRImFreq)):
+        V_list, eps_list, delta_list, error_list = [], [], [], []
+        for j, (block, delta_blk) in enumerate(Delta_triqs):
+            res = hybfit_triqs(delta_blk, tol, Np, svdtol, solver, maxiter, mmin, mmax, verbose, debug)
+            V_list.append(res[0])
+            eps_list.append(res[1])
+            delta_list.append(res[2])
+            if debug:
+                error_list.append(res[3])
+
+        if debug:
+            return V_list, eps_list, BlockGf(name_list=list(Delta_triqs.indices), block_list=delta_list), error_list
+        else:
+            return V_list, eps_list, BlockGf(name_list=list(Delta_triqs.indices), block_list=delta_list)
+    else:
+        raise RuntimeError("Error: Delta_triqs.mesh must be an instance of MeshImFreq or MeshDLRImFreq.")
+
+def obtain_orbitals(pol, weight, svdtol=1e-7):
+    """
+    obtaining bath orbitals through svd
+    """
+    polelist = []
+    veclist = []
+    matlist = []
+    for i in range(weight.shape[0]):
+        eigval, eigvec = np.linalg.eig(weight[i])
+        for j in range(eigval.shape[0]):
+            if eigval[j] > svdtol:
+                polelist.append(pol[i])
+                veclist.append(eigvec[:, j] * np.sqrt(eigval[j]))
+                matlist.append(
+                    (eigvec[:, j, None] * np.conjugate(eigvec[:, j].T)) * (eigval[j])
+                )
+
+    return np.array(polelist), np.array(veclist), np.array(matlist)

adapol-0.1.0/src/adapol.egg-info/PKG-INFO

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: adapol
+Version: 0.1.0
+Summary: Adaptive Pole Fitting for Quantum Many-Body Physics 
+Author-email: Zhen Huang <hertz@berkeley.edu>, Chia-Nan Yeh <cyeh@flatironinstitute.org>, Nils Wentzell <nwentzell@flatironinstitute.org>, Jason Kaye <jkaye@flatironinstitute.org>, Lin Lin <linlin@berkeley.edu>
+Project-URL: Homepage, https://flatironinstitute.github.io/adapol
+Project-URL: Bug Tracker, https://github.com/flatironinstitute/adapol/issues
+Keywords: Bath,Fitting,Hybridization,DMFT,Matsubara
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: cvxpy
+
+# adapol: Adaptive Pole Fitting for Quantum Many-Body Physics
+[`adapol`](https://github.com/Hertz4/Adapol) (pronounced "add a pole") is a python package for fitting Matsubara functions with the following form:
+```math
+G(\mathrm i \omega_k) = \sum_l \frac{V_lV_l^{\dagger}}{\mathrm i\omega_k - E_l}.
+```
+
+Current applications include
+(1) hybridization fitting, (2) analytic continuation.
+
+We also provide a [TRIQS](https://triqs.github.io/) interface if the Matsubara functions are stored in `triqs` Green's function container.
+
+# Installation
+`adapol` has `numpy` and `scipy` as its prerequisites. [`cvxpy`](https://www.cvxpy.org/) is also required for hybridization fitting of matrix-valued (instead of scalar-valued) Matsubara functions.
+
+To install `adapol`, run
+```terminal
+pip install adapol
+```
+
+
+
+# Documentation
+
+See the detailed [documentation](https://flatironinstitute.github.io/adapol/) for physical background, algorithms and user manual.
+
+`Adapol` is a stand-alone package. For TRIQS users, we also provide a TRIQS interface. See [user manual](https://flatironinstitute.github.io/adapol/latest/python.html#triqs-interface) for details.
+
+# Examples
+In the `tutorial` page, we provide two examples [`discrete.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/discrete.html) and [`semicircle.ipynb`](https://flatironinstitute.github.io/adapol/latest/tutorials/semicircle.html), showcasing how to use `adapol` for both discrete spectrum and continuous spectrum.
+
+In these notebooks, we also demonstrate how to use our code through the triqs interface.
+
+# References
+To cite this work, please include a reference to this GitHub repository, and
+cite the following references:
+
+1. Huang, Zhen, Emanuel Gull, and Lin Lin. "Robust analytic continuation of Green's functions via projection, pole estimation, and semidefinite relaxation." Physical Review B 107.7 (2023): 075151.
+2. Mejuto-Zaera, Carlos, et al. "Efficient hybridization fitting for dynamical mean-field theory via semi-definite relaxation." Physical Review B 101.3 (2020): 035143.
+3. Nakatsukasa, Yuji, Olivier Sète, and Lloyd N. Trefethen. "The AAA algorithm for rational approximation." SIAM Journal on Scientific Computing 40.3 (2018): A1494-A1522.

adapol-0.1.0/src/adapol.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+MANIFEST.in
+README.md
+pyproject.toml
+src/adapol/__init__.py
+src/adapol/aaa.py
+src/adapol/anacont.py
+src/adapol/fit_utils.py
+src/adapol/hybfit.py
+src/adapol.egg-info/PKG-INFO
+src/adapol.egg-info/SOURCES.txt
+src/adapol.egg-info/dependency_links.txt
+src/adapol.egg-info/requires.txt
+src/adapol.egg-info/top_level.txt

adapol-0.1.0/src/adapol.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

adapol-0.1.0/src/adapol.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy
+scipy
+cvxpy

adapol-0.1.0/src/adapol.egg-info/top_level.txt

@@ -0,0 +1 @@
+adapol