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

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/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/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/mean_field/graphene.py

@@ -4,10 +4,12 @@
 
 """Provides the implementation for Graphene."""
 
+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
 
 
@@ -21,7 +23,11 @@ class GrapheneHamiltonian(BaseHamiltonian):
         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"
@@ -52,46 +58,85 @@ class GrapheneHamiltonian(BaseHamiltonian):
     def delta_orbital_basis(self, new_delta: npt.NDArray[np.float64]) -> None:
         self._delta_orbital_basis = new_delta
 
-    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_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((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_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()
+            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] = (
+            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])
+                    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)
+            h[:, 1, 0] = h[:, 0, 1].conjugate()
 
-        return h
+        return h.squeeze()

quant_met/mean_field/quantum_metric.py

@@ -44,12 +44,12 @@ def quantum_metric(
                 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])
+                            bloch[k_index][:, band].conjugate()
                             @ h_derivative_direction_1[k_index]
                             @ bloch[k_index][:, n]
                         )
                         * (
-                            np.conjugate(bloch[k_index][:, n])
+                            bloch[k_index][:, n].conjugate()
                             @ h_derivative_direction_2[k_index]
                             @ bloch[k_index][:, band]
                         )
@@ -57,3 +57,53 @@ def quantum_metric(
                     )
 
     return np.real(quantum_geom_tensor) / number_k_points
+
+
+def quantum_metric_bdg(
+    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], bands: list[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 band in bands:
+        for i, direction_1 in enumerate(["x", "y"]):
+            h_derivative_dir_1 = h.bdg_hamiltonian_derivative(k=k_grid, direction=direction_1)
+            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]:
+                        quantum_geom_tensor[i, j] += (
+                            (
+                                bdg_functions[k_index][:, band].conjugate()
+                                @ h_derivative_dir_1[k_index]
+                                @ bdg_functions[k_index][:, n]
+                            )
+                            * (
+                                bdg_functions[k_index][:, n].conjugate()
+                                @ h_derivative_dir_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/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]
             )
@@ -71,34 +71,8 @@ def _current_operator(
     return j
 
 
-def _w_matrix(
-    h: BaseHamiltonian, k: npt.NDArray[np.float64]
-) -> tuple[npt.NDArray[np.complex64], npt.NDArray[np.complex64]]:
-    _, bloch = h.diagonalize_nonint(k=k)
-    _, bdg_functions = h.diagonalize_bdg(k=k)
-
-    w_plus = np.zeros((2 * h.number_of_bands, h.number_of_bands), dtype=np.complex64)
-    for i in range(2 * h.number_of_bands):
-        for m in range(h.number_of_bands):
-            w_plus[i, m] = (
-                np.tensordot(bloch[:, m], np.array([1, 0]), axes=0).reshape(-1)
-                @ bdg_functions[:, i]
-            )
-
-    w_minus = np.zeros((2 * h.number_of_bands, h.number_of_bands), dtype=np.complex64)
-    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)
-                @ bdg_functions[:, i]
-            )
-
-    return w_plus, w_minus
-
-
 def _c_factor(h: BaseHamiltonian, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-    bdg_energies, _ = h.diagonalize_bdg(k)
-    w_plus, w_minus = _w_matrix(h, k)
+    bdg_energies, bdg_functions = h.diagonalize_bdg(k)
     c_mnpq = np.zeros(
         shape=(
             h.number_of_bands,
@@ -124,10 +98,10 @@ 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_plus[j, n]
-                                * np.conjugate(w_minus[j, p])
-                                * w_minus[i, q]
+                                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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.3
+Version: 0.0.5
 Summary: Calculate superconductivity in flat-band systems.
 Author: Tjark Sievers
 Author-email: tsievers@physnet.uni-hamburg.de
@@ -9,7 +9,7 @@ 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)
-Requires-Dist: matplotlib (>=3.9.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)

quant_met-0.0.5.dist-info/RECORD

@@ -0,0 +1,17 @@
+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,,

quant_met-0.0.3.dist-info/RECORD

@@ -1,17 +0,0 @@
-quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
-quant_met/mean_field/__init__.py,sha256=kBkGItunNits1SrSMRIfKkqeSXvzbUJQS-OkcV-0zmc,1136
-quant_met/mean_field/_utils.py,sha256=plkx6eYjyYV3CT3BWwlulqW7L-Q0t1TzZTLR4k7u0dg,666
-quant_met/mean_field/base_hamiltonian.py,sha256=YvuUD_RxZVS7yWIJrkylbaOieslz86zrQa7gRWM-6ow,8505
-quant_met/mean_field/eg_x.py,sha256=hv4gTOnqfLAi_OR3uSZlzph-vrRqnhnCqz3_qJzY8nw,4003
-quant_met/mean_field/free_energy.py,sha256=FSGCHoBO1myHGwGQ8CqGu7_08whH0Ot3ikZhBu27tyM,3444
-quant_met/mean_field/graphene.py,sha256=lR_T7TdJiBA_8leG6aUQ4hllxKnjI5qsLVCUUKU-jpw,3025
-quant_met/mean_field/quantum_metric.py,sha256=ohTs1IzReXFMj03QOKlvlenM94VJjmyAyd4KicHL5gI,2002
-quant_met/mean_field/superfluid_weight.py,sha256=egW9f3zR_NC5hLTNOdw_GA3fsKOE-L45LDSze2eGcoY,4899
-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.3.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.3.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.3.dist-info/METADATA,sha256=dB9mP1Ytt6ptRbse_R2-8TcNKFWzUJVe0tMsqIQPReI,2598
-quant_met-0.0.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-quant_met-0.0.3.dist-info/RECORD,,