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

quant_met/mean_field/graphene.py

@@ -0,0 +1,142 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for Graphene."""
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from ._utils import _check_valid_array, _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,
+        *args: tuple[Any, ...],
+        **kwargs: tuple[dict[str, Any], ...],
+    ) -> None:
+        del args
+        del kwargs
+        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(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        """
+        Return the normal state Hamiltonian in orbital basis.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Hamiltonian in matrix form.
+
+        """
+        assert _check_valid_array(k)
+        t_nn = self.t_nn
+        a = self.a
+        mu = self.mu
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], 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[:, 0, 0] -= mu
+        h[:, 1, 1] -= mu
+
+        return h.squeeze()
+
+    def hamiltonian_derivative(
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        """
+        Deriative of the Hamiltonian.
+
+        Parameters
+        ----------
+        k: :class:`numpy.ndarray`
+            List of k points.
+        direction: str
+            Direction for derivative, either 'x' oder 'y'.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Derivative of Hamiltonian.
+
+        """
+        assert _check_valid_array(k)
+        assert direction in ["x", "y"]
+
+        t_nn = self.t_nn
+        a = self.a
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros((k.shape[0], 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.squeeze()

quant_met/mean_field/quantum_metric.py

@@ -0,0 +1,108 @@
+# 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] += (
+                        (
+                            bloch[k_index][:, band].conjugate()
+                            @ h_derivative_direction_1[k_index]
+                            @ bloch[k_index][:, n]
+                        )
+                        * (
+                            bloch[k_index][:, n].conjugate()
+                            @ 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
+
+
+def quantum_metric_bdg(
+    h: BaseHamiltonian, k_grid: npt.NDArray[np.float64], band: int
+) -> npt.NDArray[np.float64]:
+    """Calculate the quantum metric in the BdG 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, bdg_functions = h.diagonalize_bdg(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.bdg_hamiltonian_derivative(k=k_grid, direction=direction_1)
+        for j, direction_2 in enumerate(["x", "y"]):
+            h_derivative_direction_2 = h.bdg_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] += (
+                        (
+                            bdg_functions[k_index][:, band].conjugate()
+                            @ h_derivative_direction_1[k_index]
+                            @ bdg_functions[k_index][:, n]
+                        )
+                        * (
+                            bdg_functions[k_index][:, n].conjugate()
+                            @ h_derivative_direction_2[k_index]
+                            @ bdg_functions[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] = (
+                bloch[:, m].conjugate()
+                @ 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(bloch[:, m].conjugate(), 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 *= (
+                                w_minus[i, m].conjugate()
+                                * w_plus[j, n]
+                                * w_minus[j, p].conjugate()
+                                * 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,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