quant-met 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

quant_met-0.0.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+quant_met/__init__.py,sha256=ZO1UFz1awUYTI7B9ZkBwucvDz7GMGXnLLUGnEwLBhkc,155
+quant_met/mean_field/__init__.py,sha256=kBkGItunNits1SrSMRIfKkqeSXvzbUJQS-OkcV-0zmc,1136
+quant_met/mean_field/_utils.py,sha256=plkx6eYjyYV3CT3BWwlulqW7L-Q0t1TzZTLR4k7u0dg,666
+quant_met/mean_field/base_hamiltonian.py,sha256=YvuUD_RxZVS7yWIJrkylbaOieslz86zrQa7gRWM-6ow,8505
+quant_met/mean_field/eg_x.py,sha256=hv4gTOnqfLAi_OR3uSZlzph-vrRqnhnCqz3_qJzY8nw,4003
+quant_met/mean_field/free_energy.py,sha256=FSGCHoBO1myHGwGQ8CqGu7_08whH0Ot3ikZhBu27tyM,3444
+quant_met/mean_field/graphene.py,sha256=lR_T7TdJiBA_8leG6aUQ4hllxKnjI5qsLVCUUKU-jpw,3025
+quant_met/mean_field/quantum_metric.py,sha256=ohTs1IzReXFMj03QOKlvlenM94VJjmyAyd4KicHL5gI,2002
+quant_met/mean_field/superfluid_weight.py,sha256=egW9f3zR_NC5hLTNOdw_GA3fsKOE-L45LDSze2eGcoY,4899
+quant_met/plotting/__init__.py,sha256=QRQ3TNb0PNQi2lWXY0LHKgYSRuegM1N3dVVs9146Zug,457
+quant_met/plotting/plotting.py,sha256=iVTFZ9tQz_GalzqbQhxCiNWOhYHJM4wiZPTjXaXnApM,7326
+quant_met/utils.py,sha256=Tvw_YfqjIWx0FPGSReikSnw9xfN-T2dpQZN-KPMa69A,1709
+quant_met-0.0.3.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.3.dist-info/LICENSES/MIT.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
+quant_met-0.0.3.dist-info/METADATA,sha256=dB9mP1Ytt6ptRbse_R2-8TcNKFWzUJVe0tMsqIQPReI,2598
+quant_met-0.0.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+quant_met-0.0.3.dist-info/RECORD,,

quant_met/hamiltonians/__init__.py

@@ -1,14 +0,0 @@
-from ._base_hamiltonian import BaseHamiltonian
-from ._eg_x import EGXHamiltonian
-from ._free_energy import free_energy, free_energy_uniform_pairing
-from ._graphene import GrapheneHamiltonian
-from ._superfluid_weight import calculate_superfluid_weight
-
-__all__ = [
-    "BaseHamiltonian",
-    "GrapheneHamiltonian",
-    "EGXHamiltonian",
-    "calculate_superfluid_weight",
-    "free_energy",
-    "free_energy_uniform_pairing",
-]

quant_met/hamiltonians/_eg_x.py

@@ -1,124 +0,0 @@
-import numpy as np
-import numpy.typing as npt
-
-from ._base_hamiltonian import BaseHamiltonian
-from ._utils import _check_valid_float
-
-
-class EGXHamiltonian(BaseHamiltonian):
-    def __init__(
-        self,
-        t_gr: float,
-        t_x: float,
-        V: float,
-        a: float,
-        mu: float,
-        U_gr: float,
-        U_x: float,
-        delta: npt.NDArray[np.float64] | None = None,
-    ):
-        self.t_gr = _check_valid_float(t_gr, "Hopping graphene")
-        self.t_x = _check_valid_float(t_x, "Hopping impurity")
-        self.V = _check_valid_float(V, "Hybridisation")
-        self.a = _check_valid_float(a, "Lattice constant")
-        self.mu = _check_valid_float(mu, "Chemical potential")
-        self.U_gr = _check_valid_float(U_gr, "Coloumb interaction graphene")
-        self.U_x = _check_valid_float(U_x, "Coloumb interaction impurity")
-        if delta is None:
-            self._delta_orbital_basis = np.zeros(3)
-        else:
-            self._delta_orbital_basis = delta
-
-    @property
-    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:
-        return np.array([self.U_gr, self.U_gr, self.U_x])
-
-    @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.float64]:
-        return self._delta_orbital_basis
-
-    @delta_orbital_basis.setter
-    def delta_orbital_basis(self, new_delta: npt.NDArray[np.float64]) -> None:
-        self._delta_orbital_basis = new_delta
-
-    @property
-    def number_of_bands(self) -> int:
-        return 3
-
-    def _hamiltonian_derivative_one_point(
-        self, k: npt.NDArray[np.float64], direction: str
-    ) -> npt.NDArray[np.complex64]:
-        assert direction in ["x", "y"]
-
-        t_gr = self.t_gr
-        t_x = self.t_x
-        a = self.a
-
-        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
-
-        if direction == "x":
-            h[0, 1] = (
-                t_gr
-                * a
-                * np.exp(-0.5j * a / np.sqrt(3) * k[1])
-                * np.sin(0.5 * a * k[0])
-            )
-            h[1, 0] = h[0, 1].conjugate()
-            h[2, 2] = (
-                2
-                * a
-                * t_x
-                * (
-                    np.sin(a * k[0])
-                    + np.sin(0.5 * a * k[0]) * np.cos(0.5 * np.sqrt(3) * a * k[1])
-                )
-            )
-        else:
-            h[0, 1] = (
-                -t_gr
-                * 1j
-                * a
-                / np.sqrt(3)
-                * (
-                    np.exp(1j * a / np.sqrt(3) * k[1])
-                    - np.exp(-0.5j * a / np.sqrt(3) * k[1]) * np.cos(0.5 * a * k[0])
-                )
-            )
-            h[1, 0] = h[0, 1].conjugate()
-            h[2, 2] = np.sqrt(3) * a * t_x * np.cos(0.5 * np.sqrt(3) * a * k[1])
-
-        return h
-
-    def _hamiltonian_one_point(
-        self, k: npt.NDArray[np.float64]
-    ) -> npt.NDArray[np.complex64]:
-        t_gr = self.t_gr
-        t_x = self.t_x
-        a = self.a
-        # a_0 = a / np.sqrt(3)
-        V = self.V
-        mu = self.mu
-
-        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
-
-        h[0, 1] = -t_gr * (
-            np.exp(1j * k[1] * a / np.sqrt(3))
-            + 2 * np.exp(-0.5j * a / np.sqrt(3) * k[1]) * (np.cos(0.5 * a * k[0]))
-        )
-
-        h[1, 0] = h[0, 1].conjugate()
-
-        h[2, 0] = V
-        h[0, 2] = V
-
-        h[2, 2] = (
-            -2
-            * t_x
-            * (
-                np.cos(a * k[0])
-                + 2 * np.cos(0.5 * a * k[0]) * np.cos(0.5 * np.sqrt(3) * a * k[1])
-            )
-        )
-        h -= mu * np.eye(3, dtype=np.complex64)
-
-        return h

quant_met/hamiltonians/_free_energy.py

@@ -1,39 +0,0 @@
-import numpy as np
-import numpy.typing as npt
-
-from ._base_hamiltonian import BaseHamiltonian
-
-
-def free_energy(
-    delta_vector: npt.NDArray[np.float64],
-    hamiltonian: BaseHamiltonian,
-    k_points: npt.NDArray[np.float64],
-) -> float:
-    number_k_points = len(k_points)
-    hamiltonian.delta_orbital_basis = delta_vector
-    bdg_energies, _ = hamiltonian.diagonalize_bdg(k_points)
-
-    k_array = np.array(
-        [
-            np.sum(np.abs(bdg_energies[k_index][0 : hamiltonian.number_of_bands]))
-            for k_index in range(number_k_points)
-        ]
-    )
-
-    integral: float = -np.sum(k_array, axis=-1) / number_k_points + np.sum(
-        np.power(np.abs(delta_vector), 2) / hamiltonian.coloumb_orbital_basis
-    )
-
-    return integral
-
-
-def free_energy_uniform_pairing(
-    delta: float,
-    hamiltonian: BaseHamiltonian,
-    k_points: npt.NDArray[np.float64],
-) -> float:
-    delta_vector = np.ones(hamiltonian.number_of_bands) * delta
-
-    return free_energy(
-        delta_vector=delta_vector, hamiltonian=hamiltonian, k_points=k_points
-    )

quant_met/hamiltonians/_utils.py

@@ -1,10 +0,0 @@
-import numpy as np
-
-
-def _check_valid_float(float_in: float, parameter_name: str) -> float:
-    if np.isinf(float_in):
-        raise ValueError(f"{parameter_name} must not be Infinity")
-    elif np.isnan(float_in):
-        raise ValueError(f"{parameter_name} must not be NaN")
-    else:
-        return float_in

quant_met/plotting/_plotting.py

@@ -1,156 +0,0 @@
-from typing import Any, List, Tuple
-
-import matplotlib.axes
-import matplotlib.colors
-import matplotlib.figure
-import matplotlib.pyplot as plt
-import numpy as np
-import numpy.typing as npt
-from matplotlib.collections import LineCollection
-from numpy import dtype, generic, ndarray
-
-
-def scatter_into_bz(
-    bz_corners: List[npt.NDArray[np.float64]],
-    k_points: npt.NDArray[np.float64],
-    data: npt.NDArray[np.float64] | None = None,
-    data_label: str | None = None,
-    fig_in: matplotlib.figure.Figure | None = None,
-    ax_in: matplotlib.axes.Axes | None = None,
-) -> matplotlib.figure.Figure:
-    if fig_in is None or ax_in is None:
-        fig, ax = plt.subplots()
-    else:
-        fig, ax = fig_in, ax_in
-
-    if data is not None:
-        scatter = ax.scatter(*zip(*k_points), c=data, cmap="viridis")
-        fig.colorbar(scatter, ax=ax, fraction=0.046, pad=0.04, label=data_label)
-    else:
-        ax.scatter(*zip(*k_points))
-
-    ax.scatter(*zip(*bz_corners), alpha=0.8)
-    ax.set_aspect("equal", adjustable="box")
-    ax.set_xlabel(r"$k_x\ [1/a_0]$")
-    ax.set_ylabel(r"$k_y\ [1/a_0]$")
-
-    return fig
-
-
-def plot_bandstructure(
-    bands: npt.NDArray[np.float64],
-    k_point_list: npt.NDArray[np.float64],
-    ticks: List[float],
-    labels: List[str],
-    overlaps: npt.NDArray[np.float64] | None = None,
-    overlap_labels: List[str] | None = None,
-    fig_in: matplotlib.figure.Figure | None = None,
-    ax_in: matplotlib.axes.Axes | None = None,
-) -> matplotlib.figure.Figure:
-    if fig_in is None or ax_in is None:
-        fig, ax = plt.subplots()
-    else:
-        fig, ax = fig_in, ax_in
-
-    ax.axhline(y=0, alpha=0.7, linestyle="--", color="black")
-
-    if overlaps is None:
-        for band in bands:
-            ax.plot(k_point_list, band)
-    else:
-        line = LineCollection(segments=[np.array([(0, 0)])])
-        for band, wx in zip(bands, overlaps):
-            points = np.array([k_point_list, band]).T.reshape(-1, 1, 2)
-            segments = np.concatenate([points[:-1], points[1:]], axis=1)
-
-            norm = matplotlib.colors.Normalize(-1, 1)
-            lc = LineCollection(segments, cmap="seismic", norm=norm)
-            lc.set_array(wx)
-            lc.set_linewidth(2)
-            line = ax.add_collection(lc)
-
-        colorbar = fig.colorbar(line, fraction=0.046, pad=0.04, ax=ax)
-        color_ticks = [-1, 1]
-        colorbar.set_ticks(ticks=color_ticks, labels=overlap_labels)
-
-    ax.set_ylim(
-        top=np.max(bands) + 0.1 * np.max(bands),
-        bottom=np.min(bands) - 0.1 * np.abs(np.min(bands)),
-    )
-    ax.set_box_aspect(1)
-    ax.set_xticks(ticks, labels)
-    ax.set_ylabel(r"$E\ [t]$")
-    ax.set_facecolor("lightgray")
-    ax.grid(visible=True)
-    ax.tick_params(
-        axis="both", direction="in", bottom=True, top=True, left=True, right=True
-    )
-
-    return fig
-
-
-def _generate_part_of_path(
-    p_0: npt.NDArray[np.float64],
-    p_1: npt.NDArray[np.float64],
-    n: int,
-    length_whole_path: int,
-) -> npt.NDArray[np.float64]:
-    distance = np.linalg.norm(p_1 - p_0)
-    number_of_points = int(n * distance / length_whole_path) + 1
-
-    k_space_path = np.vstack(
-        [
-            np.linspace(p_0[0], p_1[0], number_of_points),
-            np.linspace(p_0[1], p_1[1], number_of_points),
-        ]
-    ).T[:-1]
-
-    return k_space_path
-
-
-def generate_bz_path(
-    points: List[Tuple[npt.NDArray[np.float64], str]], number_of_points: int = 1000
-) -> tuple[
-    ndarray[Any, dtype[generic | generic | Any]],
-    ndarray[Any, dtype[generic | generic | Any]],
-    list[int | Any],
-    list[str],
-]:
-    n = number_of_points
-
-    cycle = [
-        np.linalg.norm(points[i][0] - points[i + 1][0]) for i in range(len(points) - 1)
-    ]
-    cycle.append(np.linalg.norm(points[-1][0] - points[0][0]))
-
-    length_whole_path = np.sum(np.array([cycle]))
-
-    ticks = [0]
-    for i in range(0, len(cycle) - 1):
-        ticks.append(np.sum(cycle[0 : i + 1]) / length_whole_path)
-    ticks.append(1)
-    labels = [rf"${points[i][1]}$" for i in range(len(points))]
-    labels.append(rf"${points[0][1]}$")
-
-    whole_path_plot = np.concatenate(
-        [
-            np.linspace(
-                ticks[i],
-                ticks[i + 1],
-                num=int(n * cycle[i] / length_whole_path),
-                endpoint=False,
-            )
-            for i in range(0, len(ticks) - 1)
-        ]
-    )
-
-    points_path = [
-        _generate_part_of_path(points[i][0], points[i + 1][0], n, length_whole_path)
-        for i in range(0, len(points) - 1)
-    ]
-    points_path.append(
-        _generate_part_of_path(points[-1][0], points[0][0], n, length_whole_path)
-    )
-    whole_path = np.concatenate(points_path)
-
-    return whole_path, whole_path_plot, ticks, labels

quant_met-0.0.2.dist-info/RECORD

@@ -1,15 +0,0 @@
-quant_met/__init__.py,sha256=Exc923N_e87XwJA_lO22UiG4WQy7dnmPmnuLiHyamRk,149
-quant_met/hamiltonians/__init__.py,sha256=PahN7ppBysli0rKnPLhTBMVaKC_nlD2mJfTvzfrrrRs,427
-quant_met/hamiltonians/_base_hamiltonian.py,sha256=N-8Pik-TByDFeaHUH_X442A6mBOaQWlRcN8UdywfFzE,5857
-quant_met/hamiltonians/_eg_x.py,sha256=QmVdrO26qMPp2AQA3ClHb1cBGHAx2BVjfF22WcpZMHw,3643
-quant_met/hamiltonians/_free_energy.py,sha256=Y7OFL-PFTZsrC4tLY5jegwVhnUeaQwLFE1w_8U9hoPs,1065
-quant_met/hamiltonians/_graphene.py,sha256=p8bRCcNsKguz2B3hbbtp-wGGAQtj6MDIZSwIQoY7Yug,2778
-quant_met/hamiltonians/_superfluid_weight.py,sha256=_YUJ5yE1x4JswuY8gydo5iN7LS0mP2Aeikhhsjy7CeQ,4260
-quant_met/hamiltonians/_utils.py,sha256=w2fMk6APN7kmSF6x4mVk-8CWKul-Ut01oBzQK0V6DbA,311
-quant_met/plotting/__init__.py,sha256=b-r6EpFZdc0aX0OrN_SXTo84ojjV8P_htlnnsmVkQWI,165
-quant_met/plotting/_plotting.py,sha256=YfJB6G4E_htnpBh-eogs1ieKNIXK7Hw0S4_qX9mGmj4,4737
-quant_met/utils.py,sha256=wLW7Q-_RbcKBdxCOJqIW_5BDuReE6leRtagABJvlm6U,821
-quant_met-0.0.2.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.2.dist-info/METADATA,sha256=c_Y95udJ7geJwTpY4Yb4FCwOs2mb718nzlut_5YAmnM,2602
-quant_met-0.0.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-quant_met-0.0.2.dist-info/RECORD,,