def test_apply_transformation(self): l = Lattice.cubic(4) s_orig = Structure( l, [{ "Li": 0.19, "Na": 0.19, "K": 0.62 }, { "O": 1 }], [[0, 0, 0], [0.5, 0.5, 0.5]], ) dot = DiscretizeOccupanciesTransformation(max_denominator=5, tol=0.5) s = dot.apply_transformation(s_orig) self.assertEqual( dict(s[0].species), { Element("Li"): 0.2, Element("Na"): 0.2, Element("K"): 0.6 }, ) dot = DiscretizeOccupanciesTransformation(max_denominator=5, tol=0.01) self.assertRaises(RuntimeError, dot.apply_transformation, s_orig) s_orig_2 = Structure( l, [{ "Li": 0.5, "Na": 0.25, "K": 0.25 }, { "O": 1 }], [[0, 0, 0], [0.5, 0.5, 0.5]], ) dot = DiscretizeOccupanciesTransformation(max_denominator=9, tol=0.25, fix_denominator=False) s = dot.apply_transformation(s_orig_2) self.assertEqual( dict(s[0].species), { Element("Li"): Fraction(1 / 2), Element("Na"): Fraction(1 / 4), Element("K"): Fraction(1 / 4), }, ) dot = DiscretizeOccupanciesTransformation(max_denominator=9, tol=0.05, fix_denominator=True) self.assertRaises(RuntimeError, dot.apply_transformation, s_orig_2)
def test_apply_transformation(self): t = PrimitiveCellTransformation() coords = [] coords.append([0, 0, 0]) coords.append([0.375, 0.375, 0.375]) coords.append([0.5, 0.5, 0.5]) coords.append([0.875, 0.875, 0.875]) coords.append([0.125, 0.125, 0.125]) coords.append([0.25, 0.25, 0.25]) coords.append([0.625, 0.625, 0.625]) coords.append([0.75, 0.75, 0.75]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure( lattice, ["Li+", "Li+", "Li+", "Li+", "O2-", "O2-", "O2-", "O2-"], coords) s = t.apply_transformation(struct) self.assertEqual(len(s), 4) with open(os.path.join(PymatgenTest.TEST_FILES_DIR, "TiO2_super.json")) as f: s = json.load(f, cls=MontyDecoder) prim = t.apply_transformation(s) self.assertEqual(prim.formula, "Ti4 O8") d = t.as_dict() self.assertEqual(type(PrimitiveCellTransformation.from_dict(d)), PrimitiveCellTransformation)
def test_apply_transformation(self): t = DeformStructureTransformation([[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.05, 1.0]]) coords = [] coords.append([0, 0, 0]) coords.append([0.375, 0.375, 0.375]) coords.append([0.5, 0.5, 0.5]) coords.append([0.875, 0.875, 0.875]) coords.append([0.125, 0.125, 0.125]) coords.append([0.25, 0.25, 0.25]) coords.append([0.625, 0.625, 0.625]) coords.append([0.75, 0.75, 0.75]) lattice = [ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ] struct = Structure( lattice, ["Li+", "Li+", "Li+", "Li+", "O2-", "O2-", "O2-", "O2-"], coords) transformed_s = t.apply_transformation(struct) self.assertAlmostEqual(transformed_s.lattice.a, 3.84019793) self.assertAlmostEqual(transformed_s.lattice.b, 3.84379750) self.assertAlmostEqual(transformed_s.lattice.c, 3.75022981) d = json.loads(json.dumps(t.as_dict())) self.assertEqual( type(DeformStructureTransformation.from_dict(d)), DeformStructureTransformation, )
def setUp(self): coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.5, 0.75]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) self.struct = Structure(lattice, ["Si"] * 2, coords)
def test_no_oxidation(self): specie = {"Cu1+": 0.5, "Au2+": 0.5} cuau = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.677), [specie], [[0, 0, 0]]) trans = OrderDisorderedStructureTransformation() ss = trans.apply_transformation(cuau, return_ranked_list=100) self.assertEqual(ss[0]["structure"].composition["Cu+"], 2) trans = OrderDisorderedStructureTransformation(no_oxi_states=True) ss = trans.apply_transformation(cuau, return_ranked_list=100) self.assertEqual(ss[0]["structure"].composition["Cu+"], 0) self.assertEqual(ss[0]["structure"].composition["Cu"], 2)
def test_apply_transformation(self): t = ConventionalCellTransformation() coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure(lattice, ["Li+", "Li+", "O2-", "O2-"], coords) conventional_struct = t.apply_transformation(struct) self.assertEqual(conventional_struct.lattice.alpha, 90)
def test_too_small_cell(self): t = OrderDisorderedStructureTransformation() coords = [] coords.append([0.5, 0.5, 0.5]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure(lattice, [{ "X4+": 0.33, "O2-": 0.33, "P5+": 0.33 }], coords) self.assertRaises(ValueError, t.apply_transformation, struct)
def test_apply_transformation(self): t = SubstitutionTransformation({"Li+": "Na+", "O2-": "S2-"}) coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure(lattice, ["Li+", "Li+", "O2-", "O2-"], coords) s = t.apply_transformation(struct) self.assertEqual(s.composition.formula, "Na2 S2")
def test_apply_transformation(self): l = Lattice.cubic(4) s_orig = Structure( l, [{ "Li": 0.19, "Na": 0.19, "K": 0.62 }, { "O": 1 }], [[0, 0, 0], [0.5, 0.5, 0.5]], ) cct = ChargedCellTransformation(charge=3) s = cct.apply_transformation(s_orig) self.assertEqual(s.charge, 3)
def test_apply_transformation(self): # Test on slab relaxation where volume is fixed f = os.path.join(PymatgenTest.TEST_FILES_DIR, "surface_tests") Cu_fin = Structure.from_file(os.path.join(f, "Cu_slab_fin.cif")) Cu_init = Structure.from_file(os.path.join(f, "Cu_slab_init.cif")) slab_scaling = ScaleToRelaxedTransformation(Cu_init, Cu_fin) Au_init = Structure.from_file(os.path.join(f, "Au_slab_init.cif")) Au_fin = slab_scaling.apply_transformation(Au_init) self.assertAlmostEqual(Au_fin.lattice.volume, Au_init.lattice.volume) # Test on gb relaxation f = os.path.join(PymatgenTest.TEST_FILES_DIR, "grain_boundary") Be_fin = Structure.from_file(os.path.join(f, "Be_gb_fin.cif")) Be_init = Structure.from_file(os.path.join(f, "Be_gb_init.cif")) Zn_init = Structure.from_file(os.path.join(f, "Zn_gb_init.cif")) gb_scaling = ScaleToRelaxedTransformation(Be_init, Be_fin) Zn_fin = gb_scaling.apply_transformation(Zn_init) self.assertTrue(all([site.species_string == "Zn" for site in Zn_fin])) self.assertEqual(Be_init.lattice.a < Be_fin.lattice.a, Zn_init.lattice.a < Zn_fin.lattice.a) self.assertEqual(Be_init.lattice.b < Be_fin.lattice.b, Zn_init.lattice.b < Zn_fin.lattice.b) self.assertEqual(Be_init.lattice.c < Be_fin.lattice.c, Zn_init.lattice.c < Zn_fin.lattice.c) Fe_fin = Structure.from_file(os.path.join(f, "Fe_gb_fin.cif")) Fe_init = Structure.from_file(os.path.join(f, "Fe_gb_init.cif")) Mo_init = Structure.from_file(os.path.join(f, "Mo_gb_init.cif")) gb_scaling = ScaleToRelaxedTransformation(Fe_init, Fe_fin) Mo_fin = gb_scaling.apply_transformation(Mo_init) self.assertTrue(all([site.species_string == "Mo" for site in Mo_fin])) self.assertEqual(Fe_init.lattice.a < Fe_fin.lattice.a, Mo_init.lattice.a < Mo_fin.lattice.a) self.assertEqual(Fe_init.lattice.b < Fe_fin.lattice.b, Mo_init.lattice.b < Mo_fin.lattice.b) self.assertEqual(Fe_init.lattice.c < Fe_fin.lattice.c, Mo_init.lattice.c < Mo_fin.lattice.c)
def test_apply_transformation(self): t = RemoveSpeciesTransformation(["Li+"]) coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure(lattice, ["Li+", "Li+", "O2-", "O2-"], coords) s = t.apply_transformation(struct) self.assertEqual(s.composition.formula, "O2") d = t.as_dict() self.assertEqual(type(RemoveSpeciesTransformation.from_dict(d)), RemoveSpeciesTransformation)
def test_apply_transformation(self): t = PartialRemoveSpecieTransformation("Li+", 1.0 / 3, 3) coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure(lattice, ["Li+", "Li+", "Li+", "O2-"], coords) self.assertEqual(len(t.apply_transformation(struct, 100)), 2) d = t.as_dict() self.assertEqual( type(PartialRemoveSpecieTransformation.from_dict(d)), PartialRemoveSpecieTransformation, )
def test_apply_transformation(self): t = PerturbStructureTransformation(0.05) coords = [] coords.append([0, 0, 0]) coords.append([0.375, 0.375, 0.375]) coords.append([0.5, 0.5, 0.5]) coords.append([0.875, 0.875, 0.875]) coords.append([0.125, 0.125, 0.125]) coords.append([0.25, 0.25, 0.25]) coords.append([0.625, 0.625, 0.625]) coords.append([0.75, 0.75, 0.75]) lattice = [ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ] struct = Structure( lattice, ["Li+", "Li+", "Li+", "Li+", "O2-", "O2-", "O2-", "O2-"], coords) transformed_s = t.apply_transformation(struct) for i, site in enumerate(transformed_s): self.assertAlmostEqual(site.distance(struct[i]), 0.05) d = t.as_dict() self.assertEqual( type(PerturbStructureTransformation.from_dict(d)), PerturbStructureTransformation, ) t2 = PerturbStructureTransformation(0.05, 0) transformed_s2 = t2.apply_transformation(struct) for i, site in enumerate(transformed_s2): self.assertLessEqual(site.distance(struct[i]), 0.05) self.assertGreaterEqual(site.distance(struct[i]), 0) d = t2.as_dict() self.assertEqual( type(PerturbStructureTransformation.from_dict(d)), PerturbStructureTransformation, )
def test_best_first(self): t = OrderDisorderedStructureTransformation(algo=2) coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure( lattice, [ { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, ], coords, ) output = t.apply_transformation(struct, return_ranked_list=3) self.assertAlmostEqual(output[0]["energy"], -234.57813667648315, 4)
def test_apply_transformation_fast(self): t = PartialRemoveSpecieTransformation("Li+", 0.5) coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) coords.append([0.1, 0.1, 0.1]) coords.append([0.3, 0.75, 0.3]) lattice = Lattice([[10, 0.00, 0.00], [0, 10, 0.00], [0.00, 0, 10]]) struct = Structure(lattice, ["Li+"] * 6, coords) fast_opt_s = t.apply_transformation(struct) t = PartialRemoveSpecieTransformation( "Li+", 0.5, PartialRemoveSpecieTransformation.ALGO_COMPLETE) slow_opt_s = t.apply_transformation(struct) self.assertAlmostEqual( EwaldSummation(fast_opt_s).total_energy, EwaldSummation(slow_opt_s).total_energy, 4, ) self.assertEqual(fast_opt_s, slow_opt_s)
def test_symmetrized_structure(self): t = OrderDisorderedStructureTransformation(symmetrized_structures=True) c = [] sp = [] c.append([0.5, 0.5, 0.5]) sp.append("Si4+") c.append([0.45, 0.45, 0.45]) sp.append({"Si4+": 0.5}) c.append([0.56, 0.56, 0.56]) sp.append({"Si4+": 0.5}) c.append([0.25, 0.75, 0.75]) sp.append({"Si4+": 0.5}) c.append([0.75, 0.25, 0.25]) sp.append({"Si4+": 0.5}) l = Lattice.cubic(5) s = Structure(l, sp, c) test_site = PeriodicSite("Si4+", c[2], l) s = SymmetrizedStructure(s, "not_real", [0, 1, 1, 2, 2], ["a", "b", "b", "c", "c"]) output = t.apply_transformation(s) self.assertTrue(test_site in output.sites)
def test_apply_transformation(self): t = OxidationStateDecorationTransformation({"Li": 1, "O": -2}) coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure(lattice, ["Li", "Li", "O", "O"], coords) s = t.apply_transformation(struct) self.assertEqual(s[0].species_string, "Li+") self.assertEqual(s[2].species_string, "O2-") d = t.as_dict() self.assertEqual( type(OxidationStateDecorationTransformation.from_dict(d)), OxidationStateDecorationTransformation, )
def test_fractional_substitution(self): t = SubstitutionTransformation({ "Li+": "Na+", "O2-": { "S2-": 0.5, "Se2-": 0.5 } }) # test the to and from dict on the nested dictionary t = SubstitutionTransformation.from_dict(t.as_dict()) coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure(lattice, ["Li+", "Li+", "O2-", "O2-"], coords) s = t.apply_transformation(struct) self.assertEqual(s.composition.formula, "Na2 Se1 S1")
def test_apply_transformation(self): t = OrderDisorderedStructureTransformation() coords = [] coords.append([0, 0, 0]) coords.append([0.75, 0.75, 0.75]) coords.append([0.5, 0.5, 0.5]) coords.append([0.25, 0.25, 0.25]) lattice = Lattice([ [3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603], ]) struct = Structure( lattice, [ { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, { "Si4+": 0.5, "O2-": 0.25, "P5+": 0.25 }, ], coords, ) output = t.apply_transformation(struct, return_ranked_list=50) self.assertEqual(len(output), 12) self.assertIsInstance(output[0]["structure"], Structure) struct = Structure( lattice, [ { "Si4+": 0.5 }, { "Si4+": 0.5 }, { "P5+": 0.5, "O2-": 0.5 }, { "P5+": 0.5, "O2-": 0.5 }, ], coords, ) output = t.apply_transformation(struct, return_ranked_list=50) self.assertIsInstance(output, list) self.assertEqual(len(output), 4) self.assertEqual(t.lowest_energy_structure, output[0]["structure"]) struct = Structure(lattice, [{ "Si4+": 0.5 }, { "Si4+": 0.5 }, { "O2-": 0.5 }, { "O2-": 0.5 }], coords) allstructs = t.apply_transformation(struct, 50) self.assertEqual(len(allstructs), 4) struct = Structure(lattice, [{ "Si4+": 0.333 }, { "Si4+": 0.333 }, { "Si4+": 0.333 }, "O2-"], coords) allstructs = t.apply_transformation(struct, 50) self.assertEqual(len(allstructs), 3) d = t.as_dict() self.assertEqual( type(OrderDisorderedStructureTransformation.from_dict(d)), OrderDisorderedStructureTransformation, )