def test_make_calc_summary(mocker): defect_entry = mocker.Mock(spec=DefectEntry, autospec=True) defect_entry.name = "Va_O1" defect_entry.charge = 1 defect_entry.full_name = "Va_O1_1" calc_results = mocker.Mock(spec=CalcResults, autospec=True) calc_results.structure = \ IStructure(Lattice.cubic(1.0), ["Mg"], [[0.0]*3]) calc_results.energy = 10.0 + defaults.abs_strange_energy - 0.1 structure_info = mocker.Mock(spec=DefectStructureInfo, autospec=True) p_calc_results = mocker.Mock(spec=CalcResults, autospec=True) p_calc_results.structure = \ IStructure(Lattice.cubic(1.0), ["Mg", "O"], [[0.0]*3]*2) p_calc_results.energy = 10.0 actual = make_calc_summary(calc_set=[(calc_results, defect_entry, structure_info)], p_calc_results=p_calc_results) single_summary = SingleCalcSummary( charge=1, atom_io={"O": -1}, electronic_conv=calc_results.electronic_conv, ionic_conv=calc_results.ionic_conv, is_energy_strange=False, same_config_from_init=structure_info.same_config_from_init, defect_type=str(structure_info.defect_type), symm_relation=str(structure_info.symm_relation)) expected = CalcSummary({"Va_O1_1": single_summary}) assert actual == expected
def test_get_supercell_size(self): l = Lattice.cubic(1) l2 = Lattice.cubic(0.9) s1 = Structure(l, ['Mg', 'Cu', 'Ag', 'Cu', 'Ag'], [[0]*3]*5) s2 = Structure(l2, ['Cu', 'Cu', 'Ag'], [[0]*3]*3) sm = StructureMatcher(supercell_size='volume') self.assertEqual(sm._get_supercell_size(s1, s2), (1, True)) self.assertEqual(sm._get_supercell_size(s2, s1), (1, True)) sm = StructureMatcher(supercell_size='num_sites') self.assertEqual(sm._get_supercell_size(s1, s2), (2, False)) self.assertEqual(sm._get_supercell_size(s2, s1), (2, True)) sm = StructureMatcher(supercell_size='Ag') self.assertEqual(sm._get_supercell_size(s1, s2), (2, False)) self.assertEqual(sm._get_supercell_size(s2, s1), (2, True)) sm = StructureMatcher(supercell_size='wfieoh') self.assertRaises(ValueError, sm._get_supercell_size, s1, s2)
def test_judge_defect_type(): """The structures remain as they could be used in the future""" perfect = Structure(Lattice.cubic(10), species=["H"]*4, coords=[[0.0, 0.0, 0.0], [0.0, 0.5, 0.5], [0.5, 0.0, 0.5], [0.5, 0.5, 0.0]]) defect = Structure(Lattice.cubic(10), species=["H"]*3, coords=[[0.0, 0.0, 0.0], [0.25, 0.25, 0.5], [0.5, 0.5, 0.0]]) site_diff = SiteDiff(removed=[(1, "H", (0.0, 0.5, 0.5)), (2, "H", (0.5, 0.0, 0.5))], inserted=[(1, "H", (0.25, 0.25, 0.5))], removed_by_sub=[], inserted_by_sub=[]) assert judge_defect_type(site_diff) == DefectType.vacancy_split defect_2 = Structure(Lattice.cubic(10), species=["H"]*5, coords=[[0.0, 0.0, 0.0], [0.25, 0.25, 0.5], [0.75, 0.25, 0.5], [0.25, 0.75, 0.5], [0.5, 0.5, 0.0]]) site_diff_2 = SiteDiff(removed=[(1, "H", (0.0, 0.5, 0.5)), (2, "H", (0.5, 0.0, 0.5))], inserted=[(1, "H", (0.25, 0.25, 0.5)), (2, "H", (0.75, 0.25, 0.5)), (3, "H", (0.25, 0.75, 0.5))], removed_by_sub=[], inserted_by_sub=[]) assert judge_defect_type(site_diff_2) == DefectType.interstitial_split defect_3 = Structure(Lattice.cubic(10), species=["H", "He", "H"], coords=[[0.0, 0.0, 0.0], [0.25, 0.25, 0.5], [0.5, 0.5, 0.0]]) site_diff_3 = SiteDiff(removed=[(1, "H", (0.0, 0.5, 0.5)), (2, "H", (0.5, 0.0, 0.5))], inserted=[(1, "He", (0.25, 0.25, 0.5))], removed_by_sub=[], inserted_by_sub=[]) assert judge_defect_type(site_diff_3) == DefectType.unknown
def test_make_defect_entry(defect_entry): relaxed_coords = \ [[0.25, 0.0, 0.0], [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5], [0.0, 0.0, 0.51], [0.0, 0.51, 0.0], [0.5, 0.0, 0.0], [0.5, 0.5, 0.5]] relaxed_defect = IStructure(Lattice.cubic(10.0), ["Li"] + ["H"] * 3 + ["He"] * 4, relaxed_coords) unrelaxed_coords = \ [[0.25, 0.0, 0.0], [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5], [0.0, 0.0, 0.5], [0.0, 0.5, 0.0], [0.5, 0.0, 0.0], [0.5, 0.5, 0.5]] unrelaxed_defect = IStructure(Lattice.cubic(10.0), ["Li"] + ["H"] * 3 + ["He"] * 4, unrelaxed_coords) actual = make_defect_entry(name="Va_O1", charge=1, perfect_structure=perfect, defect_structure=relaxed_defect) expected = DefectEntry(name="Va_O1", charge=1, structure=unrelaxed_defect, perturbed_structure=None, site_symmetry="4mm", defect_center=(0.125, 0.0, 0.0)) assert actual == expected
def test_make_defect_energy_info(mocker): defect_entry = mocker.Mock(DefectEntry, autospec=True) defect_entry.name = "Va_Mg1" defect_entry.charge = -1 calc_results = mocker.Mock(CalcResults, autospec=True) calc_results.structure = IStructure(Lattice.cubic(1.0), ["O"], [[0.0]*3]) calc_results.energy = 10.0 calc_results.electronic_conv = False correction = mocker.Mock(Correction, autospec=True) correction.correction_dict = {"a": 10.0} p_calc_results = mocker.Mock(CalcResults, autospec=True) p_calc_results.structure = IStructure(Lattice.cubic(1.0), ["Mg", "O"], [[0.0]*3]*2) p_calc_results.energy = 1.0 standard_energies = StandardEnergies({"Mg": 10.0, "O": 20.0}) unitcell = mocker.Mock() unitcell.vbm = 100.0 actual = make_defect_energy_info(defect_entry, calc_results, correction, p_calc_results, standard_energies, unitcell) energy = DefectEnergy(formation_energy=10.0 - 1.0 + 10 - 100.0, energy_corrections={"a": 10.0}, is_shallow=None) expected = DefectEnergyInfo(name="Va_Mg1", charge=-1, atom_io={"Mg": -1}, defect_energy=energy) assert actual == expected
def structure_comparator(): cu2o_perfect = IStructure( Lattice.cubic(5), species=["Cu"] * 4 + ["O"] * 2, coords=[ [0.25, 0.25, 0.25], # removed [0.25, 0.74, 0.74], # removed [0.75, 0.75, 0.25], [0.75, 0.25, 0.75], [0, 0, 0], [0.5, 0.5, 0.5] ]) cu2o_defect = IStructure( Lattice.cubic(5), species=["Cu"] * 3 + ["O"] * 2 + ["H"], coords=[ [0.25, 0.5, 0.5], # inserted [0.76, 0.73, 0.24], [0.75, 0.25, 0.73], [0.05, 0.95, 0], [0.5, 0.5, 0.5], [0.25] * 3 ]) # inserted return DefectStructureComparator(defect_structure=cu2o_defect, perfect_structure=cu2o_perfect)
def get_unit_cell(specie, lattice, alat): """ Get the unit cell from specie, lattice type and lattice constant. Args specie (str): Name of specie. lattice (str): The lattice type of structure. e.g. bcc or diamond. alat (float): The lattice constant of specific lattice and specie. """ if lattice == "fcc": unit_cell = Structure.from_spacegroup(sg="Fm-3m", lattice=Lattice.cubic(alat), species=[specie], coords=[[0, 0, 0]]) elif lattice == "bcc": unit_cell = Structure.from_spacegroup(sg="Im-3m", lattice=Lattice.cubic(alat), species=[specie], coords=[[0, 0, 0]]) elif lattice == "diamond": unit_cell = Structure.from_spacegroup(sg="Fd-3m", lattice=Lattice.cubic(alat), species=[specie], coords=[[0, 0, 0]]) else: raise ValueError("Lattice type is invalid.") return unit_cell
def test_fit(self): """ Take two known matched structures 1) Ensure match 2) Ensure match after translation and rotations 3) Ensure no-match after large site translation 4) Ensure match after site shuffling """ sm = StructureMatcher() self.assertTrue(sm.fit(self.struct_list[0], self.struct_list[1])) # Test rotational/translational invariance op = SymmOp.from_axis_angle_and_translation([0, 0, 1], 30, False, np.array([0.4, 0.7, 0.9])) self.struct_list[1].apply_operation(op) self.assertTrue(sm.fit(self.struct_list[0], self.struct_list[1])) #Test failure under large atomic translation self.struct_list[1].translate_sites([0], [.4, .4, .2], frac_coords=True) self.assertFalse(sm.fit(self.struct_list[0], self.struct_list[1])) self.struct_list[1].translate_sites([0], [-.4, -.4, -.2], frac_coords=True) # random.shuffle(editor._sites) self.assertTrue(sm.fit(self.struct_list[0], self.struct_list[1])) #Test FrameworkComporator sm2 = StructureMatcher(comparator=FrameworkComparator()) lfp = self.get_structure("LiFePO4") nfp = self.get_structure("NaFePO4") self.assertTrue(sm2.fit(lfp, nfp)) self.assertFalse(sm.fit(lfp, nfp)) #Test anonymous fit. self.assertEqual(sm.fit_anonymous(lfp, nfp), True) self.assertAlmostEqual(sm.get_rms_anonymous(lfp, nfp)[0], 0.060895871160262717) #Test partial occupancies. s1 = Structure(Lattice.cubic(3), [{"Fe": 0.5}, {"Fe": 0.5}, {"Fe": 0.5}, {"Fe": 0.5}], [[0, 0, 0], [0.25, 0.25, 0.25], [0.5, 0.5, 0.5], [0.75, 0.75, 0.75]]) s2 = Structure(Lattice.cubic(3), [{"Fe": 0.25}, {"Fe": 0.5}, {"Fe": 0.5}, {"Fe": 0.75}], [[0, 0, 0], [0.25, 0.25, 0.25], [0.5, 0.5, 0.5], [0.75, 0.75, 0.75]]) self.assertFalse(sm.fit(s1, s2)) self.assertFalse(sm.fit(s2, s1)) s2 = Structure(Lattice.cubic(3), [{"Mn": 0.5}, {"Mn": 0.5}, {"Mn": 0.5}, {"Mn": 0.5}], [[0, 0, 0], [0.25, 0.25, 0.25], [0.5, 0.5, 0.5], [0.75, 0.75, 0.75]]) self.assertEqual(sm.fit_anonymous(s1, s2), True) self.assertAlmostEqual(sm.get_rms_anonymous(s1, s2)[0], 0)
def setUp(self): self.maxDiff = None # trivial example, simple square lattice for testing structure = Structure(Lattice.tetragonal(5.0, 50.0), ["H"], [[0, 0, 0]]) self.square_sg = StructureGraph.with_empty_graph(structure, edge_weight_name="", edge_weight_units="") self.square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(1, 0, 0)) self.square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(-1, 0, 0)) self.square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(0, 1, 0)) self.square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(0, -1, 0)) # TODO: decorating still fails because the structure graph gives a CN of 8 for this square lattice # self.square_sg.decorate_structure_with_ce_info() # body-centered square lattice for testing structure = Structure(Lattice.tetragonal(5.0, 50.0), ["H", "He"], [[0, 0, 0], [0.5, 0.5, 0.5]]) self.bc_square_sg = StructureGraph.with_empty_graph(structure, edge_weight_name="", edge_weight_units="") self.bc_square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(1, 0, 0)) self.bc_square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(-1, 0, 0)) self.bc_square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(0, 1, 0)) self.bc_square_sg.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(0, -1, 0)) self.bc_square_sg.add_edge(0, 1, from_jimage=(0, 0, 0), to_jimage=(0, 0, 0)) self.bc_square_sg.add_edge(0, 1, from_jimage=(0, 0, 0), to_jimage=(-1, 0, 0)) self.bc_square_sg.add_edge(0, 1, from_jimage=(0, 0, 0), to_jimage=(-1, -1, 0)) self.bc_square_sg.add_edge(0, 1, from_jimage=(0, 0, 0), to_jimage=(0, -1, 0)) # body-centered square lattice for testing # directions reversed, should be equivalent to bc_square structure = Structure(Lattice.tetragonal(5.0, 50.0), ["H", "He"], [[0, 0, 0], [0.5, 0.5, 0.5]]) self.bc_square_sg_r = StructureGraph.with_empty_graph(structure, edge_weight_name="", edge_weight_units="") self.bc_square_sg_r.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(1, 0, 0)) self.bc_square_sg_r.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(-1, 0, 0)) self.bc_square_sg_r.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(0, 1, 0)) self.bc_square_sg_r.add_edge(0, 0, from_jimage=(0, 0, 0), to_jimage=(0, -1, 0)) self.bc_square_sg_r.add_edge(0, 1, from_jimage=(0, 0, 0), to_jimage=(0, 0, 0)) self.bc_square_sg_r.add_edge(1, 0, from_jimage=(-1, 0, 0), to_jimage=(0, 0, 0)) self.bc_square_sg_r.add_edge(1, 0, from_jimage=(-1, -1, 0), to_jimage=(0, 0, 0)) self.bc_square_sg_r.add_edge(1, 0, from_jimage=(0, -1, 0), to_jimage=(0, 0, 0)) # MoS2 example, structure graph obtained from critic2 # (not ground state, from mp-1023924, single layer) stdout_file = os.path.join(PymatgenTest.TEST_FILES_DIR, "critic2/MoS2_critic2_stdout.txt") with open(stdout_file) as f: reference_stdout = f.read() self.structure = Structure.from_file(os.path.join(PymatgenTest.TEST_FILES_DIR, "critic2/MoS2.cif")) c2o = Critic2Analysis(self.structure, reference_stdout) self.mos2_sg = c2o.structure_graph(include_critical_points=False) latt = Lattice.cubic(4.17) species = ["Ni", "O"] coords = [[0, 0, 0], [0.5, 0.5, 0.5]] self.NiO = Structure.from_spacegroup(225, latt, species, coords).get_primitive_structure() # BCC example. self.bcc = Structure(Lattice.cubic(5.0), ["He", "He"], [[0, 0, 0], [0.5, 0.5, 0.5]]) warnings.simplefilter("ignore")
def setUp(self): self.gnd_real = Structure.from_file(TEST_FILES / 'POSCAR.C0.gz') self.exd_real = Structure.from_file(TEST_FILES / 'POSCAR.C-.gz') self.gnd_test = Structure(Lattice.cubic(1.), ['H'], [[0., 0., 0.]]) self.exd_test = Structure(Lattice.cubic(1.), ['H'], [[0.5, 0.5, 0.5]]) self.sct_test = Structure(Lattice.cubic(1.), ['H'], [[0.25, 0.25, 0.25]]) self.vrs = [TEST_FILES / 'vasprun.xml.0.gz'] + \ glob.glob(str(TEST_FILES / 'lower' / '*' / 'vasprun.xml.gz'))
def setUp(self): c1 = [[0.5] * 3, [0.9] * 3] c2 = [[0.5] * 3, [0.9, 0.1, 0.1]] s1 = Structure(Lattice.cubic(5), ['Si', 'Si'], c1) s2 = Structure(Lattice.cubic(5), ['Si', 'Si'], c2) structs = [] for s in s1.interpolate(s2, 3, pbc=True): structs.append(Structure.from_sites(s.sites, to_unit_cell=True)) self.structures = structs self.vis = MITNEBSet(self.structures)
def structure_comparator_periodic_issue(): cu2o_perfect = IStructure(Lattice.cubic(5), species=["Cu"] * 4 + ["O"] * 2, coords=[[0.25, 0.25, 0.25], [0.25, 0.75, 0.75], [0.75, 0.75, 0.25], [0.75, 0.25, 0.75], [0, 0, 0], [0.5, 0.5, 0.5]]) # defect center is ([1.0, 1.0, 1.0] + [0.99, 0.99, 0.99]) / 2 = [0.995]*3 cu2o_defect = IStructure(Lattice.cubic(5), species=["Cu"] * 4 + ["O"] + ["H"], coords=[[0.25, 0.25, 0.25], [0.25, 0.75, 0.75], [0.75, 0.75, 0.25], [0.75, 0.25, 0.75], [0.5, 0.5, 0.5], [0.99, 0.99, 0.99]]) return DefectStructureComparator(defect_structure=cu2o_defect, perfect_structure=cu2o_perfect)
def test_make_defect_structure_info2(): perf = Structure(Lattice.cubic(1), ["H"], [[0., 0., 0.]]) init = Structure(Lattice.cubic(1), ["H"] * 2, [[0., 0., 0.], [0.5, 0.0, 0.0]]) fin = Structure(Lattice.cubic(1), ["H"] * 2, [[0., 0., 0.], [0.4, 0.0, 0.0]]) info = MakeDefectStructureInfo(perf, init, fin, dist_tol=0.05, symprec=0.1, neighbor_cutoff_factor=1.2) actual = info.defect_structure_info print(actual)
def test_make_poscars_from_query(tmpdir): mg_structure = Structure(Lattice.cubic(1), species=["Mg", "Mg"], coords=[[0, 0, 0], [0.5, 0.5, 0.5]]) query = [{"full_formula": "Mg2", "task_id": "mp-1", "total_magnetization": 0.1, "band_gap": 0.0, "structure": mg_structure}, {"full_formula": "O16"}] make_poscars_from_query(query, path=Path(tmpdir)) tmpdir.chdir() s_mg = Structure.from_file(Path("Mg_mp-1") / "POSCAR") assert s_mg == mg_structure actual = loadfn(Path("Mg_mp-1") / "prior_info.yaml") expected = {'band_gap': 0.0, 'data_source': 'mp-1', 'total_magnetization': 0.1} assert actual == expected actual = Structure.from_file(Path("mol_O2") / "POSCAR") expected = Structure.from_str("""Default POSCAR of O2 molecule 1.00000000000000 10.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 10.0000000000000000 0.0000000000000000 0.0000000000000000 0.0000000000000000 10.0000000000000000 O 2 Direct 0.0145089778962415 0.0000000000000000 0.0000000000000000 0.1354910221037571 0.0000000000000000 0.0000000000000000""", fmt="POSCAR") assert actual == expected
def test_two_targets(self): s = Structure(Lattice.cubic(3), ["Si"], [[0, 0, 0]]) with ScratchDir("."): # initialize the model self.model2.train([s, s], [[0.1, 0.2], [0.1, 0.2]], epochs=1) pred = self.model2.predict_structure(s) self.assertEqual(len(pred.ravel()), 2)
def bi(self): """Return BCC Bi structure.""" bcc_bi = Structure.from_spacegroup("Im-3m", Lattice.cubic(3.453), ["Bi"], [[0, 0, 0]]) bcc_bi = bcc_bi.get_reduced_structure("niggli") return bcc_bi
def test_writestring(self): # Test for the string export of s atructure into the exciting input xml schema input_string = ( '<input xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' 'xsi:noNamespaceSchemaLocation="http://xml.exciting-code.org/excitinginput' '.xsd">\n <title>Na4 Cl4</title>\n <structure speciespath="./">\n ' '<crystal scale="1.8897543768634038">\n <basevect> 5.62000000' ' 0.00000000 0.00000000</basevect>\n <basevect> ' '0.00000000 5.62000000 0.00000000</basevect>\n ' '<basevect> 0.00000000 0.00000000 5.62000000</basevect>' '\n </crystal>\n <species speciesfile="Na.xml">\n <atom coord=' '" 0.00000000 0.00000000 0.00000000" />\n <atom coor' 'd=" 0.50000000 0.50000000 0.00000000" />\n <atom co' 'ord=" 0.50000000 0.00000000 0.50000000" />\n <atom ' 'coord=" 0.00000000 0.50000000 0.50000000" />\n </spec' 'ies>\n <species speciesfile="Cl.xml">\n <atom coord=" 0.5000' '0000 0.00000000 0.00000000" />\n <atom coord=" 0.00' '000000 0.50000000 0.00000000" />\n <atom coord=" 0.' '00000000 0.00000000 0.50000000" />\n <atom coord=" ' '0.50000000 0.50000000 0.50000000" />\n </species>\n </str' 'ucture>\n</input>\n') lattice = Lattice.cubic('5.62') structure = Structure( lattice, ['Na', 'Na', 'Na', 'Na', 'Cl', 'Cl', 'Cl', 'Cl'], [[0, 0, 0], [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5], [0.5, 0.0, 0.0], [0.0, 0.5, 0.0], [0.0, 0.0, 0.5], [0.5, 0.5, 0.5]]) excin = ExcitingInput(structure) for l1, l2 in zip(input_string.split("\n"), excin.write_string('unchanged').split("\n")): if not l1.strip().startswith("<crystal scale"): self.assertEqual(l1.strip(), l2.strip())
def test_equality_of_sqs_objects(): """SQS structures with different underlying crystal structures are equivalent iff sublattice models are equivalent.""" config = [['A', 'B'], ['A']] occupancy = [[0.5, 0.5], [1]] site_ratios = [3, 1] # Use same sublattice for different underlying structures. Should be equal s1 = PRLStructure(Lattice.hexagonal(1, 2), ['Mg', 'Mg'], [[0, 0, 0], [0.3333, 0.66666, 0.5]], sublattice_configuration=config, sublattice_occupancies=occupancy, sublattice_site_ratios=site_ratios) s2 = PRLStructure(Lattice.cubic(1), ['Fe'], [[0, 0, 0]], sublattice_configuration=config, sublattice_occupancies=occupancy, sublattice_site_ratios=site_ratios) assert s1 == s2 # Use same underlying crystal structures, but different sublattice configurations. Should be not equal s1.sublattice_site_ratios = [2, 1] assert s1 != s2 s1.sublattice_site_ratios = site_ratios s1.sublattice_occupancies = [[0.25, 0.5], [1]] assert s1 != s2 s1.sublattice_occupancies = occupancy s1.sublattice_configuration = [['A', 'A'], ['A']] assert s1 != s2 s1.sublattice_configuration = config assert s1 == s2
def make_atom_mp_relax_set(): for element, potcar in PotcarSet.mp_relax_set.potcar_dict().items(): if potcar is None: continue if is_target_element(element) is False: continue structure = Structure(Lattice.cubic(10), coords=[[0.5] * 3], species=[element]) mp_set = MPRelaxSet(structure, user_kpoints_settings=Kpoints(kpts=((1, 1, 1), )), user_incar_settings={ "ALGO": "D", "ISIF": 2, "ISMEAR": 0, "MAGMOM": { "H": 1.0 }, "NELM": 300 }) Path(element).mkdir() mp_set.write_input(element)
def simple_cubic_2x2x2(): lattice = Lattice.cubic(2.0) coords = [[0.0, 0.0, 0.0], [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5], [0.0, 0.0, 0.5], [0.0, 0.5, 0.0], [0.5, 0.0, 0.0], [0.5, 0.5, 0.5]] return IStructure(lattice=lattice, species=["H"] * 8, coords=coords)
def def_str_info(displacements): site_diff = SiteDiff(removed=[(0, 'H', (0.25, 0.25, 0.25))], inserted=[(0, 'H', (0.27, 0.25, 0.25))], removed_by_sub=[(2, 'Li', (0.5, 0.5, 0.5))], inserted_by_sub=[(2, 'Be', (0.5, 0.5, 0.5009))]) site_diff_from_init = SiteDiff(removed=[(0, 'H', (0.25, 0.25, 0.25))], inserted=[(0, 'H', (0.27, 0.25, 0.25))], removed_by_sub=[(2, 'Li', (0.5, 0.5, 0.5))], inserted_by_sub=[(2, 'Be', (0.5, 0.5, 0.5)) ]) shifted_final = Structure(Lattice.cubic(10), species=["H", "He", "Be", "U"], coords=[[0.27, 0.25, 0.25], [0.76, 0.75, 0.75], [0.5, 0.5, 0.5009], [0.0, 0.0, 0.0]]) return DefectStructureInfo(shifted_final_structure=shifted_final, initial_site_sym="3m", final_site_sym="m", site_diff=site_diff, site_diff_from_initial=site_diff_from_init, symprec=0.1, dist_tol=0.2, anchor_atom_idx=3, neighbor_atom_indices=[0], neighbor_cutoff_factor=1.2, drift_vector=(0.0, 0.0, 0.0001), drift_dist=0.001, center=(0.38, 0.375, 0.375175), displacements=displacements)
def structures(): perfect = Structure(Lattice.cubic(10), species=["H", "He", "Li", "U"], coords=[[0.25, 0.25, 0.25], [0.75, 0.75, 0.75], [0.5, 0.5, 0.5], [0, 0, 0]]) initial = Structure(Lattice.cubic(10), species=["H", "He", "Be", "U"], coords=[[0.25, 0.25, 0.25], [0.75, 0.75, 0.75], [0.5, 0.5, 0.5], [0.0, 0.0, 0.0]]) final = Structure(Lattice.cubic(10), species=["H", "He", "Be", "U"], coords=[[0.27, 0.25, 0.2501], [0.76, 0.75, 0.7501], [0.5, 0.5, 0.501], [0.0, 0.0, 0.0001]]) return perfect, initial, final
def test_writestring(self): # Test for the string export of s atructure into the exciting input xml schema input_string = ( '<input xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' 'xsi:noNamespaceSchemaLocation="http://xml.exciting-code.org/excitinginput' '.xsd">\n <title>Na4 Cl4</title>\n <structure speciespath="./">\n ' '<crystal scale="1.8897543768634038">\n <basevect> 5.62000000' ' 0.00000000 0.00000000</basevect>\n <basevect> ' '0.00000000 5.62000000 0.00000000</basevect>\n ' '<basevect> 0.00000000 0.00000000 5.62000000</basevect>' '\n </crystal>\n <species speciesfile="Na.xml">\n <atom coord=' '" 0.00000000 0.00000000 0.00000000" />\n <atom coor' 'd=" 0.50000000 0.50000000 0.00000000" />\n <atom co' 'ord=" 0.50000000 0.00000000 0.50000000" />\n <atom ' 'coord=" 0.00000000 0.50000000 0.50000000" />\n </spec' 'ies>\n <species speciesfile="Cl.xml">\n <atom coord=" 0.5000' '0000 0.00000000 0.00000000" />\n <atom coord=" 0.00' '000000 0.50000000 0.00000000" />\n <atom coord=" 0.' '00000000 0.00000000 0.50000000" />\n <atom coord=" ' '0.50000000 0.50000000 0.50000000" />\n </species>\n </str' 'ucture>\n</input>\n') lattice = Lattice.cubic('5.62') structure = Structure(lattice, ['Na', 'Na', 'Na', 'Na', 'Cl', 'Cl', 'Cl', 'Cl'], [[0, 0, 0], [0.5, 0.5, 0.0], [0.5, 0.0, 0.5], [0.0, 0.5, 0.5], [0.5, 0.0, 0.0], [0.0, 0.5, 0.0], [0.0, 0.0, 0.5], [0.5, 0.5, 0.5]]) excin = ExcitingInput(structure) for l1, l2 in zip(input_string.split("\n"), excin.write_string('unchanged').split("\n")): if not l1.strip().startswith("<crystal scale"): self.assertEqual(l1, l2)
def test_sqs_obj_correctly_serialized(): """Tests that the as_dict method of the SQS object correctly includes metadata and is able to be seralized/unserialized.""" sqs = AbstractSQS(Lattice.cubic(5), ['Xaa', 'Xab'], [[0, 0, 0], [0.5, 0.5, 0.5]], sublattice_model=[['a', 'b']], sublattice_names=['a']) # first seralization s1 = AbstractSQS.from_dict(sqs.as_dict()) assert sqs == s1 assert s1.sublattice_model == [['a', 'b']] assert s1._sublattice_names == ['a'] assert s1.normalized_sublattice_site_ratios == [[0.5, 0.5]] # second serialization s2 = AbstractSQS.from_dict(sqs.as_dict()) assert sqs == s2 assert s2.sublattice_model == [['a', 'b']] assert s2._sublattice_names == ['a'] assert s2.normalized_sublattice_site_ratios == [[0.5, 0.5]] # test that we can make it concrete concrete_structure = s2.get_concrete_sqs([['Fe', 'Ni']]) assert {s.symbol for s in concrete_structure.types_of_specie} == {'Fe', 'Ni'}
def test_model_load(self): s = Structure(Lattice.cubic(3.6), ["Mo", "Mo"], [[0.5, 0.5, 0.5], [0, 0, 0]]) center_indices, neighbor_indices, images, distances = get_graphs_within_cutoff(s, 4) self.assertListEqual( center_indices.tolist(), [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], )
def test_out_of_cell_s2_like_s1(self): l = Lattice.cubic(5) s1 = Structure(l, ["Si", "Ag", "Si"], [[0, 0, -0.02], [0, 0, 0.001], [0.7, 0.4, 0.5]]) s2 = Structure(l, ["Si", "Ag", "Si"], [[0, 0, 0.98], [0, 0, 0.99], [0.7, 0.4, 0.5]]) new_s2 = StructureMatcher(primitive_cell=False).get_s2_like_s1(s1, s2) dists = np.sum((s1.cart_coords - new_s2.cart_coords) ** 2, axis=-1) ** 0.5 self.assertLess(np.max(dists), 0.1)
def calc_results(): return CalcResults(structure=IStructure(Lattice.cubic(1.0), ["H"], [[0.0] * 3]), energy=1.0, magnetization=0.0, potentials=[0.0], electronic_conv=False, ionic_conv=False)
def test_sbond(): s = Structure(Lattice.cubic(3.9), species=["Ba", "Ti"], coords=[[0.5]*3, [0.0]*3]) actual = repr(SBond(s, bond_factor=1.2)) expected = '''SBOND 1 Ba Ti 0.0 2.81 0 0 1 0 1 2 Ti Ba 0.0 2.81 0 0 1 0 1 0 0 0 0 ''' assert actual == expected
def test_make_site_diff_wo_diff(): s1 = IStructure(Lattice.cubic(10), species=["H"], coords=[[0] * 3]) s2 = s1.copy() structure_comparator = DefectStructureComparator(s1, s2) site_diff = structure_comparator.make_site_diff() assert site_diff == SiteDiff([], [], [], []) assert site_diff.is_no_diff s1 = IStructure(Lattice.cubic(10), species=["H", "He"], coords=[[0] * 3, [0.5] * 3]) s2 = IStructure(Lattice.cubic(10), species=["H"], coords=[[0] * 3]) structure_comparator = DefectStructureComparator(defect_structure=s2, perfect_structure=s1) site_diff = structure_comparator.make_site_diff() assert site_diff == SiteDiff([(1, "He", (0.5, 0.5, 0.5))], [], [], []) assert site_diff.is_no_diff is False
def setUp(self): parser = CifParser(os.path.join(PymatgenTest.TEST_FILES_DIR, "Fe.cif")) self.Fe = parser.get_structures()[0] parser = CifParser( os.path.join(PymatgenTest.TEST_FILES_DIR, "LiFePO4.cif")) self.LiFePO4 = parser.get_structures()[0] parser = CifParser( os.path.join(PymatgenTest.TEST_FILES_DIR, "Fe3O4.cif")) self.Fe3O4 = parser.get_structures()[0] parser = CifParser( os.path.join(PymatgenTest.TEST_FILES_DIR, "magnetic.ncl.example.GdB4.mcif")) self.GdB4 = parser.get_structures()[0] parser = CifParser( os.path.join(PymatgenTest.TEST_FILES_DIR, "magnetic.example.NiO.mcif")) self.NiO_expt = parser.get_structures()[0] latt = Lattice.cubic(4.17) species = ["Ni", "O"] coords = [[0, 0, 0], [0.5, 0.5, 0.5]] self.NiO = Structure.from_spacegroup(225, latt, species, coords) latt = Lattice([[2.085, 2.085, 0.0], [0.0, -2.085, -2.085], [-2.085, 2.085, -4.17]]) species = ["Ni", "Ni", "O", "O"] coords = [[0.5, 0, 0.5], [0, 0, 0], [0.25, 0.5, 0.25], [0.75, 0.5, 0.75]] self.NiO_AFM_111 = Structure(latt, species, coords, site_properties={"magmom": [-5, 5, 0, 0]}) latt = Lattice([[2.085, 2.085, 0], [0, 0, -4.17], [-2.085, 2.085, 0]]) species = ["Ni", "Ni", "O", "O"] coords = [[0.5, 0.5, 0.5], [0, 0, 0], [0, 0.5, 0], [0.5, 0, 0.5]] self.NiO_AFM_001 = Structure(latt, species, coords, site_properties={"magmom": [-5, 5, 0, 0]}) latt = Lattice([[2.085, 2.085, 0], [0, 0, -4.17], [-2.085, 2.085, 0]]) species = ["Ni", "Ni", "O", "O"] coords = [[0.5, 0.5, 0.5], [0, 0, 0], [0, 0.5, 0], [0.5, 0, 0.5]] self.NiO_AFM_001_opposite = Structure( latt, species, coords, site_properties={"magmom": [5, -5, 0, 0]}) latt = Lattice([[2.085, 2.085, 0], [0, 0, -4.17], [-2.085, 2.085, 0]]) species = ["Ni", "Ni", "O", "O"] coords = [[0.5, 0.5, 0.5], [0, 0, 0], [0, 0.5, 0], [0.5, 0, 0.5]] self.NiO_unphysical = Structure( latt, species, coords, site_properties={"magmom": [-3, 0, 0, 0]}) warnings.simplefilter("ignore")
def test_out_of_cell_s2_like_s1(self): l = Lattice.cubic(5) s1 = Structure(l, ['Si', 'Ag', 'Si'], [[0, 0, -0.02], [0, 0, 0.001], [.7, .4, .5]]) s2 = Structure(l, ['Si', 'Ag', 'Si'], [[0, 0, 0.98], [0, 0, 0.99], [.7, .4, .5]]) new_s2 = StructureMatcher(primitive_cell=False).get_s2_like_s1(s1, s2) dists = np.sum((s1.cart_coords - new_s2.cart_coords)**2, axis=-1)**0.5 self.assertLess(np.max(dists), 0.1)
def test_shift_distance_data2(): grids = Grids(lattice=Lattice.cubic(10), dim=(2, 2, 2), distance_data=np.array([[[0.0, 5.0], [5.0, 7.07]], [[5.0, 7.07], [7.07, 8.66]]])) actual = grids.shifted_distance_data(center=[1, 1, 1]) expected = np.array([[[8.66, 7.07], [7.07, 5.0]], [[7.07, 5.0], [5.0, 0.0]]]) np.testing.assert_array_almost_equal(actual, expected)
def test_get_supercells(self): sm = StructureMatcher(comparator=ElementComparator()) l = Lattice.cubic(1) l2 = Lattice.cubic(0.5) s1 = Structure(l, ['Mg', 'Cu', 'Ag', 'Cu'], [[0]*3]*4) s2 = Structure(l2, ['Cu', 'Cu', 'Ag'], [[0]*3]*3) scs = list(sm._get_supercells(s1, s2, 8, False)) for x in scs: self.assertAlmostEqual(abs(np.linalg.det(x[3])), 8) self.assertEqual(len(x[0]), 4) self.assertEqual(len(x[1]), 24) self.assertEqual(len(scs), 48) scs = list(sm._get_supercells(s2, s1, 8, True)) for x in scs: self.assertAlmostEqual(abs(np.linalg.det(x[3])), 8) self.assertEqual(len(x[0]), 24) self.assertEqual(len(x[1]), 4) self.assertEqual(len(scs), 48)
def test_get_mask(self): sm = StructureMatcher(comparator=ElementComparator()) l = Lattice.cubic(1) s1 = Structure(l, ['Mg', 'Cu', 'Ag', 'Cu'], [[0]*3]*4) s2 = Structure(l, ['Cu', 'Cu', 'Ag'], [[0]*3]*3) result = [[True, False, True, False], [True, False, True, False], [True, True, False, True]] m, inds, i = sm._get_mask(s1, s2, 1, True) self.assertTrue(np.all(m == result)) self.assertTrue(i == 2) self.assertEqual(inds, [2]) #test supercell with match result = [[1, 1, 0, 0, 1, 1, 0, 0], [1, 1, 0, 0, 1, 1, 0, 0], [1, 1, 1, 1, 0, 0, 1, 1]] m, inds, i = sm._get_mask(s1, s2, 2, True) self.assertTrue(np.all(m == result)) self.assertTrue(i == 2) self.assertTrue(np.allclose(inds, np.array([4]))) #test supercell without match result = [[1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1], [1, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1]] m, inds, i = sm._get_mask(s2, s1, 2, True) self.assertTrue(np.all(m == result)) self.assertTrue(i == 0) self.assertTrue(np.allclose(inds, np.array([]))) #test s2_supercell result = [[1, 1, 1], [1, 1, 1], [0, 0, 1], [0, 0, 1], [1, 1, 0], [1, 1, 0], [0, 0, 1], [0, 0, 1]] m, inds, i = sm._get_mask(s2, s1, 2, False) self.assertTrue(np.all(m == result)) self.assertTrue(i == 0) self.assertTrue(np.allclose(inds, np.array([]))) #test for multiple translation indices s1 = Structure(l, ['Cu', 'Ag', 'Cu', 'Ag', 'Ag'], [[0]*3]*5) s2 = Structure(l, ['Ag', 'Cu', 'Ag'], [[0]*3]*3) result = [[1, 0, 1, 0, 0], [0, 1, 0, 1, 1], [1, 0, 1, 0, 0]] m, inds, i = sm._get_mask(s1, s2, 1, True) self.assertTrue(np.all(m == result)) self.assertTrue(i == 1) self.assertTrue(np.allclose(inds, [0, 2]))
def test_nelect(self): coords = [[0] * 3, [0.5] * 3, [0.75] * 3] lattice = Lattice.cubic(4) s = Structure(lattice, ['Si', 'Si', 'Fe'], coords) self.assertAlmostEqual(MITRelaxSet(s).nelect, 16) # Check that it works even when oxidation states are present. Was a bug # previously. s = Structure(lattice, ['Si4+', 'Si4+', 'Fe2+'], coords) self.assertAlmostEqual(MITRelaxSet(s).nelect, 16) self.assertAlmostEqual(MPRelaxSet(s).nelect, 22)
def test_get_supercell_size(self): l = Lattice.cubic(1) l2 = Lattice.cubic(0.9) s1 = Structure(l, ["Mg", "Cu", "Ag", "Cu", "Ag"], [[0] * 3] * 5) s2 = Structure(l2, ["Cu", "Cu", "Ag"], [[0] * 3] * 3) sm = StructureMatcher(supercell_size="volume") self.assertEqual(sm._get_supercell_size(s1, s2), (1, True)) self.assertEqual(sm._get_supercell_size(s2, s1), (1, True)) sm = StructureMatcher(supercell_size="num_sites") self.assertEqual(sm._get_supercell_size(s1, s2), (2, False)) self.assertEqual(sm._get_supercell_size(s2, s1), (2, True)) sm = StructureMatcher(supercell_size="Ag") self.assertEqual(sm._get_supercell_size(s1, s2), (2, False)) self.assertEqual(sm._get_supercell_size(s2, s1), (2, True)) sm = StructureMatcher(supercell_size="wfieoh") self.assertRaises(ValueError, sm._get_supercell_size, s1, s2)
def test_metal_check(self): structure = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3), ["Cu"], [[0, 0, 0]]) with warnings.catch_warnings(record=True) as w: # Cause all warnings to always be triggered. warnings.simplefilter("always") # Trigger a warning. vis = MITRelaxSet(structure) incar = vis.incar # Verify some things self.assertIn("ISMEAR", str(w[-1].message))
def test_get_supercell_size(self): l = Lattice.cubic(1) l2 = Lattice.cubic(0.9) s1 = Structure(l, ['Mg', 'Cu', 'Ag', 'Cu', 'Ag'], [[0]*3]*5) s2 = Structure(l2, ['Cu', 'Cu', 'Ag'], [[0]*3]*3) sm = StructureMatcher(supercell_size='volume') result = sm._get_supercell_size(s1, s2) self.assertEqual(result[0], 1) self.assertEqual(result[1], True) result = sm._get_supercell_size(s2, s1) self.assertEqual(result[0], 1) self.assertEqual(result[1], True) sm = StructureMatcher(supercell_size='num_sites') result = sm._get_supercell_size(s1, s2) self.assertEqual(result[0], 2) self.assertEqual(result[1], False) result = sm._get_supercell_size(s2, s1) self.assertEqual(result[0], 2) self.assertEqual(result[1], True)
def setUp(self): parser = CifParser(os.path.join(test_dir, 'Fe.cif')) self.Fe = parser.get_structures()[0] parser = CifParser(os.path.join(test_dir, 'LiFePO4.cif')) self.LiFePO4 = parser.get_structures()[0] parser = CifParser(os.path.join(test_dir, 'Fe3O4.cif')) self.Fe3O4 = parser.get_structures()[0] parser = CifParser(os.path.join(test_dir, 'magnetic.ncl.example.GdB4.mcif')) self.GdB4 = parser.get_structures()[0] parser = CifParser(os.path.join(test_dir, 'magnetic.example.NiO.mcif')) self.NiO_expt = parser.get_structures()[0] latt = Lattice.cubic(4.17) species = ["Ni", "O"] coords = [[0, 0, 0], [0.5, 0.5, 0.5]] self.NiO = Structure.from_spacegroup(225, latt, species, coords) latt = Lattice([[2.085, 2.085, 0.0], [0.0, -2.085, -2.085], [-2.085, 2.085, -4.17]]) species = ["Ni", "Ni", "O", "O"] coords = [[0.5, 0, 0.5], [0, 0, 0], [0.25, 0.5, 0.25], [0.75, 0.5, 0.75]] self.NiO_AFM_111 = Structure(latt, species, coords, site_properties={'magmom': [-5, 5, 0, 0]}) latt = Lattice([[2.085, 2.085, 0], [0, 0, -4.17], [-2.085, 2.085, 0]]) species = ["Ni", "Ni", "O", "O"] coords = [[0.5, 0.5, 0.5], [0, 0, 0], [0, 0.5, 0], [0.5, 0, 0.5]] self.NiO_AFM_001 = Structure(latt, species, coords, site_properties={'magmom': [-5, 5, 0, 0]})
if scan: wf_name += " - SCAN" wf = Workflow(fws, name=wf_name) wf = add_additional_fields_to_taskdocs(wf, {"wf_meta": self.wf_meta}) tag = "magnetic_orderings group: >>{}<<".format(self.uuid) wf = add_tags(wf, [tag, ordered_structure_origins]) return wf if __name__ == "__main__": # for trying workflows from fireworks import LaunchPad latt = Lattice.cubic(4.17) species = ["Ni", "O"] coords = [[0.00000, 0.00000, 0.00000], [0.50000, 0.50000, 0.50000]] NiO = Structure.from_spacegroup(225, latt, species, coords) wf_deformation = get_wf_magnetic_deformation(NiO) wf_orderings = MagneticOrderingsWF(NiO).get_wf() lpad = LaunchPad.auto_load() lpad.add_wf(wf_orderings) lpad.add_wf(wf_deformation)