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

quant_met/mean_field/hamiltonians/dressed_graphene.py

@@ -28,30 +28,14 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
         if parameters.delta is not None:
             self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
 
-    def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:
-        """Set up lattice based on parameters."""
+    def setup_lattice(self, parameters: DressedGrapheneParameters) -> BaseLattice:  # noqa: D102
         return GrapheneLattice(lattice_constant=parameters.lattice_constant)
 
     @classmethod
-    def get_parameters_model(cls) -> type[DressedGrapheneParameters]:
-        """Return the specific parameters model for the subclass."""
+    def get_parameters_model(cls) -> type[DressedGrapheneParameters]:  # noqa: D102
         return DressedGrapheneParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        """
-        Return the normal state Hamiltonian in orbital basis.
-
-        Parameters
-        ----------
-        k : :class:`numpy.ndarray`
-            List of k points.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Hamiltonian in matrix form.
-
-        """
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
         assert _check_valid_array(k)
 
         t_gr = self.hopping_gr
@@ -88,25 +72,9 @@ class DressedGraphene(BaseHamiltonian[DressedGrapheneParameters]):
 
         return h.squeeze()
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
-        """
-        Deriative of the Hamiltonian.
-
-        Parameters
-        ----------
-        k: :class:`numpy.ndarray`
-            List of k points.
-        direction: str
-            Direction for derivative, either 'x' oder 'y'.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Derivative of Hamiltonian.
-
-        """
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 

quant_met/mean_field/hamiltonians/graphene.py

@@ -27,30 +27,14 @@ class Graphene(BaseHamiltonian[GrapheneParameters]):
         if parameters.delta is not None:
             self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
 
-    def setup_lattice(self, parameters: GrapheneParameters) -> GrapheneLattice:
-        """Set up lattice based on parameters."""
+    def setup_lattice(self, parameters: GrapheneParameters) -> GrapheneLattice:  # noqa: D102
         return GrapheneLattice(lattice_constant=parameters.lattice_constant)
 
     @classmethod
-    def get_parameters_model(cls) -> type[GrapheneParameters]:
-        """Return the specific parameters model for the subclass."""
+    def get_parameters_model(cls) -> type[GrapheneParameters]:  # noqa: D102
         return GrapheneParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        """
-        Return the normal state Hamiltonian in orbital basis.
-
-        Parameters
-        ----------
-        k : :class:`numpy.ndarray`
-            List of k points.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Hamiltonian in matrix form.
-
-        """
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -72,25 +56,9 @@ class Graphene(BaseHamiltonian[GrapheneParameters]):
 
         return h.squeeze()
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
-        """
-        Deriative of the Hamiltonian.
-
-        Parameters
-        ----------
-        k: :class:`numpy.ndarray`
-            List of k points.
-        direction: str
-            Direction for derivative, either 'x' oder 'y'.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Derivative of Hamiltonian.
-
-        """
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 

quant_met/mean_field/hamiltonians/one_band_tight_binding.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: MIT
 
-"""Provides the implementation for Graphene."""
+"""Provides the implementation for a one band tight binding model."""
 
 import numpy as np
 import numpy.typing as npt
@@ -15,7 +15,7 @@ from .base_hamiltonian import BaseHamiltonian
 
 
 class OneBand(BaseHamiltonian[OneBandParameters]):
-    """Hamiltonian for Graphene."""
+    """Hamiltonian for one band tight binding model."""
 
     def __init__(self, parameters: OneBandParameters) -> None:
         super().__init__(parameters)
@@ -24,30 +24,14 @@ class OneBand(BaseHamiltonian[OneBandParameters]):
         if parameters.delta is not None:
             self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
 
-    def setup_lattice(self, parameters: OneBandParameters) -> SquareLattice:
-        """Set up lattice based on parameters."""
+    def setup_lattice(self, parameters: OneBandParameters) -> SquareLattice:  # noqa: D102
         return SquareLattice(lattice_constant=parameters.lattice_constant)
 
     @classmethod
-    def get_parameters_model(cls) -> type[OneBandParameters]:
-        """Return the specific parameters model for the subclass."""
+    def get_parameters_model(cls) -> type[OneBandParameters]:  # noqa: D102
         return OneBandParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        """
-        Return the normal state Hamiltonian in orbital basis.
-
-        Parameters
-        ----------
-        k : :class:`numpy.ndarray`
-            List of k points.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Hamiltonian in matrix form.
-
-        """
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -64,25 +48,9 @@ class OneBand(BaseHamiltonian[OneBandParameters]):
 
         return h
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
-        """
-        Deriative of the Hamiltonian.
-
-        Parameters
-        ----------
-        k: :class:`numpy.ndarray`
-            List of k points.
-        direction: str
-            Direction for derivative, either 'x' oder 'y'.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Derivative of Hamiltonian.
-
-        """
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 

quant_met/mean_field/hamiltonians/three_band_tight_binding.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: MIT
 
-"""Provides the implementation for Graphene."""
+"""Provides the implementation for a three band tight binding model."""
 
 import numpy as np
 import numpy.typing as npt
@@ -24,30 +24,14 @@ class ThreeBand(BaseHamiltonian[ThreeBandParameters]):
         if parameters.delta is not None:
             self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
 
-    def setup_lattice(self, parameters: ThreeBandParameters) -> SquareLattice:
-        """Set up lattice based on parameters."""
+    def setup_lattice(self, parameters: ThreeBandParameters) -> SquareLattice:  # noqa: D102
         return SquareLattice(lattice_constant=parameters.lattice_constant)
 
     @classmethod
-    def get_parameters_model(cls) -> type[ThreeBandParameters]:
-        """Return the specific parameters model for the subclass."""
+    def get_parameters_model(cls) -> type[ThreeBandParameters]:  # noqa: D102
         return ThreeBandParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        """
-        Return the normal state Hamiltonian in orbital basis.
-
-        Parameters
-        ----------
-        k : :class:`numpy.ndarray`
-            List of k points.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Hamiltonian in matrix form.
-
-        """
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -75,25 +59,9 @@ class ThreeBand(BaseHamiltonian[ThreeBandParameters]):
 
         return h.squeeze()
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
-        """
-        Deriative of the Hamiltonian.
-
-        Parameters
-        ----------
-        k: :class:`numpy.ndarray`
-            List of k points.
-        direction: str
-            Direction for derivative, either 'x' oder 'y'.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Derivative of Hamiltonian.
-
-        """
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 

quant_met/mean_field/hamiltonians/two_band_tight_binding.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: MIT
 
-"""Provides the implementation for Graphene."""
+"""Provides the implementation for a two band tight binding model."""
 
 import numpy as np
 import numpy.typing as npt
@@ -24,30 +24,14 @@ class TwoBand(BaseHamiltonian[TwoBandParameters]):
         if parameters.delta is not None:
             self.delta_orbital_basis = np.astype(parameters.delta, np.complex64)
 
-    def setup_lattice(self, parameters: TwoBandParameters) -> SquareLattice:
-        """Set up lattice based on parameters."""
+    def setup_lattice(self, parameters: TwoBandParameters) -> SquareLattice:  # noqa: D102
         return SquareLattice(lattice_constant=parameters.lattice_constant)
 
     @classmethod
-    def get_parameters_model(cls) -> type[TwoBandParameters]:
-        """Return the specific parameters model for the subclass."""
+    def get_parameters_model(cls) -> type[TwoBandParameters]:  # noqa: D102
         return TwoBandParameters
 
-    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        """
-        Return the normal state Hamiltonian in orbital basis.
-
-        Parameters
-        ----------
-        k : :class:`numpy.ndarray`
-            List of k points.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Hamiltonian in matrix form.
-
-        """
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:  # noqa: D102
         assert _check_valid_array(k)
         hopping = self.hopping
         lattice_constant = self.lattice.lattice_constant
@@ -68,25 +52,9 @@ class TwoBand(BaseHamiltonian[TwoBandParameters]):
 
         return h.squeeze()
 
-    def hamiltonian_derivative(
+    def hamiltonian_derivative(  # noqa: D102
         self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
-        """
-        Deriative of the Hamiltonian.
-
-        Parameters
-        ----------
-        k: :class:`numpy.ndarray`
-            List of k points.
-        direction: str
-            Direction for derivative, either 'x' oder 'y'.
-
-        Returns
-        -------
-        :class:`numpy.ndarray`
-            Derivative of Hamiltonian.
-
-        """
         assert _check_valid_array(k)
         assert direction in ["x", "y"]
 

quant_met/mean_field/quantum_metric.py

@@ -14,21 +14,30 @@ from quant_met.parameters import GenericParameters
 def quantum_metric(
     h: BaseHamiltonian[GenericParameters], k_grid: npt.NDArray[np.float64], bands: list[int]
 ) -> npt.NDArray[np.float64]:
-    """Calculate the quantum metric in the normal state.
+    """Calculate the quantum metric (geometric tensor) for specified bands.
+
+    This function computes the quantum geometric tensor associated with
+    the specified bands of a given Hamiltonian over a grid of k-points.
+    The output is a 2x2 matrix representing the quantum metric.
 
     Parameters
     ----------
-    bands
-    h : :class:`~quant_met.BaseHamiltonian`
-        Hamiltonian object.
-    k_grid : :class:`numpy.ndarray`
-        List of k points.
+    h : BaseHamiltonian
+        Hamiltonian object used to compute Bloch states and their derivatives.
+    k_grid : numpy.ndarray
+        Array of k points in the Brillouin zone.
+    bands : list of int
+        Indices of the bands for which the quantum metric is to be calculated.
 
     Returns
     -------
     :class:`numpy.ndarray`
-        Quantum metric in the normal state.
+        A 2x2 matrix representing the quantum metric.
 
+    Raises
+    ------
+    ValueError
+        If `bands` contains invalid indices or `k_grid` is empty.
     """
     energies, bloch = h.diagonalize_nonint(k_grid)
 
@@ -58,52 +67,3 @@ def quantum_metric(
                         )
 
     return np.real(quantum_geom_tensor) / number_k_points
-
-
-def quantum_metric_bdg(
-    h: BaseHamiltonian[GenericParameters], k_grid: npt.NDArray[np.float64], bands: list[int]
-) -> npt.NDArray[np.float64]:
-    """Calculate the quantum metric in the BdG state.
-
-    Parameters
-    ----------
-    bands
-    h : :class:`~quant_met.BaseHamiltonian`
-        Hamiltonian object.
-    k_grid : :class:`numpy.ndarray`
-        List of k points.
-
-    Returns
-    -------
-    :class:`numpy.ndarray`
-        Quantum metric in the normal state.
-
-    """
-    energies, bdg_functions = h.diagonalize_bdg(k_grid)
-
-    number_k_points = len(k_grid)
-
-    quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex64)
-
-    for band in bands:
-        for i, direction_1 in enumerate(["x", "y"]):
-            h_derivative_dir_1 = h.bdg_hamiltonian_derivative(k=k_grid, direction=direction_1)
-            for j, direction_2 in enumerate(["x", "y"]):
-                h_derivative_dir_2 = h.bdg_hamiltonian_derivative(k=k_grid, direction=direction_2)
-                for k_index in range(len(k_grid)):
-                    for n in [i for i in range(2 * h.number_of_bands) if i != band]:
-                        quantum_geom_tensor[i, j] += (
-                            (
-                                bdg_functions[k_index][:, band].conjugate()
-                                @ h_derivative_dir_1[k_index]
-                                @ bdg_functions[k_index][:, n]
-                            )
-                            * (
-                                bdg_functions[k_index][:, n].conjugate()
-                                @ h_derivative_dir_2[k_index]
-                                @ bdg_functions[k_index][:, band]
-                            )
-                            / (energies[k_index][band] - energies[k_index][n]) ** 2
-                        )
-
-    return np.real(quantum_geom_tensor) / number_k_points

quant_met/mean_field/self_consistency.py

@@ -4,37 +4,80 @@
 
 """Self-consistency loop."""
 
+import logging
+
 import numpy as np
 import numpy.typing as npt
 
 from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
 from quant_met.parameters import GenericParameters
 
+logger = logging.getLogger(__name__)
+
 
 def self_consistency_loop(
     h: BaseHamiltonian[GenericParameters],
     k_space_grid: npt.NDArray[np.float64],
     epsilon: float,
 ) -> BaseHamiltonian[GenericParameters]:
-    """Self-consistency loop.
+    """Self-consistently solves the gap equation for a given Hamiltonian.
+
+    This function performs a self-consistency loop to solve the gap equation
+    for a Hamiltonian `h`.
+    The gaps in the orbital basis are iteratively updated until the change is within
+    a specified tolerance `epsilon`.
 
     Parameters
     ----------
-    k_space_grid
-    h
-    epsilon
+    h : :class:`BaseHamiltonian<quant_met.mean_field.hamiltonians.BaseHamiltonian>`
+        The Hamiltonian object with the parameters for the calculation.
+
+    k_space_grid : :class:`numpy.ndarray`
+        A grid of points in the Brillouin zone at which the gap equation is evaluated.
+        See
+
+    epsilon : float
+        The convergence criterion. The loop will terminate when the change
+        in the delta orbital basis is less than this value.
+
+    Returns
+    -------
+    :class:`quant_met.mean_field.BaseHamiltonian`
+        The updated Hamiltonian object with the new gaps.
+
+    Notes
+    -----
+    The function initializes the gaps with random complex numbers before entering the
+    self-consistency loop.
+    The mixing parameter is set to 0.2, which controls how much of the new gaps is taken
+    relative to the previous value in each iteration.
     """
+    logger.info("Starting self-consistency loop.")
+
     rng = np.random.default_rng()
     delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.complex64)
     delta_init += (0.2 * rng.random(size=h.delta_orbital_basis.shape) - 1) + 1.0j * (
         0.2 * rng.random(size=h.delta_orbital_basis.shape) - 1
     )
     h.delta_orbital_basis = delta_init
+    logger.debug("Initial gaps set to: %s", h.delta_orbital_basis)
 
+    iteration_count = 0
     while True:
+        iteration_count += 1
+        logger.debug("Iteration %d: Computing new gaps.", iteration_count)
+
         new_gap = h.gap_equation(k=k_space_grid)
-        if (np.abs(h.delta_orbital_basis - new_gap) < epsilon).all():
+
+        delta_change = np.abs(h.delta_orbital_basis - new_gap)
+        logger.debug("New gaps computed: %s", new_gap)
+
+        if (delta_change < epsilon).all():
             h.delta_orbital_basis = new_gap
+            logger.info("Convergence achieved after %d iterations.", iteration_count)
             return h
-        mixing_greed = 0.5
+
+        mixing_greed = 0.2
         h.delta_orbital_basis = mixing_greed * new_gap + (1 - mixing_greed) * h.delta_orbital_basis
+        logger.debug("Updated gaps: %s", h.delta_orbital_basis)
+        logger.debug("Change in gaps: %s", delta_change)

quant_met/parameters/__init__.py

@@ -3,16 +3,24 @@
 # SPDX-License-Identifier: MIT
 
 """
-Parameters (:mod:`quant_met.parameters`)
-========================================
+Parameter Classes
+=================
+
+Main class holding all the parameters for the calculation.
+
+- :class:`Parameters<quant_met.parameters.Parameters>`
+
+Classes holding the configuration for the Hamiltonians.
 
 .. autosummary::
    :toctree: generated/parameters/
 
+    Parameters  # noqa
     DressedGrapheneParameters
     GrapheneParameters
     OneBandParameters
-    Parameters
+    TwoBandParameters
+    ThreeBandParameters
 """  # noqa: D205, D400
 
 from .hamiltonians import (

quant_met/parameters/hamiltonians.py

@@ -34,10 +34,22 @@ def validate_float(value: float, info: ValidationInfo) -> float:
 
 
 class HamiltonianParameters(BaseModel):
-    """Base class for Hamiltonian parameters."""
+    """Base class for Hamiltonian parameters.
+
+    Attributes
+    ----------
+    name : str
+        The name of the Hamiltonian model (e.g., "Graphene", "DressedGraphene").
+    beta : float
+        The inverse temperature; default is set to infinity.
+    q : :class:`numpy.ndarray` | None
+        An optional numpy array representing the momentum of Cooper pairs.
+    hubbard_int_orbital_basis : :class:`numpy.ndarray`
+        A numpy array representing the Hubbard interactions in the orbital basis.
+    """
 
     name: str
-    beta: float | None = Field(default=None, description="Inverse temperature")
+    beta: float = Field(default=np.inf, description="Inverse temperature")
     q: NDArray[Shape["2"], int | float] | None = Field(
         default=None, description="Momentum of Cooper pairs"
     )
@@ -47,7 +59,25 @@ class HamiltonianParameters(BaseModel):
 
 
 class DressedGrapheneParameters(HamiltonianParameters):
-    """Parameters for the dressed Graphene model."""
+    """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.float64]
+        Hubbard interaction in the orbital basis.
+    delta : npt.NDArray[np.complex64] | None
+        Initial value for gaps in orbital space.
+    """
 
     name: Literal["DressedGraphene"] = "DressedGraphene"
     hopping_gr: float = Field(..., description="Hopping in graphene")

quant_met/parameters/main.py

@@ -12,7 +12,20 @@ from .hamiltonians import DressedGrapheneParameters, GrapheneParameters, OneBand
 
 
 class Control(BaseModel):
-    """Control for the calculation."""
+    """Control for the calculation.
+
+    Attributes
+    ----------
+    calculation : str
+        Specifies the type of calculation to be performed.
+    prefix : str
+        A string used as a prefix for naming output files generated by the simulation.
+    outdir : :class:`pathlib.Path`
+        A path indicating the output directory where results will be saved.
+    conv_treshold : float
+        A float value representing the convergence threshold.
+        The calculation will stop when changes in the results drop below this threshold.
+    """
 
     calculation: str
     prefix: str
@@ -21,14 +34,33 @@ class Control(BaseModel):
 
 
 class KPoints(BaseModel):
-    """Control for k points."""
+    """Control for k points.
+
+    Attributes
+    ----------
+    nk1 : int
+        The number of k-points in the first dimension of the k-space grid.
+    nk2 : int
+        The number of k-points in the second dimension of the k-space grid.
+    """
 
     nk1: int
     nk2: int
 
 
 class Parameters(BaseModel):
-    """Class to hold the parameters for a calculation."""
+    """Class to hold the parameters for a calculation.
+
+    Attributes
+    ----------
+    control : Control
+        An instance of the `Control` class containing settings for the calculation.
+    model :
+        An instance of one of the Hamiltonian parameter classes, holding the specific parameters
+        of the selected Hamiltonian model.
+    k_points : KPoints
+        An instance of the `KPoints` class that specifies the number of k-points for the simulation.
+    """
 
     control: Control
     model: DressedGrapheneParameters | GrapheneParameters | OneBandParameters = Field(

quant_met/plotting/__init__.py

@@ -18,13 +18,11 @@ Functions
     scatter_into_bz
     plot_bandstructure
     plot_superfluid_weight
-    plot_quantum_metric
 """  # noqa: D205, D400
 
 from .plotting import (
     format_plot,
     plot_bandstructure,
-    plot_quantum_metric,
     plot_superfluid_weight,
     scatter_into_bz,
 )
@@ -34,5 +32,4 @@ __all__ = [
     "format_plot",
     "plot_bandstructure",
     "plot_superfluid_weight",
-    "plot_quantum_metric",
 ]