quant-met 0.0.1__tar.gz → 0.0.3__tar.gz

quant_met-0.0.3/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.1 → quant_met-0.0.3}/PKG-INFO

@@ -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.1 → quant_met-0.0.3}/README.md

@@ -1,19 +1,35 @@
+<!--
+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
 
@@ -30,12 +46,10 @@ 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/pyproject.toml

@@ -0,0 +1,74 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+[project]
+name = "quant-met"
+requires-python = ">=3.11"
+
+[tool.poetry]
+name = "quant-met"
+version = "0.0.3"
+description = "Calculate superconductivity in flat-band systems."
+authors = ["Tjark Sievers <tsievers@physnet.uni-hamburg.de>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+numpy = "^2.0.0"
+scipy = "^1.14.0"
+matplotlib = "^3.9.1"
+pandas = "^2.2.2"
+h5py = "^3.11.0"
+
+[tool.poetry.group.dev.dependencies]
+pre-commit = "^3.7.0"
+scriv = "^1.5.1"
+jupyter = "^1.0.0"
+ipympl = "^0.9.4"
+sphinx = "^7.3.7"
+myst-parser = "^3.0.1"
+nbsphinx = "^0.9.4"
+sphinx-gallery = "^0.16.0"
+pydata-sphinx-theme = "^0.15.4"
+sphinx-design = "^0.6.0"
+tox = "^4.15.0"
+mypy = "^1.10.0"
+pytest = "^8.2.1"
+pytest-cov = "^5.0.0"
+hypothesis = {extras = ["numpy"], version = "^6.103.0"}
+pytest-regressions = "^2.5.0"
+numpydoc = "^1.7.0"
+ruff = "^0.5.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+# Config for ruff
+[tool.ruff]
+line-length = 100
+force-exclude = true
+extend-exclude = ["tests", "docs/source/conf.py"]
+
+[tool.ruff.lint]
+#select = []
+#select = ["D", "E", "F", "I", "W"]
+select = ["ALL"]
+ignore = [
+    "D203", # one-blank-line-before-class
+    "D212", # multi-line-summary-first-line
+    "COM812",
+    "ISC001",
+    "Q000",
+    "Q003",
+    "S101", # This checks against using assert
+    "PLR0913", # This checks against using more than 5 function arguments
+]
+
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+#[format]
+#docstring-code-format = true

quant_met-0.0.3/src/quant_met/__init__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""quant-met, a package to treat superconductivity in flat-band systems."""

quant_met-0.0.3/src/quant_met/mean_field/__init__.py

@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""
+Mean field treatment (:mod:`quant_met.mean_field`)
+==================================================
+
+Hamiltonians
+------------
+
+Base
+
+.. autosummary::
+   :toctree: generated/
+
+    BaseHamiltonian
+
+.. autosummary::
+   :toctree: generated/
+
+    GrapheneHamiltonian
+    EGXHamiltonian
+
+
+Functions
+---------
+
+.. autosummary::
+   :toctree: generated/
+
+   superfluid_weight
+   quantum_metric
+   free_energy
+   free_energy_uniform_pairing
+"""  # noqa: D205, D400
+
+from .base_hamiltonian import BaseHamiltonian
+from .eg_x import EGXHamiltonian
+from .free_energy import (
+    free_energy,
+    free_energy_complex_gap,
+    free_energy_real_gap,
+    free_energy_uniform_pairing,
+)
+from .graphene import GrapheneHamiltonian
+from .quantum_metric import quantum_metric
+from .superfluid_weight import superfluid_weight
+
+__all__ = [
+    "superfluid_weight",
+    "quantum_metric",
+    "free_energy",
+    "free_energy_complex_gap",
+    "free_energy_real_gap",
+    "free_energy_uniform_pairing",
+    "BaseHamiltonian",
+    "GrapheneHamiltonian",
+    "EGXHamiltonian",
+]

quant_met-0.0.3/src/quant_met/mean_field/_utils.py

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+
+def _check_valid_array(array_in: npt.NDArray[Any]) -> bool:
+    if np.isnan(array_in).any() or np.isinf(array_in).any():
+        msg = "k is NaN or Infinity"
+        raise ValueError(msg)
+
+    return True
+
+
+def _validate_float(float_in: float, parameter_name: str) -> float:
+    if np.isinf(float_in):
+        msg = f"{parameter_name} must not be Infinity"
+        raise ValueError(msg)
+    if np.isnan(float_in):
+        msg = f"{parameter_name} must not be NaN"
+        raise ValueError(msg)
+
+    return float_in

quant_met-0.0.3/src/quant_met/mean_field/base_hamiltonian.py

@@ -0,0 +1,296 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the base class for Hamiltonians."""
+
+import pathlib
+from abc import ABC, abstractmethod
+
+import h5py
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+
+from ._utils import _check_valid_array
+
+
+class BaseHamiltonian(ABC):
+    """Base class for Hamiltonians."""
+
+    @property
+    @abstractmethod
+    def number_of_bands(self) -> int:
+        """Number of bands in the model."""
+        raise NotImplementedError
+
+    @property
+    def coloumb_orbital_basis(self) -> npt.NDArray[np.float64]:
+        """
+        Coloumb interaction split up in orbitals.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+
+        """
+        raise NotImplementedError
+
+    @property
+    def delta_orbital_basis(self) -> npt.NDArray[np.complex64]:
+        """
+        Order parameter in orbital basis.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+
+        """
+        raise NotImplementedError
+
+    @delta_orbital_basis.setter
+    @abstractmethod
+    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _hamiltonian_one_point(self, k_point: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def _hamiltonian_derivative_one_point(
+        self, k_point: npt.NDArray[np.float64], directions: str
+    ) -> npt.NDArray[np.complex64]:
+        raise NotImplementedError
+
+    def _bdg_hamiltonian_one_point(
+        self, k_point: npt.NDArray[np.float64]
+    ) -> npt.NDArray[np.complex64]:
+        delta_matrix: npt.NDArray[np.complex64] = np.zeros(
+            shape=(self.number_of_bands, self.number_of_bands), dtype=np.complex64
+        )
+        np.fill_diagonal(delta_matrix, self.delta_orbital_basis)
+
+        return np.block(
+            [
+                [self.hamiltonian(k_point), delta_matrix],
+                [np.conjugate(delta_matrix), -np.conjugate(self.hamiltonian(-k_point))],
+            ]
+        )
+
+    def save(self, filename: pathlib.Path) -> None:
+        """
+        Save the Hamiltonian as a HDF5 file.
+
+        Parameters
+        ----------
+        filename : :class:`pathlib.Path`
+            Filename to save the Hamiltonian to, should end in .hdf5
+
+        """
+        with h5py.File(f"{filename}", "a") as f:
+            f.create_dataset("delta", data=self.delta_orbital_basis)
+            for key, value in vars(self).items():
+                if not key.startswith("_"):
+                    f.attrs[key] = value
+
+    @classmethod
+    def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":
+        """
+        Initialise a Hamiltonian from a HDF5 file.
+
+        Parameters
+        ----------
+        filename : :class:`pathlib.Path`
+            File to load the Hamiltonian from.
+
+        """
+        with h5py.File(f"{filename}", "r") as f:
+            config_dict = dict(f.attrs.items())
+            config_dict["delta"] = f["delta"][()]
+
+        return cls(**config_dict)
+
+    def bdg_hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        """
+        Bogoliuobov de Genne Hamiltonian.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            BdG Hamiltonian.
+
+        """
+        if np.isnan(k).any() or np.isinf(k).any():
+            msg = "k is NaN or Infinity"
+            raise ValueError(msg)
+        if k.ndim == 1:
+            h = self._bdg_hamiltonian_one_point(k)
+        else:
+            h = np.array([self._bdg_hamiltonian_one_point(k) for k in k])
+        return h
+
+    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)
+        if k.ndim == 1:
+            h = self._hamiltonian_one_point(k)
+        else:
+            h = np.array([self._hamiltonian_one_point(k) for k in k])
+        return h
+
+    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)
+        if k.ndim == 1:
+            h = self._hamiltonian_derivative_one_point(k, direction)
+        else:
+            h = np.array([self._hamiltonian_derivative_one_point(k, direction) for k in k])
+        return h
+
+    def diagonalize_nonint(
+        self, k: npt.NDArray[np.float64]
+    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+        """
+        Diagonalize the normal state Hamiltonian.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Eigenvalues of the normal state Hamiltonian.
+        :class:`numpy.ndarray`
+            Diagonalising matrix of the normal state Hamiltonian.
+
+        """
+        k_point_matrix = self.hamiltonian(k)
+
+        if k.ndim == 1:
+            band_energies, bloch_wavefunctions = np.linalg.eigh(k_point_matrix)
+        else:
+            bloch_wavefunctions = np.zeros(
+                (len(k), self.number_of_bands, self.number_of_bands),
+                dtype=complex,
+            )
+            band_energies = np.zeros((len(k), self.number_of_bands))
+
+            for i in range(len(k)):
+                band_energies[i], bloch_wavefunctions[i] = np.linalg.eigh(k_point_matrix[i])
+
+        return band_energies, bloch_wavefunctions
+
+    def diagonalize_bdg(
+        self, k: npt.NDArray[np.float64]
+    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.complex64]]:
+        """
+        Diagonalize the BdG Hamiltonian.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+
+        Returns
+        -------
+        :class:`numpy.ndarray`
+            Eigenvalues of the BdG Hamiltonian.
+        :class:`numpy.ndarray`
+            Diagonalising matrix of the BdG Hamiltonian.
+
+        """
+        bdg_matrix = self.bdg_hamiltonian(k)
+
+        if k.ndim == 1:
+            bdg_energies, bdg_wavefunctions = np.linalg.eigh(bdg_matrix)
+        else:
+            bdg_wavefunctions = np.zeros(
+                (len(k), 2 * self.number_of_bands, 2 * self.number_of_bands),
+                dtype=np.complex64,
+            )
+            bdg_energies = np.zeros((len(k), 2 * self.number_of_bands))
+
+            for i in range(len(k)):
+                bdg_energies[i], bdg_wavefunctions[i] = np.linalg.eigh(bdg_matrix[i])
+
+        return bdg_energies, bdg_wavefunctions
+
+    def calculate_bandstructure(
+        self,
+        k: npt.NDArray[np.float64],
+        overlaps: tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]] | None = None,
+    ) -> pd.DataFrame:
+        """
+        Calculate the band structure.
+
+        Parameters
+        ----------
+        k : :class:`numpy.ndarray`
+            List of k points.
+        overlaps : tuple(:class:`numpy.ndarray`, :class:`numpy.ndarray`), optional
+            Overlaps.
+
+        Returns
+        -------
+        `pandas.DataFrame`
+            Band structure.
+
+        """
+        k_point_matrix = self.hamiltonian(k)
+
+        results = pd.DataFrame(
+            index=range(len(k)),
+            dtype=float,
+        )
+
+        for i in range(len(k)):
+            energies, eigenvectors = np.linalg.eigh(k_point_matrix[i])
+
+            for band_index in range(self.number_of_bands):
+                results.loc[i, f"band_{band_index}"] = energies[band_index]
+
+                if overlaps is not None:
+                    results.loc[i, f"wx_{band_index}"] = (
+                        np.abs(np.dot(eigenvectors[:, band_index], overlaps[0])) ** 2
+                        - np.abs(np.dot(eigenvectors[:, band_index], overlaps[1])) ** 2
+                    )
+
+        return results