quant-met 0.0.16__py3-none-any.whl → 0.0.18__py3-none-any.whl

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)
+        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.float64)
 
         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,195 @@ 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 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-12)
 
-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))
+        return (2 * np.real(current)) / len(k)
+
+    def calculate_superfluid_weight(
+        self,
+        k: npt.NDArray[np.floating],
+    ) -> tuple[npt.NDArray[np.complexfloating], npt.NDArray[np.complexfloating]]:
+        """Calculate the superfluid weight.
+
+        Parameters
+        ----------
+        h : :class:`~quant_met.mean_field.Hamiltonian`
+        Hamiltonian.
+        k : :class:`numpy.ndarray`
+        List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+        Conventional contribution to the superfluid weight.
+        :class:`numpy.ndarray`
+        Geometric contribution to the superfluid weight.
+
+        """
+        s_weight_conv = np.zeros(shape=(2, 2), dtype=np.complex128)
+        s_weight_geom = np.zeros(shape=(2, 2), dtype=np.complex128)
+
+        c_mnpq_cache = {}
+
+        for i, direction_1 in enumerate(["x", "y"]):
+            for j, direction_2 in enumerate(["x", "y"]):
+                for k_point in k:
+                    k_tuple = tuple(k_point)
+
+                    if k_tuple not in c_mnpq_cache:
+                        c_mnpq_cache[k_tuple] = self._c_factor(k_point)
+                    c_mnpq = c_mnpq_cache[k_tuple]
+
+                    j_up = self._current_operator(direction_1, k_point)
+                    j_down = self._current_operator(direction_2, -k_point)
+
+                    for m in range(self.number_of_bands):
+                        for n in range(self.number_of_bands):
+                            for p in range(self.number_of_bands):
+                                for q in range(self.number_of_bands):
+                                    s_weight = c_mnpq[m, n, p, q] * j_up[m, n] * j_down[q, p]
+                                    if m == n and p == q:
+                                        s_weight_conv[i, j] += s_weight
+                                    else:
+                                        s_weight_geom[i, j] += s_weight
+
+        return s_weight_conv, s_weight_geom
+
+    def _current_operator(
+        self, direction: str, k: npt.NDArray[np.floating]
+    ) -> npt.NDArray[np.complexfloating]:
+        j = np.zeros(shape=(self.number_of_bands, self.number_of_bands), dtype=np.complex128)
+
+        _, bloch = self.diagonalize_nonint(k=k)
+
+        for m in range(self.number_of_bands):
+            for n in range(self.number_of_bands):
+                j[m, n] = (
+                    bloch[:, m].conjugate()
+                    @ self.hamiltonian_derivative(direction=direction, k=k)
+                    @ bloch[:, n]
+                )
+
+        return j
+
+    def _c_factor(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:
+        bdg_energies, bdg_functions = self.diagonalize_bdg(k)
+        c_mnpq = np.zeros(
+            shape=(
+                self.number_of_bands,
+                self.number_of_bands,
+                self.number_of_bands,
+                self.number_of_bands,
+            ),
+            dtype=np.complex128,
+        )
+
+        for m in range(self.number_of_bands):
+            for n in range(self.number_of_bands):
+                for p in range(self.number_of_bands):
+                    for q in range(self.number_of_bands):
+                        c_tmp: float = 0
+                        for i in range(2 * self.number_of_bands):
+                            for j in range(2 * self.number_of_bands):
+                                if bdg_energies[i] != bdg_energies[j]:
+                                    c_tmp += (
+                                        fermi_dirac(bdg_energies[i], self.beta)
+                                        - fermi_dirac(bdg_energies[j], self.beta)
+                                    ) / (bdg_energies[i] - bdg_energies[j])
+                                else:
+                                    c_tmp -= _fermi_dirac_derivative()
+
+                                c_tmp *= (
+                                    bdg_functions[i, m].conjugate()
+                                    * bdg_functions[j, n]
+                                    * bdg_functions[j, p].conjugate()
+                                    * bdg_functions[i, q].conjugate()
+                                )
+
+                        c_mnpq[m, n, p, q] = 2 * c_tmp
+
+        return c_mnpq
+
+
+def _fermi_dirac_derivative() -> float:
+    return 0
+
+
+def _gaussian(x: npt.NDArray[np.floating], sigma: float) -> npt.NDArray[np.floating]:
+    gaussian: npt.NDArray[np.floating] = np.exp(-(x**2) / (2 * sigma**2)) / np.sqrt(
+        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.complex128)
 
     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])