quant-met 0.0.2__tar.gz → 0.0.4__tar.gz

quant_met-0.0.4/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 → quant_met-0.0.4}/PKG-INFO

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

{quant_met-0.0.2 → quant_met-0.0.4}/README.md

@@ -1,3 +1,9 @@
+<!--
+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)

quant_met-0.0.4/pyproject.toml

@@ -0,0 +1,76 @@
+# 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.4"
+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
+    "PLR2004", # Check against "magic values"
+    "T201", # Warn about print statements
+]
+
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy"
+
+#[format]
+#docstring-code-format = true

quant_met-0.0.4/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.4/src/quant_met/mean_field/__init__.py

@@ -0,0 +1,61 @@
+# 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, quantum_metric_bdg
+from .superfluid_weight import superfluid_weight
+
+__all__ = [
+    "superfluid_weight",
+    "quantum_metric",
+    "quantum_metric_bdg",
+    "free_energy",
+    "free_energy_complex_gap",
+    "free_energy_real_gap",
+    "free_energy_uniform_pairing",
+    "BaseHamiltonian",
+    "GrapheneHamiltonian",
+    "EGXHamiltonian",
+]

quant_met-0.0.4/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.4/src/quant_met/mean_field/base_hamiltonian.py

@@ -0,0 +1,310 @@
+# 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(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.
+
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    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.
+
+        """
+        raise NotImplementedError
+
+    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}", "w") 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.
+
+        """
+        assert _check_valid_array(k)
+        if k.ndim == 1:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros(
+            (k.shape[0], 2 * self.number_of_bands, 2 * self.number_of_bands), dtype=np.complex64
+        )
+
+        h[:, 0 : self.number_of_bands, 0 : self.number_of_bands] = self.hamiltonian(k)
+        h[
+            :,
+            self.number_of_bands : 2 * self.number_of_bands,
+            self.number_of_bands : 2 * self.number_of_bands,
+        ] = -self.hamiltonian(-k).conjugate()
+
+        for i in range(self.number_of_bands):
+            h[:, self.number_of_bands + i, i] = self.delta_orbital_basis[i]
+        h[:, 0:2, 2:4] = h[:, 2:4, 0:2].copy().conjugate()
+
+        return h.squeeze()
+
+    def bdg_hamiltonian_derivative(
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        """
+        Deriative of the BdG 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:
+            k = np.expand_dims(k, axis=0)
+
+        h = np.zeros(
+            (k.shape[0], 2 * self.number_of_bands, 2 * self.number_of_bands), dtype=np.complex64
+        )
+
+        h[:, 0 : self.number_of_bands, 0 : self.number_of_bands] = self.hamiltonian_derivative(
+            k, direction
+        )
+        h[
+            :,
+            self.number_of_bands : 2 * self.number_of_bands,
+            self.number_of_bands : 2 * self.number_of_bands,
+        ] = -self.hamiltonian_derivative(-k, direction).conjugate()
+
+        return h.squeeze()
+
+    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_point_matrix.ndim == 2:
+            k_point_matrix = np.expand_dims(k_point_matrix, axis=0)
+            k = np.expand_dims(k, axis=0)
+
+        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.squeeze(), bloch_wavefunctions.squeeze()
+
+    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 bdg_matrix.ndim == 2:
+            bdg_matrix = np.expand_dims(bdg_matrix, axis=0)
+            k = np.expand_dims(k, axis=0)
+
+        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.squeeze(), bdg_wavefunctions.squeeze()
+
+    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.
+
+        """
+        results = pd.DataFrame(
+            index=range(len(k)),
+            dtype=float,
+        )
+        energies, wavefunctions = self.diagonalize_nonint(k)
+
+        for i, (energy_k, wavefunction_k) in enumerate(zip(energies, wavefunctions, strict=False)):
+            for band_index in range(self.number_of_bands):
+                results.loc[i, f"band_{band_index}"] = energy_k[band_index]
+
+                if overlaps is not None:
+                    results.loc[i, f"wx_{band_index}"] = (
+                        np.abs(np.dot(wavefunction_k[:, band_index], overlaps[0])) ** 2
+                        - np.abs(np.dot(wavefunction_k[:, band_index], overlaps[1])) ** 2
+                    )
+
+        return results