quant-met 0.0.9__py3-none-any.whl → 0.0.11__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

@@ -12,36 +12,45 @@ from quant_met.parameters import GenericParameters
 
 
 def quantum_metric(
-    h: BaseHamiltonian[GenericParameters], k_grid: npt.NDArray[np.float64], bands: list[int]
+    h: BaseHamiltonian[GenericParameters], k: 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 : 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)
+    energies, bloch = h.diagonalize_nonint(k)
 
-    number_k_points = len(k_grid)
+    number_k_points = len(k)
 
     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_direction_1 = h.hamiltonian_derivative(k=k_grid, direction=direction_1)
+            h_derivative_direction_1 = h.hamiltonian_derivative(k=k, direction=direction_1)
             for j, direction_2 in enumerate(["x", "y"]):
-                h_derivative_direction_2 = h.hamiltonian_derivative(k=k_grid, direction=direction_2)
-                for k_index in range(len(k_grid)):
+                h_derivative_direction_2 = h.hamiltonian_derivative(k=k, direction=direction_2)
+                for k_index in range(len(k)):
                     for n in [i for i in range(h.number_of_bands) if i != band]:
                         quantum_geom_tensor[i, j] += (
                             (
@@ -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,91 @@
 
 """Self-consistency loop."""
 
+import logging
+import sys
+
 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,
+    max_iter: int = 1000,
 ) -> 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.
+
+    max_iter : int
+        Maximal number of iterations, default 300.
+
+    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
+        if iteration_count > max_iter:
+            sys.exit("Maximum number of iterations reached.")
+
+        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():
+
+        if not np.allclose(h.delta_orbital_basis, 0):
+            delta_change = np.abs(h.delta_orbital_basis - new_gap) / np.abs(h.delta_orbital_basis)
+        else:
+            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/mean_field/superfluid_weight.py

@@ -13,7 +13,7 @@ from quant_met.parameters import GenericParameters
 
 def superfluid_weight(
     h: BaseHamiltonian[GenericParameters],
-    k_grid: npt.NDArray[np.float64],
+    k: npt.NDArray[np.float64],
 ) -> tuple[npt.NDArray[np.complex64], npt.NDArray[np.complex64]]:
     """Calculate the superfluid weight.
 
@@ -21,7 +21,7 @@ def superfluid_weight(
     ----------
     h : :class:`~quant_met.mean_field.Hamiltonian`
         Hamiltonian.
-    k_grid : :class:`numpy.ndarray`
+    k : :class:`numpy.ndarray`
         List of k points.
 
     Returns
@@ -37,10 +37,10 @@ def superfluid_weight(
 
     for i, direction_1 in enumerate(["x", "y"]):
         for j, direction_2 in enumerate(["x", "y"]):
-            for k in k_grid:
-                c_mnpq = _c_factor(h, k)
-                j_up = _current_operator(h, direction_1, k)
-                j_down = _current_operator(h, direction_2, -k)
+            for k_point in k:
+                c_mnpq = _c_factor(h, k_point)
+                j_up = _current_operator(h, direction_1, k_point)
+                j_down = _current_operator(h, direction_2, -k_point)
                 for m in range(h.number_of_bands):
                     for n in range(h.number_of_bands):
                         for p in range(h.number_of_bands):

quant_met/parameters/__init__.py

@@ -3,30 +3,42 @@
 # SPDX-License-Identifier: MIT
 
 """
-Parameters (:mod:`quant_met.parameters`)
-========================================
+Parameter Classes
+=================
+
+Main class holding all the parameters for the calculation.
+
+Classes holding the configuration for the Hamiltonians.
+
+.. autosummary::
+    :toctree: generated/parameters/hamiltonians
+
+    hamiltonians
 
 .. autosummary::
    :toctree: generated/parameters/
 
-    DressedGrapheneParameters
-    GrapheneParameters
-    OneBandParameters
-    Parameters
+    Parameters  # noqa
+    Control  # noqa
+    KPoints  # noqa
 """  # noqa: D205, D400
 
 from .hamiltonians import (
     DressedGrapheneParameters,
     GenericParameters,
     GrapheneParameters,
+    HamiltonianParameters,
     OneBandParameters,
     ThreeBandParameters,
     TwoBandParameters,
 )
-from .main import Parameters
+from .main import Control, KPoints, Parameters
 
 __all__ = [
     "Parameters",
+    "Control",
+    "KPoints",
+    "HamiltonianParameters",
     "DressedGrapheneParameters",
     "GrapheneParameters",
     "OneBandParameters",