quant-met 0.0.1__tar.gz

quant_met-0.0.1/LICENSE.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.1/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.1
+Name: quant-met
+Version: 0.0.1
+Summary: 
+Author: Tjark Sievers
+Author-email: tsievers@physnet.uni-hamburg.de
+Requires-Python: >=3.10,<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: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: scipy (>=1.13.0,<2.0.0)
+Requires-Dist: sympy (>=1.12,<2.0)
+Description-Content-Type: text/markdown
+
+# 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)
+
+* Documentation: [quant-met.readthedocs.io](https://quant-met.readthedocs.io/en/latest/)
+
+## Installation
+
+The package can be installed via
+
+## Usage
+
+## Contributing
+
+You are welcome to open an issue if you want something changed or added in the software or if there are bugs occuring.
+
+### Developing
+
+You can also help develop this software further.
+This should help you get set up to start this.
+
+Prerequisites:
+* make
+* python
+* conda
+
+Set up the development environment:
+* clone the repository
+* 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.
+
+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.
+

quant_met-0.0.1/README.md

@@ -0,0 +1,41 @@
+# 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)
+
+* Documentation: [quant-met.readthedocs.io](https://quant-met.readthedocs.io/en/latest/)
+
+## Installation
+
+The package can be installed via
+
+## Usage
+
+## Contributing
+
+You are welcome to open an issue if you want something changed or added in the software or if there are bugs occuring.
+
+### Developing
+
+You can also help develop this software further.
+This should help you get set up to start this.
+
+Prerequisites:
+* make
+* python
+* conda
+
+Set up the development environment:
+* clone the repository
+* 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.
+
+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.

quant_met-0.0.1/pyproject.toml

@@ -0,0 +1,35 @@
+[tool.poetry]
+name = "quant-met"
+version = "0.0.1"
+description = ""
+authors = ["Tjark Sievers <tsievers@physnet.uni-hamburg.de>"]
+readme = "README.md"
+
+[tool.poetry.scripts]
+quantmet = "quant_met.cli:cli"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+numpy = "^1.26.4"
+scipy = "^1.13.0"
+click = "^8.1.7"
+matplotlib = "^3.8.4"
+pandas = "^2.2.2"
+sympy = "^1.12"
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = "^3.7.0"
+scriv = "^1.5.1"
+tox = "^4.15.0"
+jupyter = "^1.0.0"
+ipympl = "^0.9.4"
+black = "^24.4.2"
+sphinx = "^7.3.7"
+sphinx-rtd-theme = "^2.0.0"
+myst-parser = "^3.0.1"
+nbsphinx = "^0.9.4"
+sphinx-gallery = "^0.16.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

quant_met-0.0.1/src/quant_met/__about__.py

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

quant_met-0.0.1/src/quant_met/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2024-present Tjark <tjarksievers@icloud.com>
+#
+# SPDX-License-Identifier: MIT

quant_met-0.0.1/src/quant_met/bcs/find_fixpoint.py

@@ -0,0 +1,65 @@
+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-0.0.1/src/quant_met/bcs/gap_equation.py

@@ -0,0 +1,43 @@
+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-0.0.1/src/quant_met/cli.py

@@ -0,0 +1,16 @@
+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-0.0.1/src/quant_met/configuration.py

@@ -0,0 +1,53 @@
+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-0.0.1/src/quant_met/hamiltonians.py

@@ -0,0 +1,174 @@
+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/src/quant_met/plotting/__init__.py

@@ -0,0 +1,2 @@
+from . import _plotting
+from ._plotting import *

quant_met-0.0.1/src/quant_met/plotting/_plotting.py

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