quant-met 0.0.26__py3-none-any.whl → 0.1.0__py3-none-any.whl

quant_met/routines/loop_over_q.py

@@ -0,0 +1,154 @@
+"""Function to run search for critical temperature."""
+
+import logging
+from functools import partial
+from multiprocessing import Pool
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+import sisl
+
+from quant_met import bdg
+
+from .self_consistency import self_consistency_loop
+
+logger = logging.getLogger(__name__)
+
+MAX_Q = 0.5
+
+
+def is_gap_zero(result: dict[str, float], atol: float = 1e-8) -> bool:
+    """Check if all delta values in result are (approximately) zero."""
+    deltas = np.array([x for key, x in result.items() if key.startswith("delta")])
+    return np.isclose(np.max(np.abs(deltas)), 0, atol=atol)
+
+
+def adjust_q_upper_bound(
+    gap_for_q_partial: partial[dict[str, Any] | None], initial_q: float = 0.5
+) -> float:
+    """
+    Adjust q_upper_bound until gap is non-zero or exceeds upper limit.
+
+    Returns the adjusted q_upper_bound.
+    """
+    q_upper_bound = initial_q
+
+    while True:
+        result_tmp: dict[str, float] | None = gap_for_q_partial(q_upper_bound)
+
+        if result_tmp is None or is_gap_zero(result_tmp):
+            q_upper_bound /= 2
+        else:
+            break
+
+    while True:
+        result_tmp = gap_for_q_partial(q_upper_bound)
+
+        if result_tmp is None or is_gap_zero(result_tmp):
+            q_upper_bound *= 1.1
+            if q_upper_bound > MAX_Q:
+                break
+        else:
+            break
+
+    return q_upper_bound
+
+
+def _gap_for_q(  # noqa: PLR0913
+    q_fraction: float,
+    hamiltonian: sisl.Hamiltonian,
+    kgrid: sisl.MonkhorstPack,
+    hubbard_int_orbital_basis: npt.NDArray[np.float64],
+    epsilon: float,
+    temp: float,
+    max_iter: int = 1000,
+) -> dict[str, Any] | None:  # pragma: no cover
+    beta = np.inf if temp == 0 else 1 / temp
+    q = q_fraction * hamiltonian.geometry.rcell[0]
+    data_dict: dict[str, Any] = {
+        "q_fraction": q_fraction,
+    }
+    try:
+        gap = self_consistency_loop(
+            hamiltonian=hamiltonian,
+            kgrid=kgrid,
+            beta=beta,
+            hubbard_int_orbital_basis=hubbard_int_orbital_basis,
+            epsilon=epsilon,
+            max_iter=max_iter,
+            q=q,
+        )
+    except RuntimeError:
+        logger.exception("Did not converge.")
+        return None
+    else:
+        bdg_energies, bdg_wavefunctions = bdg.diagonalize_bdg(
+            hamiltonian=hamiltonian,
+            kgrid=kgrid,
+            delta_orbital_basis=gap,
+            q=q,
+        )
+        current = bdg.calculate_current_density(
+            hamiltonian=hamiltonian,
+            k=kgrid,
+            bdg_energies=bdg_energies,
+            bdg_wavefunctions=bdg_wavefunctions,
+            beta=beta,
+        )
+        data_dict.update({f"delta_{orbital}": gap[orbital] for orbital in range(len(gap))})
+        data_dict.update(
+            {
+                "current_x": current[0],
+                "current_y": current[1],
+                "current_abs": np.linalg.norm(current),
+            },
+        )
+        return data_dict
+
+
+def loop_over_q(  # noqa: PLR0913
+    hamiltonian: sisl.Hamiltonian,
+    kgrid: sisl.MonkhorstPack,
+    hubbard_int_orbital_basis: npt.NDArray[np.float64],
+    epsilon: float,
+    max_iter: int,
+    n_q_points: int,
+    crit_temps: npt.NDArray[np.float64],
+) -> dict[str, pd.DataFrame]:  # pragma: no cover
+    """Loop over q."""
+    logger.info("Start search for upper bound for q.")
+
+    crit_temp = np.max(crit_temps)
+    temp_list = [crit_temp * x for x in [0.65, 0.7, 0.75, 0.8, 0.85, 0.87, 0.89, 0.91, 0.93, 0.95]]
+
+    delta_vs_q = {}
+    for temp in temp_list:
+        gap_for_q_partial = partial(
+            _gap_for_q,
+            hamiltonian=hamiltonian,
+            kgrid=kgrid,
+            hubbard_int_orbital_basis=hubbard_int_orbital_basis,
+            epsilon=epsilon,
+            max_iter=max_iter,
+            temp=temp,
+        )
+        q_upper_bound = adjust_q_upper_bound(gap_for_q_partial, initial_q=0.5)
+        logger.info("q upper bound: %s", q_upper_bound)
+
+        q_list = np.linspace(
+            0,
+            q_upper_bound,
+            num=n_q_points,
+        )
+
+        with Pool() as p:
+            delta_vs_q_list = [x for x in p.map(gap_for_q_partial, q_list) if x is not None]  # type: ignore[arg-type]
+
+        delta_vs_q_tmp = (
+            pd.DataFrame(delta_vs_q_list).sort_values(by=["q_fraction"]).reset_index(drop=True)
+        )
+        delta_vs_q[f"{temp}"] = delta_vs_q_tmp
+
+    return delta_vs_q

quant_met/{mean_field → routines}/search_crit_temp.py

@@ -1,7 +1,3 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """Function to run search for critical temperature."""
 
 import logging
@@ -14,16 +10,16 @@ import matplotlib.pyplot as plt
 import numpy as np
 import numpy.typing as npt
 import pandas as pd
+import sisl
 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__)
 
+MIN_NUMBER_OF_T_POINTS_FITTING = 4
+MAX_ITERATIONS_GET_BOUNDS = 100
+
 
 def _get_bounds(
     initial_temp: float,
@@ -37,7 +33,9 @@ def _get_bounds(
     temp = initial_temp
     direction = "down"
     iterations = 0
-    while (found_zero_gap and found_nonzero_gap) is False and iterations < 100:
+    while (
+        found_zero_gap and found_nonzero_gap
+    ) is False and iterations < MAX_ITERATIONS_GET_BOUNDS:
         logger.info("Trying temperature: %s", temp)
         data_dict = gap_for_temp_partial(temp)
         logger.info("Result: %s", data_dict)
@@ -50,7 +48,9 @@ def _get_bounds(
                 found_zero_gap = True
                 temp = 0.5 * temp
             elif np.allclose(
-                gap, zero_temperature_gap, atol=0.10 * np.max(np.abs(zero_temperature_gap))
+                gap,
+                zero_temperature_gap,
+                atol=0.10 * np.max(np.abs(zero_temperature_gap)),
             ):
                 logger.info("Found temperature with nonzero gap.")
                 nonzero_gap_temp = temp
@@ -61,7 +61,7 @@ def _get_bounds(
                 temp = 0.5 * temp
             else:
                 logger.info(
-                    "Gap is neither zero nor equal to the zero gap. Increasing temperature."
+                    "Gap is neither zero nor equal to the zero gap. Increasing temperature.",
                 )
                 temp = 2 * temp
         elif direction == "down":
@@ -85,7 +85,8 @@ def _get_bounds(
 
 
 def _fit_for_crit_temp(
-    delta_vs_temp: pd.DataFrame, orbital: int
+    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(
@@ -103,21 +104,22 @@ def _fit_for_crit_temp(
                         rtol=1e-2,
                         atol=0,
                     ),
-                )
-            )
+                ),
+            ),
         )
     ]
 
     err = []
-    if len(filtered_results) <= 4:
+    if len(filtered_results) <= MIN_NUMBER_OF_T_POINTS_FITTING:
         return None, filtered_results, None, None
 
-    lengths = range(4, len(filtered_results))
+    lengths = range(MIN_NUMBER_OF_T_POINTS_FITTING, 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
+            range_results["T"],
+            np.abs(range_results[f"delta_{orbital}"]) ** 2,
         )
         err.append(linreg.stderr)
 
@@ -128,64 +130,83 @@ def _fit_for_crit_temp(
     return range_results, filtered_results, linreg.intercept, linreg.slope
 
 
-def _gap_for_temp(
+def _gap_for_temp(  # noqa: PLR0913
     temp: float,
-    h: BaseHamiltonian[GenericParameters],
-    k_space_grid: npt.NDArray[np.floating],
+    hamiltonian: sisl.Hamiltonian,
+    kgrid: sisl.MonkhorstPack,
+    hubbard_int_orbital_basis: npt.NDArray[np.float64],
     epsilon: float,
     max_iter: int = 1000,
+    delta_init: npt.NDArray[np.complex128] | None = None,
+    q: npt.NDArray[np.float64] | None = None,
 ) -> 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)
+        gap = self_consistency_loop(
+            hamiltonian=hamiltonian,
+            kgrid=kgrid,
+            beta=beta,
+            hubbard_int_orbital_basis=hubbard_int_orbital_basis,
+            epsilon=epsilon,
+            max_iter=max_iter,
+            delta_init=delta_init,
+            q=q,
+        )
     except RuntimeError:
         logger.exception("Did not converge.")
         return None
     else:
-        data_dict = {
+        data_dict: dict[str, Any] = {
             "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))
-            }
-        )
+        data_dict.update({f"delta_{orbital}": gap[orbital] for orbital in range(len(gap))})
         return data_dict
 
 
-def search_crit_temp(
-    h: BaseHamiltonian[GenericParameters],
-    k_space_grid: npt.NDArray[np.floating],
+def search_crit_temp(  # noqa: PLR0913
+    hamiltonian: sisl.Hamiltonian,
+    kgrid: sisl.MonkhorstPack,
+    hubbard_int_orbital_basis: npt.NDArray[np.float64],
     epsilon: float,
     max_iter: int,
     n_temp_points: int,
+    q: npt.NDArray[np.float64] | None = None,
+    beta_init: float | None = None,
 ) -> 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 10 * h.hubbard_int_orbital_basis[0]
+    beta = 10 * hubbard_int_orbital_basis[0] if beta_init is None else beta_init
+    temp = 1 / beta if not np.isinf(beta) else 1e-8
 
     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
+        _gap_for_temp,
+        hamiltonian=hamiltonian,
+        kgrid=kgrid,
+        hubbard_int_orbital_basis=hubbard_int_orbital_basis,
+        epsilon=epsilon,
+        max_iter=max_iter,
+        q=q,
     )
 
     logger.info("Calculating zero temperature gap")
     data_dict = gap_for_temp_partial(0)
-    assert data_dict is not None
+    if data_dict is None:
+        err_msg = "Calculation for T = 0 did not converge."
+        raise ValueError(err_msg)
     logger.info("Result: %s", data_dict)
 
     zero_temperature_gap = np.array(
-        [data_dict[key] for key in data_dict if key.startswith("delta")]
+        [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
+        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)
@@ -199,12 +220,18 @@ def search_crit_temp(
                 endpoint=False,
             ),
             np.linspace(
-                nonzero_gap_temp, zero_gap_temp, num=int(0.9 * n_temp_points), endpoint=False
+                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
+                zero_gap_temp,
+                1.2 * zero_gap_temp,
+                num=int(0.05 * n_temp_points),
+                endpoint=True,
             ),
-        ]
+        ],
     )
 
     with Pool() as p:
@@ -213,14 +240,12 @@ def search_crit_temp(
 
     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)
-    )
+    fit_fig, fit_axs = plt.subplots(nrows=1, ncols=hamiltonian.no, figsize=(hamiltonian.no * 6, 6))
 
-    for orbital in range(h.number_of_bands):
+    for orbital in range(hamiltonian.no):
         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]
+        ax = fit_axs if hamiltonian.no == 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
@@ -248,7 +273,6 @@ def search_crit_temp(
             "--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 → routines}/self_consistency.py

@@ -1,27 +1,27 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """Self-consistency loop."""
 
 import logging
 
 import numpy as np
 import numpy.typing as npt
+import sisl
+from numpy import complexfloating, dtype, ndarray
 
-from quant_met.mean_field.hamiltonians.base_hamiltonian import BaseHamiltonian
-from quant_met.parameters import GenericParameters
+from quant_met.bdg import gap_equation
 
 logger = logging.getLogger(__name__)
 
 
-def self_consistency_loop(
-    h: BaseHamiltonian[GenericParameters],
-    k_space_grid: npt.NDArray[np.floating],
+def self_consistency_loop(  # noqa: PLR0913
+    hamiltonian: sisl.Hamiltonian,
+    kgrid: sisl.MonkhorstPack,
+    beta: float,
+    hubbard_int_orbital_basis: npt.NDArray[np.float64],
     epsilon: float,
     max_iter: int = 1000,
     delta_init: npt.NDArray[np.complex128] | None = None,
-) -> BaseHamiltonian[GenericParameters]:
+    q: npt.NDArray[np.float64] | None = None,
+) -> ndarray[tuple[int, ...], dtype[complexfloating]]:
     """Self-consistently solves the gap equation for a given Hamiltonian.
 
     This function performs a self-consistency loop to solve the gap equation
@@ -31,11 +31,12 @@ def self_consistency_loop(
 
     Parameters
     ----------
-    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.
+    q
+    kgrid
+    hubbard_int_orbital_basis
+    beta
+    hamiltonian : sisl.Hamiltonian
+        The Hamiltonian object.
 
     epsilon : float
         The convergence criterion. The loop will terminate when the change
@@ -63,12 +64,12 @@ def self_consistency_loop(
 
     if delta_init is None:
         rng = np.random.default_rng()
-        delta_init = np.zeros(shape=h.delta_orbital_basis.shape, dtype=np.complex128)
-        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
+        delta_init = np.zeros(shape=hamiltonian.no, dtype=np.complex128)
+        delta_init += (0.2 * rng.random(size=hamiltonian.no) - 1) + 1.0j * (
+            0.2 * rng.random(size=hamiltonian.no) - 1
         )
-    h.delta_orbital_basis = delta_init  # type: ignore[assignment]
-    logger.debug("Initial gaps set to: %s", h.delta_orbital_basis)
+    logger.debug("Initial gaps set to: %s", delta_init)
+    delta = delta_init
 
     iteration_count = 0
     while True:
@@ -79,16 +80,20 @@ def self_consistency_loop(
 
         logger.debug("Iteration %d: Computing new gaps.", iteration_count)
 
-        new_gap = h.gap_equation(k=k_space_grid)
+        new_gap = gap_equation(
+            hamiltonian=hamiltonian,
+            kgrid=kgrid,
+            q=q,
+            beta=beta,
+            hubbard_int_orbital_basis=hubbard_int_orbital_basis,
+            delta_orbital_basis=delta,
+        )
 
         logger.debug("New gaps computed: %s", new_gap)
 
-        if np.allclose(h.delta_orbital_basis, new_gap, atol=1e-10, rtol=epsilon):
-            h.delta_orbital_basis = new_gap  # type: ignore[assignment]
+        if np.allclose(delta, new_gap, atol=1e-10, rtol=epsilon):
             logger.info("Convergence achieved after %d iterations.", iteration_count)
-            return h
+            return new_gap
 
         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", np.abs(h.delta_orbital_basis - new_gap))
+        delta = mixing_greed * new_gap + (1 - mixing_greed) * delta

quant_met/utils.py

@@ -1,7 +1,3 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
 """
 Utility functions (:mod:`quant_met.utils`)
 ==========================================
@@ -66,7 +62,7 @@ def generate_uniform_grid(
                 num=ncols,
             )
             for i in range(nrows)
-        ]
+        ],
     )
 
     return grid

{quant_met-0.0.26.dist-info → quant_met-0.1.0.dist-info}/METADATA

@@ -1,35 +1,31 @@
 Metadata-Version: 2.4
 Name: quant-met
-Version: 0.0.26
+Version: 0.1.0
 Summary: Calculate superconductivity in flat-band systems.
-Author-email: Tjark Sievers <tsievers@physnet.uni-hamburg.de>
+Author-email: Tjark Sievers <tjarksievers@icloud.com>
 License-File: LICENSE.txt
 Requires-Python: >=3.11
 Requires-Dist: click>=8.1.8
 Requires-Dist: h5py>=3.12.1
 Requires-Dist: matplotlib>=3.10.0
-Requires-Dist: numba>=0.60.0
-Requires-Dist: numpy<2.1
-Requires-Dist: numpydantic>=1.6.6
+Requires-Dist: numba>=0.61.0
+Requires-Dist: numpy>=2.1
+Requires-Dist: numpydantic>=1.6.8
 Requires-Dist: pandas>=2.2.3
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: scipy>=1.15.0
+Requires-Dist: sisl[viz]>0.16.0
 Requires-Dist: tables>=3.10.2
+Requires-Dist: tbmodels>=1.4.3
 Description-Content-Type: text/markdown
 
-<!--
-SPDX-FileCopyrightText: 2024 Tjark Sievers
-
-SPDX-License-Identifier: MIT
--->
 
 # quant-met
 
 [![DOI](https://zenodo.org/badge/800628635.svg)](https://zenodo.org/badge/latestdoi/800628635)
 [![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 is a python package to treat superconductivity in flat-band systems.

quant_met-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+quant_met/__init__.py,sha256=9WVEpcOuJ6ObayeK9u9Vkm2D-iPyb5Olc4PZdLWPORk,186
+quant_met/utils.py,sha256=pr-J_ElUDKxmSdErxsz4Eclvojoejbaup-Fg12QKMVQ,1989
+quant_met/bdg/__init__.py,sha256=RHxvGyCTDeK4vlIm807K9wJkLOI0jGA3ibuq0YRfo74,605
+quant_met/bdg/bdg_hamiltonian.py,sha256=6zKW_a7XVXYk61RFvJjp_av4Gh7KSMqLUV1Ir8iS1sY,2708
+quant_met/bdg/gap_equation.py,sha256=VyGbQxNxjbUkp-NHzGs3-5vejc6CcBfvmtXREWRS3eI,3372
+quant_met/bdg/sc_current.py,sha256=fRX4KH1J7IY1T8Oxrpd_0RJd8fvPDNeP3yCg-UwRLpI,1840
+quant_met/bdg/superfluid_weight.py,sha256=rLS6fK41Pt8aXxPL0KNVvK0dMWwYdbZ0eAqBEoGvAQ8,4207
+quant_met/cli/__init__.py,sha256=11q_R4KoAKZy2EOuUgnAn4GxbS9yyTA6nSjKpDl-UjI,175
+quant_met/cli/crit_temp.py,sha256=l4jPXY07z75FD7xgACrj_C2B3t3xX-yQeWlcnkEGIAA,2179
+quant_met/cli/main.py,sha256=DNgXguBfVpp-pddmN-RKePeO1R2Dsr_b97BKei1MMG0,2074
+quant_met/cli/q_analysis.py,sha256=H-3o-of_xEv3c1uUqtREGKroY-pk8Yu7RWXmLxi0xpU,1986
+quant_met/cli/q_loop.py,sha256=6T01sS65pzqOwLx5gymC-6kbEa3XJjGerujfkB4D1cQ,3524
+quant_met/cli/scf.py,sha256=jpFoIpC0ghf48lK7SfNeTXXADEtyCzv6kzyMvdcBF1Y,3283
+quant_met/parameters/__init__.py,sha256=d1XBoH8siW0fNRz5I8tpI2-JQfiSjadFBcmQANV97Zk,448
+quant_met/parameters/control.py,sha256=ZxtAf35Gnb2LwooazcFrdb1d2b_sipGHIUtF5bZwTIg,1384
+quant_met/parameters/main.py,sha256=P0o7f4o2woHNtLEqYJnO7dXdKEX3t_dsCky8-Sr_W88,977
+quant_met/quantum_geometry/__init__.py,sha256=RMD7pNHPFAJuOtUfNiV4XssA1RjL6h1eZBsh76Fc-8Y,185
+quant_met/quantum_geometry/qgt.py,sha256=jdYUxBOeKYYR96Zex2xIVOVCsT11HZ1NVrUBmmjTlLY,1358
+quant_met/routines/__init__.py,sha256=a8xHRD6j4v8lkrwGSzwmj4BHUg2tgTN0Hp0Vpu4863Y,479
+quant_met/routines/analyse_q_data.py,sha256=8q32GBB2ftYgdjWJ1_EpvcNJO9_Fn1kfKSaWLhIAJeY,8409
+quant_met/routines/loop_over_q.py,sha256=3yYhCf_Xo7ziT5Pj4HmLDvvq8crbb7-MdJOjmyluYao,4460
+quant_met/routines/search_crit_temp.py,sha256=phK2pJTibj8sgtxOghEJkurbG4xt2LRq23MTdfwygAE,9598
+quant_met/routines/self_consistency.py,sha256=nb-gRzyEd24kc6ZU2O53ov07Zg3pN6wSz-9jjo68RCM,3071
+quant_met-0.1.0.dist-info/METADATA,sha256=Eos9y8wuLVX9JdvRwf5QXAnD8XDgL22NpRd9MCSwDXo,1837
+quant_met-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+quant_met-0.1.0.dist-info/entry_points.txt,sha256=1Al3Kt-cMeQxwMp84ZSNL0qFwlbOVBu1o8A19MH8lEU,48
+quant_met-0.1.0.dist-info/licenses/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.1.0.dist-info/RECORD,,

quant_met/cli/_utils.py

@@ -1,66 +0,0 @@
-# SPDX-FileCopyrightText: 2024 Tjark Sievers
-#
-# SPDX-License-Identifier: MIT
-
-import numpy as np
-from triqs.lattice.tight_binding import TBLattice
-
-from quant_met.mean_field.hamiltonians import BaseHamiltonian
-from quant_met.parameters import GenericParameters, 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
-
-
-def _tbl_factory(h: BaseHamiltonian[GenericParameters]) -> TBLattice:
-    lattice_constant = np.sqrt(3)
-
-    basis_vectors = [
-        0.5 * lattice_constant * np.array([1, np.sqrt(3), 0]),
-        0.5 * lattice_constant * np.array([1, -np.sqrt(3), 0]),
-    ]
-    orbital_positions = [
-        (0.5 * (np.sqrt(3) - 1), 0, 0),
-        (0.5 * (np.sqrt(3) + 1), 0, 0),
-        (0.5 * (np.sqrt(3) - 1), 0, 0),
-    ]
-    hoppings = {
-        (0, 0): [
-            [0, h.hopping_gr, h.hopping_x_gr_a],
-            [h.hopping_gr, 0, 0],
-            [h.hopping_x_gr_a, 0, 0],
-        ],
-        (1, 0): [[0, 0, 0], [h.hopping_gr, 0, 0], [0, 0, 0]],
-        (-1, 0): [[0, h.hopping_gr, 0], [0, 0, 0], [0, 0, 0]],
-        (0, 1): [[0, h.hopping_gr, 0], [0, 0, 0], [0, 0, 0]],
-        (0, -1): [[0, 0, 0], [h.hopping_gr, 0, 0], [0, 0, 0]],
-    }
-
-    return TBLattice(
-        units=basis_vectors,
-        hoppings=hoppings,
-        orbital_positions=orbital_positions,
-        orbital_names=["A", "B", "X"],
-    )