quant-met 0.0.2__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.2 → quant_met-0.0.3}/PKG-INFO

@@ -1,22 +1,26 @@
 Metadata-Version: 2.1
 Name: quant-met
-Version: 0.0.2
+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: 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.3}/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.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.2/src/quant_met/hamiltonians/_base_hamiltonian.py → quant_met-0.0.3/src/quant_met/mean_field/base_hamiltonian.py

@@ -1,3 +1,9 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the base class for Hamiltonians."""
+
 import pathlib
 from abc import ABC, abstractmethod
 
@@ -6,6 +12,8 @@ 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."""
@@ -13,26 +21,40 @@ class BaseHamiltonian(ABC):
     @property
     @abstractmethod
     def number_of_bands(self) -> int:
+        """Number of bands in the model."""
         raise NotImplementedError
 
     @property
-    @abstractmethod
     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.float64]:
+    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.float64]) -> None:
+    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]:
+    def _hamiltonian_one_point(self, k_point: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
         raise NotImplementedError
 
     @abstractmethod
@@ -49,15 +71,23 @@ class BaseHamiltonian(ABC):
         )
         np.fill_diagonal(delta_matrix, self.delta_orbital_basis)
 
-        h = np.block(
+        return np.block(
             [
                 [self.hamiltonian(k_point), delta_matrix],
                 [np.conjugate(delta_matrix), -np.conjugate(self.hamiltonian(-k_point))],
             ]
         )
-        return h
 
     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():
@@ -66,17 +96,39 @@ class BaseHamiltonian(ABC):
 
     @classmethod
     def from_file(cls, filename: pathlib.Path) -> "BaseHamiltonian":
-        config_dict = {}
+        """
+        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"][()]
-            for key, value in f.attrs.items():
-                config_dict[key] = value
 
         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():
-            raise ValueError("k is NaN or Infinity")
+            msg = "k is NaN or Infinity"
+            raise ValueError(msg)
         if k.ndim == 1:
             h = self._bdg_hamiltonian_one_point(k)
         else:
@@ -84,8 +136,21 @@ class BaseHamiltonian(ABC):
         return h
 
     def hamiltonian(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
-        if np.isnan(k).any() or np.isinf(k).any():
-            raise ValueError("k is NaN or Infinity")
+        """
+        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:
@@ -95,19 +160,48 @@ class BaseHamiltonian(ABC):
     def hamiltonian_derivative(
         self, k: npt.NDArray[np.float64], direction: str
     ) -> npt.NDArray[np.complex64]:
-        if np.isnan(k).any() or np.isinf(k).any():
-            raise ValueError("k is NaN or Infinity")
+        """
+        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]
-            )
+            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:
@@ -119,16 +213,30 @@ class BaseHamiltonian(ABC):
             )
             band_energies = np.zeros((len(k), self.number_of_bands))
 
-            for i, k in enumerate(k):
-                band_energies[i], bloch_wavefunctions[i] = np.linalg.eigh(
-                    k_point_matrix[i]
-                )
+            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:
@@ -140,7 +248,7 @@ class BaseHamiltonian(ABC):
             )
             bdg_energies = np.zeros((len(k), 2 * self.number_of_bands))
 
-            for i, k in enumerate(k):
+            for i in range(len(k)):
                 bdg_energies[i], bdg_wavefunctions[i] = np.linalg.eigh(bdg_matrix[i])
 
         return bdg_energies, bdg_wavefunctions
@@ -150,6 +258,22 @@ class BaseHamiltonian(ABC):
         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(
@@ -157,14 +281,14 @@ class BaseHamiltonian(ABC):
             dtype=float,
         )
 
-        for i, k in enumerate(k):
+        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.at[i, f"band_{band_index}"] = energies[band_index]
+                results.loc[i, f"band_{band_index}"] = energies[band_index]
 
                 if overlaps is not None:
-                    results.at[i, f"wx_{band_index}"] = (
+                    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
                     )

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

@@ -0,0 +1,120 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Provides the implementation for the EG-X model."""
+
+import numpy as np
+import numpy.typing as npt
+
+from ._utils import _validate_float
+from .base_hamiltonian import BaseHamiltonian
+
+
+class EGXHamiltonian(BaseHamiltonian):
+    """Hamiltonian for the EG-X model."""
+
+    def __init__(
+        self,
+        hopping_gr: float,
+        hopping_x: float,
+        hopping_x_gr_a: float,
+        lattice_constant: float,
+        mu: float,
+        coloumb_gr: float,
+        coloumb_x: float,
+        delta: npt.NDArray[np.complex64] | None = None,
+    ) -> None:
+        self.hopping_gr = _validate_float(hopping_gr, "Hopping graphene")
+        self.hopping_x = _validate_float(hopping_x, "Hopping impurity")
+        self.hopping_x_gr_a = _validate_float(hopping_x_gr_a, "Hybridisation")
+        self.lattice_constant = _validate_float(lattice_constant, "Lattice constant")
+        self.mu = _validate_float(mu, "Chemical potential")
+        self.coloumb_gr = _validate_float(coloumb_gr, "Coloumb interaction graphene")
+        self.coloumb_x = _validate_float(coloumb_x, "Coloumb interaction impurity")
+        self._coloumb_orbital_basis = np.array([self.coloumb_gr, self.coloumb_gr, self.coloumb_x])
+        self._number_of_bands = 3
+        if delta is None:
+            self._delta_orbital_basis = np.zeros(3, dtype=np.complex64)
+        else:
+            self._delta_orbital_basis = delta
+
+    @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.complex64]:  # noqa: D102
+        return self._delta_orbital_basis
+
+    @delta_orbital_basis.setter
+    def delta_orbital_basis(self, new_delta: npt.NDArray[np.complex64]) -> None:
+        self._delta_orbital_basis = new_delta
+
+    @property
+    def number_of_bands(self) -> int:  # noqa: D102
+        return self._number_of_bands
+
+    def _hamiltonian_derivative_one_point(
+        self, k: npt.NDArray[np.float64], direction: str
+    ) -> npt.NDArray[np.complex64]:
+        assert direction in ["x", "y"]
+
+        t_gr = self.hopping_gr
+        t_x = self.hopping_x
+        a = self.lattice_constant
+
+        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        if direction == "x":
+            h[0, 1] = t_gr * 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()
+            h[2, 2] = (
+                2
+                * a
+                * t_x
+                * (np.sin(a * k[0]) + np.sin(0.5 * a * k[0]) * np.cos(0.5 * np.sqrt(3) * a * k[1]))
+            )
+        else:
+            h[0, 1] = (
+                -t_gr
+                * 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()
+            h[2, 2] = np.sqrt(3) * a * t_x * np.cos(0.5 * np.sqrt(3) * a * k[1])
+
+        return h
+
+    def _hamiltonian_one_point(self, k: npt.NDArray[np.float64]) -> npt.NDArray[np.complex64]:
+        t_gr = self.hopping_gr
+        t_x = self.hopping_x
+        a = self.lattice_constant
+        v = self.hopping_x_gr_a
+        mu = self.mu
+
+        h = np.zeros((self.number_of_bands, self.number_of_bands), dtype=np.complex64)
+
+        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 -= mu * np.eye(3, dtype=np.complex64)
+
+        return h