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

quant_met/__init__.py

@@ -1,10 +1,5 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """quant-met, a package to treat superconductivity in flat-band systems."""
 
-from . import cli, geometry, mean_field, parameters, plotting
+from . import bdg, cli, quantum_geometry, routines
 
-__all__ = ["cli", "geometry", "mean_field", "parameters", "plotting"]
+__all__ = ["bdg", "cli", "quantum_geometry", "routines"]

quant_met/bdg/__init__.py

@@ -0,0 +1,26 @@
+"""
+Bogoliubov-de Gennes (BdG)
+==========================
+
+.. autosummary::
+    :toctree: generated/
+
+    bdg_hamiltonian
+    diagonalize_bdg
+    gap_equation
+    calculate_superfluid_weight
+    calculate_current_density
+"""  # noqa: D205, D400
+
+from .bdg_hamiltonian import bdg_hamiltonian, diagonalize_bdg
+from .gap_equation import gap_equation
+from .sc_current import calculate_current_density
+from .superfluid_weight import calculate_superfluid_weight
+
+__all__ = [
+    "bdg_hamiltonian",
+    "calculate_current_density",
+    "calculate_superfluid_weight",
+    "diagonalize_bdg",
+    "gap_equation",
+]

quant_met/bdg/bdg_hamiltonian.py

@@ -0,0 +1,97 @@
+"""BdG Hamiltonian."""
+
+import numpy as np
+import numpy.typing as npt
+import sisl
+
+
+def bdg_hamiltonian(
+    hamiltonian: sisl.Hamiltonian,
+    k: npt.NDArray[np.floating],
+    delta_orbital_basis: npt.NDArray[np.complexfloating],
+    q: npt.NDArray[np.floating] | None = None,
+) -> npt.NDArray[np.complexfloating]:
+    """
+    Construct the BdG Hamiltonian at momentum k.
+
+    Parameters
+    ----------
+    hamiltonian : sisl.Hamiltonian
+        The normal-state tight-binding Hamiltonian.
+    k : np.ndarray
+        k-point(s) in reduced coordinates. Shape: (3,) or (N_k, 3).
+    delta_orbital_basis : np.ndarray
+        Pairing amplitudes in the orbital basis. Shape: (N_orbitals,)
+    q : np.ndarray, optional
+        Pairing momentum (e.g. for FFLO). Default is 0.
+
+    Returns
+    -------
+    np.ndarray
+        The BdG Hamiltonian. Shape: (2N, 2N) or (N_k, 2N, 2N)
+    """
+    k = np.atleast_2d(k)
+    n_k_points = k.shape[0]
+    n_orbitals = hamiltonian.no
+
+    if q is None:
+        q = np.zeros(3)
+
+    h_bdg = np.zeros((n_k_points, 2 * n_orbitals, 2 * n_orbitals), dtype=np.complex128)
+
+    for i, kpt in enumerate(k):
+        h_k = hamiltonian.Hk(kpt).toarray()
+        h_mkq = hamiltonian.Hk(q - kpt).toarray()
+
+        h_bdg[i, :n_orbitals, :n_orbitals] = h_k
+        h_bdg[i, n_orbitals:, n_orbitals:] = -h_mkq.conj()
+
+        for j in range(n_orbitals):
+            h_bdg[i, n_orbitals + j, j] = delta_orbital_basis[j]
+
+        h_bdg[i, :n_orbitals, n_orbitals:] = h_bdg[i, n_orbitals:, :n_orbitals].conj().T
+
+    return h_bdg.squeeze()
+
+
+def diagonalize_bdg(
+    hamiltonian: sisl.Hamiltonian,
+    kgrid: sisl.MonkhorstPack,
+    delta_orbital_basis: np.ndarray,
+    q: npt.NDArray[np.floating] | None,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.complex128]]:
+    """Diagonalizes the BdG Hamiltonian.
+
+    This method computes the eigenvalues and eigenvectors of the Bogoliubov-de
+    Gennes Hamiltonian, providing insight into the quasiparticle excitations in
+    superconducting states.
+
+    Parameters
+    ----------
+    q
+    kgrid
+    delta_orbital_basis
+    hamiltonian
+
+    Returns
+    -------
+    tuple
+        - :class:`numpy.ndarray`: Eigenvalues of the BdG Hamiltonian.
+        - :class:`numpy.ndarray`: Eigenvectors corresponding to the eigenvalues of the
+          BdG Hamiltonian.
+    """
+    energies = []
+    wavefunctions = []
+
+    for kpt in kgrid:
+        bdg = bdg_hamiltonian(
+            hamiltonian=hamiltonian,
+            delta_orbital_basis=delta_orbital_basis,
+            k=kpt,
+            q=q,
+        )
+        e, v = np.linalg.eigh(bdg)
+        energies.append(e)
+        wavefunctions.append(v)
+
+    return np.array(energies), np.array(wavefunctions)

quant_met/bdg/gap_equation.py

@@ -0,0 +1,127 @@
+"""Gap equation."""
+
+import numpy as np
+import numpy.typing as npt
+import sisl
+from numba import jit
+
+from .bdg_hamiltonian import diagonalize_bdg
+
+
+def gap_equation(  # noqa: PLR0913
+    hamiltonian: sisl.Hamiltonian,
+    beta: float,
+    hubbard_int_orbital_basis: npt.NDArray[np.float64],
+    delta_orbital_basis: npt.NDArray[np.complex128],
+    kgrid: sisl.MonkhorstPack,
+    q: npt.NDArray[np.float64] | None,
+) -> npt.NDArray[np.complexfloating]:
+    """Gap equation.
+
+    Parameters
+    ----------
+    q
+    kgrid
+    delta_orbital_basis
+    hubbard_int_orbital_basis
+    beta
+    hamiltonian
+
+    Returns
+    -------
+    New delta
+    """
+    bdg_energies, bdg_wavefunctions = diagonalize_bdg(
+        hamiltonian=hamiltonian,
+        kgrid=kgrid,
+        q=q,
+        delta_orbital_basis=delta_orbital_basis,
+    )
+    delta = np.zeros(hamiltonian.no, dtype=np.complex128)
+    return gap_equation_loop(
+        bdg_energies=bdg_energies,
+        bdg_wavefunctions=bdg_wavefunctions,
+        delta=delta,
+        beta=beta,
+        hubbard_int_orbital_basis=hubbard_int_orbital_basis,
+        kgrid=kgrid.k,
+        weights=kgrid.weight,
+    )
+
+
+@jit
+def gap_equation_loop(  # noqa: PLR0913
+    bdg_energies: npt.NDArray[np.float64],
+    bdg_wavefunctions: npt.NDArray[np.complex128],
+    delta: npt.NDArray[np.complex128],
+    beta: float,
+    hubbard_int_orbital_basis: npt.NDArray[np.float64],
+    kgrid: npt.NDArray[np.float64],
+    weights: npt.NDArray[np.float64],
+) -> npt.NDArray[np.complexfloating]:
+    """Calculate the gap equation.
+
+    The gap equation determines the order parameter for superconductivity by
+    relating the pairings to the spectral properties of the BdG Hamiltonian.
+
+    Parameters
+    ----------
+    kgrid
+    bdg_energies : :class:`numpy.ndarray`
+        BdG energies
+    bdg_wavefunctions : :class:`numpy.ndarray`
+        BdG wavefunctions
+    delta : :class:`numpy.ndarray`
+        Delta
+    beta : :class:`float`
+        Beta
+    hubbard_int_orbital_basis : :class:`numpy.ndarray`
+        Hubard interaction in orbital basis
+    k : :class:`numpy.ndarray`
+        List of k points in reciprocal space.
+
+    Returns
+    -------
+    :class:`numpy.ndarray`
+        New pairing gap in orbital basis, adjusted to remove global phase.
+    """
+    number_of_bands = len(delta)
+    new_delta = np.zeros_like(delta)
+
+    for i in range(number_of_bands):
+        sum_tmp = 0
+        for k_index in range(len(kgrid)):
+            weight = weights[k_index]
+
+            for j in range(2 * number_of_bands):
+                sum_tmp += (
+                    np.conj(bdg_wavefunctions[k_index, i, j])
+                    * bdg_wavefunctions[k_index, i + number_of_bands, j]
+                    * fermi_dirac(bdg_energies[k_index, j], beta)
+                    * weight
+                )
+        new_delta[i] = (-hubbard_int_orbital_basis[i] * sum_tmp).conjugate()
+
+    new_delta *= np.exp(-1j * np.angle(new_delta[np.argmax(np.abs(new_delta))]))
+    return new_delta
+
+
+@jit
+def fermi_dirac(energy: npt.NDArray[np.floating], beta: float) -> npt.NDArray[np.floating]:
+    """Fermi dirac distribution.
+
+    Parameters
+    ----------
+    energy
+    beta
+
+    Returns
+    -------
+    fermi_dirac
+
+    """
+    return (
+        np.where(energy < 0, 1.0, 0.0)
+        if np.isinf(beta)
+        else np.asarray(1 / (1 + np.exp(beta * energy)))
+    )

quant_met/bdg/sc_current.py

@@ -0,0 +1,60 @@
+"""Calculate supercurrent."""
+
+import numpy as np
+import sisl
+from numpy.typing import NDArray
+
+
+def calculate_current_density(
+    hamiltonian: sisl.Hamiltonian,
+    k: sisl.MonkhorstPack,
+    bdg_energies: NDArray[np.floating],
+    bdg_wavefunctions: NDArray[np.complexfloating],
+    beta: float,
+) -> NDArray[np.floating]:
+    """Calculate current density from BdG wavefunctions and normal-state Hamiltonian derivatives.
+
+    Parameters
+    ----------
+    hamiltonian : sisl.Hamiltonian
+        The normal-state Hamiltonian.
+    k : np.ndarray
+        Array of k-points in the Brillouin zone.
+    bdg_energies : np.ndarray
+        BdG eigenvalues for each k-point.
+    bdg_wavefunctions : np.ndarray
+        BdG eigenvectors for each k-point.
+    beta : float
+        Inverse temperature (1 / k_B T).
+
+    Returns
+    -------
+    np.ndarray
+        Real current density vector (2D).
+    """
+
+    def fermi_dirac(e: float, beta: float) -> float:
+        return 1.0 / (np.exp(beta * e) + 1)
+
+    num_bands = hamiltonian.no
+    current = np.zeros(2, dtype=np.complex128)
+
+    for dir_idx, _direction in enumerate(["x", "y"]):
+        matrix = np.zeros((num_bands, num_bands), dtype=np.complex128)
+
+        for k_index, kpt in enumerate(k):
+            dhk = hamiltonian.dHk(kpt, format="array")[dir_idx]
+
+            for i in range(num_bands):
+                for j in range(num_bands):
+                    for n in range(2 * num_bands):
+                        matrix[i, j] += (
+                            dhk[i, j]
+                            * np.conj(bdg_wavefunctions[k_index, i, n])
+                            * bdg_wavefunctions[k_index, j, n]
+                            * fermi_dirac(bdg_energies[k_index, n], beta)
+                        )
+
+        current[dir_idx] = np.sum(matrix)
+
+    return (2 * np.real(current)) / len(k)

quant_met/bdg/superfluid_weight.py

@@ -0,0 +1,110 @@
+"""Function to calculate superfluid weight."""
+
+import numpy as np
+import numpy.typing as npt
+import sisl
+
+from .bdg_hamiltonian import bdg_hamiltonian
+
+
+def calculate_superfluid_weight(
+    hamiltonian: sisl.Hamiltonian,
+    kgrid: sisl.MonkhorstPack,
+    beta: float,
+    delta_orbital_basis: npt.NDArray[np.complexfloating],
+) -> tuple[npt.NDArray[np.complexfloating], npt.NDArray[np.complexfloating]]:
+    """Calculate superfluid weight (conventional + geometric)."""
+    s_weight_conv = np.zeros((2, 2), dtype=np.complex128)
+    s_weight_geom = np.zeros((2, 2), dtype=np.complex128)
+    c_mnpq_cache = {}
+
+    for i, _dir1 in enumerate(["x", "y"]):
+        for j, _dir2 in enumerate(["x", "y"]):
+            for k_point in kgrid:
+                k_tuple = tuple(k_point)
+
+                # Solve BdG problem
+                bdg_h = bdg_hamiltonian(hamiltonian, k_point, delta_orbital_basis)
+                energies, wavefuncs = np.linalg.eigh(bdg_h)
+
+                # Cache coefficient tensor
+                if k_tuple not in c_mnpq_cache:
+                    c_mnpq_cache[k_tuple] = _c_factor(energies, wavefuncs, beta)
+                c_mnpq = c_mnpq_cache[k_tuple]
+
+                bdg_h_deriv_1 = np.zeros(
+                    (2 * hamiltonian.no, 2 * hamiltonian.no),
+                    dtype=np.complex128,
+                )
+                bdg_h_deriv_2 = np.zeros(
+                    (2 * hamiltonian.no, 2 * hamiltonian.no),
+                    dtype=np.complex128,
+                )
+
+                bdg_h_deriv_1[0 : hamiltonian.no, 0 : hamiltonian.no] = hamiltonian.dHk(
+                    k=k_point,
+                    format="array",
+                )[i]
+                bdg_h_deriv_1[
+                    hamiltonian.no : 2 * hamiltonian.no,
+                    hamiltonian.no : 2 * hamiltonian.no,
+                ] = hamiltonian.dHk(k=-k_point, format="array")[i]
+
+                bdg_h_deriv_2[0 : hamiltonian.no, 0 : hamiltonian.no] = hamiltonian.dHk(
+                    k=k_point,
+                    format="array",
+                )[j]
+                bdg_h_deriv_2[
+                    hamiltonian.no : 2 * hamiltonian.no,
+                    hamiltonian.no : 2 * hamiltonian.no,
+                ] = hamiltonian.dHk(k=-k_point, format="array")[j]
+
+                j_op_1 = _current_operator(bdg_h_deriv_1, wavefuncs)
+                j_op_2 = _current_operator(bdg_h_deriv_2, wavefuncs)
+
+                for m in range(len(wavefuncs)):
+                    for n in range(len(wavefuncs)):
+                        for p in range(len(wavefuncs)):
+                            for q in range(len(wavefuncs)):
+                                s_w = c_mnpq[m, n, p, q] * j_op_1[m, n] * j_op_2[q, p]
+                                if m == n and p == q:
+                                    s_weight_conv[i, j] += s_w
+                                else:
+                                    s_weight_geom[i, j] += s_w
+
+    return s_weight_conv, s_weight_geom
+
+
+def _c_factor(e: npt.NDArray, psi: npt.NDArray, beta: float) -> npt.NDArray:
+    n = len(e)
+    c = np.zeros((n, n, n, n), dtype=np.complex128)
+    for i in range(n):
+        for j in range(n):
+            if np.isclose(e[i], e[j]):
+                f_term = -_fermi_dirac_derivative(e[i], beta)
+            else:
+                f_term = (_fermi_dirac(e[i], beta) - _fermi_dirac(e[j], beta)) / (e[i] - e[j])
+            for m in range(n):
+                for n_ in range(n):
+                    for p in range(n):
+                        for q in range(n):
+                            c[m, n_, p, q] += f_term * (
+                                psi[:, i].conj()[m]
+                                * psi[:, j][n_]
+                                * psi[:, j].conj()[p]
+                                * psi[:, i][q]
+                            )
+    return 2 * c
+
+
+def _current_operator(h_deriv: npt.NDArray, psi: npt.NDArray) -> npt.NDArray:
+    return psi.conj().T @ h_deriv @ psi
+
+
+def _fermi_dirac(energy: float, beta: float) -> float:
+    return 1.0 / (np.exp(beta * energy) + 1.0)
+
+
+def _fermi_dirac_derivative(energy: float, beta: float) -> float:
+    f = _fermi_dirac(energy, beta)
+    return -beta * f * (1 - f)

quant_met/cli/__init__.py

@@ -1,8 +1,3 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """
 Command-Line-Interface
 ======================

quant_met/cli/crit_temp.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 routines
 from quant_met.parameters import Parameters
-
-from ._utils import _hamiltonian_factory
+from quant_met.parameters.control import CritTemp
 
 logger = logging.getLogger(__name__)
 
@@ -27,18 +23,26 @@ def crit_temp(parameters: Parameters) -> None:
         An instance of Parameters containing control settings, the model,
         and k-point specifications for the T_C calculation.
     """
+    if not isinstance(parameters.control, CritTemp):
+        err_msg = "Wrong parameters for crit-temp."
+        raise TypeError(err_msg)
+
     result_path = Path(parameters.control.outdir)
     result_path.mkdir(exist_ok=True, parents=True)
 
-    h = _hamiltonian_factory(parameters=parameters.model, classname=parameters.model.name)
+    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],
+    )
 
-    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
-        ),
+    delta_vs_temp, critical_temperatures, fit_fig = routines.search_crit_temp(
+        hamiltonian=hamiltonian,
+        kgrid=k_grid_obj,
+        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),
         n_temp_points=parameters.control.n_temp_points,
     )
 
@@ -55,7 +59,5 @@ def crit_temp(parameters: Parameters) -> None:
     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

@@ -1,8 +1,3 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-# SPDX-FileCopyrightText: 2025 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """Command line interface."""
 
 import logging
@@ -15,6 +10,8 @@ import yaml
 from quant_met.parameters import Parameters
 
 from .crit_temp import crit_temp
+from .q_analysis import q_analysis
+from .q_loop import q_loop
 from .scf import scf
 
 logger = logging.getLogger(__name__)
@@ -61,6 +58,12 @@ def cli(input_file: TextIO, *, debug: bool) -> None:
         case "crit-temp":
             logger.info("Starting T_C calculation.")
             crit_temp(params)
+        case "q-loop":
+            logger.info("Starting q-loop calculation.")
+            q_loop(params)
+        case "q-analysis":
+            logger.info("Starting analysis of q data.")
+            q_analysis(params)
         case _:
             logger.error("Calculation %s not found.", params.control.calculation)
             sys.exit(1)

quant_met/cli/q_analysis.py

@@ -0,0 +1,60 @@
+"""Functions to run self-consistent calculation for the order parameter."""
+
+import logging
+from pathlib import Path
+
+import h5py
+import pandas as pd
+import sisl
+
+from quant_met import routines
+from quant_met.parameters import Parameters
+from quant_met.parameters.control import QAnalysis
+
+logger = logging.getLogger(__name__)
+
+
+def q_analysis(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.
+    """
+    if not isinstance(parameters.control, QAnalysis):
+        err_msg = "Wrong parameters for q-loop."
+        raise TypeError(err_msg)
+
+    q_data: dict[str, pd.DataFrame] = {}
+    with h5py.File(f"{parameters.control.q_data}") as f:
+        for key in f:
+            q_data.update({key: pd.DataFrame()})
+
+    for key in q_data:
+        data: pd.DataFrame = pd.read_hdf(f"{parameters.control.q_data}", key=key)
+        q_data[key] = data
+
+    hamiltonian = sisl.get_sile(parameters.control.hamiltonian_file).read_hamiltonian()
+
+    (
+        lengths_vs_temp,
+        gap_and_current_fig,
+    ) = routines.get_lengths_vs_temp(q_data=q_data, hamiltonian=hamiltonian)
+
+    result_file = Path(f"{parameters.control.outdir}/{parameters.control.prefix}_sc_lengths.hdf5")
+    result_file.unlink()
+    lengths_vs_temp.to_hdf(result_file, key="lengths_vs_temp")
+    gap_and_current_fig.savefig(
+        f"{parameters.control.outdir}/{parameters.control.prefix}_gap_and_current_vs_q.pdf",
+    )
+
+    zero_temp_lengths, length_vs_temp_fig = routines.get_zero_temperature_values(
+        hamiltonian=hamiltonian,
+        lengths_vs_temp=lengths_vs_temp,
+    )
+    zero_temp_lengths.to_hdf(result_file, key="zero_temp_lengths")
+    length_vs_temp_fig.savefig(
+        f"{parameters.control.outdir}/{parameters.control.prefix}_lengths_vs_temperature.pdf",
+    )

quant_met/cli/q_loop.py

@@ -0,0 +1,95 @@
+"""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 routines
+from quant_met.parameters import Parameters
+from quant_met.parameters.control import CritTemp, QLoop
+
+logger = logging.getLogger(__name__)
+
+
+def q_loop(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.
+    """
+    if not isinstance(parameters.control, QLoop):
+        err_msg = "Wrong parameters for q-loop."
+        raise TypeError(err_msg)
+
+    result_path = Path(parameters.control.outdir)
+    result_path.mkdir(exist_ok=True, parents=True)
+
+    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],
+    )
+
+    if isinstance(parameters.control.crit_temp, CritTemp):
+        delta_vs_temp, critical_temperatures, fit_fig = routines.search_crit_temp(
+            hamiltonian=hamiltonian,
+            kgrid=k_grid_obj,
+            hubbard_int_orbital_basis=np.array(parameters.control.crit_temp.hubbard_int_orbital_basis),
+            epsilon=parameters.control.crit_temp.conv_treshold,
+            max_iter=parameters.control.crit_temp.max_iter,
+            n_temp_points=20,
+        )
+        logger.info("Search for T_C completed successfully.")
+        logger.info("Obtained T_Cs: %s", critical_temperatures)
+
+        fit_fig.savefig(
+            result_path / f"{parameters.control.crit_temp.prefix}_critical_temperatures_fit.pdf",
+            bbox_inches="tight",
+        )
+
+        result_file_crit_temp = (
+            result_path / f"{parameters.control.crit_temp.prefix}_critical_temperatures.hdf5"
+        )
+        if result_file_crit_temp.exists():
+            result_file_crit_temp.exists()
+        delta_vs_temp.to_hdf(result_file_crit_temp, key="delta_vs_temp")
+        with h5py.File(result_file_crit_temp, 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_crit_temp)
+    else:
+        critical_temperatures = []
+        with h5py.File(f"{parameters.control.crit_temp}", mode="r") as file:
+            for key, critical_temperature in file.attrs.items():
+                if key.startswith("T_C"):
+                    critical_temperatures.append(critical_temperature)
+        logger.info("Read critical temperatures from file.")
+        logger.info("Obtained T_Cs: %s", critical_temperatures)
+
+    delta_vs_q = routines.loop_over_q(
+        hamiltonian=hamiltonian,
+        kgrid=k_grid_obj,
+        hubbard_int_orbital_basis=np.array(parameters.control.hubbard_int_orbital_basis),
+        epsilon=parameters.control.conv_treshold,
+        max_iter=parameters.control.max_iter,
+        n_q_points=parameters.control.n_q_points,
+        crit_temps=np.array(critical_temperatures),
+    )
+
+    result_file_q = result_path / f"{parameters.control.prefix}_q.hdf5"
+
+    if result_file_q.exists():
+        result_file_q.unlink()
+    for key, df in delta_vs_q.items():
+        df.to_hdf(result_file_q, key=f"temp_{float(key):.6f}")
+        with h5py.File(result_file_q, "a") as f:
+            grp = f[f"temp_{float(key):.6f}"]
+            grp.attrs["crit_temp"] = critical_temperatures
+            grp.attrs["temp"] = float(key)