quant-met 0.0.19__py3-none-any.whl → 0.0.21__py3-none-any.whl

quant_met/cli/_utils.py

@@ -2,8 +2,11 @@
 #
 # SPDX-License-Identifier: MIT
 
+import numpy as np
+from triqs.lattice.tight_binding import TBLattice
+
 from quant_met.mean_field.hamiltonians import BaseHamiltonian
-from quant_met.parameters import HamiltonianParameters
+from quant_met.parameters import GenericParameters, HamiltonianParameters
 
 
 def _hamiltonian_factory(
@@ -29,3 +32,31 @@ def _hamiltonian_factory(
     cls = getattr(hamiltonians, classname)
     h: BaseHamiltonian[HamiltonianParameters] = cls(parameters)
     return h
+
+
+def _tbl_factory(h: BaseHamiltonian[GenericParameters]) -> TBLattice:
+    lattice_constant = np.sqrt(3)
+
+    basis_vectors = [
+        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)]
+    hoppings = {
+        (0, 0): [
+            [0, h.hopping_gr, h.hopping_x_gr_a],
+            [h.hopping_gr, 0, 0],
+            [h.hopping_x_gr_a, 0, 0],
+        ],
+        (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]],
+    }
+
+    return TBLattice(
+        units=basis_vectors,
+        hoppings=hoppings,
+        orbital_positions=orbital_positions,
+        orbital_names=["C1", "C2", "X"],
+    )

quant_met/cli/dmft.py

@@ -0,0 +1,91 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to run self-consistent calculation for the order parameter."""
+
+import logging
+from pathlib import Path
+
+from h5 import HDFArchive
+from triqs.gf import Gf, Idx
+
+from quant_met.cli._utils import _hamiltonian_factory, _tbl_factory
+from quant_met.dmft.dmft_loop import dmft_loop
+from quant_met.dmft.utils import get_gloc
+from quant_met.parameters import Parameters
+
+logger = logging.getLogger(__name__)
+
+
+def dmft_scf(parameters: Parameters) -> None:
+    """Self-consistent calculation for the order parameter.
+
+    Parameters
+    ----------
+    parameters: Parameters
+        An instance of Parameters containing control settings, the model,
+        and k-point specifications for the self-consistency calculation.
+    """
+    result_path = Path(parameters.control.outdir)
+    result_path.mkdir(exist_ok=True, parents=True)
+
+    h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
+    tbl = _tbl_factory(h=h)
+
+    kmesh = tbl.get_kmesh(n_k=(parameters.k_points.nk1, parameters.k_points.nk2, 1))
+
+    enk = tbl.fourier(kmesh)
+    n_orbitals = tbl.n_orbitals
+    nambu_shape = (2 * n_orbitals, 2 * n_orbitals)
+    h0_nambu_k = Gf(mesh=kmesh, target_shape=nambu_shape)
+    for k in kmesh:
+        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
+
+    solver = dmft_loop(
+        tbl=tbl,
+        h=h,
+        h0_nambu_k=h0_nambu_k,
+        n_bath=parameters.control.n_bath,
+        n_iw=parameters.control.n_iw,
+        broadening=parameters.control.broadening,
+        n_w=parameters.control.n_w,
+        w_mixing=parameters.control.wmixing,
+        n_success=parameters.control.n_success,
+        xmu=xmu,
+        kmesh=kmesh,
+        epsilon=parameters.control.conv_treshold,
+        max_iter=parameters.control.max_iter,
+    )
+
+    # Calculate local Green's function on the real axis
+    s_w = solver.Sigma_w["up"]
+    s_an_w = solver.Sigma_an_w["up_dn"]
+    s_iw = solver.Sigma_iw["up"]
+    s_an_iw = solver.Sigma_an_iw["up_dn"]
+    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))
+
+    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
+
+    logger.info("Results saved to %s", result_file)

quant_met/cli/main.py

@@ -14,6 +14,7 @@ import yaml
 from quant_met.parameters import Parameters
 
 from .crit_temp import crit_temp
+from .dmft import dmft_scf
 from .scf import scf
 
 logger = logging.getLogger(__name__)
@@ -60,6 +61,9 @@ def cli(input_file: TextIO, *, debug: bool) -> None:
         case "crit-temp":
             logger.info("Starting T_C calculation.")
             crit_temp(params)
+        case "dmft-scf":
+            logger.info("Starting DMFT SCF calculation.")
+            dmft_scf(params)
         case _:
             logger.error("Calculation %s not found.", params.control.calculation)
             sys.exit(1)

quant_met/dmft/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2025 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""DMFT package."""

quant_met/dmft/dmft_loop.py

@@ -0,0 +1,189 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to run self-consistent calculation for the order parameter."""
+
+import logging
+from itertools import product
+
+import numpy as np
+import numpy.typing as npt
+from triqs.gf import BlockGf, Gf, MeshBrZone
+from triqs.lattice.tight_binding import TBLattice
+from triqs.operators import c, c_dag, dagger, n
+
+from edipack2triqs.fit import BathFittingParams
+from edipack2triqs.solver import EDIpackSolver
+from quant_met.mean_field.hamiltonians import BaseHamiltonian
+from quant_met.parameters import GenericParameters
+
+from .utils import _dmft_weiss_field, get_gloc
+
+logger = logging.getLogger(__name__)
+
+
+def dmft_loop(
+    tbl: TBLattice,
+    h: BaseHamiltonian[GenericParameters],
+    h0_nambu_k: Gf,
+    n_bath: float,
+    n_iw: int,
+    broadening: float,
+    n_w: int,
+    w_mixing: float,
+    n_success: int,
+    xmu: npt.NDArray[np.float64],
+    kmesh: MeshBrZone,
+    epsilon: float,
+    max_iter: int,
+) -> EDIpackSolver:
+    """DMFT loop.
+
+    Parameters
+    ----------
+    tbl
+    h
+    h0_nambu_k
+    n_bath
+    n_iw
+    broadening
+    n_w
+    w_mixing
+    n_success
+    xmu
+    kmesh
+    epsilon
+    max_iter
+
+    Returns
+    -------
+    EDIpackSolver
+
+    """
+    energy_window = (-2.0 * h.hopping_gr, 2.0 * h.hopping_gr)
+
+    spins = ("up", "dn")
+    orbs = range(tbl.n_orbitals)
+
+    # Fundamental sets for impurity degrees of freedom
+    fops_imp_up = [("up", o) for o in orbs]
+    fops_imp_dn = [("dn", o) for o in orbs]
+
+    # Fundamental sets for bath degrees of freedom
+    fops_bath_up = [("B_up", i) for i in range(tbl.n_orbitals * n_bath)]
+    fops_bath_dn = [("B_dn", i) for i in range(tbl.n_orbitals * n_bath)]
+
+    # Non-interacting part of the impurity Hamiltonian
+    h_loc = -xmu * np.eye(tbl.n_orbitals)
+    hamiltonian = sum(
+        h_loc[o1, o2] * c_dag(spin, o1) * c(spin, o2) for spin, o1, o2 in product(spins, orbs, orbs)
+    )
+
+    # Interaction part
+    hamiltonian += -h.hubbard_int_orbital_basis[0] * sum(n("up", o) * n("dn", o) for o in 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)])
+    v = 0.5 * np.ones((tbl.n_orbitals, n_bath))
+    d = -0.2 * np.eye(tbl.n_orbitals * n_bath)
+
+    # Bath
+    hamiltonian += sum(
+        eps[o, nu] * c_dag("B_" + s, o * n_bath + nu) * c("B_" + s, o * n_bath + nu)
+        for s, o, nu in product(spins, orbs, range(n_bath))
+    )
+
+    hamiltonian += sum(
+        v[o, nu]
+        * (c_dag(s, o) * c("B_" + s, o * n_bath + nu) + c_dag("B_" + s, o * n_bath + nu) * c(s, o))
+        for s, o, nu in product(spins, orbs, range(n_bath))
+    )
+
+    # Anomalous bath
+    hamiltonian += sum(
+        d[o, q] * (c("B_up", o) * c("B_dn", q)) + dagger(d[o, q] * (c("B_up", o) * c("B_dn", q)))
+        for o, q in product(range(tbl.n_orbitals * n_bath), range(tbl.n_orbitals * n_bath))
+    )
+
+    # Create solver object
+    fit_params = BathFittingParams(method="minimize", grad="numeric")
+    solver = EDIpackSolver(
+        hamiltonian,
+        fops_imp_up,
+        fops_imp_dn,
+        fops_bath_up,
+        fops_bath_dn,
+        lanc_dim_threshold=1024,
+        verbose=1,
+        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}")
+
+        # Solve the effective impurity problem
+        solver.solve(
+            beta=h.beta,
+            n_iw=n_iw,
+            energy_window=energy_window,
+            n_w=n_w,
+            broadening=broadening,
+        )
+
+        # Normal and anomalous components of computed self-energy
+        s_iw = solver.Sigma_iw["up"]
+        s_an_iw = solver.Sigma_an_iw["up_dn"]
+
+        # Compute local Green's function
+        g_iw, g_an_iw = get_gloc(s_iw, s_an_iw, h0_nambu_k, xmu, broadening, kmesh)
+        # Compute Weiss field
+        g0_iw, g0_an_iw = _dmft_weiss_field(g_iw, g_an_iw, s_iw, s_an_iw)
+
+        # Bath fitting and mixing
+        g0_iw_full = BlockGf(name_list=spins, block_list=[g0_iw, g0_iw])
+        g0_an_iw_full = BlockGf(name_list=["up_dn"], block_list=[g0_an_iw])
+
+        bath_new = solver.chi2_fit_bath(g0_iw_full, g0_an_iw_full)[0]
+        solver.bath = w_mixing * bath_new + (1 - w_mixing) * solver.bath
+
+        # 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
+        )
+
+        # 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:
+            break
+
+    return solver

quant_met/dmft/utils.py

@@ -0,0 +1,98 @@
+# SPDX-FileCopyrightText: 2025 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Utility functions used in DMFT."""
+
+import numpy as np
+import numpy.typing as npt
+from triqs.gf import Gf, MeshBrZone, MeshImFreq, MeshProduct, conjugate, dyson, inverse, iOmega_n
+
+
+def get_gloc(
+    s: Gf,
+    s_an: Gf,
+    h0_nambu_k: Gf,
+    xmu: npt.NDArray[np.complex128],
+    broadening: float,
+    kmesh: MeshBrZone,
+) -> tuple[Gf, Gf]:
+    """Compute local GF from bare lattice Hamiltonian and self-energy.
+
+    Parameters
+    ----------
+    s
+    s_an
+    h0_nambu_k
+
+    Returns
+    -------
+    tuple[Gf, Gf]
+
+    """
+    z = Gf(mesh=s.mesh, target_shape=h0_nambu_k.target_shape)
+    n_orbitals = z.target_shape[0] // 2
+    if isinstance(s.mesh, MeshImFreq):
+        z[:n_orbitals, :n_orbitals] << iOmega_n + xmu - s
+        z[:n_orbitals, n_orbitals:] << -s_an
+        z[n_orbitals:, :n_orbitals] << -s_an
+        z[n_orbitals:, n_orbitals:] << iOmega_n - xmu + conjugate(s)
+    else:
+        z[:n_orbitals, n_orbitals:] << -s_an
+        z[n_orbitals:, :n_orbitals] << -s_an
+        for w in z.mesh:
+            z[w][:n_orbitals, :n_orbitals] = (w + 1j * broadening + xmu) * np.eye(n_orbitals) - s[w]
+            z[w][n_orbitals:, n_orbitals:] = (w + 1j * broadening - xmu) * np.eye(
+                n_orbitals
+            ) + conjugate(s(-w))
+
+    g_k = Gf(mesh=MeshProduct(kmesh, z.mesh), target_shape=h0_nambu_k.target_shape)
+    for k in kmesh:
+        g_k[k, :] << inverse(z - h0_nambu_k[k])
+
+    g_loc_nambu = sum(g_k[k, :] for k in kmesh) / len(kmesh)
+
+    g_loc = s.copy()
+    g_loc_an = s_an.copy()
+    g_loc[:] = g_loc_nambu[:n_orbitals, :n_orbitals]
+    g_loc_an[:] = g_loc_nambu[:n_orbitals, n_orbitals:]
+    return g_loc, g_loc_an
+
+
+def _dmft_weiss_field(g_iw: Gf, g_an_iw: Gf, s_iw: Gf, s_an_iw: Gf) -> tuple[Gf, Gf]:
+    """Compute Weiss field from local GF and self-energy.
+
+    Parameters
+    ----------
+    g_iw
+    g_an_iw
+    s_iw
+    s_an_iw
+
+    Returns
+    -------
+    tuple[Gf, Gf]
+
+    """
+    n_orbitals = g_iw.target_shape[0]
+    nambu_shape = (2 * n_orbitals, 2 * n_orbitals)
+    g_nambu_iw = Gf(mesh=g_iw.mesh, target_shape=nambu_shape)
+    s_nambu_iw = Gf(mesh=s_iw.mesh, target_shape=nambu_shape)
+
+    g_nambu_iw[:n_orbitals, :n_orbitals] = g_iw
+    g_nambu_iw[:n_orbitals, n_orbitals:] = g_an_iw
+    g_nambu_iw[n_orbitals:, :n_orbitals] = g_an_iw
+    g_nambu_iw[n_orbitals:, n_orbitals:] = -conjugate(g_iw)
+
+    s_nambu_iw[:n_orbitals, :n_orbitals] = s_iw
+    s_nambu_iw[:n_orbitals, n_orbitals:] = s_an_iw
+    s_nambu_iw[n_orbitals:, :n_orbitals] = s_an_iw
+    s_nambu_iw[n_orbitals:, n_orbitals:] = -conjugate(s_iw)
+
+    g0_nambu_iw = dyson(G_iw=g_nambu_iw, Sigma_iw=s_nambu_iw)
+
+    g0_iw = g_iw.copy()
+    g0_an_iw = g_an_iw.copy()
+    g0_iw[:] = g0_nambu_iw[:n_orbitals, :n_orbitals]
+    g0_an_iw[:] = g0_nambu_iw[:n_orbitals, n_orbitals:]
+    return g0_iw, g0_an_iw

quant_met/mean_field/__init__.py

@@ -29,13 +29,11 @@ Functions
 
 from quant_met.mean_field import hamiltonians
 
-from .quantum_metric import quantum_metric
 from .search_crit_temp import search_crit_temp
 from .self_consistency import self_consistency_loop
 
 __all__ = [
     "hamiltonians",
-    "quantum_metric",
     "search_crit_temp",
     "self_consistency_loop",
 ]

quant_met/mean_field/hamiltonians/base_hamiltonian.py

@@ -603,7 +603,7 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
                             * bdg_wavefunctions[k_index, j, n]
                             * fermi_dirac(bdg_energies[k_index, n].item(), self.beta)
                         )
-                        matrix_y[i, j] *= (
+                        matrix_y[i, j] += (
                             h_der_y[k_index, i, j]
                             * np.conjugate(bdg_wavefunctions[k_index, i, n])
                             * bdg_wavefunctions[k_index, j, n]
@@ -721,6 +721,65 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
         return c_mnpq
 
+    def calculate_quantum_metric(
+        self, k: npt.NDArray[np.floating], bands: list[int]
+    ) -> npt.NDArray[np.floating]:
+        """Calculate the quantum metric (geometric tensor) for specified bands.
+
+        This function computes the quantum geometric tensor associated with
+        the specified bands of a given Hamiltonian over a grid of k-points.
+        The output is a 2x2 matrix representing the quantum metric.
+
+        Parameters
+        ----------
+        h : BaseHamiltonian
+            Hamiltonian object used to compute Bloch states and their derivatives.
+        k : numpy.ndarray
+            Array of k points in the Brillouin zone.
+        bands : list of int
+            Indices of the bands for which the quantum metric is to be calculated.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            A 2x2 matrix representing the quantum metric.
+
+        Raises
+        ------
+        ValueError
+            If `bands` contains invalid indices or `k_grid` is empty.
+        """
+        energies, bloch = self.diagonalize_nonint(k)
+
+        number_k_points = len(k)
+
+        quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex128)
+
+        for band in bands:
+            for i, direction_1 in enumerate(["x", "y"]):
+                h_derivative_direction_1 = self.hamiltonian_derivative(k=k, direction=direction_1)
+                for j, direction_2 in enumerate(["x", "y"]):
+                    h_derivative_direction_2 = self.hamiltonian_derivative(
+                        k=k, direction=direction_2
+                    )
+                    for k_index in range(len(k)):
+                        for n in [i for i in range(self.number_of_bands) if i != band]:
+                            quantum_geom_tensor[i, j] += (
+                                (
+                                    bloch[k_index][:, band].conjugate()
+                                    @ h_derivative_direction_1[k_index]
+                                    @ bloch[k_index][:, n]
+                                )
+                                * (
+                                    bloch[k_index][:, n].conjugate()
+                                    @ h_derivative_direction_2[k_index]
+                                    @ bloch[k_index][:, band]
+                                )
+                                / (energies[k_index][band] - energies[k_index][n]) ** 2
+                            )
+
+        return np.real(quantum_geom_tensor) / number_k_points
+
 
 def _fermi_dirac_derivative() -> float:
     return 0

quant_met/parameters/main.py

@@ -41,6 +41,14 @@ class Control(BaseModel):
     n_temp_points: int = 50
     calculate_additional: bool = False
 
+    n_spin: int = 1
+    n_success: int = 1
+    wmixing: float = 0.5
+    n_bath: int = 2
+    n_iw: int = 1024
+    n_w: int = 4000
+    broadening: float = 0.005
+
 
 class KPoints(BaseModel):
     """Control for k points.

{quant_met-0.0.19.dist-info → quant_met-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quant-met
-Version: 0.0.19
+Version: 0.0.21
 Summary: Calculate superconductivity in flat-band systems.
 Author-email: Tjark Sievers <tsievers@physnet.uni-hamburg.de>
 License-File: LICENSE.txt
@@ -13,6 +13,7 @@ Requires-Dist: numpy<2.1
 Requires-Dist: numpydantic>=1.6.6
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pydantic>=2.10.4
+Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: scipy>=1.15.0
 Requires-Dist: tables>=3.10.2
 Description-Content-Type: text/markdown

{quant_met-0.0.19.dist-info → quant_met-0.0.21.dist-info}/RECORD

@@ -1,22 +1,25 @@
 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=n_aP8_4sZXgPwBxngDcKozfdgYJL6VTwOn9qFLKrnzY,941
+quant_met/cli/_utils.py,sha256=vGXWDXqs15F4MiU-gRk4lHdmP7FB8vQQXuvbx-sesyE,1952
 quant_met/cli/crit_temp.py,sha256=t9sPZKORl6dpa1UNAOMH2gDmeQxf80iFH7p_L3FI5q8,2027
-quant_met/cli/main.py,sha256=lVAPGPUZtzyX6QKPEFYyDKFWYhQ30dMXjOEq5VdTa7I,1871
+quant_met/cli/dmft.py,sha256=4sbTddeHhTxV0DBUNxcQDUBxQe1J9ntqnEQOLluHh1o,3016
+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=R3lYIhUNtBVa_XyjUphZchTAeG3gWXbR1leLz0EhP2A,5738
+quant_met/dmft/utils.py,sha256=z9Y9EP_V8_Bj7NIvz_GSnaQ7tha7QwqtJsEYhKIEoxQ,2897
 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
 quant_met/geometry/graphene.py,sha256=ZLE55wV1E-jRCkGxW66pca2y5VWaNtMmXiXi-HB6bgs,1627
 quant_met/geometry/square.py,sha256=17XZH79lK9TeeDtXiBBa8rd2d9kv5yt2S9F6te0YZPU,1565
-quant_met/mean_field/__init__.py,sha256=dO7ATRQyes96tr2WMvmPPqr_S90WL2RCHquRdXWaSjU,662
+quant_met/mean_field/__init__.py,sha256=Unweog9Tst1NxUMQ4X1OYiUQtyxI2ho-OQoCaekoMFk,597
 quant_met/mean_field/_utils.py,sha256=7hr0DDSdIqjft5Jjluvbw_HGoNLWgYJTxyuPJJvhBnc,356
-quant_met/mean_field/quantum_metric.py,sha256=aiZLdUsWmoBLunv-aJr_BCQVfhD7t0GHbeYrT60s3cI,2583
 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=2UlTckCHyBDujzKQk-GvWXJSqUE_2WEZ9D-m6W0TWuY,26880
+quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=4sp2LD213-6aNpbEQAgclJEWOdZdTpDf5QwkgigD0f0,29383
 quant_met/mean_field/hamiltonians/dressed_graphene.py,sha256=Q5LiA3rgK88ZZV1V7JflgjlkEpve7uNZFzFCIoQND-w,4048
 quant_met/mean_field/hamiltonians/graphene.py,sha256=sa3H8jVq9Fkc_qcz5gJTCMgN8YD3N18JWLRBImhLyxo,3276
 quant_met/mean_field/hamiltonians/one_band_tight_binding.py,sha256=DZXaD95yWv1VZSMqgxkqEZv3PGihNGy7PuqupnN75ew,2512
@@ -24,11 +27,11 @@ quant_met/mean_field/hamiltonians/three_band_tight_binding.py,sha256=g8XNImzCn_6
 quant_met/mean_field/hamiltonians/two_band_tight_binding.py,sha256=DMySc94YQ1M2nPIKZjfc-Ax5Ysf7inwSuVKyd6dfqr0,2865
 quant_met/parameters/__init__.py,sha256=9yu7i0J-O3QxSicnLEh2ci7FSMwB8bPW0pbl8KWHJUs,1007
 quant_met/parameters/hamiltonians.py,sha256=PiWVV-miCdT4Z9GWloDVvIU_1QpRHHV-zVOga7DWwCw,6046
-quant_met/parameters/main.py,sha256=bHf3Ixjg7nkr_kDihZUXC1egmXo7LecxmVsqBS-eOAA,2165
+quant_met/parameters/main.py,sha256=QP7Z24-QePMcy6txujqxbx5ztQTdC67m6elNsJtGtXQ,2325
 quant_met/plotting/__init__.py,sha256=VypHrLAGmCiQaQggGh5Cs4EF4YAjRiETddf_7mOX9MQ,544
 quant_met/plotting/plotting.py,sha256=4ZYclWJH3hlE8S7b7bL_JJlP3CKaCGcVzdIsqolCAaM,6592
-quant_met-0.0.19.dist-info/METADATA,sha256=I9-r-z4gagkY0B3vWuNSmz-3q9G6uiC4QRjKTZD1Saw,1949
-quant_met-0.0.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-quant_met-0.0.19.dist-info/entry_points.txt,sha256=1Al3Kt-cMeQxwMp84ZSNL0qFwlbOVBu1o8A19MH8lEU,48
-quant_met-0.0.19.dist-info/licenses/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.19.dist-info/RECORD,,
+quant_met-0.0.21.dist-info/METADATA,sha256=cyCRB0PAwVRHwgPFcI7WZBtlubWfvgZoJDq0hKZNSrc,1978
+quant_met-0.0.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quant_met-0.0.21.dist-info/entry_points.txt,sha256=1Al3Kt-cMeQxwMp84ZSNL0qFwlbOVBu1o8A19MH8lEU,48
+quant_met-0.0.21.dist-info/licenses/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.21.dist-info/RECORD,,

quant_met/mean_field/quantum_metric.py

@@ -1,69 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Functions to calculate the quantum metric."""
-
-import numpy as np
-import numpy.typing as npt
-
-from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
-from quant_met.parameters import GenericParameters
-
-
-def quantum_metric(
-    h: BaseHamiltonian[GenericParameters], k: npt.NDArray[np.floating], bands: list[int]
-) -> npt.NDArray[np.floating]:
-    """Calculate the quantum metric (geometric tensor) for specified bands.
-
-    This function computes the quantum geometric tensor associated with
-    the specified bands of a given Hamiltonian over a grid of k-points.
-    The output is a 2x2 matrix representing the quantum metric.
-
-    Parameters
-    ----------
-    h : BaseHamiltonian
-        Hamiltonian object used to compute Bloch states and their derivatives.
-    k : numpy.ndarray
-        Array of k points in the Brillouin zone.
-    bands : list of int
-        Indices of the bands for which the quantum metric is to be calculated.
-
-    Returns
-    -------
-    :class:`numpy.ndarray`
-        A 2x2 matrix representing the quantum metric.
-
-    Raises
-    ------
-    ValueError
-        If `bands` contains invalid indices or `k_grid` is empty.
-    """
-    energies, bloch = h.diagonalize_nonint(k)
-
-    number_k_points = len(k)
-
-    quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex128)
-
-    for band in bands:
-        for i, direction_1 in enumerate(["x", "y"]):
-            h_derivative_direction_1 = h.hamiltonian_derivative(k=k, direction=direction_1)
-            for j, direction_2 in enumerate(["x", "y"]):
-                h_derivative_direction_2 = h.hamiltonian_derivative(k=k, direction=direction_2)
-                for k_index in range(len(k)):
-                    for n in [i for i in range(h.number_of_bands) if i != band]:
-                        quantum_geom_tensor[i, j] += (
-                            (
-                                bloch[k_index][:, band].conjugate()
-                                @ h_derivative_direction_1[k_index]
-                                @ bloch[k_index][:, n]
-                            )
-                            * (
-                                bloch[k_index][:, n].conjugate()
-                                @ h_derivative_direction_2[k_index]
-                                @ bloch[k_index][:, band]
-                            )
-                            / (energies[k_index][band] - energies[k_index][n]) ** 2
-                        )
-
-    return np.real(quantum_geom_tensor) / number_k_points