def test_energy_contraction_ones_z2(self):
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps Energy (Ham=Identity, peps=ones, Z2 symmetry) calculation\n'
+ '-' * 50)
# Create a PEPS
from cyclopeps.tools.peps_tools import PEPS
Nx = 2
Ny = 2
d = 2
D = 3
Zn = 2
backend = 'numpy'
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=1000,
Zn=2,
backend=backend,
normalize=False)
# Set all tensor values to 1
for xind in range(Nx):
for yind in range(Ny):
peps[xind][yind].fill_all(1.)
# Get the Hamiltonian
from cyclopeps.ops.identity import return_op
ham = return_op(Nx, Ny, sym='Z2', backend=backend)
# Calculate initial norm
norm0 = peps.calc_norm() * 4.
mpiprint(0, 'Norm (routine) = {}'.format(norm0))
# Perform the Exact energy calculation:
bra = einsum('LDWCM,lMXcu->LDluWXCc', peps[0][0],
peps[0][1]).remove_empty_ind(0).remove_empty_ind(
0).remove_empty_ind(0).remove_empty_ind(0)
bra = einsum('WXCc,CdYRm->dRWXYcm', bra,
peps[1][0]).remove_empty_ind(0).remove_empty_ind(0)
bra = einsum('WXYcm,cmZru->ruWXYZ', bra,
peps[1][1]).remove_empty_ind(0).remove_empty_ind(0)
norm1 = einsum('WXYZ,WXYZ->', bra, bra.conj())
norm1 = norm1 * 4.
mpiprint(0, 'Norm (explicit) = {}'.format(norm1))
tmp = einsum('WXYZ,wxYZ->WXwx', bra, bra.conj())
E1 = einsum('WXwx,WXwx->', tmp, ham[0][0][0])
tmp = einsum('WXYZ,wXyZ->WYwy', bra, bra.conj())
E1 += einsum('WYwy,WYwy->', tmp, ham[1][0][0])
tmp = einsum('WXYZ,WXyz->YZyz', bra, bra.conj())
E1 += einsum('YZyz,YZyz->', tmp, ham[0][1][0])
tmp = einsum('WXYZ,WxYz->XZxz', bra, bra.conj())
E1 += einsum('XZxz,XZxz->', tmp, ham[1][1][0])
mpiprint(0,
'Explicitly computed energy (not normalized) = {}'.format(E1))
# Contract Energy again
E2 = peps.calc_op(ham, normalize=False)
mpiprint(0, 'Energy via peps Method (not normalized) = {}'.format(E2))
self.assertTrue(abs((norm0 - norm1) / norm0) < 1e-10)
print('Check here {}, {}, {}, {}'.format(norm0, norm1, E1, E2))
self.assertTrue(abs((norm0 - E1) / norm0) < 1e-10)
self.assertTrue(abs((norm0 - E2) / norm0) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_canonical_normalization_z2(self):
from cyclopeps.tools.peps_tools import PEPS
mpiprint(
0, '\n' + '=' * 50 +
'\nCanonical Peps Normalization test (Z2 Symmetry) \n' + '-' * 50)
Nx = 3
Ny = 5
d = 2
D = 3
chi = 10
Zn = 2
backend = 'numpy'
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
Zn=Zn,
backend=backend,
normalize=False,
canonical=True)
norm = peps.calc_norm(chi=chi)
norm = peps.normalize()
mpiprint(0, 'Norm = {}'.format(norm))
self.assertTrue(abs(1.0 - norm) < 1e-3)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_normalization_Z3(self):
from cyclopeps.tools.peps_tools import PEPS
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps (5x5) Normalization test with Z3 Symmetry\n' + '-' * 50)
Nx = 5
Ny = 5
d = 2
D = 6
chi = 50
Zn = 3 # Zn symmetry (here, Z3)
dZn = 2
backend = 'ctf'
# Generate random PEPS
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
Zn=Zn,
dZn=dZn,
backend=backend,
normalize=False)
# Compute the norm (2 ways for comparison)
peps_sparse = peps.make_sparse()
norm0 = peps.calc_norm(chi=chi)
norm1 = peps_sparse.calc_norm(chi=chi)
mpiprint(0, 'Symmetric Sparse Norm = {}'.format(norm1))
mpiprint(0, 'Symmetric Dense Norm = {}'.format(norm0))
self.assertTrue(abs((norm0 - norm1) / norm1) < 1e-3)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_normalization_ctf(self):
from cyclopeps.tools.peps_tools import PEPS
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps (5x5) Normalization test without Symmetry (ctf)\n' +
'-' * 50)
Nx = 5
Ny = 5
d = 2
D = 6
chi = 10
Zn = None
backend = 'ctf'
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
Zn=Zn,
backend=backend,
normalize=True)
norm = peps.calc_norm(chi=chi)
mpiprint(0, 'Norm = {}'.format(norm))
self.assertTrue(abs(1.0 - norm) < 1e-3)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_energy_contraction_heis_z2(self):
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps Energy (Ham=Heisenberg, peps=random, Z2 symmetry) calculation\n'
+ '-' * 50)
# Create a PEPS
from cyclopeps.tools.peps_tools import PEPS
Nx = 2
Ny = 2
d = 2
D = 3
Zn = 2
backend = 'ctf'
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=1000,
Zn=2,
backend=backend,
normalize=False)
# Get the Hamiltonian
from cyclopeps.ops.heis import return_op
ham = return_op(Nx, Ny, sym='Z2', backend=backend)
# Calculate initial norm
norm0 = peps.calc_norm()
mpiprint(0, 'Norm (routine) = {}'.format(norm0))
# Perform the Exact energy calculation:
bra = einsum('LDWCM,lMXcu->LDluWXCc', peps[0][0],
peps[0][1]).remove_empty_ind(0).remove_empty_ind(
0).remove_empty_ind(0).remove_empty_ind(0)
bra = einsum('WXCc,CdYRm->dRWXYcm', bra,
peps[1][0]).remove_empty_ind(0).remove_empty_ind(0)
bra = einsum('WXYcm,cmZru->ruWXYZ', bra,
peps[1][1]).remove_empty_ind(0).remove_empty_ind(0)
norm1 = einsum('WXYZ,WXYZ->', bra, bra.conj())
norm1 = norm1
mpiprint(0, 'Norm (explicit) = {}'.format(norm1))
#print(ham[0][0][0])
tmp = einsum('WXYZ,wxYZ->WXwx', bra, bra.conj())
E1 = einsum('WXwx,WXwx->', tmp, ham[0][0][0])
tmp = einsum('WXYZ,wXyZ->WYwy', bra, bra.conj())
E1 += einsum('WYwy,WYwy->', tmp, ham[1][0][0])
tmp = einsum('WXYZ,WXyz->YZyz', bra, bra.conj())
E1 += einsum('YZyz,YZyz->', tmp, ham[0][1][0])
tmp = einsum('WXYZ,WxYz->XZxz', bra, bra.conj())
E1 += einsum('XZxz,XZxz->', tmp, ham[1][1][0])
E1 = E1
mpiprint(0,
'Explicitly computed energy (not normalized) = {}'.format(E1))
# Contract Energy again
E2 = peps.calc_op(ham, normalize=False)
mpiprint(0, 'Energy via peps Method (not normalized) = {}'.format(E2))
self.assertTrue(abs((norm0 - norm1) / norm0) < 1e-10)
self.assertTrue(abs((E2 - E1) / E1) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_rotate_ctf(self):
mpiprint(0,
'\n' + '=' * 50 + '\nPeps Rotation test (ctf)\n' + '-' * 50)
from cyclopeps.tools.peps_tools import PEPS
Nx = 3
Ny = 3
d = 2
D = 3
chi = 100
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
normalize=False,
backend='ctf')
norm0 = peps.calc_norm()
peps.rotate()
norm1 = peps.calc_norm()
peps.rotate(clockwise=False)
norm2 = peps.calc_norm()
mpiprint(0, 'Norms = {},{},{}'.format(norm0, norm1, norm2))
self.assertTrue(abs((norm0 - norm1) / norm0) < 1e-5)
self.assertTrue(abs((norm0 - norm2) / norm0) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_canonical_rotate_z2(self):
mpiprint(
0, '\n' + '=' * 50 +
'\nCanonical Peps Rotation test (Z2 Symmetry)\n' + '-' * 50)
from cyclopeps.tools.peps_tools import PEPS
Nx = 3
Ny = 3
d = 2
D = 3
chi = 10
Zn = 2
backend = 'numpy'
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
Zn=Zn,
backend=backend,
normalize=False,
canonical=True)
norm0 = peps.calc_norm()
peps.rotate()
norm1 = peps.calc_norm()
peps.rotate(clockwise=False)
norm2 = peps.calc_norm()
mpiprint(0, 'Norms = {},{},{}'.format(norm0, norm1, norm2))
self.assertTrue(abs((norm0 - norm1) / norm0) < 1e-3)
self.assertTrue(abs((norm0 - norm2) / norm0) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_canonical_flip(self):
mpiprint(
0, '\n' + '=' * 50 + '\nCanonical Peps Flipping test\n' + '-' * 50)
from cyclopeps.tools.peps_tools import PEPS
Nx = 5
Ny = 5
d = 2
D = 3
chi = 10
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
normalize=False,
canonical=True)
norm0 = peps.calc_norm()
peps.flip()
norm1 = peps.calc_norm()
peps.flip()
norm2 = peps.calc_norm()
mpiprint(0, 'Norms = {},{},{}'.format(norm0, norm1, norm2))
self.assertTrue(abs((norm0 - norm1) / norm0) < 1e-3)
self.assertTrue(abs((norm0 - norm2) / norm0) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_energy_itf_contraction_ones(self):
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps Energy (Ham=ITF, peps=ones, no symmetry) calculation\n' +
'-' * 50)
# Create a PEPS
from cyclopeps.tools.peps_tools import PEPS
Nx = 2
Ny = 2
d = 2
D = 3
backend = 'ctf'
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=1000,
normalize=False,
backend=backend)
# Set all tensor values to 1
for xind in range(Nx):
for yind in range(Ny):
peps[xind][yind].fill_all(1.)
# Get the Hamiltonian
from cyclopeps.ops.itf import return_op
ham = return_op(Nx, Ny, (1., 2.), backend=backend)
# Calculate initial norm
norm0 = peps.calc_norm()
mpiprint(0, 'Norm = {}'.format(norm0))
# Perform the Exact energy calculation:
bra = einsum('LDWCM,lMXcu->WXCc', peps[0][0], peps[0][1])
bra = einsum('WXCc,CdYRm->WXYcm', bra, peps[1][0])
bra = einsum('WXYcm,cmZru->WXYZ', bra, peps[1][1])
norm1 = einsum('WXYZ,WXYZ->', bra, bra.conj())
mpiprint(0, 'Explicitly computed norm = {}'.format(norm1))
tmp = einsum('WXYZ,wxYZ->WXwx', bra, bra.conj())
E1 = einsum('WXwx,WXwx->', tmp, ham[0][0][0])
tmp = einsum('WXYZ,wXyZ->WYwy', bra, bra.conj())
E1 += einsum('WYwy,WYwy->', tmp, ham[1][0][0])
tmp = einsum('WXYZ,WXyz->YZyz', bra, bra.conj())
E1 += einsum('YZyz,YZyz->', tmp, ham[0][1][0])
tmp = einsum('WXYZ,WxYz->XZxz', bra, bra.conj())
E1 += einsum('XZxz,XZxz->', tmp, ham[1][1][0])
mpiprint(0,
'Explicitly computed energy (not normalized) = {}'.format(E1))
# Contract Energy again
E2 = peps.calc_op(ham, normalize=False)
mpiprint(0, 'Energy (routine) = {}'.format(E2))
self.assertTrue(abs((E2 - E1) / E1) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_energy_contraction(self):
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps Energy (Ham=Identity, peps=random, no symmetry) calculation\n'
+ '-' * 50)
# Create a PEPS
from cyclopeps.tools.peps_tools import PEPS
Nx = 2
Ny = 2
d = 2
D = 3
backend = 'ctf'
peps = PEPS(Nx=Nx, Ny=Ny, d=d, D=D, chi=1000, backend=backend)
# Get the Hamiltonian
from cyclopeps.ops.identity import return_op
ham = return_op(Nx, Ny, backend=backend)
# Calculate initial norm
norm0 = peps.calc_norm() * 4.
# Perform the Exact energy calculation:
bra = einsum('LDWCM,lMXcu->WXCc', peps[0][0], peps[0][1])
bra = einsum('WXCc,CdYRm->WXYcm', bra, peps[1][0])
bra = einsum('WXYcm,cmZru->WXYZ', bra, peps[1][1])
norm1 = einsum('WXYZ,WXYZ->', bra, bra.conj()) * 4.
tmp = einsum('WXYZ,wxYZ->WXwx', bra, bra.conj())
E1 = einsum('WXwx,WXwx->', tmp, ham[0][0][0])
tmp = einsum('WXYZ,wXyZ->WYwy', bra, bra.conj())
E1 += einsum('WYwy,WYwy->', tmp, ham[1][0][0])
tmp = einsum('WXYZ,WXyz->YZyz', bra, bra.conj())
E1 += einsum('YZyz,YZyz->', tmp, ham[0][1][0])
tmp = einsum('WXYZ,WxYz->XZxz', bra, bra.conj())
E1 += einsum('XZxz,XZxz->', tmp, ham[1][1][0])
# Contract Energy again
E2 = peps.calc_op(ham, normalize=False)
self.assertTrue(abs((norm0 - norm1) / norm0) < 1e-10)
mpiprint(0, 'Passed Norm1')
self.assertTrue(abs((norm0 - E1) / norm0) < 1e-10)
mpiprint(0, 'Passed E1')
mpiprint(0, 'Norm from calc_norm = {}'.format(norm0))
mpiprint(0, 'Norm from exact contraction {}'.format(norm1))
mpiprint(0, 'Norm from Energy calc op = {}'.format(E2))
mpiprint(0, 'Norm from Energy exact contraction {}'.format(E1))
#mpiprint(0,norm1,E1,norm0,E2,abs((norm0-E2)/norm0))
self.assertTrue(abs((norm0 - E2) / norm0) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_energy_itf_contraction(self):
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps Energy (Ham=ITF, peps=random, no symmetry) calculation\n' +
'-' * 50)
# Create a PEPS
from cyclopeps.tools.peps_tools import PEPS
Nx = 2
Ny = 2
d = 2
D = 3
backend = 'ctf'
peps = PEPS(Nx=Nx, Ny=Ny, d=d, D=D, chi=1000, backend=backend)
peps2 = PEPS(Nx=Nx, Ny=Ny, d=d, D=D, chi=1000, backend=backend)
# Get the Hamiltonian
from cyclopeps.ops.itf import return_op
ham = return_op(Nx, Ny, (1., 2.), backend=backend)
# Perform the Exact energy calculation:
bra = einsum('LDWCM,lMXcu->WXCc', peps[0][0], peps[0][1])
bra = einsum('WXCc,CdYRm->WXYcm', bra, peps[1][0])
bra = einsum('WXYcm,cmZru->WXYZ', bra, peps[1][1])
ket = einsum('LDWCM,lMXcu->WXCc', peps2[0][0], peps2[0][1])
ket = einsum('WXCc,CdYRm->WXYcm', ket, peps2[1][0])
ket = einsum('WXYcm,cmZru->WXYZ', ket, peps2[1][1])
norm1 = einsum('WXYZ,WXYZ->', bra, ket)
tmp = einsum('WXYZ,wxYZ->WXwx', bra, ket)
E1 = einsum('WXwx,WXwx->', tmp, ham[0][0][0])
tmp = einsum('WXYZ,wXyZ->WYwy', bra, ket)
E2 = einsum('WYwy,WYwy->', tmp, ham[1][0][0])
tmp = einsum('WXYZ,WXyz->YZyz', bra, ket)
E3 = einsum('YZyz,YZyz->', tmp, ham[0][1][0])
tmp = einsum('WXYZ,WxYz->XZxz', bra, ket)
E4 = einsum('XZxz,XZxz->', tmp, ham[1][1][0])
E1 = E1 + E2 + E3 + E4
# Contract Energy again
E2 = peps.calc_op(ham, normalize=False, chi=1e100, ket=peps2)
mpiprint(0, 'Energy (exact) = {}'.format(E1))
mpiprint(0, 'Energy (routine) = {}'.format(E2))
self.assertTrue(abs((E2 - E1) / E1) < 1e-10)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_flip_Z2_ctf(self):
mpiprint(
0, '\n' + '=' * 50 + '\nPeps Z2 Flipping test (ctf)\n' + '-' * 50)
from cyclopeps.tools.peps_tools import PEPS
Nx = 5
Ny = 5
d = 2
D = 6
Zn = 2
chi = 10
backend = 'ctf'
# Generate random PEPS
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
Zn=Zn,
backend=backend,
normalize=False)
# Compute the norm (2 ways for comparison)
norm0 = peps.calc_norm(chi=chi)
peps_sparse = peps.make_sparse()
norm1 = peps_sparse.calc_norm(chi=chi)
mpiprint(0, 'Symmetric Dense Norm = {}'.format(norm0))
mpiprint(0, 'Symmetric Sparse Norm = {}'.format(norm1))
# Rotate the PEPS
peps.flip()
norm2 = peps.calc_norm(chi=chi)
peps_sparse = peps.make_sparse()
norm3 = peps_sparse.calc_norm(chi=chi)
mpiprint(0, 'Flipped Symmetric Dense Norm = {}'.format(norm2))
mpiprint(0, 'Flipped Symmetric Sparse Norm = {}'.format(norm3))
self.assertTrue(abs((norm0 - norm1) / norm1) < 1e-3)
self.assertTrue(abs((norm0 - norm2) / norm2) < 1e-3)
self.assertTrue(abs((norm0 - norm3) / norm3) < 1e-3)
mpiprint(0, 'Passed\n' + '=' * 50)
def test_normalization_Z2_ctf(self):
from cyclopeps.tools.peps_tools import PEPS
mpiprint(
0, '\n' + '=' * 50 +
'\nPeps (5x5) Normalization test with Z2 Symmetry (ctf)\n' +
'-' * 50)
Nx = 5
Ny = 5
d = 2
D = 6
chi = 10
Zn = 2 # Zn symmetry (here, Z2)
backend = 'ctf'
# Generate random PEPS
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
Zn=Zn,
backend=backend,
normalize=False)
# Compute the norm (2 ways for comparison)
norm0 = peps.calc_norm(chi=chi)
peps_sparse = peps.make_sparse()
norm1 = peps_sparse.calc_norm(chi=chi)
mpiprint(0, 'Symmetric Dense Norm = {}'.format(norm0))
mpiprint(0, 'Symmetric Sparse Norm = {}'.format(norm1))
# Normalize the PEPS
norm2 = peps.normalize()
peps_sparse = peps.make_sparse()
norm3 = peps_sparse.calc_norm(chi=chi)
mpiprint(0,
'Symmetric Dense Norm (After normalized) = {}'.format(norm2))
mpiprint(0,
'Symmetric Sparse Norm (After normalized) = {}'.format(norm3))
# Do some assertions to check if passed
self.assertTrue(abs((norm0 - norm1) / norm1) < 1e-3)
self.assertTrue(abs(1.0 - norm2) < 1e-3)
self.assertTrue(abs(1.0 - norm3) < 1e-3)
mpiprint(0, 'Passed\n' + '=' * 50)
# TEBD Parameters
step_sizes = [0.1]
n_step = [5]
# Get Hamiltonian
if Zn is None:
ham = return_op(Nx, Ny, sym=None, backend=backend)
else:
ham = return_op(Nx, Ny, sym='Z2', backend=backend)
# Create PEPS
peps = PEPS(Nx,
Ny,
d,
D,
chi,
Zn=Zn,
chi_norm=10,
chi_op=10,
backend=backend,
normalize=False)
# Setup Profiling
profile_fname = 'calc_norm_stats_Nx{}_Ny{}_d{}_D{}_chi{}_Zn{}_{}'.format(
Nx, Ny, d, D, chi, Zn, backend)
if backend == 'ctf':
from ctf import timer_epoch
te = timer_epoch('1')
te.begin()
t0 = time.time()
# Evaluate Operator
cProfile.run('val = peps.calc_norm(chi=chi)', profile_fname)
print('dr = {}'.format(dr))
print('dl = {}'.format(dl))
print('du = {}'.format(du))
print('dd = {}'.format(dd))
print('sx = {}'.format(sx))
print('sy = {}'.format(sy))
# Create the Suzuki trotter decomposed operator
ops = return_op(Nx, Ny, params)
opsl = ops_conj_trans(ops)
curr_ops = return_curr_op(Nx, Ny, params)
dens_ops_top = return_dens_op(Nx, Ny, top=True)
dens_ops_bot = return_dens_op(Nx, Ny, top=False)
# Run TEBD
peps = PEPS(Nx, Ny, d, D[0], chi[0], fname=fnamer, fdir=savedir)
pepsl = PEPS(Nx, Ny, d, D[0], chi[0], fname=fnamel, fdir=savedir)
# Loop over all optimizaton parameters
for ind in range(len(D)):
# --------------------------------------------------------------------
# Calculate right eigenstate
Ef, peps = run_tebd(Nx,
Ny,
d,
ops,
peps=peps,
D=D[ind],
chi=chi[ind],
n_step=n_step[ind],
print('dl = {}'.format(dl))
print('du = {}'.format(du))
print('dd = {}'.format(dd))
print('sx = {}'.format(sx))
print('sy = {}'.format(sy))
# Create the Suzuki trotter decomposed operator
ops = return_op(Nx, Ny, params)
opsl = ops_conj_trans(ops)
# Run TEBD
pepsl = PEPS(Nx,
Ny,
d,
D[0],
chi[0],
fname=fnamel,
fdir=savedir,
norm_tol=0.5,
norm_bs_upper=3.,
norm_bs_lower=0.)
# Loop over all optimizaton parameters
for ind in range(len(D)):
# Update PEPS Parameters
pepsl.D = D[ind]
pepsl.chi = chi[ind]
pepsl.fname = prepend + "Nx{}_Ny{}_sx{}_sy{}_D{}_chi{}_run_left".format(
Nx, Ny, sxind, syind, D[ind], chi[ind])
# --------------------------------------------------------------------
# Calculate left eigenstate
print('dr = {}'.format(dr))
print('dl = {}'.format(dl))
print('du = {}'.format(du))
print('dd = {}'.format(dd))
print('sx = {}'.format(sx))
print('sy = {}'.format(sy))
# Create the Suzuki trotter decomposed operator
ops = return_op(Nx,Ny,params)
opsl= ops_conj_trans(ops)
curr_ops = return_curr_op(Nx,Ny,params)
dens_ops_top = return_dens_op(Nx,Ny,top=True)
dens_ops_bot = return_dens_op(Nx,Ny,top=False)
# Run TEBD
peps = PEPS(Nx,Ny,d,D[0],chi[0])
pepsl = PEPS(Nx,Ny,d,D[0],chi[0])
for ind in range(len(D)):
print('Right Vector' + '-'*50)
# Calculate right state
try:
Ef,peps = run_tebd(Nx,
Ny,
d,
ops,
peps=peps,
D=D[ind],
chi=chi[ind],
n_step=ns[ind],
step_size=dt[ind])
except Exception as e:
from cyclopeps.tools.peps_tools import PEPS, load_peps
from cyclopeps.ops.asep import return_op
from cyclopeps.algs.tebd import run_tebd
from cyclopeps.algs.tebd import run_tebd
from sys import argv
import numpy as np
# Get input values
fname = argv[1]
Nx = int(argv[2])
Ny = int(argv[3])
start = 3
# ---------------------------------------------------------
# Create an initial peps
peps = PEPS(Nx=Nx, Ny=Ny, fname=fname + '_restart', fdir='./', normalize=False)
peps.load_tensors(fname)
# TEBD Parameters
step_sizes = [
0.5, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1,
0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01,
0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1,
0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01, 0.1, 0.01,
0.1, 0.01, 0.1, 0.01
]
D = [
1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5,
5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9,
9, 10, 10, 10, 10, 10, 10
]
import pstats
# Get inputs
Ny = int(argv[1])
Nx = int(argv[2])
d = 2
D = int(argv[3])
chi = int(argv[4])
Zn = int(argv[5])
backend = 'numpy'
# Create a random pep
peps = PEPS(Nx=Nx,
Ny=Ny,
d=d,
D=D,
chi=chi,
Zn=Zn,
backend=backend,
normalize=False)
# contract the norm
fname = argv[6] + '_norm_stats_Nx' + str(Nx) + '_Ny' + str(Ny) + '_d' + str(
d) + '_D' + str(D) + '_chi' + str(chi)
t0 = time.time()
cProfile.run('norm = peps.calc_norm(chi=chi)', fname + '_symtensor')
tf = time.time()
print('Symtensor Contraction Time = {}'.format(tf - t0))
peps_sparse = peps.make_sparse()
t0 = time.time()
cProfile.run('norm1 = peps_sparse.calc_norm(chi=chi)', fname + '_slow')
print('Slow Contraction Time = {}'.format(tf - t0))
for N in Nvec:
for prepend in prepend_vec:
for dind in range(len(D)):
for sxind in range(21)[::-1]:
loaded = False
# Get peps loaded
try:
fnamel = prepend + 'Nx{}_Ny{}_sx{}_sy{}_D{}_chi{}_run_left'.format(
N, N, sxind, 0, D[dind], chi[dind])
pepsl = PEPS(N,
N,
d,
D[dind],
chi[dind],
norm_tol=0.5,
norm_bs_upper=3.,
norm_bs_lower=0.,
normalize=False)
pepsl.load_tensors(pepsdir + fnamel)
loaded = True
except Exception as e:
#print('Failed to get PEPS left loaded: {}'.format(e))
pepsl = None
try:
fnamer = prepend + 'Nx{}_Ny{}_sx{}_sy{}_D{}_chi{}_run_right'.format(
N, N, sxind, 0, D[dind], chi[dind])
peps = PEPS(N,
N,
d,
print('sx = {}'.format(sx))
print('sy = {}'.format(sy))
# Create the Suzuki trotter decomposed operator
ops = return_op(Nx, Ny, params)
opsl = ops_conj_trans(ops)
curr_ops = return_curr_op(Nx, Ny, params)
dens_ops_top = return_dens_op(Nx, Ny, top=True)
dens_ops_bot = return_dens_op(Nx, Ny, top=False)
# Run TEBD
peps = PEPS(Nx,
Ny,
d,
D[0],
chi[0],
fname=fnamer,
fdir=savedir,
norm_tol=0.5,
norm_bs_upper=3.,
norm_bs_lower=0.)
pepsl = PEPS(Nx,
Ny,
d,
D[0],
chi[0],
fname=fnamel,
fdir=savedir,
norm_tol=0.5,
norm_bs_upper=3.,
norm_bs_lower=0.)