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

quant_met/mean_field/quantum_metric.py

@@ -8,26 +8,36 @@ 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
 
 
 def quantum_metric(
-    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], bands: list[int]
+    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)
 
@@ -57,52 +67,3 @@ def quantum_metric(
                         )
 
     return np.real(quantum_geom_tensor) / number_k_points
-
-
-def quantum_metric_bdg(
-    h: BaseHamiltonian, 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,46 +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,
+    h: BaseHamiltonian[GenericParameters],
     k_space_grid: npt.NDArray[np.float64],
-    beta: np.float64,
     epsilon: float,
-    q: npt.NDArray[np.float64] | None = None,
-) -> BaseHamiltonian:
-    """Self-consistency loop.
+) -> BaseHamiltonian[GenericParameters]:
+    """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
     ----------
-    lattice
-    q
-    beta
-    number_of_k_points
-    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.
     """
-    if q is None:
-        q = np.array([0, 0])
+    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 += (
-        2 * rng.random(size=h.delta_orbital_basis.shape)
-        - 1
-        + 1.0j * (2 * rng.random(size=h.delta_orbital_basis.shape) - 1)
+    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:
-        new_gap = h.gap_equation(k=k_space_grid, q=q, beta=beta)
-        if (np.abs(h.delta_orbital_basis - new_gap) < epsilon).all():
+        iteration_count += 1
+        logger.debug("Iteration %d: Computing new gaps.", iteration_count)
+
+        new_gap = h.gap_equation(k=k_space_grid)
+
+        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.1
+
+        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

@@ -8,10 +8,11 @@ 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
 
 
 def superfluid_weight(
-    h: BaseHamiltonian,
+    h: BaseHamiltonian[GenericParameters],
     k_grid: npt.NDArray[np.float64],
 ) -> tuple[npt.NDArray[np.complex64], npt.NDArray[np.complex64]]:
     """Calculate the superfluid weight.
@@ -54,7 +55,7 @@ def superfluid_weight(
 
 
 def _current_operator(
-    h: BaseHamiltonian, direction: str, k: npt.NDArray[np.float64]
+    h: BaseHamiltonian[GenericParameters], direction: str, k: npt.NDArray[np.float64]
 ) -> npt.NDArray[np.complex64]:
     j = np.zeros(shape=(h.number_of_bands, h.number_of_bands), dtype=np.complex64)
 
@@ -71,7 +72,9 @@ def _current_operator(
     return j
 
 
-def _c_factor(h: BaseHamiltonian, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+def _c_factor(
+    h: BaseHamiltonian[GenericParameters], k: npt.NDArray[np.float64]
+) -> npt.NDArray[np.complex64]:
     bdg_energies, bdg_functions = h.diagonalize_bdg(k)
     c_mnpq = np.zeros(
         shape=(

quant_met/parameters/__init__.py

@@ -3,19 +3,42 @@
 # 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 DressedGrapheneParameters, GrapheneParameters, OneBandParameters
+from .hamiltonians import (
+    DressedGrapheneParameters,
+    GenericParameters,
+    GrapheneParameters,
+    OneBandParameters,
+    ThreeBandParameters,
+    TwoBandParameters,
+)
 from .main import Parameters
 
-__all__ = ["Parameters", "DressedGrapheneParameters", "GrapheneParameters", "OneBandParameters"]
+__all__ = [
+    "Parameters",
+    "DressedGrapheneParameters",
+    "GrapheneParameters",
+    "OneBandParameters",
+    "TwoBandParameters",
+    "ThreeBandParameters",
+    "GenericParameters",
+]

quant_met/parameters/hamiltonians.py

@@ -4,44 +4,174 @@
 
 """Pydantic models to hold parameters for Hamiltonians."""
 
-from typing import Literal
+from typing import Literal, TypeVar
 
 import numpy as np
 from numpydantic import NDArray, Shape
-from pydantic import BaseModel
+from pydantic import BaseModel, Field, field_validator
+from pydantic_core.core_schema import ValidationInfo
 
+GenericParameters = TypeVar("GenericParameters", bound="HamiltonianParameters")
 
-class DressedGrapheneParameters(BaseModel):
-    """Parameters for the dressed Graphene model."""
+
+def check_positive_values(value: float, info: ValidationInfo) -> float:
+    """Check for positive values."""
+    if value < 0:
+        msg = f"{info.field_name} must be positive"
+        raise ValueError(msg)
+    return value
+
+
+def validate_float(value: float, info: ValidationInfo) -> float:
+    """Check for valid floats."""
+    if np.isinf(value):
+        msg = f"{info.field_name} must not be Infinity"
+        raise ValueError(msg)
+    if np.isnan(value):
+        msg = f"{info.field_name} must not be NaN"
+        raise ValueError(msg)
+    return value
+
+
+class HamiltonianParameters(BaseModel):
+    """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 = Field(default=np.inf, description="Inverse temperature")
+    q: NDArray[Shape["2"], int | float] | None = Field(
+        default=None, description="Momentum of Cooper pairs"
+    )
+    hubbard_int_orbital_basis: NDArray = Field(
+        ..., description="Hubbard interaction in orbital basis"
+    )
+
+
+class DressedGrapheneParameters(HamiltonianParameters):
+    """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
-    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
+    hopping_gr: float = Field(..., description="Hopping in graphene")
+    hopping_x: float = Field(..., description="Hopping in impurity")
+    hopping_x_gr_a: float = Field(..., description="Hybridization")
+    lattice_constant: float = Field(..., description="Lattice constant")
+    chemical_potential: float = Field(..., description="Chemical potential")
+    hubbard_int_orbital_basis: NDArray[Shape["3"], np.float64] = Field(
+        ..., description="Hubbard interaction in orbital basis"
+    )
+    delta: NDArray[Shape["3"], np.complex64] | None = Field(
+        default=None, description="Initial value for gaps in orbital space"
+    )
+
+    _check_positive_values = field_validator(
+        "hopping_gr", "hopping_x", "hopping_x_gr_a", "lattice_constant"
+    )(check_positive_values)
+
+    _check_valid_floats = field_validator(
+        "hopping_gr", "hopping_x", "hopping_x_gr_a", "lattice_constant", "chemical_potential"
+    )(validate_float)
 
 
-class GrapheneParameters(BaseModel):
+class GrapheneParameters(HamiltonianParameters):
     """Parameters for Graphene model."""
 
     name: Literal["Graphene"] = "Graphene"
     hopping: float
     lattice_constant: float
     chemical_potential: float
-    hubbard_int: float
+    hubbard_int_orbital_basis: NDArray[Shape["2"], np.float64] = Field(
+        ..., description="Hubbard interaction in orbital basis"
+    )
     delta: NDArray[Shape["2"], np.complex64] | None = None
 
+    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
 
-class OneBandParameters(BaseModel):
+    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
+        validate_float
+    )
+
+
+class OneBandParameters(HamiltonianParameters):
     """Parameters for Graphene model."""
 
     name: Literal["OneBand"] = "OneBand"
     hopping: float
     lattice_constant: float
     chemical_potential: float
-    hubbard_int: float
+    hubbard_int_orbital_basis: NDArray[Shape["1"], np.float64] = Field(
+        ..., description="Hubbard interaction in orbital basis"
+    )
     delta: NDArray[Shape["1"], np.complex64] | None = None
+
+    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
+
+    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
+        validate_float
+    )
+
+
+class TwoBandParameters(HamiltonianParameters):
+    """Parameters for Graphene model."""
+
+    name: Literal["TwoBand"] = "TwoBand"
+    hopping: float
+    lattice_constant: float
+    chemical_potential: float
+    hubbard_int_orbital_basis: NDArray[Shape["2"], np.float64] = Field(
+        ..., description="Hubbard interaction in orbital basis"
+    )
+    delta: NDArray[Shape["2"], np.complex64] | None = None
+
+    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
+
+    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
+        validate_float
+    )
+
+
+class ThreeBandParameters(HamiltonianParameters):
+    """Parameters for Graphene model."""
+
+    name: Literal["ThreeBand"] = "ThreeBand"
+    hopping: float
+    lattice_constant: float
+    chemical_potential: float
+    hubbard_int_orbital_basis: NDArray[Shape["3"], np.float64] = Field(
+        ..., description="Hubbard interaction in orbital basis"
+    )
+    delta: NDArray[Shape["3"], np.complex64] | None = None
+
+    _check_positive_values = field_validator("hopping", "lattice_constant")(check_positive_values)
+
+    _check_valid_floats = field_validator("hopping", "lattice_constant", "chemical_potential")(
+        validate_float
+    )

quant_met/parameters/main.py

@@ -6,32 +6,61 @@
 
 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."""
+    """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
     outdir: pathlib.Path
     conv_treshold: float
-    beta: float
-    q: NDArray[Shape["2"], int | float] | None = None
 
 
 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",
 ]

quant_met/plotting/plotting.py

@@ -212,37 +212,3 @@ def plot_superfluid_weight(
     ax.set_ylabel(r"$D_S\ [t]$")
 
     return fig
-
-
-def plot_quantum_metric(
-    x_data: npt.NDArray[np.float64],
-    quantum_metric: npt.NDArray[np.float64],
-    fig_in: matplotlib.figure.Figure | None = None,
-    ax_in: matplotlib.axes.Axes | None = None,
-) -> matplotlib.figure.Figure:
-    """Plot quantum metric against some parameter.
-
-    Parameters
-    ----------
-    x_data : :class:`numpy.ndarray`
-    quantum_metric : :class:`numpy.ndarray`
-    fig_in : :class:`matplotlib.figure.Figure`, optional
-    ax_in : :class:`matplotlib.axes.Axes`, optional
-
-    Returns
-    -------
-    :obj:`matplotlib.figure.Figure`
-        Figure with the data plotted onto the axis.
-
-    """
-    if fig_in is None or ax_in is None:
-        fig, ax = plt.subplots()
-    else:
-        fig, ax = fig_in, ax_in
-
-    ax.plot(x_data, quantum_metric, "x--")
-
-    ax = format_plot(ax)
-    ax.set_ylabel(r"$M\ [t]$")
-
-    return fig

{quant_met-0.0.8.dist-info → quant_met-0.0.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.8
+Version: 0.0.10
 Summary: Calculate superconductivity in flat-band systems.
 Home-page: https://quant-met.tjarksievers.de
 Author: Tjark Sievers

quant_met-0.0.10.dist-info/RECORD

@@ -0,0 +1,33 @@
+quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
+quant_met/cli/__init__.py,sha256=nGFXhK8zWyEKQtsQTyJWfEOLFOHTCjZnfEcrVb2dARc,254
+quant_met/cli/main.py,sha256=VyOu4FhpDR_CsSDaFcY4FlYrRxnRRCBFpwhLLB2GP2Y,1729
+quant_met/cli/scf.py,sha256=8Ph13lcJcRg5vhqT4Ugf0HJ9FSt6huK0oS4SvTPgnVw,2355
+quant_met/geometry/__init__.py,sha256=5BLliTnMzlzPrjzmphQ_EpTE6f6dF-uXgQU_Qj8sBoI,592
+quant_met/geometry/base_lattice.py,sha256=dUBk3167cppy5nUNSEbXq57rwgbVnIen20jC_vrhomA,2642
+quant_met/geometry/bz_path.py,sha256=q_eNhKYjhKLeFNjio8BdKVsseO6slQKlwKKSQQYTVJQ,2497
+quant_met/geometry/graphene.py,sha256=AIKI2ice7LiKk5LHS27w97FkUds0UFV7EVNML3W5D28,1623
+quant_met/geometry/square.py,sha256=lAEJ2R_2VBBPI_Bc-x-KhPE5r8AGoY1RgAx8GdoqdNY,1561
+quant_met/mean_field/__init__.py,sha256=JgF26LUDI6LqOZdws6uZnilqdrEhj_3ysq-zElsL4DU,645
+quant_met/mean_field/_utils.py,sha256=7hr0DDSdIqjft5Jjluvbw_HGoNLWgYJTxyuPJJvhBnc,356
+quant_met/mean_field/hamiltonians/__init__.py,sha256=kLe31GiWYvPshl2-tpjEz0AHct2S1AuwRakAK2XDNSg,681
+quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=_GZLmNAcRAu6NGCM8PnwacPV9AlOxrGLo0vdgrcoBvM,18295
+quant_met/mean_field/hamiltonians/dressed_graphene.py,sha256=sTApzorTj0jeXdEzeDxNUxuvSWq44UtVPwDzRawbvXs,4035
+quant_met/mean_field/hamiltonians/graphene.py,sha256=tnmaaBka3G_vAMrg8ZsVcNGYjPPMPB3Z3NQfTbGRJNM,3263
+quant_met/mean_field/hamiltonians/one_band_tight_binding.py,sha256=SXHPoVd_zyevNvUvmHuK85cfs2Y-_8phBbE7qM62RIE,2499
+quant_met/mean_field/hamiltonians/three_band_tight_binding.py,sha256=MuOxUTPPBENjKBotPVQH-8343y4dv73jtZXo-w8mJsA,3282
+quant_met/mean_field/hamiltonians/two_band_tight_binding.py,sha256=Vk01wY1UP4V1yYHZ9RmlbB0cybPJjGlrBUkR8d3o3j8,2852
+quant_met/mean_field/quantum_metric.py,sha256=jjttOnLKR18oqX5yweHdgn17nfJCFbp932lq3yRh1pE,2615
+quant_met/mean_field/self_consistency.py,sha256=MNPDopLcPs8v77AQCJot54SIWVazqaMxVIc4w4JgS6w,2906
+quant_met/mean_field/superfluid_weight.py,sha256=c7fNcq7JQQBpKt0R5JjkGlO-pAoznblPkA__5rNCyVw,4118
+quant_met/parameters/__init__.py,sha256=Pt2iI2y0donTs3IMVo30pQdMFChSciqxhwD_Gs-zysQ,917
+quant_met/parameters/hamiltonians.py,sha256=c-POY9q38CBMzEnlUzkx17uH4lGnFa8dbX4h-QOiS08,6115
+quant_met/parameters/main.py,sha256=acLuOLn5KD9_h5cbnd5H3akkF9XwcwAhLqV7jYJh0OA,1932
+quant_met/plotting/__init__.py,sha256=HEt2KKhUOR1he2cKL9GLfGfqN87Q6jl_AKylGC20U4g,544
+quant_met/plotting/plotting.py,sha256=ueFKhGK2mo-_JKifhRlgT6WDuEbKSMwDaTNnl70tCZQ,6583
+quant_met/utils.py,sha256=JG_tShSL1JIi-Fn-N6mVD6J0sl7Egf-zuHnOSEKu7VA,1666
+quant_met-0.0.10.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.10.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.10.dist-info/METADATA,sha256=xSLhNGqt2f7KGpg-Yj74M_h6QpFYr3PDbv0YFwNt798,2954
+quant_met-0.0.10.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quant_met-0.0.10.dist-info/entry_points.txt,sha256=fuVnEk5wiqPMEhn-Cc7q0Hdk2s_OniOn0zfdFPicH4Y,47
+quant_met-0.0.10.dist-info/RECORD,,

quant_met-0.0.8.dist-info/RECORD

@@ -1,31 +0,0 @@
-quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
-quant_met/cli/__init__.py,sha256=If5Jdi7mG-5PbIyjQGxnt9o2bsY5VyE3qtdcO5yTGnQ,321
-quant_met/cli/main.py,sha256=EZTRRTfrN3z-srgbG2BoDg64iYBjzZLuuMtrxTdZU8s,698
-quant_met/cli/scf.py,sha256=x9qxjQizXAKH7217dBuHTlA26eGenzcC2LDpN1q7030,1435
-quant_met/geometry/__init__.py,sha256=uCLEDBrYuMUkEgJmPnLAvR2WlmvoM9X9_cV_Q2zMzoA,620
-quant_met/geometry/base_lattice.py,sha256=QVHuZVy6bOvBSITY_mKhr7hYW1jHJ5UAm3sMCFClYZ0,2276
-quant_met/geometry/bz_path.py,sha256=q_eNhKYjhKLeFNjio8BdKVsseO6slQKlwKKSQQYTVJQ,2497
-quant_met/geometry/graphene.py,sha256=86C1LiYFunoSGSS1_A79dPq24FiiOxpHvOLUVrdRq_E,1271
-quant_met/geometry/square.py,sha256=1fSrHab07uB6ildNzlbTwINJvPa5C2Az0B0uuOVJmMc,1216
-quant_met/mean_field/__init__.py,sha256=yH_UovKDaP5c06cb1uWPtvIO2WQ76pi6ZTsNBzE8oso,793
-quant_met/mean_field/_utils.py,sha256=plkx6eYjyYV3CT3BWwlulqW7L-Q0t1TzZTLR4k7u0dg,666
-quant_met/mean_field/hamiltonians/__init__.py,sha256=FcqhV5fG_gzngVuiVfBucripdbNTzOxPRafu7sZ4ueA,644
-quant_met/mean_field/hamiltonians/base_hamiltonian.py,sha256=fL1dl1ZX3I_4gzARiQl5o2eCTIr-udRA23qZo4VWq0k,13622
-quant_met/mean_field/hamiltonians/dressed_graphene.py,sha256=zzHRVmp8749I2ll5N-wjks8l5dJLdtmhWR7smR7ezM0,6542
-quant_met/mean_field/hamiltonians/graphene.py,sha256=Zg_S9xTMYi_7v_6PBK7NUdiwgmyqyCPElUfezuiozm0,5611
-quant_met/mean_field/hamiltonians/one_band_tight_binding.py,sha256=kBYqthKUPby754PhOwf0mzHLTHNVbdKZbtJhvp2yc3E,4766
-quant_met/mean_field/quantum_metric.py,sha256=5FC3NU_ObbHlUUZMCAP1DyZuyifgnEr3s2cSH6cA8-8,3903
-quant_met/mean_field/self_consistency.py,sha256=xkZIWkOopekhDufJnSGK6ARsro6XaIuVhhrnJmb6sk8,1291
-quant_met/mean_field/superfluid_weight.py,sha256=m_x2uVYcEVdbItwEV3-Ml80Qad7X-YWLgb38fJKLJsY,4004
-quant_met/parameters/__init__.py,sha256=DvzEtTAnHcRcJufZV7bwYGZUeA-0Q2B8N9syGA9uNRM,552
-quant_met/parameters/hamiltonians.py,sha256=Q5uGTzxM8kIdUnRuIpEJNPmSHF27Zj7LBV3kgKd5dP4,1213
-quant_met/parameters/main.py,sha256=yrDME_KfDZ_9xf3ofTt7V8kw_8qbgD9EfVlxLcymcNE,899
-quant_met/plotting/__init__.py,sha256=s-DS22impzozKiS7p-v3yCmeccDQfXmBbtPiYMKwH0Y,620
-quant_met/plotting/plotting.py,sha256=_SqL8GrDqlBtccHnUWpZPqdSJy0Yd_4dhFdUOxOzPpY,7447
-quant_met/utils.py,sha256=JG_tShSL1JIi-Fn-N6mVD6J0sl7Egf-zuHnOSEKu7VA,1666
-quant_met-0.0.8.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.8.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.8.dist-info/METADATA,sha256=vh99nVcyAhUECV32kkXxfDjne2LvBufs6ekW60m8pYs,2953
-quant_met-0.0.8.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quant_met-0.0.8.dist-info/entry_points.txt,sha256=fuVnEk5wiqPMEhn-Cc7q0Hdk2s_OniOn0zfdFPicH4Y,47
-quant_met-0.0.8.dist-info/RECORD,,