def test_delayed_updates_check(config): success = True print('Testing delayed updates', flush=True) n_agreed = 0 n_failed = 0 wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) for _ in range(200): current_ampl = wf.current_ampl for step in range(1000): acc, detr, jastrr = wf.perform_MC_step()[:3] current_ampl *= detr * jastrr wf.perform_explicit_GF_update() final_ampl = wf.current_ampl final_ampl_solid = wf.get_cur_Jastrow_factor() * wf.get_cur_det() if np.isclose(final_ampl_solid, final_ampl) and np.isclose(current_ampl, final_ampl): n_agreed += 1 else: print('Delayed updates test failed:', final_ampl, final_ampl_solid) n_failed += 1 success = False if n_failed == 0: print('Passed') else: print('Failed on samples:', n_failed) return success
def test_double_move_commutation_check(config): success = True print('Testing fast double updates have correct commutation properties...', flush=True) n_agreed = 0 n_failed = 0 wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) state = (wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy) while n_agreed < 1000: L = len(wf.state) // 2 i, j, k, l = np.random.randint(0, 2 * L, size = 4) if len(np.unique([i, j, k, l])) < 4: continue ratio_fast_ijkl = get_wf_ratio_double_exchange(*state, wf.var_f, i, j, k, l) ratio_fast_ilkj = get_wf_ratio_double_exchange(*state, wf.var_f, i, l, k, j) ratio_fast_kjil = get_wf_ratio_double_exchange(*state, wf.var_f, k, j, i, l) ratio_fast_lkij = get_wf_ratio_double_exchange(*state, wf.var_f, k, l, i, j) if np.allclose([ratio_fast_ilkj, ratio_fast_kjil, ratio_fast_lkij], \ [-ratio_fast_ijkl, -ratio_fast_ijkl, ratio_fast_ijkl], atol = 1e-11, rtol = 1e-11): n_agreed += 1 # print('double move check permutation ⟨x|d^{\\dag}_i d_j d^{\\dag}_k d_l|Ф⟩ / ⟨x|Ф⟩ fine:', \ # ratio_fast_ijkl, ratio_fast_ilkj, ratio_fast_kjil, ratio_fast_lkij, i, j, k, l) else: print('double move check permutation ⟨x|d^{\\dag}_i d_j d^{\\dag}_k d_l|Ф⟩ / ⟨x|Ф⟩ failed:', \ ratio_fast_ijkl, ratio_fast_ilkj, ratio_fast_kjil, ratio_fast_lkij, i, j, k, l) n_failed += 1 success = False if n_failed == 0: print('Passed') else: print('Failed on samples:', n_failed) return success
def test_onsite_gf_is_density_check(config): success = True print('Testing ⟨x|d^{\\dag}_i d_i|Ф⟩ / ⟨x|Ф⟩ = n_i', flush=True) n_agreed = 0 n_failed = 0 wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) while n_agreed < 50: L = len(wf.state) // 2 i = np.random.randint(0, 2 * L) state = (wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy) gf = get_wf_ratio(*state, wf.var_f, i, i) density = float(wf.place_in_string[i] > -1) if np.isclose(density, gf, atol = 1e-11, rtol = 1e-11): n_agreed += 1 else: print('Testing ⟨x|d^{\\dag}_i d_i|Ф⟩ / ⟨x|Ф⟩ = n_i failed:', density, gf, i) n_failed += 1 success = False if n_failed == 0: print('Passed') else: print('Failed on samples:', n_failed) return success
def test_chiral_gap_preserves_something(config): success = True print('Testing that some elements of H_MF are zero', flush=True) n_agreed = 0 n_failed = 0 for _ in range(20): wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) i, j = np.random.randint(0, config.total_dof // 2, size = 2) j += config.total_dof // 2 acc, det_ratio, j_ratio, i, j = wf.perform_MC_step(proposed_move = (i, j), enforce=True) if not acc: continue if config.enforce_valley_orbitals: if np.abs(det_ratio) > 1e-10 and (i + j) % 2 == 1: n_failed += 1 print(i, j, det_ratio, flush=True) if not config.enforce_valley_orbitals: if np.abs(det_ratio) > 1e-10 and (i + j) % 2 == 0: n_failed += 1 print(i, j, det_ratio) if n_failed == 0: print('Passed') else: print('Failed on samples:', n_failed) success = False # exit(-1) return success
def test_double_move_check(config): success = True print('Testing double moves ⟨x|d^{\\dag}_i d_j d^{\\dag}_k d_l|Ф⟩ / ⟨x|Ф⟩', flush=True) n_agreed = 0 n_failed = 0 # wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) while n_agreed < 20: print('try', n_agreed) wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) L = len(wf.state) // 2 i, j, k, l = np.random.randint(0, 2 * L, size = 4) print(i, j, k, l) #if i == j or i == l or k == l or k == j: # continue # the degenerate cases are considered separately (directly by density operator) initial_ampl = wf.current_ampl state = deepcopy((wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy)) ratio_fast = get_wf_ratio_double_exchange(*state, wf.var_f, i, j, k, l) W_ij_0 = get_wf_ratio(*state, wf.var_f, i, j) acc = wf.perform_MC_step(proposed_move = (i, j))[0] if not acc: print('failed first acc') continue wf.perform_explicit_GF_update() state = (wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy) middle_ampl = wf.current_ampl W_kl_upd = get_wf_ratio(*state, wf.var_f, k, l) ratio_check = W_kl_upd * W_ij_0 acc = wf.perform_MC_step(proposed_move = (k, l))[0] if not acc: print('failed 2nd acc') continue wf.perform_explicit_GF_update() final_ampl = wf.current_ampl ratio_straight = final_ampl / initial_ampl if np.allclose([ratio_fast, ratio_fast], [ratio_straight, ratio_check], atol = 1e-11, rtol = 1e-11): n_agreed += 1 print('success', i, j, k, l) else: print('double move check ⟨x|d^{\\dag}_i d_j d^{\\dag}_k d_l|Ф⟩ / ⟨x|Ф⟩ failed:', ratio_fast / ratio_straight, ratio_straight, ratio_check, i, j, k, l) n_failed += 1 success = False exit(-1) if n_failed == 0: print('Passed') else: print('Failed on samples:', n_failed) return success
def test_particle_hole(config): success = True parameters = config.initial_parameters parameters[:config.layout[0]] *= 0 # set mu_BCS = 0, otherwise no ph-symmetry #parameters *= 0. print('Particle-hole symmetry of the hamiltonian with twist check...', flush=True) wf_ph = wavefunction_singlet(config, config.pairings_list, parameters, False, None, particle_hole=False) HMF = wf_ph.T spectrum, _ = np.linalg.eigh(HMF) if np.allclose(spectrum, -spectrum[::-1]): print('Passed') else: success = False print('Failed') print('Particle-hole symmetry of the wave function check...', flush=True) n_passed = 0 for _ in range(200): seed = np.random.randint(0, 1000) np.random.seed(seed) config.twist = [np.exp(2.0j * np.pi * 0.1904 * 1e-3), np.exp(2.0j * np.pi * (0.1904 + 0.10) * 1e-3)] wf_ph = wavefunction_singlet(config, config.pairings_list, parameters, False, None, particle_hole=False) np.random.seed(seed) #config.twist = [np.exp(-2.0j * np.pi * 0.1904), np.exp(-2.0j * np.pi * (0.1904 + 0.10))] wf_hp = wavefunction_singlet(config, config.pairings_list, parameters, False, None, particle_hole=True) n_passed += float(np.isclose(wf_ph.current_ampl, wf_hp.current_ampl)) if not (np.abs(np.abs(wf_ph.current_ampl / wf_hp.current_ampl) - 1.0) < 1e-8): print('Failed', wf_ph.current_ampl / wf_hp.current_ampl) print('Failed', wf_ph.current_det / wf_hp.current_det) else: print('Passed', np.angle(wf_ph.current_ampl / wf_hp.current_ampl)) if n_passed == 200: print('Passed') else: print('Failed!') success = False return success
def test_single_move_check(config): success = True print('Testing simple moves ⟨x|d^{\\dag}_i d_k|Ф⟩ / ⟨x|Ф⟩', flush=True) n_agreed = 0 n_failed = 0 wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) #for MC_step in range(config.MC_thermalisation): # wf.perform_MC_step() #wf.perform_explicit_GF_update() for _ in range(20): wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) L = len(wf.state) // 2 i, j = np.random.randint(0, 2 * L, size = 2) initial_ampl = wf.current_ampl state = (wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy) ratio_fast = get_wf_ratio(*state, wf.var_f, i, j) acc = wf.perform_MC_step((i, j), enforce = True)[0] if not acc: continue wf.perform_explicit_GF_update() final_ampl = wf.current_ampl final_ampl_solid = wf.get_cur_Jastrow_factor() * wf.get_cur_det() if np.isclose(final_ampl / initial_ampl, ratio_fast) and np.isclose(final_ampl_solid, final_ampl): n_agreed += 1 else: print('single move check ⟨x|d^{\\dag}_i d_k|Ф⟩ / ⟨x|Ф⟩ failed:', final_ampl / initial_ampl, ratio_fast) n_failed += 1 success = False if n_failed == 0: print('Passed') else: print('Failed on samples:', n_failed) return success
def test_gf_means_correct(config): success = True print('Testing Greens function ⟨x|d^{\\dag}_i d_k|Ф⟩ / ⟨x|Ф⟩', flush=True) n_agreed = 0 n_failed = 0 for _ in range(200): wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) L = len(wf.state) // 2 i, j = np.random.randint(0, 2 * L, size = 2) initial_ampl = wf.current_ampl state = (wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy) ratio_fast = get_wf_ratio(*state, wf.var_f, i, j) acc = wf.perform_MC_step((i, j), enforce = False)[0] if not acc: continue
def test_explicit_factors_check(config): # np.random.seed(14) wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) for MC_step in range(config.MC_thermalisation): wf.perform_MC_step() wf.perform_explicit_GF_update() delta = np.sum(np.abs(wf.Jastrow - wf.Jastrow.T)) success = True print('Testing the Jastrow matrix is symmetric', flush=True) if np.isclose(delta, 0.0, rtol=1e-11, atol=1e-11): print('Passed') else: print('Failed:', np.sum(np.abs(delta))) print('Testing det and jastrow factors', flush=True) for _ in range(100): det_initial = wf.get_cur_det() Jastrow_initial = wf.get_cur_Jastrow_factor() acc = False ddet = 1. dJastrow = 1. while not acc: state = deepcopy((wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy)) acc, ddet, dJastrow, moved_site, empty_site = wf.perform_MC_step() wf.perform_explicit_GF_update() det_final = wf.get_cur_det() Jastrow_final = wf.get_cur_Jastrow_factor() if not np.isclose(ddet, det_final / det_initial, atol = 1e-8, rtol = 1e-8): print('Det ratio failed:', ddet, det_final / det_initial, moved_site, empty_site) success = False if not np.isclose(dJastrow, Jastrow_final / Jastrow_initial, rtol=1e-10, atol=1e-10): print('Jastrow ratio failed:', dJastrow, Jastrow_final / Jastrow_initial, moved_site, empty_site) success = False if success: print('Passed') return success
def test_chain_moves(config): success = True print('Testing chain of moves \\prod_{move} ⟨x|d^{\\dag}_i d_k|Ф⟩ / ⟨x|Ф⟩', flush=True) n_agreed = 0 n_failed = 0 for _ in range(20): wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) ratio_acc = 1. + 0.0j initial_ampl = wf.current_ampl for move in range(300): L = len(wf.state) // 2 #i, j = np.random.randint(0, 2 * L, size = 2) state = (wf.Jastrow, wf.W_GF, wf.place_in_string, wf.state, wf.occupancy) acc, det_ratio, j_ratio, i, j = wf.perform_MC_step() #print(ratio_acc, det_ratio, j_ratio) ratio_acc *= (det_ratio * j_ratio) #if i > L and j < L: # print('non-conserving move') wf.perform_explicit_GF_update() final_ampl = wf.current_ampl final_ampl_solid = wf.get_cur_Jastrow_factor() * wf.get_cur_det() if np.isclose(final_ampl / initial_ampl, ratio_acc) and np.isclose(final_ampl_solid, final_ampl): n_agreed += 1 else: print('chain ⟨x|d^{\\dag}_i d_k|Ф⟩ / ⟨x|Ф⟩ failed:', final_ampl / initial_ampl, ratio_acc) n_failed += 1 success = False if n_failed == 0: print('Passed') else: print('Failed on samples:', n_failed) return success
def _get_MC_chain_result(n_iter, config_vmc, pairings_list, \ parameters, twist, final_state = False, orbitals_in_use = None, K_up = None, K_down = None, reg = None, twist_id = 0): config_vmc.twist = tuple(twist) t = time() hamiltonian = config_vmc.hamiltonian( config_vmc, K_up, K_down) # the Hubbard Hamiltonian will be initialized with the print('H init takes {:.10f}'.format(time() - t)) # print(K_up, K_down, flush=True) ''' if final_state == False: wf = wavefunction_singlet(config_vmc, pairings_list, parameters, False, None) else: wf = wavefunction_singlet(config_vmc, pairings_list, parameters, True, final_state) ''' t = time() if final_state == False: wf = wavefunction_singlet(config_vmc, pairings_list, parameters, \ False, None, orbitals_in_use, \ False, K_up, K_down, reg) # always start with bare configuration else: print('With presaved state') wf = wavefunction_singlet(config_vmc, pairings_list, parameters, \ True, final_state, orbitals_in_use, \ False, K_up, K_down, reg) print('WF Init takes {:.10f}'.format(time() - t)) wf.perform_explicit_GF_update() configs = [] t_steps = 0 t = time() n_steps = 0 for MC_step in range(config_vmc.MC_thermalisation): n_steps += 1 #t = time() acc = wf.perform_MC_step(demand_accept=False)[0] #print('MC step takes {:.10f}, accepted = {:b}'.format(time() - t, acc)) t_steps += time() - t energies = [] Os = [] acceptance = [] densities = [] t_energies = 0 t_forces = 0 t_observables = 0 t_update = 0 observables = [] names = [] plus_densities = [] minus_densities = [] precision_factor = 1. if config_vmc.opt_raw > n_iter else 4. tc = time() for MC_step in range( int(precision_factor * config_vmc.MC_chain * (config_vmc.opt_parameters[2]**n_iter))): n_steps += 1 if MC_step % config_vmc.correlation == 0: t = time() wf.perform_explicit_GF_update() t_steps += time() - t t = time() energies.append(hamiltonian(wf)) densities.append(wf.total_density()) plus_densities.append(wf.total_plus_density()) minus_densities.append(wf.total_minus_density()) t_energies += time() - t #print('energies take {:.10f}'.format(time() - t)) t = time() if config_vmc.generator_mode: # forces only if necessary Os.append(wf.get_O()) t_forces += time() - t #print('forces take {:.10f}'.format(time() - t)) t = time() if MC_step % config_vmc.observables_frequency == 0 and n_iter > config_vmc.thermalization \ and (n_iter - config_vmc.thermalization) % config_vmc.obs_calc_frequency == 1: obs, names = observables_vmc.compute_observables(wf) observables.append(obs) t_observables += time() - t #t = time() acceptance.append(wf.perform_MC_step(demand_accept=False)[0]) #configs.append(wf.state.copy() * 1.0) #print('MC step take {:.10f}'.format(time() - t)) t_steps += time() - t # print('t_chain = ', time() - tc) print(t_update, t_observables, t_energies, t_forces, t_steps, wf.update, wf.wf, twist) print(wf.t_jastrow / n_steps, wf.t_det / n_steps, wf.t_choose_site / n_steps, wf.t_overhead_after / n_steps, wf.t_gf_update / np.sum(acceptance), wf.t_ab / np.sum(acceptance)) print(wf.t_jastrow, wf.t_det, wf.t_choose_site, wf.t_overhead_after, wf.t_gf_update, wf.t_ab, flush=True) # self.t_jastrow = 0 # self.t_det = 0 # self.t_choose_site = 0 # self.t_overhead_after = 0 # self.t_gf_update = 0 # self.t_ab = 0 #print('accepted = {:d}, rejected_filling = {:d}, rejected_factor = {:d}'.format(wf.accepted, wf.rejected_filled, wf.rejected_factor)) ''' U = wf.U_matrix plus_valley_particle = np.einsum('ij,ij->j', U[np.arange(0, config_vmc.total_dof // 2, 2), ...], \ U[np.arange(0, config_vmc.total_dof // 2, 2), ...].conj()).real plus_valley_hole = np.einsum('ij,ij->j', U[np.arange(config_vmc.total_dof // 2, config_vmc.total_dof, 2), ...], \ U[np.arange(config_vmc.total_dof // 2, config_vmc.total_dof, 2), ...].conj()).real minus_valley_particle = np.einsum('ij,ij->j', U[np.arange(1, config_vmc.total_dof // 2, 2), ...], \ U[np.arange(1, config_vmc.total_dof // 2, 2), ...].conj()).real minus_valley_hole = np.einsum('ij,ij->j', U[np.arange(config_vmc.total_dof // 2 + 1, config_vmc.total_dof, 2), ...], \ U[np.arange(config_vmc.total_dof // 2 + 1, config_vmc.total_dof, 2), ...].conj()).real thr = 0.99 plus_valley_particle = plus_valley_particle > thr plus_valley_hole = plus_valley_hole > thr minus_valley_particle = minus_valley_particle > thr minus_valley_hole = minus_valley_hole > thr print(twist, np.mean(np.abs(wf.wf_ampls)), np.mean(acceptance), wf.gap, np.mean(densities), np.std(densities), \ np.mean(plus_densities), np.std(plus_densities), np.mean(minus_densities), np.std(minus_densities), 'wave function ampl!', \ np.mean(np.abs(np.abs(Os)[:, 0])), \ np.sum(plus_valley_particle), np.sum(minus_valley_particle), np.sum(plus_valley_hole), np.sum(minus_valley_hole), \ np.sum(plus_valley_particle + plus_valley_hole + minus_valley_particle + minus_valley_hole)) print('!!!!!!!!!!!!!!!!', wf.accepted / (wf.accepted + wf.rejected_factor), np.mean(wf.ws), np.mean(np.array(wf.ws) ** 2)) ''' #configs = np.array(configs) #print('correlation: ') #for shift in range(1000): # A = np.einsum('ij,ij', configs[np.arange(len(configs) - shift)], configs[shift + np.arange(len(configs) - shift)]) / len(np.arange(len(configs) - shift)) / len(configs[0]) * 2 # print('A[{:d}] = {:.10f}'.format(shift, A), flush=True) return energies, Os, acceptance, wf.get_state(), observables, \ names, wf.U_matrix, wf.E, densities, wf.gap
def test_gf_symmetry(config): print('Testing WF symmetry ⟨x|S|Ф⟩ = U ⟨x|Ф⟩', flush=True) n_agreed = 0 n_failed = 0 C3z = np.argmax(np.abs(pairings.C3z_symmetry_map_chiral), axis = 0) C2y = np.argmax(np.abs(pairings.C2y_symmetry_map_chiral), axis = 0) Tx = np.argmax(np.abs(pairings.Tx_symmetry_map), axis = 0) Ty = np.argmax(np.abs(pairings.Ty_symmetry_map), axis = 0) TRS = np.concatenate([np.array([2 * i + 1, 2 * i]) for i in range(config.total_dof // 2)]) PHS = np.concatenate([np.arange(config.total_dof // 2, config.total_dof), np.arange(0, config.total_dof // 2)], axis = 0) C3z = np.concatenate([C3z, C3z + config.total_dof // 2]) C2y = np.concatenate([C2y, C2y + config.total_dof // 2]) Tx = np.concatenate([Tx, Tx + config.total_dof // 2]) Ty = np.concatenate([Ty, Ty + config.total_dof // 2]) parameters = config.initial_parameters.copy() parameters[0] = 0; # to ensure particle-hole symmetry for _ in range(20): wf = wavefunction_singlet(config, config.pairings_list, config.initial_parameters, False, None) ampl = wf.get_cur_det() * wf.get_cur_Jastrow_factor() occ_sites, _, _ = wf.get_state() conf = np.zeros(config.total_dof); conf[occ_sites] = 1 assert len(C3z) == len(conf) conf_new = conf[C3z] occ_new = np.where(conf_new > 0)[0] assert len(occ_new) == len(occ_sites) place_in_string = (np.zeros(config.total_dof) - 1).astype(np.int64) place_in_string[occ_new] = np.arange(len(occ_new)) empty_sites = np.arange(config.total_dof); empty_sites[occ_new] = -1; empty_sites = set(empty_sites[empty_sites > -0.5]) wf_transformed = wavefunction_singlet(config, config.pairings_list, \ config.initial_parameters, True, (occ_new, empty_sites, place_in_string)) ampl_new = wf_transformed.get_cur_det() * wf_transformed.get_cur_Jastrow_factor() if np.isclose(np.abs(ampl / ampl_new), 1): n_agreed += 1 print('passed C3z', ampl / ampl_new) else: n_failed += 1 print('failed C3z!', ampl, ampl_new, ampl / ampl_new, \ wf.get_cur_det() / wf_transformed.get_cur_det(), \ wf.get_cur_Jastrow_factor() / wf_transformed.get_cur_Jastrow_factor()) #exit(-1) conf_new = conf[C2y] occ_new = np.where(conf_new > 0)[0] place_in_string = (np.zeros(config.total_dof) - 1).astype(np.int64) place_in_string[occ_new] = np.arange(len(occ_new)) empty_sites = np.arange(config.total_dof); empty_sites[occ_new] = -1; empty_sites = set(empty_sites[empty_sites > -0.5]) wf_transformed = wavefunction_singlet(config, config.pairings_list, \ config.initial_parameters, True, (occ_new, empty_sites, place_in_string)) ampl_new = wf_transformed.get_cur_det() * wf_transformed.get_cur_Jastrow_factor() if np.isclose(np.abs(ampl / ampl_new), 1): n_agreed += 1 print('passed C2y', ampl / ampl_new) else: n_failed += 1 print('failed C2y!', ampl, ampl_new, ampl / ampl_new, \ wf.get_cur_det() / wf_transformed.get_cur_det(), \ wf.get_cur_Jastrow_factor() / wf_transformed.get_cur_Jastrow_factor()) conf_new = conf[Tx] occ_new = np.where(conf_new > 0)[0] place_in_string = (np.zeros(config.total_dof) - 1).astype(np.int64) place_in_string[occ_new] = np.arange(len(occ_new)) empty_sites = np.arange(config.total_dof); empty_sites[occ_new] = -1; empty_sites = set(empty_sites[empty_sites > -0.5]) wf_transformed = wavefunction_singlet(config, config.pairings_list, \ config.initial_parameters, True, (occ_new, empty_sites, place_in_string)) ampl_new = wf_transformed.get_cur_det() * wf_transformed.get_cur_Jastrow_factor() if np.isclose(np.abs(ampl / ampl_new), 1): n_agreed += 1 print('passed Tx', ampl / ampl_new) else: n_failed += 1 print('failed Tx!', ampl, ampl_new, ampl / ampl_new, \ wf.get_cur_det() / wf_transformed.get_cur_det(), \ wf.get_cur_Jastrow_factor() / wf_transformed.get_cur_Jastrow_factor()) conf_new = conf[Ty] occ_new = np.where(conf_new > 0)[0] place_in_string = (np.zeros(config.total_dof) - 1).astype(np.int64) place_in_string[occ_new] = np.arange(len(occ_new)) empty_sites = np.arange(config.total_dof); empty_sites[occ_new] = -1; empty_sites = set(empty_sites[empty_sites > -0.5]) wf_transformed = wavefunction_singlet(config, config.pairings_list, \ config.initial_parameters, True, (occ_new, empty_sites, place_in_string)) ampl_new = wf_transformed.get_cur_det() * wf_transformed.get_cur_Jastrow_factor() if np.isclose(np.abs(ampl / ampl_new), 1): n_agreed += 1 print('passed Ty', ampl / ampl_new) else: n_failed += 1 print('failed Ty!', ampl, ampl_new, ampl / ampl_new, \ wf.get_cur_det() / wf_transformed.get_cur_det(), \ wf.get_cur_Jastrow_factor() / wf_transformed.get_cur_Jastrow_factor()) conf_new = conf[TRS] occ_new = np.where(conf_new > 0)[0] place_in_string = (np.zeros(config.total_dof) - 1).astype(np.int64) place_in_string[occ_new] = np.arange(len(occ_new)) empty_sites = np.arange(config.total_dof); empty_sites[occ_new] = -1; empty_sites = set(empty_sites[empty_sites > -0.5]) wf_transformed = wavefunction_singlet(config, config.pairings_list, \ config.initial_parameters, True, (occ_new, empty_sites, place_in_string), trs_test = True) ampl_new = wf_transformed.get_cur_det() * wf_transformed.get_cur_Jastrow_factor() if np.isclose(np.abs(ampl / ampl_new), 1): n_agreed += 1 print('passed TRS', ampl / ampl_new) else: n_failed += 1 print('failed TRS!', ampl, ampl_new, ampl / ampl_new, \ wf.get_cur_det() / wf_transformed.get_cur_det(), \ wf.get_cur_Jastrow_factor() / wf_transformed.get_cur_Jastrow_factor()) conf_new = conf[PHS] occ_new = np.where(conf_new > 0)[0] place_in_string = (np.zeros(config.total_dof) - 1).astype(np.int64) place_in_string[occ_new] = np.arange(len(occ_new)) empty_sites = np.arange(config.total_dof); empty_sites[occ_new] = -1; empty_sites = set(empty_sites[empty_sites > -0.5]) wf_transformed = wavefunction_singlet(config, config.pairings_list, \ config.initial_parameters, True, (occ_new, empty_sites, place_in_string), ph_test = True) ampl_new = wf_transformed.get_cur_det() * wf_transformed.get_cur_Jastrow_factor() if np.isclose(np.abs(ampl / ampl_new), 1): n_agreed += 1 print('passed PHS', ampl / ampl_new, ampl) else: n_failed += 1 print('failed PHS!', ampl, ampl_new, ampl / ampl_new, \ wf.get_cur_det() / wf_transformed.get_cur_det(), \ wf.get_cur_Jastrow_factor() / wf_transformed.get_cur_Jastrow_factor()) print('\n\n\n\n') return n_failed == 0
def test_numerical_derivative_check(config): print(config.twist) dt = 1e-7 success = True der_shift = 0 print('chemical potentials derivative check...', flush=True) n_passed = 0 for mu_idx in range(config.layout[0]): np.random.seed(11) delta = np.zeros(len(config.initial_parameters)); delta[der_shift] += 1 wf_1 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters - delta * dt / 2, False, None) np.random.seed(11) wf_2 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters + delta * dt / 2, False, None) n_passed += float(compare_derivatives_numerically(wf_1, wf_2, der_shift, dt)) der_shift += 1 if n_passed == config.layout[0]: print('Passed') else: print('Failed!') success = False ''' print('fugacity derivative check...', flush=True) if not config.PN_projection: np.random.seed(11) delta = np.zeros(len(config.initial_parameters)); delta[der_shift] += 1 wf_1 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters - delta * dt / 2, False, None) np.random.seed(11) wf_2 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters + delta * dt / 2, False, None) if compare_derivatives_numerically(wf_1, wf_2, der_shift, dt): print('Passed') else: print('Failed!') success = False der_shift += config.layout[1] ''' print('hoppings derivative check...', flush=True) n_passed = 0 for waves_idx in range(config.layout[2]): np.random.seed(11) delta = np.zeros(len(config.initial_parameters)); delta[der_shift] += 1 wf_1 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters - delta * dt / 2, False, None) np.random.seed(11) wf_2 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters + delta * dt / 2, False, None) n_passed += float(compare_derivatives_numerically(wf_1, wf_2, der_shift, dt)) der_shift += 1 if n_passed == config.layout[2]: print('Passed') else: print('Failed!') success = False print('Pairings derivative check...', flush=True) n_passed = 0 for gap_idx in range(config.layout[3]): np.random.seed(11) delta = np.zeros(len(config.initial_parameters)); delta[der_shift] += 1 wf_1 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters - delta * dt / 2, False, None) np.random.seed(11) wf_2 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters + delta * dt / 2, False, None) n_passed += float(compare_derivatives_numerically(wf_1, wf_2, der_shift, dt)) der_shift += 1 if n_passed == config.layout[3]: print('Passed') else: print('Failed!') success = False print('Jastrow derivative check...', flush=True) n_passed = 0 for jastrow_idx in range(config.layout[4]): np.random.seed(11) delta = np.zeros(len(config.initial_parameters)); delta[der_shift] += 1 wf_1 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters - delta * dt / 2, False, None) np.random.seed(11) wf_2 = wavefunction_singlet(config, config.pairings_list, config.initial_parameters + delta * dt / 2, False, None) n_passed += float(compare_derivatives_numerically(wf_1, wf_2, der_shift, dt)) der_shift += 1 if n_passed == config.layout[4]: print('Passed') else: print('Failed!') success = False return success