quant-met 0.0.17__py3-none-any.whl → 0.0.18__py3-none-any.whl

quant_met/cli/scf.py

@@ -7,6 +7,8 @@
 import logging
 from pathlib import Path
 
+import h5py
+
 from quant_met import mean_field
 from quant_met.parameters import Parameters
 
@@ -28,12 +30,13 @@ def scf(parameters: Parameters) -> None:
     result_path.mkdir(exist_ok=True, parents=True)
 
     h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
+    k_space_grid = h.lattice.generate_bz_grid(
+        ncols=parameters.k_points.nk1, nrows=parameters.k_points.nk2
+    )
 
     solved_h = mean_field.self_consistency_loop(
         h=h,
-        k_space_grid=h.lattice.generate_bz_grid(
-            ncols=parameters.k_points.nk1, nrows=parameters.k_points.nk2
-        ),
+        k_space_grid=k_space_grid,
         epsilon=parameters.control.conv_treshold,
         max_iter=parameters.control.max_iter,
     )
@@ -44,3 +47,24 @@ def scf(parameters: Parameters) -> None:
     result_file = result_path / f"{parameters.control.prefix}.hdf5"
     solved_h.save(filename=result_file)
     logger.info("Results saved to %s", result_file)
+
+    if parameters.control.calculate_additional is True:
+        logger.info("Calculating additional things.")
+        current = solved_h.calculate_current_density(k=k_space_grid)
+        free_energy = solved_h.calculate_free_energy(k=k_space_grid)
+        sf_weight_conv, sf_weight_geom = solved_h.calculate_superfluid_weight(k=k_space_grid)
+
+        with h5py.File(result_file, "a") as f:
+            f.attrs["current_x"] = current[0]
+            f.attrs["current_y"] = current[1]
+            f.attrs["free_energy"] = free_energy
+            f.attrs["sf_weight_conv_xx"] = sf_weight_conv[0, 0]
+            f.attrs["sf_weight_conv_xy"] = sf_weight_conv[0, 1]
+            f.attrs["sf_weight_conv_yx"] = sf_weight_conv[1, 0]
+            f.attrs["sf_weight_conv_yy"] = sf_weight_conv[1, 1]
+            f.attrs["sf_weight_geom_xx"] = sf_weight_geom[0, 0]
+            f.attrs["sf_weight_geom_xy"] = sf_weight_geom[0, 1]
+            f.attrs["sf_weight_geom_yx"] = sf_weight_geom[1, 0]
+            f.attrs["sf_weight_geom_yy"] = sf_weight_geom[1, 1]
+
+        logger.info("Additional results saved to %s", result_file)

quant_met/mean_field/__init__.py

@@ -32,12 +32,10 @@ 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
-from .superfluid_weight import superfluid_weight
 
 __all__ = [
     "hamiltonians",
     "quantum_metric",
     "search_crit_temp",
     "self_consistency_loop",
-    "superfluid_weight",
 ]

quant_met/mean_field/hamiltonians/base_hamiltonian.py

@@ -493,7 +493,7 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
                 ),
             ]
         )
-        density_of_states = np.zeros(shape=energies.shape, dtype=np.floating)
+        density_of_states = np.zeros(shape=energies.shape, dtype=np.float64)
 
         for i, energy in enumerate(energies):
             density_of_states[i] = np.sum(
@@ -612,10 +612,119 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
         current[0] = np.sum(matrix_x, axis=None)
         current[1] = np.sum(matrix_y, axis=None)
-        assert np.allclose(np.imag(current), 0, atol=1e-14)
+        assert np.allclose(np.imag(current), 0, atol=1e-12)
 
         return (2 * np.real(current)) / len(k)
 
+    def calculate_superfluid_weight(
+        self,
+        k: npt.NDArray[np.floating],
+    ) -> tuple[npt.NDArray[np.complexfloating], npt.NDArray[np.complexfloating]]:
+        """Calculate the superfluid weight.
+
+        Parameters
+        ----------
+        h : :class:`~quant_met.mean_field.Hamiltonian`
+        Hamiltonian.
+        k : :class:`numpy.ndarray`
+        List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+        Conventional contribution to the superfluid weight.
+        :class:`numpy.ndarray`
+        Geometric contribution to the superfluid weight.
+
+        """
+        s_weight_conv = np.zeros(shape=(2, 2), dtype=np.complex128)
+        s_weight_geom = np.zeros(shape=(2, 2), dtype=np.complex128)
+
+        c_mnpq_cache = {}
+
+        for i, direction_1 in enumerate(["x", "y"]):
+            for j, direction_2 in enumerate(["x", "y"]):
+                for k_point in k:
+                    k_tuple = tuple(k_point)
+
+                    if k_tuple not in c_mnpq_cache:
+                        c_mnpq_cache[k_tuple] = self._c_factor(k_point)
+                    c_mnpq = c_mnpq_cache[k_tuple]
+
+                    j_up = self._current_operator(direction_1, k_point)
+                    j_down = self._current_operator(direction_2, -k_point)
+
+                    for m in range(self.number_of_bands):
+                        for n in range(self.number_of_bands):
+                            for p in range(self.number_of_bands):
+                                for q in range(self.number_of_bands):
+                                    s_weight = c_mnpq[m, n, p, q] * j_up[m, n] * j_down[q, p]
+                                    if m == n and p == q:
+                                        s_weight_conv[i, j] += s_weight
+                                    else:
+                                        s_weight_geom[i, j] += s_weight
+
+        return s_weight_conv, s_weight_geom
+
+    def _current_operator(
+        self, direction: str, k: npt.NDArray[np.floating]
+    ) -> npt.NDArray[np.complexfloating]:
+        j = np.zeros(shape=(self.number_of_bands, self.number_of_bands), dtype=np.complex128)
+
+        _, bloch = self.diagonalize_nonint(k=k)
+
+        for m in range(self.number_of_bands):
+            for n in range(self.number_of_bands):
+                j[m, n] = (
+                    bloch[:, m].conjugate()
+                    @ self.hamiltonian_derivative(direction=direction, k=k)
+                    @ bloch[:, n]
+                )
+
+        return j
+
+    def _c_factor(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:
+        bdg_energies, bdg_functions = self.diagonalize_bdg(k)
+        c_mnpq = np.zeros(
+            shape=(
+                self.number_of_bands,
+                self.number_of_bands,
+                self.number_of_bands,
+                self.number_of_bands,
+            ),
+            dtype=np.complex128,
+        )
+
+        for m in range(self.number_of_bands):
+            for n in range(self.number_of_bands):
+                for p in range(self.number_of_bands):
+                    for q in range(self.number_of_bands):
+                        c_tmp: float = 0
+                        for i in range(2 * self.number_of_bands):
+                            for j in range(2 * self.number_of_bands):
+                                if bdg_energies[i] != bdg_energies[j]:
+                                    c_tmp += (
+                                        fermi_dirac(bdg_energies[i], self.beta)
+                                        - fermi_dirac(bdg_energies[j], self.beta)
+                                    ) / (bdg_energies[i] - bdg_energies[j])
+                                else:
+                                    c_tmp -= _fermi_dirac_derivative()
+
+                                c_tmp *= (
+                                    bdg_functions[i, m].conjugate()
+                                    * bdg_functions[j, n]
+                                    * bdg_functions[j, p].conjugate()
+                                    * bdg_functions[i, q].conjugate()
+                                )
+
+                        c_mnpq[m, n, p, q] = 2 * c_tmp
+
+        return c_mnpq
+
+
+def _fermi_dirac_derivative() -> float:
+    return 0
+
 
 def _gaussian(x: npt.NDArray[np.floating], sigma: float) -> npt.NDArray[np.floating]:
     gaussian: npt.NDArray[np.floating] = np.exp(-(x**2) / (2 * sigma**2)) / np.sqrt(

quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -26,7 +26,7 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
         self.hubbard_int_orbital_basis = parameters.hubbard_int_orbital_basis
         self.chemical_potential = parameters.chemical_potential
         if parameters.delta is not None:
-            self.delta_orbital_basis = parameters.delta.astype(np.complexfloating)
+            self.delta_orbital_basis = parameters.delta.astype(np.complex128)
 
     def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:  # noqa: D102
         return GrapheneLattice(lattice_constant=parameters.lattice_constant)

quant_met/mean_field/quantum_metric.py

@@ -43,7 +43,7 @@ def quantum_metric(
 
     number_k_points = len(k)
 
-    quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complexfloating)
+    quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex128)
 
     for band in bands:
         for i, direction_1 in enumerate(["x", "y"]):

quant_met/parameters/main.py

@@ -39,6 +39,7 @@ class Control(BaseModel):
     conv_treshold: float
     max_iter: int = 1000
     n_temp_points: int = 50
+    calculate_additional: bool = False
 
 
 class KPoints(BaseModel):

{quant_met-0.0.17.dist-info → quant_met-0.0.18.dist-info}/METADATA

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

{quant_met-0.0.17.dist-info → quant_met-0.0.18.dist-info}/RECORD

@@ -4,32 +4,31 @@ quant_met/cli/__init__.py,sha256=nGFXhK8zWyEKQtsQTyJWfEOLFOHTCjZnfEcrVb2dARc,254
 quant_met/cli/_utils.py,sha256=n_aP8_4sZXgPwBxngDcKozfdgYJL6VTwOn9qFLKrnzY,941
 quant_met/cli/crit_temp.py,sha256=t9sPZKORl6dpa1UNAOMH2gDmeQxf80iFH7p_L3FI5q8,2027
 quant_met/cli/main.py,sha256=lVAPGPUZtzyX6QKPEFYyDKFWYhQ30dMXjOEq5VdTa7I,1871
-quant_met/cli/scf.py,sha256=wHilJRBk7_8nOheJpGk1ZeBOWu4UF9oDVI4SjHptQgY,1464
+quant_met/cli/scf.py,sha256=3_rwtQHwypFjAwjrsO2r2sqjJKpNiDLAj6svU52CCcU,2613
 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=fCPMFKoYh47aa5Aa0wSQ3cZWMgUdGQqqjfeXO6OzB-E,736
+quant_met/mean_field/__init__.py,sha256=dO7ATRQyes96tr2WMvmPPqr_S90WL2RCHquRdXWaSjU,662
 quant_met/mean_field/_utils.py,sha256=7hr0DDSdIqjft5Jjluvbw_HGoNLWgYJTxyuPJJvhBnc,356
-quant_met/mean_field/quantum_metric.py,sha256=YDvCsn1W-NBd0PdxyNUpsaO0GPIpIL20LElP-S-HmYY,2588
+quant_met/mean_field/quantum_metric.py,sha256=aiZLdUsWmoBLunv-aJr_BCQVfhD7t0GHbeYrT60s3cI,2583
 quant_met/mean_field/search_crit_temp.py,sha256=Lp6iJEyXnLwfZQ3549J3s9HYQo6OgakzT_FJRRZ5oM0,8661
 quant_met/mean_field/self_consistency.py,sha256=YY_zhCurxOK3RLkK-Hglfkx33uhsvqpoAKOP4FuPdfo,3371
-quant_met/mean_field/superfluid_weight.py,sha256=XiJ6wFZkxFoGtIzy2NCMoznothqrMkvIvYU_0_29mUc,4321
 quant_met/mean_field/hamiltonians/__init__.py,sha256=r-8TaLqRnRbAro-TMIyxzCCZHwVqyKrausODpQJb2tw,681
-quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=WA3WKb34xi0m78WRmIsyjJ_skq7OsndiI3YsUOCvx8I,22624
-quant_met/mean_field/hamiltonians/dressed_graphene.py,sha256=99HCr1VXv_9sQpp5Mn51ijdnBOsN-y4s8n7YSyBXWJE,4053
+quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=2UlTckCHyBDujzKQk-GvWXJSqUE_2WEZ9D-m6W0TWuY,26880
+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
 quant_met/mean_field/hamiltonians/three_band_tight_binding.py,sha256=g8XNImzCn_6CRYKDYI6sy3q6_TBYUDxDmQZ-AqenXTE,3295
 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=hGcJvRixkXuUk9MytAs0S1L2VvcJlT8qVG1g7NZOjlE,2126
+quant_met/parameters/main.py,sha256=bHf3Ixjg7nkr_kDihZUXC1egmXo7LecxmVsqBS-eOAA,2165
 quant_met/plotting/__init__.py,sha256=VypHrLAGmCiQaQggGh5Cs4EF4YAjRiETddf_7mOX9MQ,544
 quant_met/plotting/plotting.py,sha256=4ZYclWJH3hlE8S7b7bL_JJlP3CKaCGcVzdIsqolCAaM,6592
-quant_met-0.0.17.dist-info/METADATA,sha256=9Vz7cCEp8RC9i3YphnvG6WNmCoWxtUMJGDmD5Qv4BHo,1949
-quant_met-0.0.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-quant_met-0.0.17.dist-info/entry_points.txt,sha256=1Al3Kt-cMeQxwMp84ZSNL0qFwlbOVBu1o8A19MH8lEU,48
-quant_met-0.0.17.dist-info/licenses/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.17.dist-info/RECORD,,
+quant_met-0.0.18.dist-info/METADATA,sha256=t4UafmOjpoGKF8s6dqo3J_kKQA2kZhtSZiZaNaFAgHs,1949
+quant_met-0.0.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quant_met-0.0.18.dist-info/entry_points.txt,sha256=1Al3Kt-cMeQxwMp84ZSNL0qFwlbOVBu1o8A19MH8lEU,48
+quant_met-0.0.18.dist-info/licenses/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.18.dist-info/RECORD,,

quant_met/mean_field/superfluid_weight.py

@@ -1,126 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Functions to calculate the superfluid weight."""
-
-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
-from quant_met.utils import fermi_dirac
-
-
-def superfluid_weight(
-    h: BaseHamiltonian[GenericParameters],
-    k: npt.NDArray[np.floating],
-) -> tuple[npt.NDArray[np.complexfloating], npt.NDArray[np.complexfloating]]:
-    """Calculate the superfluid weight.
-
-    Parameters
-    ----------
-    h : :class:`~quant_met.mean_field.Hamiltonian`
-        Hamiltonian.
-    k : :class:`numpy.ndarray`
-        List of k points.
-
-    Returns
-    -------
-    :class:`numpy.ndarray`
-        Conventional contribution to the superfluid weight.
-    :class:`numpy.ndarray`
-        Geometric contribution to the superfluid weight.
-
-    """
-    s_weight_conv = np.zeros(shape=(2, 2), dtype=np.complexfloating)
-    s_weight_geom = np.zeros(shape=(2, 2), dtype=np.complexfloating)
-
-    c_mnpq_cache = {}
-
-    for i, direction_1 in enumerate(["x", "y"]):
-        for j, direction_2 in enumerate(["x", "y"]):
-            for k_point in k:
-                k_tuple = tuple(k_point)
-
-                if k_tuple not in c_mnpq_cache:
-                    c_mnpq_cache[k_tuple] = _c_factor(h, k_point)
-                c_mnpq = c_mnpq_cache[k_tuple]
-
-                j_up = _current_operator(h, direction_1, k_point)
-                j_down = _current_operator(h, direction_2, -k_point)
-
-                for m in range(h.number_of_bands):
-                    for n in range(h.number_of_bands):
-                        for p in range(h.number_of_bands):
-                            for q in range(h.number_of_bands):
-                                s_weight = c_mnpq[m, n, p, q] * j_up[m, n] * j_down[q, p]
-                                if m == n and p == q:
-                                    s_weight_conv[i, j] += s_weight
-                                else:
-                                    s_weight_geom[i, j] += s_weight
-
-    return s_weight_conv, s_weight_geom
-
-
-def _current_operator(
-    h: BaseHamiltonian[GenericParameters], direction: str, k: npt.NDArray[np.floating]
-) -> npt.NDArray[np.complexfloating]:
-    j = np.zeros(shape=(h.number_of_bands, h.number_of_bands), dtype=np.complexfloating)
-
-    _, bloch = h.diagonalize_nonint(k=k)
-
-    for m in range(h.number_of_bands):
-        for n in range(h.number_of_bands):
-            j[m, n] = (
-                bloch[:, m].conjugate()
-                @ h.hamiltonian_derivative(direction=direction, k=k)
-                @ bloch[:, n]
-            )
-
-    return j
-
-
-def _c_factor(
-    h: BaseHamiltonian[GenericParameters], k: npt.NDArray[np.floating]
-) -> npt.NDArray[np.complexfloating]:
-    bdg_energies, bdg_functions = h.diagonalize_bdg(k)
-    c_mnpq = np.zeros(
-        shape=(
-            h.number_of_bands,
-            h.number_of_bands,
-            h.number_of_bands,
-            h.number_of_bands,
-        ),
-        dtype=np.complexfloating,
-    )
-
-    for m in range(h.number_of_bands):
-        for n in range(h.number_of_bands):
-            for p in range(h.number_of_bands):
-                for q in range(h.number_of_bands):
-                    c_tmp: float = 0
-                    for i in range(2 * h.number_of_bands):
-                        for j in range(2 * h.number_of_bands):
-                            if bdg_energies[i] != bdg_energies[j]:
-                                c_tmp += (
-                                    fermi_dirac(bdg_energies[i], h.beta)
-                                    - fermi_dirac(bdg_energies[j], h.beta)
-                                ) / (bdg_energies[i] - bdg_energies[j])
-                            else:
-                                c_tmp -= _fermi_dirac_derivative()
-
-                            c_tmp *= (
-                                bdg_functions[i, m].conjugate()
-                                * bdg_functions[j, n]
-                                * bdg_functions[j, p].conjugate()
-                                * bdg_functions[i, q].conjugate()
-                            )
-
-                    c_mnpq[m, n, p, q] = 2 * c_tmp
-
-    return c_mnpq
-
-
-def _fermi_dirac_derivative() -> float:
-    return 0