def __init__(self, structure, element): """ Initializes a Substitution Generator note: an Antisite is considered a type of substitution Args: structure(Structure): pymatgen structure object element (str or Element or Specie): element for the substitution """ self.structure = structure self.element = element # Find equivalent site list sga = SpacegroupAnalyzer(self.structure) self.symm_structure = sga.get_symmetrized_structure() self.equiv_sub = [] for equiv_site_set in list(self.symm_structure.equivalent_sites): vac_site = equiv_site_set[0] if isinstance( element, str ): # make sure you compare with specie symbol or Element type vac_specie = vac_site.specie.symbol else: vac_specie = vac_site.specie if element != vac_specie: defect_site = PeriodicSite(element, vac_site.coords, structure.lattice, coords_are_cartesian=True) sub = Substitution(structure, defect_site) self.equiv_sub.append(sub)
def setUp(self): self.struc = PymatgenTest.get_structure("VO2") V_index = self.struc.indices_from_symbol("V")[0] sub_site = PeriodicSite("Sr", self.struc[V_index].coords, self.struc.lattice, coords_are_cartesian=True) self.substitution = Substitution(self.struc, sub_site)
def test_convert_cd_to_de(self): #create a ComputedDefect object similar to legacy format # Vacancy type first struc = PymatgenTest.get_structure("VO2") struc.make_supercell(3) vac = Vacancy(struc, struc.sites[0], charge=-3) ids = vac.generate_defect_structure(1) defect_data = { "locpot_path": "defect/path/to/files/LOCPOT", "encut": 520 } bulk_data = {"locpot_path": "bulk/path/to/files/LOCPOT"} cse_defect = ComputedStructureEntry(ids, 100., data=defect_data) cd = ComputedDefect(cse_defect, struc.sites[0], charge=-3, name="Vac_1_O") b_cse = ComputedStructureEntry(struc, 10., data=bulk_data) de = convert_cd_to_de(cd, b_cse) self.assertIsInstance(de.defect, Vacancy) self.assertIsInstance(de, DefectEntry) self.assertEqual(de.parameters["defect_path"], "defect/path/to/files") self.assertEqual(de.parameters["bulk_path"], "bulk/path/to/files") self.assertEqual(de.parameters["encut"], 520) self.assertEqual(de.site.specie.symbol, "O") # try again for substitution type # (site object had bulk specie for ComputedDefects, # while it should have substituional site specie for DefectEntrys...) de_site_type = PeriodicSite("Sb", vac.site.frac_coords, struc.lattice) sub = Substitution(struc, de_site_type, charge=1) ids = sub.generate_defect_structure(1) cse_defect = ComputedStructureEntry(ids, 100., data=defect_data) cd = ComputedDefect(cse_defect, struc.sites[0], charge=1, name="Sub_1_Sb_on_O") de = convert_cd_to_de(cd, b_cse) self.assertIsInstance(de.defect, Substitution) self.assertIsInstance(de, DefectEntry) self.assertEqual(de.site.specie.symbol, "Sb")
def convert_cd_to_de( cd, b_cse): """ As of pymatgen v2.0, ComputedDefect objects were deprecated in favor of DefectEntry objects in pymatgen.analysis.defects.core This function takes a ComputedDefect (either as a dict or object) and converts it into a DefectEntry object in order to handle legacy PyCDT creation within the current paradigm of PyCDT. :param cd (dict or ComputedDefect object): ComputedDefect as an object or as a dictionary :params b_cse (dict or ComputedStructureEntry object): ComputedStructureEntry of bulk entry associated with the ComputedDefect. :return: de (DefectEntry): Resulting DefectEntry object """ if type(cd) != dict: cd = cd.as_dict() if type(b_cse) != dict: b_cse = b_cse.as_dict() bulk_sc_structure = Structure.from_dict( b_cse["structure"]) #modify defect_site as required for Defect object, confirming site exists in bulk structure site_cls = cd["site"] defect_site = PeriodicSite.from_dict( site_cls) def_nom = cd["name"].lower() if "sub_" in def_nom or "as_" in def_nom: #modify site object for substitution site of Defect object site_cls["species"][0]["element"] = cd["name"].split("_")[2] defect_site = PeriodicSite.from_dict( site_cls) poss_deflist = sorted( bulk_sc_structure.get_sites_in_sphere(defect_site.coords, 0.1, include_index=True), key=lambda x: x[1]) if len(poss_deflist) != 1: raise ValueError("ComputedDefect to DefectEntry conversion failed. " "Could not determine periodic site position in bulk supercell.") # create defect object if "vac_" in def_nom: defect_obj = Vacancy(bulk_sc_structure, defect_site, charge=cd["charge"]) elif "as_" in def_nom or "sub_" in def_nom: defect_obj = Substitution(bulk_sc_structure, defect_site, charge=cd["charge"]) elif "int_" in def_nom: defect_obj = Interstitial(bulk_sc_structure, defect_site, charge=cd["charge"]) else: raise ValueError("Could not recognize defect type for {}".format( cd["name"])) # assign proper energy and parameter metadata uncorrected_energy = cd["entry"]["energy"] - b_cse["energy"] def_path = os.path.split( cd["entry"]["data"]["locpot_path"])[0] bulk_path = os.path.split( b_cse["data"]["locpot_path"])[0] p = {"defect_path": def_path, "bulk_path": bulk_path, "encut": cd["entry"]["data"]["encut"]} de = DefectEntry( defect_obj, uncorrected_energy, parameters = p) return de
def test_defect_matching(self): # SETUP DEFECTS FOR TESTING # symmorphic defect test set s_struc = Structure.from_file(os.path.join( test_dir, "CsSnI3.cif")) # tetragonal CsSnI3 identical_Cs_vacs = [ Vacancy(s_struc, s_struc[0]), Vacancy(s_struc, s_struc[1]) ] identical_I_vacs_sublattice1 = [ Vacancy(s_struc, s_struc[4]), Vacancy(s_struc, s_struc[5]), Vacancy(s_struc, s_struc[8]), Vacancy(s_struc, s_struc[9]) ] # in plane halides identical_I_vacs_sublattice2 = [ Vacancy(s_struc, s_struc[6]), Vacancy(s_struc, s_struc[7]) ] # out of plane halides pdc = PointDefectComparator() # NOW TEST DEFECTS # test vacancy matching self.assertTrue( pdc.are_equal(identical_Cs_vacs[0], identical_Cs_vacs[0])) # trivial vacancy test self.assertTrue( pdc.are_equal( identical_Cs_vacs[0], identical_Cs_vacs[1])) # vacancies on same sublattice for i, j in itertools.combinations(range(4), 2): self.assertTrue( pdc.are_equal(identical_I_vacs_sublattice1[i], identical_I_vacs_sublattice1[j])) self.assertTrue( pdc.are_equal(identical_I_vacs_sublattice2[0], identical_I_vacs_sublattice2[1])) self.assertFalse( pdc.are_equal( identical_Cs_vacs[ 0], # both vacancies, but different specie types identical_I_vacs_sublattice1[0])) self.assertFalse( pdc.are_equal( identical_I_vacs_sublattice1[ 0], # same specie type, different sublattice identical_I_vacs_sublattice2[0])) # test substitutional matching sub_Cs_on_I_sublattice1_set1 = PeriodicSite( 'Cs', identical_I_vacs_sublattice1[0].site.frac_coords, s_struc.lattice) sub_Cs_on_I_sublattice1_set2 = PeriodicSite( 'Cs', identical_I_vacs_sublattice1[1].site.frac_coords, s_struc.lattice) sub_Cs_on_I_sublattice2 = PeriodicSite( 'Cs', identical_I_vacs_sublattice2[0].site.frac_coords, s_struc.lattice) sub_Rb_on_I_sublattice2 = PeriodicSite( 'Rb', identical_I_vacs_sublattice2[0].site.frac_coords, s_struc.lattice) self.assertTrue( pdc.are_equal( # trivial substitution test Substitution(s_struc, sub_Cs_on_I_sublattice1_set1), Substitution(s_struc, sub_Cs_on_I_sublattice1_set1))) self.assertTrue( pdc.are_equal( # same sublattice, different coords Substitution(s_struc, sub_Cs_on_I_sublattice1_set1), Substitution(s_struc, sub_Cs_on_I_sublattice1_set2))) self.assertFalse( pdc.are_equal( # different subs (wrong specie) Substitution(s_struc, sub_Cs_on_I_sublattice2), Substitution(s_struc, sub_Rb_on_I_sublattice2))) self.assertFalse( pdc.are_equal( # different subs (wrong sublattice) Substitution(s_struc, sub_Cs_on_I_sublattice1_set1), Substitution(s_struc, sub_Cs_on_I_sublattice2))) # test symmorphic interstitial matching # (using set generated from Voronoi generator, with same sublattice given by saturatated_interstitial_structure function) inter_H_sublattice1_set1 = PeriodicSite('H', [0., 0.75, 0.25], s_struc.lattice) inter_H_sublattice1_set2 = PeriodicSite('H', [0., 0.75, 0.75], s_struc.lattice) inter_H_sublattice2 = PeriodicSite( 'H', [0.57796112, 0.06923687, 0.56923687], s_struc.lattice) inter_H_sublattice3 = PeriodicSite('H', [0.25, 0.25, 0.54018268], s_struc.lattice) inter_He_sublattice3 = PeriodicSite('He', [0.25, 0.25, 0.54018268], s_struc.lattice) self.assertTrue( pdc.are_equal( # trivial interstitial test Interstitial(s_struc, inter_H_sublattice1_set1), Interstitial(s_struc, inter_H_sublattice1_set1))) self.assertTrue( pdc.are_equal( # same sublattice, different coords Interstitial(s_struc, inter_H_sublattice1_set1), Interstitial(s_struc, inter_H_sublattice1_set2))) self.assertFalse( pdc.are_equal( # different interstitials (wrong sublattice) Interstitial(s_struc, inter_H_sublattice1_set1), Interstitial(s_struc, inter_H_sublattice2))) self.assertFalse( pdc.are_equal( # different interstitials (wrong sublattice) Interstitial(s_struc, inter_H_sublattice1_set1), Interstitial(s_struc, inter_H_sublattice3))) self.assertFalse( pdc.are_equal( # different interstitials (wrong specie) Interstitial(s_struc, inter_H_sublattice3), Interstitial(s_struc, inter_He_sublattice3))) # test non-symmorphic interstitial matching # (using set generated from Voronoi generator, with same sublattice given by saturatated_interstitial_structure function) ns_struc = Structure.from_file(os.path.join(test_dir, "CuCl.cif")) ns_inter_H_sublattice1_set1 = PeriodicSite( 'H', [0.06924513, 0.06308959, 0.86766528], ns_struc.lattice) ns_inter_H_sublattice1_set2 = PeriodicSite( 'H', [0.43691041, 0.36766528, 0.06924513], ns_struc.lattice) ns_inter_H_sublattice2 = PeriodicSite( 'H', [0.06022109, 0.60196031, 0.1621814], ns_struc.lattice) ns_inter_He_sublattice2 = PeriodicSite( 'He', [0.06022109, 0.60196031, 0.1621814], ns_struc.lattice) self.assertTrue( pdc.are_equal( # trivial interstitial test Interstitial(ns_struc, ns_inter_H_sublattice1_set1), Interstitial(ns_struc, ns_inter_H_sublattice1_set1))) self.assertTrue( pdc.are_equal( # same sublattice, different coords Interstitial(ns_struc, ns_inter_H_sublattice1_set1), Interstitial(ns_struc, ns_inter_H_sublattice1_set2))) self.assertFalse( pdc.are_equal( Interstitial(ns_struc, ns_inter_H_sublattice1_set1 ), # different interstitials (wrong sublattice) Interstitial(ns_struc, ns_inter_H_sublattice2))) self.assertFalse( pdc.are_equal( # different interstitials (wrong specie) Interstitial(ns_struc, ns_inter_H_sublattice2), Interstitial(ns_struc, ns_inter_He_sublattice2))) # test influence of charge on defect matching (default is to be charge agnostic) vac_diff_chg = identical_Cs_vacs[0].copy() vac_diff_chg.set_charge(3.) self.assertTrue(pdc.are_equal(identical_Cs_vacs[0], vac_diff_chg)) chargecheck_pdc = PointDefectComparator( check_charge=True) # switch to PDC which cares about charge state self.assertFalse( chargecheck_pdc.are_equal(identical_Cs_vacs[0], vac_diff_chg)) # test different supercell size # (comparing same defect but different supercells - default is to not check for this) sc_agnostic_pdc = PointDefectComparator(check_primitive_cell=True) sc_scaled_s_struc = s_struc.copy() sc_scaled_s_struc.make_supercell([2, 2, 3]) sc_scaled_I_vac_sublatt1_ps1 = PeriodicSite( 'I', identical_I_vacs_sublattice1[0].site.coords, sc_scaled_s_struc.lattice, coords_are_cartesian=True) sc_scaled_I_vac_sublatt1_ps2 = PeriodicSite( 'I', identical_I_vacs_sublattice1[1].site.coords, sc_scaled_s_struc.lattice, coords_are_cartesian=True) sc_scaled_I_vac_sublatt2_ps = PeriodicSite( 'I', identical_I_vacs_sublattice2[1].site.coords, sc_scaled_s_struc.lattice, coords_are_cartesian=True) sc_scaled_I_vac_sublatt1_defect1 = Vacancy( sc_scaled_s_struc, sc_scaled_I_vac_sublatt1_ps1) sc_scaled_I_vac_sublatt1_defect2 = Vacancy( sc_scaled_s_struc, sc_scaled_I_vac_sublatt1_ps2) sc_scaled_I_vac_sublatt2_defect = Vacancy(sc_scaled_s_struc, sc_scaled_I_vac_sublatt2_ps) self.assertFalse( pdc.are_equal( identical_I_vacs_sublattice1[ 0], # trivially same defect site but between different supercells sc_scaled_I_vac_sublatt1_defect1)) self.assertTrue( sc_agnostic_pdc.are_equal(identical_I_vacs_sublattice1[0], sc_scaled_I_vac_sublatt1_defect1)) self.assertFalse( pdc.are_equal( identical_I_vacs_sublattice1[ 1], # same coords, different lattice structure sc_scaled_I_vac_sublatt1_defect1)) self.assertTrue( sc_agnostic_pdc.are_equal(identical_I_vacs_sublattice1[1], sc_scaled_I_vac_sublatt1_defect1)) self.assertFalse( pdc.are_equal( identical_I_vacs_sublattice1[ 0], # same sublattice, different coords sc_scaled_I_vac_sublatt1_defect2)) self.assertTrue( sc_agnostic_pdc.are_equal(identical_I_vacs_sublattice1[0], sc_scaled_I_vac_sublatt1_defect2)) self.assertFalse( sc_agnostic_pdc.are_equal( identical_I_vacs_sublattice1[ 0], # different defects (wrong sublattice) sc_scaled_I_vac_sublatt2_defect)) # test same structure size, but scaled lattice volume # (default is to not allow these to be equal, but check_lattice_scale=True allows for this) vol_agnostic_pdc = PointDefectComparator(check_lattice_scale=True) vol_scaled_s_struc = s_struc.copy() vol_scaled_s_struc.scale_lattice(s_struc.volume * 0.95) vol_scaled_I_vac_sublatt1_defect1 = Vacancy(vol_scaled_s_struc, vol_scaled_s_struc[4]) vol_scaled_I_vac_sublatt1_defect2 = Vacancy(vol_scaled_s_struc, vol_scaled_s_struc[5]) vol_scaled_I_vac_sublatt2_defect = Vacancy(vol_scaled_s_struc, vol_scaled_s_struc[6]) self.assertFalse( pdc.are_equal( identical_I_vacs_sublattice1[ 0], # trivially same defect (but vol change) vol_scaled_I_vac_sublatt1_defect1)) self.assertTrue( vol_agnostic_pdc.are_equal(identical_I_vacs_sublattice1[0], vol_scaled_I_vac_sublatt1_defect1)) self.assertFalse( pdc.are_equal( identical_I_vacs_sublattice1[ 0], # same defect, different sublattice point (and vol change) vol_scaled_I_vac_sublatt1_defect2)) self.assertTrue( vol_agnostic_pdc.are_equal(identical_I_vacs_sublattice1[0], vol_scaled_I_vac_sublatt1_defect2)) self.assertFalse( vol_agnostic_pdc.are_equal( identical_I_vacs_sublattice1[ 0], # different defect (wrong sublattice) vol_scaled_I_vac_sublatt2_defect)) # test identical defect which has had entire lattice shifted shift_s_struc = s_struc.copy() shift_s_struc.translate_sites(range(len(s_struc)), [0.2, 0.3, 0.4], frac_coords=True, to_unit_cell=True) shifted_identical_Cs_vacs = [ Vacancy(shift_s_struc, shift_s_struc[0]), Vacancy(shift_s_struc, shift_s_struc[1]) ] self.assertTrue( pdc.are_equal( identical_Cs_vacs[0], # trivially same defect (but shifted) shifted_identical_Cs_vacs[0])) self.assertTrue( pdc.are_equal( identical_Cs_vacs[ 0], # same defect on different sublattice point (and shifted) shifted_identical_Cs_vacs[1])) # test uniform lattice shift within non-symmorphic structure shift_ns_struc = ns_struc.copy() shift_ns_struc.translate_sites(range(len(ns_struc)), [0., 0.6, 0.3], frac_coords=True, to_unit_cell=True) shift_ns_inter_H_sublattice1_set1 = PeriodicSite( 'H', ns_inter_H_sublattice1_set1.frac_coords + [0., 0.6, 0.3], shift_ns_struc.lattice) shift_ns_inter_H_sublattice1_set2 = PeriodicSite( 'H', ns_inter_H_sublattice1_set2.frac_coords + [0., 0.6, 0.3], shift_ns_struc.lattice) self.assertTrue( pdc.are_equal( Interstitial(ns_struc, ns_inter_H_sublattice1_set1 ), # trivially same defect (but shifted) Interstitial(shift_ns_struc, shift_ns_inter_H_sublattice1_set1))) self.assertTrue( pdc.are_equal( Interstitial(ns_struc, ns_inter_H_sublattice1_set1), # same defect on different sublattice point (and shifted) Interstitial(shift_ns_struc, shift_ns_inter_H_sublattice1_set2))) # test a rotational + supercell type structure transformation (requires check_primitive_cell=True) rotated_s_struc = s_struc.copy() rotated_s_struc.make_supercell([[2, 1, 0], [-1, 3, 0], [0, 0, 2]]) rotated_identical_Cs_vacs = [ Vacancy(rotated_s_struc, rotated_s_struc[0]), Vacancy(rotated_s_struc, rotated_s_struc[1]) ] self.assertFalse( pdc.are_equal( identical_Cs_vacs[0], # trivially same defect (but rotated) rotated_identical_Cs_vacs[0])) self.assertTrue( sc_agnostic_pdc.are_equal(identical_Cs_vacs[0], rotated_identical_Cs_vacs[0])) self.assertFalse( pdc.are_equal( identical_Cs_vacs[ 0], # same defect on different sublattice (and rotated) rotated_identical_Cs_vacs[1])) self.assertTrue( sc_agnostic_pdc.are_equal( identical_Cs_vacs[ 0], # same defect on different sublattice point (and rotated) rotated_identical_Cs_vacs[1])) # test a rotational + supercell + shift type structure transformation for non-symmorphic structure rotANDshift_ns_struc = ns_struc.copy() rotANDshift_ns_struc.translate_sites(range(len(ns_struc)), [0., 0.6, 0.3], frac_coords=True, to_unit_cell=True) rotANDshift_ns_struc.make_supercell([[2, 1, 0], [-1, 3, 0], [0, 0, 2]]) ns_vac_Cs_set1 = Vacancy(ns_struc, ns_struc[0]) rotANDshift_ns_vac_Cs_set1 = Vacancy(rotANDshift_ns_struc, rotANDshift_ns_struc[0]) rotANDshift_ns_vac_Cs_set2 = Vacancy(rotANDshift_ns_struc, rotANDshift_ns_struc[1]) self.assertTrue( sc_agnostic_pdc.are_equal( ns_vac_Cs_set1, # trivially same defect (but rotated and sublattice shifted) rotANDshift_ns_vac_Cs_set1)) self.assertTrue( sc_agnostic_pdc.are_equal( ns_vac_Cs_set1, # same defect on different sublattice point (shifted and rotated) rotANDshift_ns_vac_Cs_set2))
incar_settings['LVTOT'] = '.TRUE.' kpoints = Kpoints.gamma_automatic(kpts=(2, 2, 2)) supercell_size = 3 structure.make_supercell(supercell_size) structure_pure = structure.copy() for el in charge_states_dict: structure = structure_pure.copy() for s in structure.sites: if s.species_string == 'Na': defect_site = PeriodicSite(el, s.frac_coords, s.lattice) break substitution = Substitution(structure, defect_site) defect_site_coords = defect_site.frac_coords structure = substitution.generate_defect_structure() structure.get_sorted_structure() for charge in charge_states_dict[el]: path = os.path.join(os.getcwd(), f'{el}-substitution', f'Charged{charge}') default_inputs = DefaultInputs(structure) potcar_symbols = [] for s in default_inputs.potcar_symbols: if s != 'Na_pv': potcar_symbols.append(s) else:
def test_sublattice_generation(self): struc = PymatgenTest.get_structure("CsCl") sc_struc = struc.copy() sc_struc.make_supercell(3) # test for vacancy and sub (should not change structure) Cs_index = sc_struc.indices_from_symbol("Cs")[0] cs_vac = Vacancy(sc_struc, sc_struc[Cs_index]) decorated_cs_vac = create_saturated_interstitial_structure(cs_vac) self.assertEqual(len(decorated_cs_vac), len(sc_struc)) Cl_index = sc_struc.indices_from_symbol("Cl")[0] cl_vac = Vacancy(sc_struc, sc_struc[Cl_index]) decorated_cl_vac = create_saturated_interstitial_structure(cl_vac) self.assertEqual(len(decorated_cl_vac), len(sc_struc)) sub_site = PeriodicSite("Sr", sc_struc[Cs_index].coords, sc_struc.lattice, coords_are_cartesian=True) sub = Substitution(sc_struc, sub_site) decorated_sub = create_saturated_interstitial_structure(sub) self.assertEqual(len(decorated_sub), len(sc_struc)) # test interstitial in symmorphic structure type inter_site = PeriodicSite("H", [0., 1.05225, 2.1045], struc.lattice, coords_are_cartesian=True) # voronoi type interstitial = Interstitial(struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 14) inter_site = PeriodicSite("H", [0.10021429, 0.10021429, 2.1045], struc.lattice, coords_are_cartesian=True) # InFit type interstitial = Interstitial(struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 14) inter_site = PeriodicSite("H", [4.10878571, 1.10235714, 2.1045], struc.lattice, coords_are_cartesian=True) # InFit type interstitial = Interstitial(struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 26) inter_site = PeriodicSite( "H", [0., 0., 0.5], struc.lattice, coords_are_cartesian=False) # a reasonable guess type interstitial = Interstitial(struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 5) # test interstitial in non-symmorphic structure type # (voronoi and InFit generator of different types...) ns_struc = Structure.from_file(os.path.join(test_dir, "CuCl.cif")) inter_site = PeriodicSite("H", [0.45173594, 0.41157895, 5.6604067], ns_struc.lattice, coords_are_cartesian=True) # InFit type interstitial = Interstitial(ns_struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 40) inter_site = PeriodicSite("H", [0.47279906, 0.82845998, 5.62015285], ns_struc.lattice, coords_are_cartesian=True) # InFit type interstitial = Interstitial(ns_struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 40) inter_site = PeriodicSite("H", [0.70845255, 6.50298148, 5.16979425], ns_struc.lattice, coords_are_cartesian=True) # InFit type interstitial = Interstitial(ns_struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 40) inter_site = PeriodicSite("H", [0.98191329, 0.36460337, 4.64718203], ns_struc.lattice, coords_are_cartesian=True) # InFit type interstitial = Interstitial(ns_struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 40) inter_site = PeriodicSite("H", [0.39286561, 3.92702149, 1.05802631], ns_struc.lattice, coords_are_cartesian=True) # InFit type interstitial = Interstitial(ns_struc, inter_site) decorated_inter = create_saturated_interstitial_structure(interstitial) self.assertEqual(len(decorated_inter), 40)
def test_substitution(self): struc = PymatgenTest.get_structure("VO2") V_index = struc.indices_from_symbol("V")[0] sub_site = PeriodicSite("Sr", struc[V_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) # test generation and super cell sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.composition.as_dict(), { "V": 1, "Sr": 1, "O": 4 }) sub_struc = substitution.generate_defect_structure(2) self.assertEqual(sub_struc.composition.as_dict(), { "V": 15, "Sr": 1, "O": 32 }) sub_struc = substitution.generate_defect_structure(3) self.assertEqual(sub_struc.composition.as_dict(), { "V": 53, "Sr": 1, "O": 108 }) sub_struc = substitution.generate_defect_structure([[2., 0, 0], [0, 0, -3.], [0, 2., 0]]) self.assertEqual(sub_struc.composition.as_dict(), { "V": 23, "O": 48, "Sr": 1 }) # test charge substitution = Substitution(struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 0.0) substitution = Substitution(struc, sub_site, charge=1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 1.0) substitution = Substitution(struc, sub_site, charge=-1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, -1.0) # test multiplicity substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 2.0) O_index = struc.indices_from_symbol("O")[0] sub_site = PeriodicSite("Sr", struc[O_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 4) # Test composition self.assertEqual(dict(substitution.defect_composition.as_dict()), { "V": 2, "Sr": 1, "O": 3 }) # test that structure has all velocities equal if velocities previously existed # (previously caused failures for structure printing) vel_struc = Structure( struc.lattice, struc.species, struc.frac_coords, site_properties={'velocities': [[0., 0., 0.]] * len(struc)}) substitution = Substitution(vel_struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertTrue( (np.array(sub_struc.site_properties['velocities']) == 0.).all()) self.assertEqual(len(sub_struc.site_properties['velocities']), len(sub_struc))
def test_substitution(self): struc = PymatgenTest.get_structure("VO2") V_index = struc.indices_from_symbol("V")[0] sub_site = PeriodicSite("Sr", struc[V_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) # test generation and super cell sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.composition.as_dict(), {"V": 1, "Sr": 1, "O": 4}) sub_struc = substitution.generate_defect_structure(2) self.assertEqual(sub_struc.composition.as_dict(), {"V": 15, "Sr": 1, "O": 32}) sub_struc = substitution.generate_defect_structure(3) self.assertEqual(sub_struc.composition.as_dict(), {"V": 53, "Sr": 1, "O": 108}) sub_struc = substitution.generate_defect_structure([[2., 0, 0], [0, 0, -3.], [0, 2., 0]]) self.assertEqual(sub_struc.composition.as_dict(), {"V": 23, "O": 48, "Sr": 1}) # test charge substitution = Substitution(struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 0.0) substitution = Substitution(struc, sub_site, charge=1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 1.0) substitution = Substitution(struc, sub_site, charge=-1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, -1.0) # test multiplicity substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 2.0) O_index = struc.indices_from_symbol("O")[0] sub_site = PeriodicSite("Sr", struc[O_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 4) # Test composition self.assertEqual(dict(substitution.defect_composition.as_dict()), {"V": 2, "Sr": 1, "O": 3}) # test that structure has all velocities equal if velocities previously existed # (previously caused failures for structure printing) vel_struc = Structure( struc.lattice, struc.species, struc.frac_coords, site_properties= {'velocities': [[0., 0., 0.]]*len(struc) } ) substitution = Substitution(vel_struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertTrue( (np.array(sub_struc.site_properties['velocities']) == 0.).all()) self.assertEqual( len(sub_struc.site_properties['velocities']), len(sub_struc))
def test_substitution(self): struc = PymatgenTest.get_structure("VO2") V_index = struc.indices_from_symbol("V")[0] sub_site = PeriodicSite("Sr", struc[V_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) # test generation and super cell sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.composition.as_dict(), { "V": 1, "Sr": 1, "O": 4 }) sub_struc = substitution.generate_defect_structure(2) self.assertEqual(sub_struc.composition.as_dict(), { "V": 15, "Sr": 1, "O": 32 }) sub_struc = substitution.generate_defect_structure(3) self.assertEqual(sub_struc.composition.as_dict(), { "V": 53, "Sr": 1, "O": 108 }) sub_struc = substitution.generate_defect_structure([[2., 0, 0], [0, 0, -3.], [0, 2., 0]]) self.assertEqual(sub_struc.composition.as_dict(), { "V": 23, "O": 48, "Sr": 1 }) # test charge substitution = Substitution(struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 0.0) substitution = Substitution(struc, sub_site, charge=1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 1.0) substitution = Substitution(struc, sub_site, charge=-1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, -1.0) # test multiplicity substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 2.0) O_index = struc.indices_from_symbol("O")[0] sub_site = PeriodicSite("Sr", struc[O_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 4) # Test composition self.assertEqual(dict(substitution.defect_composition.as_dict()), { "V": 2, "Sr": 1, "O": 3 }) # test that structure generation doesn't break if velocities existed previously # (previously caused failures for structure printing) vel_struc = Structure( struc.lattice, struc.species, struc.frac_coords, site_properties={'velocities': [[0., 0., 0.]] * len(struc)}) substitution = Substitution(vel_struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertTrue('velocities' not in sub_struc.site_properties) # test value error raised for site not in the structure non_site = PeriodicSite("Sr", struc[V_index].frac_coords - [0., 0., .1], struc.lattice) self.assertRaises(ValueError, Substitution, struc, non_site)
def test_substitution(self): struc = PymatgenTest.get_structure("VO2") V_index = struc.indices_from_symbol("V")[0] sub_site = PeriodicSite("Sr", struc[V_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) # test generation and super cell sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.composition.as_dict(), { "V": 1, "Sr": 1, "O": 4 }) sub_struc = substitution.generate_defect_structure(2) self.assertEqual(sub_struc.composition.as_dict(), { "V": 15, "Sr": 1, "O": 32 }) sub_struc = substitution.generate_defect_structure(3) self.assertEqual(sub_struc.composition.as_dict(), { "V": 53, "Sr": 1, "O": 108 }) sub_struc = substitution.generate_defect_structure([[2., 0, 0], [0, 0, -3.], [0, 2., 0]]) self.assertEqual(sub_struc.composition.as_dict(), { "V": 23, "O": 48, "Sr": 1 }) # test charge substitution = Substitution(struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 0.0) substitution = Substitution(struc, sub_site, charge=1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 1.0) substitution = Substitution(struc, sub_site, charge=-1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, -1.0) # test multiplicity substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 2.0) O_index = struc.indices_from_symbol("O")[0] sub_site = PeriodicSite("Sr", struc[O_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 4) # Test composoition self.assertEqual(dict(substitution.defect_composition.as_dict()), { "V": 2, "Sr": 1, "O": 3 })
def test_substitution(self): struc = PymatgenTest.get_structure("VO2") V_index = struc.indices_from_symbol("V")[0] sub_site = PeriodicSite("Sr", struc[V_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) # test generation and super cell sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.composition.as_dict(), {"V": 1, "Sr": 1, "O": 4}) sub_struc = substitution.generate_defect_structure(2) self.assertEqual(sub_struc.composition.as_dict(), {"V": 15, "Sr": 1, "O": 32}) sub_struc = substitution.generate_defect_structure(3) self.assertEqual(sub_struc.composition.as_dict(), {"V": 53, "Sr": 1, "O": 108}) sub_struc = substitution.generate_defect_structure([[2., 0, 0], [0, 0, -3.], [0, 2., 0]]) self.assertEqual(sub_struc.composition.as_dict(), {"V": 23, "O": 48, "Sr": 1}) # test charge substitution = Substitution(struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 0.0) substitution = Substitution(struc, sub_site, charge=1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 1.0) substitution = Substitution(struc, sub_site, charge=-1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, -1.0) # test multiplicity substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 2.0) O_index = struc.indices_from_symbol("O")[0] sub_site = PeriodicSite("Sr", struc[O_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 4) # Test composition self.assertEqual(dict(substitution.defect_composition.as_dict()), {"V": 2, "Sr": 1, "O": 3}) # test that structure generation doesn't break if velocities existed previously # (previously caused failures for structure printing) vel_struc = Structure( struc.lattice, struc.species, struc.frac_coords, site_properties= {'velocities': [[0., 0., 0.]]*len(struc) } ) substitution = Substitution(vel_struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertTrue( 'velocities' not in sub_struc.site_properties) # test value error raised for site not in the structure non_site = PeriodicSite( "Sr", struc[V_index].frac_coords - [0., 0., .1], struc.lattice) self.assertRaises( ValueError, Substitution, struc, non_site)
def test_substitution(self): struc = PymatgenTest.get_structure("VO2") V_index = struc.indices_from_symbol("V")[0] sub_site = PeriodicSite("Sr", struc[V_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) # test generation and super cell sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.composition.as_dict(), {"V": 1, "Sr": 1, "O": 4}) sub_struc = substitution.generate_defect_structure(2) self.assertEqual(sub_struc.composition.as_dict(), {"V": 15, "Sr": 1, "O": 32}) sub_struc = substitution.generate_defect_structure(3) self.assertEqual(sub_struc.composition.as_dict(), {"V": 53, "Sr": 1, "O": 108}) sub_struc = substitution.generate_defect_structure([[2., 0, 0], [0, 0, -3.], [0, 2., 0]]) self.assertEqual(sub_struc.composition.as_dict(), {"V": 23, "O": 48, "Sr": 1}) # test charge substitution = Substitution(struc, sub_site) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 0.0) substitution = Substitution(struc, sub_site, charge=1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, 1.0) substitution = Substitution(struc, sub_site, charge=-1.0) sub_struc = substitution.generate_defect_structure(1) self.assertEqual(sub_struc.charge, -1.0) # test multiplicity substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 2.0) O_index = struc.indices_from_symbol("O")[0] sub_site = PeriodicSite("Sr", struc[O_index].coords, struc.lattice, coords_are_cartesian=True) substitution = Substitution(struc, sub_site) self.assertEqual(substitution.multiplicity, 4) # Test composoition self.assertEqual(dict(substitution.defect_composition.as_dict()), {"V": 2, "Sr": 1, "O": 3})