quant-met 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

quant_met/geometry/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Geometry (:mod:`quant_met.geometry`)
+========
+
+.. currentmodule:: quant_met.geometry
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+    generate_bz_path
+    Graphene
+"""  # noqa: D205, D400
+
+from .base_lattice import BaseLattice
+from .bz_path import generate_bz_path
+from .graphene import Graphene
+from .square import SquareLattice
+
+__all__ = ["generate_bz_path", "BaseLattice", "Graphene", "SquareLattice"]

quant_met/geometry/base_lattice.py

@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Base class for lattice geometries."""
+
+from abc import ABC, abstractmethod
+
+import numpy as np
+import numpy.typing as npt
+
+from quant_met.utils import generate_uniform_grid
+
+from .bz_path import generate_bz_path
+
+
+class BaseLattice(ABC):
+    """Base class for lattice geometries."""
+
+    @property
+    @abstractmethod
+    def lattice_constant(self) -> np.float64:
+        """Lattice constant."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def bz_corners(self) -> npt.NDArray[np.float64]:
+        """Corners of the BZ."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:
+        """Tuple of high symmetry points and names."""
+        raise NotImplementedError
+
+    def generate_bz_grid(self, ncols: int, nrows: int) -> npt.NDArray[np.float64]:
+        """Generate a grid in the BZ.
+
+        Parameters
+        ----------
+        ncols : int
+            Number of points in column.
+        nrows : int
+            Number of points in row.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Array of grid points in the BZ.
+
+        """
+        return generate_uniform_grid(
+            ncols, nrows, self.bz_corners[0], self.bz_corners[1], origin=np.array([0, 0])
+        )
+
+    def generate_high_symmetry_path(
+        self, number_of_points: int
+    ) -> tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        list[float],
+        list[str],
+    ]:
+        """Generate a path through high symmetry points.
+
+        Parameters
+        ----------
+        number_of_points: int
+            Number of point in the whole path.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            List of two-dimensional k points.
+        :class:`numpy.ndarray`
+            Path for plotting purposes: points between 0 and 1, with appropriate spacing.
+        list[float]
+            A list of ticks for the plotting path.
+        list[str]
+            A list of labels for the plotting path.
+
+        """
+        return generate_bz_path(list(self.high_symmetry_points), number_of_points=number_of_points)

quant_met/geometry/bz_path.py

@@ -0,0 +1,89 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Methods to generate paths through the BZ."""
+
+import numpy as np
+import numpy.typing as npt
+
+
+def _generate_part_of_path(
+    p_0: npt.NDArray[np.float64],
+    p_1: npt.NDArray[np.float64],
+    n: int,
+    length_whole_path: int,
+) -> npt.NDArray[np.float64]:
+    distance = np.linalg.norm(p_1 - p_0)
+    number_of_points = int(n * distance / length_whole_path) + 1
+
+    return np.vstack(
+        [
+            np.linspace(p_0[0], p_1[0], number_of_points),
+            np.linspace(p_0[1], p_1[1], number_of_points),
+        ]
+    ).T[:-1]
+
+
+def generate_bz_path(
+    points: list[tuple[npt.NDArray[np.float64], str]], number_of_points: int = 1000
+) -> tuple[
+    npt.NDArray[np.float64],
+    npt.NDArray[np.float64],
+    list[float],
+    list[str],
+]:
+    """Generate a path through high symmetry points.
+
+    Parameters
+    ----------
+    points : :class:`numpy.ndarray`
+        Test
+    number_of_points: int
+        Number of point in the whole path.
+
+    Returns
+    -------
+    :class:`numpy.ndarray`
+        List of two-dimensional k points.
+    :class:`numpy.ndarray`
+        Path for plotting purposes: points between 0 and 1, with appropriate spacing.
+    list[float]
+        A list of ticks for the plotting path.
+    list[str]
+        A list of labels for the plotting path.
+
+    """
+    n = number_of_points
+
+    cycle = [np.linalg.norm(points[i][0] - points[i + 1][0]) for i in range(len(points) - 1)]
+    cycle.append(np.linalg.norm(points[-1][0] - points[0][0]))
+
+    length_whole_path = np.sum(np.array([cycle]))
+
+    ticks = [0.0]
+    ticks.extend([np.sum(cycle[0 : i + 1]) / length_whole_path for i in range(len(cycle) - 1)])
+    ticks.append(1.0)
+    labels = [rf"${points[i][1]}$" for i in range(len(points))]
+    labels.append(rf"${points[0][1]}$")
+
+    whole_path_plot = np.concatenate(
+        [
+            np.linspace(
+                ticks[i],
+                ticks[i + 1],
+                num=int(n * cycle[i] / length_whole_path),
+                endpoint=False,
+            )
+            for i in range(len(ticks) - 1)
+        ]
+    )
+
+    points_path = [
+        _generate_part_of_path(points[i][0], points[i + 1][0], n, length_whole_path)
+        for i in range(len(points) - 1)
+    ]
+    points_path.append(_generate_part_of_path(points[-1][0], points[0][0], n, length_whole_path))
+    whole_path = np.concatenate(points_path)
+
+    return whole_path, whole_path_plot, ticks, labels

quant_met/geometry/graphene.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Lattice geometry for Graphene."""
+
+import numpy as np
+import numpy.typing as npt
+
+from .base_lattice import BaseLattice
+
+
+class Graphene(BaseLattice):
+    """Lattice geometry for Graphene."""
+
+    def __init__(self, lattice_constant: np.float64) -> None:
+        self._lattice_constant = lattice_constant
+        self._bz_corners = (
+            4
+            * np.pi
+            / (3 * self.lattice_constant)
+            * np.array([(np.cos(i * np.pi / 3), np.sin(i * np.pi / 3)) for i in range(6)])
+        )
+        self.Gamma = np.array([0, 0])
+        self.M = np.pi / self.lattice_constant * np.array([1, 1 / np.sqrt(3)])
+        self.K = 4 * np.pi / (3 * self.lattice_constant) * np.array([1, 0])
+        self._high_symmetry_points = ((self.M, "M"), (self.Gamma, r"\Gamma"), (self.K, "K"))
+
+    @property
+    def lattice_constant(self) -> np.float64:  # noqa: D102
+        return self._lattice_constant
+
+    @property
+    def bz_corners(self) -> npt.NDArray[np.float64]:  # noqa: D102
+        return self._bz_corners
+
+    @property
+    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # noqa: D102
+        return self._high_symmetry_points

quant_met/geometry/square.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Lattice geometry for Square Lattice."""
+
+import numpy as np
+import numpy.typing as npt
+
+from .base_lattice import BaseLattice
+
+
+class SquareLattice(BaseLattice):
+    """Lattice geometry for Square Lattice."""
+
+    def __init__(self, lattice_constant: np.float64) -> None:
+        self._lattice_constant = lattice_constant
+        self._bz_corners = (
+            np.pi
+            / lattice_constant
+            * np.array([np.array([1, 1]), np.array([-1, 1]), np.array([1, -1]), np.array([-1, -1])])
+        )
+        self.Gamma = np.array([0, 0])
+        self.M = np.pi / lattice_constant * np.array([1, 1])
+        self.X = np.pi / lattice_constant * np.array([1, 0])
+        self._high_symmetry_points = ((self.Gamma, r"\Gamma"), (self.M, "M"))
+
+    @property
+    def lattice_constant(self) -> np.float64:  # noqa: D102
+        return self._lattice_constant
+
+    @property
+    def bz_corners(self) -> npt.NDArray[np.float64]:  # noqa: D102
+        return self._bz_corners
+
+    @property
+    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # noqa: D102
+        return self._high_symmetry_points

quant_met/mean_field/__init__.py

@@ -44,7 +44,9 @@ from .free_energy import (
     free_energy_uniform_pairing,
 )
 from .graphene import GrapheneHamiltonian
+from .one_band_tight_binding import OneBandTightBindingHamiltonian
 from .quantum_metric import quantum_metric, quantum_metric_bdg
+from .self_consistency import self_consistency_loop
 from .superfluid_weight import superfluid_weight
 
 __all__ = [
@@ -55,7 +57,9 @@ __all__ = [
     "free_energy_complex_gap",
     "free_energy_real_gap",
     "free_energy_uniform_pairing",
+    "self_consistency_loop",
     "BaseHamiltonian",
     "GrapheneHamiltonian",
     "EGXHamiltonian",
+    "OneBandTightBindingHamiltonian",
 ]

quant_met/mean_field/base_hamiltonian.py

@@ -25,9 +25,9 @@ class BaseHamiltonian(ABC):
         raise NotImplementedError
 
     @property
-    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:
+    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:
         """
-        Coloumb interaction split up in orbitals.
+        hubbard_int interaction split up in orbitals.
 
         Returns
         -------
@@ -158,7 +158,11 @@ class BaseHamiltonian(ABC):
 
         for i in range(self.number_of_bands):
             h[:, self.number_of_bands + i, i] = self.delta_orbital_basis[i]
-        h[:, 0:2, 2:4] = h[:, 2:4, 0:2].copy().conjugate()
+        h[:, 0 : self.number_of_bands, self.number_of_bands : self.number_of_bands * 2] = (
+            h[:, self.number_of_bands : self.number_of_bands * 2, 0 : self.number_of_bands]
+            .copy()
+            .conjugate()
+        )
 
         return h.squeeze()
 
@@ -270,6 +274,47 @@ class BaseHamiltonian(ABC):
 
         return bdg_energies.squeeze(), bdg_wavefunctions.squeeze()
 
+    def gap_equation(
+        self, k: npt.NDArray[np.float64], beta: np.float64
+    ) -> npt.NDArray[np.complex64]:
+        """Gap equation.
+
+        Parameters
+        ----------
+        beta
+        k
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            New gap in orbital basis.
+
+
+        """
+        bdg_energies, bdg_wavefunctions = self.diagonalize_bdg(k)
+        bdg_energies_minus_k, _ = self.diagonalize_bdg(-k)
+        delta = np.zeros(self.number_of_bands, dtype=np.complex64)
+
+        for i in range(self.number_of_bands):
+            sum_tmp = 0
+            for j in range(self.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 + self.number_of_bands, j
+                    ] * _fermi_dirac(
+                        bdg_energies[k_index, j + self.number_of_bands].item(), beta
+                    ) + np.conjugate(
+                        bdg_wavefunctions[k_index, i, j + self.number_of_bands]
+                    ) * bdg_wavefunctions[
+                        k_index, i + self.number_of_bands, j + self.number_of_bands
+                    ] * _fermi_dirac(
+                        -bdg_energies_minus_k[k_index, j + self.number_of_bands].item(), beta
+                    )
+            delta[i] = (-self.hubbard_int_orbital_basis[i] * sum_tmp / len(k)).conjugate()
+
+        delta_without_phase: npt.NDArray[np.complex64] = delta * np.exp(-1j * np.angle(delta[0]))
+        return delta_without_phase
+
     def calculate_bandstructure(
         self,
         k: npt.NDArray[np.float64],
@@ -298,13 +343,51 @@ class BaseHamiltonian(ABC):
         energies, wavefunctions = self.diagonalize_nonint(k)
 
         for i, (energy_k, wavefunction_k) in enumerate(zip(energies, wavefunctions, strict=False)):
-            for band_index in range(self.number_of_bands):
-                results.loc[i, f"band_{band_index}"] = energy_k[band_index]
-
-                if overlaps is not None:
-                    results.loc[i, f"wx_{band_index}"] = (
-                        np.abs(np.dot(wavefunction_k[:, band_index], overlaps[0])) ** 2
-                        - np.abs(np.dot(wavefunction_k[:, band_index], overlaps[1])) ** 2
-                    )
+            if self.number_of_bands == 1:
+                results.loc[i, "band"] = energy_k
+            else:
+                for band_index in range(self.number_of_bands):
+                    results.loc[i, f"band_{band_index}"] = energy_k[band_index]
+
+                    if overlaps is not None:
+                        results.loc[i, f"wx_{band_index}"] = (
+                            np.abs(np.dot(wavefunction_k[:, band_index], overlaps[0])) ** 2
+                            - np.abs(np.dot(wavefunction_k[:, band_index], overlaps[1])) ** 2
+                        )
 
         return results
+
+    def calculate_density_of_states(
+        self, k: npt.NDArray[np.float64], energies: npt.NDArray[np.float64]
+    ) -> npt.NDArray[np.float64]:
+        """Calculate the density of states.
+
+        Parameters
+        ----------
+        k
+        energies
+
+        Returns
+        -------
+        Density of states.
+
+        """
+        density_of_states = np.zeros(shape=energies.shape, dtype=np.float64)
+        bands, _ = self.diagonalize_bdg(k=k)
+        for i, energy in enumerate(energies):
+            density_of_states[i] = np.sum(
+                _gaussian(x=(energy - bands.flatten()), sigma=1e-2)
+            ) / len(k)
+        return density_of_states
+
+
+def _gaussian(x: npt.NDArray[np.float64], sigma: float) -> npt.NDArray[np.float64]:
+    gaussian: npt.NDArray[np.float64] = np.exp(-(x**2) / (2 * sigma**2)) / np.sqrt(
+        2 * np.pi * sigma**2
+    )
+    return gaussian
+
+
+def _fermi_dirac(energy: np.float64, beta: np.float64) -> np.float64:
+    fermi_dirac: np.float64 = 1 / (1 + np.exp(beta * energy))
+    return fermi_dirac

quant_met/mean_field/eg_x.py

@@ -22,9 +22,9 @@ class EGXHamiltonian(BaseHamiltonian):
         hopping_x: float,
         hopping_x_gr_a: float,
         lattice_constant: float,
-        mu: float,
-        coloumb_gr: float,
-        coloumb_x: float,
+        chemical_potential: float,
+        hubbard_int_gr: float,
+        hubbard_int_x: float,
         delta: npt.NDArray[np.complex64] | None = None,
         *args: tuple[Any, ...],
         **kwargs: tuple[dict[str, Any], ...],
@@ -34,20 +34,28 @@ class EGXHamiltonian(BaseHamiltonian):
         self.hopping_gr = _validate_float(hopping_gr, "Hopping graphene")
         self.hopping_x = _validate_float(hopping_x, "Hopping impurity")
         self.hopping_x_gr_a = _validate_float(hopping_x_gr_a, "Hybridisation")
+        if lattice_constant <= 0:
+            msg = "Lattice constant must be positive"
+            raise ValueError(msg)
         self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
-        self.mu = _validate_float(mu, "Chemical potential")
-        self.coloumb_gr = _validate_float(coloumb_gr, "Coloumb interaction graphene")
-        self.coloumb_x = _validate_float(coloumb_x, "Coloumb interaction impurity")
-        self._coloumb_orbital_basis = np.array([self.coloumb_gr, self.coloumb_gr, self.coloumb_x])
+        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
+        self.hubbard_int_gr = _validate_float(hubbard_int_gr, "hubbard_int interaction graphene")
+        self.hubbard_int_x = _validate_float(hubbard_int_x, "hubbard_int interaction impurity")
+        self._hubbard_int_orbital_basis = np.array(
+            [self.hubbard_int_gr, self.hubbard_int_gr, self.hubbard_int_x]
+        )
         self._number_of_bands = 3
         if delta is None:
-            self._delta_orbital_basis = np.zeros(3, dtype=np.complex64)
+            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
         else:
-            self._delta_orbital_basis = delta
+            if delta.shape != (self.number_of_bands,):
+                msg = "Invalid input value for gaps."
+                raise ValueError(msg)
+            self._delta_orbital_basis = np.astype(delta, np.complex64)
 
     @property
-    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
-        return self._coloumb_orbital_basis
+    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
+        return self._hubbard_int_orbital_basis
 
     @property
     def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
@@ -82,7 +90,7 @@ class EGXHamiltonian(BaseHamiltonian):
         t_x = self.hopping_x
         a = self.lattice_constant
         v = self.hopping_x_gr_a
-        mu = self.mu
+        chemical_potential = self.chemical_potential
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 
@@ -106,9 +114,9 @@ class EGXHamiltonian(BaseHamiltonian):
                 + 2 * np.cos(0.5 * a * k[:, 0]) * np.cos(0.5 * np.sqrt(3) * a * k[:, 1])
             )
         )
-        h[:, 0, 0] -= mu
-        h[:, 1, 1] -= mu
-        h[:, 2, 2] -= mu
+        h[:, 0, 0] -= chemical_potential
+        h[:, 1, 1] -= chemical_potential
+        h[:, 2, 2] -= chemical_potential
 
         return h.squeeze()
 

quant_met/mean_field/free_energy.py

@@ -40,7 +40,7 @@ def free_energy(
     )
 
     integral: float = -np.sum(k_array, axis=-1) / number_k_points + np.sum(
-        np.power(np.abs(hamiltonian.delta_orbital_basis), 2) / hamiltonian.coloumb_orbital_basis
+        np.power(np.abs(hamiltonian.delta_orbital_basis), 2) / hamiltonian.hubbard_int_orbital_basis
     )
 
     return integral

quant_met/mean_field/graphene.py

@@ -18,44 +18,47 @@ class GrapheneHamiltonian(BaseHamiltonian):
 
     def __init__(
         self,
-        t_nn: float,
-        a: float,
-        mu: float,
-        coulomb_gr: float,
+        hopping: float,
+        lattice_constant: float,
+        chemical_potential: float,
+        hubbard_int_gr: float,
         delta: npt.NDArray[np.float64] | None = None,
         *args: tuple[Any, ...],
         **kwargs: tuple[dict[str, Any], ...],
     ) -> None:
         del args
         del kwargs
-        self.t_nn = _validate_float(t_nn, "Hopping")
-        if a <= 0:
+        self.hopping = _validate_float(hopping, "Hopping")
+        if lattice_constant <= 0:
             msg = "Lattice constant must be positive"
             raise ValueError(msg)
-        self.a = _validate_float(a, "Lattice constant")
-        self.mu = _validate_float(mu, "Chemical potential")
-        self.coulomb_gr = _validate_float(coulomb_gr, "Coloumb interaction")
-        self._coloumb_orbital_basis = np.array([self.coulomb_gr, self.coulomb_gr])
+        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
+        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
+        self.hubbard_int_gr = _validate_float(hubbard_int_gr, "hubbard_int interaction")
+        self._hubbard_int_orbital_basis = np.array([self.hubbard_int_gr, self.hubbard_int_gr])
         self._number_of_bands = 2
         if delta is None:
-            self._delta_orbital_basis = np.zeros(2)
+            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
         else:
-            self._delta_orbital_basis = delta
+            if delta.shape != (self.number_of_bands,):
+                msg = "Invalid input value for gaps."
+                raise ValueError(msg)
+            self._delta_orbital_basis = np.astype(delta, np.complex64)
 
     @property
     def number_of_bands(self) -> int:  # noqa: D102
         return self._number_of_bands
 
     @property
-    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
-        return self._coloumb_orbital_basis
+    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
+        return self._hubbard_int_orbital_basis
 
     @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
+    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
         return self._delta_orbital_basis
 
     @delta_orbital_basis.setter
-    def delta_orbital_basis(self, new_delta: npt.NDArray[np.float64]) -> None:
+    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
         self._delta_orbital_basis = new_delta
 
     def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
@@ -74,21 +77,23 @@ class GrapheneHamiltonian(BaseHamiltonian):
 
         """
         assert _check_valid_array(k)
-        t_nn = self.t_nn
-        a = self.a
-        mu = self.mu
+        hopping = self.hopping
+        lattice_constant = self.lattice_constant
+        chemical_potential = self.chemical_potential
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 
         h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
 
-        h[:, 0, 1] = -t_nn * (
-            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] = -hopping * (
+            np.exp(1j * k[:, 1] * lattice_constant / np.sqrt(3))
+            + 2
+            * np.exp(-0.5j * lattice_constant / np.sqrt(3) * k[:, 1])
+            * (np.cos(0.5 * lattice_constant * k[:, 0]))
         )
         h[:, 1, 0] = h[:, 0, 1].conjugate()
-        h[:, 0, 0] -= mu
-        h[:, 1, 1] -= mu
+        h[:, 0, 0] -= chemical_potential
+        h[:, 1, 1] -= chemical_potential
 
         return h.squeeze()
 
@@ -114,8 +119,8 @@ class GrapheneHamiltonian(BaseHamiltonian):
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 
-        t_nn = self.t_nn
-        a = self.a
+        hopping = self.hopping
+        lattice_constant = self.lattice_constant
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 
@@ -123,18 +128,22 @@ class GrapheneHamiltonian(BaseHamiltonian):
 
         if direction == "x":
             h[:, 0, 1] = (
-                t_nn * a * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * np.sin(0.5 * a * k[:, 0])
+                hopping
+                * lattice_constant
+                * np.exp(-0.5j * lattice_constant / np.sqrt(3) * k[:, 1])
+                * np.sin(0.5 * lattice_constant * k[:, 0])
             )
             h[:, 1, 0] = h[:, 0, 1].conjugate()
         else:
             h[:, 0, 1] = (
-                -t_nn
+                -hopping
                 * 1j
-                * a
+                * lattice_constant
                 / np.sqrt(3)
                 * (
-                    np.exp(1j * a / np.sqrt(3) * k[:, 1])
-                    - np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * np.cos(0.5 * a * k[:, 0])
+                    np.exp(1j * lattice_constant / np.sqrt(3) * k[:, 1])
+                    - np.exp(-0.5j * lattice_constant / np.sqrt(3) * k[:, 1])
+                    * np.cos(0.5 * lattice_constant * k[:, 0])
                 )
             )
             h[:, 1, 0] = h[:, 0, 1].conjugate()

quant_met/mean_field/one_band_tight_binding.py

@@ -0,0 +1,129 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for Graphene."""
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from ._utils import _check_valid_array, _validate_float
+from .base_hamiltonian import BaseHamiltonian
+
+
+class OneBandTightBindingHamiltonian(BaseHamiltonian):
+    """Hamiltonian for Graphene."""
+
+    def __init__(
+        self,
+        hopping: float,
+        lattice_constant: float,
+        chemical_potential: float,
+        hubbard_int: float,
+        delta: npt.NDArray[np.float64] | None = None,
+        *args: tuple[Any, ...],
+        **kwargs: tuple[dict[str, Any], ...],
+    ) -> None:
+        del args
+        del kwargs
+        self.hopping = _validate_float(hopping, "Hopping")
+        if lattice_constant <= 0:
+            msg = "Lattice constant must be positive"
+            raise ValueError(msg)
+        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
+        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
+        self.hubbard_int = _validate_float(hubbard_int, "hubbard_int interaction")
+        self._hubbard_int_orbital_basis = np.array([self.hubbard_int])
+        self._number_of_bands = 1
+        if delta is None:
+            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
+        else:
+            if delta.shape != (self.number_of_bands,):
+                msg = "Invalid input value for gaps."
+                raise ValueError(msg)
+            self._delta_orbital_basis = np.astype(delta, np.complex64)
+
+    @property
+    def number_of_bands(self) -> int:  # noqa: D102
+        return self._number_of_bands
+
+    @property
+    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
+        return self._hubbard_int_orbital_basis
+
+    @property
+    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
+        return self._delta_orbital_basis
+
+    @delta_orbital_basis.setter
+    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
+        self._delta_orbital_basis = new_delta
+
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        """
+        Return the normal state Hamiltonian in orbital basis.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Hamiltonian in matrix form.
+
+        """
+        assert _check_valid_array(k)
+        hopping = self.hopping
+        lattice_constant = self.lattice_constant
+        chemical_potential = self.chemical_potential
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        h[:, 0, 0] = (
+            -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
+        )
+        h[:, 0, 0] -= chemical_potential
+
+        return h
+
+    def hamiltonian_derivative(
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        """
+        Deriative of the Hamiltonian.
+
+        Parameters
+        ----------
+        k: :class:`numpy.ndarray`
+            List of k points.
+        direction: str
+            Direction for derivative, either 'x' oder 'y'.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Derivative of Hamiltonian.
+
+        """
+        assert _check_valid_array(k)
+        assert direction in ["x", "y"]
+
+        hopping = self.hopping
+        lattice_constant = self.lattice_constant
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        if direction == "x":
+            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+        else:
+            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+
+        return h.squeeze()

quant_met/mean_field/quantum_metric.py

@@ -11,18 +11,17 @@ from .base_hamiltonian import BaseHamiltonian
 
 
 def quantum_metric(
-    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], band: int
+    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], bands: list[int]
 ) -> npt.NDArray[np.float64]:
     """Calculate the quantum metric in the normal state.
 
     Parameters
     ----------
+    bands
     h : :class:`~quant_met.BaseHamiltonian`
         Hamiltonian object.
     k_grid : :class:`numpy.ndarray`
         List of k points.
-    band : int
-        Index of band for which the quantum metric is calculated.
 
     Returns
     -------
@@ -36,25 +35,26 @@ def quantum_metric(
 
     quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex64)
 
-    for i, direction_1 in enumerate(["x", "y"]):
-        h_derivative_direction_1 = h.hamiltonian_derivative(k=k_grid, direction=direction_1)
-        for j, direction_2 in enumerate(["x", "y"]):
-            h_derivative_direction_2 = h.hamiltonian_derivative(k=k_grid, direction=direction_2)
-            for k_index in range(len(k_grid)):
-                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]
+    for band in bands:
+        for i, direction_1 in enumerate(["x", "y"]):
+            h_derivative_direction_1 = h.hamiltonian_derivative(k=k_grid, direction=direction_1)
+            for j, direction_2 in enumerate(["x", "y"]):
+                h_derivative_direction_2 = h.hamiltonian_derivative(k=k_grid, direction=direction_2)
+                for k_index in range(len(k_grid)):
+                    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
                         )
-                        / (energies[k_index][band] - energies[k_index][n]) ** 2
-                    )
 
     return np.real(quantum_geom_tensor) / number_k_points
 
@@ -66,12 +66,11 @@ def quantum_metric_bdg(
 
     Parameters
     ----------
+    bands
     h : :class:`~quant_met.BaseHamiltonian`
         Hamiltonian object.
     k_grid : :class:`numpy.ndarray`
         List of k points.
-    band : int
-        Index of band for which the quantum metric is calculated.
 
     Returns
     -------
@@ -91,7 +90,7 @@ def quantum_metric_bdg(
             for j, direction_2 in enumerate(["x", "y"]):
                 h_derivative_dir_2 = h.bdg_hamiltonian_derivative(k=k_grid, direction=direction_2)
                 for k_index in range(len(k_grid)):
-                    for n in [i for i in range(h.number_of_bands) if i != band]:
+                    for n in [i for i in range(2 * h.number_of_bands) if i != band]:
                         quantum_geom_tensor[i, j] += (
                             (
                                 bdg_functions[k_index][:, band].conjugate()

quant_met/mean_field/self_consistency.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Self-consistency loop."""
+
+import numpy as np
+
+from quant_met import geometry
+
+from .base_hamiltonian import BaseHamiltonian
+
+
+def self_consistency_loop(
+    h: BaseHamiltonian, beta: np.float64, number_of_k_points: int, epsilon: float
+) -> BaseHamiltonian:
+    """Self-consistency loop.
+
+    Parameters
+    ----------
+    beta
+    number_of_k_points
+    h
+    epsilon
+    """
+    lattice = geometry.Graphene(lattice_constant=np.sqrt(3))
+    k_space_grid = lattice.generate_bz_grid(ncols=number_of_k_points, nrows=number_of_k_points)
+    rng = np.random.default_rng()
+    delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.float64)
+    rng.random(size=h.delta_orbital_basis.shape, out=delta_init)
+    h.delta_orbital_basis = delta_init.astype(np.complex64)
+
+    while True:
+        new_gap = h.gap_equation(k=k_space_grid, beta=beta)
+        if (np.abs(h.delta_orbital_basis - new_gap) < epsilon).all():
+            h.delta_orbital_basis = new_gap
+            return h
+        mixing_greed = 0.2
+        h.delta_orbital_basis = mixing_greed * new_gap + (1 - mixing_greed) * h.delta_orbital_basis

quant_met/plotting/__init__.py

@@ -14,15 +14,25 @@ Functions
 .. autosummary::
    :toctree: generated/
 
+    format_plot
     scatter_into_bz
     plot_bandstructure
-    generate_bz_path
+    plot_superfluid_weight
+    plot_quantum_metric
 """  # noqa: D205, D400
 
-from .plotting import generate_bz_path, plot_bandstructure, scatter_into_bz
+from .plotting import (
+    format_plot,
+    plot_bandstructure,
+    plot_quantum_metric,
+    plot_superfluid_weight,
+    scatter_into_bz,
+)
 
 __all__ = [
     "scatter_into_bz",
+    "format_plot",
     "plot_bandstructure",
-    "generate_bz_path",
+    "plot_superfluid_weight",
+    "plot_quantum_metric",
 ]

quant_met/plotting/plotting.py

@@ -4,8 +4,6 @@
 
 """Methods for plotting data."""
 
-from typing import Any
-
 import matplotlib.axes
 import matplotlib.colors
 import matplotlib.figure
@@ -13,7 +11,28 @@ import matplotlib.pyplot as plt
 import numpy as np
 import numpy.typing as npt
 from matplotlib.collections import Collection, LineCollection
-from numpy import dtype, generic, ndarray
+
+
+def format_plot(
+    ax: matplotlib.axes.Axes,
+) -> matplotlib.axes.Axes:
+    """Format the axis to the predefined style.
+
+    Parameters
+    ----------
+    ax : :class:`matplotlib.axes.Axes`
+
+    Returns
+    -------
+    :class:`matplotlib.axes.Axes`
+
+    """
+    ax.set_box_aspect(1)
+    ax.set_facecolor("lightgray")
+    ax.grid(visible=True)
+    ax.tick_params(axis="both", direction="in", bottom=True, top=True, left=True, right=True)
+
+    return ax
 
 
 def scatter_into_bz(
@@ -107,7 +126,6 @@ def plot_bandstructure(
     :obj:`matplotlib.figure.Figure`
         Figure with the data plotted onto the axis.
 
-
     """
     if fig_in is None or ax_in is None:
         fig, ax = plt.subplots()
@@ -139,92 +157,92 @@ def plot_bandstructure(
         top=float(np.max(bands) + 0.1 * np.max(bands)),
         bottom=float(np.min(bands) - 0.1 * np.abs(np.min(bands))),
     )
-    ax.set_box_aspect(1)
     ax.set_xticks(ticks, labels)
+
+    ax = format_plot(ax)
+
     ax.set_ylabel(r"$E\ [t]$")
-    ax.set_facecolor("lightgray")
-    ax.grid(visible=True)
-    ax.tick_params(axis="both", direction="in", bottom=True, top=True, left=True, right=True)
 
     return fig
 
 
-def _generate_part_of_path(
-    p_0: npt.NDArray[np.float64],
-    p_1: npt.NDArray[np.float64],
-    n: int,
-    length_whole_path: int,
-) -> npt.NDArray[np.float64]:
-    distance = np.linalg.norm(p_1 - p_0)
-    number_of_points = int(n * distance / length_whole_path) + 1
-
-    return np.vstack(
-        [
-            np.linspace(p_0[0], p_1[0], number_of_points),
-            np.linspace(p_0[1], p_1[1], number_of_points),
-        ]
-    ).T[:-1]
-
-
-def generate_bz_path(
-    points: list[tuple[npt.NDArray[np.float64], str]], number_of_points: int = 1000
-) -> tuple[
-    ndarray[Any, dtype[generic | Any]],
-    ndarray[Any, dtype[generic | Any]],
-    list[int | Any],
-    list[str],
-]:
-    """Generate a path through high symmetry points.
+def plot_superfluid_weight(
+    x_data: npt.NDArray[np.float64],
+    sf_weight_geom: npt.NDArray[np.float64],
+    sf_weight_conv: npt.NDArray[np.float64],
+    fig_in: matplotlib.figure.Figure | None = None,
+    ax_in: matplotlib.axes.Axes | None = None,
+) -> matplotlib.figure.Figure:
+    """Plot superfluid weight against some parameter.
 
     Parameters
     ----------
-    points : :class:`numpy.ndarray`
-        Test
-    number_of_points: int
-        Number of point in the whole path.
+    x_data : :class:`numpy.ndarray`
+    sf_weight_geom : :class:`numpy.ndarray`
+    sf_weight_conv : :class:`numpy.ndarray`
+    fig_in : :class:`matplotlib.figure.Figure`, optional
+    ax_in : :class:`matplotlib.axes.Axes`, optional
 
     Returns
     -------
-    :class:`numpy.ndarray`
-        List of two-dimensional k points.
-    :class:`numpy.ndarray`
-        Path for plotting purposes: points between 0 and 1, with appropiate spacing.
-    list[float]
-        A list of ticks for the plotting path.
-    list[str]
-        A list of labels for the plotting path.
+    :obj:`matplotlib.figure.Figure`
+        Figure with the data plotted onto the axis.
 
     """
-    n = number_of_points
-
-    cycle = [np.linalg.norm(points[i][0] - points[i + 1][0]) for i in range(len(points) - 1)]
-    cycle.append(np.linalg.norm(points[-1][0] - points[0][0]))
-
-    length_whole_path = np.sum(np.array([cycle]))
-
-    ticks = [0]
-    ticks.extend([np.sum(cycle[0 : i + 1]) / length_whole_path for i in range(len(cycle) - 1)])
-    ticks.append(1)
-    labels = [rf"${points[i][1]}$" for i in range(len(points))]
-    labels.append(rf"${points[0][1]}$")
-
-    whole_path_plot = np.concatenate(
-        [
-            np.linspace(
-                ticks[i],
-                ticks[i + 1],
-                num=int(n * cycle[i] / length_whole_path),
-                endpoint=False,
-            )
-            for i in range(len(ticks) - 1)
-        ]
+    if fig_in is None or ax_in is None:
+        fig, ax = plt.subplots()
+    else:
+        fig, ax = fig_in, ax_in
+
+    ax.fill_between(
+        x_data, 0, np.abs(sf_weight_geom), color="black", fc="#0271BB", label="geometric", hatch="-"
     )
+    ax.fill_between(
+        x_data,
+        np.abs(sf_weight_geom),
+        np.abs(sf_weight_geom) + np.abs(sf_weight_conv),
+        color="black",
+        fc="#E2001A",
+        label="conventional",
+        hatch="//",
+    )
+    ax.plot(x_data, np.abs(sf_weight_geom) + np.abs(sf_weight_conv), "x--", color="black")
+
+    ax = format_plot(ax)
+    ax.set_ylabel(r"$D_S\ [t]$")
+
+    return fig
 
-    points_path = [
-        _generate_part_of_path(points[i][0], points[i + 1][0], n, length_whole_path)
-        for i in range(len(points) - 1)
-    ]
-    points_path.append(_generate_part_of_path(points[-1][0], points[0][0], n, length_whole_path))
-    whole_path = np.concatenate(points_path)
 
-    return whole_path, whole_path_plot, ticks, labels
+def plot_quantum_metric(
+    x_data: npt.NDArray[np.float64],
+    quantum_metric: npt.NDArray[np.float64],
+    fig_in: matplotlib.figure.Figure | None = None,
+    ax_in: matplotlib.axes.Axes | None = None,
+) -> matplotlib.figure.Figure:
+    """Plot quantum metric against some parameter.
+
+    Parameters
+    ----------
+    x_data : :class:`numpy.ndarray`
+    quantum_metric : :class:`numpy.ndarray`
+    fig_in : :class:`matplotlib.figure.Figure`, optional
+    ax_in : :class:`matplotlib.axes.Axes`, optional
+
+    Returns
+    -------
+    :obj:`matplotlib.figure.Figure`
+        Figure with the data plotted onto the axis.
+
+    """
+    if fig_in is None or ax_in is None:
+        fig, ax = plt.subplots()
+    else:
+        fig, ax = fig_in, ax_in
+
+    ax.plot(x_data, quantum_metric, "x--")
+
+    ax = format_plot(ax)
+    ax.set_ylabel(r"$M\ [t]$")
+
+    return fig

{quant_met-0.0.5.dist-info → quant_met-0.0.7.dist-info}/METADATA

@@ -1,18 +1,21 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.5
+Version: 0.0.7
 Summary: Calculate superconductivity in flat-band systems.
+Home-page: https://quant-met.tjarksievers.de
 Author: Tjark Sievers
 Author-email: tsievers@physnet.uni-hamburg.de
 Requires-Python: >=3.11,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: h5py (>=3.11.0,<4.0.0)
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: h5py (>=3.12.1,<4.0.0)
 Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
-Requires-Dist: numpy (>=2.0.0,<3.0.0)
-Requires-Dist: pandas (>=2.2.2,<3.0.0)
-Requires-Dist: scipy (>=1.14.0,<2.0.0)
+Requires-Dist: numpy (>=2.1.2,<3.0.0)
+Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: scipy (>=1.14.1,<2.0.0)
+Project-URL: Repository, https://github.com/Ruberhauptmann/quant-met
 Description-Content-Type: text/markdown
 
 <!--
@@ -30,7 +33,7 @@ SPDX-License-Identifier: MIT
 
 This is a python package to treat superconductivity in flat-band systems.
 
-* Documentation: [quant-met.readthedocs.io](https://quant-met.readthedocs.io/en/latest/)
+* Documentation: [quant-met.tjarksievers.de](https://quant-met.tjarksievers.de)
 
 ## Installation
 
@@ -41,7 +44,7 @@ pip install quant-met
 
 ## Usage
 
-For usage examples see [documentation](https://quant-met.readthedocs.io/en/latest/examples.html).
+For usage examples see [documentation](https://quant-met.tjarksievers.de/en/latest/examples.html).
 
 ## Contributing
 
@@ -69,5 +72,10 @@ After pushing your branch, all tests will also be run via Github Actions.
 Using `pre-commit`, automatic linting and formatting is done before every commit, which may cause the first commit to fail.
 A second try should then succeed.
 
+To fix the reuse copyright:
+```bash
+  reuse annotate --license=MIT --copyright="Tjark Sievers" --skip-unrecognised -r .
+```
+
 After you are done working on an issue and all tests are running successful, you can add a new piece of changelog via `scriv create` and make a pull request.
 

quant_met-0.0.7.dist-info/RECORD

@@ -0,0 +1,24 @@
+quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
+quant_met/geometry/__init__.py,sha256=dWT4yYDBKsJUI9Hv1DDCGtqx-lDLQF6mH7xSRLomvD4,508
+quant_met/geometry/base_lattice.py,sha256=QVHuZVy6bOvBSITY_mKhr7hYW1jHJ5UAm3sMCFClYZ0,2276
+quant_met/geometry/bz_path.py,sha256=q_eNhKYjhKLeFNjio8BdKVsseO6slQKlwKKSQQYTVJQ,2497
+quant_met/geometry/graphene.py,sha256=37CZXj_NpFsnR1pPE_jFbrAiiMFhs1Q3FLlcgqG2pwM,1264
+quant_met/geometry/square.py,sha256=1fSrHab07uB6ildNzlbTwINJvPa5C2Az0B0uuOVJmMc,1216
+quant_met/mean_field/__init__.py,sha256=sXKp572huLdcqYEj0b9ojgefLiOiIHV7CH2XN54WU7E,1368
+quant_met/mean_field/_utils.py,sha256=plkx6eYjyYV3CT3BWwlulqW7L-Q0t1TzZTLR4k7u0dg,666
+quant_met/mean_field/base_hamiltonian.py,sha256=kUZ6-eU525l_9e3YoSA66HsE9c5isUNjNqOh6T71OGk,11773
+quant_met/mean_field/eg_x.py,sha256=w-6UcSVYPC-B58152aJpp0HDNoxyy46c6eXNZCGHi6Q,5805
+quant_met/mean_field/free_energy.py,sha256=59GPLJhyllyAJEZteAr6iYqCbHGFsmV1zcYxJ8Aw9Ao,3448
+quant_met/mean_field/graphene.py,sha256=8xMR43ndL5oJ7BbYBVGxWTLU5BscsE8ixTpPlCZzKO8,4917
+quant_met/mean_field/one_band_tight_binding.py,sha256=ZfZQZxcqoKRtx3oomQyXwuong81K5vKKg0cyjs5JJ48,4138
+quant_met/mean_field/quantum_metric.py,sha256=3OiwSDxz_Pw4uioGO18lYyYb_myK2kSCwF9AloUZIt4,3870
+quant_met/mean_field/self_consistency.py,sha256=r2J9mEEcgWkI92exEol0tkwoWlM9ithodgNzdKEQpfs,1193
+quant_met/mean_field/superfluid_weight.py,sha256=840Fe3aHOVz1W7hi5GrX69_QxQ3vmdy3H0_B852dZqA,3971
+quant_met/plotting/__init__.py,sha256=s-DS22impzozKiS7p-v3yCmeccDQfXmBbtPiYMKwH0Y,620
+quant_met/plotting/plotting.py,sha256=_SqL8GrDqlBtccHnUWpZPqdSJy0Yd_4dhFdUOxOzPpY,7447
+quant_met/utils.py,sha256=Tvw_YfqjIWx0FPGSReikSnw9xfN-T2dpQZN-KPMa69A,1709
+quant_met-0.0.7.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.7.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.7.dist-info/METADATA,sha256=eq-LGEGvKZsMw_MC5guVaJvrfvF24OmMkNLj6l74CRo,2880
+quant_met-0.0.7.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quant_met-0.0.7.dist-info/RECORD,,

{quant_met-0.0.5.dist-info → quant_met-0.0.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

quant_met-0.0.5.dist-info/RECORD

@@ -1,17 +0,0 @@
-quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
-quant_met/mean_field/__init__.py,sha256=msHp5Y5cuHjqr_EdC9jS9JKpeAi6CBHggtxrG_psDRk,1182
-quant_met/mean_field/_utils.py,sha256=plkx6eYjyYV3CT3BWwlulqW7L-Q0t1TzZTLR4k7u0dg,666
-quant_met/mean_field/base_hamiltonian.py,sha256=7rNBbkoSSaIQVg4GiKDI1WaSZxJiGR26bdidh9uygzw,8812
-quant_met/mean_field/eg_x.py,sha256=y_DWBoyRaHVIof_itAgHaoaFEEssY_Q9mhvsKC7DxdM,5286
-quant_met/mean_field/free_energy.py,sha256=FSGCHoBO1myHGwGQ8CqGu7_08whH0Ot3ikZhBu27tyM,3444
-quant_met/mean_field/graphene.py,sha256=rKD2UjB0blN4ALePk4bQlg0XahHoe_3mCqRAvEUGiqI,4162
-quant_met/mean_field/quantum_metric.py,sha256=y-ky4bU566TNBxldaYWyloqojfpTODo9gbn4TPe6-4A,3902
-quant_met/mean_field/superfluid_weight.py,sha256=840Fe3aHOVz1W7hi5GrX69_QxQ3vmdy3H0_B852dZqA,3971
-quant_met/plotting/__init__.py,sha256=QRQ3TNb0PNQi2lWXY0LHKgYSRuegM1N3dVVs9146Zug,457
-quant_met/plotting/plotting.py,sha256=iVTFZ9tQz_GalzqbQhxCiNWOhYHJM4wiZPTjXaXnApM,7326
-quant_met/utils.py,sha256=Tvw_YfqjIWx0FPGSReikSnw9xfN-T2dpQZN-KPMa69A,1709
-quant_met-0.0.5.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.5.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.5.dist-info/METADATA,sha256=Kh99UUBpu1y3cOU1wYektey2RuA1a5Xd_acXxMQnsyc,2598
-quant_met-0.0.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-quant_met-0.0.5.dist-info/RECORD,,