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

quant_met/cli/__init__.py

@@ -3,11 +3,8 @@
 # SPDX-License-Identifier: MIT
 
 """
-Command-Line-Interface (:mod:`quant_met.cli`)
-=============================================
-
-Functions
----------
+Command-Line-Interface
+======================
 
 .. autosummary::
     :toctree: generated/

quant_met/cli/main.py

@@ -4,6 +4,7 @@
 
 """Command line interface."""
 
+import logging
 import sys
 from typing import TextIO
 
@@ -14,21 +15,47 @@ from quant_met.parameters import Parameters
 
 from .scf import scf
 
+logger = logging.getLogger(__name__)
+
 
 @click.command()
 @click.argument("input-file", type=click.File("r"))
-def cli(input_file: TextIO) -> None:
+@click.option("--debug", is_flag=True, help="Enable debug logging.")
+def cli(input_file: TextIO, *, debug: bool) -> None:
     """Command line interface for quant-met.
 
     Parameters
     ----------
-    input_file
+    input_file: TextIO
+        A file object containing YAML formatted parameters for the simulation.
+    debug : bool
+        If set, enables debug logging instead of the default info logging.
+
+    This command reads the parameters from the specified file and runs the
+    desired calculation based on the provided parameters.
     """
+    if debug:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            stream=sys.stdout,
+        )
+        logger.setLevel(logging.DEBUG)
+        logger.info("Debug logging is enabled.")
+    else:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+            stream=sys.stdout,
+        )
+
     params = Parameters(**yaml.safe_load(input_file))
+    logger.info("Loaded parameters successfully.")
 
     match params.control.calculation:
         case "scf":
+            logger.info("Starting SCF calculation.")
             scf(params)
         case _:
-            print(f"Calculation {params.control.calculation} not found.")
+            logger.error("Calculation %s not found.", params.control.calculation)
             sys.exit(1)

quant_met/cli/scf.py

@@ -4,39 +4,69 @@
 
 """Functions to run self-consistent calculation for the order parameter."""
 
+import logging
 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
+
+logger = logging.getLogger(__name__)
+
 
+def _hamiltonian_factory(
+    classname: str, parameters: HamiltonianParameters
+) -> BaseHamiltonian[HamiltonianParameters]:
+    """Create a Hamiltonian by its class name.
 
-def _hamiltonian_factory(classname: str, parameters: BaseModel) -> BaseHamiltonian:
-    """Create a hamiltonian by its class name."""
+    Parameters
+    ----------
+    classname: str
+        The name of the Hamiltonian class to instantiate.
+    parameters: HamiltonianParameters
+        An instance of HamiltonianParameters containing all necessary
+        configuration for the specific Hamiltonian.
+
+    Returns
+    -------
+    BaseHamiltonian[HamiltonianParameters]
+        An instance of the specified Hamiltonian class.
+    """
     from quant_met.mean_field import hamiltonians
 
     cls = getattr(hamiltonians, classname)
-    h: BaseHamiltonian = cls(parameters)
+    h: BaseHamiltonian[HamiltonianParameters] = cls(parameters)
     return h
 
 
 def scf(parameters: Parameters) -> None:
-    """Self-consistent calculation for the order parameter."""
+    """Self-consistent calculation for the order parameter.
+
+    Parameters
+    ----------
+    parameters: Parameters
+        An instance of Parameters containing control settings, the model,
+        and k-point specifications for the self-consistency calculation.
+    """
     result_path = Path(parameters.control.outdir)
     result_path.mkdir(exist_ok=True, parents=True)
+
+    logger.info("Initializing Hamiltonian factory.")
     h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
+
+    logger.info("Starting self-consistency loop.")
     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)
+
+    logger.info("Self-consistency loop completed successfully.")
+    logger.debug("Obtained delta values: %s", solved_h.delta_orbital_basis)
+
     result_file = result_path / f"{parameters.control.prefix}.hdf5"
     solved_h.save(filename=result_file)
+    logger.info("Results saved to %s", result_file)

quant_met/geometry/__init__.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: MIT
 
 """
-Geometry (:mod:`quant_met.geometry`)
+Geometry
 ========
 
 .. currentmodule:: quant_met.geometry

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

@@ -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/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

@@ -3,8 +3,8 @@
 # SPDX-License-Identifier: MIT
 
 """
-Mean field treatment (:mod:`quant_met.mean_field`)
-==================================================
+Mean field
+==========
 
 Submodules
 ----------
@@ -23,20 +23,18 @@ Functions
 
    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 .quantum_metric import quantum_metric
 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/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

@@ -3,8 +3,8 @@
 # SPDX-License-Identifier: MIT
 
 """
-Hamiltonians (:mod:`quant_met.mean_field.hamiltonians`)
-=======================================================
+hamiltonians
+============
 
 Base
 
@@ -19,16 +19,15 @@ Base
     Graphene
     DressedGraphene
     OneBand
+    TwoBand
+    ThreeBand
 """  # 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",
-]
+__all__ = ["BaseHamiltonian", "Graphene", "DressedGraphene", "OneBand", "TwoBand", "ThreeBand"]