quant-met 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

quant_met/__init__.py

@@ -1,3 +1,5 @@
-# SPDX-FileCopyrightText: 2024-present Tjark <tjarksievers@icloud.com>
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
 #
 # SPDX-License-Identifier: MIT
+
+"""quant-met, a package to treat superconductivity in flat-band systems."""

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/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/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

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

quant_met/mean_field/free_energy.py

@@ -0,0 +1,130 @@
+# SPDX-FileCopyrightText: 2024 Tjark Sievers
+#
+# SPDX-License-Identifier: MIT
+
+"""Functions to calculate the free energy of a BdG Hamiltonian."""
+
+import numpy as np
+import numpy.typing as npt
+
+from .base_hamiltonian import BaseHamiltonian
+
+
+def free_energy(
+    hamiltonian: BaseHamiltonian,
+    k_points: npt.NDArray[np.float64],
+) -> float:
+    """Calculate the free energy of a BdG Hamiltonian.
+
+    Parameters
+    ----------
+    hamiltonian : :class:`BaseHamiltonian`
+        Hamiltonian to be evaluated.
+    k_points : :class:`numpy.ndarray`
+        List of k points
+
+    Returns
+    -------
+    float
+        Free energy from the BdG Hamiltonian.
+
+    """
+    number_k_points = len(k_points)
+    bdg_energies, _ = hamiltonian.diagonalize_bdg(k_points)
+
+    k_array = np.array(
+        [
+            np.sum(np.abs(bdg_energies[k_index][0 : hamiltonian.number_of_bands]))
+            for k_index in range(number_k_points)
+        ]
+    )
+
+    integral: float = -np.sum(k_array, axis=-1) / number_k_points + np.sum(
+        np.power(np.abs(hamiltonian.delta_orbital_basis), 2) / hamiltonian.coloumb_orbital_basis
+    )
+
+    return integral
+
+
+def free_energy_complex_gap(
+    delta_vector: npt.NDArray[np.float64],
+    hamiltonian: BaseHamiltonian,
+    k_points: npt.NDArray[np.float64],
+) -> float:
+    """Calculate the free energy of a BdG Hamiltonian, with a complex order parameter.
+
+    Parameters
+    ----------
+    delta_vector : :class:`numpy.ndarray`
+        Delta in orbital basis, with consecutive floats getting converted into one complex number,
+        so [a, b, c, d] -> [a+b*j, c+d*j].
+    hamiltonian : :class:`BaseHamiltonian`
+        Hamiltonian to be evaluated.
+    k_points : :class:`numpy.ndarray`
+        List of k points
+
+    Returns
+    -------
+    float
+        Free energy from the BdG Hamiltonian.
+
+    """
+    hamiltonian.delta_orbital_basis = delta_vector[0::2] + 1j * delta_vector[1::2]
+
+    return free_energy(hamiltonian=hamiltonian, k_points=k_points)
+
+
+def free_energy_real_gap(
+    delta_vector: npt.NDArray[np.float64],
+    hamiltonian: BaseHamiltonian,
+    k_points: npt.NDArray[np.float64],
+) -> float:
+    """Calculate the free energy of a BdG Hamiltonian, with a real order parameter.
+
+    Parameters
+    ----------
+    delta_vector : :class:`numpy.ndarray`
+        Delta in orbital basis.
+    hamiltonian : :class:`BaseHamiltonian`
+        Hamiltonian to be evaluated.
+    k_points : :class:`numpy.ndarray`
+        List of k points
+
+    Returns
+    -------
+    float
+        Free energy from the BdG Hamiltonian.
+
+    """
+    hamiltonian.delta_orbital_basis = delta_vector.astype(np.complex64)
+
+    return free_energy(hamiltonian=hamiltonian, k_points=k_points)
+
+
+def free_energy_uniform_pairing(
+    delta: float,
+    hamiltonian: BaseHamiltonian,
+    k_points: npt.NDArray[np.float64],
+) -> float:
+    """Calculate the free energy of a BdG Hamiltonian, with uniform pairing constraint.
+
+    Parameters
+    ----------
+    delta : float
+        Delta.
+    hamiltonian : :class:`BaseHamiltonian`
+        Hamiltonian to be evaluated.
+    k_points : :class:`numpy.ndarray`
+        List of k points
+
+    Returns
+    -------
+    float
+        Free energy from the BdG Hamiltonian.
+
+    """
+    hamiltonian.delta_orbital_basis = np.full(
+        hamiltonian.number_of_bands, fill_value=delta, dtype=np.float64
+    ).astype(np.complex64)
+
+    return free_energy(hamiltonian=hamiltonian, k_points=k_points)