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_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_cart2abc(self): castep_fname = REAL_PATH + "data/Na3Zn4-swap-ReOs-OQMD_759599.castep" self.assertTrue(os.path.isfile(castep_fname)) test_doc, s = castep2dict(castep_fname, db=True, verbosity=VERBOSITY) try: self.assertTrue( np.allclose(test_doc["lattice_abc"], cart2abc(test_doc["lattice_cart"])), msg="Conversion cart2abc failed.", ) self.assertTrue( np.allclose( cart2abc(test_doc["lattice_cart"]), cart2abc(abc2cart(test_doc["lattice_abc"])), ), msg="Conversion abc2cart failed.", ) self.assertAlmostEqual( test_doc["cell_volume"], cart2volume(test_doc["lattice_cart"]), msg="Failed to calculate volume from lattice vectors.", places=5, ) self.assertIsInstance(test_doc["lattice_abc"], list, msg="Failed abc numpy cast to list") self.assertIsInstance( test_doc["lattice_cart"], list, msg="Failed cartesian numpy cast to list", ) cart_pos = frac2cart(test_doc["lattice_cart"], test_doc["positions_frac"]) back2frac = cart2frac(test_doc["lattice_cart"], cart_pos) np.testing.assert_array_almost_equal(back2frac, test_doc["positions_frac"]) except AssertionError: print("cart:", test_doc["lattice_cart"], abc2cart(test_doc["lattice_abc"])) print("abc:", test_doc["lattice_abc"], cart2abc(test_doc["lattice_cart"])) print( "volume:", test_doc["cell_volume"], cart2volume(test_doc["lattice_cart"]), ) raise AssertionError
def pwout2dict(fname, **kwargs): """ Extract available information from pw.x .out file. Parameters: fname (str/list): filename or list of filenames to scrape as a QuantumEspresso pw.x output. """ flines, fname = get_flines_extension_agnostic(fname, ["out", "in"]) pwout = {} pwout['source'] = [fname] try: # grab file owner username from pwd import getpwuid pwout['user'] = getpwuid(stat(fname).st_uid).pw_name except Exception: pwout['user'] = '******' if 'CollCode' in fname: pwout['icsd'] = fname.split('CollCode')[-1] for ind, line in enumerate(reversed(flines)): ind = len(flines) - 1 - ind if 'cell_parameters' in line.lower() and 'angstrom' in line.lower( ) and 'lattice_cart' not in pwout: pwout['lattice_cart'] = [] for j in range(3): line = flines[ind + j + 1].strip().split() pwout['lattice_cart'].append(list(map(float, line))) pwout['cell_volume'] = cart2volume(pwout['lattice_cart']) elif 'atomic_positions' in line.lower( ) and 'positions_frac' not in pwout: pwout['positions_frac'] = [] pwout['atom_types'] = [] j = 1 while True: if 'End final coordinates' in flines[j + ind]: break else: try: line = flines[j + ind].strip().split() pwout['atom_types'].append(line[0]) pwout['positions_frac'].append( list(map(float, line[1:5]))) j += 1 except Exception: break pwout['num_atoms'] = len(pwout['atom_types']) elif 'final enthalpy' in line.lower() and 'enthalpy' not in pwout: pwout['enthalpy'] = RY_TO_EV * float(line.lower().split()[-2]) elif 'total stress' in line.lower() and 'pressure' not in pwout: pwout['pressure'] = KBAR_TO_GPA * float(line.lower().split()[-1]) elif all(key in pwout for key in ['enthalpy', 'pressure', 'lattice_cart', 'positions_frac']): break # get abc lattice pwout['lattice_abc'] = cart2abc(pwout['lattice_cart']) # calculate stoichiometry pwout['stoichiometry'] = defaultdict(float) for atom in pwout['atom_types']: if atom not in pwout['stoichiometry']: pwout['stoichiometry'][atom] = 0 pwout['stoichiometry'][atom] += 1 gcd_val = 0 for atom in pwout['atom_types']: if gcd_val == 0: gcd_val = pwout['stoichiometry'][atom] else: gcd_val = gcd(pwout['stoichiometry'][atom], gcd_val) # convert stoichiometry to tuple for fryan temp_stoich = [] for key, value in pwout['stoichiometry'].items(): if float(value) / gcd_val % 1 != 0: temp_stoich.append([key, float(value) / gcd_val]) else: temp_stoich.append([key, value / gcd_val]) pwout['stoichiometry'] = temp_stoich atoms_per_fu = 0 for elem in pwout['stoichiometry']: atoms_per_fu += elem[1] pwout['num_fu'] = len(pwout['atom_types']) / atoms_per_fu return pwout, True
def cif2dict(fname, **kwargs): """ Extract available information from .cif file and store as a dictionary. Raw cif data is stored under the `'_cif'` key. Symmetric sites are expanded by the symmetry operations and their occupancies are tracked. Parameters: fname (str/list): filename or list of filenames of .cif file(s) (with or without extension). Returns: (dict/str, bool): if successful, a dictionary containing scraped data and True, if not, then an error string and False. """ flines, fname = get_flines_extension_agnostic(fname, "cif") doc = dict() cif_dict = _cif_parse_raw(flines) doc['_cif'] = cif_dict doc['source'] = [str(Path(fname).resolve())] doc['atom_types'] = [] atom_labels = cif_dict.get("_atom_site_type_symbol", False) if not atom_labels: atom_labels = cif_dict.get("_atom_site_label", False) if not atom_labels: raise RuntimeError(f"Unable to find atom types in cif file {fname}.") for atom in atom_labels: symbol = '' for character in atom: if not character.isalpha(): break else: symbol += character doc['atom_types'].append(symbol) doc['positions_frac'] = [list(map(lambda x: float(x.split('(')[0]), vector)) for vector in zip(cif_dict['_atom_site_fract_x'], cif_dict['_atom_site_fract_y'], cif_dict['_atom_site_fract_z'])] if '_atom_site_occupancy' in cif_dict: doc['site_occupancy'] = [float(x.split('(')[0]) for x in cif_dict['_atom_site_occupancy']] else: doc['site_occupancy'] = [1.0 for _ in doc['positions_frac']] if '_atom_site_symmetry_multiplicity' in cif_dict: doc['site_multiplicity'] = [float(x.split('(')[0]) for x in cif_dict['_atom_site_symmetry_multiplicity']] else: doc['site_multiplicity'] = [1.0 for _ in doc['positions_frac']] doc['lattice_abc'] = [list(map(_cif_parse_float_with_errors, [cif_dict['_cell_length_a'], cif_dict['_cell_length_b'], cif_dict['_cell_length_c']])), list(map(_cif_parse_float_with_errors, [cif_dict['_cell_angle_alpha'], cif_dict['_cell_angle_beta'], cif_dict['_cell_angle_gamma']]))] doc['lattice_cart'] = abc2cart(doc['lattice_abc']) doc['cell_volume'] = cart2volume(doc['lattice_cart']) doc['stoichiometry'] = _cif_disordered_stoichiometry(doc) doc['num_atoms'] = len(doc['positions_frac']) if '_space_group_symop_operation_xyz' in doc['_cif'] and '_symmetry_equiv_pos_as_xyz' not in doc['_cif']: doc["_cif"]["_symmetry_equiv_pos_as_xyz"] = doc["_cif"]["_space_group_symop_operation_xyz"] if '_symmetry_equiv_pos_as_xyz' in doc['_cif']: _cif_set_unreduced_sites(doc) try: doc['space_group'] = get_spacegroup_spg(doc, check_occ=False) except RuntimeError: pass return doc, True
def construct_structure_attributes(self, doc: Crystal): structure_attributes = {} # from optimade StructureResourceAttributes structure_attributes["elements"] = doc.elems structure_attributes["nelements"] = len(doc.elems) concentration = get_concentration(doc._data, elements=doc.elems, include_end=True) structure_attributes["elements_ratios"] = concentration structure_attributes["chemical_formula_descriptive"] = doc.formula structure_attributes["chemical_formula_reduced"] = doc.formula structure_attributes["chemical_formula_hill"] = None sorted_stoich = sorted(doc.stoichiometry, key=lambda x: x[1], reverse=True) gen = anonymous_element_generator() for ind, elem in enumerate(sorted_stoich): elem[0] = next(gen) structure_attributes[ "chemical_formula_anonymous"] = get_formula_from_stoich( doc.stoichiometry, elements=[elem[0] for elem in sorted_stoich]) structure_attributes["dimension_types"] = [1, 1, 1] structure_attributes["nperiodic_dimensions"] = 3 structure_attributes["lattice_vectors"] = doc.lattice_cart structure_attributes["lattice_abc"] = doc.lattice_abc structure_attributes["cell_volume"] = cart2volume(doc.lattice_cart) structure_attributes["fractional_site_positions"] = doc.positions_frac structure_attributes["cartesian_site_positions"] = doc.positions_abs structure_attributes["nsites"] = doc.num_atoms structure_attributes["species_at_sites"] = doc.atom_types species = [] for ind, atom in enumerate(doc.elems): species.append( Species(name=atom, chemical_symbols=[atom], concentration=[1.0])) structure_attributes["species"] = species structure_attributes["assemblies"] = None structure_attributes["structure_features"] = [] # from optimade EntryResourceAttributes if "text_id" not in doc._data: structure_attributes["local_id"] = " ".join([ self.wlines[random.randint(0, self.num_words - 1)].strip(), self.nlines[random.randint(0, self.num_nouns - 1)].strip(), ]) else: structure_attributes["local_id"] = " ".join(doc._data["text_id"]) structure_attributes["last_modified"] = datetime.datetime.now() if "_id" in doc._data: structure_attributes["immutable_id"] = str(doc._data["_id"]) else: structure_attributes["immutable_id"] = str( bson.objectid.ObjectId()) # if "date" in doc._data: # date = [int(val) for val in doc._data["date"].split("-")] # structure_attributes["date"] = datetime.date( # year=date[-1], month=date[1], day=date[0] # ) # from matador extensions structure_attributes[ "dft_parameters"] = self.construct_dft_hamiltonian(doc) structure_attributes["submitter"] = self.construct_submitter(doc) structure_attributes["thermodynamics"] = self.construct_thermodynamics( doc) structure_attributes["space_group"] = self.construct_spacegroup(doc) structure_attributes["calculator"] = self.construct_calculator(doc) structure_attributes["stress_tensor"] = doc._data.get("stress") structure_attributes["stress"] = doc._data["pressure"] structure_attributes["forces"] = doc._data.get("forces") structure_attributes["max_force_on_atom"] = doc._data.get( "max_force_on_atom") return MatadorStructureResourceAttributes(**structure_attributes)
def random_slice(parent_seeds, standardize=True, supercell=True, shift=True, debug=False): """ Simple cut-and-splice crossover of two parents. The overall size of the child can vary between 0.5 and 1.5 the size of the parent structures. Both parent structures are cut and spliced along the same crystallographic axis. Parameters: parents (list(dict)) : parent structures to crossover, standardize (bool) : use spglib to standardize parents pre-crossover, supercell (bool) : make a random supercell to rescale parents, shift (bool) : randomly shift atoms in parents to unbias. Returns: dict: newborn structure from parents. """ parents = deepcopy(parent_seeds) child = dict() # child_size is a number between 0.5 and 2 child_size = 0.5 + 1.5 * np.random.rand() # cut_val is a number between 0.25*child_size and 0.75*child_size # the slice position of one parent in fractional coordinates # (the other is (child_size-cut_val)) cut_val = child_size * (0.25 + (np.random.rand() / 2.0)) parent_densities = [] for ind, parent in enumerate(parents): if "cell_volume" not in parent: parents[ind]["cell_volume"] = cart2volume(parent["lattice_cart"]) parent_densities.append(parent["num_atoms"] / parent["cell_volume"]) target_density = sum(parent_densities) / len(parent_densities) if standardize: parents = [standardize_doc_cell(parent) for parent in parents] if supercell: # check ratio of num atoms in parents and grow the smaller one parent_extent_ratio = parents[0]["cell_volume"] / parents[1][ "cell_volume"] if debug: print( parent_extent_ratio, parents[0]["cell_volume"], "vs", parents[1]["cell_volume"], ) if parent_extent_ratio < 1: supercell_factor = int(round(1 / parent_extent_ratio)) supercell_target = 0 elif parent_extent_ratio >= 1: supercell_factor = int(round(parent_extent_ratio)) supercell_target = 1 if debug: print(supercell_target, supercell_factor) supercell_vector = [1, 1, 1] if supercell_factor > 1: for ind in range(supercell_factor): min_lat_vec_abs = 1e10 min_lat_vec_ind = -1 for i in range(3): lat_vec_abs = np.sum( np.asarray( parents[supercell_target]["lattice_cart"][i])**2) if lat_vec_abs < min_lat_vec_abs: min_lat_vec_abs = lat_vec_abs min_lat_vec_ind = i supercell_vector[min_lat_vec_ind] += 1 if debug: print("Making supercell of {} with {}".format( parents[supercell_target]["source"][0], supercell_vector)) if supercell_vector != [1, 1, 1]: parents[supercell_target] = create_simple_supercell( parents[supercell_target], supercell_vector, standardize=False) child["positions_frac"] = [] child["atom_types"] = [] child["lattice_cart"] = cut_val * np.asarray( parents[0]["lattice_cart"]) + (child_size - cut_val) * np.asarray( parents[1]["lattice_cart"]) child["lattice_cart"] = child["lattice_cart"].tolist() # choose slice axis axis = np.random.randint(low=0, high=3) for ind, parent in enumerate(parents): if shift: # apply same random shift to all atoms in parents shift_vec = np.random.rand(3) for idx, _ in enumerate(parent["positions_frac"]): for k in range(3): parent["positions_frac"][idx][k] += shift_vec[k] if parent["positions_frac"][idx][k] >= 1: parent["positions_frac"][idx][k] -= 1 elif parent["positions_frac"][idx][k] < 0: parent["positions_frac"][idx][k] += 1 # slice parent for atom, pos in zip(parent["atom_types"], parent["positions_frac"]): if ind == (pos[axis] <= cut_val): child["positions_frac"].append(pos) child["atom_types"].append(atom) # check child is sensible child["mutations"] = ["crossover"] child["stoichiometry"] = get_stoich(child["atom_types"]) child["num_atoms"] = len(child["atom_types"]) if "cell_volume" not in child: child["cell_volume"] = cart2volume(child["lattice_cart"]) number_density = child["num_atoms"] / child["cell_volume"] # rescale cell based on number density of parents new_scale = np.cbrt(number_density / target_density) child["lattice_abc"] = np.asarray(cart2abc(child["lattice_cart"])) child["lattice_abc"][0] *= new_scale child["lattice_abc"] = child["lattice_abc"].tolist() child["lattice_cart"] = abc2cart(child["lattice_abc"]) child["cell_volume"] = cart2volume(child["lattice_cart"]) child["positions_abs"] = frac2cart(child["lattice_cart"], child["positions_frac"]) return child
def check_feasible(mutant, parents, max_num_atoms, structure_filter=None, minsep_dict=None, debug=False): """ Check if a mutated/newly-born cell is "feasible". Here, feasible means: * number density within 25% of pre-mutation/birth level, * no overlapping atoms, parameterised by minsep_dict, * cell angles between 50 and 130 degrees, * fewer than max_num_atoms in the cell, * ensure number of atomic types is maintained, * any custom filter is obeyed. Parameters: mutant (dict): matador doc containing new structure. parents (list(dict)): list of doc(s) containing parent structures. max_num_atoms (int): any structures with more than this many atoms will be filtered out. Keyword Arguments: structure_filter (callable): any function that takes a matador document and returns True or False. minsep_dict (dict): dictionary containing element-specific minimum separations, e.g. {('K', 'K'): 2.5, ('K', 'P'): 2.0}. Returns: bool: True if structure is feasible, else False. """ # first check the structure filter if structure_filter is not None and not structure_filter(mutant): message = "Mutant with {} failed to pass the custom filter.".format( ", ".join(mutant["mutations"])) LOG.debug(message) if debug: print(message) return False # check number of atoms if "num_atoms" not in mutant or mutant["num_atoms"] != len( mutant["atom_types"]): mutant["num_atoms"] = len(mutant["atom_types"]) if mutant["num_atoms"] > max_num_atoms: message = "Mutant with {} contained too many atoms ({} vs {}).".format( ", ".join(mutant["mutations"]), mutant["num_atoms"], max_num_atoms) LOG.debug(message) if debug: print(message) return False # check number density if "cell_volume" not in mutant: mutant["cell_volume"] = cart2volume(mutant["lattice_cart"]) number_density = mutant["num_atoms"] / mutant["cell_volume"] parent_densities = [] for ind, parent in enumerate(parents): if "cell_volume" not in parent: parents[ind]["cell_volume"] = cart2volume(parent["lattice_cart"]) parent_densities.append(parent["num_atoms"] / parent["cell_volume"]) target_density = sum(parent_densities) / len(parent_densities) if number_density > 1.5 * target_density or number_density < 0.5 * target_density: message = "Mutant with {} failed number density.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False # now check element-agnostic minseps if not minseps_feasible(mutant, minsep_dict=minsep_dict, debug=debug): return False # check all cell angles are between 60 and 120. if "lattice_abc" not in mutant: mutant["lattice_abc"] = cart2abc(mutant["lattice_cart"]) if min(mutant["lattice_abc"][1]) < 30: message = "Mutant with {} failed cell angle check.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False if max(mutant["lattice_abc"][1]) > 120: message = "Mutant with {} failed cell angle check.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False # check that we haven't deleted/transmuted all atoms of a certain type if len(set(mutant["atom_types"])) < len(set(parents[0]["atom_types"])): message = "Mutant with {} transmutation error.".format(", ".join( mutant["mutations"])) LOG.debug(message) if debug: print(message) return False return True
def volume(self): """ The cell volume in ų. """ if not self._volume: self._volume = cell_utils.cart2volume(self._lattice_cart) return self._volume
def __init__(self, doc, lazy=False, **kwargs): """ Initialise parameters and run PDF (unless lazy=True). Parameters: doc (dict) : matador document to calculate PDF of Keyword Arguments: dr (float) : bin width for PDF (Angstrom) (DEFAULT: 0.01) gaussian_width (float) : width of Gaussian smearing (Angstrom) (DEFAULT: 0.01) num_images (int/str) : number of unit cell images include in PDF calculation (DEFAULT: 'auto') max_num_images (int) : cutoff number of unit cells before crashing (DEFAULT: 50) rmax (float) : maximum distance cutoff for PDF (Angstrom) (DEFAULT: 15) projected (bool) : optionally calculate the element-projected PDF standardize (bool) : standardize cell before calculating PDF lazy (bool) : if True, calculator is not called when initializing PDF object timing (bool) : if True, print the total time taken to calculate the PDF """ prop_defaults = { 'dr': 0.01, 'gaussian_width': 0.1, 'rmax': 15, 'num_images': 'auto', 'style': 'smear', 'debug': False, 'timing': False, 'low_mem': False, 'projected': True, 'max_num_images': 50, 'standardize': True } # read and store kwargs self.kwargs = prop_defaults self.kwargs.update( {key: kwargs[key] for key in kwargs if kwargs[key] is not None}) # useful data for labelling self.spg = None structure = copy.deepcopy(doc) if self.kwargs.get('standardize'): structure = standardize_doc_cell(structure) self.spg = structure['space_group'] self.stoichiometry = structure.get('stoichiometry', get_stoich(structure['atom_types'])) # private variables self._num_images = self.kwargs.get('num_images') self._lattice = np.asarray(structure['lattice_cart']) self._poscart = np.asarray( frac2cart(structure['lattice_cart'], structure['positions_frac'])).reshape(-1, 3) self._types = structure['atom_types'] self._num_atoms = len(self._poscart) self._volume = cart2volume(self._lattice) self._image_vec = None # public variables self.rmax = self.kwargs.get('rmax') self.number_density = self._num_atoms / self._volume self.dr = self.kwargs.get('dr') self.r_space = None self.gr = None self.elem_gr = None self.label = None if self.kwargs.get('label'): self.label = self.kwargs["label"] elif 'text_id' in structure: self.label = ' '.join(structure['text_id']) if not lazy: if self.kwargs.get('timing'): start = time.time() self.calc_pdf() if self.kwargs.get('timing'): end = time.time() print('PDF calculated in {:.3f} s'.format(end - start))
def test_kpt_path(self): cell, s = castep2dict(REAL_PATH + "data/Na3Zn4-swap-ReOs-OQMD_759599.castep") std_cell, path, seekpath_results = get_seekpath_kpoint_path( cell, spacing=0.01, debug=False) self.assertEqual(539, len(path)) self.assertLess(pdf_sim_dist(cell, std_cell), 0.05) import glob from os import remove from matador.utils.cell_utils import frac2cart fnames = glob.glob(REAL_PATH + "data/bs_test/*.res") spacing = 0.01 for fname in fnames: doc, s = res2dict(fname, db=False) doc["cell_volume"] = cart2volume(doc["lattice_cart"]) std_doc, path, seekpath_results = get_seekpath_kpoint_path( doc, spacing=spacing, debug=False) seekpath_results_path = get_path(doc2spg(doc)) rel_path = seekpath_results["explicit_kpoints_rel"] abs_path = seekpath_results["explicit_kpoints_abs"] cart_kpts = np.asarray( frac2cart(real2recip(std_doc["lattice_cart"]), path)) diffs = np.zeros((len(cart_kpts[:-1]))) np.testing.assert_array_almost_equal(cart_kpts, abs_path) np.testing.assert_array_almost_equal(path, rel_path) for ind, kpt in enumerate(cart_kpts[:-1]): diffs[ind] = np.sqrt(np.sum((kpt - cart_kpts[ind + 1])**2)) self.assertLess( len(np.where(diffs > 1.1 * spacing)[0]), len(seekpath_results["explicit_segments"]), ) if "flrys4-1x109" in fname: bs, s = bands2dict(fname.replace(".res", ".bands")) np.testing.assert_array_almost_equal(bs["kpoint_path"], rel_path) np.testing.assert_array_almost_equal(bs["lattice_cart"], std_doc["lattice_cart"]) self.assertLess( len(np.where(diffs > 1.1 * spacing)[0]), len(seekpath_results["explicit_segments"]), ) cell_path = fname.replace(".res", ".cell") doc2cell(std_doc, cell_path) new_doc, s = cell2dict(cell_path, lattice=True, positions=True, db=False) assert "positions_frac" in new_doc remove(cell_path) seekpath_new_results = get_path(doc2spg(new_doc)) self.assertEqual( seekpath_new_results["bravais_lattice_extended"], seekpath_results_path["bravais_lattice_extended"], ) dist = pdf_sim_dist(doc, std_doc) self.assertLess(dist, 0.01) dist = pdf_sim_dist(doc, new_doc) self.assertLess(dist, 0.01)