Esempio n. 1
0
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,
Esempio n. 2
0
                    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,
Esempio n. 3
0
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:])