quant-met 0.0.12__tar.gz → 0.0.13__tar.gz

{quant_met-0.0.12 → quant_met-0.0.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.12
+Version: 0.0.13
 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 → quant_met-0.0.13}/README.md

@@ -6,7 +6,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 → quant_met-0.0.13}/pyproject.toml

@@ -8,7 +8,7 @@ requires-python = ">=3.11,<3.13"
 
 [tool.poetry]
 name = "quant-met"
-version = "0.0.12"
+version = "0.0.13"
 description = "Calculate superconductivity in flat-band systems."
 authors = ["Tjark Sievers <tsievers@physnet.uni-hamburg.de>"]
 homepage = "https://quant-met.tjarksievers.de"
@@ -28,6 +28,7 @@ h5py = "^3.12.1"
 pydantic = "^2.9.2"
 click = "^8.1.7"
 numpydantic = "^1.6.4"
+tables = "^3.10.1"
 
 [tool.poetry.group.dev.dependencies]
 pre-commit = "^3.7.0"
@@ -49,6 +50,9 @@ pytest-regressions = "^2.5.0"
 numpydoc = "^1.7.0"
 ruff = "^0.5.0"
 types-pyyaml = "^6.0.12.20240917"
+autodoc-pydantic = "^2.2.0"
+pytest-integration = "^0.2.3"
+pytest-mock = "^3.14.0"
 
 [build-system]
 requires = ["poetry-core"]
@@ -58,12 +62,9 @@ build-backend = "poetry.core.masonry.api"
 [tool.ruff]
 line-length = 100
 force-exclude = true
-#extend-exclude = ["tests", "docs/source/conf.py"]
 extend-exclude = ["docs/source/conf.py"]
 
 [tool.ruff.lint]
-#select = []
-#select = ["D", "E", "F", "I", "W"]
 select = ["ALL"]
 ignore = [
     "D203", # one-blank-line-before-class
@@ -78,9 +79,5 @@ ignore = [
     "T201", # Warn about print statements
 ]
 
-
 [tool.ruff.lint.pydocstyle]
 convention = "numpy"
-
-#[format]
-#docstring-code-format = true

quant_met-0.0.13/src/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-0.0.13/src/quant_met/cli/crit_temp.py

@@ -0,0 +1,55 @@
+# 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}_T_C_fit.pdf", bbox_inches="tight")
+
+    result_file = result_path / f"{parameters.control.prefix}.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
+
+    logger.info("Results saved to %s", result_file)

{quant_met-0.0.12 → quant_met-0.0.13}/src/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-0.0.12 → quant_met-0.0.13}/src/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-0.0.12 → quant_met-0.0.13}/src/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-0.0.13/src/quant_met/mean_field/search_crit_temp.py

@@ -0,0 +1,227 @@
+# 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(
+    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 = temp
+    found_zero_gap = False
+    found_nonzero_gap = False
+    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
+            else:
+                temp = 0.5 * temp
+        else:
+            temp = 0.5 * temp
+        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
+    )
+
+    data_dict = gap_for_temp_partial(0)
+    assert data_dict is not None
+
+    logger.info("Calculating zero temperature gap")
+    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-0.0.12 → quant_met-0.0.13}/src/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-0.0.12 → quant_met-0.0.13}/src/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-0.0.12 → quant_met-0.0.13}/src/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-0.0.12 → quant_met-0.0.13}/src/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