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

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/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/cli/scf.py

@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to run self-consistent calculation for the order parameter."""
+
+from pathlib import Path
+
+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: HamiltonianParameters
+) -> BaseHamiltonian[HamiltonianParameters]:
+    """Create a hamiltonian by its class name."""
+    from quant_met.mean_field import hamiltonians
+
+    cls = getattr(hamiltonians, classname)
+    h: BaseHamiltonian[HamiltonianParameters] = 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
+        ),
+        epsilon=parameters.control.conv_treshold,
+    )
+    print(solved_h.delta_orbital_basis)
+    result_file = result_path / f"{parameters.control.prefix}.hdf5"
+    solved_h.save(filename=result_file)

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/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/geometry/graphene.py

@@ -10,10 +10,10 @@ 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:
+    def __init__(self, lattice_constant: float) -> None:
         self._lattice_constant = lattice_constant
         self._bz_corners = (
             4
@@ -25,15 +25,23 @@ class Graphene(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/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/mean_field/__init__.py

@@ -6,21 +6,13 @@
 Mean field treatment (:mod:`quant_met.mean_field`)
 ==================================================
 
-Hamiltonians
-------------
-
-Base
+Submodules
+----------
 
 .. autosummary::
-   :toctree: generated/
+    :toctree: generated/
 
-    BaseHamiltonian
-
-.. autosummary::
-   :toctree: generated/
-
-    GrapheneHamiltonian
-    EGXHamiltonian
+    hamiltonians
 
 
 Functions
@@ -31,20 +23,12 @@ Functions
 
    superfluid_weight
    quantum_metric
-   free_energy
-   free_energy_uniform_pairing
+   quantum_metric_bdg
+   self_consistency_loop
 """  # 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 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
@@ -53,13 +37,6 @@ __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",
+    "hamiltonians",
 ]

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/mean_field/hamiltonians/__init__.py

@@ -0,0 +1,31 @@
+# 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
+from .three_band_tight_binding import ThreeBand
+from .two_band_tight_binding import TwoBand
+
+__all__ = ["BaseHamiltonian", "Graphene", "DressedGraphene", "OneBand", "TwoBand", "ThreeBand"]

quant_met/mean_field/{base_hamiltonian.py → hamiltonians/base_hamiltonian.py}

@@ -6,55 +6,44 @@
 
 import pathlib
 from abc import ABC, abstractmethod
+from typing import Generic
 
 import h5py
 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
+from quant_met.parameters.hamiltonians import GenericParameters
 
 
-class BaseHamiltonian(ABC):
+class BaseHamiltonian(Generic[GenericParameters], ABC):
     """Base class for Hamiltonians."""
 
-    @property
-    @abstractmethod
-    def number_of_bands(self) -> int:
-        """Number of bands in the model."""
-        raise NotImplementedError
-
-    @property
-    def hubbard_int_orbital_basis(self) -> npt.NDArray[np.float64]:
-        """
-        hubbard_int interaction split up in orbitals.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
+    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)
 
-        """
-        raise NotImplementedError
-
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:
-        """
-        Order parameter in orbital basis.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
+        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
+    @abstractmethod
+    def setup_lattice(self, parameters: GenericParameters) -> BaseLattice:  # pragma: no cover
+        """Set up lattice based on parameters."""
 
-    @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.
 
@@ -69,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.
 
@@ -91,7 +79,6 @@ class BaseHamiltonian(ABC):
             Derivative of Hamiltonian.
 
         """
-        raise NotImplementedError
 
     def save(self, filename: pathlib.Path) -> None:
         """
@@ -103,28 +90,23 @@ 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
+                if key != "lattice":
+                    f.attrs[key.strip("_")] = value
+            f.attrs["lattice_constant"] = self.lattice.lattice_constant
 
     @classmethod
-    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.
-
-        """
-        with h5py.File(f"{filename}", "r") as f:
+    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"][()]
 
-        return cls(**config_dict)
+        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]) -> npt.NDArray[np.complex64]:
         """
@@ -154,10 +136,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(self.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,7 +223,8 @@ 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],
     ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.complex64]]:
         """
         Diagonalize the BdG Hamiltonian.
@@ -258,7 +242,7 @@ class BaseHamiltonian(ABC):
             Diagonalising matrix of the BdG Hamiltonian.
 
         """
-        bdg_matrix = self.bdg_hamiltonian(k)
+        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)
@@ -275,13 +259,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],
     ) -> npt.NDArray[np.complex64]:
         """Gap equation.
 
         Parameters
         ----------
-        beta
         k
 
         Returns
@@ -291,28 +275,23 @@ class BaseHamiltonian(ABC):
 
 
         """
-        bdg_energies, bdg_wavefunctions = self.diagonalize_bdg(k)
-        bdg_energies_minus_k, _ = self.diagonalize_bdg(-k)
+        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[0]))
+        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(
@@ -358,27 +337,59 @@ 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],
+    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
         """Calculate the density of states.
 
         Parameters
         ----------
         k
-        energies
 
         Returns
         -------
         Density of states.
 
         """
-        density_of_states = np.zeros(shape=energies.shape, dtype=np.float64)
         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)
+
         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]) -> float:
+        """Calculate the spectral gap.
+
+        Parameters
+        ----------
+        k
+
+        Returns
+        -------
+        Spectral gap
+
+        """
+        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]
+
+        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]:
@@ -388,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