quant-met 0.0.3__tar.gz → 0.0.4__tar.gz

{quant_met-0.0.3 → quant_met-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.3
+Version: 0.0.4
 Summary: Calculate superconductivity in flat-band systems.
 Author: Tjark Sievers
 Author-email: tsievers@physnet.uni-hamburg.de

{quant_met-0.0.3 → quant_met-0.0.4}/pyproject.toml

@@ -8,7 +8,7 @@ requires-python = ">=3.11"
 
 [tool.poetry]
 name = "quant-met"
-version = "0.0.3"
+version = "0.0.4"
 description = "Calculate superconductivity in flat-band systems."
 authors = ["Tjark Sievers <tsievers@physnet.uni-hamburg.de>"]
 readme = "README.md"
@@ -64,6 +64,8 @@ ignore = [
     "Q003",
     "S101", # This checks against using assert
     "PLR0913", # This checks against using more than 5 function arguments
+    "PLR2004", # Check against "magic values"
+    "T201", # Warn about print statements
 ]
 
 

{quant_met-0.0.3 → quant_met-0.0.4}/src/quant_met/mean_field/__init__.py

@@ -44,12 +44,13 @@ from .free_energy import (
     free_energy_uniform_pairing,
 )
 from .graphene import GrapheneHamiltonian
-from .quantum_metric import quantum_metric
+from .quantum_metric import quantum_metric, quantum_metric_bdg
 from .superfluid_weight import superfluid_weight
 
 __all__ = [
     "superfluid_weight",
     "quantum_metric",
+    "quantum_metric_bdg",
     "free_energy",
     "free_energy_complex_gap",
     "free_energy_real_gap",

{quant_met-0.0.3 → quant_met-0.0.4}/src/quant_met/mean_field/base_hamiltonian.py

@@ -54,29 +54,44 @@ class BaseHamiltonian(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def _hamiltonian_one_point(self, k_point: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+    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.
+
+        """
         raise NotImplementedError
 
     @abstractmethod
-    def _hamiltonian_derivative_one_point(
-        self, k_point: npt.NDArray[np.float64], directions: str
+    def hamiltonian_derivative(
+        self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
-        raise NotImplementedError
+        """
+        Deriative of the Hamiltonian.
 
-    def _bdg_hamiltonian_one_point(
-        self, k_point: npt.NDArray[np.float64]
-    ) -> npt.NDArray[np.complex64]:
-        delta_matrix: npt.NDArray[np.complex64] = np.zeros(
-            shape=(self.number_of_bands, self.number_of_bands), dtype=np.complex64
-        )
-        np.fill_diagonal(delta_matrix, self.delta_orbital_basis)
+        Parameters
+        ----------
+        k: :class:`numpy.ndarray`
+            List of k points.
+        direction: str
+            Direction for derivative, either 'x' oder 'y'.
 
-        return np.block(
-            [
-                [self.hamiltonian(k_point), delta_matrix],
-                [np.conjugate(delta_matrix), -np.conjugate(self.hamiltonian(-k_point))],
-            ]
-        )
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Derivative of Hamiltonian.
+
+        """
+        raise NotImplementedError
 
     def save(self, filename: pathlib.Path) -> None:
         """
@@ -88,7 +103,7 @@ class BaseHamiltonian(ABC):
             Filename to save the Hamiltonian to, should end in .hdf5
 
         """
-        with h5py.File(f"{filename}", "a") as f:
+        with h5py.File(f"{filename}", "w") as f:
             f.create_dataset("delta", data=self.delta_orbital_basis)
             for key, value in vars(self).items():
                 if not key.startswith("_"):
@@ -126,42 +141,32 @@ class BaseHamiltonian(ABC):
             BdG Hamiltonian.
 
         """
-        if np.isnan(k).any() or np.isinf(k).any():
-            msg = "k is NaN or Infinity"
-            raise ValueError(msg)
+        assert _check_valid_array(k)
         if k.ndim == 1:
-            h = self._bdg_hamiltonian_one_point(k)
-        else:
-            h = np.array([self._bdg_hamiltonian_one_point(k) for k in k])
-        return h
+            k = np.expand_dims(k, axis=0)
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        """
-        Return the normal state Hamiltonian in orbital basis.
+        h = np.zeros(
+            (k.shape[0], 2 * self.number_of_bands, 2 * self.number_of_bands), dtype=np.complex64
+        )
 
-        Parameters
-        ----------
-        k : :class:`numpy.ndarray`
-            List of k points.
+        h[:, 0 : self.number_of_bands, 0 : self.number_of_bands] = self.hamiltonian(k)
+        h[
+            :,
+            self.number_of_bands : 2 * self.number_of_bands,
+            self.number_of_bands : 2 * self.number_of_bands,
+        ] = -self.hamiltonian(-k).conjugate()
 
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Hamiltonian in matrix form.
+        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()
 
-        """
-        assert _check_valid_array(k)
-        if k.ndim == 1:
-            h = self._hamiltonian_one_point(k)
-        else:
-            h = np.array([self._hamiltonian_one_point(k) for k in k])
-        return h
+        return h.squeeze()
 
-    def hamiltonian_derivative(
+    def bdg_hamiltonian_derivative(
         self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
         """
-        Deriative of the Hamiltonian.
+        Deriative of the BdG Hamiltonian.
 
         Parameters
         ----------
@@ -178,10 +183,22 @@ class BaseHamiltonian(ABC):
         """
         assert _check_valid_array(k)
         if k.ndim == 1:
-            h = self._hamiltonian_derivative_one_point(k, direction)
-        else:
-            h = np.array([self._hamiltonian_derivative_one_point(k, direction) for k in k])
-        return h
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros(
+            (k.shape[0], 2 * self.number_of_bands, 2 * self.number_of_bands), dtype=np.complex64
+        )
+
+        h[:, 0 : self.number_of_bands, 0 : self.number_of_bands] = self.hamiltonian_derivative(
+            k, direction
+        )
+        h[
+            :,
+            self.number_of_bands : 2 * self.number_of_bands,
+            self.number_of_bands : 2 * self.number_of_bands,
+        ] = -self.hamiltonian_derivative(-k, direction).conjugate()
+
+        return h.squeeze()
 
     def diagonalize_nonint(
         self, k: npt.NDArray[np.float64]
@@ -203,20 +220,20 @@ class BaseHamiltonian(ABC):
 
         """
         k_point_matrix = self.hamiltonian(k)
+        if k_point_matrix.ndim == 2:
+            k_point_matrix = np.expand_dims(k_point_matrix, axis=0)
+            k = np.expand_dims(k, axis=0)
 
-        if k.ndim == 1:
-            band_energies, bloch_wavefunctions = np.linalg.eigh(k_point_matrix)
-        else:
-            bloch_wavefunctions = np.zeros(
-                (len(k), self.number_of_bands, self.number_of_bands),
-                dtype=complex,
-            )
-            band_energies = np.zeros((len(k), self.number_of_bands))
+        bloch_wavefunctions = np.zeros(
+            (len(k), self.number_of_bands, self.number_of_bands),
+            dtype=complex,
+        )
+        band_energies = np.zeros((len(k), self.number_of_bands))
 
-            for i in range(len(k)):
-                band_energies[i], bloch_wavefunctions[i] = np.linalg.eigh(k_point_matrix[i])
+        for i in range(len(k)):
+            band_energies[i], bloch_wavefunctions[i] = np.linalg.eigh(k_point_matrix[i])
 
-        return band_energies, bloch_wavefunctions
+        return band_energies.squeeze(), bloch_wavefunctions.squeeze()
 
     def diagonalize_bdg(
         self, k: npt.NDArray[np.float64]
@@ -238,20 +255,20 @@ class BaseHamiltonian(ABC):
 
         """
         bdg_matrix = self.bdg_hamiltonian(k)
+        if bdg_matrix.ndim == 2:
+            bdg_matrix = np.expand_dims(bdg_matrix, axis=0)
+            k = np.expand_dims(k, axis=0)
 
-        if k.ndim == 1:
-            bdg_energies, bdg_wavefunctions = np.linalg.eigh(bdg_matrix)
-        else:
-            bdg_wavefunctions = np.zeros(
-                (len(k), 2 * self.number_of_bands, 2 * self.number_of_bands),
-                dtype=np.complex64,
-            )
-            bdg_energies = np.zeros((len(k), 2 * self.number_of_bands))
+        bdg_wavefunctions = np.zeros(
+            (len(k), 2 * self.number_of_bands, 2 * self.number_of_bands),
+            dtype=np.complex64,
+        )
+        bdg_energies = np.zeros((len(k), 2 * self.number_of_bands))
 
-            for i in range(len(k)):
-                bdg_energies[i], bdg_wavefunctions[i] = np.linalg.eigh(bdg_matrix[i])
+        for i in range(len(k)):
+            bdg_energies[i], bdg_wavefunctions[i] = np.linalg.eigh(bdg_matrix[i])
 
-        return bdg_energies, bdg_wavefunctions
+        return bdg_energies.squeeze(), bdg_wavefunctions.squeeze()
 
     def calculate_bandstructure(
         self,
@@ -274,23 +291,20 @@ class BaseHamiltonian(ABC):
             Band structure.
 
         """
-        k_point_matrix = self.hamiltonian(k)
-
         results = pd.DataFrame(
             index=range(len(k)),
             dtype=float,
         )
+        energies, wavefunctions = self.diagonalize_nonint(k)
 
-        for i in range(len(k)):
-            energies, eigenvectors = np.linalg.eigh(k_point_matrix[i])
-
+        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}"] = energies[band_index]
+                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(eigenvectors[:, band_index], overlaps[0])) ** 2
-                        - np.abs(np.dot(eigenvectors[:, band_index], overlaps[1])) ** 2
+                        np.abs(np.dot(wavefunction_k[:, band_index], overlaps[0])) ** 2
+                        - np.abs(np.dot(wavefunction_k[:, band_index], overlaps[1])) ** 2
                     )
 
         return results

{quant_met-0.0.3 → quant_met-0.0.4}/src/quant_met/mean_field/eg_x.py

@@ -4,10 +4,12 @@
 
 """Provides the implementation for the EG-X model."""
 
+from typing import Any
+
 import numpy as np
 import numpy.typing as npt
 
-from ._utils import _validate_float
+from ._utils import _check_valid_array, _validate_float
 from .base_hamiltonian import BaseHamiltonian
 
 
@@ -24,7 +26,11 @@ class EGXHamiltonian(BaseHamiltonian):
         coloumb_gr: float,
         coloumb_x: float,
         delta: npt.NDArray[np.complex64] | None = None,
+        *args: tuple[Any, ...],
+        **kwargs: tuple[dict[str, Any], ...],
     ) -> None:
+        del args
+        del kwargs
         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")
@@ -55,66 +61,113 @@ class EGXHamiltonian(BaseHamiltonian):
     def number_of_bands(self) -> int:  # noqa: D102
         return self._number_of_bands
 
-    def _hamiltonian_derivative_one_point(
+    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)
+
+        t_gr = self.hopping_gr
+        t_x = self.hopping_x
+        a = self.lattice_constant
+        v = self.hopping_x_gr_a
+        mu = self.mu
+        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_gr * (
+            np.exp(1j * k[:, 1] * a / np.sqrt(3))
+            + 2 * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * (np.cos(0.5 * a * k[:, 0]))
+        )
+
+        h[:, 1, 0] = h[:, 0, 1].conjugate()
+
+        h[:, 2, 0] = v
+        h[:, 0, 2] = v
+
+        h[:, 2, 2] = (
+            -2
+            * t_x
+            * (
+                np.cos(a * k[:, 0])
+                + 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
+
+        return h.squeeze()
+
+    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"]
 
         t_gr = self.hopping_gr
         t_x = self.hopping_x
         a = self.lattice_constant
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
 
-        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+        h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
 
         if direction == "x":
-            h[0, 1] = t_gr * a * np.exp(-0.5j * a / np.sqrt(3) * k[1]) * np.sin(0.5 * a * k[0])
-            h[1, 0] = h[0, 1].conjugate()
-            h[2, 2] = (
+            h[:, 0, 1] = (
+                t_gr * a * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * np.sin(0.5 * a * k[:, 0])
+            )
+            h[:, 1, 0] = h[:, 0, 1].conjugate()
+            h[:, 2, 2] = (
                 2
                 * a
                 * t_x
-                * (np.sin(a * k[0]) + np.sin(0.5 * a * k[0]) * np.cos(0.5 * np.sqrt(3) * a * k[1]))
+                * (
+                    np.sin(a * k[:, 0])
+                    + np.sin(0.5 * a * k[:, 0]) * np.cos(0.5 * np.sqrt(3) * a * k[:, 1])
+                )
             )
         else:
-            h[0, 1] = (
+            h[:, 0, 1] = (
                 -t_gr
                 * 1j
                 * a
                 / 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 * a / np.sqrt(3) * k[:, 1])
+                    - np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * np.cos(0.5 * a * k[:, 0])
                 )
             )
-            h[1, 0] = h[0, 1].conjugate()
-            h[2, 2] = np.sqrt(3) * a * t_x * np.cos(0.5 * np.sqrt(3) * a * k[1])
-
-        return h
-
-    def _hamiltonian_one_point(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        t_gr = self.hopping_gr
-        t_x = self.hopping_x
-        a = self.lattice_constant
-        v = self.hopping_x_gr_a
-        mu = self.mu
-
-        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
-
-        h[0, 1] = -t_gr * (
-            np.exp(1j * k[1] * a / np.sqrt(3))
-            + 2 * np.exp(-0.5j * a / np.sqrt(3) * k[1]) * (np.cos(0.5 * a * k[0]))
-        )
-
-        h[1, 0] = h[0, 1].conjugate()
-
-        h[2, 0] = v
-        h[0, 2] = v
-
-        h[2, 2] = (
-            -2
-            * t_x
-            * (np.cos(a * k[0]) + 2 * np.cos(0.5 * a * k[0]) * np.cos(0.5 * np.sqrt(3) * a * k[1]))
-        )
-        h -= mu * np.eye(3, dtype=np.complex64)
+            h[:, 1, 0] = h[:, 0, 1].conjugate()
+            h[:, 2, 2] = np.sqrt(3) * a * t_x * np.cos(0.5 * np.sqrt(3) * a * k[:, 1])
 
-        return h
+        return h.squeeze()

quant_met-0.0.4/src/quant_met/mean_field/graphene.py

@@ -0,0 +1,142 @@
+# 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 GrapheneHamiltonian(BaseHamiltonian):
+    """Hamiltonian for Graphene."""
+
+    def __init__(
+        self,
+        t_nn: float,
+        a: float,
+        mu: float,
+        coulomb_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:
+            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._number_of_bands = 2
+        if delta is None:
+            self._delta_orbital_basis = np.zeros(2)
+        else:
+            self._delta_orbital_basis = delta
+
+    @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
+
+    @property
+    def delta_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
+        return self._delta_orbital_basis
+
+    @delta_orbital_basis.setter
+    def delta_orbital_basis(self, new_delta: npt.NDArray[np.float64]) -> 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)
+        t_nn = self.t_nn
+        a = self.a
+        mu = self.mu
+        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[:, 1, 0] = h[:, 0, 1].conjugate()
+        h[:, 0, 0] -= mu
+        h[:, 1, 1] -= mu
+
+        return h.squeeze()
+
+    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"]
+
+        t_nn = self.t_nn
+        a = self.a
+        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, 1] = (
+                t_nn * a * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * np.sin(0.5 * a * k[:, 0])
+            )
+            h[:, 1, 0] = h[:, 0, 1].conjugate()
+        else:
+            h[:, 0, 1] = (
+                -t_nn
+                * 1j
+                * a
+                / 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])
+                )
+            )
+            h[:, 1, 0] = h[:, 0, 1].conjugate()
+
+        return h.squeeze()

quant_met-0.0.4/src/quant_met/mean_field/quantum_metric.py

@@ -0,0 +1,108 @@
+# 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 .base_hamiltonian import BaseHamiltonian
+
+
+def quantum_metric(
+    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], band: int
+) -> npt.NDArray[np.float64]:
+    """Calculate the quantum metric in the normal state.
+
+    Parameters
+    ----------
+    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
+    -------
+    :class:`numpy.ndarray`
+        Quantum metric in the normal state.
+
+    """
+    energies, bloch = h.diagonalize_nonint(k_grid)
+
+    number_k_points = len(k_grid)
+
+    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]
+                        )
+                        / (energies[k_index][band] - energies[k_index][n]) ** 2
+                    )
+
+    return np.real(quantum_geom_tensor) / number_k_points
+
+
+def quantum_metric_bdg(
+    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], band: int
+) -> npt.NDArray[np.float64]:
+    """Calculate the quantum metric in the BdG state.
+
+    Parameters
+    ----------
+    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
+    -------
+    :class:`numpy.ndarray`
+        Quantum metric in the normal state.
+
+    """
+    energies, bdg_functions = h.diagonalize_bdg(k_grid)
+
+    number_k_points = len(k_grid)
+
+    quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex64)
+
+    for i, direction_1 in enumerate(["x", "y"]):
+        h_derivative_direction_1 = h.bdg_hamiltonian_derivative(k=k_grid, direction=direction_1)
+        for j, direction_2 in enumerate(["x", "y"]):
+            h_derivative_direction_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]:
+                    quantum_geom_tensor[i, j] += (
+                        (
+                            bdg_functions[k_index][:, band].conjugate()
+                            @ h_derivative_direction_1[k_index]
+                            @ bdg_functions[k_index][:, n]
+                        )
+                        * (
+                            bdg_functions[k_index][:, n].conjugate()
+                            @ h_derivative_direction_2[k_index]
+                            @ bdg_functions[k_index][:, band]
+                        )
+                        / (energies[k_index][band] - energies[k_index][n]) ** 2
+                    )
+
+    return np.real(quantum_geom_tensor) / number_k_points

{quant_met-0.0.3 → quant_met-0.0.4}/src/quant_met/mean_field/superfluid_weight.py

@@ -63,7 +63,7 @@ def _current_operator(
     for m in range(h.number_of_bands):
         for n in range(h.number_of_bands):
             j[m, n] = (
-                np.conjugate(bloch[:, m])
+                bloch[:, m].conjugate()
                 @ h.hamiltonian_derivative(direction=direction, k=k)
                 @ bloch[:, n]
             )
@@ -89,7 +89,7 @@ def _w_matrix(
     for i in range(2 * h.number_of_bands):
         for m in range(h.number_of_bands):
             w_minus[i, m] = (
-                np.tensordot(np.conjugate(bloch[:, m]), np.array([0, 1]), axes=0).reshape(-1)
+                np.tensordot(bloch[:, m].conjugate(), np.array([0, 1]), axes=0).reshape(-1)
                 @ bdg_functions[:, i]
             )
 
@@ -124,9 +124,9 @@ def _c_factor(h: BaseHamiltonian, k: npt.NDArray[np.float64]) -> npt.NDArray[np.
                                 c_tmp -= _fermi_dirac_derivative()
 
                             c_tmp *= (
-                                np.conjugate(w_minus[i, m])
+                                w_minus[i, m].conjugate()
                                 * w_plus[j, n]
-                                * np.conjugate(w_minus[j, p])
+                                * w_minus[j, p].conjugate()
                                 * w_minus[i, q]
                             )
 

quant_met-0.0.3/src/quant_met/mean_field/graphene.py

@@ -1,97 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Provides the implementation for Graphene."""
-
-import numpy as np
-import numpy.typing as npt
-
-from ._utils import _validate_float
-from .base_hamiltonian import BaseHamiltonian
-
-
-class GrapheneHamiltonian(BaseHamiltonian):
-    """Hamiltonian for Graphene."""
-
-    def __init__(
-        self,
-        t_nn: float,
-        a: float,
-        mu: float,
-        coulomb_gr: float,
-        delta: npt.NDArray[np.float64] | None = None,
-    ) -> None:
-        self.t_nn = _validate_float(t_nn, "Hopping")
-        if a <= 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._number_of_bands = 2
-        if delta is None:
-            self._delta_orbital_basis = np.zeros(2)
-        else:
-            self._delta_orbital_basis = delta
-
-    @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
-
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
-        return self._delta_orbital_basis
-
-    @delta_orbital_basis.setter
-    def delta_orbital_basis(self, new_delta: npt.NDArray[np.float64]) -> None:
-        self._delta_orbital_basis = new_delta
-
-    def _hamiltonian_derivative_one_point(
-        self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:
-        assert direction in ["x", "y"]
-
-        t_nn = self.t_nn
-        a = self.a
-
-        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
-
-        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])
-            h[1, 0] = h[0, 1].conjugate()
-        else:
-            h[0, 1] = (
-                -t_nn
-                * 1j
-                * a
-                / 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])
-                )
-            )
-            h[1, 0] = h[0, 1].conjugate()
-
-        return h
-
-    def _hamiltonian_one_point(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        t_nn = self.t_nn
-        a = self.a
-        mu = self.mu
-
-        h = np.zeros((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[1, 0] = h[0, 1].conjugate()
-        h -= mu * np.eye(2)
-
-        return h

quant_met-0.0.3/src/quant_met/mean_field/quantum_metric.py

@@ -1,59 +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 .base_hamiltonian import BaseHamiltonian
-
-
-def quantum_metric(
-    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], band: int
-) -> npt.NDArray[np.float64]:
-    """Calculate the quantum metric in the normal state.
-
-    Parameters
-    ----------
-    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
-    -------
-    :class:`numpy.ndarray`
-        Quantum metric in the normal state.
-
-    """
-    energies, bloch = h.diagonalize_nonint(k_grid)
-
-    number_k_points = len(k_grid)
-
-    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] += (
-                        (
-                            np.conjugate(bloch[k_index][:, band])
-                            @ h_derivative_direction_1[k_index]
-                            @ bloch[k_index][:, n]
-                        )
-                        * (
-                            np.conjugate(bloch[k_index][:, n])
-                            @ 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