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
