def test_otf_parser_from_checkpt(software): if not os.environ.get(cmd[software], False): pytest.skip(f"{cmd[software]} not found in environment:" " Please install the code " f" and set the {cmd[software]} env. " "variable to point to the executable.") if software == "cp2k": pytest.skip() example = 1 casename = name_list[example] log_name = f"{casename}_otf_{software}" output_name = f"{log_name}.out" otf_traj = OtfAnalysis(output_name) try: replicated_gp = otf_traj.make_gp() except: init_gp = GaussianProcess.from_file(log_name + "_gp.json") replicated_gp = otf_traj.make_gp(init_gp=init_gp) outdir = f"test_outputs_{software}" if not os.path.isdir(outdir): os.mkdir(outdir) for f in os.listdir("./"): if f"{casename}_otf_{software}" in f: shutil.move(f, outdir) cleanup(software, f"{casename}_otf_{software}")
def test_otf_parser(md_engine): output_name = f"{md_engine}.out" otf_traj = OtfAnalysis(output_name) try: replicated_gp = otf_traj.make_gp() except: init_flare = FLARE_Calculator.from_file(md_engine + "_flare.json") replicated_gp = otf_traj.make_gp(init_gp=init_flare.gp_model) print("ase otf traj parsed") for f in glob.glob(md_engine + "*"): os.remove(f)
def test_replicate_gp(): """ Based on gp_test_al.out, ensures that given hyperparameters and DFT calls a GP model can be reproduced and correctly re-predict forces and uncertainties :return: """ os.system('cp test_files/sample_h2_otf.out .') parsed = OtfAnalysis('sample_h2_otf.out') positions = parsed.position_list forces = parsed.force_list gp_model = parsed.make_gp() structures = parsed.output_md_structures() assert np.isclose(structures[-1].positions, positions[-1]).all() assert np.isclose(structures[-1].forces, forces[-1]).all() final_structure = structures[-1] pred_for, pred_stds = predict_on_structure(final_structure, gp_model) assert np.isclose(final_structure.forces, pred_for).all() assert np.isclose(final_structure.stds, pred_stds).all() set_of_structures = structures[-3:-1] for structure in set_of_structures: pred_for, pred_stds = predict_on_structure(structure, gp_model) assert np.isclose(structure.forces, pred_for, atol=1e-6).all() assert np.isclose(structure.stds, pred_stds, atol=1e-6).all() os.system('rm sample_slab_otf.out')
def test_update_L_alpha(): # set up gp model kernel = mc_simple.two_plus_three_body_mc kernel_grad = mc_simple.two_plus_three_body_mc_grad cutoffs = [6.0, 5.0] hyps = np.array([0.001770, 0.183868, -0.001415, 0.372588, 0.026315]) # get an otf traj from file for training data old_otf = OtfAnalysis('test_files/AgI_snippet.out') call_no = 1 cell = old_otf.header['cell'] gp_model = old_otf.make_gp(kernel=kernel, kernel_grad=kernel_grad, call_no=call_no, cutoffs=cutoffs, hyps=hyps) # update database & use update_L_alpha to get ky_mat for n in range(call_no, call_no + 1): positions = old_otf.gp_position_list[n] species = old_otf.gp_species_list[n] atoms = old_otf.gp_atom_list[n] forces = old_otf.gp_force_list[n] struc_curr = Structure(cell, species, positions) gp_model.update_db(struc_curr, forces, custom_range=atoms) gp_model.update_L_alpha() ky_mat_from_update = np.copy(gp_model.ky_mat) # use set_L_alpha to get ky_mat gp_model.set_L_alpha() ky_mat_from_set = np.copy(gp_model.ky_mat) assert (np.all(np.absolute(ky_mat_from_update - ky_mat_from_set)) < 1e-6)
def test_replicate_gp(): """ Based on gp_test_al.out, ensures that given hyperparameters and DFT calls a GP model can be reproduced and correctly re-predict forces and uncertainties :return: """ parsed = OtfAnalysis('test_files/VelocityVerlet.log') positions = parsed.position_list forces = parsed.force_list gp_model = parsed.make_gp(kernel_name="two_plus_three_body_mc") structures = parsed.output_md_structures() assert np.isclose(structures[-1].positions, positions[-1]).all() assert np.isclose(structures[-1].forces, forces[-1]).all() final_structure = structures[-1] pred_for, pred_stds = predict_on_structure(final_structure, gp_model) assert np.isclose(final_structure.forces, pred_for, rtol=1e-3).all() assert np.isclose(final_structure.stds, pred_stds, rtol=1e-3).all() set_of_structures = structures[-3:-1] for structure in set_of_structures: pred_for, pred_stds = predict_on_structure(structure, gp_model) assert np.isclose(structure.forces, pred_for, rtol=1e-3, atol=1e-6).all() assert np.isclose(structure.stds, pred_stds, rtol=1e-3, atol=1e-6).all()
def test_otf_parser(software): if not os.environ.get(cmd[software], False): pytest.skip(f"{cmd[software]} not found in environment:" " Please install the code " f" and set the {cmd[software]} env. " "variable to point to the executable.") example = 1 casename = name_list[example] output_name = f"{casename}_otf_{software}.out" otf_traj = OtfAnalysis(output_name) replicated_gp = otf_traj.make_gp() # TODO: debug cp2k if software == "cp2k": pytest.skip() otf = pytest.my_otf assert otf.dft_count == len(otf_traj.gp_position_list) assert otf.curr_step == len(otf_traj.position_list) + 1 assert otf.dft_count == len(otf_traj.gp_thermostat["temperature"]) assert otf.curr_step == len(otf_traj.thermostat["temperature"]) + 1 if otf_traj.gp_cell_list: assert otf.dft_count == len(otf_traj.gp_cell_list)
def test_otf_parser(md_engine): output_name = f"{md_engine}.out" otf_traj = OtfAnalysis(output_name) try: replicated_gp = otf_traj.make_gp() except: init_flare = FLARE_Calculator.from_file(md_engine + "_flare.json") replicated_gp = otf_traj.make_gp(init_gp=init_flare.gp_model) print("ase otf traj parsed") # Check that the GP forces change. comp1 = otf_traj.force_list[0][1, 0] comp2 = otf_traj.force_list[-1][1, 0] assert (comp1 != comp2) for f in glob.glob(md_engine + "*"): os.remove(f)
def test_otf_parser(md_engine, write_model): output_name = f"{md_engine}_{write_model}" otf_traj = OtfAnalysis(output_name + ".out") try: replicated_gp = otf_traj.make_gp() except: init_flare = FLARE_Calculator.from_file(output_name + "_flare.json") replicated_gp = otf_traj.make_gp(init_gp=init_flare.gp_model) print("ase otf traj parsed") # Check that the GP forces change. comp1 = otf_traj.force_list[-2][1, 0] comp2 = otf_traj.force_list[-1][1, 0] assert comp1 != comp2 for f in glob.glob(output_name + "*"): os.remove(f) for f in glob.glob("*_ckpt_*"): shutil.rmtree(f, ignore_errors=True)
def test_stress_with_lammps(): """ Based on gp_test_al.out, ensures that given hyperparameters and DFT calls a GP model can be reproduced and correctly re-predict forces and uncertainties :return: """ # build up GP from a previous trajectory parsed = OtfAnalysis('test_files/VelocityVerlet.log') positions = parsed.position_list forces = parsed.force_list gp_model = parsed.make_gp(kernel=two_plus_three_body_mc, kernel_grad=two_plus_three_body_mc_grad) # build up MGP from GP struc_params = { 'species': [47, 53], 'cube_lat': np.eye(3) * 100, 'mass_dict': { '0': 27, '1': 16 } } # grid parameters lower_cut = 2.5 grid_num_2 = 64 grid_num_3 = 32 two_cut = 5.0 three_cut = 5.0 grid_params = { 'bounds_2': [[lower_cut], [two_cut]], 'bounds_3': [[lower_cut, lower_cut, -1], [three_cut, three_cut, 1]], 'grid_num_2': grid_num_2, 'grid_num_3': [grid_num_3, grid_num_3, grid_num_3], 'svd_rank_2': 0, 'svd_rank_3': 0, 'bodies': [2, 3], 'load_grid': None, 'update': True } mgp_model = MappedGaussianProcess(gp_model.hyps, gp_model.cutoffs, grid_params, struc_params, mean_only=True, container_only=False, GP=gp_model, lmp_file_name='lmp.mgp') # ------------ create ASE's flare calculator ----------------------- flare_calc = FLARE_Calculator(gp_model, mgp_model, par=True, use_mapping=True) a = 3.855 alpha = 90 super_cell = crystal( ['Ag', 'I'], # Ag, I basis=[(0, 0, 0), (0.5, 0.5, 0.5)], size=(2, 1, 1), cellpar=[a, a, a, alpha, alpha, alpha]) super_cell.positions = positions[-1] super_cell.set_calculator(flare_calc) super_cell.get_forces() stresses = super_cell.calc.results['stresses'] # parse lammps stress lmp_file = open('test_files/stress.lammps') lines = lmp_file.readlines()[9:] for ind, line in enumerate(lines): line = line.split() strs = np.array([float(l) for l in line[1:]]) / 1.60217662e6 assert np.isclose(stresses[ind], strs, rtol=1e-3).all() os.system('rm -r __pycache__') os.system('rm grid3*') os.system('rm -r kv3') os.system('rm lmp.mgp')