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

quant_met/__init__.py

@@ -1,3 +1,7 @@
 # SPDX-FileCopyrightText: 2024-present Tjark <tjarksievers@icloud.com>
 #
 # SPDX-License-Identifier: MIT
+
+import numpy as np
+
+np.seterr(all="ignore")

quant_met/hamiltonians/__init__.py

@@ -0,0 +1,14 @@
+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/_base_hamiltonian.py

@@ -0,0 +1,172 @@
+import pathlib
+from abc import ABC, abstractmethod
+
+import h5py
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+
+
+class BaseHamiltonian(ABC):
+    """Base class for Hamiltonians."""
+
+    @property
+    @abstractmethod
+    def number_of_bands(self) -> int:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:
+        raise NotImplementedError
+
+    @property
+    def delta_orbital_basis(self) -> npt.NDArray[np.float64]:
+        raise NotImplementedError
+
+    @delta_orbital_basis.setter
+    @abstractmethod
+    def delta_orbital_basis(self, new_delta: npt.NDArray[np.float64]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _hamiltonian_one_point(
+        self, k_point: npt.NDArray[np.float64]
+    ) -> npt.NDArray[np.complex64]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _hamiltonian_derivative_one_point(
+        self, k_point: npt.NDArray[np.float64], directions: str
+    ) -> npt.NDArray[np.complex64]:
+        raise NotImplementedError
+
+    def _bdg_hamiltonian_one_point(
+        self, k_point: npt.NDArray[np.float64]
+    ) -> npt.NDArray[np.complex64]:
+        delta_matrix: npt.NDArray[np.complex64] = np.zeros(
+            shape=(self.number_of_bands, self.number_of_bands), dtype=np.complex64
+        )
+        np.fill_diagonal(delta_matrix, self.delta_orbital_basis)
+
+        h = np.block(
+            [
+                [self.hamiltonian(k_point), delta_matrix],
+                [np.conjugate(delta_matrix), -np.conjugate(self.hamiltonian(-k_point))],
+            ]
+        )
+        return h
+
+    def save(self, filename: pathlib.Path) -> None:
+        with h5py.File(f"{filename}", "a") as f:
+            f.create_dataset("delta", data=self.delta_orbital_basis)
+            for key, value in vars(self).items():
+                if not key.startswith("_"):
+                    f.attrs[key] = value
+
+    @classmethod
+    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":
+        config_dict = {}
+        with h5py.File(f"{filename}", "r") as f:
+            config_dict["delta"] = f["delta"][()]
+            for key, value in f.attrs.items():
+                config_dict[key] = value
+
+        return cls(**config_dict)
+
+    def bdg_hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        if np.isnan(k).any() or np.isinf(k).any():
+            raise ValueError("k is NaN or Infinity")
+        if k.ndim == 1:
+            h = self._bdg_hamiltonian_one_point(k)
+        else:
+            h = np.array([self._bdg_hamiltonian_one_point(k) for k in k])
+        return h
+
+    def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        if np.isnan(k).any() or np.isinf(k).any():
+            raise ValueError("k is NaN or Infinity")
+        if k.ndim == 1:
+            h = self._hamiltonian_one_point(k)
+        else:
+            h = np.array([self._hamiltonian_one_point(k) for k in k])
+        return h
+
+    def hamiltonian_derivative(
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        if np.isnan(k).any() or np.isinf(k).any():
+            raise ValueError("k is NaN or Infinity")
+        if k.ndim == 1:
+            h = self._hamiltonian_derivative_one_point(k, direction)
+        else:
+            h = np.array(
+                [self._hamiltonian_derivative_one_point(k, direction) for k in k]
+            )
+        return h
+
+    def diagonalize_nonint(
+        self, k: npt.NDArray[np.float64]
+    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+        k_point_matrix = self.hamiltonian(k)
+
+        if k.ndim == 1:
+            band_energies, bloch_wavefunctions = np.linalg.eigh(k_point_matrix)
+        else:
+            bloch_wavefunctions = np.zeros(
+                (len(k), self.number_of_bands, self.number_of_bands),
+                dtype=complex,
+            )
+            band_energies = np.zeros((len(k), self.number_of_bands))
+
+            for i, k in enumerate(k):
+                band_energies[i], bloch_wavefunctions[i] = np.linalg.eigh(
+                    k_point_matrix[i]
+                )
+
+        return band_energies, bloch_wavefunctions
+
+    def diagonalize_bdg(
+        self, k: npt.NDArray[np.float64]
+    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.complex64]]:
+        bdg_matrix = self.bdg_hamiltonian(k)
+
+        if k.ndim == 1:
+            bdg_energies, bdg_wavefunctions = np.linalg.eigh(bdg_matrix)
+        else:
+            bdg_wavefunctions = np.zeros(
+                (len(k), 2 * self.number_of_bands, 2 * self.number_of_bands),
+                dtype=np.complex64,
+            )
+            bdg_energies = np.zeros((len(k), 2 * self.number_of_bands))
+
+            for i, k in enumerate(k):
+                bdg_energies[i], bdg_wavefunctions[i] = np.linalg.eigh(bdg_matrix[i])
+
+        return bdg_energies, bdg_wavefunctions
+
+    def calculate_bandstructure(
+        self,
+        k: npt.NDArray[np.float64],
+        overlaps: tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]] | None = None,
+    ) -> pd.DataFrame:
+        k_point_matrix = self.hamiltonian(k)
+
+        results = pd.DataFrame(
+            index=range(len(k)),
+            dtype=float,
+        )
+
+        for i, k in enumerate(k):
+            energies, eigenvectors = np.linalg.eigh(k_point_matrix[i])
+
+            for band_index in range(self.number_of_bands):
+                results.at[i, f"band_{band_index}"] = energies[band_index]
+
+                if overlaps is not None:
+                    results.at[i, f"wx_{band_index}"] = (
+                        np.abs(np.dot(eigenvectors[:, band_index], overlaps[0])) ** 2
+                        - np.abs(np.dot(eigenvectors[:, band_index], overlaps[1])) ** 2
+                    )
+
+        return results

quant_met/hamiltonians/_eg_x.py

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,39 @@
+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/_graphene.py

@@ -0,0 +1,93 @@
+import numpy as np
+import numpy.typing as npt
+
+from ._base_hamiltonian import BaseHamiltonian
+from ._utils import _check_valid_float
+
+
+class GrapheneHamiltonian(BaseHamiltonian):
+    def __init__(
+        self,
+        t_nn: float,
+        a: float,
+        mu: float,
+        coulomb_gr: float,
+        delta: npt.NDArray[np.float64] | None = None,
+    ):
+        self.t_nn = _check_valid_float(t_nn, "Hopping")
+        if a <= 0:
+            raise ValueError("Lattice constant must be positive")
+        self.a = _check_valid_float(a, "Lattice constant")
+        self.mu = _check_valid_float(mu, "Chemical potential")
+        self.coulomb_gr = _check_valid_float(coulomb_gr, "Coloumb interaction")
+        if delta is None:
+            self._delta_orbital_basis = np.zeros(2)
+        else:
+            self._delta_orbital_basis = delta
+
+    @property
+    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:
+        return np.array([self.coulomb_gr, self.coulomb_gr])
+
+    @property
+    def number_of_bands(self) -> int:
+        return 2
+
+    @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
+
+    def _hamiltonian_derivative_one_point(
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        assert direction in ["x", "y"]
+
+        t_nn = self.t_nn
+        a = self.a
+
+        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        if direction == "x":
+            h[0, 1] = (
+                t_nn
+                * 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()
+        else:
+            h[0, 1] = (
+                -t_nn
+                * 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()
+
+        return h
+
+    def _hamiltonian_one_point(
+        self, k: npt.NDArray[np.float64]
+    ) -> npt.NDArray[np.complex64]:
+        t_nn = self.t_nn
+        a = self.a
+        mu = self.mu
+
+        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        h[0, 1] = -t_nn * (
+            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 -= mu * np.eye(2)
+
+        return h

quant_met/hamiltonians/_superfluid_weight.py

@@ -0,0 +1,130 @@
+import numpy as np
+import numpy.typing as npt
+
+from ._base_hamiltonian import BaseHamiltonian
+
+
+def calculate_current_operator(
+    h: BaseHamiltonian, direction: str, k: npt.NDArray[np.float64]
+) -> npt.NDArray[np.complex64]:
+    j = np.zeros(shape=(h.number_of_bands, h.number_of_bands), dtype=np.complex64)
+
+    _, bloch = h.diagonalize_nonint(k=k)
+
+    for m in range(h.number_of_bands):
+        for n in range(h.number_of_bands):
+            j[m, n] = (
+                np.conjugate(bloch[:, m])
+                @ h.hamiltonian_derivative(direction=direction, k=k)
+                @ bloch[:, n]
+            )
+
+    return j
+
+
+def calculate_w_matrix(
+    h: BaseHamiltonian, k: npt.NDArray[np.float64]
+) -> tuple[npt.NDArray[np.complex64], npt.NDArray[np.complex64]]:
+    _, bloch = h.diagonalize_nonint(k=k)
+    _, bdg_functions = h.diagonalize_bdg(k=k)
+
+    w_plus = np.zeros((2 * h.number_of_bands, h.number_of_bands), dtype=np.complex64)
+    for i in range(2 * h.number_of_bands):
+        for m in range(h.number_of_bands):
+            w_plus[i, m] = (
+                np.tensordot(bloch[:, m], np.array([1, 0]), axes=0).reshape(-1)
+                @ bdg_functions[:, i]
+            )
+
+    w_minus = np.zeros((2 * h.number_of_bands, h.number_of_bands), dtype=np.complex64)
+    for i in range(2 * h.number_of_bands):
+        for m in range(h.number_of_bands):
+            w_minus[i, m] = (
+                np.tensordot(
+                    np.conjugate(bloch[:, m]), np.array([0, 1]), axes=0
+                ).reshape(-1)
+                @ bdg_functions[:, i]
+            )
+
+    return w_plus, w_minus
+
+
+def calculate_c_factor(
+    h: BaseHamiltonian, k: npt.NDArray[np.float64]
+) -> npt.NDArray[np.complex64]:
+    bdg_energies, _ = h.diagonalize_bdg(k)
+    w_plus, w_minus = calculate_w_matrix(h, k)
+    C_mnpq = np.zeros(
+        shape=(
+            h.number_of_bands,
+            h.number_of_bands,
+            h.number_of_bands,
+            h.number_of_bands,
+        ),
+        dtype=np.complex64,
+    )
+
+    for m in range(h.number_of_bands):
+        for n in range(h.number_of_bands):
+            for p in range(h.number_of_bands):
+                for q in range(h.number_of_bands):
+                    C_tmp: float = 0
+                    for i in range(2 * h.number_of_bands):
+                        for j in range(2 * h.number_of_bands):
+                            if bdg_energies[i] != bdg_energies[j]:
+                                C_tmp += (
+                                    fermi_dirac(bdg_energies[i])
+                                    - fermi_dirac(bdg_energies[j])
+                                ) / (bdg_energies[j] - bdg_energies[i])
+                            else:
+                                C_tmp -= fermi_dirac_derivative()
+
+                            C_tmp *= (
+                                np.conjugate(w_minus[i, m])
+                                * w_plus[j, n]
+                                * np.conjugate(w_minus[j, p])
+                                * w_minus[i, q]
+                            )
+
+                    C_mnpq[m, n, p, q] = 2 * C_tmp
+
+    return C_mnpq
+
+
+def fermi_dirac_derivative() -> float:
+    return 0
+
+
+def fermi_dirac(energy: np.float64) -> np.float64:
+    if energy > 0:
+        return np.float64(0)
+    else:
+        return np.float64(1)
+
+
+def calculate_superfluid_weight(
+    h: BaseHamiltonian,
+    k_grid: npt.NDArray[np.float64],
+    direction_1: str,
+    direction_2: str,
+) -> tuple[float, float]:
+    # number_k_points = len(k_grid)
+
+    s_weight_conv = 0
+    s_weight_geom = 0
+
+    for k in k_grid:
+        C_mnpq = calculate_c_factor(h, k)
+        j_up = calculate_current_operator(h, direction_1, k)
+        j_down = calculate_current_operator(h, direction_2, -k)
+        for m in range(h.number_of_bands):
+            for n in range(h.number_of_bands):
+                for p in range(h.number_of_bands):
+                    for q in range(h.number_of_bands):
+                        s_weight = C_mnpq[m, n, p, q] * j_up[m, n] * j_down[q, p]
+                        if m == n and p == q:
+                            s_weight_conv += s_weight
+                        else:
+                            s_weight_geom += s_weight
+
+    return s_weight_conv, s_weight_geom

quant_met/hamiltonians/_utils.py

@@ -0,0 +1,10 @@
+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/__init__.py

@@ -1,2 +1,7 @@
-from . import _plotting
-from ._plotting import *
+from ._plotting import generate_bz_path, plot_bandstructure, scatter_into_bz
+
+__all__ = [
+    "scatter_into_bz",
+    "plot_bandstructure",
+    "generate_bz_path",
+]

quant_met/plotting/_plotting.py

@@ -1,94 +1,56 @@
+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
-
-
-def plot_into_bz(
-    bz_corners, k_points, fig: plt.Figure | None = None, ax: plt.Axes | None = None
-):
-    if fig is None:
-        fig, ax = plt.subplots()
-
-    ax.scatter(*zip(*k_points))
-    ax.scatter(*zip(*bz_corners), alpha=0.8)
-
-    ax.set_aspect("equal", adjustable="box")
-
-    return fig
+from numpy import dtype, generic, ndarray
 
 
 def scatter_into_bz(
-    bz_corners,
-    k_points,
-    data,
-    fig: plt.Figure | None = None,
-    ax: plt.Axes | None = None,
-):
-    if fig is None:
+    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
 
-    scatter = ax.scatter(*zip(*k_points), c=data, cmap="viridis")
-    ax.scatter(*zip(*bz_corners), alpha=0.8)
-    fig.colorbar(scatter, ax=ax, fraction=0.046, pad=0.04)
+    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_bcs_bandstructure(
-    non_interacting_bands,
-    deltas,
-    k_point_list,
-    ticks,
-    labels,
-    fig: plt.Figure | None = None,
-    ax: plt.Axes | None = None,
-):
-    if fig is None:
-        fig, ax = plt.subplots()
-
-    ax.axhline(y=0, alpha=0.7, linestyle="--", color="black")
-
-    for index, (band, delta) in enumerate(zip(non_interacting_bands, deltas)):
-        ax.plot(
-            k_point_list,
-            np.sqrt(band**2 + np.abs(delta) ** 2),
-            label=f"band {index}, +",
-        )
-        ax.plot(
-            k_point_list,
-            -np.sqrt(band**2 + np.abs(delta) ** 2),
-            label=f"band {index}, -",
-        )
-    ax.set_box_aspect(1)
-
-    ax.set_xticks(ticks, labels)
-    ax.set_yticks(range(-5, 6))
-    ax.set_facecolor("lightgray")
-    ax.grid(visible=True)
-    # ax.set_ylim([-5, 5])
-    ax.tick_params(
-        axis="both", direction="in", bottom=True, top=True, left=True, right=True
-    )
-
-    ax.legend()
-
-    return fig, ax
-
-
-def plot_nonint_bandstructure(
-    bands,
-    k_point_list,
-    ticks,
-    labels,
-    overlaps: npt.NDArray | None = None,
-    fig: plt.Figure | None = None,
-    ax: plt.Axes | None = None,
-):
-    if fig is None:
+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")
 
@@ -96,13 +58,12 @@ def plot_nonint_bandstructure(
         for band in bands:
             ax.plot(k_point_list, band)
     else:
-        line = None
-
+        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 = plt.Normalize(-1, 1)
+            norm = matplotlib.colors.Normalize(-1, 1)
             lc = LineCollection(segments, cmap="seismic", norm=norm)
             lc.set_array(wx)
             lc.set_linewidth(2)
@@ -110,14 +71,17 @@ def plot_nonint_bandstructure(
 
         colorbar = fig.colorbar(line, fraction=0.046, pad=0.04, ax=ax)
         color_ticks = [-1, 1]
-        colorbar.set_ticks(ticks=color_ticks, labels=[r"$w_{\mathrm{Gr}_1}$", r"$w_X$"])
+        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_yticks(range(-5, 6))
+    ax.set_ylabel(r"$E\ [t]$")
     ax.set_facecolor("lightgray")
     ax.grid(visible=True)
-    # ax.set_ylim([-5, 5])
     ax.tick_params(
         axis="both", direction="in", bottom=True, top=True, left=True, right=True
     )
@@ -125,7 +89,12 @@ def plot_nonint_bandstructure(
     return fig
 
 
-def _generate_part_of_path(p_0, p_1, n, length_whole_path):
+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
 
@@ -139,7 +108,14 @@ def _generate_part_of_path(p_0, p_1, n, length_whole_path):
     return k_space_path
 
 
-def generate_bz_path(points=None, number_of_points=1000):
+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 = [

quant_met/utils.py

@@ -0,0 +1,28 @@
+import numpy as np
+import numpy.typing as npt
+
+
+def generate_uniform_grid(
+    ncols: int,
+    nrows: int,
+    corner_1: npt.NDArray[np.float64],
+    corner_2: npt.NDArray[np.float64],
+    origin: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    if ncols <= 1 or nrows <= 1:
+        raise ValueError("Number of columns and rows must be greater than 1.")
+    if np.linalg.norm(corner_1) == 0 or np.linalg.norm(corner_2) == 0:
+        raise ValueError("Vectors to the corners cannot be zero.")
+
+    grid: npt.NDArray[np.float64] = np.concatenate(
+        [
+            np.linspace(
+                origin[0] + i / (nrows - 1) * corner_2,
+                origin[1] + corner_1 + i / (nrows - 1) * corner_2,
+                num=ncols,
+            )
+            for i in range(nrows)
+        ]
+    )
+
+    return grid

{quant_met-0.0.1.dist-info → quant_met-0.0.2.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.1
-Summary: 
+Version: 0.0.2
+Summary: Calculate superconductivity in flat-band systems.
 Author: Tjark Sievers
 Author-email: tsievers@physnet.uni-hamburg.de
 Requires-Python: >=3.10,<4.0
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: h5py (>=3.11.0,<4.0.0)
 Requires-Dist: matplotlib (>=3.8.4,<4.0.0)
 Requires-Dist: numpy (>=1.26.4,<2.0.0)
 Requires-Dist: pandas (>=2.2.2,<3.0.0)
@@ -21,18 +21,28 @@ Description-Content-Type: text/markdown
 
 [![Test](https://github.com/Ruberhauptmann/quant-met/actions/workflows/test.yml/badge.svg)](https://github.com/Ruberhauptmann/quant-met/actions/workflows/test.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/)
+
+This is a python package to treat superconductivity in flat-band systems.
 
 * Documentation: [quant-met.readthedocs.io](https://quant-met.readthedocs.io/en/latest/)
 
 ## Installation
 
 The package can be installed via
+```shell
+pip install quant-met
+```
 
 ## Usage
 
+For usage examples see [documentation](https://quant-met.readthedocs.io/en/latest/examples.html).
+
 ## Contributing
 
-You are welcome to open an issue if you want something changed or added in the software or if there are bugs occuring.
+This is a personal project, very geared to the work I did in my master's thesis.
+If someone is using this and experiencing bugs or want the software extended, feel free to open an issue!
 
 ### Developing
 
@@ -49,13 +59,11 @@ Set up the development environment:
 * run `make environment`
 * now activate the conda environment `conda activate quant-met-dev`
 
-Now you can create a separate branch to work on the project.
-
 You can manually run tests using for example `tox -e py312` (for running against python 3.12).
-After pushing your branch, all tests will also be run via Gitlab Actions.
+After pushing your branch, all tests will also be run via Github Actions.
 
 Using `pre-commit`, automatic linting and formatting is done before every commit, which may cause the first commit to fail.
 A second try should then succeed.
 
-After you are done working on an issue and all tests are running successful, you can add a new piece of changelog via `scriv create` and make a merge request.
+After you are done working on an issue and all tests are running successful, you can add a new piece of changelog via `scriv create` and make a pull request.
 

quant_met-0.0.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+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,,

quant_met/__about__.py

@@ -1,4 +0,0 @@
-# SPDX-FileCopyrightText: 2024-present Tjark <tjarksievers@icloud.com>
-#
-# SPDX-License-Identifier: MIT
-__version__ = "0.0.1"

quant_met/bcs/find_fixpoint.py

@@ -1,65 +0,0 @@
-import numpy as np
-import numpy.typing as npt
-from scipy import interpolate, optimize
-
-from quant_met.bcs.gap_equation import gap_equation_real
-from quant_met.configuration import DeltaVector
-from quant_met.hamiltonians import BaseHamiltonian
-
-
-def generate_k_space_grid(nx, nrows, corner_1, corner_2):
-    k_points = np.concatenate(
-        [
-            np.linspace(
-                i / (nrows - 1) * corner_2,
-                corner_1 + i / (nrows - 1) * corner_2,
-                num=nx,
-            )
-            for i in range(nrows)
-        ]
-    )
-
-    return k_points
-
-
-def solve_gap_equation(
-    hamiltonian: BaseHamiltonian, k_points: npt.NDArray, beta: float = 0
-) -> DeltaVector:
-    energies, bloch_absolute = hamiltonian.generate_bloch(k_points=k_points)
-
-    delta_vector = DeltaVector(
-        k_points=k_points, initial=0.1, number_bands=hamiltonian.number_bands
-    )
-    try:
-        solution = optimize.fixed_point(
-            gap_equation_real,
-            delta_vector.as_1d_vector,
-            args=(hamiltonian.U, beta, bloch_absolute, energies, len(k_points)),
-        )
-    except RuntimeError:
-        print("Failed")
-        solution = DeltaVector(
-            k_points=k_points, initial=0.0, number_bands=hamiltonian.number_bands
-        ).as_1d_vector
-
-    delta_vector.update_from_1d_vector(solution)
-
-    return delta_vector
-
-
-def interpolate_gap(
-    delta_vector_on_grid: DeltaVector, bandpath: npt.NDArray
-) -> DeltaVector:
-    delta_vector_interpolated = DeltaVector(
-        k_points=bandpath, number_bands=delta_vector_on_grid.number_bands
-    )
-
-    for band in range(delta_vector_interpolated.number_bands):
-        delta_vector_interpolated.data.loc[:, f"delta_{band}"] = interpolate.griddata(
-            delta_vector_on_grid.k_points,
-            delta_vector_on_grid.data.loc[:, f"delta_{band}"],
-            bandpath,
-            method="cubic",
-        )
-
-    return delta_vector_interpolated

quant_met/bcs/gap_equation.py

@@ -1,43 +0,0 @@
-import numpy as np
-import numpy.typing as npt
-
-
-def gap_equation_real(
-    delta_k: npt.NDArray,
-    U: npt.NDArray,
-    beta: float,
-    bloch_absolute: npt.NDArray,
-    energies: npt.NDArray,
-    number_k_points: int,
-):
-    return_vector = np.zeros(len(delta_k))
-
-    number_bands = int(len(return_vector) / number_k_points)
-
-    for n in range(number_bands):
-        offset_n = int(len(delta_k) / number_bands * n)
-        for k_prime_index in range(0, number_k_points):
-            sum_tmp = 0
-            for alpha in range(number_bands):
-                for m in range(number_bands):
-                    offset_m = int(len(delta_k) / number_bands * m)
-                    for k_index in range(0, number_k_points):
-                        sum_tmp += (
-                            U[alpha]
-                            * bloch_absolute[k_prime_index][alpha][n]
-                            * bloch_absolute[k_index][alpha][m]
-                            * delta_k[k_index + offset_m]
-                            / (
-                                2
-                                * np.sqrt(
-                                    (energies[k_index][m]) ** 2
-                                    + np.abs(delta_k[k_index + offset_m]) ** 2
-                                )
-                            )
-                        )
-
-            return_vector[k_prime_index + offset_n] = sum_tmp / (
-                2.5980762113533156 * number_k_points
-            )
-
-    return return_vector

quant_met/cli.py

@@ -1,16 +0,0 @@
-import click
-
-from quant_met.bcs import find_fixpoint
-
-
-@click.command()
-def cli():
-    find_fixpoint.solve_gap_equation()
-
-
-def hello_world():
-    return "Hello World!"
-
-
-if __name__ == "__main__":
-    cli()

quant_met/configuration.py

@@ -1,53 +0,0 @@
-import numpy as np
-import numpy.typing as npt
-import pandas as pd
-
-
-class DeltaVector:
-    def __init__(
-        self,
-        number_bands: int,
-        hdf_file=None,
-        k_points: npt.NDArray | None = None,
-        initial: float | None = None,
-    ):
-        self.number_bands = number_bands
-        if hdf_file is not None:
-            pass
-        #    self.data = pd.DataFrame(pd.read_hdf(hdf_file, key="table"))
-        #    self.k_points = np.column_stack(
-        #        (np.array(self.data.loc[:, "kx"]), np.array(self.data.loc[:, "ky"]))
-        #    )
-        else:
-            self.k_points = k_points
-            self.data = pd.DataFrame(
-                # columns=["kx", "ky", "delta_1", "delta_2", "delta_3"],
-                index=range(len(k_points)),
-                dtype=np.float64,
-            )
-            self.data.loc[:, "kx"] = self.k_points[:, 0]
-            self.data.loc[:, "ky"] = self.k_points[:, 1]
-            if initial is not None:
-                for i in range(number_bands):
-                    self.data.loc[:, f"delta_{i}"] = initial
-
-    def __repr__(self):
-        return self.data.to_string(index=False)
-
-    def update_from_1d_vector(self, delta: npt.NDArray):
-        for n in range(self.number_bands):
-            offset = int(n * len(delta) / self.number_bands)
-            self.data.loc[:, f"delta_{n}"] = delta[offset : offset + len(self.k_points)]
-
-    def save(self, path):
-        pass
-        # self.data.to_hdf(path, key="table", format="table", data_columns=True)
-
-    @property
-    def as_1d_vector(self) -> npt.NDArray:
-        return np.concatenate(
-            [
-                np.array(self.data.loc[:, f"delta_{n}"].values)
-                for n in range(self.number_bands)
-            ]
-        )

quant_met/hamiltonians.py

@@ -1,174 +0,0 @@
-from abc import ABC, abstractmethod
-
-import numpy as np
-import numpy.typing as npt
-import pandas as pd
-
-
-class BaseHamiltonian(ABC):
-    @property
-    @abstractmethod
-    def number_bands(self) -> int:
-        raise NotImplementedError
-
-    @property
-    @abstractmethod
-    def U(self) -> list[float]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def _k_space_matrix_one_point(self, k: npt.NDArray, h: npt.NDArray) -> npt.NDArray:
-        raise NotImplementedError
-
-    def k_space_matrix(self, k: npt.NDArray) -> npt.NDArray:
-        if k.ndim == 1:
-            h = np.zeros((1, self.number_bands, self.number_bands), dtype=complex)
-            h[0] = self._k_space_matrix_one_point(k, h[0])
-        else:
-            h = np.zeros(
-                (k.shape[0], self.number_bands, self.number_bands), dtype=complex
-            )
-            for k_index, k in enumerate(k):
-                h[k_index] = self._k_space_matrix_one_point(k, h[k_index])
-        return h
-
-    def calculate_bandstructure(self, k_point_list: npt.NDArray):
-        k_point_matrix = self.k_space_matrix(k_point_list)
-
-        results = pd.DataFrame(
-            index=range(len(k_point_list)),
-            dtype=float,
-        )
-
-        for i, k in enumerate(k_point_list):
-            energies, eigenvectors = np.linalg.eigh(k_point_matrix[i])
-
-            for band_index in range(self.number_bands):
-                results.at[i, f"band_{band_index}"] = energies[band_index]
-
-        return results
-
-    def generate_bloch(self, k_points: npt.NDArray):
-        k_point_matrix = self.k_space_matrix(k_points)
-
-        if k_points.ndim == 1:
-            energies, bloch = np.linalg.eigh(k_point_matrix[0])
-        else:
-            bloch = np.zeros(
-                (len(k_points), self.number_bands, self.number_bands), dtype=complex
-            )
-            energies = np.zeros((len(k_points), self.number_bands))
-
-            for i, k in enumerate(k_points):
-                energies[i], bloch[i] = np.linalg.eigh(k_point_matrix[i])
-
-        return energies, bloch
-
-
-class GrapheneHamiltonian(BaseHamiltonian):
-    def __init__(self, t_nn: float, a: float, mu: float, U_gr: float):
-        self.t_nn = t_nn
-        self.a = a
-        self.mu = mu
-        self.U_gr = U_gr
-
-    @property
-    def U(self) -> list[float]:
-        return [self.U_gr, self.U_gr]
-
-    @property
-    def number_bands(self) -> int:
-        return 2
-
-    def _k_space_matrix_one_point(self, k: npt.NDArray, h: npt.NDArray) -> npt.NDArray:
-        t_nn = self.t_nn
-        a = self.a
-        mu = self.mu
-
-        h[0, 1] = t_nn * (
-            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 = h - mu * np.eye(2)
-        return h
-
-
-class EGXHamiltonian(BaseHamiltonian):
-    def __init__(
-        self,
-        t_gr: float,
-        t_x: float,
-        V: float,
-        a: float,
-        mu: float,
-        U_gr: float,
-        U_x: float,
-    ):
-        self.t_gr = t_gr
-        self.t_x = t_x
-        self.V = V
-        self.a = a
-        self.mu = mu
-        self.U_gr = U_gr
-        self.U_x = U_x
-
-    @property
-    def U(self) -> list[float]:
-        return [self.U_gr, self.U_gr, self.U_x]
-
-    @property
-    def number_bands(self) -> int:
-        return 3
-
-    def _k_space_matrix_one_point(self, k: npt.NDArray, h: npt.NDArray) -> npt.NDArray:
-        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[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 = h - mu * np.eye(3)
-        return h
-
-    def calculate_bandstructure(self, k_point_list: npt.NDArray):
-        k_point_matrix = self.k_space_matrix(k_point_list)
-
-        results = pd.DataFrame(
-            index=range(len(k_point_list)),
-            dtype=float,
-        )
-
-        for i, k in enumerate(k_point_list):
-            energies, eigenvectors = np.linalg.eigh(k_point_matrix[i])
-
-            for band_index in range(self.number_bands):
-                results.at[i, f"band_{band_index}"] = energies[band_index]
-                results.at[i, f"wx_{band_index}"] = (
-                    np.abs(np.dot(eigenvectors[:, band_index], np.array([0, 0, 1])))
-                    ** 2
-                    - np.abs(np.dot(eigenvectors[:, band_index], np.array([1, 0, 0])))
-                    ** 2
-                )
-
-        return results

quant_met-0.0.1.dist-info/RECORD

@@ -1,15 +0,0 @@
-quant_met/__about__.py,sha256=6FvoyjKMderO3l6cPxDWjV4mVs2rLATIwiQbeNG2hv8,126
-quant_met/__init__.py,sha256=nK4YcOOHyCkCgRju6gu_7sPIFGqL6w07-uMzTmd1F6o,104
-quant_met/bcs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-quant_met/bcs/find_fixpoint.py,sha256=aJj1htdBg7Z8Kxsn_WDYCRK4_gm0vRIPgrkFJH2wd6c,1942
-quant_met/bcs/gap_equation.py,sha256=aCP7cDI-AdrF8o-Ois6nHJoX0HGCSwOEOziUE41vgj4,1489
-quant_met/cli.py,sha256=4yWAa7AQsilCO4Y3M8U9w9LmaGqJAb-LG5Bio1MEOFw,209
-quant_met/configuration.py,sha256=DL4_X47198sA1-C2Lu6W1hXVcqVem80PlFEWWX-Xnwg,1768
-quant_met/hamiltonians.py,sha256=0B78trWo2YP1R18GQWU7ZyDSPnOwkI-sM8P-JK7xLkc,4897
-quant_met/plotting/__init__.py,sha256=vm92FEALO5yc152WjNf04TgxxXR_JVYH5ha9FjtbXxM,49
-quant_met/plotting/_plotting.py,sha256=2CtYshJ53xLCTbcs1VLxKqBXyDu0OhIzFeRruvecJgg,4757
-quant_met-0.0.1.dist-info/LICENSE.txt,sha256=QO_duPQihSJlaxSLxPAXo52X3esROP5wBkhxqBd1Z4E,1104
-quant_met-0.0.1.dist-info/METADATA,sha256=N-kd1e91pO-jE_EQ04WDVy87qpg7O-9iKKkEHCyy4GM,2127
-quant_met-0.0.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-quant_met-0.0.1.dist-info/entry_points.txt,sha256=qnX2LVrCzWILIWh5jQs_uzEPBIos013bRE82kyOr24Q,46
-quant_met-0.0.1.dist-info/RECORD,,

quant_met-0.0.1.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-quantmet=quant_met.cli:cli
-