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

quant_met/mean_field/graphene.py

@@ -0,0 +1,97 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for Graphene."""
+
+import numpy as np
+import numpy.typing as npt
+
+from ._utils import _validate_float
+from .base_hamiltonian import BaseHamiltonian
+
+
+class GrapheneHamiltonian(BaseHamiltonian):
+    """Hamiltonian for Graphene."""
+
+    def __init__(
+        self,
+        t_nn: float,
+        a: float,
+        mu: float,
+        coulomb_gr: float,
+        delta: npt.NDArray[np.float64] | None = None,
+    ) -> None:
+        self.t_nn = _validate_float(t_nn, "Hopping")
+        if a <= 0:
+            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 number_of_bands(self) -> int:  # noqa: D102
+        return self._number_of_bands
+
+    @property
+    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]:  # noqa: D102
+        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/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/mean_field/superfluid_weight.py

@@ -0,0 +1,146 @@
+# 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
+
+
+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 _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 _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 _c_factor(h: BaseHamiltonian, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+    bdg_energies, _ = h.diagonalize_bdg(k)
+    w_plus, w_minus = _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)
+
+    return np.float64(1)

quant_met/plotting/__init__.py

@@ -1,2 +1,28 @@
-from . import _plotting
-from ._plotting import *
+# 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",
+    "plot_bandstructure",
+    "generate_bz_path",
+]

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

@@ -0,0 +1,71 @@
+# 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
+
+
+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]:
+    """
+    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:
+        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:
+        msg = "Vectors to the corners cannot be zero."
+        raise ValueError(msg)
+
+    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.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.