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

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

@@ -1,38 +1,52 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.1
-Summary: 
+Version: 0.0.3
+Summary: Calculate superconductivity in flat-band systems.
 Author: Tjark Sievers
 Author-email: tsievers@physnet.uni-hamburg.de
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.11,<4.0
 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: matplotlib (>=3.8.4,<4.0.0)
-Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: h5py (>=3.11.0,<4.0.0)
+Requires-Dist: matplotlib (>=3.9.1,<4.0.0)
+Requires-Dist: numpy (>=2.0.0,<3.0.0)
 Requires-Dist: pandas (>=2.2.2,<3.0.0)
-Requires-Dist: scipy (>=1.13.0,<2.0.0)
-Requires-Dist: sympy (>=1.12,<2.0)
+Requires-Dist: scipy (>=1.14.0,<2.0.0)
 Description-Content-Type: text/markdown
 
+<!--
+SPDX-FileCopyrightText: 2024 Tjark Sievers
+
+SPDX-License-Identifier: MIT
+-->
+
 # quant-met
 
 [![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 +63,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.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/__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/plotting/_plotting.py

@@ -1,180 +0,0 @@
-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
-
-
-def scatter_into_bz(
-    bz_corners,
-    k_points,
-    data,
-    fig: plt.Figure | None = None,
-    ax: plt.Axes | None = None,
-):
-    if fig is None:
-        fig, ax = plt.subplots()
-
-    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)
-
-    ax.set_aspect("equal", adjustable="box")
-
-    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:
-        fig, ax = plt.subplots()
-
-    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 = None
-
-        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)
-            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=[r"$w_{\mathrm{Gr}_1}$", r"$w_X$"])
-
-    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
-    )
-
-    return fig
-
-
-def _generate_part_of_path(p_0, p_1, n, length_whole_path):
-    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=None, number_of_points=1000):
-    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.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
-