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

quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -2,111 +2,40 @@
 #
 # SPDX-License-Identifier: MIT
 
-"""Provides the implementation for the EG-X model."""
+"""Provides the implementation for the dressed graphene model."""
 
-import pathlib
-from typing import Any
-
-import h5py
 import numpy as np
 import numpy.typing as npt
 
+from quant_met.geometry import BaseLattice
 from quant_met.geometry.graphene 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 DressedGrapheneParameters
 
 from .base_hamiltonian import BaseHamiltonian
 
 
-class DressedGraphene(BaseHamiltonian):
-    """Hamiltonian for the EG-X model."""
-
-    def __init__(
-        self,
-        parameters: DressedGrapheneParameters,
-        *args: tuple[Any, ...],
-        **kwargs: tuple[dict[str, Any], ...],
-    ) -> None:
-        del args
-        del kwargs
-        self._name = parameters.name
-        self.hopping_gr = _validate_float(parameters.hopping_gr, "Hopping graphene")
-        self.hopping_x = _validate_float(parameters.hopping_x, "Hopping impurity")
-        self.hopping_x_gr_a = _validate_float(parameters.hopping_x_gr_a, "Hybridisation")
-        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_gr = _validate_float(
-            parameters.hubbard_int_gr, "hubbard_int interaction graphene"
-        )
-        self.hubbard_int_x = _validate_float(
-            parameters.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 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 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
-
-    @property
-    def number_of_bands(self) -> int:  # noqa: D102
-        return self._number_of_bands
-
-    @property
-    def lattice(self) -> GrapheneLattice:  # noqa: D102
-        return self._lattice
+    def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:  # noqa: D102
+        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 = DressedGrapheneParameters.model_validate(config_dict)
-        return cls(parameters=parameters)
-
-    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.
-
-        """
+    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
         assert _check_valid_array(k)
 
         t_gr = self.hopping_gr
@@ -143,25 +72,9 @@ class DressedGraphene(BaseHamiltonian):
 
         return h.squeeze()
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         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"]
 

quant_met/mean_field/hamiltonians/graphene.py

@@ -4,100 +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
+        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 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
-
-    @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:  # noqa: D102
+        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 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.
-
-        """
+    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
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -119,25 +56,9 @@ class Graphene(BaseHamiltonian):
 
         return h.squeeze()
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         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"]
 

quant_met/mean_field/hamiltonians/one_band_tight_binding.py

@@ -2,100 +2,36 @@
 #
 # SPDX-License-Identifier: MIT
 
-"""Provides the implementation for Graphene."""
+"""Provides the implementation for a one band tight binding model."""
 
-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):
-    """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
+class OneBand(BaseHamiltonian[OneBandParameters]):
+    """Hamiltonian for one band tight binding model."""
 
-    @property
-    def lattice(self) -> SquareLattice:  # noqa: D102
-        return self._lattice
+    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 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
-
-    @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:  # noqa: D102
+        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 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.
-
-        """
+    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
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -112,25 +48,9 @@ class OneBand(BaseHamiltonian):
 
         return h
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         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"]
 

quant_met/mean_field/hamiltonians/three_band_tight_binding.py

@@ -0,0 +1,84 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for a three band tight binding model."""
+
+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:  # noqa: D102
+        return SquareLattice(lattice_constant=parameters.lattice_constant)
+
+    @classmethod
+    def get_parameters_model(cls) -> type[ThreeBandParameters]:  # noqa: D102
+        return ThreeBandParameters
+
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
+        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(  # noqa: D102
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        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,75 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for a two band tight binding model."""
+
+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:  # noqa: D102
+        return SquareLattice(lattice_constant=parameters.lattice_constant)
+
+    @classmethod
+    def get_parameters_model(cls) -> type[TwoBandParameters]:  # noqa: D102
+        return TwoBandParameters
+
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
+        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(  # noqa: D102
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        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()