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

quant_met/geometry/__init__.py

@@ -32,4 +32,4 @@ from .bz_path import generate_bz_path
 from .graphene import GrapheneLattice
 from .square import SquareLattice
 
-__all__ = ["generate_bz_path", "BaseLattice", "GrapheneLattice", "SquareLattice"]
+__all__ = ["BaseLattice", "GrapheneLattice", "SquareLattice", "generate_bz_path"]

quant_met/geometry/base_lattice.py

@@ -25,7 +25,7 @@ class BaseLattice(ABC):
 
     @property
     @abstractmethod
-    def bz_corners(self) -> npt.NDArray[np.float64]:  # pragma: no cover
+    def bz_corners(self) -> npt.NDArray[np.floating]:  # pragma: no cover
         """Corners of the BZ."""
         raise NotImplementedError
 
@@ -33,7 +33,7 @@ class BaseLattice(ABC):
     @abstractmethod
     def reciprocal_basis(
         self,
-    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:  # pragma: no cover
+    ) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:  # pragma: no cover
         """Reciprocal basis vectors."""
         raise NotImplementedError
 
@@ -41,11 +41,11 @@ class BaseLattice(ABC):
     @abstractmethod
     def high_symmetry_points(
         self,
-    ) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # pragma: no cover
+    ) -> tuple[tuple[npt.NDArray[np.floating], str], ...]:  # pragma: no cover
         """Tuple of high symmetry points and names."""
         raise NotImplementedError
 
-    def generate_bz_grid(self, ncols: int, nrows: int) -> npt.NDArray[np.float64]:
+    def generate_bz_grid(self, ncols: int, nrows: int) -> npt.NDArray[np.floating]:
         """Generate a grid in the BZ.
 
         Parameters
@@ -72,8 +72,8 @@ class BaseLattice(ABC):
     def generate_high_symmetry_path(
         self, number_of_points: int
     ) -> tuple[
-        npt.NDArray[np.float64],
-        npt.NDArray[np.float64],
+        npt.NDArray[np.floating],
+        npt.NDArray[np.floating],
         list[float],
         list[str],
     ]:

quant_met/geometry/bz_path.py

@@ -9,11 +9,11 @@ import numpy.typing as npt
 
 
 def _generate_part_of_path(
-    p_0: npt.NDArray[np.float64],
-    p_1: npt.NDArray[np.float64],
+    p_0: npt.NDArray[np.floating],
+    p_1: npt.NDArray[np.floating],
     n: int,
     length_whole_path: int,
-) -> npt.NDArray[np.float64]:
+) -> npt.NDArray[np.floating]:
     distance = np.linalg.norm(p_1 - p_0)
     number_of_points = int(n * distance / length_whole_path) + 1
 
@@ -26,10 +26,10 @@ def _generate_part_of_path(
 
 
 def generate_bz_path(
-    points: list[tuple[npt.NDArray[np.float64], str]], number_of_points: int = 1000
+    points: list[tuple[npt.NDArray[np.floating], str]], number_of_points: int = 1000
 ) -> tuple[
-    npt.NDArray[np.float64],
-    npt.NDArray[np.float64],
+    npt.NDArray[np.floating],
+    npt.NDArray[np.floating],
     list[float],
     list[str],
 ]:

quant_met/geometry/graphene.py

@@ -35,13 +35,13 @@ class GrapheneLattice(BaseLattice):
         return self._lattice_constant
 
     @property
-    def bz_corners(self) -> npt.NDArray[np.float64]:  # noqa: D102
+    def bz_corners(self) -> npt.NDArray[np.floating]:  # noqa: D102
         return self._bz_corners
 
     @property
-    def reciprocal_basis(self) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:  # noqa: D102
+    def reciprocal_basis(self) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:  # noqa: D102
         return self._reciprocal_basis
 
     @property
-    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # noqa: D102
+    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.floating], str], ...]:  # noqa: D102
         return self._high_symmetry_points

quant_met/geometry/square.py

@@ -34,13 +34,13 @@ class SquareLattice(BaseLattice):
         return self._lattice_constant
 
     @property
-    def bz_corners(self) -> npt.NDArray[np.float64]:  # noqa: D102  # pragma: no cover
+    def bz_corners(self) -> npt.NDArray[np.floating]:  # noqa: D102  # pragma: no cover
         return self._bz_corners
 
     @property
-    def reciprocal_basis(self) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:  # noqa: D102
+    def reciprocal_basis(self) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:  # noqa: D102
         return self._reciprocal_basis
 
     @property
-    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # noqa: D102
+    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.floating], str], ...]:  # noqa: D102
         return self._high_symmetry_points

quant_met/mean_field/__init__.py

@@ -35,9 +35,9 @@ from .self_consistency import self_consistency_loop
 from .superfluid_weight import superfluid_weight
 
 __all__ = [
-    "superfluid_weight",
+    "hamiltonians",
     "quantum_metric",
-    "self_consistency_loop",
     "search_crit_temp",
-    "hamiltonians",
+    "self_consistency_loop",
+    "superfluid_weight",
 ]

quant_met/mean_field/hamiltonians/__init__.py

@@ -30,4 +30,4 @@ from .one_band_tight_binding import OneBand
 from .three_band_tight_binding import ThreeBand
 from .two_band_tight_binding import TwoBand
 
-__all__ = ["BaseHamiltonian", "Graphene", "DressedGraphene", "OneBand", "TwoBand", "ThreeBand"]
+__all__ = ["BaseHamiltonian", "DressedGraphene", "Graphene", "OneBand", "ThreeBand", "TwoBand"]

quant_met/mean_field/hamiltonians/base_hamiltonian.py

@@ -12,10 +12,12 @@ import h5py
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
+from numba import jit
 
 from quant_met.geometry import BaseLattice
 from quant_met.mean_field._utils import _check_valid_array
 from quant_met.parameters.hamiltonians import GenericParameters, HamiltonianParameters
+from quant_met.utils import fermi_dirac
 
 GenericHamiltonian = TypeVar("GenericHamiltonian", bound="BaseHamiltonian[HamiltonianParameters]")
 
@@ -64,7 +66,7 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
         self.lattice = self.setup_lattice(parameters)
         self.hubbard_int_orbital_basis = parameters.hubbard_int_orbital_basis
         self.number_of_bands = len(self.hubbard_int_orbital_basis)
-        self.delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
+        self.delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex128)
 
     @abstractmethod
     def setup_lattice(self, parameters: GenericParameters) -> BaseLattice:  # pragma: no cover
@@ -97,8 +99,8 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
     @abstractmethod
     def hamiltonian(
-        self, k: npt.NDArray[np.float64]
-    ) -> npt.NDArray[np.complex64]:  # pragma: no cover
+        self, k: npt.NDArray[np.floating]
+    ) -> npt.NDArray[np.complexfloating]:  # pragma: no cover
         """Return the normal state Hamiltonian.
 
         Parameters
@@ -114,8 +116,8 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
     @abstractmethod
     def hamiltonian_derivative(
-        self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:  # pragma: no cover
+        self, k: npt.NDArray[np.floating], direction: str
+    ) -> npt.NDArray[np.complexfloating]:  # pragma: no cover
         """Calculate the spatial derivative of the Hamiltonian.
 
         Parameters
@@ -174,7 +176,7 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
         parameters = parameters_model.model_validate(config_dict)
         return cls(parameters=parameters)
 
-    def bdg_hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+    def bdg_hamiltonian(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:
         """Generate the Bogoliubov-de Gennes (BdG) Hamiltonian.
 
         The BdG Hamiltonian incorporates pairing interactions and is used to
@@ -197,7 +199,8 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
             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
+            (k.shape[0], 2 * self.number_of_bands, 2 * self.number_of_bands),
+            dtype=np.complex128,
         )
 
         h[:, 0 : self.number_of_bands, 0 : self.number_of_bands] = self.hamiltonian(k)
@@ -219,8 +222,8 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
         return h.squeeze()
 
     def bdg_hamiltonian_derivative(
-        self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:
+        self, k: npt.NDArray[np.floating], direction: str
+    ) -> npt.NDArray[np.complexfloating]:
         """Calculate the derivative of the BdG Hamiltonian.
 
         This method computes the spatial derivative of the Bogoliubov-de Gennes
@@ -243,7 +246,8 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
             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
+            (k.shape[0], 2 * self.number_of_bands, 2 * self.number_of_bands),
+            dtype=np.complex128,
         )
 
         h[:, 0 : self.number_of_bands, 0 : self.number_of_bands] = self.hamiltonian_derivative(
@@ -258,8 +262,8 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
         return h.squeeze()
 
     def diagonalize_nonint(
-        self, k: npt.NDArray[np.float64]
-    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+        self, k: npt.NDArray[np.floating]
+    ) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:
         """Diagonalizes the normal state Hamiltonian.
 
         This method computes the eigenvalues and eigenvectors of the normal state
@@ -296,8 +300,8 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
     def diagonalize_bdg(
         self,
-        k: npt.NDArray[np.float64],
-    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.complex64]]:
+        k: npt.NDArray[np.floating],
+    ) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.complexfloating]]:
         """Diagonalizes the BdG Hamiltonian.
 
         This method computes the eigenvalues and eigenvectors of the Bogoliubov-de
@@ -323,7 +327,7 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
         bdg_wavefunctions = np.zeros(
             (len(k), 2 * self.number_of_bands, 2 * self.number_of_bands),
-            dtype=np.complex64,
+            dtype=np.complex128,
         )
         bdg_energies = np.zeros((len(k), 2 * self.number_of_bands))
 
@@ -332,10 +336,34 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
         return bdg_energies.squeeze(), bdg_wavefunctions.squeeze()
 
-    def gap_equation(
-        self,
-        k: npt.NDArray[np.float64],
-    ) -> npt.NDArray[np.complex64]:
+    def gap_equation(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:
+        """Gap equation.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            k grid
+
+        Returns
+        -------
+        New delta
+        """
+        bdg_energies, bdg_wavefunctions = self.diagonalize_bdg(k=k)
+        delta = np.zeros(self.number_of_bands, dtype=np.complex128)
+        return self.gap_equation_loop(
+            bdg_energies, bdg_wavefunctions, delta, self.beta, self.hubbard_int_orbital_basis, k
+        )
+
+    @staticmethod
+    @jit
+    def gap_equation_loop(
+        bdg_energies: npt.NDArray[np.float64],
+        bdg_wavefunctions: npt.NDArray[np.complex128],
+        delta: npt.NDArray[np.float64],
+        beta: float,
+        hubbard_int_orbital_basis: npt.NDArray[np.float64],
+        k: npt.NDArray[np.floating],
+    ) -> npt.NDArray[np.complexfloating]:
         """Calculate the gap equation.
 
         The gap equation determines the order parameter for superconductivity by
@@ -343,6 +371,16 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
         Parameters
         ----------
+        bdg_energies : :class:`numpy.ndarray`
+            BdG energies
+        bdg_wavefunctions : :class:`numpy.ndarray`
+            BdG wavefunctions
+        delta : :class:`numpy.ndarray`
+            Delta
+        beta : :class:`float`
+            Beta
+        hubbard_int_orbital_basis : :class:`numpy.ndarray`
+            Hubard interaction in orbital basis
         k : :class:`numpy.ndarray`
             List of k points in reciprocal space.
 
@@ -351,29 +389,27 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
         :class:`numpy.ndarray`
             New pairing gap in orbital basis, adjusted to remove global phase.
         """
-        bdg_energies, bdg_wavefunctions = self.diagonalize_bdg(k=k)
-        delta = np.zeros(self.number_of_bands, dtype=np.complex64)
-
-        for i in range(self.number_of_bands):
+        number_of_bands = len(delta)
+        for i in range(number_of_bands):
             sum_tmp = 0
-            for j in range(2 * self.number_of_bands):
+            for j in range(2 * 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].item(), self.beta)
+                        * bdg_wavefunctions[k_index, i + number_of_bands, j]
+                        * fermi_dirac(bdg_energies[k_index, j].item(), beta)
                     )
-            delta[i] = (-self.hubbard_int_orbital_basis[i] * sum_tmp / len(k)).conjugate()
+            delta[i] = (-hubbard_int_orbital_basis[i] * sum_tmp / len(k)).conjugate()
 
-        delta_without_phase: npt.NDArray[np.complex64] = delta * np.exp(
+        delta_without_phase: npt.NDArray[np.complexfloating] = delta * np.exp(
             -1j * np.angle(delta[np.argmax(np.abs(delta))])
         )
         return delta_without_phase
 
     def calculate_bandstructure(
         self,
-        k: npt.NDArray[np.float64],
-        overlaps: tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]] | None = None,
+        k: npt.NDArray[np.floating],
+        overlaps: tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]] | None = None,
     ) -> pd.DataFrame:
         """Calculate the band structure.
 
@@ -401,24 +437,24 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
         energies, wavefunctions = self.diagonalize_nonint(k)
 
         for i, (energy_k, wavefunction_k) in enumerate(zip(energies, wavefunctions, strict=False)):
-            if self.number_of_bands == 1:
+            if np.ndim(energy_k) == 0:
                 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]
+                    results.loc[i, f"band_{band_index}"] = energy_k[band_index]  # type: ignore[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
+                            np.abs(np.dot(wavefunction_k[:, band_index], overlaps[0])) ** 2  # type: ignore[index]
+                            - np.abs(np.dot(wavefunction_k[:, band_index], overlaps[1])) ** 2  # type: ignore[index]
                         )
 
         return results
 
     def calculate_density_of_states(
         self,
-        k: npt.NDArray[np.float64],
-    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+        k: npt.NDArray[np.floating],
+    ) -> tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]:
         """Calculate the density of states (DOS).
 
         This method computes the density of states by evaluating the eigenvalues
@@ -437,16 +473,35 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
             - numpy.ndarray: The density of states corresponding to each energy level.
         """
         bands, _ = self.diagonalize_bdg(k=k)
-        energies = np.linspace(start=np.min(bands), stop=np.max(bands), num=5000)
-        density_of_states = np.zeros(shape=energies.shape, dtype=np.float64)
+        gap_fraction = 10
+        energies = np.concatenate(
+            [
+                np.linspace(
+                    start=np.min(bands),
+                    stop=-gap_fraction * np.max(np.abs(self.delta_orbital_basis)),
+                    num=100,
+                ),
+                np.linspace(
+                    start=-gap_fraction * np.max(np.abs(self.delta_orbital_basis)),
+                    stop=gap_fraction * np.max(np.abs(self.delta_orbital_basis)),
+                    num=200,
+                ),
+                np.linspace(
+                    start=gap_fraction * np.max(np.abs(self.delta_orbital_basis)),
+                    stop=np.max(bands),
+                    num=100,
+                ),
+            ]
+        )
+        density_of_states = np.zeros(shape=energies.shape, dtype=np.floating)
 
         for i, energy in enumerate(energies):
             density_of_states[i] = np.sum(
-                _gaussian(x=(energy - bands.flatten()), sigma=1e-2)
+                _gaussian(x=(energy - bands.flatten()), sigma=0.01)
             ) / len(k)
         return energies, density_of_states
 
-    def calculate_spectral_gap(self, k: npt.NDArray[np.float64]) -> float:
+    def calculate_spectral_gap(self, k: npt.NDArray[np.floating]) -> float:
         """Calculate the spectral gap.
 
         This method evaluates the spectral gap of the system by examining the
@@ -466,13 +521,15 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
         """
         energies, density_of_states = self.calculate_density_of_states(k=k)
 
-        coherence_peaks = np.where(np.isclose(density_of_states, np.max(density_of_states)))[0]
+        coherence_peaks = np.where(
+            np.isclose(density_of_states, np.max(density_of_states), rtol=1e-2)
+        )[0]
 
-        gap_region = density_of_states[coherence_peaks[0] : coherence_peaks[1] + 1] / np.max(
+        gap_region = density_of_states[coherence_peaks[0] : coherence_peaks[-1] + 1] / np.max(
             density_of_states
         )
-        energies_gap_region = energies[coherence_peaks[0] : coherence_peaks[1] + 1]
-        zero_indeces = np.where(gap_region <= 1e-10)[0]
+        energies_gap_region = energies[coherence_peaks[0] : coherence_peaks[-1] + 1]
+        zero_indeces = np.where(gap_region <= 1e-6)[0]
         if len(zero_indeces) == 0:
             gap = 0
         else:
@@ -482,16 +539,86 @@ class BaseHamiltonian(Generic[GenericParameters], ABC):
 
         return gap
 
+    def calculate_free_energy(self, k: npt.NDArray[np.floating]) -> float:
+        """Calculate the free energy for the Hamiltonian.
 
-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
+        Parameters
+        ----------
+        k
+
+        Returns
+        -------
+        free_energy
+
+        """
+        number_k_points = len(k)
+        bdg_energies, _ = self.diagonalize_bdg(k)
+        integral: float = 0
+
+        k_array = (
+            1
+            / self.beta
+            * np.array(
+                [
+                    np.sum(np.log(1 + np.exp(-self.beta * bdg_energies[k_index])))
+                    for k_index in range(number_k_points)
+                ]
+            )
+        )
+
+        integral += -np.sum(k_array, axis=-1) / number_k_points + 0.5 * np.sum(
+            np.power(np.abs(self.delta_orbital_basis), 2) / self.hubbard_int_orbital_basis
+        )
 
+        return integral
 
-def _fermi_dirac(energy: float, beta: float | None) -> float:
-    fermi_dirac: float = (
-        (1 if energy < 0 else 0) if beta is None else 1 / (1 + np.exp(beta * energy))
+    def calculate_current_density(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.floating]:
+        """Calculate the current density.
+
+        Parameters
+        ----------
+        k
+
+        Returns
+        -------
+        current_density
+
+        """
+        bdg_energies, bdg_wavefunctions = self.diagonalize_bdg(k=k)
+        h_der_x = self.hamiltonian_derivative(k=k, direction="x")
+        h_der_y = self.hamiltonian_derivative(k=k, direction="y")
+
+        current = np.zeros(2, dtype=np.complex128)
+
+        matrix_x = np.zeros((3, 3), dtype=np.complex128)
+        matrix_y = np.zeros((3, 3), dtype=np.complex128)
+
+        for k_index in range(len(k)):
+            for i in range(self.number_of_bands):
+                for j in range(self.number_of_bands):
+                    for n in range(2 * self.number_of_bands):
+                        matrix_x[i, j] += (
+                            h_der_x[k_index, i, j]
+                            * np.conjugate(bdg_wavefunctions[k_index, i, n])
+                            * bdg_wavefunctions[k_index, j, n]
+                            * fermi_dirac(bdg_energies[k_index, n].item(), self.beta)
+                        )
+                        matrix_y[i, j] *= (
+                            h_der_y[k_index, i, j]
+                            * np.conjugate(bdg_wavefunctions[k_index, i, n])
+                            * bdg_wavefunctions[k_index, j, n]
+                            * fermi_dirac(bdg_energies[k_index, n].item(), self.beta)
+                        )
+
+        current[0] = np.sum(matrix_x, axis=None)
+        current[1] = np.sum(matrix_y, axis=None)
+        assert np.allclose(np.imag(current), 0, atol=1e-14)
+
+        return (2 * np.real(current)) / len(k)
+
+
+def _gaussian(x: npt.NDArray[np.floating], sigma: float) -> npt.NDArray[np.floating]:
+    gaussian: npt.NDArray[np.floating] = np.exp(-(x**2) / (2 * sigma**2)) / np.sqrt(
+        2 * np.pi * sigma**2
     )
-    return fermi_dirac
+    return gaussian

quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -26,7 +26,7 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
         self.hubbard_int_orbital_basis = parameters.hubbard_int_orbital_basis
         self.chemical_potential = parameters.chemical_potential
         if parameters.delta is not None:
-            self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
+            self.delta_orbital_basis = parameters.delta.astype(np.complexfloating)
 
     def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:  # noqa: D102
         return GrapheneLattice(lattice_constant=parameters.lattice_constant)
@@ -35,7 +35,7 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
     def get_parameters_model(cls) -> type[DressedGrapheneParameters]:  # noqa: D102
         return DressedGrapheneParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
+    def hamiltonian(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:  # noqa: D102
         assert _check_valid_array(k)
 
         t_gr = self.hopping_gr
@@ -46,7 +46,7 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
         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 = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex128)
 
         h[:, 0, 1] = -t_gr * (
             np.exp(1j * k[:, 1] * a / np.sqrt(3))
@@ -73,8 +73,8 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
         return h.squeeze()
 
     def hamiltonian_derivative(  # noqa: D102
-        self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:
+        self, k: npt.NDArray[np.floating], direction: str
+    ) -> npt.NDArray[np.complexfloating]:
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 
@@ -84,7 +84,7 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
         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 = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex128)
 
         if direction == "x":
             h[:, 0, 1] = (

quant_met/mean_field/hamiltonians/graphene.py

@@ -25,7 +25,7 @@ class Graphene(BaseHamiltonian[GrapheneParameters]):
         self.hopping = parameters.hopping
         self.chemical_potential = parameters.chemical_potential
         if parameters.delta is not None:
-            self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
+            self.delta_orbital_basis = parameters.delta.astype(np.complex128)
 
     def setup_lattice(self, parameters: GrapheneParameters) -> GrapheneLattice:  # noqa: D102
         return GrapheneLattice(lattice_constant=parameters.lattice_constant)
@@ -34,7 +34,7 @@ class Graphene(BaseHamiltonian[GrapheneParameters]):
     def get_parameters_model(cls) -> type[GrapheneParameters]:  # noqa: D102
         return GrapheneParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
+    def hamiltonian(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:  # noqa: D102
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -42,7 +42,7 @@ class Graphene(BaseHamiltonian[GrapheneParameters]):
         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 = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex128)
 
         h[:, 0, 1] = -hopping * (
             np.exp(1j * k[:, 1] * lattice_constant / np.sqrt(3))
@@ -57,8 +57,8 @@ class Graphene(BaseHamiltonian[GrapheneParameters]):
         return h.squeeze()
 
     def hamiltonian_derivative(  # noqa: D102
-        self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:
+        self, k: npt.NDArray[np.floating], direction: str
+    ) -> npt.NDArray[np.complexfloating]:
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 
@@ -67,7 +67,7 @@ class Graphene(BaseHamiltonian[GrapheneParameters]):
         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 = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex128)
 
         if direction == "x":
             h[:, 0, 1] = (

quant_met/mean_field/hamiltonians/one_band_tight_binding.py

@@ -22,7 +22,7 @@ class OneBand(BaseHamiltonian[OneBandParameters]):
         self.hopping = parameters.hopping
         self.chemical_potential = parameters.chemical_potential
         if parameters.delta is not None:
-            self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
+            self.delta_orbital_basis = parameters.delta.astype(np.complex128)
 
     def setup_lattice(self, parameters: OneBandParameters) -> SquareLattice:  # noqa: D102
         return SquareLattice(lattice_constant=parameters.lattice_constant)
@@ -31,7 +31,7 @@ class OneBand(BaseHamiltonian[OneBandParameters]):
     def get_parameters_model(cls) -> type[OneBandParameters]:  # noqa: D102
         return OneBandParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
+    def hamiltonian(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:  # noqa: D102
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -39,7 +39,7 @@ class OneBand(BaseHamiltonian[OneBandParameters]):
         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 = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex128)
 
         h[:, 0, 0] = (
             -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
@@ -49,8 +49,8 @@ class OneBand(BaseHamiltonian[OneBandParameters]):
         return h
 
     def hamiltonian_derivative(  # noqa: D102
-        self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:
+        self, k: npt.NDArray[np.floating], direction: str
+    ) -> npt.NDArray[np.complexfloating]:
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 
@@ -59,7 +59,7 @@ class OneBand(BaseHamiltonian[OneBandParameters]):
         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 = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex128)
 
         if direction == "x":
             h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])