quant-met 0.0.27__py3-none-any.whl → 0.1.1__py3-none-any.whl

quant_met/cli/scf.py

@@ -1,19 +1,15 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """Functions to run self-consistent calculation for the order parameter."""
 
 import logging
 from pathlib import Path
 
 import h5py
+import numpy as np
+import sisl
 
-from quant_met import mean_field
+from quant_met import bdg, routines
 from quant_met.parameters import Parameters
-
-from ._utils import _hamiltonian_factory
+from quant_met.parameters.control import SCF
 
 logger = logging.getLogger(__name__)
 
@@ -24,41 +20,66 @@ def scf(parameters: Parameters) -> None:
     Parameters
     ----------
     parameters: Parameters
-        An instance of Parameters containing control settings, the model,
-        and k-point specifications for the self-consistency calculation.
+        An instance of Parameters containing control settings.
     """
+    if not isinstance(parameters.control, SCF):
+        err_msg = "Wrong parameters for scf."
+        raise TypeError(err_msg)
+
     result_path = Path(parameters.control.outdir)
     result_path.mkdir(exist_ok=True, parents=True)
+    result_file = result_path / f"{parameters.control.prefix}.hdf5"
 
-    h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
-    k_space_grid = h.lattice.generate_bz_grid(
-        ncols=parameters.k_points.nk1, nrows=parameters.k_points.nk2
+    hamiltonian = sisl.get_sile(parameters.control.hamiltonian_file).read_hamiltonian()
+    k_grid_obj = sisl.MonkhorstPack(
+        hamiltonian.geometry,
+        [parameters.k_points.nk1, parameters.k_points.nk2, 1],
     )
 
-    solved_h = mean_field.self_consistency_loop(
-        h=h,
-        k_space_grid=k_space_grid,
+    solved_gap = routines.self_consistency_loop(
+        hamiltonian=hamiltonian,
+        kgrid=k_grid_obj,
+        beta=parameters.control.beta,
+        hubbard_int_orbital_basis=np.array(parameters.control.hubbard_int_orbital_basis),
         epsilon=parameters.control.conv_treshold,
         max_iter=parameters.control.max_iter,
+        q=np.array(parameters.control.q),
     )
 
     logger.info("Self-consistency loop completed successfully.")
-    logger.debug("Obtained delta values: %s", solved_h.delta_orbital_basis)
+    logger.debug("Obtained delta values: %s", solved_gap)
 
-    result_file = result_path / f"{parameters.control.prefix}.hdf5"
-    solved_h.save(filename=result_file)
+    with h5py.File(result_file, "a") as f:
+        f.create_dataset("delta", data=solved_gap)
     logger.info("Results saved to %s", result_file)
 
     if parameters.control.calculate_additional is True:
         logger.info("Calculating additional things.")
-        current = solved_h.calculate_current_density(k=k_space_grid)
-        free_energy = solved_h.calculate_free_energy(k=k_space_grid)
-        sf_weight_conv, sf_weight_geom = solved_h.calculate_superfluid_weight(k=k_space_grid)
+
+        bdg_energies, bdg_wavefunctions = bdg.diagonalize_bdg(
+            hamiltonian=hamiltonian,
+            kgrid=k_grid_obj,
+            delta_orbital_basis=solved_gap,
+            q=np.array(parameters.control.q),
+        )
+
+        current = bdg.calculate_current_density(
+            hamiltonian=hamiltonian,
+            k=k_grid_obj,
+            bdg_energies=bdg_energies,
+            bdg_wavefunctions=bdg_wavefunctions,
+            beta=parameters.control.beta,
+        )
+        sf_weight_conv, sf_weight_geom = bdg.calculate_superfluid_weight(
+            hamiltonian=hamiltonian,
+            kgrid=k_grid_obj,
+            beta=parameters.control.beta,
+            delta_orbital_basis=solved_gap,
+        )
 
         with h5py.File(result_file, "a") as f:
             f.attrs["current_x"] = current[0]
             f.attrs["current_y"] = current[1]
-            f.attrs["free_energy"] = free_energy
             f.attrs["sf_weight_conv_xx"] = sf_weight_conv[0, 0]
             f.attrs["sf_weight_conv_xy"] = sf_weight_conv[0, 1]
             f.attrs["sf_weight_conv_yx"] = sf_weight_conv[1, 0]

quant_met/parameters/__init__.py

@@ -1,8 +1,3 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """
 Parameter Classes
 =================
@@ -11,11 +6,6 @@ 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/
    :template: autosummary/pydantic.rst
@@ -25,26 +15,10 @@ Classes holding the configuration for the Hamiltonians.
     KPoints  # noqa
 """  # noqa: D205, D400
 
-from .hamiltonians import (
-    DressedGrapheneParameters,
-    GenericParameters,
-    GrapheneParameters,
-    HamiltonianParameters,
-    OneBandParameters,
-    ThreeBandParameters,
-    TwoBandParameters,
-)
 from .main import Control, KPoints, Parameters
 
 __all__ = [
     "Control",
-    "DressedGrapheneParameters",
-    "GenericParameters",
-    "GrapheneParameters",
-    "HamiltonianParameters",
     "KPoints",
-    "OneBandParameters",
     "Parameters",
-    "ThreeBandParameters",
-    "TwoBandParameters",
 ]

quant_met/parameters/control.py

@@ -0,0 +1,57 @@
+"""Control parameters."""
+
+import pathlib
+from typing import Annotated, Literal, TypeAlias
+
+from pydantic import BaseModel, Field
+
+FloatList: TypeAlias = list[float]
+
+
+class ControlBase(BaseModel):
+    """Base class for control parameters."""
+
+    prefix: str
+    hamiltonian_file: pathlib.Path
+    outdir: pathlib.Path
+    conv_treshold: float
+    hubbard_int_orbital_basis: FloatList = Field(..., min_length=1)
+    max_iter: int = 1000
+
+
+class SCF(ControlBase):
+    """Parameters for the scf calculation."""
+
+    calculation: Literal["scf"]
+    beta: float
+    calculate_additional: bool = False
+    q: FloatList | None = Field(..., min_length=2, max_length=2)
+
+
+class CritTemp(ControlBase):
+    """Parameters for the critical temperature calculation."""
+
+    calculation: Literal["crit-temp"]
+    n_temp_points: int = 50
+    q: FloatList | None = Field(..., min_length=2, max_length=2)
+
+
+class QLoop(ControlBase):
+    """Parameters for the q-loop calculation."""
+
+    calculation: Literal["q-loop"]
+    n_q_points: int = 50
+    crit_temp: CritTemp | pathlib.Path
+
+
+class QAnalysis(BaseModel):
+    """Parameters for the q-analysis calculation."""
+
+    calculation: Literal["q-analysis"]
+    q_data: pathlib.Path
+    hamiltonian_file: pathlib.Path
+    prefix: str
+    outdir: pathlib.Path
+
+
+Control = Annotated[SCF | CritTemp | QLoop | QAnalysis, Field(discriminator="calculation")]

quant_met/parameters/main.py

@@ -1,54 +1,8 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """Pydantic models to hold parameters to run a simulation."""
 
-import pathlib
-
-from pydantic import BaseModel, Field
-
-from .hamiltonians import (
-    DressedGrapheneParameters,
-    GrapheneParameters,
-    OneBandParameters,
-    ThreeBandParameters,
-    TwoBandParameters,
-)
-
-
-class Control(BaseModel):
-    """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
-    max_iter: int = 1000
-    n_temp_points: int = 50
-    calculate_additional: bool = False
+from pydantic import BaseModel
 
-    n_spin: int = 1
-    n_success: int = 1
-    wmixing: float = 0.5
-    n_bath: int = 2
-    n_iw: int = 1024
-    n_w: int = 4000
-    broadening: float = 0.005
+from .control import Control
 
 
 class KPoints(BaseModel):
@@ -81,11 +35,4 @@ class Parameters(BaseModel):
     """
 
     control: Control
-    model: (
-        DressedGrapheneParameters
-        | GrapheneParameters
-        | OneBandParameters
-        | TwoBandParameters
-        | ThreeBandParameters
-    ) = Field(..., discriminator="name")
     k_points: KPoints

quant_met/quantum_geometry/__init__.py

@@ -0,0 +1,13 @@
+"""
+Quantum Geometry
+================
+
+.. autosummary::
+    :toctree: generated/
+
+    calculate_qgt
+"""  # noqa: D205, D400
+
+from .qgt import calculate_qgt
+
+__all__ = ["calculate_qgt"]

quant_met/quantum_geometry/qgt.py

@@ -0,0 +1,37 @@
+"""Calculate the quantum geometric tensor."""
+
+import numpy as np
+import numpy.typing as npt
+import sisl
+
+
+def calculate_qgt(
+    hamiltonian: sisl.Hamiltonian,
+    k_grid: npt.NDArray[np.floating],
+    bands: list[int],
+) -> npt.NDArray[np.floating]:
+    """Calculate the quantum geometric tensor for selected bands."""
+    qgt = np.zeros((2, 2), dtype=np.complex128)
+
+    for k_point in k_grid:
+        # Diagonalize at this k-point
+        hk = hamiltonian.Hk(k=k_point, format="array")
+        energies, bloch = np.linalg.eigh(hk)
+
+        # Derivatives of H at this k-point
+        der_h_k = hamiltonian.dHk(k=k_point, format="array")
+
+        for band in bands:
+            for i, der_h_i in enumerate(der_h_k):  # i: x=0, y=1
+                for j, der_h_j in enumerate(der_h_k):  # j: x=0, y=1
+                    for n in range(len(energies)):
+                        if n == band:
+                            continue
+                        denom = (energies[band] - energies[n]) ** 2
+                        if np.isclose(denom, 0.0):
+                            continue  # avoid division by zero
+                        mni = np.vdot(bloch[:, band], der_h_i @ bloch[:, n])
+                        mnj = np.vdot(bloch[:, n], der_h_j @ bloch[:, band])
+                        qgt[i, j] += mni * mnj / denom
+
+    return np.real(qgt) / len(k_grid)

quant_met/routines/__init__.py

@@ -0,0 +1,22 @@
+"""
+Routines
+========
+
+.. autosummary::
+    :toctree: generated/
+
+    self_consistency_loop
+"""  # noqa: D205, D400
+
+from .analyse_q_data import get_lengths_vs_temp, get_zero_temperature_values
+from .loop_over_q import loop_over_q
+from .search_crit_temp import search_crit_temp
+from .self_consistency import self_consistency_loop
+
+__all__ = [
+    "get_lengths_vs_temp",
+    "get_zero_temperature_values",
+    "loop_over_q",
+    "search_crit_temp",
+    "self_consistency_loop",
+]

quant_met/routines/analyse_q_data.py

@@ -0,0 +1,226 @@
+"""Routine to analyse q data."""
+
+import logging
+
+import matplotlib.figure
+import matplotlib.pyplot as plt
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+import sisl
+from scipy.interpolate import CubicSpline
+from scipy.optimize import curve_fit, minimize_scalar, root_scalar
+
+logger = logging.getLogger(__name__)
+
+
+MIN_LENGTH_FIT = 5
+FIT_CUTOFF = 0.01
+
+
+def _lambda_from_xi(xi: float, jdp: float) -> float:
+    return np.sqrt(2 / (3 * np.sqrt(3) * xi * jdp))
+
+
+def _correl_length_temp_dependence(
+    temp: npt.NDArray[np.floating], xi_0: float, crit_temp: float
+) -> npt.NDArray[np.floating]:
+    return xi_0 / np.sqrt(1 - temp / crit_temp)
+
+
+def _london_depth_temp_dependence(
+    temp: npt.NDArray[np.floating], lambda_0: float, crit_temp: float
+) -> npt.NDArray[np.floating]:
+    return lambda_0 / np.sqrt(1 - (temp / crit_temp))
+
+
+def get_lengths_vs_temp(
+    q_data: dict[str, pd.DataFrame],
+    hamiltonian: sisl.Hamiltonian,
+) -> tuple[pd.DataFrame, matplotlib.figure.Figure]:
+    """Calculate SC lengths vs temperature.
+
+    Args:
+        q_data (dict[str, pd.DataFrame]): Dataframe with q data.
+        hamiltonian (sisl.Hamiltonian): Hamiltonian
+
+    Returns
+    -------
+        tuple[pd.DataFrame, matplotlib.figure.Figure]: Results. Figure with fits.
+    """
+    lengths_row_list = []
+
+    for temperature, data in q_data.items():
+        lengths_dict = {
+            "T": float(temperature.split("_")[-1]),
+        }
+        results_fit = data[
+            np.abs(data["current_abs"]) / np.max(np.abs(data["current_abs"])) > FIT_CUTOFF
+        ]
+        results_fit.reset_index(drop=True, inplace=True)
+
+        if len(results_fit) > MIN_LENGTH_FIT:
+            j_spl = CubicSpline(x=results_fit["q_fraction"], y=results_fit["current_abs"])
+            res = minimize_scalar(
+                lambda x, spline=j_spl: -spline(x),
+                bounds=(0, results_fit["q_fraction"].tail(1).item()),
+            )
+            q_j_max = float(res.x)
+            j_dp = float(j_spl(q_j_max))
+            lengths_dict.update({"q_j_max": q_j_max, "j_dp": j_dp})
+            for orbital in range(hamiltonian.no):
+                delta_spl = CubicSpline(
+                    x=results_fit["q_fraction"],
+                    y=np.abs(results_fit[f"delta_{orbital}"])
+                    / np.abs(data.at[0, f"delta_{orbital}"]),
+                )
+                try:
+                    res = root_scalar(
+                        lambda x, spline=delta_spl: spline(x) - 1 / np.sqrt(2),
+                        bracket=(0, results_fit["q_fraction"].tail(1)),
+                    )
+
+                    xi = 1 / (np.sqrt(2) * res.root * np.linalg.norm(hamiltonian.geometry.rcell[0]))
+                    lengths_dict.update(
+                        {
+                            f"Q_{orbital}": res.root,
+                            f"delta_{orbital}": delta_spl(res.root)
+                            * np.abs(data.at[0, f"delta_{orbital}"]),
+                            f"xi_{orbital}": xi,
+                        },
+                    )
+                    if j_dp is not None:
+                        lambda_london = _lambda_from_xi(xi, j_dp)
+                        lengths_dict.update({f"lambda_{orbital}": lambda_london})
+                except ValueError:
+                    logger.exception("Value error.")
+        lengths_row_list.append(lengths_dict)
+
+    lengths_vs_temp = pd.DataFrame(lengths_row_list).sort_values("T").reset_index(drop=True)
+
+    gap_and_current_fig, gap_and_current_axs = plt.subplots(
+        ncols=hamiltonian.no + 1,
+        figsize=(7 * hamiltonian.no, 5),
+    )
+
+    for temperature, data in q_data.items():
+        for orbital in range(hamiltonian.no):
+            gap_ax = gap_and_current_axs[orbital]
+            gap_ax.plot(
+                data["q_fraction"],
+                data[f"delta_{orbital}"],
+                "x--",
+                label=f"{float(temperature.split('_')[-1]):.2f}",
+            )
+            gap_ax.plot(lengths_vs_temp[f"Q_{orbital}"], lengths_vs_temp[f"delta_{orbital}"], "o--")
+            gap_ax.legend()
+        current_ax = gap_and_current_axs[hamiltonian.no]
+        current_ax.plot(
+            data["q_fraction"],
+            data["current_abs"],
+            "x--",
+            label=f"{float(temperature.split('_')[-1]):.2f}",
+        )
+        current_ax.legend()
+
+    current_ax = gap_and_current_axs[hamiltonian.no]
+    current_ax.plot(lengths_vs_temp["q_j_max"], lengths_vs_temp["j_dp"], "o--")
+
+    return lengths_vs_temp, gap_and_current_fig
+
+
+def get_zero_temperature_values(
+    hamiltonian: sisl.Hamiltonian, lengths_vs_temp: pd.DataFrame
+) -> tuple[pd.DataFrame, matplotlib.figure.Figure]:
+    """Get zero temperature values for the SC length scales.
+
+    Args:
+        hamiltonian (sisl.Hamiltonian): Hamiltonian.
+        lengths_vs_temp (pd.DataFrame): SC lengths against temperature.
+
+    Returns
+    -------
+        tuple[pd.DataFrame, matplotlib.figure.Figure]: Results, Figure with fits.
+    """
+    length_vs_temp_fig, length_vs_temp_axs = plt.subplots(
+        nrows=2,
+        ncols=hamiltonian.no,
+        figsize=(7 * hamiltonian.no, 2 * 5),
+    )
+    zero_temp_length_row_list = []
+    zero_temp_length_dict = {}
+    for orbital in range(hamiltonian.no):
+        xi_ax = length_vs_temp_axs[0, orbital]
+        lambda_ax = length_vs_temp_axs[1, orbital]
+
+        if f"xi_{orbital}" in lengths_vs_temp:
+            xi_ax.plot(lengths_vs_temp["T"], lengths_vs_temp[f"xi_{orbital}"], "x--")
+
+            xi_fit = lengths_vs_temp[["T", f"xi_{orbital}"]].dropna().reset_index(drop=True)
+            xi_fit.reset_index(drop=True, inplace=True)
+
+            if len(xi_fit) > MIN_LENGTH_FIT:
+                p0, p0cov = curve_fit(
+                    _correl_length_temp_dependence,
+                    xi_fit["T"],
+                    xi_fit[f"xi_{orbital}"],
+                    bounds=([0.0, 0.0], [np.inf, np.inf]),
+                    p0=[2.0, 2.0],
+                )
+                xi_0 = p0[0]
+                crit_temp_xi = p0[1]
+                temp_points_interpolate = np.linspace(
+                    xi_fit.at[0, "T"],
+                    xi_fit.at[len(xi_fit) - 1, "T"],
+                    num=500,
+                )
+                xi_ax.plot(
+                    temp_points_interpolate,
+                    _correl_length_temp_dependence(temp_points_interpolate, xi_0, crit_temp_xi),
+                )
+                xi_ax.axvline(x=crit_temp_xi, ls="--")
+                xi_ax.axhline(y=xi_0, ls="--")
+                xi_ax.set_ylim(bottom=0)
+                zero_temp_length_dict.update(
+                    {f"xi0_{orbital}": xi_0, f"T_C_{orbital}_xi": crit_temp_xi},
+                )
+        if f"lambda_{orbital}" in lengths_vs_temp:
+            lambda_ax.plot(lengths_vs_temp["T"], lengths_vs_temp[f"lambda_{orbital}"], "x--")
+            lambda_fit = lengths_vs_temp[["T", f"lambda_{orbital}"]].dropna().reset_index(drop=True)
+
+            if len(lambda_fit) > MIN_LENGTH_FIT:
+                p0, p0cov = curve_fit(
+                    _london_depth_temp_dependence,
+                    lambda_fit["T"],
+                    lambda_fit[f"lambda_{orbital}"],
+                    bounds=([0.0, 0.0], [np.inf, np.inf]),
+                    p0=[2.0, 2.0],
+                )
+
+                lambda_0 = p0[0]
+                crit_temp_lambda = p0[1]
+                temp_points_interpolate = np.linspace(
+                    lambda_fit.at[0, "T"],
+                    lambda_fit.at[len(lambda_fit) - 1, "T"],
+                    num=500,
+                )
+                lambda_ax.plot(
+                    temp_points_interpolate,
+                    _london_depth_temp_dependence(
+                        temp_points_interpolate, lambda_0, crit_temp_lambda
+                    ),
+                )
+                lambda_ax.axvline(x=crit_temp_lambda, ls="--")
+                lambda_ax.axhline(y=lambda_0, ls="--")
+                lambda_ax.set_ylim(bottom=0)
+                zero_temp_length_dict.update(
+                    {
+                        f"lambda0_{orbital}": lambda_0,
+                        f"T_C_lambda0_{orbital}": crit_temp_lambda,
+                    },
+                )
+
+    zero_temp_length_row_list.append(zero_temp_length_dict)
+    zero_temp_lengths = pd.DataFrame(zero_temp_length_row_list)
+
+    return zero_temp_lengths, length_vs_temp_fig