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

quant_met/mean_field/hamiltonians/graphene.py

@@ -4,84 +4,37 @@
 
 """Provides the implementation for Graphene."""
 
-import pathlib
-from typing import Any
-
-import h5py
 import numpy as np
 import numpy.typing as npt
 
 from quant_met.geometry import GrapheneLattice
-from quant_met.mean_field._utils import _check_valid_array, _validate_float
+from quant_met.mean_field._utils import _check_valid_array
 from quant_met.parameters.hamiltonians import GrapheneParameters
 
 from .base_hamiltonian import BaseHamiltonian
 
 
-class Graphene(BaseHamiltonian):
+class Graphene(BaseHamiltonian[GrapheneParameters]):
     """Hamiltonian for Graphene."""
 
     def __init__(
         self,
         parameters: GrapheneParameters,
-        *args: tuple[Any, ...],
-        **kwargs: tuple[dict[str, Any], ...],
     ) -> None:
-        del args
-        del kwargs
-        self._name = parameters.name
-        self.hopping = _validate_float(parameters.hopping, "Hopping")
-        if parameters.lattice_constant <= 0:
-            msg = "Lattice constant must be positive"
-            raise ValueError(msg)
-        self._lattice = GrapheneLattice(
-            lattice_constant=np.float64(
-                _validate_float(parameters.lattice_constant, "Lattice constant")
-            )
-        )
-        self.lattice_constant = self._lattice.lattice_constant
-        self.chemical_potential = _validate_float(
-            parameters.chemical_potential, "Chemical potential"
-        )
-        self.hubbard_int = _validate_float(parameters.hubbard_int, "Hubbard interaction")
-        self._hubbard_int_orbital_basis = np.array([self.hubbard_int, self.hubbard_int])
-        self._number_of_bands = 2
-        if parameters.delta is None:
-            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
-        else:
-            self._delta_orbital_basis = np.astype(parameters.delta, np.complex64)
-
-    @property
-    def name(self) -> str:  # noqa: D102
-        return self._name
-
-    @property
-    def lattice(self) -> GrapheneLattice:  # noqa: D102
-        return self._lattice
-
-    @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
-
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
-        return self._delta_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)
 
-    @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: GrapheneParameters) -> GrapheneLattice:
+        """Set up lattice based on parameters."""
+        return GrapheneLattice(lattice_constant=parameters.lattice_constant)
 
     @classmethod
-    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":  # noqa: D102
-        with h5py.File(f"{filename}", "r") as f:
-            config_dict = dict(f.attrs.items())
-            config_dict["delta"] = f["delta"][()]
-        parameters = GrapheneParameters.model_validate(config_dict)
-        return cls(parameters=parameters)
+    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]:
         """

quant_met/mean_field/hamiltonians/one_band_tight_binding.py

@@ -4,82 +4,34 @@
 
 """Provides the implementation for Graphene."""
 
-import pathlib
-from typing import Any
-
-import h5py
 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, _validate_float
+from quant_met.mean_field._utils import _check_valid_array
 from quant_met.parameters import OneBandParameters
 
 from .base_hamiltonian import BaseHamiltonian
 
 
-class OneBand(BaseHamiltonian):
+class OneBand(BaseHamiltonian[OneBandParameters]):
     """Hamiltonian for Graphene."""
 
-    def __init__(
-        self,
-        parameters: OneBandParameters,
-        *args: tuple[Any, ...],
-        **kwargs: tuple[dict[str, Any], ...],
-    ) -> None:
-        del args
-        del kwargs
-        self._name = parameters.name
-        self.hopping = _validate_float(parameters.hopping, "Hopping")
-        if parameters.lattice_constant <= 0:
-            msg = "Lattice constant must be positive"
-            raise ValueError(msg)
-        self._lattice = SquareLattice(
-            np.float64(_validate_float(parameters.lattice_constant, "Lattice constant"))
-        )
-        self.lattice_constant = self._lattice.lattice_constant
-        self.chemical_potential = _validate_float(
-            parameters.chemical_potential, "Chemical potential"
-        )
-        self.hubbard_int = _validate_float(parameters.hubbard_int, "Hubbard interaction")
-        self._hubbard_int_orbital_basis = np.array([self.hubbard_int])
-        self._number_of_bands = 1
-        if parameters.delta is None:
-            self._delta_orbital_basis = np.zeros(self.number_of_bands, dtype=np.complex64)
-        else:
-            self._delta_orbital_basis = np.astype(parameters.delta, np.complex64)
-
-    @property
-    def name(self) -> str:  # noqa: D102
-        return self._name
-
-    @property
-    def lattice(self) -> SquareLattice:  # noqa: D102
-        return self._lattice
-
-    @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
-
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:  # noqa: D102
-        return self._delta_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)
 
-    @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: OneBandParameters) -> SquareLattice:
+        """Set up lattice based on parameters."""
+        return SquareLattice(lattice_constant=parameters.lattice_constant)
 
     @classmethod
-    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":  # noqa: D102
-        with h5py.File(f"{filename}", "r") as f:
-            config_dict = dict(f.attrs.items())
-            config_dict["delta"] = f["delta"][()]
-        parameters = OneBandParameters.model_validate(config_dict)
-        return cls(parameters=parameters)
+    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]:
         """

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

@@ -8,10 +8,11 @@ import numpy as np
 import numpy.typing as npt
 
 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

@@ -8,42 +8,33 @@ import numpy as np
 import numpy.typing as npt
 
 from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
+from quant_met.parameters import GenericParameters
 
 
 def self_consistency_loop(
-    h: BaseHamiltonian,
+    h: BaseHamiltonian[GenericParameters],
     k_space_grid: npt.NDArray[np.float64],
-    beta: np.float64,
     epsilon: float,
-    q: npt.NDArray[np.float64] | None = None,
-) -> BaseHamiltonian:
+) -> BaseHamiltonian[GenericParameters]:
     """Self-consistency loop.
 
     Parameters
     ----------
-    lattice
-    q
-    beta
-    number_of_k_points
+    k_space_grid
     h
     epsilon
     """
-    if q is None:
-        q = np.array([0, 0])
-
     rng = np.random.default_rng()
     delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.complex64)
-    delta_init += (
-        2 * rng.random(size=h.delta_orbital_basis.shape)
-        - 1
-        + 1.0j * (2 * rng.random(size=h.delta_orbital_basis.shape) - 1)
+    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, q=q, 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.1
+        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

@@ -8,10 +8,11 @@ import numpy as np
 import numpy.typing as npt
 
 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=(

quant_met/parameters/__init__.py

@@ -15,7 +15,22 @@ Parameters (:mod:`quant_met.parameters`)
     Parameters
 """  # noqa: D205, D400
 
-from .hamiltonians import DressedGrapheneParameters, GrapheneParameters, OneBandParameters
+from .hamiltonians import (
+    DressedGrapheneParameters,
+    GenericParameters,
+    GrapheneParameters,
+    OneBandParameters,
+    ThreeBandParameters,
+    TwoBandParameters,
+)
 from .main import Parameters
 
-__all__ = ["Parameters", "DressedGrapheneParameters", "GrapheneParameters", "OneBandParameters"]
+__all__ = [
+    "Parameters",
+    "DressedGrapheneParameters",
+    "GrapheneParameters",
+    "OneBandParameters",
+    "TwoBandParameters",
+    "ThreeBandParameters",
+    "GenericParameters",
+]