print('jl = {}'.format(jl))
print('ju = {}'.format(ju))
print('jd = {}'.format(jd))
print('cr = {}'.format(cr))
print('cl = {}'.format(cl))
print('cu = {}'.format(cu))
print('cd = {}'.format(cd))
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,
jd = 1. - ju
cr = 0.5
cl = 0.5
cu = 0.5
cd = 0.5
dr = 0.5
dl = 0.5
du = 0.5
dd = 0.5
sx = sxVec[sxind]
sy = syVec[0]
params = (jr, jl, ju, jd, cr, cl, cu, cd, dr, dl, du, dd,
sx, sy)
# Create the Suzuki trotter decomposed operator
ops = return_op(N, N, params)
opsl = ops_conj_trans(ops)
curr_ops = return_curr_op(N, N, params)
dens_ops_top = return_dens_op(N, N, top=True)
dens_ops_bot = return_dens_op(N, N, top=False)
try:
E = peps.calc_op(ops, return_sum=True, chi=chi[dind])
El = pepsl.calc_op(opsl,
return_sum=True,
chi=chi[dind])
Elr = peps.calc_op(ops,
return_sum=True,
ket=pepsl,
chi=chi[dind])
currents = peps.calc_op(curr_ops,
jr = 0.9
jl = 0.1
ju = 0.5
jd = 0.5
cr = 0.5
cl = 0.5
cu = 0.5
cd = 0.5
dr = 0.5
dl = 0.5
du = 0.5
dd = 0.5
sx = -0.5
sy = 0.
params = (jr, jl, ju, jd, cr, cl, cu, cd, dr, dl, du, dd, sx, sy)
# Create the Suzuki trotter decomposed operator
ops = return_op(peps.Nx, peps.Ny, params)
# Run TEBD
Ef, _ = run_tebd(peps.Nx,
peps.Ny,
peps.d,
ops,
peps=peps,
D=D[start:],
chi=chi[start:],
n_step=n_step[start:],
conv_tol=1e-8,
step_size=step_sizes[start:])