def test_pdf_primitive_vs_supercell(self): test_doc, success = res2dict(REAL_PATH + "data/KP_primitive.res", db=False) test_doc["text_id"] = ["primitive", "cell"] test_doc["lattice_cart"] = abc2cart(test_doc["lattice_abc"]) test_doc["cell_volume"] = cart2volume(test_doc["lattice_cart"]) supercell_doc, success = res2dict(REAL_PATH + "data/KP_supercell.res", db=False) supercell_doc["text_id"] = ["supercell", "cell"] supercell_doc["lattice_cart"] = abc2cart(supercell_doc["lattice_abc"]) supercell_doc["cell_volume"] = cart2volume( supercell_doc["lattice_cart"]) test_doc["pdf"] = PDF(test_doc, dr=0.01, low_mem=True, rmax=10, num_images="auto", debug=DEBUG) supercell_doc["pdf"] = PDF( supercell_doc, dr=0.01, low_mem=True, rmax=10, num_images="auto", debug=DEBUG, ) overlap = PDFOverlap(test_doc["pdf"], supercell_doc["pdf"]) self.assertLessEqual(overlap.similarity_distance, 1e-3) self.assertGreaterEqual(overlap.similarity_distance, 0.0)
def test_convert_positions(self): doc = res2dict(REAL_PATH + "data/structures/Li7Sn-Fmmm.res")[0] crystal = res2dict(REAL_PATH + "data/structures/Li7Sn-Fmmm.res", as_model=True)[ 0 ] doc["positions_abs"] = frac2cart(doc["lattice_cart"], doc["positions_frac"]) np.testing.assert_array_equal(doc["positions_abs"], crystal.positions_abs) print(crystal.positions_abs) for site in crystal: print(site, site.get_coords("cartesian"))
def test_pseudoternary_from_fake_query(self): cursor, s = res2dict(REAL_PATH + "data/hull-LLZO/*.res") print() print(80 * "-") self.assertEqual( len(cursor), 12, "Error with test res files, please check installation...") hull = QueryConvexHull(cursor=cursor, elements=["La2O3", "ZrO2", "Li2O"], no_plot=True) self.assertEqual(len(hull.cursor), 7) fake_query = DBQuery.__new__(DBQuery) fake_query.cursor = hull.cursor for ind, doc in enumerate(fake_query.cursor): fake_query.cursor[ind]["_id"] = None fake_query.cursor[ind]["text_id"] = [doc["source"][0], "."] fake_query._non_elemental = True fake_query._create_hull = True fake_query.args = dict() fake_query.args["intersection"] = True fake_query.args["subcmd"] = "hull" fake_query.args["composition"] = ["La2O3:ZrO2:Li2O"] hull = QueryConvexHull( query=fake_query, hull_cutoff=0.01, chempots=[26200.3194 / 40, -8715.94784 / 12, -3392.59361 / 12], no_plot=True, ) self.assertEqual(len(hull.cursor), 10) self.assertEqual(len(hull.hull_cursor), 9)
def test_binary_from_fake_query(self): cursor, s = res2dict(REAL_PATH + "data/hull-KP-KSnP_pub/*.res") print() print(80 * "-") self.assertEqual( len(cursor), 295, "Error with test res files, please check installation...") hull = QueryConvexHull(cursor=cursor, elements=["KP"], no_plot=True) self.assertEqual(len(hull.cursor), 295) self.assertEqual(len(hull.hull_cursor), 7) fake_query = DBQuery.__new__(DBQuery) fake_query.cursor = hull.cursor for ind, doc in enumerate(fake_query.cursor): fake_query.cursor[ind]["_id"] = None fake_query.cursor[ind]["text_id"] = [doc["source"][0], "."] del fake_query.cursor[ind]["hull_distance"] del fake_query.cursor[ind]["concentration"] fake_query._non_elemental = False fake_query._create_hull = True fake_query.args = dict() fake_query.args["intersection"] = False fake_query.args["subcmd"] = "hull" fake_query.args["composition"] = ["KP"] hull = QueryConvexHull(query=fake_query, chempots=[-791.456765, -219.58161025], no_plot=True) # now need to include custom chempots in counts self.assertEqual(len(hull.cursor), 297) self.assertEqual(len(hull.hull_cursor), 9)
def test_pseudoternary_hull_with_custom_chempots(self): cursor, s = res2dict(REAL_PATH + "data/hull-LLZO/*.res") print() print(80 * "-") self.assertEqual( len(cursor), 12, "Error with test res files, please check installation...") hull = QueryConvexHull( cursor=cursor, elements=["La2O3", "ZrO2", "Li2O"], chempots=[-3275.040 / 5, -2178.987 / 3, -848.148 / 3], no_plot=True, ) self.assertEqual(len(hull.cursor), 10) self.assertEqual(len(hull.hull_cursor), 5) # cursor, s = res2dict(REAL_PATH + 'data/hull-LLZO/*.res') hull = QueryConvexHull( cursor=cursor, elements=["La2O3", "ZrO2", "Li2O"], hull_cutoff=0.20, chempots=[26200.3194 / 40, -8715.94784 / 12, -3392.59361 / 12], no_plot=True, ) self.assertEqual(len(hull.cursor), 10) self.assertEqual(len(hull.hull_cursor), 10) for doc in hull.hull_cursor: if "cubic-LLZO" in doc["source"][0]: self.assertAlmostEqual(doc["formation_enthalpy_per_atom"], -0.05758265622) self.assertAlmostEqual(doc["hull_distance"], 0.008746875) break else: raise RuntimeError("Did not find cubic-LLZO in cursor")
def test_double_uniqueness_hierarchy(self): import glob files = glob.glob(REAL_PATH + "data/uniqueness_hierarchy/*.res") files += glob.glob(REAL_PATH + "data/hull-LLZO/*LLZO*.res") cursor = [res2dict(f)[0] for f in files] cursor = sorted(cursor, key=lambda x: x["enthalpy_per_atom"])[0:10] uniq_inds, _, _, _ = get_uniq_cursor(cursor, sim_tol=0.1, energy_tol=1e20, projected=True, **{ "dr": 0.01, "gaussian_width": 0.1 }) filtered_cursor = [cursor[ind] for ind in uniq_inds] self.assertEqual(len(uniq_inds), 3) self.assertEqual(len(filtered_cursor), 3) print([doc["source"] for doc in filtered_cursor]) self.assertTrue( "cubic-LLZO-CollCode999999" in filtered_cursor[0]["source"][0]) self.assertTrue("KP-NaP-OQMD_2817-CollCode14009" in filtered_cursor[1] ["source"][0]) self.assertTrue( "KP-NaP-CollCode421420" in filtered_cursor[2]["source"][0])
def _scrape_prototypes(self, file_lists, root): """ Scrape prototype data, i.e. structures with no DFT data, and push to database. Parameters: file_lists (dict): filenames and filetype counts stored by directory name key. root (str): directory name to scrape. Returns: int: number of successfully structures imported to database. """ import_count = 0 for _, file in enumerate(file_lists[root]['res']): res_dict, success = res2dict(file, db=False, verbosity=self.verbosity, noglob=True) if not success: self.logfile.write('! {}'.format(res_dict)) else: final_struct = res_dict if not self.dryrun: final_struct.update(self.tag_dict) import_count += self._struct2db(final_struct) return import_count
def test_k3p_uniq_default(self): cursor, _ = res2dict(REAL_PATH + "data/K3P_uniq/*.res") cursor = sorted(cursor, key=lambda x: x["enthalpy_per_atom"]) uniq_inds, _, _, _ = get_uniq_cursor(cursor) filtered_cursor = [cursor[ind] for ind in uniq_inds] self.assertEqual(len(cursor), 10) self.assertEqual(len(filtered_cursor), 5) found = [] correct_structures = [ "K3P-OQMD_4786-CollCode25550", "K3P-mode-follow-swap-Na3N-OQMD_21100-CollCode165992", "KP-fvsqdf", "PK-NNa3-OQMD_21100-CollCode165992", "KP-yzcni8", ] for struct in correct_structures: for doc in filtered_cursor: if struct in doc["source"][0]: found.append(True) break else: found.append(False) if not all(found): print([doc["source"][0] for doc in filtered_cursor]) self.assertTrue(all(found))
def test_binary_voltage_mayo(self): """ Test binary voltages from cursor for Mayo et al, DOI: 10.1021/acs.chemmater.5b04208. """ res_list = glob(REAL_PATH + "data/hull-LiP-mdm_chem_mater/*.res") cursor = [res2dict(res)[0] for res in res_list] hull = QueryConvexHull(cursor=cursor, elements=["Li", "P"], no_plot=True, voltage=True) for profile in hull.voltage_data: self.assertEqual(len(profile.voltages), len(profile.capacities)) LiP_voltage_curve = np.loadtxt(REAL_PATH + "data/LiP_voltage.csv", delimiter=",") self.assertTrue(len(hull.voltage_data) == 1) np.testing.assert_allclose( hull.voltage_data[0].voltages, LiP_voltage_curve[:, 1], verbose=True, rtol=1e-4, ) np.testing.assert_allclose(hull.voltage_data[0].capacities, LiP_voltage_curve[:, 0], verbose=True, rtol=1e-4) self._check_voltages_match_capacities(hull.voltage_data)
def test_ternary_voltage_with_single_phase_region(self): """ Test ternary voltages with single-phase regions. """ # load old hull then rejig it to go through a ternary phase cursor = res2dict(REAL_PATH + "data/hull-LiSiP/*.res")[0] hull = QueryConvexHull(cursor=cursor, species="LiSiP", no_plot=True, voltage=True) np.testing.assert_array_almost_equal( np.asarray(hull.voltage_data[0].voltages), np.asarray([ 1.1683, 1.1683, 1.0759, 0.7983, 0.6447, 0.3726, 0.3394, 0.1995, 0.1570, 0.1113, 0.1041, 0.0000, ]), decimal=3, ) self.assertEqual(len(hull.voltage_data[0].capacities), 12) self.assertEqual(len(hull.voltage_data[1].capacities), 11) self._check_voltages_match_capacities(hull.voltage_data)
def test_concurrent_pdf(self): import glob import numpy as np import time from copy import deepcopy files = glob.glob(REAL_PATH + "data/hull-KPSn-KP/*.res")[0:24] cursor = [res2dict(file, db=False)[0] for file in files] serial_cursor = deepcopy(cursor) pdf_args = { "dr": 0.1, "num_images": "auto", "gaussian_width": 0.1, "lazy": False, "projected": False, } start = time.time() pdf_factory = PDFFactory(cursor, **pdf_args) factory_elapsed = time.time() - start start = time.time() for doc in serial_cursor: doc["pdf"] = PDF(doc, **pdf_args, timing=False) serial_elapsed = time.time() - start print("{:.2f} s over {} processes vs {:.2f} s in serial".format( factory_elapsed, pdf_factory.nprocs, serial_elapsed)) print("Corresponding to a speedup of {:.1f} vs ideal {:.1f}".format( serial_elapsed / factory_elapsed, pdf_factory.nprocs)) for ind, doc in enumerate(serial_cursor): np.testing.assert_array_almost_equal(doc["pdf"].gr, cursor[ind]["pdf"].gr, decimal=6)
def test_ternary_voltage_with_exclusively_two_phase_regions(self): """ Test ternary voltages exclusively awkward two-phase regions. """ # load old hull then rejig it to go through a ternary phase res_list = glob(REAL_PATH + "data/hull-KPSn-KP/*.res") self.assertEqual( len(res_list), 87, "Could not find test res files, please check installation...", ) cursor = [res2dict(res)[0] for res in res_list] cursor = [ doc for doc in cursor if (doc["stoichiometry"] == [["P", 1], ["Sn", 1]] or doc["stoichiometry"] == [["K", 1], ["P", 1], ["Sn", 1]] or doc["stoichiometry"] == [["P", 1]] or doc["stoichiometry"] == [["K", 1]] or doc["stoichiometry"] == [["Sn", 1]]) ] hull = QueryConvexHull( cursor=cursor, elements=["K", "Sn", "P"], no_plot=True, pathways=True, voltage=True, ) self.assertEqual(len(hull.voltage_data), 1) self._check_voltages_match_capacities(hull.voltage_data)
def test_spg_standardize(self): from matador.utils.cell_utils import standardize_doc_cell from matador.scrapers import cif2dict import glob doc, s = castep2dict(REAL_PATH + "data/Na3Zn4-swap-ReOs-OQMD_759599.castep") std_doc = standardize_doc_cell(doc) dist = pdf_sim_dist(doc, std_doc) self.assertLess(dist, 0.01) fnames = glob.glob(REAL_PATH + "data/bs_test/*.res") for fname in fnames: doc, s = res2dict(fname, db=False) doc["cell_volume"] = cart2volume(doc["lattice_cart"]) std_doc = standardize_doc_cell(doc) dist = pdf_sim_dist(doc, std_doc) self.assertLess(dist, 0.01) doc = Crystal( castep2dict(REAL_PATH + "data/Na3Zn4-swap-ReOs-OQMD_759599.castep")[0]) std_doc = standardize_doc_cell(doc) dist = pdf_sim_dist(doc, std_doc) self.assertLess(dist, 0.01) doc = Crystal(cif2dict(REAL_PATH + "data/cif_files/AgBiI.cif")[0]) with self.assertRaises(RuntimeError): std_doc = standardize_doc_cell(doc)
def test_ternary_hull_distances(self): """ Test computing ternary hull distances. """ res_list = glob(REAL_PATH + "data/hull-KPSn-KP/*.res") self.assertEqual( len(res_list), 87, "Could not find test res files, please check installation...", ) cursor = [res2dict(res)[0] for res in res_list] hull = QueryConvexHull(cursor=cursor, elements=["K", "Sn", "P"], no_plot=True) self.assertEqual(len(hull.hull_cursor), 16) self.assertEqual(len(hull.cursor), 87) for ind, doc in enumerate(hull.cursor): hull.cursor[ind]["filename"] = doc["source"][0].split("/")[-1] structures = np.loadtxt(REAL_PATH + "data/test_KSnP.dat") hull_dist_test = np.loadtxt(REAL_PATH + "data/test_KSnP_hull_dist.dat") precomp_hull_dist = hull.get_hull_distances(structures, precompute=True) no_precomp_hull_dist = hull.get_hull_distances(structures, precompute=False) np.testing.assert_array_almost_equal(np.sort(hull_dist_test), np.sort(hull.hull_dist), decimal=3) np.testing.assert_array_almost_equal(np.sort(hull.hull_dist), np.sort(precomp_hull_dist), decimal=3) np.testing.assert_array_almost_equal(no_precomp_hull_dist, precomp_hull_dist, decimal=5) self.assertFalse(np.isnan(hull.hull_dist).any())
def test_pseudoternary_hull(self): cursor, s = res2dict(REAL_PATH + "data/hull-LLZO/*.res") print() print(80 * "-") self.assertEqual( len(cursor), 12, "Error with test res files, please check installation...") hull = QueryConvexHull(cursor=cursor, elements=["La2O3", "ZrO2", "Li2O"], no_plot=True) self.assertEqual(len(hull.cursor), 7) self.assertEqual(len(hull.hull_cursor), 5) hull = QueryConvexHull( cursor=cursor, elements=["La2O3", "ZrO2", "Li2O"], hull_cutoff=0.01, no_plot=True, ) self.assertEqual(len(hull.cursor), 7) self.assertEqual(len(hull.hull_cursor), 6) self.assertEqual(len(hull.convex_hull.vertices), 5) for doc in hull.hull_cursor: if "cubic-LLZO" in doc["source"][0]: self.assertAlmostEqual(doc["formation_enthalpy_per_atom"], -0.05758265622) self.assertAlmostEqual(doc["hull_distance"], 0.008746875) break else: raise RuntimeError("Did not find cubic-LLZO in cursor")
def test_hull_from_file_with_extraneous_elements(self): """ Loading hull structures from files with too many elements. """ res_list = glob(REAL_PATH + "data/hull-KPSn-KP/*.res") cursor = [res2dict(res)[0] for res in res_list] hull = QueryConvexHull(cursor=cursor, elements=["K", "Sn"], no_plot=True, debug=True) self.assertEqual(len(hull.hull_cursor), 5)
def test_pseudoternary_hull_failure(self): cursor, s = res2dict(REAL_PATH + "data/hull-LLZO/*.res") print() print(80 * "-") self.assertEqual( len(cursor), 12, "Error with test res files, please check installation...") with self.assertRaises(RuntimeError): QueryConvexHull(cursor=cursor, no_plot=True)
def main(): """ Run GA. """ from glob import glob from sys import argv from matador.hull import QueryConvexHull from matador.fingerprints.similarity import get_uniq_cursor from matador.utils.chem_utils import get_formula_from_stoich from matador.scrapers.castep_scrapers import res2dict from ilustrado.ilustrado import ArtificialSelector cursor = [res2dict(res)[0] for res in glob('seed/*.res')] hull = QueryConvexHull(cursor=cursor, no_plot=True, kpoint_tolerance=0.03, summary=True, hull_cutoff=1e-1) print('Filtering down to only ternary phases... {}'.format( len(hull.hull_cursor))) hull.hull_cursor = [ doc for doc in hull.hull_cursor if len(doc['stoichiometry']) == 3 ] print('Filtering unique structures... {}'.format(len(hull.hull_cursor))) # uniq_list, _, _, _ = list(get_uniq_cursor(hull.hull_cursor[1:-1], debug=False)) # cursor = [hull.hull_cursor[1:-1][ind] for ind in uniq_list] cursor = hull.hull_cursor print('Final cursor length... {}'.format(len(cursor))) print('over {} stoichiometries...'.format( len( set([ get_formula_from_stoich(doc['stoichiometry']) for doc in cursor ])))) print([doc['stoichiometry'] for doc in cursor]) def filter_fn(doc): """ Filter out any non-ternary phases. """ return True if len(doc['stoichiometry']) == 3 else False ArtificialSelector(gene_pool=cursor, seed='KPSn', compute_mode='slurm', entrypoint=__file__, walltime_hrs=12, slurm_template='template.slurm', max_num_nodes=100, hull=hull, check_dupes=0, structure_filter=filter_fn, best_from_stoich=True, max_num_mutations=3, max_num_atoms=50, mutation_rate=0.4, crossover_rate=0.6, num_generations=20, population=30, num_survivors=20, elitism=0.5, loglevel='debug')
def test_pdf_from_projected(self): doc, success = res2dict(REAL_PATH + "data/LiPZn-r57des.res") doc["lattice_cart"] = abc2cart(doc["lattice_abc"]) doc["text_id"] = ["unprojected", "test"] doc["pdf_unprojected"] = PDF(doc, dr=0.01, **{"debug": False}) doc["text_id"] = ["projected", "test"] doc["pdf_projected"] = PDF(doc, dr=0.01, **{"debug": False}) np.testing.assert_array_almost_equal(doc["pdf_unprojected"].gr, doc["pdf_projected"].gr)
def test_with_skips(self): from matador.crystal import Crystal from matador.utils.cursor_utils import filter_unique_structures import glob files = glob.glob(REAL_PATH + "data/uniqueness_hierarchy/*.res") cursor = [Crystal(res2dict(f)[0]) for f in files] filtered_cursor = filter_unique_structures(cursor, energy_tol=0) self.assertEqual(len(filtered_cursor), len(cursor)) cursor = sorted([res2dict(f)[0] for f in files], key=lambda doc: doc["enthalpy_per_atom"])[0:10] for ind, doc in enumerate(cursor): doc["enthalpy_per_atom"] = float(-ind) cursor[8]["enthalpy_per_atom"] = -5.0 cursor[9]["enthalpy_per_atom"] = -5.0001 filtered_cursor = filter_unique_structures(cursor, energy_tol=0.003) self.assertEqual(len(filtered_cursor), 8)
def test_binary_volume_curve(self): """ Test simple binary volume curve. """ res_list = glob(REAL_PATH + "data/hull-LiP-mdm_chem_mater/*.res") cursor = [res2dict(res)[0] for res in res_list] hull = QueryConvexHull(cursor=cursor, elements=["Li", "P"], no_plot=True) hull.volume_curve() self.assertEqual(len(hull.volume_data["x"][0]), len(hull.hull_cursor) - 1) self.assertEqual(len(hull.volume_data["electrode_volume"][0]), len(hull.hull_cursor) - 1)
def swaps(): """ Run swaps, returning data to be checked. """ sys.argv = [ "matador", "swaps", "--db", DB_NAME, "--res", "--cell", "-c", "NaPZn", "-int", "-sw", "NaLi:PSi:ZnSn", ] if CONFIG_FNAME is not None: sys.argv += ["--config", CONFIG_FNAME] matador.cli.cli.main() expected_dir = "swaps-NaPZn-ci_test-NaLi:PSi:ZnSn" output_folder_exists = os.path.isdir(expected_dir) successes = [] elem_successes = [] if output_folder_exists: os.chdir(expected_dir) expected_files = [ "Li3Si2-swap-NaP_intermediates", "Li3Sn4-swap-Na3Zn4-ReOs-OQMD_759599", "Li-swap-Na-edgecase-CollCode10101", ] target_elems = ["Li", "Si", "Sn"] for files in expected_files: cell, s = cell2dict(files, db=False, positions=True) successes.append(s) if s: elems = set(cell["atom_types"]) elem_successes.append( any([elem not in target_elems for elem in elems])) else: elem_successes.append(False) res, s = res2dict(files, db=False) successes.append(s) if s: elems = set(res["atom_types"]) elem_successes.append( any([elem not in target_elems for elem in elems])) else: elem_successes.append(False) os.chdir(OUTPUT_DIR) return output_folder_exists, successes, elem_successes
def test_hull_from_file(self): """ Loading hull structures from files. """ res_list = glob(REAL_PATH + "data/hull-KPSn-KP/*.res") self.assertEqual( len(res_list), 87, "Could not find test res files, please check installation...", ) cursor = [res2dict(res)[0] for res in res_list] hull = QueryConvexHull(cursor=cursor, elements=["K", "Sn", "P"], no_plot=True) self.assertEqual(len(hull.hull_cursor), 16)
def test_slice(self): parents = [ res2dict(REAL_PATH + "/query-K3P-KP/KP-NaP-CollCode182164.res")[0], res2dict(REAL_PATH + "/query-K6P-KP/KP-GA-uynlzz-17x7.res")[0], ] doc2res(parents[0], "parent1", hash_dupe=False, info=False) doc2res(parents[1], "parent2", hash_dupe=False, info=False) _iter = 0 while _iter < 100: child = random_slice( parents, standardize=True, supercell=True, shift=True, debug=True ) feasible = check_feasible(child, parents, max_num_atoms=50) _iter += 1 if feasible: doc2res(child, "feasible", hash_dupe=True, info=False) else: doc2res(child, "failed", hash_dupe=True, info=False) parents[1] = create_simple_supercell(parents[1], [3, 1, 1]) doc2res(parents[1], "supercell2", hash_dupe=False, info=False)
def test_identity_overlap(self): doc, success = res2dict(REAL_PATH + "data/LiPZn-r57des.res") doc["lattice_cart"] = abc2cart(doc["lattice_abc"]) doc["text_id"] = ["pdf", "test"] doc["pdf_smear"] = PDF( doc, num_images=3, dr=0.001, gaussian_width=0.1, style="smear", debug=False, low_mem=True, ) overlap = PDFOverlap(doc["pdf_smear"], doc["pdf_smear"]) self.assertEqual(overlap.similarity_distance, 0.0)
def test_convert_positions(self): doc = res2dict(REAL_PATH + "data/structures/Li7Sn-Fmmm.res")[0] crystal = res2dict(REAL_PATH + "data/structures/Li7Sn-Fmmm.res", as_model=True)[0] doc["positions_abs"] = frac2cart(doc["lattice_cart"], doc["positions_frac"]) np.testing.assert_array_almost_equal(doc["positions_abs"], crystal.positions_abs) for ind, site in enumerate(crystal): np.testing.assert_array_almost_equal(doc["positions_abs"][ind], site.coords_cartesian) crystal.cell.lengths = np.asarray(crystal.cell.lengths) * 10 rescaled_pos = frac2cart( np.asarray(doc["lattice_cart"]) * 10, doc["positions_frac"]) for ind, site in enumerate(crystal): np.testing.assert_array_almost_equal(doc["positions_frac"][ind], site.coords) np.testing.assert_array_almost_equal(rescaled_pos[ind], site.coords_cartesian)
def test_uniq_filter_with_hierarchy_2(self): cursor, f_ = res2dict(REAL_PATH + "data/hull-LLZO/*LLZO*.res") cursor = sorted(cursor, key=lambda x: x["enthalpy_per_atom"])[0:10] uniq_inds, _, _, _ = get_uniq_cursor(cursor, sim_tol=0.1, energy_tol=1e10, projected=True, **{ "dr": 0.01, "gaussian_width": 0.1 }) filtered_cursor = [cursor[ind] for ind in uniq_inds] self.assertEqual(len(uniq_inds), 1) self.assertEqual(len(filtered_cursor), 1) self.assertTrue( "cubic-LLZO-CollCode999999" in filtered_cursor[0]["source"][0])
def test_no_overlap_retains_all_structures(self): import glob files = glob.glob(REAL_PATH + "data/uniqueness_hierarchy/*.res") cursor = [res2dict(f)[0] for f in files] uniq_inds, _, _, _ = get_uniq_cursor(cursor, sim_tol=0, energy_tol=1e20, projected=True, debug=True, **{ "dr": 0.1, "gaussian_width": 0.1 }) filtered_cursor = [cursor[ind] for ind in uniq_inds] self.assertEqual(len(filtered_cursor), len(cursor))
def test_ternary_voltage_problematic_with_crystal_models(self): """ Test for NaSnP voltages which triggered a bug in the capacity calculation. """ cursor = res2dict(REAL_PATH + "data/voltage_data/voltage-NaSnP/*.res", as_model=True)[0] hull = QueryConvexHull(cursor=cursor, species="NaSnP", no_plot=True, voltage=True, volume=True) self._check_voltages_match_capacities(hull.voltage_data) self.assertEqual(len(hull.voltage_data), 2) self.assertEqual(len(hull.voltage_data[0].capacities), 13) self.assertEqual(len(hull.voltage_data[1].capacities), 12)
def _match_peaks(res_file, gsas_reflections, **kwargs): """ Check if peaks match with HKL between matador and GSAS. """ doc, s = res2dict(res_file, as_model=True) pxrd = PXRD(doc, **kwargs) gsas_peaks = np.loadtxt(gsas_reflections) hkl_array = {} for peak in gsas_peaks: hkl_array[(int(peak[0]), int(peak[1]), int(peak[2]))] = peak[3] for ind, hkl in enumerate(pxrd.hkls): hkl_tuple = (int(hkl[0]), int(hkl[1]), int(hkl[2])) if hkl_tuple in hkl_array: assert (np.abs(hkl_array[hkl_tuple] - pxrd.peak_positions[ind]) < PEAK_POS_TOL) return pxrd