Trajectree 0.0.0__py3-none-any.whl → 0.0.1__py3-none-any.whl

trajectree/quimb/quimb/tensor/tensor_3d_tebd.py

@@ -0,0 +1,46 @@
+"""Tools for performing TEBD like algorithms on a 3D lattice."""
+
+from .tensor_3d import gen_3d_bonds
+from .tensor_arbgeom_tebd import LocalHamGen
+
+
+class LocalHam3D(LocalHamGen):
+    def __init__(self, Lx, Ly, Lz, H2, H1=None, cyclic=False):
+        self.Lx = int(Lx)
+        self.Ly = int(Ly)
+        self.Lz = int(Lz)
+
+        # parse two site terms
+        if hasattr(H2, "shape"):
+            # use as default nearest neighbour term
+            H2 = {None: H2}
+        else:
+            H2 = dict(H2)
+
+        # possibly fill in default gates
+        default_H2 = H2.pop(None, None)
+        if default_H2 is not None:
+            for coo_a, coo_b in gen_3d_bonds(
+                Lx,
+                Ly,
+                Lz,
+                steppers=[
+                    lambda i, j, k: (i, j, k + 1),
+                    lambda i, j, k: (i, j + 1, k),
+                    lambda i, j, k: (i + 1, j, k),
+                ],
+                cyclic=cyclic,
+            ):
+                if (coo_a, coo_b) not in H2 and (coo_b, coo_a) not in H2:
+                    H2[coo_a, coo_b] = default_H2
+
+        super().__init__(H2=H2, H1=H1)
+
+    @property
+    def nsites(self):
+        """The number of sites in the system."""
+        return self.Lx * self.Ly * self.Lz
+
+    def __repr__(self):
+        s = "<LocalHam3D(Lx={}, Ly={}, Lx={}, num_terms={})>"
+        return s.format(self.Lx, self.Ly, self.Lz, len(self.terms))

trajectree/quimb/quimb/tensor/tensor_approx_spectral.py

@@ -0,0 +1,60 @@
+"""Approximating spectral functions with tensor networks.
+"""
+
+import numpy as np
+import random
+
+import quimb as qu
+
+from .tensor_builder import MPO_rand, MPO_zeros_like
+
+
+def construct_lanczos_tridiag_MPO(A, K, v0=None, initial_bond_dim=None,
+                                  beta_tol=1e-6, max_bond=None, seed=False,
+                                  v0_opts=None, k_min=10):
+    """
+    """
+    if initial_bond_dim is None:
+        initial_bond_dim = 8
+    if max_bond is None:
+        max_bond = 8
+
+    if v0 is None:
+        if seed:
+            # needs to be truly random so MPI processes don't overlap
+            qu.seed_rand(random.SystemRandom().randint(0, 2**32 - 1))
+
+        V = MPO_rand(A.L, initial_bond_dim,
+                     phys_dim=A.phys_dim(), dtype=A.dtype)
+    else:  # normalize
+        V = v0 / (v0.H @ v0)**0.5
+    Vm1 = MPO_zeros_like(V)
+
+    alpha = np.zeros(K + 1)
+    beta = np.zeros(K + 2)
+
+    bsz = A.phys_dim()**A.L
+    beta[1] = bsz  # == sqrt(prod(A.shape))
+
+    compress_kws = {'max_bond': max_bond, 'method': 'svd', "renorm": True}
+
+    for j in range(1, K + 1):
+
+        Vt = A.apply(V, compress=True, **compress_kws)
+        Vt.add_MPO(-beta[j] * Vm1, inplace=True, compress=True, **compress_kws)
+        alpha[j] = (V.H @ Vt).real
+        Vt.add_MPO(-alpha[j] * V, inplace=True, compress=True, **compress_kws)
+        beta[j + 1] = (Vt.H @ Vt)**0.5
+
+        # check for convergence
+        if abs(beta[j + 1]) < beta_tol:
+            yield alpha[1:j + 1], beta[2:j + 2], beta[1]**2 / bsz
+            break
+
+        Vm1 = V.copy()
+        V = Vt / beta[j + 1]
+
+        if j >= k_min:
+            yield (np.copy(alpha[1:j + 1]),
+                   np.copy(beta[2:j + 2]),
+                   np.copy(beta[1])**2 / bsz)