quant-met 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

quant_met/cli/_utils.py

@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+from quant_met.mean_field.hamiltonians import BaseHamiltonian
+from quant_met.parameters import HamiltonianParameters
+
+
+def _hamiltonian_factory(
+    classname: str, parameters: HamiltonianParameters
+) -> BaseHamiltonian[HamiltonianParameters]:
+    """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[HamiltonianParameters] = cls(parameters)
+    return h

quant_met/cli/crit_temp.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to run self-consistent calculation for the order parameter."""
+
+import logging
+from pathlib import Path
+
+import h5py
+
+from quant_met import mean_field
+from quant_met.parameters import Parameters
+
+from ._utils import _hamiltonian_factory
+
+logger = logging.getLogger(__name__)
+
+
+def crit_temp(parameters: Parameters) -> None:
+    """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 T_C calculation.
+    """
+    result_path = Path(parameters.control.outdir)
+    result_path.mkdir(exist_ok=True, parents=True)
+
+    h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
+
+    delta_vs_temp, critical_temperatures, fit_fig = mean_field.search_crit_temp(
+        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,
+        max_iter=parameters.control.max_iter,
+        n_temp_points=parameters.control.n_temp_points,
+    )
+
+    logger.info("Search for T_C completed successfully.")
+    logger.info("Obtained T_Cs: %s", critical_temperatures)
+
+    fit_fig.savefig(
+        result_path / f"{parameters.control.prefix}_critical_temperatures_fit.pdf",
+        bbox_inches="tight",
+    )
+
+    result_file = result_path / f"{parameters.control.prefix}_critical_temperatures.hdf5"
+    delta_vs_temp.to_hdf(result_file, key="delta_vs_temp")
+    with h5py.File(result_file, mode="a") as file:
+        for orbital, crit_temp_orbital in enumerate(critical_temperatures):
+            file.attrs[f"T_C_{orbital}"] = crit_temp_orbital
+    hamiltonian_file = result_path / f"{parameters.control.prefix}_sample_hamiltonian.hdf5"
+    h.save(hamiltonian_file)
+
+    logger.info("Results saved to %s", result_file)

quant_met/cli/main.py

@@ -13,6 +13,7 @@ import yaml
 
 from quant_met.parameters import Parameters
 
+from .crit_temp import crit_temp
 from .scf import scf
 
 logger = logging.getLogger(__name__)
@@ -56,6 +57,9 @@ def cli(input_file: TextIO, *, debug: bool) -> None:
         case "scf":
             logger.info("Starting SCF calculation.")
             scf(params)
+        case "crit-temp":
+            logger.info("Starting T_C calculation.")
+            crit_temp(params)
         case _:
             logger.error("Calculation %s not found.", params.control.calculation)
             sys.exit(1)

quant_met/cli/scf.py

@@ -8,35 +8,11 @@ import logging
 from pathlib import Path
 
 from quant_met import mean_field
-from quant_met.mean_field.hamiltonians import BaseHamiltonian
-from quant_met.parameters import HamiltonianParameters, Parameters
+from quant_met.parameters import Parameters
 
-logger = logging.getLogger(__name__)
-
-
-def _hamiltonian_factory(
-    classname: str, parameters: HamiltonianParameters
-) -> BaseHamiltonian[HamiltonianParameters]:
-    """Create a Hamiltonian by its class name.
+from ._utils import _hamiltonian_factory
 
-    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[HamiltonianParameters] = cls(parameters)
-    return h
+logger = logging.getLogger(__name__)
 
 
 def scf(parameters: Parameters) -> None:
@@ -51,16 +27,15 @@ def scf(parameters: Parameters) -> None:
     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
         ),
         epsilon=parameters.control.conv_treshold,
+        max_iter=parameters.control.max_iter,
     )
 
     logger.info("Self-consistency loop completed successfully.")

quant_met/mean_field/__init__.py

@@ -24,11 +24,13 @@ Functions
    superfluid_weight
    quantum_metric
    self_consistency_loop
+   search_crit_temp
 """  # noqa: D205, D400
 
 from quant_met.mean_field import hamiltonians
 
 from .quantum_metric import quantum_metric
+from .search_crit_temp import search_crit_temp
 from .self_consistency import self_consistency_loop
 from .superfluid_weight import superfluid_weight
 
@@ -36,5 +38,6 @@ __all__ = [
     "superfluid_weight",
     "quantum_metric",
     "self_consistency_loop",
+    "search_crit_temp",
     "hamiltonians",
 ]

quant_met/mean_field/search_crit_temp.py

@@ -0,0 +1,247 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Function to run search for critical temperature."""
+
+import logging
+from functools import partial
+from multiprocessing import Pool
+from typing import Any
+
+import matplotlib.figure
+import matplotlib.pyplot as plt
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+from scipy import stats
+
+from quant_met import plotting
+from quant_met.parameters import GenericParameters
+
+from .hamiltonians import BaseHamiltonian
+from .self_consistency import self_consistency_loop
+
+logger = logging.getLogger(__name__)
+
+
+def _get_bounds(
+    initial_temp: float,
+    gap_for_temp_partial: partial[dict[str, Any] | None],
+    zero_temperature_gap: npt.NDArray[np.complex64],
+) -> tuple[list[dict[str, Any]], float, float]:  # pragma: no cover
+    delta_vs_temp_list = []
+    zero_gap_temp = nonzero_gap_temp = 0.0
+    found_zero_gap = False
+    found_nonzero_gap = False
+    temp = initial_temp
+    direction = "down"
+    iterations = 0
+    while (found_zero_gap and found_nonzero_gap) is False and iterations < 100:
+        logger.info("Trying temperature: %s", temp)
+        data_dict = gap_for_temp_partial(temp)
+        if data_dict is not None:
+            delta_vs_temp_list.append(data_dict)
+            gap = np.array([data_dict[key] for key in data_dict if key.startswith("delta")])
+            if np.allclose(gap, 0):
+                zero_gap_temp = temp
+                temp = 0.5 * temp
+                logger.info("Found temperature with zero gap.")
+                found_zero_gap = True
+            elif np.allclose(gap, zero_temperature_gap):
+                nonzero_gap_temp = temp
+                temp = 2 * temp
+                logger.info("Found temperature with nonzero gap.")
+                found_nonzero_gap = True
+            elif direction == "down":
+                logger.info(
+                    "Gap is neither zero nor equal to the nonzero gap. Reducing temperature."
+                )
+                temp = 0.5 * temp
+            else:
+                logger.info(
+                    "Gap is neither zero nor equal to the nonzero gap. Increasing temperature."
+                )
+                temp = 2 * temp
+        else:
+            logger.info("No data found for temperature %s. Reducing temperature.", temp)
+            temp = 0.7 * temp
+        if found_zero_gap and not found_nonzero_gap and temp > initial_temp:
+            logger.info("Switching direction to decrease temperature.")
+            temp = initial_temp / 2
+            direction = "down"
+        if found_nonzero_gap and not found_zero_gap and temp < initial_temp:
+            logger.info("Switching direction to increase temperature.")
+            temp = 2 * initial_temp
+            direction = "up"
+
+        iterations += 1
+    return delta_vs_temp_list, zero_gap_temp, nonzero_gap_temp
+
+
+def _fit_for_crit_temp(
+    delta_vs_temp: pd.DataFrame, orbital: int
+) -> tuple[pd.DataFrame | None, pd.DataFrame, float | None, float | None]:  # pragma: no cover
+    filtered_results = delta_vs_temp.iloc[
+        np.where(
+            np.invert(
+                np.logical_or(
+                    np.isclose(
+                        np.abs(delta_vs_temp[f"delta_{orbital}"]) ** 2,
+                        0,
+                        atol=1000 * (np.abs(delta_vs_temp[f"delta_{orbital}"]) ** 2).min(),
+                        rtol=1e-3,
+                    ),
+                    np.isclose(
+                        np.abs(delta_vs_temp[f"delta_{orbital}"]) ** 2,
+                        (np.abs(delta_vs_temp[f"delta_{orbital}"]) ** 2).max(),
+                        rtol=1e-3,
+                    ),
+                )
+            )
+        )
+    ]
+
+    err = []
+    if len(filtered_results) <= 4:
+        return None, filtered_results, None, None
+
+    lengths = range(4, len(filtered_results))
+
+    for length in lengths:
+        range_results = filtered_results.iloc[-length:]
+        linreg = stats.linregress(
+            range_results["T"], np.abs(range_results[f"delta_{orbital}"]) ** 2
+        )
+        err.append(linreg.stderr)
+
+    min_length = lengths[np.argmin(np.array(err))]
+    range_results = filtered_results.iloc[-min_length:]
+    linreg = stats.linregress(range_results["T"], np.abs(range_results[f"delta_{orbital}"]) ** 2)
+
+    return range_results, filtered_results, linreg.intercept, linreg.slope
+
+
+def _gap_for_temp(
+    temp: float,
+    h: BaseHamiltonian[GenericParameters],
+    k_space_grid: npt.NDArray[np.float64],
+    epsilon: float,
+    max_iter: int = 1000,
+) -> dict[str, Any] | None:  # pragma: no cover
+    beta = np.inf if temp == 0 else 1 / temp
+    h.beta = beta
+    try:
+        solved_h = self_consistency_loop(h, k_space_grid, epsilon, max_iter)
+    except RuntimeError:
+        logger.exception("Did not converge.")
+        return None
+    else:
+        data_dict = {
+            "T": temp,
+        }
+        zero_temperature_gap = solved_h.delta_orbital_basis
+        data_dict.update(
+            {
+                f"delta_{orbital}": zero_temperature_gap[orbital]
+                for orbital in range(len(zero_temperature_gap))
+            }
+        )
+        return data_dict
+
+
+def search_crit_temp(
+    h: BaseHamiltonian[GenericParameters],
+    k_space_grid: npt.NDArray[np.float64],
+    epsilon: float,
+    max_iter: int,
+    n_temp_points: int,
+) -> tuple[pd.DataFrame, list[float], matplotlib.figure.Figure]:  # pragma: no cover
+    """Search for critical temperature."""
+    logger.info("Start search for bounds for T_C")
+    temp = 1 / h.beta if not np.isinf(h.beta) else 0.25 * h.hubbard_int_orbital_basis[0]
+
+    delta_vs_temp_list = []
+    critical_temp_list = []
+
+    gap_for_temp_partial = partial(
+        _gap_for_temp, h=h, k_space_grid=k_space_grid, epsilon=epsilon, max_iter=max_iter
+    )
+
+    logger.info("Calculating zero temperature gap")
+    data_dict = gap_for_temp_partial(0)
+    assert data_dict is not None
+
+    zero_temperature_gap = np.array(
+        [data_dict[key] for key in data_dict if key.startswith("delta")]
+    )
+    delta_vs_temp_list.append(data_dict)
+
+    delta_vs_temp_list_tmp, zero_gap_temp, nonzero_gap_temp = _get_bounds(
+        temp, gap_for_temp_partial, zero_temperature_gap
+    )
+    delta_vs_temp_list.extend(delta_vs_temp_list_tmp)
+    logger.info("Temperature bounds: %s to %s", nonzero_gap_temp, zero_gap_temp)
+
+    temperature_list = np.concatenate(
+        [
+            np.linspace(
+                0.8 * nonzero_gap_temp,
+                nonzero_gap_temp,
+                num=int(0.05 * n_temp_points),
+                endpoint=False,
+            ),
+            np.linspace(
+                nonzero_gap_temp, zero_gap_temp, num=int(0.9 * n_temp_points), endpoint=False
+            ),
+            np.linspace(
+                zero_gap_temp, 1.2 * zero_gap_temp, num=int(0.05 * n_temp_points), endpoint=True
+            ),
+        ]
+    )
+
+    with Pool() as p:
+        delta_vs_temp_list.extend(p.map(gap_for_temp_partial, temperature_list))  # type: ignore[arg-type]
+        delta_vs_temp_list = [x for x in delta_vs_temp_list if x is not None]
+
+    delta_vs_temp = pd.DataFrame(delta_vs_temp_list).sort_values(by=["T"]).reset_index(drop=True)
+
+    fit_fig, fit_axs = plt.subplots(
+        nrows=1, ncols=h.number_of_bands, figsize=(h.number_of_bands * 6, 6)
+    )
+
+    for orbital in range(h.number_of_bands):
+        fit_range, filtered_range, intercept, slope = _fit_for_crit_temp(delta_vs_temp, orbital)
+
+        ax = fit_axs if h.number_of_bands == 1 else fit_axs[orbital]
+
+        if fit_range is not None and intercept is not None and slope is not None:
+            critical_temp = -intercept / slope
+            critical_temp_list.append(critical_temp)
+
+            ax.plot(
+                filtered_range["T"],
+                intercept + slope * filtered_range["T"],
+                "r--",
+                alpha=0.3,
+            )
+            ax.plot(
+                fit_range["T"],
+                intercept + slope * fit_range["T"],
+                "r-",
+            )
+            ax.axvline(x=critical_temp, linestyle="--", color="gray")
+        else:
+            critical_temp = 0
+            critical_temp_list.append(critical_temp)
+
+        ax.plot(
+            delta_vs_temp["T"],
+            np.abs(delta_vs_temp[f"delta_{orbital}"]) ** 2,
+            "--x",
+            color=f"C{orbital}",
+        )
+        ax = plotting.format_plot(ax)
+        ax.set_ylabel(r"$\vert\Delta\vert^2\ [t^2]$")
+
+    return delta_vs_temp, critical_temp_list, fit_fig

quant_met/mean_field/self_consistency.py

@@ -5,7 +5,6 @@
 """Self-consistency loop."""
 
 import logging
-import sys
 
 import numpy as np
 import numpy.typing as npt
@@ -71,7 +70,8 @@ def self_consistency_loop(
     while True:
         iteration_count += 1
         if iteration_count > max_iter:
-            sys.exit("Maximum number of iterations reached.")
+            msg = "Maximum number of iterations reached."
+            raise RuntimeError(msg)
 
         logger.debug("Iteration %d: Computing new gaps.", iteration_count)
 

quant_met/parameters/__init__.py

@@ -17,6 +17,7 @@ Classes holding the configuration for the Hamiltonians.
 
 .. autosummary::
    :toctree: generated/parameters/
+   :template: autosummary/pydantic.rst
 
     Parameters  # noqa
     Control  # noqa

quant_met/parameters/hamiltonians.py

@@ -3,19 +3,20 @@
 # SPDX-License-Identifier: MIT
 
 """
-Hamiltonian Parameter Classes
-=============================
+hamiltonians
+============
 
 Classes holding the configuration for the Hamiltonians.
 
 .. autosummary::
-   :toctree: generated/parameters/
+   :toctree:
+   :template: autosummary/pydantic.rst
 
     HamiltonianParameters
     DressedGrapheneParameters
     GrapheneParameters
     OneBandParameters
-    TwobandParameters
+    TwoBandParameters
     ThreeBandParameters
 """  # noqa: D205, D400
 
@@ -49,28 +50,16 @@ def validate_float(value: float, info: ValidationInfo) -> float:
 
 
 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.
-    """
+    """Base class for Hamiltonian parameters."""
 
     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"
-    )
+    """The name of the Hamiltonian model (e.g., "Graphene", "DressedGraphene")."""
+    hubbard_int_orbital_basis: NDArray
+    """A numpy array representing the Hubbard interactions in the orbital basis."""
+    beta: float = np.inf
+    """The inverse temperature; default is set to infinity."""
+    q: NDArray[Shape["2"], float] | None = None
+    """An optional numpy array representing the momentum of Cooper pairs."""
 
 
 class DressedGrapheneParameters(HamiltonianParameters):

quant_met/parameters/main.py

@@ -8,7 +8,13 @@ import pathlib
 
 from pydantic import BaseModel, Field
 
-from .hamiltonians import DressedGrapheneParameters, GrapheneParameters, OneBandParameters
+from .hamiltonians import (
+    DressedGrapheneParameters,
+    GrapheneParameters,
+    OneBandParameters,
+    ThreeBandParameters,
+    TwoBandParameters,
+)
 
 
 class Control(BaseModel):
@@ -31,6 +37,8 @@ class Control(BaseModel):
     prefix: str
     outdir: pathlib.Path
     conv_treshold: float
+    max_iter: int = 1000
+    n_temp_points: int = 50
 
 
 class KPoints(BaseModel):
@@ -63,7 +71,11 @@ class Parameters(BaseModel):
     """
 
     control: Control
-    model: DressedGrapheneParameters | GrapheneParameters | OneBandParameters = Field(
-        ..., discriminator="name"
-    )
+    model: (
+        DressedGrapheneParameters
+        | GrapheneParameters
+        | OneBandParameters
+        | TwoBandParameters
+        | ThreeBandParameters
+    ) = Field(..., discriminator="name")
     k_points: KPoints

{quant_met-0.0.12.dist-info → quant_met-0.0.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.12
+Version: 0.0.14
 Summary: Calculate superconductivity in flat-band systems.
 Home-page: https://quant-met.tjarksievers.de
 Author: Tjark Sievers
@@ -17,6 +17,7 @@ Requires-Dist: numpydantic (>=1.6.4,<2.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: pydantic (>=2.9.2,<3.0.0)
 Requires-Dist: scipy (>=1.14.1,<2.0.0)
+Requires-Dist: tables (>=3.10.1,<4.0.0)
 Project-URL: Repository, https://github.com/Ruberhauptmann/quant-met
 Description-Content-Type: text/markdown
 
@@ -28,7 +29,7 @@ SPDX-License-Identifier: MIT
 
 # quant-met
 
-[![Test](https://github.com/Ruberhauptmann/quant-met/actions/workflows/test.yml/badge.svg)](https://github.com/Ruberhauptmann/quant-met/actions/workflows/test.yml)
+[![Test](https://github.com/Ruberhauptmann/quant-met/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/Ruberhauptmann/quant-met/actions/workflows/unit_tests.yml)
 [![Coverage Status](https://coveralls.io/repos/github/Ruberhauptmann/quant-met/badge.svg?branch=main)](https://coveralls.io/github/Ruberhauptmann/quant-met?branch=main)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/quant-met)](https://pypi.org/project/quant-met/)
 [![PyPI - Version](https://img.shields.io/pypi/v/quant-met)](https://pypi.org/project/quant-met/)

{quant_met-0.0.12.dist-info → quant_met-0.0.14.dist-info}/RECORD

@@ -1,13 +1,15 @@
 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=AT5321oo50siqm_7pY4MOi70arHZ2zO8_xrWB54YtRI,2310
+quant_met/cli/_utils.py,sha256=n_aP8_4sZXgPwBxngDcKozfdgYJL6VTwOn9qFLKrnzY,941
+quant_met/cli/crit_temp.py,sha256=t9sPZKORl6dpa1UNAOMH2gDmeQxf80iFH7p_L3FI5q8,2027
+quant_met/cli/main.py,sha256=lVAPGPUZtzyX6QKPEFYyDKFWYhQ30dMXjOEq5VdTa7I,1871
+quant_met/cli/scf.py,sha256=wHilJRBk7_8nOheJpGk1ZeBOWu4UF9oDVI4SjHptQgY,1464
 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/__init__.py,sha256=RqsqT4kXs2tQxbZZd1_NP2NGx_3RKcpQHNdwddCXg9E,736
 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
@@ -17,17 +19,18 @@ quant_met/mean_field/hamiltonians/one_band_tight_binding.py,sha256=SXHPoVd_zyevN
 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=2yRu2bfgMxgPcVqasmqfgUy8-O7gXJwJI7ziuvIShXU,2580
-quant_met/mean_field/self_consistency.py,sha256=dLTpD89IgUCrI_I_vCgLrvrPpMyUrZpZnAzGktIQsoE,3119
+quant_met/mean_field/search_crit_temp.py,sha256=iCjngwHgZhqW8rwAPZjUZvQG5XWwuutCxxITW54a__c,8550
+quant_met/mean_field/self_consistency.py,sha256=uk80FK7b1VVsFcUreGih11EMGXs45pkZ567g0bTNYwU,3140
 quant_met/mean_field/superfluid_weight.py,sha256=0T_vkJB9AvjeaPG_y5h_3ZHh-0MCefeXnaPOn-hYjKw,4127
-quant_met/parameters/__init__.py,sha256=i1pOw78ZshfBsUiUOKVo17C5xD9PfeJvlKITDRFKFvo,968
-quant_met/parameters/hamiltonians.py,sha256=u5a-hVC6FzY1kHFdcHlNG7i3c7T5vpC-XPraTg_WzVM,6402
-quant_met/parameters/main.py,sha256=acLuOLn5KD9_h5cbnd5H3akkF9XwcwAhLqV7jYJh0OA,1932
+quant_met/parameters/__init__.py,sha256=Urw9tGQkHgNogcqheIVoZYLka9Wao5FdwbvUK3-5qGw,1007
+quant_met/parameters/hamiltonians.py,sha256=E26X8FDnuruSRwV32yPn0CKhVr0Kxs9K3QBc3MMDnHI,6028
+quant_met/parameters/main.py,sha256=hGcJvRixkXuUk9MytAs0S1L2VvcJlT8qVG1g7NZOjlE,2126
 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.12.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.12.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.12.dist-info/METADATA,sha256=EyfCUoNH9QPU75fVisPlvk4jy9CUtRN9LtCiscbi4pw,2045
-quant_met-0.0.12.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quant_met-0.0.12.dist-info/entry_points.txt,sha256=fuVnEk5wiqPMEhn-Cc7q0Hdk2s_OniOn0zfdFPicH4Y,47
-quant_met-0.0.12.dist-info/RECORD,,
+quant_met-0.0.14.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.14.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.14.dist-info/METADATA,sha256=orOhm79uXFNHC6gvPn3qfXJzvfkukA63Wxe7PzAoaec,2097
+quant_met-0.0.14.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quant_met-0.0.14.dist-info/entry_points.txt,sha256=fuVnEk5wiqPMEhn-Cc7q0Hdk2s_OniOn0zfdFPicH4Y,47
+quant_met-0.0.14.dist-info/RECORD,,