def test_ising_model_3x3(self): """ Test diagonalization of 3x3 ising model with periodic boundary conditions. reference: J. Phys. A: Math. Gen 33 6683 (2000). "Finite-size scaling in the transverse Ising model on a square lattice" by C J Hamer https://doi.org/10.1088/0305-4470/33/38/303 :return: """ cluster = geom.Geometry.createSquareGeometry(3, 3, 0, 0, bc1_open=False, bc2_open=False) # paper definition of hamiltonian differs by a factor of two from mine jz_critical = -2 * 0.32424925229 h_transverse = 2 * 1.0 spin_model = tvi.spinSystem(cluster, jx=0.0, jy=0.0, jz=jz_critical, hx=h_transverse, hy=0.0, hz=0.0, use_ryd_detunes=0) hamiltonian = spin_model.createH() eig_vals, eig_vects = spin_model.diagH(hamiltonian) # runner_offset the energy by the number of sites to match Hamiltonian in paper min_eig_per_site = eig_vals[0] / spin_model.geometry.nsites + 1 # paper quote -0.075901188836 ... I get a difference in the 11th-12th decimal place # I find 38 instead of 36 self.assertAlmostEqual(min_eig_per_site, -0.0759011888, 10)
def test_three_by_three_xy_model(self): """ Test exact diagonalization of 3x3 xy model with periodic boundary conditions reference: J. Phys. A: Math. Gen 32 51 (1999). "Finite-size scaling in the spin-1/2 xy model on a square lattice" by C J Hamer et al """ cluster = geom.Geometry.createSquareGeometry(3, 3, 0, 0, bc1_open=False, bc2_open=False) spin_model = tvi.spinSystem(cluster, jx=-1.0, jy=-1.0, jz=0.0, hx=0.0, hy=0.0, hz=0.0, use_ryd_detunes=0) hamiltonian = spin_model.createH() eig_vals, eig_vects = spin_model.diagH(hamiltonian) min_eig_per_site = eig_vals[0] / spin_model.geometry.nsites self.assertAlmostEqual(min_eig_per_site, -1.149665828185, 12)
def test_translational_symm_3x3(self): """ Test translational symmetry by diagonalizing random 3x3 spin system with and without it :return: """ cluster = geom.Geometry.createSquareGeometry(3, 3, 0, 0, bc1_open=False, bc2_open=False) jx = np.random.rand() jy = np.random.rand() jz = np.random.rand() hx = np.random.rand() hy = np.random.rand() hz = np.random.rand() # diagonalize full hamiltonian spin_model = tvi.spinSystem(cluster, jx, jy, jz, hx, hy, hz, use_ryd_detunes=0) hamiltonian_full = spin_model.createH() eig_vals_full, eig_vects_full = spin_model.diagH(hamiltonian_full) xtransl_fn = symm.getTranslFn(np.array([[1], [0]])) xtransl_cycles, max_cycle_len_translx = symm.findSiteCycles( xtransl_fn, spin_model.geometry) xtransl_op = spin_model.get_xform_op(xtransl_cycles) xtransl_op = xtransl_op # y-translations ytransl_fn = symm.getTranslFn(np.array([[0], [1]])) ytransl_cycles, max_cycle_len_transly = symm.findSiteCycles( ytransl_fn, spin_model.geometry) ytransl_op = spin_model.get_xform_op(ytransl_cycles) ytransl_op = ytransl_op symm_projs, kxs, kys = symm.get2DTranslationProjectors( xtransl_op, max_cycle_len_translx, ytransl_op, max_cycle_len_transly) eig_vals_sectors = [] for ii, proj in enumerate(symm_projs): h_sector = spin_model.createH(projector=proj) eig_vals_sector, eig_vects_sector = spin_model.diagH(h_sector) eig_vals_sectors.append(eig_vals_sector) # why only accurate to 10 decimal places? eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) max_diff = np.abs(eig_vals_full - eigs_all_sectors).max() self.assertAlmostEqual(max_diff, 0, 10)
def diag_cluster(cluster_index, cluster_data_out_fname, cluster_data_in_fname): with open(cluster_data_in_fname, 'rb') as f: data = pickle.load(f) cluster_list = data[1] cluster = cluster_list[cluster_index] print("cluster %d" % cluster_index) model = tvi.spinSystem(cluster, jx=0.5, jy=0.5, jz=0.5, hx=0, hy=0, hz=0, use_ryd_detunes=0) hamiltonian = model.createH(print_results=True) eig_vals, eig_vects = model.diagH(hamiltonian, print_results=True) temps = np.logspace(-1, 0.5, 50) # compute expectation values energies = np.zeros((1, len(temps))) entropies = np.zeros((1, len(temps))) specific_heats = np.zeros((1, len(temps))) szsz_corrs = np.zeros((1, len(temps))) t_start = time.process_time() for jj, T in enumerate(temps): # calculate properties for each temperature energies[0, jj] = model.get_exp_vals_thermal(eig_vects, hamiltonian, eig_vals, T, 0) Z = np.sum(np.exp(-eig_vals / T)) entropies[0, jj] = (np.log(Z) + energies[0, jj] / T) specific_heats[0, jj] = 1. / T ** 2 * \ (model.get_exp_vals_thermal(eig_vects, hamiltonian.dot(hamiltonian), eig_vals, T, 0) - energies[0, jj] ** 2) szsz_corrs[0, jj] = 0 for aa in range(0, model.geometry.nsites): for bb in range(aa + 1, model.geometry.nsites): szsz_op = model.getTwoSiteOp(aa, bb, model.geometry.nsites, model.pauli_z, model.pauli_z, format="boson") szsz_exp = model.get_exp_vals_thermal(eig_vects, szsz_op, eig_vals, T) szsz_corrs[0, jj] = szsz_corrs[0, jj] + szsz_exp t_end = time.process_time() print("Computing %d finite temperature expectation values took %0.2fs" % (len(temps), t_end - t_start)) data_out = [ cluster, eig_vals, energies, entropies, specific_heats, szsz_corrs, temps, model ] with open(cluster_data_out_fname, 'wb') as f: pickle.dump(data_out, f)
def test_d4_symm(self): """ Test d4 symmetry by diagonalizing random spin system with and without it :return: """ cluster = geom.Geometry.createSquareGeometry(3, 3, 0, 0, bc1_open=False, bc2_open=False) jx = np.random.rand() jy = np.random.rand() jz = np.random.rand() hx = np.random.rand() hy = np.random.rand() hz = np.random.rand() # diagonalize full hamiltonian spin_model = tvi.spinSystem(cluster, jx, jy, jz, hx, hy, hz, use_ryd_detunes=0) hamiltonian_full = spin_model.createH() eig_vals_full, eig_vects_full = spin_model.diagH(hamiltonian_full) # use rotationl symmetry cx, cy = spin_model.geometry.get_center_of_mass() rot_fn = symm.getRotFn(4, cx=cx, cy=cy) rot_cycles, max_cycle_len_rot = symm.findSiteCycles( rot_fn, spin_model.geometry) rot_op = spin_model.get_xform_op(rot_cycles) refl_fn = symm.getReflFn(np.array([0, 1]), cx=cx, cy=cy) refl_cycles, max_cycle_len_ref = symm.findSiteCycles( refl_fn, spin_model.geometry) refl_op = spin_model.get_xform_op(refl_cycles) symm_projs = symm.getD4Projectors(rot_op, refl_op) eig_vals_sectors = [] for ii, proj in enumerate(symm_projs): h_sector = spin_model.createH(projector=proj) eig_vals_sector, eig_vects_sector = spin_model.diagH(h_sector) eig_vals_sectors.append(eig_vals_sector) # why only accurate to 10 decimal places? eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) max_diff = np.abs(eig_vals_full - eigs_all_sectors).max() self.assertAlmostEqual(max_diff, 0, 10)
def test_four_by_four_xy_model_symm(self): """ Test exact diagonalization of 4x4 xy model with periodic boundary conditions reference: J. Phys. A: Math. Gen 32 51 (1999). "Finite-size scaling in the spin-1/2 xy model on a square lattice" by C J Hamer et al """ cluster = geom.Geometry.createSquareGeometry(4, 4, 0, 0, bc1_open=False, bc2_open=False) # diagonalize full hamiltonian spin_model = tvi.spinSystem(cluster, jx=-1.0, jy=-1.0, jz=0.0, hx=0.0, hy=0.0, hz=0.0, use_ryd_detunes=0) # x-translations xtransl_fn = symm.getTranslFn(np.array([[1], [0]])) xtransl_cycles, max_cycle_len_translx = symm.findSiteCycles( xtransl_fn, spin_model.geometry) xtransl_op = spin_model.get_xform_op(xtransl_cycles) xtransl_op = xtransl_op # y-translations ytransl_fn = symm.getTranslFn(np.array([[0], [1]])) ytransl_cycles, max_cycle_len_transly = symm.findSiteCycles( ytransl_fn, spin_model.geometry) ytransl_op = spin_model.get_xform_op(ytransl_cycles) ytransl_op = ytransl_op symm_projs, kxs, kys = symm.get2DTranslationProjectors( xtransl_op, max_cycle_len_translx, ytransl_op, max_cycle_len_transly) eig_vals_sectors = [] hfull = spin_model.createH() for ii, proj in enumerate(symm_projs): h_sector = proj * hfull * proj.conj().transpose() eig_vals_sector, eig_vects_sector = spin_model.diagH( h_sector, print_results=True) eig_vals_sectors.append(eig_vals_sector) # why only accurate to 10 decimal places? eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) min_eig_per_site = eigs_all_sectors[0] / spin_model.geometry.nsites self.assertAlmostEqual(min_eig_per_site, -1.124972697436, 12)
def test_higher_spin(self): """ Test heisenberg system with spin > 0.5 :return: """ spin = 2.5 nx = 4 ny = 1 phi1 = 0 phi2 = 0 bc_open1 = 1 bc_open2 = 1 gm = geom.Geometry.createSquareGeometry(nx, ny, phi1, phi2, bc_open1, bc_open2) gm.dispGeometry() j1 = 0.3333 j2 = 0.23623627 j3 = 0.8434783478 # -1 to account for difference in definitions js = -np.array([[0, j1, j2, j3], [j1, 0, j2, j3], [j2, j2, 0, j3], [j3, j3, j3, 0]]) ss = tvi.spinSystem(gm, jx=js, jy=js, jz=js, spin=spin) hamiltonian = ss.createH() eig_vals, eig_vects = ss.diagH(hamiltonian) # verify these are equal to expected result # E = j1 * [s1*(s1+1) + s2*(s2+1)] + j2 * s3*(s3+1) + j3 * s4*(s4+1) + (j2-j1)*s12*(s12+1) + # (j3-j2)*s123*(s123+1) - j3 * s1234 * (s1234 + 1) eigs_analytic = [] s1 = spin s2 = s1 s3 = s1 s4 = s1 s12s = np.arange(np.abs(s1 - s2), s1 + s2 + 1) for s12 in s12s: for s123 in np.arange(np.abs(s3 - s12), s3 + s12 + 1): for s1234 in np.arange(np.abs(s4 - s123), s4 + s123 + 1): eig = j1 * (s1 * (s1 + 1) + s2 * (s2 + 1)) + \ j2 * s3 * (s3 + 1) + \ j3 * s4 * (s4 + 1) + \ (j2 - j1) * s12 * (s12 + 1) + \ (j3 - j2) * s123 * (s123 + 1) - \ j3 * s1234 * (s1234 + 1) multiplicity = int(2 * s1234 + 1) eigs_analytic += [eig] * multiplicity eigs_analytic.sort() max_diff = np.max(np.abs(eigs_analytic - eig_vals)) self.assertAlmostEqual(max_diff, 0, 12)
def test_d3_symm_6sites(self): adjacency_mat = np.array([[0, 1, 0, 1, 0, 0], [1, 0, 1, 1, 1, 0], [0, 1, 0, 0, 1, 0], [1, 1, 0, 0, 1, 1], [0, 1, 1, 1, 0, 1], [0, 0, 0, 1, 1, 0]]) cluster = geom.Geometry.createNonPeriodicGeometry( xlocs=(0, 1, 2, 0.5, 1.5, 1), ylocs=(0, 0, 0, np.sqrt(3) / 2, np.sqrt(3) / 2, np.sqrt(3)), adjacency_mat=adjacency_mat) jx = np.random.rand() jy = np.random.rand() jz = np.random.rand() hx = np.random.rand() hy = np.random.rand() hz = np.random.rand() # diagonalize full hamiltonian spin_model = tvi.spinSystem(cluster, jx, jy, jz, hx, hy, hz, use_ryd_detunes=0) hamiltonian_full = spin_model.createH() eig_vals_full, eig_vects_full = spin_model.diagH(hamiltonian_full) # use rotationl symmetry # triangle center cx, cy = 1, 1 / np.sqrt(3) rot_fn = symm.getRotFn(3, cx=cx, cy=cy) rot_cycles, max_cycle_len_rot = symm.findSiteCycles( rot_fn, spin_model.geometry) rot_op = spin_model.get_xform_op(rot_cycles) refl_fn = symm.getReflFn(np.array([0, 1]), cx=cx, cy=cy) refl_cycles, max_cycle_len_ref = symm.findSiteCycles( refl_fn, spin_model.geometry) refl_op = spin_model.get_xform_op(refl_cycles) symm_projs = symm.getD3Projectors(rot_op, refl_op) eig_vals_sectors = [] for ii, proj in enumerate(symm_projs): h_sector = spin_model.createH(projector=proj) eig_vals_sector, eig_vects_sector = spin_model.diagH(h_sector) eig_vals_sectors.append(eig_vals_sector) eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) max_diff = np.abs(eig_vals_full - eigs_all_sectors).max() self.assertAlmostEqual(max_diff, 0, 12)
def test_d3_symm_3sites(self): """ Test d3 symmetry by diagonalizing random spin system with and without it :return: """ # adjacency_mat = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]]) # cluster = geom.Geometry.createNonPeriodicGeometry(xlocs=(0,0.5,1), ylocs=(0,np.sqrt(3)/2,0), adjacency_mat=adjacency_mat) cluster = geom.Geometry.createRegularPolygonGeometry(3) jx = np.random.rand() jy = np.random.rand() jz = np.random.rand() hx = np.random.rand() hy = np.random.rand() hz = np.random.rand() # diagonalize full hamiltonian spin_model = tvi.spinSystem(cluster, jx, jy, jz, hx, hy, hz, use_ryd_detunes=0) hamiltonian_full = spin_model.createH() eig_vals_full, eig_vects_full = spin_model.diagH(hamiltonian_full) # use rotationl symmetry rot_fn = symm.getRotFn(3) rot_cycles, max_cycle_len_rot = symm.findSiteCycles( rot_fn, spin_model.geometry) rot_op = spin_model.get_xform_op(rot_cycles) refl_fn = symm.getReflFn(np.array([0, 1])) refl_cycles, max_cycle_len_ref = symm.findSiteCycles( refl_fn, spin_model.geometry) refl_op = spin_model.get_xform_op(refl_cycles) symm_projs = symm.getD3Projectors(rot_op, refl_op) eig_vals_sectors = [] for ii, proj in enumerate(symm_projs): h_sector = spin_model.createH(projector=proj) eig_vals_sector, eig_vects_sector = spin_model.diagH(h_sector) eig_vals_sectors.append(eig_vals_sector) # why only accurate to 10 decimal places? eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) max_diff = np.abs(eig_vals_full - eigs_all_sectors).max() self.assertAlmostEqual(max_diff, 0, 12)
def test_d7_symm_7sites(self): cluster = geom.Geometry.createRegularPolygonGeometry(7) jx = np.random.rand() jy = np.random.rand() jz = np.random.rand() hx = np.random.rand() hy = np.random.rand() hz = np.random.rand() # diagonalize full hamiltonian spin_model = tvi.spinSystem(cluster, jx, jy, jz, hx, hy, hz, use_ryd_detunes=0) hamiltonian_full = spin_model.createH() eig_vals_full, eig_vects_full = spin_model.diagH(hamiltonian_full) # use rotationl symmetry rot_fn = symm.getRotFn(7) rot_cycles, max_cycle_len_rot = symm.findSiteCycles( rot_fn, spin_model.geometry) rot_op = spin_model.get_xform_op(rot_cycles) refl_fn = symm.getReflFn(np.array([0, 1])) refl_cycles, max_cycle_len_ref = symm.findSiteCycles( refl_fn, spin_model.geometry) refl_op = spin_model.get_xform_op(refl_cycles) symm_projs = symm.getD6Projectors(rot_op, refl_op) eig_vals_sectors = [] for ii, proj in enumerate(symm_projs): h_sector = spin_model.createH(projector=proj) eig_vals_sector, eig_vects_sector = spin_model.diagH(h_sector) eig_vals_sectors.append(eig_vals_sector) eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) max_diff = np.abs(eig_vals_full - eigs_all_sectors).max() self.assertAlmostEqual(max_diff, 0, 14)
def test_full_symm_3x3(self): cluster = geom.Geometry.createSquareGeometry(3, 3, 0, 0, bc1_open=False, bc2_open=False) jx = np.random.rand() jy = np.random.rand() jz = np.random.rand() hx = np.random.rand() hy = np.random.rand() hz = np.random.rand() # diagonalize full hamiltonian spin_model = tvi.spinSystem(cluster, jx, jy, jz, hx, hy, hz, use_ryd_detunes=0) hamiltonian_full = spin_model.createH() eig_vals_full, eig_vects_full = spin_model.diagH(hamiltonian_full) xtransl_fn = symm.getTranslFn(np.array([[1], [0]])) xtransl_cycles, max_cycle_len_translx = symm.findSiteCycles( xtransl_fn, spin_model.geometry) tx_op = spin_model.get_xform_op(xtransl_cycles) # y-translations ytransl_fn = symm.getTranslFn(np.array([[0], [1]])) ytransl_cycles, max_cycle_len_transly = symm.findSiteCycles( ytransl_fn, spin_model.geometry) ty_op = spin_model.get_xform_op(ytransl_cycles) # rotation cx, cy = spin_model.geometry.get_center_of_mass() rot_fn = symm.getRotFn(4, cx=cx, cy=cy) rot_cycles, max_cycle_len_rot = symm.findSiteCycles( rot_fn, spin_model.geometry) rot_op = spin_model.get_xform_op(rot_cycles) # reflection # reflection about y-axis refl_fn = symm.getReflFn(np.array([0, 1]), cx=cx, cy=cy) refl_cycles, max_cycle_len_refl = symm.findSiteCycles( refl_fn, spin_model.geometry) refl_op = spin_model.get_xform_op(refl_cycles) symm_projs = symm.getC4V_and_3byb3(rot_op, refl_op, tx_op, ty_op) eig_vals_sectors = [] for ii, proj in enumerate(symm_projs): h_sector = spin_model.createH(projector=proj) eig_vals_sector, eig_vects_sector = spin_model.diagH(h_sector) eig_vals_sectors.append(eig_vals_sector) # why only accurate to 10 decimal places? eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) max_diff = np.abs(eig_vals_full - eigs_all_sectors).max() self.assertAlmostEqual(max_diff, 0, 10)
phi2 = 0 if nx > 1: bc1_open = False else: bc1_open = True if ny > 1: bc2_open = False else: bc2_open = True for ii, (phi1, phi2) in enumerate(zip(phi1s, phi2s)): gm = geom.Geometry.createSquareGeometry(nx, ny, phi1, phi2, bc1_open, bc2_open) ss = ed_spins.spinSystem() jsmat = ss.get_interaction_mat_heisenberg(gm, J) # build all possible symmetries # x-translation xtransl_fn = symm.getTranslFn(np.array([[1], [0]])) xtransl_cycles, max_cycle_len_translx = symm.findSiteCycles(xtransl_fn, gm) xtransl_op = ss.get_xform_op(xtransl_cycles) xtransl_op = xtransl_op # y-translations ytransl_fn = symm.getTranslFn(np.array([[0], [1]])) ytransl_cycles, max_cycle_len_transly = symm.findSiteCycles(ytransl_fn, gm) ytransl_op = ss.get_xform_op(ytransl_cycles) ytransl_op = ytransl_op
def test_ising_model_5x5(self): """ Test diagonalization of 5x5 ising model with periodic boundary conditions. reference: J. Phys. A: Math. Gen 33 6683 (2000). "Finite-size scaling in the transverse Ising model on a square lattice" by C J Hamer https://doi.org/10.1088/0305-4470/33/38/303 :return: """ cluster = geom.Geometry.createSquareGeometry(5, 5, 0, 0, bc1_open=False, bc2_open=False) # paper definition of hamiltonian differs by a factor of two from mine jz_critical = -2 * 0.32669593806 h_transverse = 2 * 1.0 spin_model = tvi.spinSystem(cluster, jx=0.0, jy=0.0, jz=jz_critical, hx=h_transverse, hy=0.0, hz=0.0, use_ryd_detunes=0) # symmetry swapping up/down spins spin_swap_op = spin_model.get_swap_up_down_op() # x-translations xtransl_fn = symm.getTranslFn(np.array([[1], [0]])) xtransl_cycles, max_cycle_len_translx = symm.findSiteCycles( xtransl_fn, spin_model.geometry) xtransl_op = spin_model.get_xform_op(xtransl_cycles) xtransl_op = xtransl_op # y-translations ytransl_fn = symm.getTranslFn(np.array([[0], [1]])) ytransl_cycles, max_cycle_len_transly = symm.findSiteCycles( ytransl_fn, spin_model.geometry) ytransl_op = spin_model.get_xform_op(ytransl_cycles) ytransl_op = ytransl_op symm_projs, kxs, kys = symm.get2DTranslationProjectors( xtransl_op, max_cycle_len_translx, ytransl_op, max_cycle_len_transly) eig_vals_sectors = [] full_proj_list = [] hfull = spin_model.createH() for ii, proj in enumerate(symm_projs): spin_swap_proj_op = proj * spin_swap_op * proj.conj().transpose() # char_table = np.array([[1, 1], [1, -1]]) # ccs = [[sp.eye(spin_swap_proj_op.shape[0], format="csr")], [spin_swap_proj_op]] swap_projs, phase = symm.getZnProjectors(spin_swap_proj_op, 2) for jj, sproj in enumerate(swap_projs): full_proj_list.append(sproj * proj) h_sector = sproj * proj * hfull * proj.conj().transpose( ) * sproj.conj().transpose() eig_vals_sector, eig_vects_sector = spin_model.diagH( h_sector, print_results=True) eig_vals_sectors.append(eig_vals_sector) # why only accurate to 10 decimal places? eigs_all_sectors = np.sort(np.concatenate(eig_vals_sectors)) min_eig_per_site = eigs_all_sectors[0] / spin_model.geometry.nsites + 1 self.assertAlmostEqual(min_eig_per_site, -0.064637823298, 11)
######################################## if not os.path.isfile(fname_full_cluster_ed): print("did not find file %s, diagonalizing hamiltonian" % fname_full_cluster_ed) parent_geometry = geom.Geometry.createSquareGeometry(4, 4, 0, 0, bc1_open=False, bc2_open=False) parent_geometry.permute_sites(parent_geometry.get_sorting_permutation()) model = tvi.spinSystem(parent_geometry, jx, jy, jz, hx, hy, hz, use_ryd_detunes=False) # x-translation tx_fn = symm.getTranslFn(np.array([[1], [0]])) tx_cycles, ntx = symm.findSiteCycles(tx_fn, model.geometry) tx_op = model.get_xform_op(tx_cycles) # y-translations ty_fn = symm.getTranslFn(np.array([[0], [1]])) ty_cycles, nty = symm.findSiteCycles(ty_fn, model.geometry) ty_op = model.get_xform_op(ty_cycles) # symmetry projectors
# no staggered magnetization and all correlations. U = -4 jx = 0.5 * 4 / np.abs(U) # 4t^2/|U| jy = jx jz = jx hx = 0. hy = 0. hz = 2 * (-0.4) # 2*mu - U larmor_period = 2 * np.pi / hz print("U = %0.2f" % U) print("J = %0.2f" % jx) print("hz = %0.2f" % hz) print("larmor period_exp = %0.2f" % larmor_period) # factor of two based on my convention for hamiltonian = 0.5 *\sum sigma*sigma * 2 * \sum spin*spin ss = ed_spins.spinSystem(gm, jx, jy, jz, hx, hy, hz) hamiltonian = ss.createH(projector=None, print_results=print_all) eigvals, eigvects = ss.diagH(hamiltonian) # useful operators sigma_z_op = ss.get_sum_op(ss.pauli_z) sigma_y_op = ss.get_sum_op(ss.pauli_y) sigma_x_op = ss.get_sum_op(ss.pauli_x) # ops on each site sigma_z_sites = [] sigma_y_sites = [] sigma_x_sites = [] for ii in range(0, ss.geometry.nsites): sigma_z_sites.append( ss.getSingleSiteOp(ii, ss.geometry.nsites, ss.pauli_z, format="boson"))
def test_directions_equivalent(self): """ Test if all directions are equivalent for the spin system by picking three random fields and interactions_4 and diagonalizing all six permutations of spin systems which can be created from these. The compare their eigenvalues :return: """ cluster = geom.Geometry.createSquareGeometry(3, 3, 0, 0, bc1_open=False, bc2_open=False) j1 = np.random.rand() j2 = np.random.rand() j3 = np.random.rand() h1 = np.random.rand() h2 = np.random.rand() h3 = np.random.rand() spin_model_list = [] spin_model_list.append( tvi.spinSystem(cluster, jx=j1, jy=j2, jz=j3, hx=h1, hy=h2, hz=h3, use_ryd_detunes=0)) spin_model_list.append( tvi.spinSystem(cluster, jx=j2, jy=j3, jz=j1, hx=h2, hy=h3, hz=h1, use_ryd_detunes=0)) spin_model_list.append( tvi.spinSystem(cluster, jx=j3, jy=j1, jz=j2, hx=h3, hy=h1, hz=h2, use_ryd_detunes=0)) spin_model_list.append( tvi.spinSystem(cluster, jx=j1, jy=j3, jz=j2, hx=h1, hy=h3, hz=h2, use_ryd_detunes=0)) spin_model_list.append( tvi.spinSystem(cluster, jx=j2, jy=j1, jz=j3, hx=h2, hy=h1, hz=h3, use_ryd_detunes=0)) spin_model_list.append( tvi.spinSystem(cluster, jx=j3, jy=j2, jz=j1, hx=h3, hy=h2, hz=h1, use_ryd_detunes=0)) eig_vals_list = [] for spin_model in spin_model_list: hamiltonian = spin_model.createH() eig_vals, eig_vects = spin_model.diagH(hamiltonian) # cannot get agreement better than 1e-10 eig_vals_list.append(np.round(eig_vals, 10)) n_comparisons = len(spin_model_list) - 1 eig_val_comparisons = np.zeros(n_comparisons) for ii in range(0, n_comparisons): eig_val_comparisons[ii] = np.abs(eig_vals_list[ii] - eig_vals_list[ii + 1]).max() == 0 self.assertTrue(np.all(eig_val_comparisons))
""" exact digaonalization of Heisenberg system """ import numpy as np import ed_geometry as geom import ed_spins as spins import ed_symmetry as symm # set up system J = 1 gm = geom.Geometry.createSquareGeometry(10, 1, 0, 0, bc1_open=False, bc2_open=True) ss = spins.spinSystem(gm, jx=J, jy=J, jz=J) # total sz and spin flip op sz_op = ss.get_sum_op(ss.sz) sz_flip_op = ss.get_swap_up_down_op() # translation operators xtransl_fn = symm.getTranslFn(np.array([[1], [0]])) xtransl_cycles, ntranslations = symm.findSiteCycles(xtransl_fn, ss.geometry) tx_op = ss.get_xform_op(xtransl_cycles) # inversion op cx, cy = ss.geometry.get_center_of_mass() inv_fn = symm.getInversionFn(cx, cy) inv_cycles, _ = symm.findSiteCycles(inv_fn, ss.geometry) inv_op = ss.get_xform_op(inv_cycles) # get projectors on mz subspace mz_projs, mzs = ss.get_subspace_projs(sz_op.tocsr())
nx = 4 ny = 1 phi1 = 0 phi2 = 0 bc_open1 = 1 bc_open2 = 1 gm = geom.Geometry.createSquareGeometry(nx, ny, phi1, phi2, bc_open1, bc_open2) gm.dispGeometry() j1 = 0.3333 j2 = 0.23623627 j3 = 0.8434783478 # -1 to account for difference in definitions js = -np.array([[0, j1, j2, j3], [j1, 0, j2, j3], [j2, j2, 0, j3], [j3, j3, j3, 0]]) ss = ed_spins.spinSystem(gm, jx=js, jy=js, jz=js, spin=spin) hamiltonian = ss.createH() eig_vals, eig_vects = ss.diagH(hamiltonian) # verify these are equal to expected result # E = j1 * [s1*(s1+1) + s2*(s2+1)] + j2 * s3*(s3+1) + j3 * s4*(s4+1) + (j2-j1)*s12*(s12+1) + (j3-j2)*s123*(s123+1) - j3 * s1234 * (s1234 + 1) eigs_analytic = [] s1 = spin s2 = s1 s3 = s1 s4 = s1 s12s = np.arange(np.abs(s1 - s2), s1 + s2 + 1) for s12 in s12s: for s123 in np.arange(np.abs(s3 - s12), s3 + s12 + 1):