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

quant_met/mean_field/{eg_x.py → hamiltonians/dressed_graphene.py}

@@ -2,72 +2,40 @@
 #
 # SPDX-License-Identifier: MIT
 
-"""Provides the implementation for the EG-X model."""
-
-from typing import Any
+"""Provides the implementation for the dressed graphene model."""
 
 import numpy as np
 import numpy.typing as npt
 
-from ._utils import _check_valid_array, _validate_float
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.geometry import BaseLattice
+from quant_met.geometry.graphene import GrapheneLattice
+from quant_met.mean_field._utils import _check_valid_array
+from quant_met.parameters.hamiltonians import DressedGrapheneParameters
 
+from .base_hamiltonian import BaseHamiltonian
 
-class EGXHamiltonian(BaseHamiltonian):
-    """Hamiltonian for the EG-X model."""
-
-    def __init__(
-        self,
-        hopping_gr: float,
-        hopping_x: float,
-        hopping_x_gr_a: float,
-        lattice_constant: float,
-        chemical_potential: float,
-        hubbard_int_gr: float,
-        hubbard_int_x: float,
-        delta: npt.NDArray[np.complex64] | None = None,
-        *args: tuple[Any, ...],
-        **kwargs: tuple[dict[str, Any], ...],
-    ) -> 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")
-        if lattice_constant <= 0:
-            msg = "Lattice constant must be positive"
-            raise ValueError(msg)
-        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
-        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
-        self.hubbard_int_gr = _validate_float(hubbard_int_gr, "hubbard_int interaction graphene")
-        self.hubbard_int_x = _validate_float(hubbard_int_x, "hubbard_int interaction impurity")
-        self._hubbard_int_orbital_basis = np.array(
-            [self.hubbard_int_gr, self.hubbard_int_gr, self.hubbard_int_x]
-        )
-        self._number_of_bands = 3
-        if delta is None:
-            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
-        else:
-            if delta.shape != (self.number_of_bands,):
-                msg = "Invalid input value for gaps."
-                raise ValueError(msg)
-            self._delta_orbital_basis = np.astype(delta, np.complex64)
 
-    @property
-    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
-        return self._hubbard_int_orbital_basis
+class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
+    """Hamiltonian for the dressed graphene model."""
 
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
-        return self._delta_orbital_basis
+    def __init__(self, parameters: DressedGrapheneParameters) -> None:
+        super().__init__(parameters)
+        self.hopping_gr = parameters.hopping_gr
+        self.hopping_x = parameters.hopping_x
+        self.hopping_x_gr_a = parameters.hopping_x_gr_a
+        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)
 
-    @delta_orbital_basis.setter
-    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
-        self._delta_orbital_basis = new_delta
+    def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:
+        """Set up lattice based on parameters."""
+        return GrapheneLattice(lattice_constant=parameters.lattice_constant)
 
-    @property
-    def number_of_bands(self) -> int:  # noqa: D102
-        return self._number_of_bands
+    @classmethod
+    def get_parameters_model(cls) -> type[DressedGrapheneParameters]:
+        """Return the specific parameters model for the subclass."""
+        return DressedGrapheneParameters
 
     def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
         """
@@ -88,7 +56,7 @@ class EGXHamiltonian(BaseHamiltonian):
 
         t_gr = self.hopping_gr
         t_x = self.hopping_x
-        a = self.lattice_constant
+        a = self.lattice.lattice_constant
         v = self.hopping_x_gr_a
         chemical_potential = self.chemical_potential
         if k.ndim == 1:
@@ -144,7 +112,7 @@ class EGXHamiltonian(BaseHamiltonian):
 
         t_gr = self.hopping_gr
         t_x = self.hopping_x
-        a = self.lattice_constant
+        a = self.lattice.lattice_constant
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 

quant_met/mean_field/{graphene.py → hamiltonians/graphene.py}

@@ -4,62 +4,37 @@
 
 """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 quant_met.geometry import GrapheneLattice
+from quant_met.mean_field._utils import _check_valid_array
+from quant_met.parameters.hamiltonians import GrapheneParameters
+
 from .base_hamiltonian import BaseHamiltonian
 
 
-class GrapheneHamiltonian(BaseHamiltonian):
+class Graphene(BaseHamiltonian[GrapheneParameters]):
     """Hamiltonian for Graphene."""
 
     def __init__(
         self,
-        hopping: float,
-        lattice_constant: float,
-        chemical_potential: float,
-        hubbard_int_gr: float,
-        delta: npt.NDArray[np.float64] | None = None,
-        *args: tuple[Any, ...],
-        **kwargs: tuple[dict[str, Any], ...],
+        parameters: GrapheneParameters,
     ) -> None:
-        del args
-        del kwargs
-        self.hopping = _validate_float(hopping, "Hopping")
-        if lattice_constant <= 0:
-            msg = "Lattice constant must be positive"
-            raise ValueError(msg)
-        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
-        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
-        self.hubbard_int_gr = _validate_float(hubbard_int_gr, "hubbard_int interaction")
-        self._hubbard_int_orbital_basis = np.array([self.hubbard_int_gr, self.hubbard_int_gr])
-        self._number_of_bands = 2
-        if delta is None:
-            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
-        else:
-            if delta.shape != (self.number_of_bands,):
-                msg = "Invalid input value for gaps."
-                raise ValueError(msg)
-            self._delta_orbital_basis = np.astype(delta, np.complex64)
-
-    @property
-    def number_of_bands(self) -> int:  # noqa: D102
-        return self._number_of_bands
-
-    @property
-    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
-        return self._hubbard_int_orbital_basis
+        super().__init__(parameters)
+        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)
 
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
-        return self._delta_orbital_basis
+    def setup_lattice(self, parameters: GrapheneParameters) -> GrapheneLattice:
+        """Set up lattice based on parameters."""
+        return GrapheneLattice(lattice_constant=parameters.lattice_constant)
 
-    @delta_orbital_basis.setter
-    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
-        self._delta_orbital_basis = new_delta
+    @classmethod
+    def get_parameters_model(cls) -> type[GrapheneParameters]:
+        """Return the specific parameters model for the subclass."""
+        return GrapheneParameters
 
     def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
         """
@@ -78,7 +53,7 @@ class GrapheneHamiltonian(BaseHamiltonian):
         """
         assert _check_valid_array(k)
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         chemical_potential = self.chemical_potential
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
@@ -120,7 +95,7 @@ class GrapheneHamiltonian(BaseHamiltonian):
         assert direction in ["x", "y"]
 
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 

quant_met/mean_field/{one_band_tight_binding.py → hamiltonians/one_band_tight_binding.py}

@@ -4,62 +4,34 @@
 
 """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 quant_met.geometry import SquareLattice
+from quant_met.mean_field._utils import _check_valid_array
+from quant_met.parameters import OneBandParameters
+
 from .base_hamiltonian import BaseHamiltonian
 
 
-class OneBandTightBindingHamiltonian(BaseHamiltonian):
+class OneBand(BaseHamiltonian[OneBandParameters]):
     """Hamiltonian for Graphene."""
 
-    def __init__(
-        self,
-        hopping: float,
-        lattice_constant: float,
-        chemical_potential: float,
-        hubbard_int: float,
-        delta: npt.NDArray[np.float64] | None = None,
-        *args: tuple[Any, ...],
-        **kwargs: tuple[dict[str, Any], ...],
-    ) -> None:
-        del args
-        del kwargs
-        self.hopping = _validate_float(hopping, "Hopping")
-        if lattice_constant <= 0:
-            msg = "Lattice constant must be positive"
-            raise ValueError(msg)
-        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
-        self.chemical_potential = _validate_float(chemical_potential, "Chemical potential")
-        self.hubbard_int = _validate_float(hubbard_int, "hubbard_int interaction")
-        self._hubbard_int_orbital_basis = np.array([self.hubbard_int])
-        self._number_of_bands = 1
-        if delta is None:
-            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
-        else:
-            if delta.shape != (self.number_of_bands,):
-                msg = "Invalid input value for gaps."
-                raise ValueError(msg)
-            self._delta_orbital_basis = np.astype(delta, np.complex64)
-
-    @property
-    def number_of_bands(self) -> int:  # noqa: D102
-        return self._number_of_bands
-
-    @property
-    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
-        return self._hubbard_int_orbital_basis
+    def __init__(self, parameters: OneBandParameters) -> None:
+        super().__init__(parameters)
+        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)
 
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
-        return self._delta_orbital_basis
+    def setup_lattice(self, parameters: OneBandParameters) -> SquareLattice:
+        """Set up lattice based on parameters."""
+        return SquareLattice(lattice_constant=parameters.lattice_constant)
 
-    @delta_orbital_basis.setter
-    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
-        self._delta_orbital_basis = new_delta
+    @classmethod
+    def get_parameters_model(cls) -> type[OneBandParameters]:
+        """Return the specific parameters model for the subclass."""
+        return OneBandParameters
 
     def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
         """
@@ -78,7 +50,7 @@ class OneBandTightBindingHamiltonian(BaseHamiltonian):
         """
         assert _check_valid_array(k)
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         chemical_potential = self.chemical_potential
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
@@ -115,7 +87,7 @@ class OneBandTightBindingHamiltonian(BaseHamiltonian):
         assert direction in ["x", "y"]
 
         hopping = self.hopping
-        lattice_constant = self.lattice_constant
+        lattice_constant = self.lattice.lattice_constant
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
 

quant_met/mean_field/hamiltonians/three_band_tight_binding.py

@@ -0,0 +1,116 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for Graphene."""
+
+import numpy as np
+import numpy.typing as npt
+
+from quant_met.geometry import SquareLattice
+from quant_met.mean_field._utils import _check_valid_array
+from quant_met.parameters import ThreeBandParameters
+
+from .base_hamiltonian import BaseHamiltonian
+
+
+class ThreeBand(BaseHamiltonian[ThreeBandParameters]):
+    """Hamiltonian for Graphene."""
+
+    def __init__(self, parameters: ThreeBandParameters) -> None:
+        super().__init__(parameters)
+        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)
+
+    def setup_lattice(self, parameters: ThreeBandParameters) -> SquareLattice:
+        """Set up lattice based on parameters."""
+        return SquareLattice(lattice_constant=parameters.lattice_constant)
+
+    @classmethod
+    def get_parameters_model(cls) -> type[ThreeBandParameters]:
+        """Return the specific parameters model for the subclass."""
+        return ThreeBandParameters
+
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        """
+        Return the normal state Hamiltonian in orbital basis.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Hamiltonian in matrix form.
+
+        """
+        assert _check_valid_array(k)
+        hopping = self.hopping
+        lattice_constant = self.lattice.lattice_constant
+        chemical_potential = self.chemical_potential
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        h[:, 0, 0] = (
+            -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
+        )
+        h[:, 1, 1] = (
+            -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
+        )
+        h[:, 2, 2] = (
+            -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
+        )
+        h[:, 2, 0] = 0.5
+        h[:, 0, 2] = 0.5
+
+        h[:, 0, 0] -= chemical_potential
+        h[:, 1, 1] -= chemical_potential
+        h[:, 2, 2] -= chemical_potential
+
+        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"]
+
+        hopping = self.hopping
+        lattice_constant = self.lattice.lattice_constant
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        if direction == "x":
+            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+            h[:, 1, 1] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+            h[:, 2, 2] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+        else:
+            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+            h[:, 1, 1] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+            h[:, 2, 2] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+
+        return h.squeeze()

quant_met/mean_field/hamiltonians/two_band_tight_binding.py

@@ -0,0 +1,107 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for Graphene."""
+
+import numpy as np
+import numpy.typing as npt
+
+from quant_met.geometry import SquareLattice
+from quant_met.mean_field._utils import _check_valid_array
+from quant_met.parameters import TwoBandParameters
+
+from .base_hamiltonian import BaseHamiltonian
+
+
+class TwoBand(BaseHamiltonian[TwoBandParameters]):
+    """Hamiltonian for Graphene."""
+
+    def __init__(self, parameters: TwoBandParameters) -> None:
+        super().__init__(parameters)
+        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)
+
+    def setup_lattice(self, parameters: TwoBandParameters) -> SquareLattice:
+        """Set up lattice based on parameters."""
+        return SquareLattice(lattice_constant=parameters.lattice_constant)
+
+    @classmethod
+    def get_parameters_model(cls) -> type[TwoBandParameters]:
+        """Return the specific parameters model for the subclass."""
+        return TwoBandParameters
+
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        """
+        Return the normal state Hamiltonian in orbital basis.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Hamiltonian in matrix form.
+
+        """
+        assert _check_valid_array(k)
+        hopping = self.hopping
+        lattice_constant = self.lattice.lattice_constant
+        chemical_potential = self.chemical_potential
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        h[:, 0, 0] = (
+            -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
+        )
+        h[:, 1, 1] = (
+            -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
+        )
+        h[:, 0, 0] -= chemical_potential
+        h[:, 1, 1] -= chemical_potential
+
+        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"]
+
+        hopping = self.hopping
+        lattice_constant = self.lattice.lattice_constant
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        if direction == "x":
+            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+            h[:, 1, 1] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+        else:
+            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+            h[:, 1, 1] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
+
+        return h.squeeze()

quant_met/mean_field/quantum_metric.py

@@ -7,11 +7,12 @@
 import numpy as np
 import numpy.typing as npt
 
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
+from quant_met.parameters import GenericParameters
 
 
 def quantum_metric(
-    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], bands: list[int]
+    h: BaseHamiltonian[GenericParameters], k_grid: npt.NDArray[np.float64], bands: list[int]
 ) -> npt.NDArray[np.float64]:
     """Calculate the quantum metric in the normal state.
 
@@ -60,7 +61,7 @@ def quantum_metric(
 
 
 def quantum_metric_bdg(
-    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], bands: list[int]
+    h: BaseHamiltonian[GenericParameters], k_grid: npt.NDArray[np.float64], bands: list[int]
 ) -> npt.NDArray[np.float64]:
     """Calculate the quantum metric in the BdG state.
 

quant_met/mean_field/self_consistency.py

@@ -5,35 +5,36 @@
 """Self-consistency loop."""
 
 import numpy as np
+import numpy.typing as npt
 
-from quant_met import geometry
-
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
+from quant_met.parameters import GenericParameters
 
 
 def self_consistency_loop(
-    h: BaseHamiltonian, beta: np.float64, number_of_k_points: int, epsilon: float
-) -> BaseHamiltonian:
+    h: BaseHamiltonian[GenericParameters],
+    k_space_grid: npt.NDArray[np.float64],
+    epsilon: float,
+) -> BaseHamiltonian[GenericParameters]:
     """Self-consistency loop.
 
     Parameters
     ----------
-    beta
-    number_of_k_points
+    k_space_grid
     h
     epsilon
     """
-    lattice = geometry.Graphene(lattice_constant=np.sqrt(3))
-    k_space_grid = lattice.generate_bz_grid(ncols=number_of_k_points, nrows=number_of_k_points)
     rng = np.random.default_rng()
-    delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.float64)
-    rng.random(size=h.delta_orbital_basis.shape, out=delta_init)
-    h.delta_orbital_basis = delta_init.astype(np.complex64)
+    delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.complex64)
+    delta_init += (0.2 * rng.random(size=h.delta_orbital_basis.shape) - 1) + 1.0j * (
+        0.2 * rng.random(size=h.delta_orbital_basis.shape) - 1
+    )
+    h.delta_orbital_basis = delta_init
 
     while True:
-        new_gap = h.gap_equation(k=k_space_grid, beta=beta)
+        new_gap = h.gap_equation(k=k_space_grid)
         if (np.abs(h.delta_orbital_basis - new_gap) < epsilon).all():
             h.delta_orbital_basis = new_gap
             return h
-        mixing_greed = 0.2
+        mixing_greed = 0.5
         h.delta_orbital_basis = mixing_greed * new_gap + (1 - mixing_greed) * h.delta_orbital_basis

quant_met/mean_field/superfluid_weight.py

@@ -7,11 +7,12 @@
 import numpy as np
 import numpy.typing as npt
 
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
+from quant_met.parameters import GenericParameters
 
 
 def superfluid_weight(
-    h: BaseHamiltonian,
+    h: BaseHamiltonian[GenericParameters],
     k_grid: npt.NDArray[np.float64],
 ) -> tuple[npt.NDArray[np.complex64], npt.NDArray[np.complex64]]:
     """Calculate the superfluid weight.
@@ -54,7 +55,7 @@ def superfluid_weight(
 
 
 def _current_operator(
-    h: BaseHamiltonian, direction: str, k: npt.NDArray[np.float64]
+    h: BaseHamiltonian[GenericParameters], direction: str, k: npt.NDArray[np.float64]
 ) -> npt.NDArray[np.complex64]:
     j = np.zeros(shape=(h.number_of_bands, h.number_of_bands), dtype=np.complex64)
 
@@ -71,7 +72,9 @@ def _current_operator(
     return j
 
 
-def _c_factor(h: BaseHamiltonian, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+def _c_factor(
+    h: BaseHamiltonian[GenericParameters], k: npt.NDArray[np.float64]
+) -> npt.NDArray[np.complex64]:
     bdg_energies, bdg_functions = h.diagonalize_bdg(k)
     c_mnpq = np.zeros(
         shape=(