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

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

@@ -1,19 +1,21 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.7
+Version: 0.0.8
 Summary: Calculate superconductivity in flat-band systems.
 Home-page: https://quant-met.tjarksievers.de
 Author: Tjark Sievers
 Author-email: tsievers@physnet.uni-hamburg.de
-Requires-Python: >=3.11,<4.0
+Requires-Python: >=3.11,<3.13
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (>=8.1.7,<9.0.0)
 Requires-Dist: h5py (>=3.12.1,<4.0.0)
 Requires-Dist: matplotlib (>=3.9.2,<4.0.0)
 Requires-Dist: numpy (>=2.1.2,<3.0.0)
+Requires-Dist: numpydantic (>=1.6.4,<2.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
 Requires-Dist: scipy (>=1.14.1,<2.0.0)
 Project-URL: Repository, https://github.com/Ruberhauptmann/quant-met
 Description-Content-Type: text/markdown

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

@@ -4,24 +4,30 @@
 
 [project]
 name = "quant-met"
-requires-python = ">=3.12"
+requires-python = ">=3.11,<3.13"
 
 [tool.poetry]
 name = "quant-met"
-version = "0.0.7"
+version = "0.0.8"
 description = "Calculate superconductivity in flat-band systems."
 authors = ["Tjark Sievers <tsievers@physnet.uni-hamburg.de>"]
 homepage = "https://quant-met.tjarksievers.de"
 repository = "https://github.com/Ruberhauptmann/quant-met"
 readme = "README.md"
 
+[tool.poetry.scripts]
+quant-met = 'quant_met.cli:cli'
+
 [tool.poetry.dependencies]
-python = "^3.11"
+python = ">=3.11,<3.13"
 numpy = "^2.1.2"
 scipy = "^1.14.1"
 matplotlib = "^3.9.2"
 pandas = "^2.2.3"
 h5py = "^3.12.1"
+pydantic = "^2.9.2"
+click = "^8.1.7"
+numpydantic = "^1.6.4"
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = "^3.7.0"
@@ -42,6 +48,7 @@ hypothesis = {extras = ["numpy"], version = "^6.103.0"}
 pytest-regressions = "^2.5.0"
 numpydoc = "^1.7.0"
 ruff = "^0.5.0"
+types-pyyaml = "^6.0.12.20240917"
 
 [build-system]
 requires = ["poetry-core"]
@@ -51,7 +58,8 @@ build-backend = "poetry.core.masonry.api"
 [tool.ruff]
 line-length = 100
 force-exclude = true
-extend-exclude = ["tests", "docs/source/conf.py"]
+#extend-exclude = ["tests", "docs/source/conf.py"]
+extend-exclude = ["docs/source/conf.py"]
 
 [tool.ruff.lint]
 #select = []

quant_met-0.0.8/src/quant_met/cli/__init__.py

@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Command-Line-Interface (:mod:`quant_met.cli`)
+=============================================
+
+Functions
+---------
+
+.. autosummary::
+    :toctree: generated/
+
+    cli
+"""  # noqa: D205, D400
+
+from .main import cli
+
+__all__ = [
+    "cli",
+]

quant_met-0.0.8/src/quant_met/cli/main.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Command line interface."""
+
+import sys
+from typing import TextIO
+
+import click
+import yaml
+
+from quant_met.parameters import Parameters
+
+from .scf import scf
+
+
+@click.command()
+@click.argument("input-file", type=click.File("r"))
+def cli(input_file: TextIO) -> None:
+    """Command line interface for quant-met.
+
+    Parameters
+    ----------
+    input_file
+    """
+    params = Parameters(**yaml.safe_load(input_file))
+
+    match params.control.calculation:
+        case "scf":
+            scf(params)
+        case _:
+            print(f"Calculation {params.control.calculation} not found.")
+            sys.exit(1)

quant_met-0.0.8/src/quant_met/cli/scf.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to run self-consistent calculation for the order parameter."""
+
+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
+
+
+def _hamiltonian_factory(classname: str, parameters: BaseModel) -> BaseHamiltonian:
+    """Create a hamiltonian by its class name."""
+    from quant_met.mean_field import hamiltonians
+
+    cls = getattr(hamiltonians, classname)
+    h: BaseHamiltonian = cls(parameters)
+    return h
+
+
+def scf(parameters: Parameters) -> None:
+    """Self-consistent calculation for the order parameter."""
+    result_path = Path(parameters.control.outdir)
+    result_path.mkdir(exist_ok=True, parents=True)
+    h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
+    solved_h = mean_field.self_consistency_loop(
+        h=h,
+        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"
+    solved_h.save(filename=result_file)

{quant_met-0.0.7 → quant_met-0.0.8}/src/quant_met/geometry/__init__.py

@@ -15,12 +15,21 @@ Functions
    :toctree: generated/
 
     generate_bz_path
-    Graphene
+
+Classes
+-------
+
+.. autosummary::
+   :toctree: generated/
+
+   BaseLattice
+   GrapheneLattice
+   SquareLattice
 """  # noqa: D205, D400
 
 from .base_lattice import BaseLattice
 from .bz_path import generate_bz_path
-from .graphene import Graphene
+from .graphene import GrapheneLattice
 from .square import SquareLattice
 
-__all__ = ["generate_bz_path", "BaseLattice", "Graphene", "SquareLattice"]
+__all__ = ["generate_bz_path", "BaseLattice", "GrapheneLattice", "SquareLattice"]

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

@@ -10,7 +10,7 @@ import numpy.typing as npt
 from .base_lattice import BaseLattice
 
 
-class Graphene(BaseLattice):
+class GrapheneLattice(BaseLattice):
     """Lattice geometry for Graphene."""
 
     def __init__(self, lattice_constant: np.float64) -> None:

quant_met-0.0.8/src/quant_met/mean_field/__init__.py

@@ -0,0 +1,42 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Mean field treatment (:mod:`quant_met.mean_field`)
+==================================================
+
+Submodules
+----------
+
+.. autosummary::
+    :toctree: generated/
+
+    hamiltonians
+
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   superfluid_weight
+   quantum_metric
+   quantum_metric_bdg
+   self_consistency_loop
+"""  # noqa: D205, D400
+
+from quant_met.mean_field import hamiltonians
+
+from .quantum_metric import quantum_metric, quantum_metric_bdg
+from .self_consistency import self_consistency_loop
+from .superfluid_weight import superfluid_weight
+
+__all__ = [
+    "superfluid_weight",
+    "quantum_metric",
+    "quantum_metric_bdg",
+    "self_consistency_loop",
+    "hamiltonians",
+]

quant_met-0.0.8/src/quant_met/mean_field/hamiltonians/__init__.py

@@ -0,0 +1,34 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Hamiltonians (:mod:`quant_met.mean_field.hamiltonians`)
+=======================================================
+
+Base
+
+.. autosummary::
+    :toctree: hamiltonians/
+
+    BaseHamiltonian
+
+.. autosummary::
+    :toctree: hamiltonians/
+
+    Graphene
+    DressedGraphene
+    OneBand
+"""  # noqa: D205, D400
+
+from .base_hamiltonian import BaseHamiltonian
+from .dressed_graphene import DressedGraphene
+from .graphene import Graphene
+from .one_band_tight_binding import OneBand
+
+__all__ = [
+    "BaseHamiltonian",
+    "Graphene",
+    "DressedGraphene",
+    "OneBand",
+]

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

@@ -12,19 +12,51 @@ import numpy as np
 import numpy.typing as npt
 import pandas as pd
 
-from ._utils import _check_valid_array
+from quant_met.geometry import BaseLattice
+from quant_met.mean_field._utils import _check_valid_array
 
 
 class BaseHamiltonian(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 in the model."""
+        """Number of bands.
+
+        Returns
+        -------
+        int
+
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def lattice(self) -> BaseLattice:
+        """Lattice.
+
+        Returns
+        -------
+        BaseLattice
+
+        """
         raise NotImplementedError
 
     @property
+    @abstractmethod
     def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:
         """
         hubbard_int interaction split up in orbitals.
@@ -37,6 +69,7 @@ class BaseHamiltonian(ABC):
         raise NotImplementedError
 
     @property
+    @abstractmethod
     def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:
         """
         Order parameter in orbital basis.
@@ -103,13 +136,14 @@ class BaseHamiltonian(ABC):
             Filename to save the Hamiltonian to, should end in .hdf5
 
         """
-        with h5py.File(f"{filename}", "w") as f:
+        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
 
     @classmethod
+    @abstractmethod
     def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":
         """
         Initialise a Hamiltonian from a HDF5 file.
@@ -120,18 +154,17 @@ class BaseHamiltonian(ABC):
             File to load the Hamiltonian from.
 
         """
-        with h5py.File(f"{filename}", "r") as f:
-            config_dict = dict(f.attrs.items())
-            config_dict["delta"] = f["delta"][()]
-
-        return cls(**config_dict)
+        raise NotImplementedError
 
-    def bdg_hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+    def bdg_hamiltonian(
+        self, k: npt.NDArray[np.float64], q: npt.NDArray[np.float64] | None = None
+    ) -> npt.NDArray[np.complex64]:
         """
         Bogoliuobov de Genne Hamiltonian.
 
         Parameters
         ----------
+        q
         k : :class:`numpy.ndarray`
             List of k points.
 
@@ -144,6 +177,8 @@ 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
@@ -154,10 +189,11 @@ class BaseHamiltonian(ABC):
             :,
             self.number_of_bands : 2 * self.number_of_bands,
             self.number_of_bands : 2 * self.number_of_bands,
-        ] = -self.hamiltonian(-k).conjugate()
+        ] = -self.hamiltonian(q - k).conjugate()
 
         for i in range(self.number_of_bands):
             h[:, self.number_of_bands + i, i] = self.delta_orbital_basis[i]
+
         h[:, 0 : self.number_of_bands, self.number_of_bands : self.number_of_bands * 2] = (
             h[:, self.number_of_bands : self.number_of_bands * 2, 0 : self.number_of_bands]
             .copy()
@@ -240,13 +276,14 @@ class BaseHamiltonian(ABC):
         return band_energies.squeeze(), bloch_wavefunctions.squeeze()
 
     def diagonalize_bdg(
-        self, k: npt.NDArray[np.float64]
+        self, k: npt.NDArray[np.float64], q: npt.NDArray[np.float64] | None = None
     ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.complex64]]:
         """
         Diagonalize the BdG Hamiltonian.
 
         Parameters
         ----------
+        q
         k : :class:`numpy.ndarray`
             List of k points.
 
@@ -258,7 +295,7 @@ class BaseHamiltonian(ABC):
             Diagonalising matrix of the BdG Hamiltonian.
 
         """
-        bdg_matrix = self.bdg_hamiltonian(k)
+        bdg_matrix = self.bdg_hamiltonian(k=k, q=q)
         if bdg_matrix.ndim == 2:
             bdg_matrix = np.expand_dims(bdg_matrix, axis=0)
             k = np.expand_dims(k, axis=0)
@@ -275,12 +312,13 @@ class BaseHamiltonian(ABC):
         return bdg_energies.squeeze(), bdg_wavefunctions.squeeze()
 
     def gap_equation(
-        self, k: npt.NDArray[np.float64], beta: np.float64
+        self, k: npt.NDArray[np.float64], beta: np.float64, q: npt.NDArray[np.float64] | None = None
     ) -> npt.NDArray[np.complex64]:
         """Gap equation.
 
         Parameters
         ----------
+        q
         beta
         k
 
@@ -291,8 +329,10 @@ class BaseHamiltonian(ABC):
 
 
         """
-        bdg_energies, bdg_wavefunctions = self.diagonalize_bdg(k)
-        bdg_energies_minus_k, _ = self.diagonalize_bdg(-k)
+        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)
         delta = np.zeros(self.number_of_bands, dtype=np.complex64)
 
         for i in range(self.number_of_bands):
@@ -312,7 +352,7 @@ class BaseHamiltonian(ABC):
                     )
             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[0]))
+        delta_without_phase: npt.NDArray[np.complex64] = delta * np.exp(-1j * np.angle(delta[-1]))
         return delta_without_phase
 
     def calculate_bandstructure(
@@ -358,12 +398,15 @@ class BaseHamiltonian(ABC):
         return results
 
     def calculate_density_of_states(
-        self, k: npt.NDArray[np.float64], energies: npt.NDArray[np.float64]
-    ) -> npt.NDArray[np.float64]:
+        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
 
@@ -372,13 +415,48 @@ class BaseHamiltonian(ABC):
         Density of states.
 
         """
+        bands, _ = self.diagonalize_bdg(k=k, q=q)
+        energies = np.linspace(start=np.min(bands), stop=np.max(bands), num=5000)
         density_of_states = np.zeros(shape=energies.shape, dtype=np.float64)
-        bands, _ = self.diagonalize_bdg(k=k)
+
         for i, energy in enumerate(energies):
             density_of_states[i] = np.sum(
                 _gaussian(x=(energy - bands.flatten()), sigma=1e-2)
             ) / len(k)
-        return density_of_states
+        return energies, density_of_states
+
+    def calculate_spectral_gap(
+        self, k: npt.NDArray[np.float64], q: npt.NDArray[np.float64] | None = None
+    ) -> float:
+        """Calculate the spectral gap.
+
+        Parameters
+        ----------
+        k
+        q
+
+        Returns
+        -------
+        Spectral gap
+
+        """
+        energies, density_of_states = self.calculate_density_of_states(k=k, q=q)
+
+        coherence_peaks = np.where(np.isclose(density_of_states, np.max(density_of_states)))[0]
+
+        gap_region = density_of_states[coherence_peaks[0] : coherence_peaks[1] + 1] / np.max(
+            density_of_states
+        )
+        energies_gap_region = energies[coherence_peaks[0] : coherence_peaks[1] + 1]
+        zero_indeces = np.where(gap_region <= 1e-10)[0]
+        if len(zero_indeces) == 0:
+            gap = 0
+        else:
+            gap = (
+                energies_gap_region[zero_indeces[-1]] - energies_gap_region[zero_indeces[0]]
+            ).item()
+
+        return gap
 
 
 def _gaussian(x: npt.NDArray[np.float64], sigma: float) -> npt.NDArray[np.float64]:

quant_met-0.0.7/src/quant_met/mean_field/eg_x.py → quant_met-0.0.8/src/quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -4,54 +4,65 @@
 
 """Provides the implementation for the EG-X model."""
 
+import pathlib
 from typing import Any
 
+import h5py
 import numpy as np
 import numpy.typing as npt
 
-from ._utils import _check_valid_array, _validate_float
+from quant_met.geometry.graphene import GrapheneLattice
+from quant_met.mean_field._utils import _check_valid_array, _validate_float
+from quant_met.parameters.hamiltonians import DressedGrapheneParameters
+
 from .base_hamiltonian import BaseHamiltonian
 
 
-class EGXHamiltonian(BaseHamiltonian):
+class DressedGraphene(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,
+        parameters: DressedGrapheneParameters,
         *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:
+        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_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._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 delta is None:
+        if parameters.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)
+            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
@@ -69,6 +80,18 @@ class EGXHamiltonian(BaseHamiltonian):
     def number_of_bands(self) -> int:  # noqa: D102
         return self._number_of_bands
 
+    @property
+    def lattice(self) -> GrapheneLattice:  # noqa: D102
+        return self._lattice
+
+    @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.
@@ -88,7 +111,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 +167,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-0.0.7/src/quant_met/mean_field → quant_met-0.0.8/src/quant_met/mean_field/hamiltonians}/graphene.py

@@ -4,46 +4,60 @@
 
 """Provides the implementation for Graphene."""
 
+import pathlib
 from typing import Any
 
+import h5py
 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, _validate_float
+from quant_met.parameters.hamiltonians import GrapheneParameters
+
 from .base_hamiltonian import BaseHamiltonian
 
 
-class GrapheneHamiltonian(BaseHamiltonian):
+class Graphene(BaseHamiltonian):
     """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,
+        parameters: GrapheneParameters,
         *args: tuple[Any, ...],
         **kwargs: tuple[dict[str, Any], ...],
     ) -> None:
         del args
         del kwargs
-        self.hopping = _validate_float(hopping, "Hopping")
-        if lattice_constant <= 0:
+        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_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._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 delta is None:
+        if parameters.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)
+            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
@@ -61,6 +75,14 @@ class GrapheneHamiltonian(BaseHamiltonian):
     def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
         self._delta_orbital_basis = new_delta
 
+    @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.
@@ -78,7 +100,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 +142,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-0.0.7/src/quant_met/mean_field → quant_met-0.0.8/src/quant_met/mean_field/hamiltonians}/one_band_tight_binding.py

@@ -4,46 +4,58 @@
 
 """Provides the implementation for Graphene."""
 
+import pathlib
 from typing import Any
 
+import h5py
 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, _validate_float
+from quant_met.parameters import OneBandParameters
+
 from .base_hamiltonian import BaseHamiltonian
 
 
-class OneBandTightBindingHamiltonian(BaseHamiltonian):
+class OneBand(BaseHamiltonian):
     """Hamiltonian for Graphene."""
 
     def __init__(
         self,
-        hopping: float,
-        lattice_constant: float,
-        chemical_potential: float,
-        hubbard_int: float,
-        delta: npt.NDArray[np.float64] | None = None,
+        parameters: OneBandParameters,
         *args: tuple[Any, ...],
         **kwargs: tuple[dict[str, Any], ...],
     ) -> None:
         del args
         del kwargs
-        self.hopping = _validate_float(hopping, "Hopping")
-        if lattice_constant <= 0:
+        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_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._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 delta is None:
+        if parameters.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)
+            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
@@ -61,6 +73,14 @@ class OneBandTightBindingHamiltonian(BaseHamiltonian):
     def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
         self._delta_orbital_basis = new_delta
 
+    @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.
@@ -78,7 +98,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 +135,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-0.0.7 → quant_met-0.0.8}/src/quant_met/mean_field/quantum_metric.py

@@ -7,7 +7,7 @@
 import numpy as np
 import numpy.typing as npt
 
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
 
 
 def quantum_metric(

{quant_met-0.0.7 → quant_met-0.0.8}/src/quant_met/mean_field/self_consistency.py

@@ -5,35 +5,45 @@
 """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
 
 
 def self_consistency_loop(
-    h: BaseHamiltonian, beta: np.float64, number_of_k_points: int, epsilon: float
+    h: BaseHamiltonian,
+    k_space_grid: npt.NDArray[np.float64],
+    beta: np.float64,
+    epsilon: float,
+    q: npt.NDArray[np.float64] | None = None,
 ) -> BaseHamiltonian:
     """Self-consistency loop.
 
     Parameters
     ----------
+    lattice
+    q
     beta
     number_of_k_points
     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)
+    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.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 += (
+        2 * rng.random(size=h.delta_orbital_basis.shape)
+        - 1
+        + 1.0j * (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, q=q, beta=beta)
         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.1
         h.delta_orbital_basis = mixing_greed * new_gap + (1 - mixing_greed) * h.delta_orbital_basis

{quant_met-0.0.7 → quant_met-0.0.8}/src/quant_met/mean_field/superfluid_weight.py

@@ -7,7 +7,7 @@
 import numpy as np
 import numpy.typing as npt
 
-from .base_hamiltonian import BaseHamiltonian
+from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
 
 
 def superfluid_weight(

quant_met-0.0.8/src/quant_met/parameters/__init__.py

@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Parameters (:mod:`quant_met.parameters`)
+========================================
+
+.. autosummary::
+   :toctree: generated/parameters/
+
+    DressedGrapheneParameters
+    GrapheneParameters
+    OneBandParameters
+    Parameters
+"""  # noqa: D205, D400
+
+from .hamiltonians import DressedGrapheneParameters, GrapheneParameters, OneBandParameters
+from .main import Parameters
+
+__all__ = ["Parameters", "DressedGrapheneParameters", "GrapheneParameters", "OneBandParameters"]

quant_met-0.0.8/src/quant_met/parameters/hamiltonians.py

@@ -0,0 +1,47 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Pydantic models to hold parameters for Hamiltonians."""
+
+from typing import Literal
+
+import numpy as np
+from numpydantic import NDArray, Shape
+from pydantic import BaseModel
+
+
+class DressedGrapheneParameters(BaseModel):
+    """Parameters for the dressed Graphene model."""
+
+    name: Literal["DressedGraphene"] = "DressedGraphene"
+    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: NDArray[Shape["3"], np.complex64] | None = None
+
+
+class GrapheneParameters(BaseModel):
+    """Parameters for Graphene model."""
+
+    name: Literal["Graphene"] = "Graphene"
+    hopping: float
+    lattice_constant: float
+    chemical_potential: float
+    hubbard_int: float
+    delta: NDArray[Shape["2"], np.complex64] | None = None
+
+
+class OneBandParameters(BaseModel):
+    """Parameters for Graphene model."""
+
+    name: Literal["OneBand"] = "OneBand"
+    hopping: float
+    lattice_constant: float
+    chemical_potential: float
+    hubbard_int: float
+    delta: NDArray[Shape["1"], np.complex64] | None = None

quant_met-0.0.8/src/quant_met/parameters/main.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Pydantic models to hold parameters to run a simulation."""
+
+import pathlib
+
+from numpydantic import NDArray, Shape
+from pydantic import BaseModel, Field
+
+from .hamiltonians import DressedGrapheneParameters, GrapheneParameters, OneBandParameters
+
+
+class Control(BaseModel):
+    """Control for the calculation."""
+
+    calculation: str
+    prefix: str
+    outdir: pathlib.Path
+    conv_treshold: float
+    beta: float
+    q: NDArray[Shape["2"], int | float] | None = None
+
+
+class KPoints(BaseModel):
+    """Control for k points."""
+
+    nk1: int
+    nk2: int
+
+
+class Parameters(BaseModel):
+    """Class to hold the parameters for a calculation."""
+
+    control: Control
+    model: DressedGrapheneParameters | GrapheneParameters | OneBandParameters = Field(
+        ..., discriminator="name"
+    )
+    k_points: KPoints

{quant_met-0.0.7 → quant_met-0.0.8}/src/quant_met/utils.py

@@ -14,7 +14,7 @@ Functions
 .. autosummary::
    :toctree: generated/
 
-    generate_uniform_grid - Generate a uniform grid of points in 2D.
+    generate_uniform_grid
 """  # noqa: D205, D400
 
 import numpy as np

quant_met-0.0.7/src/quant_met/mean_field/__init__.py

@@ -1,65 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""
-Mean field treatment (:mod:`quant_met.mean_field`)
-==================================================
-
-Hamiltonians
-------------
-
-Base
-
-.. autosummary::
-   :toctree: generated/
-
-    BaseHamiltonian
-
-.. autosummary::
-   :toctree: generated/
-
-    GrapheneHamiltonian
-    EGXHamiltonian
-
-
-Functions
----------
-
-.. autosummary::
-   :toctree: generated/
-
-   superfluid_weight
-   quantum_metric
-   free_energy
-   free_energy_uniform_pairing
-"""  # noqa: D205, D400
-
-from .base_hamiltonian import BaseHamiltonian
-from .eg_x import EGXHamiltonian
-from .free_energy import (
-    free_energy,
-    free_energy_complex_gap,
-    free_energy_real_gap,
-    free_energy_uniform_pairing,
-)
-from .graphene import GrapheneHamiltonian
-from .one_band_tight_binding import OneBandTightBindingHamiltonian
-from .quantum_metric import quantum_metric, quantum_metric_bdg
-from .self_consistency import self_consistency_loop
-from .superfluid_weight import superfluid_weight
-
-__all__ = [
-    "superfluid_weight",
-    "quantum_metric",
-    "quantum_metric_bdg",
-    "free_energy",
-    "free_energy_complex_gap",
-    "free_energy_real_gap",
-    "free_energy_uniform_pairing",
-    "self_consistency_loop",
-    "BaseHamiltonian",
-    "GrapheneHamiltonian",
-    "EGXHamiltonian",
-    "OneBandTightBindingHamiltonian",
-]

quant_met-0.0.7/src/quant_met/mean_field/free_energy.py

@@ -1,130 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-"""Functions to calculate the free energy of a BdG Hamiltonian."""
-
-import numpy as np
-import numpy.typing as npt
-
-from .base_hamiltonian import BaseHamiltonian
-
-
-def free_energy(
-    hamiltonian: BaseHamiltonian,
-    k_points: npt.NDArray[np.float64],
-) -> float:
-    """Calculate the free energy of a BdG Hamiltonian.
-
-    Parameters
-    ----------
-    hamiltonian : :class:`BaseHamiltonian`
-        Hamiltonian to be evaluated.
-    k_points : :class:`numpy.ndarray`
-        List of k points
-
-    Returns
-    -------
-    float
-        Free energy from the BdG Hamiltonian.
-
-    """
-    number_k_points = len(k_points)
-    bdg_energies, _ = hamiltonian.diagonalize_bdg(k_points)
-
-    k_array = np.array(
-        [
-            np.sum(np.abs(bdg_energies[k_index][0 : hamiltonian.number_of_bands]))
-            for k_index in range(number_k_points)
-        ]
-    )
-
-    integral: float = -np.sum(k_array, axis=-1) / number_k_points + np.sum(
-        np.power(np.abs(hamiltonian.delta_orbital_basis), 2) / hamiltonian.hubbard_int_orbital_basis
-    )
-
-    return integral
-
-
-def free_energy_complex_gap(
-    delta_vector: npt.NDArray[np.float64],
-    hamiltonian: BaseHamiltonian,
-    k_points: npt.NDArray[np.float64],
-) -> float:
-    """Calculate the free energy of a BdG Hamiltonian, with a complex order parameter.
-
-    Parameters
-    ----------
-    delta_vector : :class:`numpy.ndarray`
-        Delta in orbital basis, with consecutive floats getting converted into one complex number,
-        so [a, b, c, d] -> [a+b*j, c+d*j].
-    hamiltonian : :class:`BaseHamiltonian`
-        Hamiltonian to be evaluated.
-    k_points : :class:`numpy.ndarray`
-        List of k points
-
-    Returns
-    -------
-    float
-        Free energy from the BdG Hamiltonian.
-
-    """
-    hamiltonian.delta_orbital_basis = delta_vector[0::2] + 1j * delta_vector[1::2]
-
-    return free_energy(hamiltonian=hamiltonian, k_points=k_points)
-
-
-def free_energy_real_gap(
-    delta_vector: npt.NDArray[np.float64],
-    hamiltonian: BaseHamiltonian,
-    k_points: npt.NDArray[np.float64],
-) -> float:
-    """Calculate the free energy of a BdG Hamiltonian, with a real order parameter.
-
-    Parameters
-    ----------
-    delta_vector : :class:`numpy.ndarray`
-        Delta in orbital basis.
-    hamiltonian : :class:`BaseHamiltonian`
-        Hamiltonian to be evaluated.
-    k_points : :class:`numpy.ndarray`
-        List of k points
-
-    Returns
-    -------
-    float
-        Free energy from the BdG Hamiltonian.
-
-    """
-    hamiltonian.delta_orbital_basis = delta_vector.astype(np.complex64)
-
-    return free_energy(hamiltonian=hamiltonian, k_points=k_points)
-
-
-def free_energy_uniform_pairing(
-    delta: float,
-    hamiltonian: BaseHamiltonian,
-    k_points: npt.NDArray[np.float64],
-) -> float:
-    """Calculate the free energy of a BdG Hamiltonian, with uniform pairing constraint.
-
-    Parameters
-    ----------
-    delta : float
-        Delta.
-    hamiltonian : :class:`BaseHamiltonian`
-        Hamiltonian to be evaluated.
-    k_points : :class:`numpy.ndarray`
-        List of k points
-
-    Returns
-    -------
-    float
-        Free energy from the BdG Hamiltonian.
-
-    """
-    hamiltonian.delta_orbital_basis = np.full(
-        hamiltonian.number_of_bands, fill_value=delta, dtype=np.float64
-    ).astype(np.complex64)
-
-    return free_energy(hamiltonian=hamiltonian, k_points=k_points)