quant-met 0.0.8__tar.gz → 0.0.9__tar.gz

{quant_met-0.0.8 → quant_met-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.8
+Version: 0.0.9
 Summary: Calculate superconductivity in flat-band systems.
 Home-page: https://quant-met.tjarksievers.de
 Author: Tjark Sievers

{quant_met-0.0.8 → quant_met-0.0.9}/pyproject.toml

@@ -8,7 +8,7 @@ requires-python = ">=3.11,<3.13"
 
 [tool.poetry]
 name = "quant-met"
-version = "0.0.8"
+version = "0.0.9"
 description = "Calculate superconductivity in flat-band systems."
 authors = ["Tjark Sievers <tsievers@physnet.uni-hamburg.de>"]
 homepage = "https://quant-met.tjarksievers.de"

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/cli/scf.py

@@ -6,20 +6,20 @@
 
 from pathlib import Path
 
-import numpy as np
-from pydantic import BaseModel
-
 from quant_met import mean_field
 from quant_met.mean_field.hamiltonians import BaseHamiltonian
 from quant_met.parameters import Parameters
+from quant_met.parameters.hamiltonians import HamiltonianParameters
 
 
-def _hamiltonian_factory(classname: str, parameters: BaseModel) -> BaseHamiltonian:
+def _hamiltonian_factory(
+    classname: str, parameters: HamiltonianParameters
+) -> BaseHamiltonian[HamiltonianParameters]:
     """Create a hamiltonian by its class name."""
     from quant_met.mean_field import hamiltonians
 
     cls = getattr(hamiltonians, classname)
-    h: BaseHamiltonian = cls(parameters)
+    h: BaseHamiltonian[HamiltonianParameters] = cls(parameters)
     return h
 
 
@@ -33,9 +33,7 @@ def scf(parameters: Parameters) -> None:
         k_space_grid=h.lattice.generate_bz_grid(
             ncols=parameters.k_points.nk1, nrows=parameters.k_points.nk2
         ),
-        beta=np.float64(parameters.control.beta),
         epsilon=parameters.control.conv_treshold,
-        q=parameters.control.q,
     )
     print(solved_h.delta_orbital_basis)
     result_file = result_path / f"{parameters.control.prefix}.hdf5"

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/geometry/base_lattice.py

@@ -19,19 +19,29 @@ class BaseLattice(ABC):
 
     @property
     @abstractmethod
-    def lattice_constant(self) -> np.float64:
+    def lattice_constant(self) -> float:  # pragma: no cover
         """Lattice constant."""
         raise NotImplementedError
 
     @property
     @abstractmethod
-    def bz_corners(self) -> npt.NDArray[np.float64]:
+    def bz_corners(self) -> npt.NDArray[np.float64]:  # pragma: no cover
         """Corners of the BZ."""
         raise NotImplementedError
 
     @property
     @abstractmethod
-    def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:
+    def reciprocal_basis(
+        self,
+    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:  # pragma: no cover
+        """Reciprocal basis vectors."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def high_symmetry_points(
+        self,
+    ) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # pragma: no cover
         """Tuple of high symmetry points and names."""
         raise NotImplementedError
 
@@ -52,7 +62,11 @@ class BaseLattice(ABC):
 
         """
         return generate_uniform_grid(
-            ncols, nrows, self.bz_corners[0], self.bz_corners[1], origin=np.array([0, 0])
+            ncols,
+            nrows,
+            self.reciprocal_basis[0],
+            self.reciprocal_basis[1],
+            origin=np.array([0, 0]),
         )
 
     def generate_high_symmetry_path(

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/geometry/graphene.py

@@ -13,7 +13,7 @@ from .base_lattice import BaseLattice
 class GrapheneLattice(BaseLattice):
     """Lattice geometry for Graphene."""
 
-    def __init__(self, lattice_constant: np.float64) -> None:
+    def __init__(self, lattice_constant: float) -> None:
         self._lattice_constant = lattice_constant
         self._bz_corners = (
             4
@@ -25,15 +25,23 @@ class GrapheneLattice(BaseLattice):
         self.M = np.pi / self.lattice_constant * np.array([1, 1 / np.sqrt(3)])
         self.K = 4 * np.pi / (3 * self.lattice_constant) * np.array([1, 0])
         self._high_symmetry_points = ((self.M, "M"), (self.Gamma, r"\Gamma"), (self.K, "K"))
+        self._reciprocal_basis = (
+            2 * np.pi / self.lattice_constant * np.array([1, 1 / np.sqrt(3)]),
+            2 * np.pi / self.lattice_constant * np.array([1, -1 / np.sqrt(3)]),
+        )
 
     @property
-    def lattice_constant(self) -> np.float64:  # noqa: D102
+    def lattice_constant(self) -> float:  # noqa: D102
         return self._lattice_constant
 
     @property
     def bz_corners(self) -> npt.NDArray[np.float64]:  # noqa: D102
         return self._bz_corners
 
+    @property
+    def reciprocal_basis(self) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:  # noqa: D102
+        return self._reciprocal_basis
+
     @property
     def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # noqa: D102
         return self._high_symmetry_points

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/geometry/square.py

@@ -13,26 +13,34 @@ from .base_lattice import BaseLattice
 class SquareLattice(BaseLattice):
     """Lattice geometry for Square Lattice."""
 
-    def __init__(self, lattice_constant: np.float64) -> None:
+    def __init__(self, lattice_constant: float) -> None:
         self._lattice_constant = lattice_constant
         self._bz_corners = (
             np.pi
             / lattice_constant
             * np.array([np.array([1, 1]), np.array([-1, 1]), np.array([1, -1]), np.array([-1, -1])])
         )
+        self._reciprocal_basis = (
+            2 * np.pi / self.lattice_constant * np.array([1, 0]),
+            2 * np.pi / self.lattice_constant * np.array([0, 1]),
+        )
         self.Gamma = np.array([0, 0])
         self.M = np.pi / lattice_constant * np.array([1, 1])
         self.X = np.pi / lattice_constant * np.array([1, 0])
         self._high_symmetry_points = ((self.Gamma, r"\Gamma"), (self.M, "M"))
 
     @property
-    def lattice_constant(self) -> np.float64:  # noqa: D102
+    def lattice_constant(self) -> float:  # noqa: D102
         return self._lattice_constant
 
     @property
-    def bz_corners(self) -> npt.NDArray[np.float64]:  # noqa: D102
+    def bz_corners(self) -> npt.NDArray[np.float64]:  # noqa: D102  # pragma: no cover
         return self._bz_corners
 
+    @property
+    def reciprocal_basis(self) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:  # noqa: D102
+        return self._reciprocal_basis
+
     @property
     def high_symmetry_points(self) -> tuple[tuple[npt.NDArray[np.float64], str], ...]:  # noqa: D102
         return self._high_symmetry_points

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/mean_field/_utils.py

@@ -14,14 +14,3 @@ def _check_valid_array(array_in: npt.NDArray[Any]) -> bool:
         raise ValueError(msg)
 
     return True
-
-
-def _validate_float(float_in: float, parameter_name: str) -> float:
-    if np.isinf(float_in):
-        msg = f"{parameter_name} must not be Infinity"
-        raise ValueError(msg)
-    if np.isnan(float_in):
-        msg = f"{parameter_name} must not be NaN"
-        raise ValueError(msg)
-
-    return float_in

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/mean_field/hamiltonians/__init__.py

@@ -25,10 +25,7 @@ from .base_hamiltonian import BaseHamiltonian
 from .dressed_graphene import DressedGraphene
 from .graphene import Graphene
 from .one_band_tight_binding import OneBand
+from .three_band_tight_binding import ThreeBand
+from .two_band_tight_binding import TwoBand
 
-__all__ = [
-    "BaseHamiltonian",
-    "Graphene",
-    "DressedGraphene",
-    "OneBand",
-]
+__all__ = ["BaseHamiltonian", "Graphene", "DressedGraphene", "OneBand", "TwoBand", "ThreeBand"]

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/mean_field/hamiltonians/base_hamiltonian.py

@@ -6,6 +6,7 @@
 
 import pathlib
 from abc import ABC, abstractmethod
+from typing import Generic
 
 import h5py
 import numpy as np
@@ -14,80 +15,35 @@ import pandas as pd
 
 from quant_met.geometry import BaseLattice
 from quant_met.mean_field._utils import _check_valid_array
+from quant_met.parameters.hamiltonians import GenericParameters
 
 
-class BaseHamiltonian(ABC):
+class BaseHamiltonian(Generic[GenericParameters], ABC):
     """Base class for Hamiltonians."""
 
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Name of the model.
-
-        Returns
-        -------
-        str
-
-        """
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def number_of_bands(self) -> int:
-        """Number of bands.
-
-        Returns
-        -------
-        int
-
-        """
-        raise NotImplementedError
+    def __init__(self, parameters: GenericParameters) -> None:
+        self.name = parameters.name
+        self.beta = parameters.beta if parameters.beta else 1000.0
+        self.q = parameters.q if parameters.q is not None else np.zeros(2)
 
-    @property
-    @abstractmethod
-    def lattice(self) -> BaseLattice:
-        """Lattice.
-
-        Returns
-        -------
-        BaseLattice
+        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)
 
-        """
-        raise NotImplementedError
-
-    @property
     @abstractmethod
-    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:
-        """
-        hubbard_int interaction split up in orbitals.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-
-        """
-        raise NotImplementedError
+    def setup_lattice(self, parameters: GenericParameters) -> BaseLattice:  # pragma: no cover
+        """Set up lattice based on parameters."""
 
-    @property
-    @abstractmethod
-    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:
-        """
-        Order parameter in orbital basis.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-
-        """
-        raise NotImplementedError
-
-    @delta_orbital_basis.setter
+    @classmethod
     @abstractmethod
-    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
-        raise NotImplementedError
+    def get_parameters_model(cls) -> type[GenericParameters]:  # pragma: no cover
+        """Return the specific parameters model for the subclass."""
 
     @abstractmethod
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+    def hamiltonian(
+        self, k: npt.NDArray[np.float64]
+    ) -> npt.NDArray[np.complex64]:  # pragma: no cover
         """
         Return the normal state Hamiltonian in orbital basis.
 
@@ -102,12 +58,11 @@ class BaseHamiltonian(ABC):
             Hamiltonian in matrix form.
 
         """
-        raise NotImplementedError
 
     @abstractmethod
     def hamiltonian_derivative(
         self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:
+    ) -> npt.NDArray[np.complex64]:  # pragma: no cover
         """
         Deriative of the Hamiltonian.
 
@@ -124,7 +79,6 @@ class BaseHamiltonian(ABC):
             Derivative of Hamiltonian.
 
         """
-        raise NotImplementedError
 
     def save(self, filename: pathlib.Path) -> None:
         """
@@ -139,32 +93,27 @@ class BaseHamiltonian(ABC):
         with h5py.File(f"{filename.absolute()}", "w") as f:
             f.create_dataset("delta", data=self.delta_orbital_basis)
             for key, value in vars(self).items():
-                if not key.startswith("_"):
-                    f.attrs[key] = value
+                if key != "lattice":
+                    f.attrs[key.strip("_")] = value
+            f.attrs["lattice_constant"] = self.lattice.lattice_constant
 
     @classmethod
-    @abstractmethod
-    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":
-        """
-        Initialise a Hamiltonian from a HDF5 file.
-
-        Parameters
-        ----------
-        filename : :class:`pathlib.Path`
-            File to load the Hamiltonian from.
+    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian[GenericParameters]":
+        """Initialize a Hamiltonian from an HDF5 file."""
+        with h5py.File(str(filename), "r") as f:
+            config_dict = dict(f.attrs.items())
+            config_dict["delta"] = f["delta"][()]
 
-        """
-        raise NotImplementedError
+        parameters_model = cls.get_parameters_model()
+        parameters = parameters_model.model_validate(config_dict)
+        return cls(parameters=parameters)
 
-    def bdg_hamiltonian(
-        self, k: npt.NDArray[np.float64], q: npt.NDArray[np.float64] | None = None
-    ) -> npt.NDArray[np.complex64]:
+    def bdg_hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
         """
         Bogoliuobov de Genne Hamiltonian.
 
         Parameters
         ----------
-        q
         k : :class:`numpy.ndarray`
             List of k points.
 
@@ -177,8 +126,6 @@ class BaseHamiltonian(ABC):
         assert _check_valid_array(k)
         if k.ndim == 1:
             k = np.expand_dims(k, axis=0)
-        if q is None:
-            q = np.array([0, 0])
 
         h = np.zeros(
             (k.shape[0], 2 * self.number_of_bands, 2 * self.number_of_bands), dtype=np.complex64
@@ -189,7 +136,7 @@ class BaseHamiltonian(ABC):
             :,
             self.number_of_bands : 2 * self.number_of_bands,
             self.number_of_bands : 2 * self.number_of_bands,
-        ] = -self.hamiltonian(q - k).conjugate()
+        ] = -self.hamiltonian(self.q - k).conjugate()
 
         for i in range(self.number_of_bands):
             h[:, self.number_of_bands + i, i] = self.delta_orbital_basis[i]
@@ -276,14 +223,14 @@ class BaseHamiltonian(ABC):
         return band_energies.squeeze(), bloch_wavefunctions.squeeze()
 
     def diagonalize_bdg(
-        self, k: npt.NDArray[np.float64], q: npt.NDArray[np.float64] | None = None
+        self,
+        k: npt.NDArray[np.float64],
     ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.complex64]]:
         """
         Diagonalize the BdG Hamiltonian.
 
         Parameters
         ----------
-        q
         k : :class:`numpy.ndarray`
             List of k points.
 
@@ -295,7 +242,7 @@ class BaseHamiltonian(ABC):
             Diagonalising matrix of the BdG Hamiltonian.
 
         """
-        bdg_matrix = self.bdg_hamiltonian(k=k, q=q)
+        bdg_matrix = self.bdg_hamiltonian(k=k)
         if bdg_matrix.ndim == 2:
             bdg_matrix = np.expand_dims(bdg_matrix, axis=0)
             k = np.expand_dims(k, axis=0)
@@ -312,14 +259,13 @@ class BaseHamiltonian(ABC):
         return bdg_energies.squeeze(), bdg_wavefunctions.squeeze()
 
     def gap_equation(
-        self, k: npt.NDArray[np.float64], beta: np.float64, q: npt.NDArray[np.float64] | None = None
+        self,
+        k: npt.NDArray[np.float64],
     ) -> npt.NDArray[np.complex64]:
         """Gap equation.
 
         Parameters
         ----------
-        q
-        beta
         k
 
         Returns
@@ -329,30 +275,23 @@ class BaseHamiltonian(ABC):
 
 
         """
-        if q is None:
-            q = np.array([0, 0])
-        bdg_energies, bdg_wavefunctions = self.diagonalize_bdg(k=k, q=q)
-        bdg_energies_minus_k, _ = self.diagonalize_bdg(k=-k, q=-q)
+        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):
             sum_tmp = 0
-            for j in range(self.number_of_bands):
+            for j in range(2 * self.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 + self.number_of_bands].item(), beta
-                    ) + np.conjugate(
-                        bdg_wavefunctions[k_index, i, j + self.number_of_bands]
-                    ) * bdg_wavefunctions[
-                        k_index, i + self.number_of_bands, j + self.number_of_bands
-                    ] * _fermi_dirac(
-                        -bdg_energies_minus_k[k_index, j + self.number_of_bands].item(), beta
+                    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)
                     )
             delta[i] = (-self.hubbard_int_orbital_basis[i] * sum_tmp / len(k)).conjugate()
 
-        delta_without_phase: npt.NDArray[np.complex64] = delta * np.exp(-1j * np.angle(delta[-1]))
+        delta_without_phase: npt.NDArray[np.complex64] = delta * np.exp(
+            -1j * np.angle(delta[np.argmax(np.abs(delta))])
+        )
         return delta_without_phase
 
     def calculate_bandstructure(
@@ -400,22 +339,19 @@ class BaseHamiltonian(ABC):
     def calculate_density_of_states(
         self,
         k: npt.NDArray[np.float64],
-        q: npt.NDArray[np.float64] | None = None,
     ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
         """Calculate the density of states.
 
         Parameters
         ----------
-        q
         k
-        energies
 
         Returns
         -------
         Density of states.
 
         """
-        bands, _ = self.diagonalize_bdg(k=k, q=q)
+        bands, _ = self.diagonalize_bdg(k=k)
         energies = np.linspace(start=np.min(bands), stop=np.max(bands), num=5000)
         density_of_states = np.zeros(shape=energies.shape, dtype=np.float64)
 
@@ -425,22 +361,19 @@ class BaseHamiltonian(ABC):
             ) / len(k)
         return energies, density_of_states
 
-    def calculate_spectral_gap(
-        self, k: npt.NDArray[np.float64], q: npt.NDArray[np.float64] | None = None
-    ) -> float:
+    def calculate_spectral_gap(self, k: npt.NDArray[np.float64]) -> float:
         """Calculate the spectral gap.
 
         Parameters
         ----------
         k
-        q
 
         Returns
         -------
         Spectral gap
 
         """
-        energies, density_of_states = self.calculate_density_of_states(k=k, q=q)
+        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]
 
@@ -466,6 +399,6 @@ def _gaussian(x: npt.NDArray[np.float64], sigma: float) -> npt.NDArray[np.float6
     return gaussian
 
 
-def _fermi_dirac(energy: np.float64, beta: np.float64) -> np.float64:
-    fermi_dirac: np.float64 = 1 / (1 + np.exp(beta * energy))
+def _fermi_dirac(energy: float, beta: float) -> float:
+    fermi_dirac: float = 1 / (1 + np.exp(beta * energy))
     return fermi_dirac

{quant_met-0.0.8 → quant_met-0.0.9}/src/quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -2,95 +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
-
-    @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
+class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
+    """Hamiltonian for the dressed graphene model."""
 
-    @property
-    def number_of_bands(self) -> int:  # noqa: D102
-        return self._number_of_bands
+    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)
 
-    @property
-    def lattice(self) -> GrapheneLattice:  # noqa: D102
-        return self._lattice
+    def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:
+        """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 = DressedGrapheneParameters.model_validate(config_dict)
-        return cls(parameters=parameters)
+    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]:
         """