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})
