quant-met 0.0.27__py3-none-any.whl → 0.1.1__py3-none-any.whl

quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -1,118 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Provides the implementation for the dressed graphene model."""
-
-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
-from quant_met.parameters.hamiltonians import DressedGrapheneParameters
-
-from .base_hamiltonian import BaseHamiltonian
-
-
-class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
-    """Hamiltonian for the dressed graphene model."""
-
-    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 = parameters.delta.astype(np.complex128)
-
-    def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:  # noqa: D102
-        return GrapheneLattice(lattice_constant=parameters.lattice_constant)
-
-    @classmethod
-    def get_parameters_model(cls) -> type[DressedGrapheneParameters]:  # noqa: D102
-        return DressedGrapheneParameters
-
-    def hamiltonian(self, k: npt.NDArray[np.floating]) -> npt.NDArray[np.complexfloating]:  # noqa: D102
-        assert _check_valid_array(k)
-
-        t_gr = self.hopping_gr
-        t_x = self.hopping_x
-        a = self.lattice.lattice_constant
-        v = self.hopping_x_gr_a
-        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.complex128)
-
-        h[:, 0, 1] = -t_gr * (
-            np.exp(1j * k[:, 1] * a / np.sqrt(3))
-            + 2 * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * (np.cos(0.5 * a * k[:, 0]))
-        )
-
-        h[:, 1, 0] = h[:, 0, 1].conjugate()
-
-        h[:, 2, 0] = v
-        h[:, 0, 2] = v
-
-        h[:, 2, 2] = (
-            -2
-            * t_x
-            * (
-                np.cos(a * k[:, 0])
-                + 2 * np.cos(0.5 * a * k[:, 0]) * np.cos(0.5 * np.sqrt(3) * a * k[:, 1])
-            )
-        )
-        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.floating], direction: str
-    ) -> npt.NDArray[np.complexfloating]:
-        assert _check_valid_array(k)
-        assert direction in ["x", "y"]
-
-        t_gr = self.hopping_gr
-        t_x = self.hopping_x
-        a = 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.complex128)
-
-        if direction == "x":
-            h[:, 0, 1] = (
-                t_gr * a * np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * np.sin(0.5 * a * k[:, 0])
-            )
-            h[:, 1, 0] = h[:, 0, 1].conjugate()
-            h[:, 2, 2] = (
-                2
-                * a
-                * t_x
-                * (
-                    np.sin(a * k[:, 0])
-                    + np.sin(0.5 * a * k[:, 0]) * np.cos(0.5 * np.sqrt(3) * a * k[:, 1])
-                )
-            )
-        else:
-            h[:, 0, 1] = (
-                -t_gr
-                * 1j
-                * a
-                / np.sqrt(3)
-                * (
-                    np.exp(1j * a / np.sqrt(3) * k[:, 1])
-                    - np.exp(-0.5j * a / np.sqrt(3) * k[:, 1]) * np.cos(0.5 * a * k[:, 0])
-                )
-            )
-            h[:, 1, 0] = h[:, 0, 1].conjugate()
-            h[:, 2, 2] = np.sqrt(3) * a * t_x * np.cos(0.5 * np.sqrt(3) * a * k[:, 1])
-
-        return h.squeeze()

quant_met/mean_field/hamiltonians/graphene.py

@@ -1,95 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 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 GrapheneLattice
-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[GrapheneParameters]):
-    """Hamiltonian for Graphene."""
-
-    def __init__(
-        self,
-        parameters: GrapheneParameters,
-    ) -> None:
-        super().__init__(parameters)
-        self.hopping = parameters.hopping
-        self.chemical_potential = parameters.chemical_potential
-        if parameters.delta is not None:
-            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)
-
-    @classmethod
-    def get_parameters_model(cls) -> type[GrapheneParameters]:  # noqa: D102
-        return GrapheneParameters
-
-    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
-        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.complex128)
-
-        h[:, 0, 1] = -hopping * (
-            np.exp(1j * k[:, 1] * lattice_constant / np.sqrt(3))
-            + 2
-            * np.exp(-0.5j * lattice_constant / np.sqrt(3) * k[:, 1])
-            * (np.cos(0.5 * lattice_constant * k[:, 0]))
-        )
-        h[:, 1, 0] = h[:, 0, 1].conjugate()
-        h[:, 0, 0] -= chemical_potential
-        h[:, 1, 1] -= chemical_potential
-
-        return h.squeeze()
-
-    def hamiltonian_derivative(  # noqa: D102
-        self, k: npt.NDArray[np.floating], direction: str
-    ) -> npt.NDArray[np.complexfloating]:
-        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.complex128)
-
-        if direction == "x":
-            h[:, 0, 1] = (
-                hopping
-                * lattice_constant
-                * np.exp(-0.5j * lattice_constant / np.sqrt(3) * k[:, 1])
-                * np.sin(0.5 * lattice_constant * k[:, 0])
-            )
-            h[:, 1, 0] = h[:, 0, 1].conjugate()
-        else:
-            h[:, 0, 1] = (
-                -hopping
-                * 1j
-                * lattice_constant
-                / np.sqrt(3)
-                * (
-                    np.exp(1j * lattice_constant / np.sqrt(3) * k[:, 1])
-                    - np.exp(-0.5j * lattice_constant / np.sqrt(3) * k[:, 1])
-                    * np.cos(0.5 * lattice_constant * k[:, 0])
-                )
-            )
-            h[:, 1, 0] = h[:, 0, 1].conjugate()
-
-        return h.squeeze()

quant_met/mean_field/hamiltonians/one_band_tight_binding.py

@@ -1,70 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Provides the implementation for a one 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 OneBandParameters
-
-from .base_hamiltonian import BaseHamiltonian
-
-
-class OneBand(BaseHamiltonian[OneBandParameters]):
-    """Hamiltonian for one band tight binding model."""
-
-    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 = parameters.delta.astype(np.complex128)
-
-    def setup_lattice(self, parameters: OneBandParameters) -> SquareLattice:  # noqa: D102
-        return SquareLattice(lattice_constant=parameters.lattice_constant)
-
-    @classmethod
-    def get_parameters_model(cls) -> type[OneBandParameters]:  # noqa: D102
-        return OneBandParameters
-
-    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
-        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.complex128)
-
-        h[:, 0, 0] = (
-            -2 * hopping * (np.cos(k[:, 1] * lattice_constant) + np.cos(k[:, 0] * lattice_constant))
-        )
-        h[:, 0, 0] -= chemical_potential
-
-        return h
-
-    def hamiltonian_derivative(  # noqa: D102
-        self, k: npt.NDArray[np.floating], direction: str
-    ) -> npt.NDArray[np.complexfloating]:
-        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.complex128)
-
-        if direction == "x":
-            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
-        else:
-            h[:, 0, 0] = -2 * hopping * lattice_constant * np.sin(lattice_constant * k[:, 0])
-
-        return h.squeeze()

quant_met/mean_field/hamiltonians/three_band_tight_binding.py

@@ -1,85 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 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 = parameters.delta.astype(np.complex128)
-
-    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.floating]) -> npt.NDArray[np.complexfloating]:  # 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.complex128)
-
-        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.floating], direction: str
-    ) -> npt.NDArray[np.complexfloating]:
-        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.complex128)
-
-        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

@@ -1,76 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 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 = parameters.delta.astype(np.complex128)
-
-    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.floating]) -> npt.NDArray[np.complexfloating]:  # 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.complex128)
-
-        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.floating], direction: str
-    ) -> npt.NDArray[np.complexfloating]:
-        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.complex128)
-
-        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/parameters/hamiltonians.py

@@ -1,182 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""
-hamiltonians
-============
-
-Classes holding the configuration for the Hamiltonians.
-
-.. autosummary::
-   :toctree:
-   :template: autosummary/pydantic.rst
-
-    HamiltonianParameters
-    DressedGrapheneParameters
-    GrapheneParameters
-    OneBandParameters
-    TwoBandParameters
-    ThreeBandParameters
-"""  # noqa: D205, D400
-
-from typing import Literal, TypeVar
-
-import numpy as np
-from numpydantic import NDArray, Shape
-from pydantic import BaseModel, Field, field_validator
-from pydantic_core.core_schema import ValidationInfo
-
-GenericParameters = TypeVar("GenericParameters", bound="HamiltonianParameters")
-
-
-def check_positive_values(value: float, info: ValidationInfo) -> float:
-    """Check for positive values."""
-    if value < 0:
-        msg = f"{info.field_name} must be positive"
-        raise ValueError(msg)
-    return value
-
-
-def validate_float(value: float, info: ValidationInfo) -> float:
-    """Check for valid floats."""
-    if np.isinf(value):
-        msg = f"{info.field_name} must not be Infinity"
-        raise ValueError(msg)
-    if np.isnan(value):
-        msg = f"{info.field_name} must not be NaN"
-        raise ValueError(msg)
-    return value
-
-
-class HamiltonianParameters(BaseModel):
-    """Base class for Hamiltonian parameters."""
-
-    name: str
-    """The name of the Hamiltonian model (e.g., "Graphene", "DressedGraphene")."""
-    hubbard_int_orbital_basis: NDArray
-    """A numpy array representing the Hubbard interactions in the orbital basis."""
-    beta: float = np.inf
-    """The inverse temperature; default is set to infinity."""
-    q: NDArray[Shape["2"], float] | None = None
-    """An optional numpy array representing the momentum of Cooper pairs."""
-
-
-class DressedGrapheneParameters(HamiltonianParameters):
-    """Parameters for the Dressed Graphene model.
-
-    Attributes
-    ----------
-    hopping_gr : float
-        Hopping parameter in the graphene layer.
-    hopping_x : float
-        Hopping parameter at the impurity site.
-    hopping_x_gr_a : float
-        Hybridization parameter.
-    lattice_constant : float
-        The lattice constant of the model.
-    chemical_potential : float
-        The chemical potential.
-    hubbard_int_orbital_basis : npt.NDArray[np.floating]
-        Hubbard interaction in the orbital basis.
-    delta : npt.NDArray[np.complexfloating] | None
-        Initial value for gaps in orbital space.
-    """
-
-    name: Literal["DressedGraphene"] = "DressedGraphene"
-    hopping_gr: float = Field(..., description="Hopping in graphene")
-    hopping_x: float = Field(..., description="Hopping in impurity")
-    hopping_x_gr_a: float = Field(..., description="Hybridization")
-    lattice_constant: float = Field(..., description="Lattice constant")
-    chemical_potential: float = Field(..., description="Chemical potential")
-    hubbard_int_orbital_basis: NDArray[Shape["3"], np.float64] = Field(
-        ..., description="Hubbard interaction in orbital basis"
-    )
-    delta: NDArray[Shape["3"], np.complex128] | None = Field(
-        default=None, description="Initial value for gaps in orbital space"
-    )
-
-    _check_positive_values = field_validator(
-        "hopping_gr", "hopping_x", "hopping_x_gr_a", "lattice_constant"
-    )(check_positive_values)
-
-    _check_valid_floats = field_validator(
-        "hopping_gr", "hopping_x", "hopping_x_gr_a", "lattice_constant", "chemical_potential"
-    )(validate_float)
-
-
-class GrapheneParameters(HamiltonianParameters):
-    """Parameters for Graphene model."""
-
-    name: Literal["Graphene"] = "Graphene"
-    hopping: float
-    lattice_constant: float
-    chemical_potential: float
-    hubbard_int_orbital_basis: NDArray[Shape["2"], np.float64] = Field(
-        ..., description="Hubbard interaction in orbital basis"
-    )
-    delta: NDArray[Shape["2"], np.complex128] | None = None
-
-    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
-
-    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
-        validate_float
-    )
-
-
-class OneBandParameters(HamiltonianParameters):
-    """Parameters for Graphene model."""
-
-    name: Literal["OneBand"] = "OneBand"
-    hopping: float
-    lattice_constant: float
-    chemical_potential: float
-    hubbard_int_orbital_basis: NDArray[Shape["1"], np.floating] = Field(
-        ..., description="Hubbard interaction in orbital basis"
-    )
-    delta: NDArray[Shape["1"], np.complex128] | None = None
-
-    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
-
-    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
-        validate_float
-    )
-
-
-class TwoBandParameters(HamiltonianParameters):
-    """Parameters for Graphene model."""
-
-    name: Literal["TwoBand"] = "TwoBand"
-    hopping: float
-    lattice_constant: float
-    chemical_potential: float
-    hubbard_int_orbital_basis: NDArray[Shape["2"], np.float64] = Field(
-        ..., description="Hubbard interaction in orbital basis"
-    )
-    delta: NDArray[Shape["2"], np.complexfloating] | None = None
-
-    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
-
-    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
-        validate_float
-    )
-
-
-class ThreeBandParameters(HamiltonianParameters):
-    """Parameters for Graphene model."""
-
-    name: Literal["ThreeBand"] = "ThreeBand"
-    hopping: float
-    lattice_constant: float
-    chemical_potential: float
-    hubbard_int_orbital_basis: NDArray[Shape["3"], np.float64] = Field(
-        ..., description="Hubbard interaction in orbital basis"
-    )
-    delta: NDArray[Shape["3"], np.complex128] | None = None
-
-    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
-
-    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
-        validate_float
-    )

quant_met/plotting/__init__.py

@@ -1,31 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""
-Plotting
-========
-
-.. currentmodule:: quant_met.plotting
-
-Functions
----------
-
-.. autosummary::
-   :toctree: generated/
-
-    format_plot
-    scatter_into_bz
-    plot_bandstructure
-    plot_superfluid_weight
-"""  # noqa: D205, D400
-
-from .plotting import format_plot, plot_bandstructure, plot_superfluid_weight, scatter_into_bz
-
-__all__ = [
-    "format_plot",
-    "plot_bandstructure",
-    "plot_superfluid_weight",
-    "scatter_into_bz",
-]