quant-met 0.0.23__py3-none-any.whl → 0.0.24__py3-none-any.whl

quant_met/cli/_utils.py

@@ -41,7 +41,11 @@ def _tbl_factory(h: BaseHamiltonian[GenericParameters]) -> TBLattice:
         0.5 * lattice_constant * np.array([1, np.sqrt(3), 0]),
         0.5 * lattice_constant * np.array([1, -np.sqrt(3), 0]),
     ]
-    orbital_positions = [(0, 0.5, 0), (0, -0.5, 0), (0, -0.5, 0)]
+    orbital_positions = [
+        (0.5 * (np.sqrt(3) - 1), 0, 0),
+        (0.5 * (np.sqrt(3) + 1), 0, 0),
+        (0.5 * (np.sqrt(3) - 1), 0, 0),
+    ]
     hoppings = {
         (0, 0): [
             [0, h.hopping_gr, h.hopping_x_gr_a],
@@ -50,13 +54,13 @@ def _tbl_factory(h: BaseHamiltonian[GenericParameters]) -> TBLattice:
         ],
         (1, 0): [[0, 0, 0], [h.hopping_gr, 0, 0], [0, 0, 0]],
         (-1, 0): [[0, h.hopping_gr, 0], [0, 0, 0], [0, 0, 0]],
-        (0, 1): [[0, 0, 0], [h.hopping_gr, 0, 0], [0, 0, 0]],
-        (0, -1): [[0, h.hopping_gr, 0], [0, 0, 0], [0, 0, 0]],
+        (0, 1): [[0, h.hopping_gr, 0], [0, 0, 0], [0, 0, 0]],
+        (0, -1): [[0, 0, 0], [h.hopping_gr, 0, 0], [0, 0, 0]],
     }
 
     return TBLattice(
         units=basis_vectors,
         hoppings=hoppings,
         orbital_positions=orbital_positions,
-        orbital_names=["C1", "C2", "X"],
+        orbital_names=["A", "B", "X"],
     )

quant_met/cli/dmft.py

@@ -8,7 +8,8 @@ import logging
 from pathlib import Path
 
 from h5 import HDFArchive
-from triqs.gf import Gf, Idx
+from mpi4py import MPI
+from triqs.gf import Gf
 
 from quant_met.cli._utils import _hamiltonian_factory, _tbl_factory
 from quant_met.dmft.dmft_loop import dmft_loop
@@ -43,7 +44,13 @@ def dmft_scf(parameters: Parameters) -> None:
         h0_nambu_k[k][:n_orbitals, :n_orbitals] = enk(k)
         h0_nambu_k[k][n_orbitals:, n_orbitals:] = -enk(-k)
 
-    xmu = -h.hubbard_int_orbital_basis[0] / 2
+    ust = 0
+    jh = 0
+    xmu = (
+        h.hubbard_int_orbital_basis[0] / 2
+        + (tbl.n_orbitals - 1) * ust / 2
+        + (tbl.n_orbitals - 1) * (ust - jh) / 2
+    )
 
     solver = dmft_loop(
         tbl=tbl,
@@ -69,23 +76,21 @@ def dmft_scf(parameters: Parameters) -> None:
     g_iw, g_an_iw = get_gloc(s_iw, s_an_iw, h0_nambu_k, xmu, parameters.control.broadening, kmesh)
     g_w, g_an_w = get_gloc(s_w, s_an_w, h0_nambu_k, xmu, parameters.control.broadening, kmesh)
 
-    n_iw0 = int(0.5 * len(s_iw.mesh))
-    iw_0 = s_iw.mesh[n_iw0].value.imag
-
-    gap = s_an_iw[Idx(0)][0, 0].real / (1 - (s_iw[Idx(0)][0, 0].imag / iw_0))
+    comm = MPI.COMM_WORLD
+    rank = comm.Get_rank()
 
-    data_dir = Path("data/DressedGraphene/dmft/sweep_V/")
-    data_dir.mkdir(parents=True, exist_ok=True)
+    if rank == 0:
+        data_dir = Path("data/DressedGraphene/dmft/sweep_V/")
+        data_dir.mkdir(parents=True, exist_ok=True)
 
-    # Save calculation results
-    result_file = result_path / f"{parameters.control.prefix}.hdf5"
-    with HDFArchive(f"{result_file}", "w") as ar:
-        ar["s_iw"] = s_iw
-        ar["s_an_iw"] = s_an_iw
-        ar["g_iw"] = g_iw
-        ar["g_an_iw"] = g_an_iw
-        ar["g_w"] = g_w
-        ar["g_an_w"] = g_an_w
-        ar["gap"] = gap
+        # Save calculation results
+        result_file = result_path / f"{parameters.control.prefix}.hdf5"
+        with HDFArchive(f"{result_file}", "w") as ar:
+            ar["s_iw"] = s_iw
+            ar["s_an_iw"] = s_an_iw
+            ar["g_iw"] = g_iw
+            ar["g_an_iw"] = g_an_iw
+            ar["g_w"] = g_w
+            ar["g_an_w"] = g_an_w
 
-    logger.info("Results saved to %s", result_file)
+        logger.info("Results saved to %s", result_file)

quant_met/dmft/dmft_loop.py

@@ -18,7 +18,7 @@ from triqs.operators import c, c_dag, dagger, n
 from quant_met.mean_field.hamiltonians import BaseHamiltonian
 from quant_met.parameters import GenericParameters
 
-from .utils import _dmft_weiss_field, get_gloc
+from .utils import _check_convergence, _dmft_weiss_field, get_gloc
 
 logger = logging.getLogger(__name__)
 
@@ -80,8 +80,27 @@ def dmft_loop(
         h_loc[o1, o2] * c_dag(spin, o1) * c(spin, o2) for spin, o1, o2 in product(spins, orbs, orbs)
     )
 
+    ust = 0
+    jh = 0
+    jx = 0
+    jp = 0
+
     # Interaction part
-    hamiltonian += -h.hubbard_int_orbital_basis[0] * sum(n("up", o) * n("dn", o) for o in orbs)
+    hamiltonian += h.hubbard_int_orbital_basis[0] * sum(n("up", o) * n("dn", o) for o in orbs)
+    hamiltonian += ust * sum(
+        int(o1 != o2) * n("up", o1) * n("dn", o2) for o1, o2 in product(orbs, orbs)
+    )
+    hamiltonian += (ust - jh) * sum(
+        int(o1 < o2) * n(s, o1) * n(s, o2) for s, o1, o2 in product(spins, orbs, orbs)
+    )
+    hamiltonian -= jx * sum(
+        int(o1 != o2) * c_dag("up", o1) * c("dn", o1) * c_dag("dn", o2) * c("up", o2)
+        for o1, o2 in product(orbs, orbs)
+    )
+    hamiltonian += jp * sum(
+        int(o1 != o2) * c_dag("up", o1) * c_dag("dn", o1) * c("dn", o2) * c("up", o2)
+        for o1, o2 in product(orbs, orbs)
+    )
 
     # Matrix dimensions of eps and V: 3 orbitals x 2 bath states
     eps = np.array([[-1.0, -0.5, 0.5, 1.0] for _ in range(tbl.n_orbitals)])
@@ -119,8 +138,6 @@ def dmft_loop(
         bath_fitting_params=fit_params,
     )
 
-    gooditer = 0
-    g0_prev = np.zeros((2, 2 * n_iw, tbl.n_orbitals, tbl.n_orbitals), dtype=complex)
     for iloop in range(max_iter):
         print(f"\nLoop {iloop + 1} of {max_iter}")
 
@@ -151,39 +168,11 @@ def dmft_loop(
 
         # Check convergence of the Weiss field
         g0 = np.asarray([g0_iw.data, g0_an_iw.data])
-        errvec = np.real(np.sum(abs(g0 - g0_prev), axis=1) / np.sum(abs(g0), axis=1))
-        # First iteration
-        if iloop == 0:
-            errvec = np.ones_like(errvec)
-        errmin, err, errmax = np.min(errvec), np.average(errvec), np.max(errvec)
-
-        g0_prev = np.copy(g0)
-
-        if err < epsilon:
-            gooditer += 1  # Increase good iterations count
-        else:
-            gooditer = 0  # Reset good iterations count
-
-        conv_bool = ((err < epsilon) and (gooditer > n_success) and (iloop < max_iter)) or (
-            iloop >= max_iter
-        )
+        # Check convergence of the Weiss field
+        g0 = np.asarray([g0_iw.data, g0_an_iw.data])
+        err, converged = _check_convergence(g0, epsilon, n_success, max_iter)
 
-        # Print convergence message
-        if iloop < max_iter:
-            if errvec.size > 1:
-                print(f"max error={errmax:.6e}")
-            print("    " * (errvec.size > 1) + f"error={err:.6e}")
-            if errvec.size > 1:
-                print(f"min error={errmin:.6e}")
-        else:
-            if errvec.size > 1:
-                print(f"max error={errmax:.6e}")
-            print("    " * (errvec.size > 1) + f"error={err:.6e}")
-            if errvec.size > 1:
-                print(f"min error={errmin:.6e}")
-            print(f"Not converged after {max_iter} iterations.")
-
-        if conv_bool:
+        if converged:
             break
 
     return solver

quant_met/dmft/utils.py

@@ -4,11 +4,120 @@
 
 """Utility functions used in DMFT."""
 
+import sys
+from pathlib import Path
+
 import numpy as np
 import numpy.typing as npt
+from mpi4py import MPI
 from triqs.gf import Gf, MeshBrZone, MeshImFreq, MeshProduct, conjugate, dyson, inverse, iOmega_n
 
 
+def _check_convergence(
+    func: npt.NDArray[np.complex128], threshold: float = 1e-6, nsuccess: int = 1, nloop: int = 100
+) -> tuple[float, bool]:
+    comm = MPI.COMM_WORLD
+    rank = comm.Get_rank()
+
+    func = np.asarray(func)
+    err = 1.0
+    conv_bool = False
+    outfile = "error.err"
+
+    if globals().get("_whichiter") is None:
+        global _whichiter
+        global _gooditer
+        global _oldfunc
+
+        _whichiter = 0
+        _gooditer = 0
+        _oldfunc = np.zeros_like(func)
+
+    green = "\033[92m"
+    yellow = "\033[93m"
+    red = "\033[91m"
+    bold = "\033[1m"
+    colorend = "\033[0m"
+
+    # only the master does the calculation
+    if rank == 0:
+        errvec = np.real(np.sum(abs(func - _oldfunc), axis=-1) / np.sum(abs(func), axis=-1))
+        # first iteration
+        if _whichiter == 0:
+            errvec = np.ones_like(errvec)
+            # remove nan compoments, if some component is divided by zero
+        if np.prod(np.shape(errvec)) > 1:
+            errvec = errvec[~np.isnan(errvec)]
+        errmax = np.max(errvec)
+        errmin = np.min(errvec)
+        err = np.average(errvec)
+        _oldfunc = np.copy(func)
+        if err < threshold:
+            _gooditer += 1  # increase good iterations count
+        else:
+            _gooditer = 0  # reset good iterations count
+        _whichiter += 1
+        conv_bool = ((err < threshold) and (_gooditer > nsuccess) and (_whichiter < nloop)) or (
+            _whichiter >= nloop
+        )
+
+        # write out
+        with Path(outfile).open("a") as file:
+            file.write(f"{_whichiter} {err:.6e}\n")
+        if np.prod(np.shape(errvec)) > 1:
+            with Path(outfile + ".max").open("a") as file:
+                file.write(f"{_whichiter} {errmax:.6e}\n")
+            with Path(outfile + ".min").open("a") as file:
+                file.write(f"{_whichiter} {errmin:.6e}\n")
+            with Path(outfile + ".distribution").open("a") as file:
+                file.write(
+                    f"{_whichiter}" + " ".join([f"{x:.6e}" for x in errvec.flatten()]) + "\n"
+                )
+
+        # print convergence message:
+        if conv_bool:
+            colorprefix = bold + green
+        elif (err < threshold) and (_gooditer <= nsuccess):
+            colorprefix = bold + yellow
+        else:
+            colorprefix = bold + red
+
+        if _whichiter < nloop:
+            if np.prod(np.shape(errvec)) > 1:
+                print(colorprefix + "max error=" + colorend + f"{errmax:.6e}")
+            print(
+                colorprefix
+                + "    " * (np.prod(np.shape(errvec)) > 1)
+                + "error="
+                + colorend
+                + f"{err:.6e}"
+            )
+            if np.prod(np.shape(errvec)) > 1:
+                print(colorprefix + "min error=" + colorend + f"{errmin:.6e}")
+        else:
+            if np.prod(np.shape(errvec)) > 1:
+                print(colorprefix + "max error=" + colorend + f"{errmax:.6e}")
+            print(
+                colorprefix
+                + "    " * (np.prod(np.shape(errvec)) > 1)
+                + "error="
+                + colorend
+                + f"{err:.6e}"
+            )
+            if np.prod(np.shape(errvec)) > 1:
+                print(colorprefix + "min error=" + colorend + f"{errmin:.6e}")
+            print("Not converged after " + str(nloop) + " iterations.")
+            with Path("ERROR.README").open("a") as file:
+                file.write("Not converged after " + str(nloop) + " iterations.")
+        print("\n")
+
+    # pass to other cores:
+    conv_bool = comm.bcast(conv_bool, root=0)
+    err = comm.bcast(err, root=0)
+    sys.stdout.flush()
+    return err, conv_bool
+
+
 def get_gloc(
     s: Gf,
     s_an: Gf,

quant_met/mean_field/hamiltonians/base_hamiltonian.py

@@ -359,7 +359,7 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
     def gap_equation_loop(
         bdg_energies: npt.NDArray[np.float64],
         bdg_wavefunctions: npt.NDArray[np.complex128],
-        delta: npt.NDArray[np.float64],
+        delta: npt.NDArray[np.complex128],
         beta: float,
         hubbard_int_orbital_basis: npt.NDArray[np.float64],
         k: npt.NDArray[np.floating],
@@ -390,16 +390,18 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
             New pairing gap in orbital basis, adjusted to remove global phase.
         """
         number_of_bands = len(delta)
+
+        result_matrix = np.zeros((2 * number_of_bands, 2 * number_of_bands), dtype=np.complex128)
+        for k_index in range(len(k)):
+            nf = np.eye(2 * number_of_bands, 2 * number_of_bands, dtype=np.complex128) * (
+                fermi_dirac(bdg_energies[k_index], beta)
+            )
+            result_matrix += bdg_wavefunctions[k_index].conj().T @ nf @ bdg_wavefunctions[k_index]
+
         for i in range(number_of_bands):
-            sum_tmp = 0
-            for j in range(2 * number_of_bands):
-                for k_index in range(len(k)):
-                    sum_tmp += (
-                        np.conjugate(bdg_wavefunctions[k_index, i, j])
-                        * bdg_wavefunctions[k_index, i + number_of_bands, j]
-                        * fermi_dirac(bdg_energies[k_index, j].item(), beta)
-                    )
-            delta[i] = (-hubbard_int_orbital_basis[i] * sum_tmp / len(k)).conjugate()
+            delta[i] = (
+                -hubbard_int_orbital_basis[i] * result_matrix[i, i + number_of_bands] / len(k)
+            )
 
         delta_without_phase: npt.NDArray[np.complexfloating] = delta * np.exp(
             -1j * np.angle(delta[np.argmax(np.abs(delta))])

quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -48,9 +48,13 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
 
         h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex128)
 
-        h[:, 0, 1] = -t_gr * (
-            np.exp(1j * k[:, 1] * a / np.sqrt(3))
-            + 2 * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * (np.cos(0.5 * a * k[:, 0]))
+        h[:, 0, 1] = (
+            -t_gr
+            * np.exp(2j * k[:, 1] * a)
+            * (
+                np.exp(1j * k[:, 1] * a / np.sqrt(3))
+                + 2 * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * (np.cos(0.5 * a * k[:, 0]))
+            )
         )
 
         h[:, 1, 0] = h[:, 0, 1].conjugate()

{quant_met-0.0.23.dist-info → quant_met-0.0.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quant-met
-Version: 0.0.23
+Version: 0.0.24
 Summary: Calculate superconductivity in flat-band systems.
 Author-email: Tjark Sievers <tsievers@physnet.uni-hamburg.de>
 License-File: LICENSE.txt

{quant_met-0.0.23.dist-info → quant_met-0.0.24.dist-info}/RECORD

@@ -1,14 +1,14 @@
 quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
 quant_met/utils.py,sha256=J3kCbKg0tPEoGJExX04QwifHn4ch482J8IcmRQxIfP4,2067
 quant_met/cli/__init__.py,sha256=nGFXhK8zWyEKQtsQTyJWfEOLFOHTCjZnfEcrVb2dARc,254
-quant_met/cli/_utils.py,sha256=vGXWDXqs15F4MiU-gRk4lHdmP7FB8vQQXuvbx-sesyE,1952
+quant_met/cli/_utils.py,sha256=MKHvkxudWH-px07lDz0_V1AWiCCvj_IsBYbocfL-r7Y,2036
 quant_met/cli/crit_temp.py,sha256=t9sPZKORl6dpa1UNAOMH2gDmeQxf80iFH7p_L3FI5q8,2027
-quant_met/cli/dmft.py,sha256=Wvh1aeJaHhrW9gttI05VaUQqDFhSMWrhLgIrZJ9Hmbs,3017
+quant_met/cli/dmft.py,sha256=ct6e1Wd8o7V3VP7DB7pqPxyF5pbrR2mb-J8pUkP9UPE,3101
 quant_met/cli/main.py,sha256=1D1-KhGkzibts9b7Cv3JsR5Q-PnkowBWKE1Owc8tdD8,2010
 quant_met/cli/scf.py,sha256=3_rwtQHwypFjAwjrsO2r2sqjJKpNiDLAj6svU52CCcU,2613
 quant_met/dmft/__init__.py,sha256=2H0bN40Tvn-VnZgix6MugN0Q6iNwD_9AQxUC_LVLh70,99
-quant_met/dmft/dmft_loop.py,sha256=N5EmcwV08cHumhtgMjwE4DUuhJnkIoBoyMsf5lrw0IY,5738
-quant_met/dmft/utils.py,sha256=z9Y9EP_V8_Bj7NIvz_GSnaQ7tha7QwqtJsEYhKIEoxQ,2897
+quant_met/dmft/dmft_loop.py,sha256=fH8v39I5yIY2iY5RaID43El1V0nxLewAfohNsq987_A,5272
+quant_met/dmft/utils.py,sha256=JO66kuTXruYCwNoVL0aFS55D3tV7Ii3v7hC9OpuWfF8,6636
 quant_met/geometry/__init__.py,sha256=2N8l0-2-PhEOQxaUO7e8Dqy5oaxt2y9343XENDTCGPE,592
 quant_met/geometry/base_lattice.py,sha256=OJNDMyzJB-0hK1BLgF-SV4jUYfOSUksIv1XG1bH-zyY,2649
 quant_met/geometry/bz_path.py,sha256=vwN5RxyrgFkHTSqm_6cWuOigICgxa-FX5NZ7SkgKScw,2503
@@ -19,8 +19,8 @@ quant_met/mean_field/_utils.py,sha256=7hr0DDSdIqjft5Jjluvbw_HGoNLWgYJTxyuPJJvhBn
 quant_met/mean_field/search_crit_temp.py,sha256=Z9te3O7zsyBGLRrPjmNA85vxHOfBfIQ7svdDVFEJedg,8782
 quant_met/mean_field/self_consistency.py,sha256=YY_zhCurxOK3RLkK-Hglfkx33uhsvqpoAKOP4FuPdfo,3371
 quant_met/mean_field/hamiltonians/__init__.py,sha256=r-8TaLqRnRbAro-TMIyxzCCZHwVqyKrausODpQJb2tw,681
-quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=xoSpPy5qUXN3jCB6M6mh9oshDPLFfw8kbWBo1VsGGUw,29371
-quant_met/mean_field/hamiltonians/dressed_graphene.py,sha256=Q5LiA3rgK88ZZV1V7JflgjlkEpve7uNZFzFCIoQND-w,4048
+quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=Qd1V5PAEPCxoKYRVfh11og6ZzrdMtH5hDn2GyRelFNE,29422
+quant_met/mean_field/hamiltonians/dressed_graphene.py,sha256=iPQshQqvtWf-NbeSdn8VbtuSU1g7maKUjFPfoji8zwk,4135
 quant_met/mean_field/hamiltonians/graphene.py,sha256=sa3H8jVq9Fkc_qcz5gJTCMgN8YD3N18JWLRBImhLyxo,3276
 quant_met/mean_field/hamiltonians/one_band_tight_binding.py,sha256=DZXaD95yWv1VZSMqgxkqEZv3PGihNGy7PuqupnN75ew,2512
 quant_met/mean_field/hamiltonians/three_band_tight_binding.py,sha256=g8XNImzCn_6CRYKDYI6sy3q6_TBYUDxDmQZ-AqenXTE,3295
@@ -30,8 +30,8 @@ quant_met/parameters/hamiltonians.py,sha256=PiWVV-miCdT4Z9GWloDVvIU_1QpRHHV-zVOg
 quant_met/parameters/main.py,sha256=QP7Z24-QePMcy6txujqxbx5ztQTdC67m6elNsJtGtXQ,2325
 quant_met/plotting/__init__.py,sha256=IDgV6juJ0VfcJHppD-vnPH6w8wVuAC35eSeLxKzqyBc,523
 quant_met/plotting/plotting.py,sha256=4ZYclWJH3hlE8S7b7bL_JJlP3CKaCGcVzdIsqolCAaM,6592
-quant_met-0.0.23.dist-info/METADATA,sha256=BbEabzGecrsI-bBaE4_1sLPXY3OUXUuedHcLfybvb1U,1978
-quant_met-0.0.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-quant_met-0.0.23.dist-info/entry_points.txt,sha256=1Al3Kt-cMeQxwMp84ZSNL0qFwlbOVBu1o8A19MH8lEU,48
-quant_met-0.0.23.dist-info/licenses/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.23.dist-info/RECORD,,
+quant_met-0.0.24.dist-info/METADATA,sha256=39K98j0y8EPTNQDt7unKVyD4ibrIeTkDQExEkVJvZCU,1978
+quant_met-0.0.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quant_met-0.0.24.dist-info/entry_points.txt,sha256=1Al3Kt-cMeQxwMp84ZSNL0qFwlbOVBu1o8A19MH8lEU,48
+quant_met-0.0.24.dist-info/licenses/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.24.dist-info/RECORD,,