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

quant_met/{hamiltonians/_graphene.py → mean_field/graphene.py}

@@ -1,11 +1,19 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for Graphene."""
+
 import numpy as np
 import numpy.typing as npt
 
-from ._base_hamiltonian import BaseHamiltonian
-from ._utils import _check_valid_float
+from ._utils import _validate_float
+from .base_hamiltonian import BaseHamiltonian
 
 
 class GrapheneHamiltonian(BaseHamiltonian):
+    """Hamiltonian for Graphene."""
+
     def __init__(
         self,
         t_nn: float,
@@ -13,28 +21,31 @@ class GrapheneHamiltonian(BaseHamiltonian):
         mu: float,
         coulomb_gr: float,
         delta: npt.NDArray[np.float64] | None = None,
-    ):
-        self.t_nn = _check_valid_float(t_nn, "Hopping")
+    ) -> None:
+        self.t_nn = _validate_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")
+            msg = "Lattice constant must be positive"
+            raise ValueError(msg)
+        self.a = _validate_float(a, "Lattice constant")
+        self.mu = _validate_float(mu, "Chemical potential")
+        self.coulomb_gr = _validate_float(coulomb_gr, "Coloumb interaction")
+        self._coloumb_orbital_basis = np.array([self.coulomb_gr, self.coulomb_gr])
+        self._number_of_bands = 2
         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])
+    def number_of_bands(self) -> int:  # noqa: D102
+        return self._number_of_bands
 
     @property
-    def number_of_bands(self) -> int:
-        return 2
+    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
+        return self._coloumb_orbital_basis
 
     @property
-    def delta_orbital_basis(self) -> npt.NDArray[np.float64]:
+    def delta_orbital_basis(self) -> npt.NDArray[np.float64]:  # noqa: D102
         return self._delta_orbital_basis
 
     @delta_orbital_basis.setter
@@ -52,12 +63,7 @@ class GrapheneHamiltonian(BaseHamiltonian):
         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[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] = (
@@ -74,9 +80,7 @@ class GrapheneHamiltonian(BaseHamiltonian):
 
         return h
 
-    def _hamiltonian_one_point(
-        self, k: npt.NDArray[np.float64]
-    ) -> npt.NDArray[np.complex64]:
+    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

quant_met/mean_field/quantum_metric.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to calculate the quantum metric."""
+
+import numpy as np
+import numpy.typing as npt
+
+from .base_hamiltonian import BaseHamiltonian
+
+
+def quantum_metric(
+    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], band: int
+) -> npt.NDArray[np.float64]:
+    """Calculate the quantum metric in the normal state.
+
+    Parameters
+    ----------
+    h : :class:`~quant_met.BaseHamiltonian`
+        Hamiltonian object.
+    k_grid : :class:`numpy.ndarray`
+        List of k points.
+    band : int
+        Index of band for which the quantum metric is calculated.
+
+    Returns
+    -------
+    :class:`numpy.ndarray`
+        Quantum metric in the normal state.
+
+    """
+    energies, bloch = h.diagonalize_nonint(k_grid)
+
+    number_k_points = len(k_grid)
+
+    quantum_geom_tensor = np.zeros(shape=(2, 2), dtype=np.complex64)
+
+    for i, direction_1 in enumerate(["x", "y"]):
+        h_derivative_direction_1 = h.hamiltonian_derivative(k=k_grid, direction=direction_1)
+        for j, direction_2 in enumerate(["x", "y"]):
+            h_derivative_direction_2 = h.hamiltonian_derivative(k=k_grid, direction=direction_2)
+            for k_index in range(len(k_grid)):
+                for n in [i for i in range(h.number_of_bands) if i != band]:
+                    quantum_geom_tensor[i, j] += (
+                        (
+                            np.conjugate(bloch[k_index][:, band])
+                            @ h_derivative_direction_1[k_index]
+                            @ bloch[k_index][:, n]
+                        )
+                        * (
+                            np.conjugate(bloch[k_index][:, n])
+                            @ h_derivative_direction_2[k_index]
+                            @ bloch[k_index][:, band]
+                        )
+                        / (energies[k_index][band] - energies[k_index][n]) ** 2
+                    )
+
+    return np.real(quantum_geom_tensor) / number_k_points

quant_met/{hamiltonians/_superfluid_weight.py → mean_field/superfluid_weight.py}

@@ -1,10 +1,59 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to calculate the superfluid weight."""
+
 import numpy as np
 import numpy.typing as npt
 
-from ._base_hamiltonian import BaseHamiltonian
+from .base_hamiltonian import BaseHamiltonian
+
+
+def superfluid_weight(
+    h: BaseHamiltonian,
+    k_grid: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.complex64], npt.NDArray[np.complex64]]:
+    """Calculate the superfluid weight.
+
+    Parameters
+    ----------
+    h : :class:`~quant_met.mean_field.Hamiltonian`
+        Hamiltonian.
+    k_grid : :class:`numpy.ndarray`
+        List of k points.
+
+    Returns
+    -------
+    :class:`numpy.ndarray`
+        Conventional contribution to the superfluid weight.
+    :class:`numpy.ndarray`
+        Geometric contribution to the superfluid weight.
+
+    """
+    s_weight_conv = np.zeros(shape=(2, 2), dtype=np.complex64)
+    s_weight_geom = np.zeros(shape=(2, 2), dtype=np.complex64)
+
+    for i, direction_1 in enumerate(["x", "y"]):
+        for j, direction_2 in enumerate(["x", "y"]):
+            for k in k_grid:
+                c_mnpq = _c_factor(h, k)
+                j_up = _current_operator(h, direction_1, k)
+                j_down = _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[i, j] += s_weight
+                                else:
+                                    s_weight_geom[i, j] += s_weight
+
+    return s_weight_conv, s_weight_geom
 
 
-def calculate_current_operator(
+def _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)
@@ -22,7 +71,7 @@ def calculate_current_operator(
     return j
 
 
-def calculate_w_matrix(
+def _w_matrix(
     h: BaseHamiltonian, k: npt.NDArray[np.float64]
 ) -> tuple[npt.NDArray[np.complex64], npt.NDArray[np.complex64]]:
     _, bloch = h.diagonalize_nonint(k=k)
@@ -40,21 +89,17 @@ def calculate_w_matrix(
     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)
+                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]:
+def _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(
+    w_plus, w_minus = _w_matrix(h, k)
+    c_mnpq = np.zeros(
         shape=(
             h.number_of_bands,
             h.number_of_bands,
@@ -68,63 +113,34 @@ def calculate_c_factor(
         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
+                    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])
+                                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 -= _fermi_dirac_derivative()
 
-                            C_tmp *= (
+                            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
+                    c_mnpq[m, n, p, q] = 2 * c_tmp
 
-    return C_mnpq
+    return c_mnpq
 
 
-def fermi_dirac_derivative() -> float:
+def _fermi_dirac_derivative() -> float:
     return 0
 
 
-def fermi_dirac(energy: np.float64) -> np.float64:
+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
+    return np.float64(1)

quant_met/plotting/__init__.py

@@ -1,4 +1,25 @@
-from ._plotting import generate_bz_path, plot_bandstructure, scatter_into_bz
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Plotting
+========
+
+.. currentmodule:: quant_met.plotting
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+    scatter_into_bz
+    plot_bandstructure
+    generate_bz_path
+"""  # noqa: D205, D400
+
+from .plotting import generate_bz_path, plot_bandstructure, scatter_into_bz
 
 __all__ = [
     "scatter_into_bz",

quant_met/plotting/plotting.py

@@ -0,0 +1,230 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Methods for plotting data."""
+
+from typing import Any
+
+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 Collection, 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:
+    """Scatter a list of points into the brillouin zone.
+
+    Parameters
+    ----------
+    bz_corners : list[:class:`numpy.ndarray`]
+        Corner points defining the brillouin zone.
+    k_points : :class:`numpy.ndarray`
+        List of k points.
+    data : :class:`numpy.ndarray`, optional
+        Data to put on the k points.
+    data_label : :class:`str`, optional
+        Label for the data.
+    fig_in : :class:`matplotlib.figure.Figure`, optional
+        Figure that holds the axes. If not provided, a new figure and ax is created.
+    ax_in : :class:`matplotlib.axes.Axes`, optional
+        Ax to plot the data in. If not provided, a new figure and ax is created.
+
+    Returns
+    -------
+    :obj:`matplotlib.figure.Figure`
+        Figure with the data plotted onto the axis.
+
+    """
+    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:
+        x_coords, y_coords = zip(*k_points, strict=True)
+        scatter = ax.scatter(x=x_coords, y=y_coords, c=data, cmap="viridis")
+        fig.colorbar(scatter, ax=ax, fraction=0.046, pad=0.04, label=data_label)
+    else:
+        x_coords, y_coords = zip(*k_points, strict=True)
+        ax.scatter(x=x_coords, y=y_coords)
+
+    bz_corner_x, bz_corners_y = zip(*bz_corners, strict=True)
+    ax.scatter(x=bz_corner_x, y=bz_corners_y, 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:
+    """Plot bands along a k space path.
+
+    To have a plot that respects the distances in k space and generate everything that is needed for
+    plotting, use the function :func:`~quant_met.plotting.generate_bz_path`.
+
+    Parameters
+    ----------
+    bands : :class:`numpy.ndarray`
+    k_point_list : :class:`numpy.ndarray`
+        List of points to plot against. This is not a list of two-dimensional k-points!
+    ticks : list(float)
+        Position for ticks.
+    labels : list(str)
+        Labels on ticks.
+    overlaps : :class:`numpy.ndarray`, optional
+        Overlaps.
+    overlap_labels : list(str), optional
+        Labels to put on overlaps.
+    fig_in : :class:`matplotlib.figure.Figure`, optional
+        Figure that holds the axes. If not provided, a new figure and ax is created.
+    ax_in : :class:`matplotlib.axes.Axes`, optional
+        Ax to plot the data in. If not provided, a new figure and ax is created.
+
+    Returns
+    -------
+    :obj:`matplotlib.figure.Figure`
+        Figure with the data plotted onto the axis.
+
+
+    """
+    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 = Collection()
+        for band, wx in zip(bands, overlaps, strict=True):
+            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=float(np.max(bands) + 0.1 * np.max(bands)),
+        bottom=float(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
+
+    return 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]
+
+
+def generate_bz_path(
+    points: list[tuple[npt.NDArray[np.float64], str]], number_of_points: int = 1000
+) -> tuple[
+    ndarray[Any, dtype[generic | Any]],
+    ndarray[Any, dtype[generic | Any]],
+    list[int | Any],
+    list[str],
+]:
+    """Generate a path through high symmetry points.
+
+    Parameters
+    ----------
+    points : :class:`numpy.ndarray`
+        Test
+    number_of_points: int
+        Number of point in the whole path.
+
+    Returns
+    -------
+    :class:`numpy.ndarray`
+        List of two-dimensional k points.
+    :class:`numpy.ndarray`
+        Path for plotting purposes: points between 0 and 1, with appropiate spacing.
+    list[float]
+        A list of ticks for the plotting path.
+    list[str]
+        A list of labels for the plotting path.
+
+    """
+    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]
+    ticks.extend([np.sum(cycle[0 : i + 1]) / length_whole_path for i in range(len(cycle) - 1)])
+    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(len(ticks) - 1)
+        ]
+    )
+
+    points_path = [
+        _generate_part_of_path(points[i][0], points[i + 1][0], n, length_whole_path)
+        for i in range(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/utils.py

@@ -1,3 +1,22 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Utility functions (:mod:`quant_met.utils`)
+==========================================
+
+.. currentmodule:: quant_met.utils
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+    generate_uniform_grid - Generate a uniform grid of points in 2D.
+"""  # noqa: D205, D400
+
 import numpy as np
 import numpy.typing as npt
 
@@ -9,10 +28,34 @@ def generate_uniform_grid(
     corner_2: npt.NDArray[np.float64],
     origin: npt.NDArray[np.float64],
 ) -> npt.NDArray[np.float64]:
+    """
+    Generate a uniform grid of points in 2D.
+
+    Parameters
+    ----------
+        ncols : int
+            Number of columns
+        nrows : int
+            Number of rows
+        corner_1 : :py:class:`numpy.ndarray`
+            First corner vector
+        corner_2 : :py:class:`numpy.ndarray`
+            Second corner vector
+        origin : :py:class:`numpy.ndarray`
+            Origin point
+
+    Returns
+    -------
+        :py:class:`numpy.ndarray`
+            Grid
+
+    """
     if ncols <= 1 or nrows <= 1:
-        raise ValueError("Number of columns and rows must be greater than 1.")
+        msg = "Number of columns and rows must be greater than 1."
+        raise ValueError(msg)
     if np.linalg.norm(corner_1) == 0 or np.linalg.norm(corner_2) == 0:
-        raise ValueError("Vectors to the corners cannot be zero.")
+        msg = "Vectors to the corners cannot be zero."
+        raise ValueError(msg)
 
     grid: npt.NDArray[np.float64] = np.concatenate(
         [

quant_met-0.0.3.dist-info/LICENSES/MIT.txt

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024-present Tjark <tsievers@physnet.uni-hamburg.de>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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

@@ -1,22 +1,26 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.2
+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: 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: 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)