tbkit 0.6.2__tar.gz → 0.7.0__tar.gz

{tbkit-0.6.2/tbkit.egg-info → tbkit-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tbkit
-Version: 0.6.2
+Version: 0.7.0
 Summary: A Python package to build and solve Tight-Binding models.
 Author-email: Charles Poli <cpoli374@gmail.com>
 Maintainer-email: Charles Poli <cpoli374@gmail.com>
@@ -47,7 +47,7 @@ Dynamic: license-file
 
 | | |
 |:--|:-:|
-| Package | [![PyPI version](https://badgen.net/pypi/v/tbkit)](https://pypi.org/project/tbkit/) [![conda-forge](https://img.shields.io/conda/vn/conda-forge/tbkit)](https://anaconda.org/conda-forge/tbkit) [![Python versions](https://badgen.net/pypi/python/tbkit)](https://pypi.org/project/tbkit/) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23386289.svg)](https://doi.org/10.5281/zenodo.23386289) |
+| Package | [![PyPI version](https://badgen.net/pypi/v/tbkit)](https://pypi.org/project/tbkit/) [![conda-forge](https://img.shields.io/conda/vn/conda-forge/tbkit)](https://anaconda.org/conda-forge/tbkit) [![Python versions](https://badgen.net/pypi/python/tbkit)](https://pypi.org/project/tbkit/) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23755191.svg)](https://doi.org/10.5281/zenodo.23755191) |
 | Quality | [![License](https://img.shields.io/github/license/cpoli/tbkit)](https://github.com/cpoli/tbkit/blob/master/LICENSE) [![CI](https://github.com/cpoli/tbkit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/tbkit/actions/workflows/ci.yml) [![Coverage](https://codecov.io/gh/cpoli/tbkit/branch/master/graph/badge.svg)](https://codecov.io/gh/cpoli/tbkit) |
 | Documentation | [![Docs](https://badgen.net/badge/docs/cpoli.github.io%2Ftbkit/blue)](https://cpoli.github.io/tbkit/) |
 | Downloads | [![Downloads](https://static.pepy.tech/badge/tbkit)](https://pepy.tech/project/tbkit) [![Downloads/Month](https://static.pepy.tech/badge/tbkit/month)](https://pepy.tech/project/tbkit) |

{tbkit-0.6.2 → tbkit-0.7.0}/README.md

@@ -2,7 +2,7 @@
 
 | | |
 |:--|:-:|
-| Package | [![PyPI version](https://badgen.net/pypi/v/tbkit)](https://pypi.org/project/tbkit/) [![conda-forge](https://img.shields.io/conda/vn/conda-forge/tbkit)](https://anaconda.org/conda-forge/tbkit) [![Python versions](https://badgen.net/pypi/python/tbkit)](https://pypi.org/project/tbkit/) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23386289.svg)](https://doi.org/10.5281/zenodo.23386289) |
+| Package | [![PyPI version](https://badgen.net/pypi/v/tbkit)](https://pypi.org/project/tbkit/) [![conda-forge](https://img.shields.io/conda/vn/conda-forge/tbkit)](https://anaconda.org/conda-forge/tbkit) [![Python versions](https://badgen.net/pypi/python/tbkit)](https://pypi.org/project/tbkit/) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.23755191.svg)](https://doi.org/10.5281/zenodo.23755191) |
 | Quality | [![License](https://img.shields.io/github/license/cpoli/tbkit)](https://github.com/cpoli/tbkit/blob/master/LICENSE) [![CI](https://github.com/cpoli/tbkit/actions/workflows/ci.yml/badge.svg)](https://github.com/cpoli/tbkit/actions/workflows/ci.yml) [![Coverage](https://codecov.io/gh/cpoli/tbkit/branch/master/graph/badge.svg)](https://codecov.io/gh/cpoli/tbkit) |
 | Documentation | [![Docs](https://badgen.net/badge/docs/cpoli.github.io%2Ftbkit/blue)](https://cpoli.github.io/tbkit/) |
 | Downloads | [![Downloads](https://static.pepy.tech/badge/tbkit)](https://pepy.tech/project/tbkit) [![Downloads/Month](https://static.pepy.tech/badge/tbkit/month)](https://pepy.tech/project/tbkit) |

{tbkit-0.6.2 → tbkit-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tbkit"
-version = "0.6.2"
+version = "0.7.0"
 description = "A Python package to build and solve Tight-Binding models."
 readme = "README.md"
 license = "BSD-3-Clause"

{tbkit-0.6.2 → tbkit-0.7.0}/tbkit/__init__.py

@@ -6,7 +6,7 @@
 
 """tbkit: build and solve Tight-Binding models."""
 
-__version__ = "0.6.2"
+__version__ = "0.7.0"
 
 __all__ = [
     "Lattice", "System", "Plot", "Propagation", "Save", "KSpace",

{tbkit-0.6.2 → tbkit-0.7.0}/tbkit/bdg.py

@@ -395,3 +395,115 @@ def s_wave_gap(
     else:
         error_handling.converged(False, 's_wave_gap')
     return GapResult(new, en, vec, it)
+
+
+def superfluid_weight(
+    ks, delta: complex | NDArray, mu: float = 0., nk: int | tuple[int, ...] = 60,
+    temperature: float = 0., dq: float = 1e-3,
+) -> NDArray[np.float64]:
+    r'''
+    Get the superfluid weight of an s-wave superconductor,
+    :math:`D_{\mu\nu} = \partial^2\Omega/\partial A_\mu\partial A_\nu` at
+    :math:`\mathbf{A} = 0` (:math:`\hbar = e = 1`): the curvature of the
+    grand potential per unit volume in a uniform vector potential, which
+    gives the supercurrent :math:`j_\mu = -D_{\mu\nu}A_\nu` (London). *ks* is
+    the spin-up model; the spin-down electrons are its time-reversed
+    partners, :math:`h_\downarrow(\mathbf{k}) = h(-\mathbf{k})^*`, so the
+    Kramers pairs :math:`(\mathbf{k}\uparrow, -\mathbf{k}\downarrow)` pair
+    even when *ks* is a Chern band (for real hoppings, the spin-independent
+    model). In the Nambu basis
+    :math:`(c_{\mathbf{k}\uparrow}, c^\dagger_{-\mathbf{k}\downarrow})`,
+
+    .. math::
+
+        H_{\mathbf{A}}(\mathbf{k}) = \begin{pmatrix} h_{\mathbf{A}}(\mathbf{k})-\mu & \Delta \\
+        \Delta^* & -[h_{-\mathbf{A}}(\mathbf{k})-\mu]\end{pmatrix}\, ,\qquad
+        \Omega(\mathbf{A}) = \frac{1}{N_kV}\sum_{\mathbf{k}}\Big[\mathrm{Tr}\,
+        [h_{-\mathbf{A}}(\mathbf{k})-\mu] - T\sum_n\ln\big(1 + e^{-E_n/T}\big)\Big]\, ,
+
+    with :math:`h_{\mathbf{A}}` the Peierls Hamiltonian of
+    *get_ham_peierls* (phases on the bond vectors, orbital positions
+    included), :math:`\Delta = \mathrm{diag}(\Delta_i)` the onsite pairing,
+    :math:`E_n` the eigenvalues and :math:`V` the cell volume.
+    :math:`\Delta` is held fixed (not re-solved in the field), which is
+    exact when symmetry fixes it, e.g. uniform pairing. The derivatives are
+    central differences in :math:`\mathbf{A}`.
+
+    For a dispersive band it is the conventional :math:`n/m`. For an
+    isolated flat band at filling :math:`\nu`, with uniform :math:`\Delta`
+    small compared to the band gaps, there is no dispersion, and
+    :math:`D` is purely geometric (Peotta and Törmä, Nat. Commun. 6, 8944
+    (2015)),
+
+    .. math::
+
+        D_{\mu\nu} = 8\Delta\sqrt{\nu(1-\nu)}\int\frac{d^d\mathbf{k}}{(2\pi)^d}\,g_{\mu\nu}(\mathbf{k})
+        \, ,\qquad \mathrm{Tr}\,D \ge \frac{4\Delta}{\pi}\sqrt{\nu(1-\nu)}\,|C|\ \ (2D)\, ,
+
+    with :math:`g` the quantum metric of the band (see
+    *KSpace.quantum_geometric_tensor*) and :math:`C` its Chern number.
+
+    Parameters
+    ----------
+    ks : **KSpace** instance (Hermitian, orthogonal basis, spinless)
+        Spin-up model.
+    delta : Number, or array of norb numbers
+        Onsite pairing :math:`\Delta_i`.
+    mu : Real number, default 0
+        Chemical potential.
+    nk : Positive integer, or tuple of *dim* positive integers, default 60
+        k-mesh (see *mesh_grid*).
+    temperature : Positive real or zero, default 0
+    dq : Positive real, default 1e-3
+        Finite-difference step in :math:`\mathbf{A}`.
+
+    Returns
+    -------
+    D : Real ndarray, shape (dim, dim), in the k coordinates of *get_ham*
+
+    Examples
+    --------
+    Example usage::
+
+        # BCS chain: D = (1/2 pi) int dk 2t cos k (1 - xi/E)
+        chain = KSpace(lattices.chain())
+        chain.set_hopping([{'i': 0, 'j': 0, 'R': (1,), 't': -1.}])
+        d = superfluid_weight(chain, 0.2, mu=-0.5)
+    '''
+    from tbkit.kspace import KSpace
+    error_handling.kspace(ks, KSpace)
+    error_handling.hermitian_kspace(ks.is_hermitian(), ks._overlap_hop)
+    error_handling.spin_up_model(ks.spin)
+    error_handling.pairing_amplitudes(delta, ks.norb, 'delta')
+    error_handling.real_number(mu, 'mu')
+    error_handling.nk(nk, ks.dim)
+    error_handling.positive_real_zero(temperature, 'temperature')
+    error_handling.positive_real(dq, 'dq')
+    n, dim = ks.norb, ks.dim
+    k_cart = ks.mesh_grid(nk)[1] @ ks.k_basis.T
+    diag = np.arange(n)
+    pair = np.broadcast_to(np.asarray(delta, dtype='c16'), (n,))
+    volume = (2 * np.pi) ** dim / abs(np.linalg.det(ks.rec_vec_k))
+
+    def omega(q):
+        A = ks.k_basis @ q
+        hole = ks._bloch_ham(k_cart, A=-A) - mu * np.eye(n)
+        big = np.zeros((len(k_cart), 2 * n, 2 * n), 'c16')
+        big[:, :n, :n] = ks._bloch_ham(k_cart, A=A) - mu * np.eye(n)
+        big[:, n:, n:] = -hole
+        big[:, diag, diag + n] = pair
+        big[:, diag + n, diag] = pair.conj()
+        en = np.linalg.eigvalsh(big)
+        free = (-temperature * np.logaddexp(0., -en / temperature) if temperature > 0
+                   else np.minimum(en, 0.))
+        return (np.trace(hole, axis1=1, axis2=2).real.sum() + free.sum()) / (len(k_cart) * volume)
+
+    step = dq * np.eye(dim)
+    w0 = omega(np.zeros(dim))
+    d = np.zeros((dim, dim))
+    for a in range(dim):
+        d[a, a] = (omega(step[a]) - 2 * w0 + omega(-step[a])) / dq ** 2
+        for b in range(a):
+            d[a, b] = d[b, a] = (omega(step[a] + step[b]) - omega(step[a] - step[b])
+                                      - omega(step[b] - step[a]) + omega(-step[a] - step[b])) / (4 * dq ** 2)
+    return d

{tbkit-0.6.2 → tbkit-0.7.0}/tbkit/error_handling.py

@@ -1140,6 +1140,24 @@ def k_vector(vec, var_name, ndim):
             raise TypeError('\n\nParameter {} must contain real numbers.\n'.format(var_name))
 
 
+def k_points(k, var_name, ndim):
+    '''
+    Check that *k* is one k-point (see *k_vector*) or an array of shape
+    (nk, *ndim*) of real numbers.
+
+    Raises
+    ------
+    ValueError
+        Parameter *var_name* must be of shape (nk, ndim).
+    '''
+    if np.ndim(k) != 2:
+        k_vector(k, var_name, ndim)
+        return
+    k = np.asarray(k)
+    if k.shape[1] != ndim or not np.issubdtype(k.dtype, np.number) or np.iscomplexobj(k):
+        raise ValueError('\n\nParameter {} must be a real array of shape (nk, {}).\n'.format(var_name, ndim))
+
+
 def ks(ks, ndim):
     '''
     Check the k-points passed to *kspace.get_bands*: a 2D array of shape
@@ -1568,6 +1586,23 @@ def is_symmetry(err, tol):
                                     '(deviation {:.3g}).\n'.format(err))
 
 
+def symmetry_algebra(u, v, tol):
+    '''
+    Check that two symmetry operators of the same kind agree up to a phase
+    (in *kspace.KSpace.non_hermitian_class*, *v* is a product of others).
+
+    Raises
+    ------
+    ValueError
+        The symmetry operators leave a unitary symmetry: block-diagonalize it first.
+    '''
+    phase = np.trace(u.conj().T @ v) / np.trace(u.conj().T @ u)
+    if not np.allclose(v, phase * u, atol=tol):
+        raise ValueError('\n\nThe symmetry operators leave a unitary symmetry (two products of '
+                                    'the same kind differ by more than a phase): block-diagonalize '
+                                    'the Hamiltonian first.\n')
+
+
 def square(sq, tol):
     '''
     Check that the square of an antiunitary operator is +-1.
@@ -3621,21 +3656,35 @@ def interaction(V, n):
                                     'numbers (one per site).\n'.format(n))
 
 
-def pairing_amplitudes(delta, n):
+def pairing_amplitudes(delta, n, var_name='delta0'):
     '''
-    Check initial pairing amplitudes: a number, or n numbers.
+    Check pairing amplitudes: a number, or n numbers.
 
     Raises
     ------
     ValueError
-        Parameter delta0 must be a number or n numbers.
+        Parameter *var_name* must be a number or n numbers.
     '''
     if np.ndim(delta) == 0:
-        number(delta, 'delta0')
+        number(delta, var_name)
         return
     if np.shape(delta) != (n,):
-        raise ValueError('\n\nParameter delta0 must be a number, or {} numbers '
-                                    '(one per site).\n'.format(n))
+        raise ValueError('\n\nParameter {} must be a number, or {} numbers '
+                                    '(one per site).\n'.format(var_name, n))
+
+
+def spin_up_model(spin):
+    '''
+    Check that a KSpace model is spinless (the spin-up electrons).
+
+    Raises
+    ------
+    ValueError
+        This needs the spinless spin-up model.
+    '''
+    if spin:
+        raise ValueError('\n\nThis needs a spinless model (spin=False): the spin-up '
+                                   'electrons, whose time-reversed partners are the spin-down ones.\n')
 # OPTICAL RESPONSE AND TRANSPORT (tbkit.optics, tbkit.transport)
 ####################################
 

{tbkit-0.6.2 → tbkit-0.7.0}/tbkit/floquet.py

@@ -681,7 +681,24 @@ class DrivenKSpace:
         H_F : Complex ndarray, shape (norb, norb)
         '''
         error_handling.k_vector(k, 'k', self.dim)
-        return _heff(self.get_evolution(k), self.period, self.epsilon)
+        return self._hams(np.asarray(k, dtype='f8')[None])[0]
+
+    def _hams(self, ks: NDArray[np.float64]) -> NDArray[np.complex128]:
+        '''
+        Private method. *get_ham* at the k-points *ks* (shape (nk, dim)): the
+        evolutions of all the k-points advance together, one stacked
+        exponential per time step (the steps of *_grid_steps*), in chunks of
+        bounded memory.
+        '''
+        chunk = max(1, 400000 // (self.norb ** 2 * self.n_steps))
+        out = []
+        for c0 in range(0, len(ks), chunk):
+            hams, durations = self._grid_steps(ks[c0:c0 + chunk])
+            u = np.broadcast_to(np.eye(self.norb, dtype='c16'), (len(hams), self.norb, self.norb))
+            for s, dt in enumerate(durations):
+                u = LA.expm(-1j * dt * hams[:, s]) @ u
+            out += [_heff(uk, self.period, self.epsilon) for uk in u]
+        return np.array(out, dtype='c16').reshape(len(ks), self.norb, self.norb)
 
     def is_hermitian(self) -> bool:
         '''