quant-met 0.0.17__tar.gz → 0.0.18__tar.gz

{quant_met-0.0.17 → quant_met-0.0.18}/CHANGELOG.rst

@@ -1,3 +1,13 @@
+
+.. _changelog-0.0.18:
+
+0.0.18 — 2025-01-10
+-------------------
+
+Added
+^^^^^
+
+- Control parameter to calculate SC current, superfluid weight and free energy in scf calculation
 .. SPDX-FileCopyrightText: 2024 Tjark Sievers
 ..
 .. SPDX-License-Identifier: MIT

{quant_met-0.0.17 → quant_met-0.0.18}/PKG-INFO

@@ -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 → quant_met-0.0.18}/docs/source/example_input_scf.yaml

@@ -10,14 +10,16 @@ model:
   chemical_potential: 0.0
   hubbard_int_orbital_basis: [1.0, 1.0, 1.0]
   lattice_constant: 3
-  q: [0, 0]
+  q: [0.0, 0.0]
+  beta: 100
 
 control:
   calculation: scf
   prefix: test
   outdir: test/
   conv_treshold: 1e-6
-  iterations: 1000
+  max_iter: 1000
+  calculate_additional: true
 
 k_points:
   nk1: 30

{quant_met-0.0.17 → quant_met-0.0.18}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "quant-met"
-version = "0.0.17"
+version = "0.0.18"
 description = "Calculate superconductivity in flat-band systems."
 authors = [{name="Tjark Sievers", email="tsievers@physnet.uni-hamburg.de"}]
 readme = "README.md"

{quant_met-0.0.17 → quant_met-0.0.18}/src/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-0.0.17 → quant_met-0.0.18}/src/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-0.0.17 → quant_met-0.0.18}/src/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-0.0.17 → quant_met-0.0.18}/src/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-0.0.17 → quant_met-0.0.18}/src/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-0.0.17 → quant_met-0.0.18}/src/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 → quant_met-0.0.18}/tests/test_benchmarks.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2024 Tjark Sievers
 #
 # SPDX-License-Identifier: MIT
+
 import numpy as np
 
 from quant_met import mean_field, parameters
@@ -133,7 +134,6 @@ def test_benchmark_superfluid_weight_two_band(benchmark) -> None:
     )
     k_space_grid = one_band_h.lattice.generate_bz_grid(ncols=10, nrows=10)
 
-    benchmark(lambda: mean_field.superfluid_weight(
-        h=one_band_h,
+    benchmark(lambda: one_band_h.calculate_superfluid_weight(
         k=k_space_grid)
-              )
+    )

{quant_met-0.0.17 → quant_met-0.0.18}/tests/test_cli.py

@@ -5,13 +5,13 @@
 """Tests for the command line interface."""
 
 from pathlib import Path
-from unittest.mock import MagicMock
+from unittest.mock import Mock, MagicMock
 
 import yaml
 from click.testing import CliRunner
 from pytest_mock import MockerFixture
 
-from quant_met import mean_field
+from quant_met import mean_field, parameters
 from quant_met.cli import cli
 
 
@@ -82,34 +82,53 @@ def test_crit_temp_mock(tmp_path: Path, mocker: MockerFixture) -> None:
 def test_scf_mock(tmp_path: Path, mocker: MockerFixture) -> None:
     """Test scf calculation with mock."""
     runner = CliRunner()
-    parameters = {
-        "model": {
-            "name": "DressedGraphene",
-            "hopping_gr": 1,
-            "hopping_x": 0.01,
-            "hopping_x_gr_a": 1,
-            "chemical_potential": 0.0,
-            "hubbard_int_orbital_basis": [0.0, 0.0, 0.0],
-            "lattice_constant": 3,
-        },
+    model_parameters = {
+        "name": "DressedGraphene",
+        "hopping_gr": 1,
+        "hopping_x": 0.01,
+        "hopping_x_gr_a": 1,
+        "chemical_potential": 0.0,
+        "hubbard_int_orbital_basis": [0.0, 0.0, 0.0],
+        "lattice_constant": 3,
+    }
+    test_parameters = {
+        "model": model_parameters,
         "control": {
             "calculation": "scf",
             "prefix": "test",
             "outdir": "test/",
             "beta": 100,
             "conv_treshold": 1e-2,
+            "calculate_additional": True
         },
         "k_points": {"nk1": 30, "nk2": 30},
     }
     with runner.isolated_filesystem(temp_dir=tmp_path):
         with Path("input.yaml").open("w") as f:
-            yaml.dump(parameters, f)
+            yaml.dump(test_parameters, f)
         mock_search_self_consistency_loop = mocker.patch(
             "quant_met.mean_field.self_consistency_loop"
         )
-        mock_search_self_consistency_loop.return_value = MagicMock()
+        mock_search_self_consistency_loop.return_value = mean_field.hamiltonians.DressedGraphene(
+            parameters=parameters.DressedGrapheneParameters(
+                **model_parameters
+            )
+        )
         result = runner.invoke(cli, ["input.yaml", "--debug"])
+        mean_field.self_consistency_loop.assert_called()
         assert result.exit_code == 0
+    with runner.isolated_filesystem(temp_dir=tmp_path):
+        test_parameters['control']['calculate_additional'] = False
+        with Path("input.yaml").open("w") as f:
+            yaml.dump(test_parameters, f)
+        mock_search_self_consistency_loop = mocker.patch(
+            "quant_met.mean_field.self_consistency_loop"
+        )
+        mock_search_self_consistency_loop.return_value = mean_field.hamiltonians.DressedGraphene(
+            parameters=parameters.DressedGrapheneParameters(
+                **model_parameters
+            )
+        )
         result = runner.invoke(cli, ["input.yaml"])
         mean_field.self_consistency_loop.assert_called()
         assert result.exit_code == 0

{quant_met-0.0.17 → quant_met-0.0.18}/tests/test_plotting.py

@@ -257,6 +257,7 @@ def test_plotting_nonint_bandstructure_dressed_graphene_with_fig_in() -> None:
     remove_text=True,
     extensions=["png"],
     style="mpl20",
+    tol=0.06,
 )
 def test_plotting_sf_weight() -> None:
     """Test plotting for superfluid weight."""
@@ -272,6 +273,7 @@ def test_plotting_sf_weight() -> None:
     remove_text=True,
     extensions=["png"],
     style="mpl20",
+    tol=0.06,
 )
 def test_plotting_sf_weight_with_fig_in() -> None:
     """Test plotting for superfluid weight with input figure."""

{quant_met-0.0.17 → quant_met-0.0.18}/tests/test_superfluid_weight.py

@@ -31,15 +31,14 @@ def test_superfluid_weight_dressed_graphene(ndarrays_regression: NDArraysRegress
         )
     )
 
-    d_s_conv, d_s_geom = mean_field.superfluid_weight(h=dressed_graphene_h, k=bz_grid)
-    print(d_s_conv, d_s_geom)
+    d_s_conv, d_s_geom = dressed_graphene_h.calculate_superfluid_weight(k=bz_grid)
 
     ndarrays_regression.check(
         {
             "D_S_conv": np.array(d_s_conv),
             "D_S_geom": np.array(d_s_geom),
         },
-        default_tolerance={"atol": 1e-8, "rtol": 1e-5},
+        default_tolerance={"atol": 1e-5, "rtol": 1e-5},
     )
 
 
@@ -61,12 +60,12 @@ def test_superfluid_weight_graphene(ndarrays_regression: NDArraysRegressionFixtu
         )
     )
 
-    d_s_conv, d_s_geom = mean_field.superfluid_weight(h=graphene_h, k=bz_grid)
+    d_s_conv, d_s_geom = graphene_h.calculate_superfluid_weight(k=bz_grid)
 
     ndarrays_regression.check(
         {
             "D_S_conv": np.array(d_s_conv),
             "D_S_geom": np.array(d_s_geom),
         },
-        default_tolerance={"atol": 1e-8, "rtol": 1e-5},
+        default_tolerance={"atol": 1e-4, "rtol": 1e-5},
     )

{quant_met-0.0.17 → quant_met-0.0.18}/uv.lock

@@ -2319,7 +2319,7 @@ wheels = [
 
 [[package]]
 name = "quant-met"
-version = "0.0.17.dev0"
+version = "0.0.17"
 source = { editable = "." }
 dependencies = [
     { name = "click" },

quant_met-0.0.17/src/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