def check_del_atom(value): atoms, exp = value[0:2] proc, alg = value[-1] scat = ElasticScatter(exp_dict=exp, verbose=True) scat.set_processor(proc, alg) assert scat._check_wrap_atoms_state(atoms) == False # Test a set of different sized ensembles ans1 = scat.get_fq(atoms) assert scat._check_wrap_atoms_state(atoms) == True # Check that Scatter gave back something assert ans1 is not None assert np.any(ans1) atoms2 = dc(atoms) del atoms2[np.random.choice(len(atoms2))] assert scat._check_wrap_atoms_state(atoms2) == False ans2 = scat.get_fq(atoms2) assert scat._check_wrap_atoms_state(atoms2) == True # Check that Scatter gave back something assert ans2 is not None assert np.any(ans2) assert not np.allclose(ans1, ans2) # make certain we did not give back the same pointer assert ans1 is not ans2 # Check that all the values are not zero del atoms, exp, proc, alg, scat, ans1 return
def check_scatter_fq(value): """ Check two processor, algorithm pairs against each other for FQ calculation :param value: :return: """ # set everything up atoms, exp = value[:2] scat = ElasticScatter(exp_dict=exp, verbose=True) proc1, alg1 = value[-1][0] proc2, alg2 = value[-1][1] # run algorithm 1 scat.set_processor(proc1, alg1) ans1 = scat.get_fq(atoms) # run algorithm 2 scat.set_processor(proc2, alg2) ans2 = scat.get_fq(atoms) # test if not stats_check(ans1, ans2, rtol, atol): print(value) assert_allclose(ans1, ans2, rtol=rtol, atol=atol) # make certain we did not give back the same pointer assert ans1 is not ans2
def finite_difference_grad(atoms, exp_dict): s = ElasticScatter(exp_dict, verbose=True) start_fq = s.get_fq(atoms) finite_difference_grad_fq = np.zeros((len(atoms), 3, len(start_fq))) for i in range(len(atoms)): for w in range(3): atoms2 = dc(atoms) atoms2[i].position[w] += dq fq2 = s.get_fq(atoms2) finite_difference_grad_fq[i, w, :] = (fq2 - start_fq) / dq return finite_difference_grad_fq
def check_scatter_fq(value): """ Smoke test for FQ Parameters ---------- value: list or tuple The values to use in the tests """ atoms, exp = value[0:2] proc, alg = value[-1] scat = ElasticScatter(exp_dict=exp, verbose=True) scat.set_processor(proc, alg) # Test a set of different sized ensembles ans = scat.get_fq(atoms) # Check that Scatter gave back something assert ans is not None # Check that all the values are not zero assert np.any(ans) del atoms, exp, proc, alg, scat, ans return
def test_consistency(): outs = [[] for i in range(len(test_atoms))] s = ElasticScatter() for i, atoms in enumerate(test_data): fq = s.get_fq(atoms) outs[i % len(test_atoms)].append(fq) for j in range(len(test_atoms)): for a, b in permutations(outs[j], 2): stats_check(a, b, rtol=2e-7, atol=1e-7)
def check_scatter_consistancy(value): atoms, exp = value[0:2] proc, alg = value[-1] scat = ElasticScatter(exp_dict=exp, verbose=True) scat.set_processor(proc, alg) ans = scat.get_pdf(atoms) ans1 = scat.get_fq(atoms) print(len(ans1)) print(scat.get_scatter_vector().shape) ans2 = scat.get_sq(atoms) print(len(ans2)) ans3 = scat.get_iq(atoms)
def check_dynamics(value): """ Test classical dynamics simulation, symplectic dynamics are look the same forward as reversed Parameters ---------- value: list or tuple The values to use in the tests """ ideal_atoms, _ = value[0] ideal_atoms.set_velocities(np.zeros((len(ideal_atoms), 3))) if isinstance(value[1], str): s = ElasticScatter(verbose=True) target_data = None exp_func = None exp_grad = None if value[1] == 'PDF': target_data = s.get_pdf(ideal_atoms) exp_func = s.get_pdf exp_grad = s.get_grad_pdf elif value[1] == 'FQ': target_data = s.get_fq(ideal_atoms) exp_func = s.get_fq exp_grad = s.get_grad_fq calc = Calc1D(target_data=target_data, exp_function=exp_func, exp_grad_function=exp_grad, potential='rw', conv=30) else: calc = value[1] ideal_atoms.positions *= 1.02 ideal_atoms.set_calculator(calc) start_pe = ideal_atoms.get_potential_energy() e = value[2] traj = classical_dynamics(ideal_atoms, e, 5) pe_list = [] for atoms in traj: pe_list.append(atoms.get_potential_energy()) min_pe = np.min(pe_list) print(min_pe, start_pe, len(traj)) print(pe_list) if start_pe != 0.0: assert min_pe < start_pe
def check_n_forces(value): """ Test numerical vs analytical forces Parameters ---------- value: list or tuple The values to use in the tests """ rtol = 1e-6 atol = 6e-5 ideal_atoms = value[0] ideal_atoms.set_velocities(np.zeros((len(ideal_atoms), 3))) if isinstance(value[1], str): s = ElasticScatter(verbose=True) target_data = None exp_func = None exp_grad = None if value[1] == 'PDF': target_data = s.get_pdf(ideal_atoms) exp_func = s.get_pdf exp_grad = s.get_grad_pdf elif value[1] == 'FQ': target_data = s.get_fq(ideal_atoms) exp_func = s.get_fq exp_grad = s.get_grad_fq calc = Calc1D(target_data=target_data, exp_function=exp_func, exp_grad_function=exp_grad, potential='rw', conv=1) else: calc = value[1] ideal_atoms.positions *= 1.02 ideal_atoms.set_calculator(calc) ans1 = ideal_atoms.get_forces() ans2 = calc.calculate_numerical_forces(ideal_atoms, d=5e-5) stats_check(ans2, ans1, rtol=rtol, atol=atol )
def check_n_forces(value): """ Test numerical vs analytical forces Parameters ---------- value: list or tuple The values to use in the tests """ rtol = 1e-6 atol = 6e-5 ideal_atoms = value[0] ideal_atoms.set_velocities(np.zeros((len(ideal_atoms), 3))) if isinstance(value[1], str): s = ElasticScatter(verbose=True) target_data = None exp_func = None exp_grad = None if value[1] == 'PDF': target_data = s.get_pdf(ideal_atoms) exp_func = s.get_pdf exp_grad = s.get_grad_pdf elif value[1] == 'FQ': target_data = s.get_fq(ideal_atoms) exp_func = s.get_fq exp_grad = s.get_grad_fq calc = Calc1D(target_data=target_data, exp_function=exp_func, exp_grad_function=exp_grad, potential='rw', conv=1) else: calc = value[1] ideal_atoms.positions *= 1.02 ideal_atoms.set_calculator(calc) ans1 = ideal_atoms.get_forces() ans2 = calc.calculate_numerical_forces(ideal_atoms, d=5e-5) stats_check(ans2, ans1, rtol=rtol, atol=atol)
def test_fq_against_srfit(): # unpack the atoms and experiment atoms = local_test_atoms exp = None # get the pyIID F(Q) s = ElasticScatter(exp) # s.set_processor('CPU', 'nxn') # get the SrFit F(Q) stru = convert_atoms_to_stru(atoms) srfit_calc = DebyePDFCalculator() srfit_calc.qmin = s.exp['qmin'] srfit_calc.qmax = s.exp['qmax'] srfit_calc.qstep = s.exp['qbin'] srfit_calc(stru) stats_check(s.get_scatter_vector(), srfit_calc.qgrid) ans1 = s.get_fq(atoms) ans2 = srfit_calc.fq stats_check(ans1, ans2, rtol=1e-4, atol=5e-6) del srfit_calc stats_check(ans1, ans2, rtol=1e-4, atol=5e-6)