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

trajectree/quimb/quimb/tensor/tensor_3d_tebd.py

@@ -1,46 +0,0 @@
-"""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

@@ -1,60 +0,0 @@
-"""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)