def run_out_of_equilibrium(): L = 10 chi = 5 delta_t = 0.1 model_params = { 'L': L, 'S': 0.5, 'conserve': 'Sz', 'Jz': 1.0, 'Jy': 1.0, 'Jx': 1.0, 'hx': 0.0, 'hy': 0.0, 'hz': 0.0, 'muJ': 0.0, 'bc_MPS': 'finite', } heisenberg = tenpy.models.spins.SpinChain(model_params) product_state = ["up"] * int(L / 2) + ["down"] * ( L - int(L / 2) ) #starting from a product state which is not an eigenstate of the Heisenberg model psi = MPS.from_product_state(heisenberg.lat.mps_sites(), product_state, bc=heisenberg.lat.bc_MPS, form='B') tdvp_params = { 'start_time': 0, 'dt': delta_t, 'trunc_params': { 'chi_max': chi, 'svd_min': 1.e-10, 'trunc_cut': None } } tdvp_engine = tdvp.Engine(psi=psi, model=heisenberg, TDVP_params=tdvp_params) times = [] S_mid = [] for i in range(30): tdvp_engine.run_two_sites(N_steps=1) times.append(tdvp_engine.evolved_time) S_mid.append(psi.entanglement_entropy(bonds=[L // 2])[0]) for i in range(30): tdvp_engine.run_one_site(N_steps=1) #psi_2=copy.deepcopy(psi) #psi_2.canonical_form() times.append(tdvp_engine.evolved_time) S_mid.append(psi.entanglement_entropy(bonds=[L // 2])[0]) import matplotlib.pyplot as plt plt.figure() plt.plot(times, S_mid) plt.xlabel('t') plt.ylabel('S') plt.axvline(x=3.1, color='red') plt.text(0.0, 0.0000015, "Two sites update") plt.text(3.1, 0.0000015, "One site update") plt.show()
def test_tebd(bc_MPS, g=0.5): L = 2 if bc_MPS == 'infinite' else 6 # xxz_pars = dict(L=L, Jxx=1., Jz=3., hz=0., bc_MPS=bc_MPS) # M = XXZChain(xxz_pars) # factor of 4 (2) for J (h) to change spin-1/2 to Pauli matrices model_pars = dict(L=L, Jx=0., Jy=0., Jz=-4., hx=2. * g, bc_MPS=bc_MPS, conserve=None) M = SpinChain(model_pars) state = ([[1, -1.], [1, -1.]] * L)[:L] # pointing in (-x)-direction psi = MPS.from_product_state(M.lat.mps_sites(), state, bc=bc_MPS) tebd_param = { 'verbose': 2, 'dt': 0.01, 'order': 2, 'delta_tau_list': [0.1, 1.e-4, 1.e-8], 'max_error_E': 1.e-9, 'trunc_params': { 'chi_max': 50, 'trunc_cut': 1.e-13 } } engine = tebd.Engine(psi, M, tebd_param) engine.run_GS() print("norm_test", psi.norm_test()) if bc_MPS == 'finite': psi.canonical_form() ED = ExactDiag(M) ED.build_full_H_from_mpo() ED.full_diagonalization() psi_ED = ED.groundstate() Etebd = np.sum(M.bond_energies(psi)) Eexact = np.min(ED.E) print("E_TEBD={Etebd:.14f} vs E_exact={Eex:.14f}".format(Etebd=Etebd, Eex=Eexact)) assert (abs((Etebd - Eexact) / Eexact) < 1.e-7) ov = npc.inner(psi_ED, ED.mps_to_full(psi), do_conj=True) print("compare with ED: overlap = ", abs(ov)**2) assert (abs(abs(ov) - 1.) < 1.e-7) # Test real time TEBD: should change on an eigenstate Sold = np.average(psi.entanglement_entropy()) for i in range(3): engine.run() Enew = np.sum(M.bond_energies(psi)) Snew = np.average(psi.entanglement_entropy()) assert (abs(Enew - Etebd) < 1.e-8) assert (abs(Sold - Snew) < 1.e-5) # somehow we need larger tolerance here.... if bc_MPS == 'infinite': Etebd = np.average(M.bond_energies(psi)) Eexact = e0_tranverse_ising(g) print("E_TEBD={Etebd:.14f} vs E_exact={Eex:.14f}".format(Etebd=Etebd, Eex=Eexact)) Sold = np.average(psi.entanglement_entropy()) for i in range(2): engine.run() Enew = np.average(M.bond_energies(psi)) Snew = np.average(psi.entanglement_entropy()) assert (abs(Etebd - Enew) < 1.e-7) assert (abs(Sold - Snew) < 1.e-5) # somehow we need larger tolerance here....
def DMRG_tf_ising_finite(Lx, Ly, g, verbose=True): print("finite DMRG, transverse field Ising model") print("Lx={Lx:d}, Ly={Ly:d}, g={g:.2f}".format(Lx=Lx, Ly=Ly, g=g)) M = TFIModel( dict(g=g, J=1., lattice='Triangular', bc_MPS='finite', Lx=Lx, Ly=Ly, conserve=None, verbose=verbose)) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) dmrg_params = { 'mixer': None, 'max_E_err': 1.e-10, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'verbose': verbose, 'combine': True } info = dmrg.run(psi, M, dmrg_params) E = info['E'] print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) mag_x = np.sum(psi.expectation_value("Sigmax")) mag_z = np.sum(psi.expectation_value("Sigmaz")) print("magnetization in X = {mag_x:.5f}".format(mag_x=mag_x)) print("magnetization in Z = {mag_z:.5f}".format(mag_z=mag_z)) return E, psi, M
def example_TEBD_gs_tf_ising_infinite(g, verbose=True): print("infinite TEBD, imaginary time evolution, transverse field Ising") print("g={g:.2f}".format(g=g)) model_params = dict(L=2, J=1., g=g, bc_MPS='infinite', conserve=None, verbose=verbose) M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) tebd_params = { 'order': 2, 'delta_tau_list': [0.1, 0.01, 0.001, 1.e-4, 1.e-5], 'N_steps': 10, 'max_error_E': 1.e-8, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'verbose': verbose, } eng = tebd.Engine(psi, M, tebd_params) eng.run_GS() # the main work... E = np.sum(M.bond_energies(psi)) # M.bond_energies() works only a for NearestNeighborModel # alternative: directly measure E2 = np.mean(psi.expectation_value(M.H_bond)) print("E (per site) = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) mag_x = np.mean(psi.expectation_value("Sigmax")) mag_z = np.mean(psi.expectation_value("Sigmaz")) print("<sigma_x> = {mag_x:.5f}".format(mag_x=mag_x)) print("<sigma_z> = {mag_z:.5f}".format(mag_z=mag_z)) print("correlation length:", psi.correlation_length()) # compare to exact result from tfi_exact import infinite_gs_energy E_exact = infinite_gs_energy(1., g) print("Analytic result: E (per site) = {E:.13f}".format(E=E_exact)) print("relative error: ", abs((E - E_exact) / E_exact)) return E, psi, M
def example_DMRG_heisenberg_xxz_finite(L, Jz, chi, conserve='best', verbose=True): print("finite DMRG, Heisenberg XXZ chain") print("L={L:d}, Jz={Jz:.2f}".format(L=L, Jz=Jz)) model_params = dict(L=L, S=0.5, Jx=1., Jy=1., Jz=Jz, bc_MPS='finite', conserve=conserve, verbose=verbose) M = SpinModel(model_params) product_state = ["up", "down"] * (M.lat.N_sites // 2) psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) dmrg_params = { 'mixer': True, # setting this to True helps to escape local minima 'max_E_err': 1.e-16, 'trunc_params': { 'chi_max': chi, 'svd_min': 1.e-16 }, 'verbose': verbose, } info = dmrg.run(psi, M, dmrg_params) # the main work... E = info['E'] E = E * 4 print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) Sz = psi.expectation_value("Sz") # Sz instead of Sigma z: spin-1/2 operators! mag_z = np.mean(Sz) print("<S_z> = [{Sz0:.5f}, {Sz1:.5f}]; mean ={mag_z:.5f}".format(Sz0=Sz[0], Sz1=Sz[1], mag_z=mag_z)) # note: it's clear that mean(<Sz>) is 0: the model has Sz conservation! corrs = psi.correlation_function("Sz", "Sz", sites1=range(10)) print("correlations <Sz_i Sz_j> =") print(corrs) return E, psi, M
def example_DMRG_tf_ising_infinite(g, verbose=True): print("infinite DMRG, transverse field Ising model") print("g={g:.2f}".format(g=g)) model_params = dict(L=2, J=1., g=g, bc_MPS='infinite', conserve=None, verbose=verbose) M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) dmrg_params = { 'mixer': True, # setting this to True helps to escape local minima 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'max_E_err': 1.e-10, 'verbose': verbose, } # instead of # info = dmrg.run(psi, M, dmrg_params) # E = info['E'] # we can also use the a Engine directly: eng = dmrg.EngineCombine(psi, M, dmrg_params) E, psi = eng.run() # equivalent to dmrg.run() up to the return parameters. print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) mag_x = np.mean(psi.expectation_value("Sigmax")) mag_z = np.mean(psi.expectation_value("Sigmaz")) print("<sigma_x> = {mag_x:.5f}".format(mag_x=mag_x)) print("<sigma_z> = {mag_z:.5f}".format(mag_z=mag_z)) print("correlation length:", psi.correlation_length()) # compare to exact result from tfi_exact import infinite_gs_energy E_exact = infinite_gs_energy(1., g) print("Analytic result: E (per site) = {E:.13f}".format(E=E_exact)) print("relative error: ", abs((E - E_exact) / E_exact)) return E, psi, M
def run_tebd_tfi(L, mindim, g, tf, dt, verbose=False, order=2): model_params = dict(L=L, J=1., g=g, bc_MPS='finite', conserve=None, verbose=verbose) M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) tebd_params = { 'order': order, 'dt': dt, 'N_steps': int(tf / dt), 'trunc_params': { 'trunc_cut': 1e-14, 'svd_min': 1e-24, 'chi_max': mindim # 'chi_min': mindim }, 'verbose': verbose, } eng = tebd.Engine(psi, M, tebd_params) eng.run() print(np.amax(psi.chi)) return psi
def example_TEBD_gs_finite(L, g): print("finite TEBD, imaginary time evolution, L={L:d}, g={g:.2f}".format( L=L, g=g)) model_params = dict(L=L, J=1., g=g, bc_MPS='finite', conserve=None, verbose=0) M = TFIChain(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), [0] * L, bc='finite') tebd_params = { 'order': 2, 'delta_tau_list': [0.1, 0.01, 0.001, 1.e-4, 1.e-5], 'N_steps': 10, 'max_error_E': 1.e-6, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'verbose': 1 } eng = tebd.Engine(psi, M, tebd_params) eng.run_GS() # the main work... E = np.sum(psi.expectation_value(M.H_bond[1:])) print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) if L < 20: # compare to exact result E_exact = tfi_exact.finite_gs_energy(L, 1., g) print("Exact diagonalization: E = {E:.13f}".format(E=E_exact)) print("relative error: ", abs((E - E_exact) / E_exact)) return E, psi, M
def example_DMRG_infinite(g): print("infinite DMRG, g={g:.2f}".format(g=g)) model_params = dict(L=2, J=1., g=g, bc_MPS='infinite', conserve=None, verbose=0) M = TFIChain(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), [0] * 2, bc='infinite') dmrg_params = { 'mixer': True, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'max_E_err': 1.e-10, 'verbose': 1 } dmrg.run(psi, M, dmrg_params) E = np.mean(psi.expectation_value(M.H_bond)) print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) print("correlation length:", psi.correlation_length()) # compare to exact result E_exact = tfi_exact.infinite_gs_energy(1., g) print("Analytic result: E/L = {E:.13f}".format(E=E_exact)) print("relative error: ", abs((E - E_exact) / E_exact)) return E, psi, M
def run_tenpy_tdvp(L, maxdim, tf, verbose=False): model_params = dict(L=L, J=1., g=1, bc_MPS='finite', conserve=None, verbose=verbose) M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) tdvp_params = { 'start_time': 0, 'dt': 0.1, 'trunc_params': { 'chi_max': maxdim, 'svd_min': 0, 'trunc_cut': None } } tdvp_engine = tdvp.Engine(psi=psi, model=M, TDVP_params=tdvp_params) tdvp_engine.run_two_sites(N_steps=int(tf / 0.1)) return np.amax(psi.chi)
def test_ToricCode(Lx=1, Ly=2): with warnings.catch_warnings(): warnings.simplefilter('ignore') model_params = {'Lx': Lx, 'Ly': Ly} M = ToricCode(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), [0] * M.lat.N_sites, bc='infinite') dmrg_params = { 'mixer': True, 'trunc_params': { 'chi_max': 10, 'svd_min': 1.e-10 }, 'max_E_err': 1.e-10, 'N_sweeps_check': 4, 'verbose': 1 } result = dmrg.run(psi, M, dmrg_params) E = result['E'] print("E =", E) psi.canonical_form() # energy per "cell"=2 -> energy per site in the dual lattice = 1 assert abs(E - (-1.)) < dmrg_params['max_E_err'] print("chi=", psi.chi) if Ly == 2: assert tuple(psi.chi[:4]) == (2, 4, 4, 4) assert abs( psi.entanglement_entropy(bonds=[0])[0] - np.log(2) * (Ly - 1)) < 1.e-5
def example_TEBD_gs_infinite(g): print("infinite TEBD, imaginary time evolution, g={g:.2f}".format(g=g)) model_params = dict(L=2, J=1., g=g, bc_MPS='infinite', conserve=None, verbose=0) M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) tebd_params = { 'order': 2, 'delta_tau_list': [0.1, 0.01, 0.001, 1.e-4, 1.e-5], 'N_steps': 10, 'max_error_E': 1.e-8, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'verbose': 1 } eng = tebd.Engine(psi, M, tebd_params) eng.run_GS() # the main work... E = np.mean(psi.expectation_value(M.H_bond)) print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) print("correlation length:", psi.correlation_length()) # compare to exact result E_exact = tfi_exact.infinite_gs_energy(1., g) print("Analytic result: E/L = {E:.13f}".format(E=E_exact)) print("relative error: ", abs((E - E_exact) / E_exact)) return E, psi, M
def random_prod_state_tenpy(L, a_model): product_state = [] #the numpy mps used to compare psi_compare = [] sz = 2. * np.random.randint(0, 2, size=L) - 1.0 for i in range(L): psi_compare.append(np.zeros((2, 1, 1))) if sz[i] > 0: product_state += ["up"] psi_compare[-1][0, 0, 0] = 1 else: product_state += ["down"] psi_compare[-1][1, 0, 0] = 1 psi = MPS.from_product_state(a_model.lat.mps_sites(), product_state, bc=a_model.lat.bc_MPS, form='B') psi_converted = [] for i in range(L): site = psi.sites[i] perm = site.perm B_tmp = psi.get_B(i).transpose(['p', 'vL', 'vR']).to_ndarray() B = B_tmp[inverse_permutation(perm), :, :] B = B[::-1, :, :] psi_converted.append(B) return psi
def example_DMRG_tf_ising_finite(L, g, h=0, chi=2, verbose=True): print("finite DMRG, transverse field Ising model") print("L={L:d}, g={g:.2f}, h={h:.2f}".format(L=L, g=g, h=h)) model_params = dict(L=L, J=1., g=g, bc_MPS='finite', h=h) M = IsingChain(model_params) # model_params = dict(L=L, J=1., g=g, bc_MPS='finite', conserve=None, verbose=verbose) # M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) dmrg_params = { 'mixer': None, # setting this to True helps to escape local minima 'max_E_err': 1.e-16, 'trunc_params': { 'chi_max': chi, 'svd_min': 1.e-16 }, 'verbose': verbose, } info = dmrg.run(psi, M, dmrg_params) # the main work... E = info['E'] print("E = {E:.16f}".format(E=E)) print("final bond dimensions: ", psi.chi) mag_x = np.sum(psi.expectation_value("Sigmax")) mag_z = np.sum(psi.expectation_value("Sigmaz")) print("magnetization in X = {mag_x:.5f}".format(mag_x=mag_x)) print("magnetization in Z = {mag_z:.5f}".format(mag_z=mag_z)) return E, psi, M
def __init__(self, L=10, Jn=1, Jnn=0, hz=0, options={}): # use predefined local Hilbert space and onsite operators site = SpinSite(S=1 / 2, conserve=None) self.L = L lat = Chain(L, site, bc="open", bc_MPS="finite") # define geometry MultiCouplingModel.__init__(self, lat) # add terms of the Hamiltonian; # operators "Sx", "Sy", "Sz" are defined by the SpinSite self.add_coupling(Jn, 0, "Sx", 0, "Sx", 1) self.add_coupling(Jn, 0, "Sy", 0, "Sy", 1) self.add_coupling(Jn, 0, "Sz", 0, "Sz", 1) self.add_multi_coupling( Jnn, [("Sx", -1, 0), ("Sx", 1, 0)] ) #(oper, shift, internal index - it's possible to merge sites together) self.add_multi_coupling(Jnn, [("Sy", -1, 0), ("Sy", 1, 0)]) self.add_multi_coupling(Jnn, [("Sz", -1, 0), ("Sz", 1, 0)]) self.add_onsite(hz, 0, "Sz") # finish initialization MPOModel.__init__(self, lat, self.calc_H_MPO()) self.psi = MPS.from_product_state(self.lat.mps_sites(), [0] * L, "finite") self.options = options self.dmrg_retval = None
def example_1site_DMRG_tf_ising_finite(L, g, verbose=True): print("single-site finite DMRG, transverse field Ising model") print("L={L:d}, g={g:.2f}".format(L=L, g=g)) model_params = dict(L=L, J=1., g=g, bc_MPS='finite', conserve=None, verbose=verbose) M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) dmrg_params = { 'mixer': True, # setting this to True is essential for the 1-site algorithm to work. 'max_E_err': 1.e-10, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'verbose': verbose, 'combine': False, 'active_sites': 1 # specifies single-site } info = dmrg.run(psi, M, dmrg_params) E = info['E'] print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) mag_x = np.sum(psi.expectation_value("Sigmax")) mag_z = np.sum(psi.expectation_value("Sigmaz")) print("magnetization in X = {mag_x:.5f}".format(mag_x=mag_x)) print("magnetization in Z = {mag_z:.5f}".format(mag_z=mag_z)) if L < 20: # compare to exact result from tfi_exact import finite_gs_energy E_exact = finite_gs_energy(L, 1., g) print("Exact diagonalization: E = {E:.13f}".format(E=E_exact)) print("relative error: ", abs((E - E_exact) / E_exact)) return E, psi, M
def example_exact_diagonalization(L, Jz): xxz_pars = dict(L=L, Jxx=1., Jz=Jz, hz=0.0, bc_MPS='finite') M = XXZChain(xxz_pars) product_state = ["up", "down"] * (xxz_pars['L'] // 2 ) # this selects a charge sector! psi_DMRG = MPS.from_product_state(M.lat.mps_sites(), product_state) charge_sector = psi_DMRG.get_total_charge( True) # ED charge sector should match ED = ExactDiag(M, charge_sector=charge_sector, max_size=2.e6) ED.build_full_H_from_mpo() # ED.build_full_H_from_bonds() # whatever you prefer print("start diagonalization") ED.full_diagonalization() # the expensive part for large L E0_ED, psi_ED = ED.groundstate() # return the ground state print("psi_ED =", psi_ED) print("run DMRG") dmrg.run(psi_DMRG, M, {'verbose': 0}) # modifies psi_DMRG in place! # first way to compare ED with DMRG: convert MPS to ED vector psi_DMRG_full = ED.mps_to_full(psi_DMRG) print("psi_DMRG_full =", psi_DMRG_full) ov = npc.inner(psi_ED, psi_DMRG_full, axes='range', do_conj=True) print("<psi_ED|psi_DMRG_full> =", ov) assert (abs(abs(ov) - 1.) < 1.e-13) # second way: convert ED vector to MPS psi_ED_mps = ED.full_to_mps(psi_ED) ov2 = psi_ED_mps.overlap(psi_DMRG) print("<psi_ED_mps|psi_DMRG> =", ov2) assert (abs(abs(ov2) - 1.) < 1.e-13) assert (abs(ov - ov2) < 1.e-13) # -> advantage: expectation_value etc. of MPS are available! print("<Sz> =", psi_ED_mps.expectation_value('Sz'))
def example_DMRG_finite(L, g): print("finite DMRG, L={L:d}, g={g:.2f}".format(L=L, g=g)) model_params = dict(L=L, J=1., g=g, bc_MPS='finite', conserve=None, verbose=0) M = TFIChain(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), [0] * L, bc='finite') dmrg_params = { 'mixer': None, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'max_E_err': 1.e-10, 'verbose': 1 } dmrg.run(psi, M, dmrg_params) E = np.sum(psi.expectation_value(M.H_bond[1:])) print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) if L < 20: # compare to exact result E_exact = tfi_exact.finite_gs_energy(L, 1., g) print("Exact diagonalization: E = {E:.13f}".format(E=E_exact)) print("relative error: ", abs((E - E_exact) / E_exact)) return E, psi, M
def example_DMRG_tf_ising_infinite_S_xi_scaling(g): model_params = dict(L=2, J=1., g=g, bc_MPS='infinite', conserve='best', verbose=0) M = TFIChain(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) dmrg_params = { 'start_env': 10, 'mixer': False, # 'mixer_params': {'amplitude': 1.e-3, 'decay': 5., 'disable_after': 50}, 'trunc_params': { 'chi_max': 5, 'svd_min': 1.e-10 }, 'max_E_err': 1.e-9, 'max_S_err': 1.e-6, 'update_env': 0, 'verbose': 0 } chi_list = np.arange(7, 31, 2) s_list = [] xi_list = [] eng = dmrg.TwoSiteDMRGEngine(psi, M, dmrg_params) for chi in chi_list: t0 = time.time() eng.reset_stats( ) # necessary if you for example have a fixed numer of sweeps, if you don't set this you option your simulation stops after initial number of sweeps! eng.trunc_params['chi_max'] = chi ## DMRG Calculation ## print("Start IDMRG CALCULATION") eng.run() eng.engine_params['mixer'] = None psi.canonical_form() ## Calculating bond entropy and correlation length ## s_list.append(np.mean(psi.entanglement_entropy())) xi_list.append(psi.correlation_length()) print(chi, time.time() - t0, np.mean(psi.expectation_value(M.H_bond)), s_list[-1], xi_list[-1], flush=True) tenpy.tools.optimization.optimize( 3) # quite some speedup for small chi print("SETTING NEW BOND DIMENSION") return s_list, xi_list
def example_DMRG_heisenberg_xxz_infinite(Jx=1, Jy=1, Jz=1, hx=0, hy=0, hz=0, conserve='best', verbose=False, chi_max=100, S=0.5): if verbose: print("infinite DMRG, Heisenberg XXZ chain") print("Jz={Jz:.2f}, conserve={conserve!r}".format( Jz=Jz, conserve=conserve)) model_params = dict( L=2, S=S, # spin 1/2 Jx=Jx, Jy=Jy, Jz=Jz, # couplings hx=hx, hy=hy, hz=hz, bc_MPS='infinite', conserve=conserve, verbose=verbose) M = SpinModel(model_params) product_state = ["up", "up"] # initial Neel state psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) dmrg_params = { 'mixer': True, # setting this to True helps to escape local minima 'trunc_params': { 'chi_max': chi_max, 'svd_min': 1.e-10, }, 'max_E_err': 1.e-10, 'verbose': verbose, } info = dmrg.run(psi, M, dmrg_params) E = info['E'] if verbose: print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) Sz = psi.expectation_value( "Sz") # Sz instead of Sigma z: spin-1/2 operators! mag_z = np.mean(Sz) if verbose: print("<S_z> = [{Sz0:.5f}, {Sz1:.5f}]; mean ={mag_z:.5f}".format( Sz0=Sz[0], Sz1=Sz[1], mag_z=mag_z)) # note: it's clear that mean(<Sz>) is 0: the model has Sz conservation! if verbose: print("correlation length:", psi.correlation_length()) corrs = psi.correlation_function("Sz", "Sz", sites1=range(10)) if verbose: print("correlations <Sz_i Sz_j> =") print(corrs) return E, psi, M
def hubbard_dmrg(L,U,V,init="11",t=1.,mu=0,n_max=3,conserve="N",chi_max=100,bc="finite",extra_fill=0): """ Run DMRG for the Bose Hubbard model """ # Setting the initial state where = int(L/3) if where % 2: where += 1 if where > L: where = 1 if init == "11": init_config = [1] * L init_config[where] += extra_fill if init == "20": init_config = [2,0] * int(L/2) init_config[where] += extra_fill if init == "02": init_config = [0,2] * int(L/2) init_config[where] += extra_fill filling = np.sum(init_config)/L t0 = datetime.datetime.now() model_params = dict( filling = filling, n_max = n_max, t = t, U = U, V = V, mu = mu, L=L, bc_MPS=bc, conserve = conserve, verbose=0) M = BoseHubbardChain(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), init_config, bc=bc) dmrg_params = { 'mixer': None, 'trunc_params': { 'chi_max': chi_max, 'svd_min': 1.e-10 }, 'max_E_err': 1.e-10, 'verbose': 0, "norm_tol":1e-5 } eng = dmrg.TwoSiteDMRGEngine(psi, M, dmrg_params) eng.reset_stats() eng.trunc_params["chi_max"] = chi_max eng.run() E = np.sum(psi.expectation_value(M.H_bond[1:])) print("E = {E:.13f}".format(E=E)) #print("final bond dimensions: ", psi.chi) time = datetime.datetime.now() - t0 print(time) params = model_params params["chi_max"] = chi_max params["chis"] = psi.chi params["E"] = E params["time"] = time params["init_config"] = init_config params["init"] = init return psi, params
def run(model_params, phi_ext=np.linspace(0, 1.0, 7)): data = dict(phi_ext=phi_ext, QL=[], ent_spectrum=[]) dmrg_params = { 'mixer': True, # setting this to True helps to escape local minima 'mixer_params': { 'amplitude': 1.e-5, 'decay': 1.2, 'disable_after': 30 }, 'trunc_params': { 'svd_min': 1.e-10, }, 'lanczos_params': { 'N_min': 5, 'N_max': 20 }, 'chi_list': { 0: 9, 10: 49, 20: 100 }, 'max_E_err': 1.e-10, 'max_S_err': 1.e-6, 'max_sweeps': 150, 'verbose': 1., } prod_state = ['empty', 'full'] * (model_params['Lx'] * model_params['Ly']) eng = None for phi in phi_ext: print("=" * 100) print("phi_ext = ", phi) model_params['phi_ext'] = phi if eng is None: # first time in the loop M = FermionicHaldaneModel(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), prod_state, bc=M.lat.bc_MPS) eng = dmrg.TwoSiteDMRGEngine(psi, M, dmrg_params) else: del eng.engine_params['chi_list'] M = FermionicHaldaneModel(model_params) eng.init_env(model=M) E, psi = eng.run() data['QL'].append(psi.average_charge(bond=0)[0]) data['ent_spectrum'].append( psi.entanglement_spectrum(by_charge=True)[0]) return data
def main(): L = 60 chi = 80 U = 10.0 beta = 0.02 file_name = "U" + str(int(U)) +\ "_L"+str(L)+\ "_Ds_ch"+str(chi)+\ ".pkl" verbose_model = 0 verbose_dmrg = 0 t = 1.0 Mu = 16.0 alpha = 0.5 cnsrv_bsn = 'N' cnsrv_spn = None pkl_pack = [] for ddelta in range(51): delta = 0.50 + ddelta * 0.01 model_params = { 'n_max': 2, 'L': L, 'bc_MPS': 'finite', 'filling': 0.5, 't': t, 'U': U, 'mu': Mu, 'alpha': alpha, 'delta': delta, 'beta': beta, 'conserve_boson': cnsrv_bsn, 'conserve_spin': cnsrv_spn, 'verbose': verbose_model } M = BosonSpin(model_params) initial_state = [0] * (L // 2) + [2] * (L // 2) psi = MPS.from_product_state(M.lat.mps_sites(), initial_state, bc='finite') dmrg_params = {'mixer': None, 'verbose': verbose_dmrg, \ 'trunc_params': {'chi_max': chi, 'svd_min': 1.e-10}} start_time = time.time() dmrg.run(psi, M, dmrg_params) end_time = time.time() print("$\Delta = {a:.04f}$\tDMRG time = {b}".format(a=delta, b=end_time - start_time)) pkl_pack += [[psi, model_params, dmrg_params]] with open(file_name, 'wb') as g: pickle.dump(pkl_pack, g) return 0
def main(): L = 80 delta = 0.9064 file_name="L"+str(L) + \ "_D"+str(int(delta*10000))+\ "E0" + \ "_CHIall.pkl" verbose_model = 0 verbose_dmrg = 0 t = 1.0 alpha = 0.5 beta = 0.02 cnsrv_bsn = 'Sz' cnsrv_spn = None model_params = { 'L': L, 'bc_MPS': 'finite', 't': t, 'alpha': alpha, 'delta': delta, 'beta': beta, 'conserve_fermionic_boson': cnsrv_bsn, 'conserve_spin': cnsrv_spn, 'verbose': verbose_model } M = FermionOnSpinLattice(model_params) initial_state = [0] * (L // 2) + [2] * (L // 2) pkl_pack = [model_params, M] chi_start = np.arange(10) + 5 chi_end = np.arange(35) * 2 + 15 #chis = np.concatenate((chi_start, chi_end)) # extra chi for 80 chis = np.arange(10) * 2 + 85 for chi in chis: psi = MPS.from_product_state(M.lat.mps_sites(), initial_state, bc='finite') dmrg_params = {'mixer': None, 'verbose': verbose_dmrg, \ 'trunc_params': {'chi_max': chi, 'svd_min': 1.e-10}} start_time = time.time() dmrg.run(psi, M, dmrg_params) end_time = time.time() print("D max = {c}\tDMRG time = {b}".format(c=chi, b=end_time - start_time)) pkl_pack += [[psi, chi]] with open(file_name, 'wb') as g: pickle.dump(pkl_pack, g) return 0
def test_ExpMPOEvolution(bc_MPS, approximation, compression, g=1.5): # Test a time evolution against exact diagonalization for finite bc dt = 0.01 if bc_MPS == 'finite': L = 6 else: L = 2 model_pars = dict(L=L, Jx=0., Jy=0., Jz=-4., hx=2. * g, bc_MPS=bc_MPS, conserve=None) M = SpinChain(model_pars) state = ([[1 / np.sqrt(2), -1 / np.sqrt(2)]] * L ) # pointing in (-x)-direction state = ['up'] * L # pointing in (-z)-direction psi = MPS.from_product_state(M.lat.mps_sites(), state, bc=bc_MPS) options = { 'dt': dt, 'N_steps': 1, 'order': 1, 'approximation': approximation, 'compression_method': compression, 'trunc_params': { 'chi_max': 30 } } eng = mpo_evolution.ExpMPOEvolution(psi, M, options) if bc_MPS == 'finite': ED = exact_diag.ExactDiag(M) ED.build_full_H_from_mpo() ED.full_diagonalization() psiED = ED.mps_to_full(psi) psiED /= psiED.norm() UED = ED.exp_H(dt) for i in range(30): psi = eng.run() psiED = npc.tensordot(UED, psiED, ('ps*', [0])) psi_full = ED.mps_to_full(psi) assert (abs(abs(npc.inner(psiED, psi_full, [0, 0], True)) - 1) < dt) if bc_MPS == 'infinite': psiTEBD = psi.copy() TEBD_params = {'dt': dt, 'N_steps': 1} EngTEBD = tebd.Engine(psiTEBD, M, TEBD_params) for i in range(30): EngTEBD.run() psi = eng.run() print(psi.norm) print(np.abs(psi.overlap(psiTEBD) - 1)) #This test fails assert (abs(abs(psi.overlap(psiTEBD)) - 1) < 1e-2)
def setup_benchmark(mod_q=[1], legs=10, size=20, **kwargs): """Setup DMRG benchmark. Mapping of parameters: size -> chi legs -> L = number of sites mod_q -> conserve """ L = legs # number of sites: legs is abbreviated with `l` if len(mod_q) == 0: conserve = None elif mod_q == [2]: conserve = 'parity' elif mod_q == [1]: conserve = 'Sz' model_params = dict(L=L, S=2., D=0.3, bc_MPS='infinite', conserve=conserve, verbose=0) # print("conserve =", repr(conserve)) M = SpinChain(model_params) initial_state = (['up', 'down'] * L)[:L] psi = MPS.from_product_state(M.lat.mps_sites(), initial_state, bc='infinite') dmrg_params = { 'trunc_params': { 'chi_max': size, 'svd_min': 1.e-45, }, 'lanczos_params': { 'N_min': 10, 'N_max': 10 }, # 'mixer': None, # 'N_sweeps_check': 1, # 'min_sweeps': 10, # 'max_sweeps': 100, # 'max_E_err': 1.e-13, 'verbose': 0., } eng = dmrg.TwoSiteDMRGEngine(psi, M, dmrg_params) eng.verbose = 0.02 for i in range(100): eng.sweep(meas_E_trunc=False) eng.sweep(optimize=False, meas_E_trunc=False) # environment sweep if eng.verbose > 0.1: print(eng.psi.chi) print(eng.psi.entanglement_entropy()) if eng.verbose > 0.1: print("set up dmrg for size", size) if eng.verbose > 0.01: print('initial chi', eng.psi.chi) eng.reset_stats() return eng
def run(phi_ext=np.linspace(0, 1.0, 11)): data = dict(phi_ext=phi_ext, QL=[], ent_spectrum=[]) model_params = dict(conserve='N', filling=1 / 2., Lx=1, Ly=3, t=-1., mu=0, V=1., phi_ext=0., bc_MPS='infinite', bc_y='cylinder', verbose=0) dmrg_params = { 'mixer': True, # setting this to True helps to escape local minima 'mixer_params': { 'amplitude': 1.e-5, 'decay': 1.2, 'disable_after': 30 }, 'trunc_params': { 'svd_min': 1.e-10, }, 'lanczos_params': { 'N_min': 5, 'N_max': 20 }, 'chi_list': { 0: 9, 10: 49, 20: 200 }, 'max_E_err': 1.e-10, 'max_S_err': 1.e-6, 'max_sweeps': 150, 'verbose': 1., } prod_state = ['full', 'empty'] * (model_params['Lx'] * model_params['Ly'] * 2 // 2) # TODO allow tiling of list in from_product_state... eng = None for phi in phi_ext: print("=" * 100) print("phi_ext = ", phi) model_params['phi_ext'] = phi if eng is None: # first time in the loop M = FermionicHaldaneModel(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), prod_state, bc=M.lat.bc_MPS) eng = dmrg.EngineCombine(psi, M, dmrg_params) else: del eng.DMRG_params['chi_list'] M = FermionicHaldaneModel(model_params) eng.init_env(model=M) E, psi = eng.run() data['QL'].append(psi.average_charge(bond=0)[0]) data['ent_spectrum'].append(psi.entanglement_spectrum(by_charge=True)[0]) return data
def run(Jzs): L = 2 model_params = dict(L=L, Jx=1., Jy=1., Jz=Jzs[0], bc_MPS='infinite', conserve='Sz', verbose=0) chi = 300 dmrg_params = { 'trunc_params': { 'chi_max': chi, 'svd_min': 1.e-10, 'trunc_cut': None }, 'update_env': 20, 'start_env': 20, 'max_E_err': 0.0001, 'max_S_err': 0.0001, 'verbose': 1, 'mixer': False } M = SpinChain(model_params) psi = MPS.from_product_state(M.lat.mps_sites(), (["up", "down"] * L)[:L], M.lat.bc_MPS) engine = dmrg.TwoSiteDMRGEngine(psi, M, dmrg_params) np.set_printoptions(linewidth=120) corr_length = [] for Jz in Jzs: print("-" * 80) print("Jz =", Jz) print("-" * 80) model_params['Jz'] = Jz M = SpinChain(model_params) engine.init_env( model=M) # (re)initialize DMRG environment with new model # this uses the result from the previous DMRG as first initial guess engine.run() # psi is modified by engine.run() and now represents the ground state for the current `Jz`. corr_length.append(psi.correlation_length(tol_ev0=1.e-3)) print("corr. length", corr_length[-1]) print("<Sz>", psi.expectation_value('Sz')) dmrg_params[ 'start_env'] = 0 # (some of) the parameters are read out again corr_length = np.array(corr_length) results = { 'model_params': model_params, 'dmrg_params': dmrg_params, 'Jzs': Jzs, 'corr_length': corr_length, 'eval_transfermatrix': np.exp(-1. / corr_length) } return results
def run_groundstate_xxz(L=30, Jz=1., hz=0., conserve='best', chi_max=50, Jz_init=None): model_params = dict(L=L, Jx=1., Jy=1., Jz=Jz, hz=hz, bc_MPS='finite', conserve='best', verbose=1) result = {} M = SpinChain(model_params) result['model'] = 'SpinChain' result['model_params'] = model_params result['sites'] = np.arange(L) result['bonds'] = np.arange(L - 1) + 0.5 psi = MPS.from_product_state(M.lat.mps_sites(), (["up", "down"] * L)[:L]) dmrg_params = { 'trunc_params': { 'chi_max': chi_max, 'svd_min': 1.e-10, 'trunc_cut': None }, 'mixer': True, 'verbose': 1 } if Jz_init: # run first time with small hx to break the symmetry model_params_Jz = model_params.copy() model_params_Jz['Jz'] = Jz_init M_Jz = SpinChain(model_params_Jz) dmrg_params['start_env'] = 10, run_DMRG(psi, M_Jz, dmrg_params) # run simulation t0 = time.time() info = run_DMRG(psi, M, dmrg_params) print("DMRG finished after", time.time() - t0, "s") # save results in output file result['chi'] = np.array(psi.chi) result['S'] = np.array(psi.entanglement_entropy()) result['E'] = info['E'] result['sweeps'] = info['sweep_statistics']['sweep'] for key in ['E', 'S', 'max_trunc_err', 'max_E_trunc', 'max_chi']: result_key = 'sweep_' + key result[result_key] = np.array(info['sweep_statistics'][key]) return result
def example_TEBD_gs_tf_ising_next_nearest_neighbor(L, g, Jp, verbose=True): from tenpy.models.spins_nnn import SpinChainNNN2 from tenpy.models.model import NearestNeighborModel print("finite TEBD, imaginary time evolution, transverse field Ising next-nearest neighbor") print("L={L:d}, g={g:.2f}, Jp={Jp:.2f}".format(L=L, g=g, Jp=Jp)) model_params = dict(L=L, Jx=1., Jy=0., Jz=0., Jxp=Jp, Jyp=0., Jzp=0., hz=g, bc_MPS='finite', conserve=None, verbose=verbose) # we start with the non-grouped sites, but next-nearest neighbor interactions, building the MPO M = SpinChainNNN2(model_params) product_state = ["up"] * M.lat.N_sites psi = MPS.from_product_state(M.lat.mps_sites(), product_state, bc=M.lat.bc_MPS) # now we group each to sites ... psi.group_sites(n=2) # ... in the state M.group_sites(n=2) # ... and model # now, M has only 'nearest-neighbor' interactions with respect to the grouped sites # thus, we can convert the MPO into H_bond terms: M_nn = NearestNeighborModel.from_MPOModel(M) # hence, we can initialize H_bond from the MPO # now, we continue to run TEBD as before tebd_params = { 'order': 2, 'delta_tau_list': [0.1, 0.01, 0.001, 1.e-4, 1.e-5], 'N_steps': 10, 'max_error_E': 1.e-6, 'trunc_params': { 'chi_max': 30, 'svd_min': 1.e-10 }, 'verbose': verbose, } eng = tebd.Engine(psi, M_nn, tebd_params) # use M_nn and grouped psi eng.run_GS() # the main work... # expectation values: E = np.sum(M_nn.bond_energies(psi)) # bond_energies() works only a for NearestNeighborModel print("E = {E:.13f}".format(E=E)) print("final bond dimensions: ", psi.chi) # we can split the sites of the state again for an easier evaluation of expectation values psi.group_split() mag_x = 2. * np.sum(psi.expectation_value("Sx")) # factor of 2 for Sx vs Sigmax mag_z = 2. * np.sum(psi.expectation_value("Sz")) print("magnetization in X = {mag_x:.5f}".format(mag_x=mag_x)) print("magnetization in Z = {mag_z:.5f}".format(mag_z=mag_z)) return E, psi, M