def setUp(self):
self.structure = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.5),
["Ni"], [[0, 0, 0]])
lattice = Lattice.cubic(3.010)
frac_coords = [
[0.00000, 0.00000, 0.00000],
[0.00000, 0.50000, 0.50000],
[0.50000, 0.00000, 0.50000],
[0.50000, 0.50000, 0.00000],
[0.50000, 0.00000, 0.00000],
[0.50000, 0.50000, 0.50000],
[0.00000, 0.00000, 0.50000],
[0.00000, 0.50000, 0.00000],
]
species = ["Mg", "Mg", "Mg", "Mg", "O", "O", "O", "O"]
self.MgO = Structure(lattice, species, frac_coords)
slabs = generate_all_slabs(
self.structure,
max_index=2,
min_slab_size=6.0,
min_vacuum_size=15.0,
max_normal_search=1,
center_slab=True,
)
self.slab_dict = {
"".join([str(i) for i in slab.miller_index]): slab
for slab in slabs
}
self.asf_211 = AdsorbateSiteFinder(self.slab_dict["211"])
self.asf_100 = AdsorbateSiteFinder(self.slab_dict["100"])
self.asf_111 = AdsorbateSiteFinder(self.slab_dict["111"])
self.asf_110 = AdsorbateSiteFinder(self.slab_dict["110"])
self.asf_struct = AdsorbateSiteFinder(
Structure.from_sites(self.slab_dict["111"].sites))
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_make_single_defect_energy(mocker):
perfect = mocker.Mock(CalcResults, autospec=True)
perfect.energy = 1.0
perfect.structure = IStructure(Lattice.cubic(1), ["H"] * 2, [[0] * 3] * 2)
defect = mocker.Mock(CalcResults, autospec=True)
defect.energy = 3.0
defect.structure = IStructure(Lattice.cubic(1), ["H"], [[0] * 3])
name, charge = "Va_H1", 5
defect_entry = mocker.Mock(DefectEntry, autospec=True)
defect_entry.name = name
defect_entry.charge = charge
single_defect_energy = \
make_single_defect_energy(perfect=perfect,
defect=defect,
defect_entry=defect_entry,
abs_chem_pot={Element.H: 100},
correction=ManualCorrection(7.0))
energy = 3.0 - 1.0 + 100
assert isinstance(single_defect_energy, SingleDefectEnergy)
assert single_defect_energy == SingleDefectEnergy(name, charge, energy,
7.0)
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 setUp(self):
self.structure = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.5),
["Ni"], [[0, 0, 0]])
lattice = Lattice.cubic(3.010)
frac_coords = [[0.00000, 0.00000, 0.00000],
[0.00000, 0.50000, 0.50000],
[0.50000, 0.00000, 0.50000],
[0.50000, 0.50000, 0.00000],
[0.50000, 0.00000, 0.00000],
[0.50000, 0.50000, 0.50000],
[0.00000, 0.00000, 0.50000],
[0.00000, 0.50000, 0.00000]]
species = ['Mg', 'Mg', 'Mg', 'Mg', 'O', 'O', 'O', 'O']
self.MgO = Structure(lattice, species, frac_coords)
slabs = generate_all_slabs(self.structure, max_index=2,
min_slab_size=6.0, min_vacuum_size=15.0,
max_normal_search=1, center_slab=True)
self.slab_dict = {''.join([str(i) for i in slab.miller_index]):
slab for slab in slabs}
self.asf_211 = AdsorbateSiteFinder(self.slab_dict["211"])
self.asf_100 = AdsorbateSiteFinder(self.slab_dict["100"])
self.asf_111 = AdsorbateSiteFinder(self.slab_dict["111"])
self.asf_110 = AdsorbateSiteFinder(self.slab_dict["110"])
self.asf_struct = AdsorbateSiteFinder(
Structure.from_sites(self.slab_dict["111"].sites))
def structure_analyzer():
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]
])
# add [0.1, -0.1, 0]
# 3rd -- 6th
# [0.85, 0.65, 0.25] - [0.76, 0.73, 0.24] = [0.09, -0.08, 0.01]
# [0.85, 0.15, 0.75] - [0.75, 0.25, 0.73] = [0.10, -0.10, 0.02]
# [0.1, -0.1, 0] -[0.1, -0.1, 0] = [0, 0, 0]
# [0.6, 0.4, 0.5] - [0.5, 0.5, 0.5] = [0.1, -0.1, 0]
cu2o_defect = IStructure(
Lattice.cubic(5),
species=["Cu"] * 3 + ["O"] * 2 + ["H"],
coords=[
[0.25, 0.5, 0.5], # defect
[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
]) # defect
return DefectStructureComparator(defect_structure=cu2o_defect,
perfect_structure=cu2o_perfect)
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=structure_info.defect_type,
symm_relation=structure_info.symm_relation)
expected = CalcSummary({"Va_O1_1": single_summary})
assert actual == expected
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 get_unit_cell(self, 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 setUp(self):
self.structure1 = Structure.from_spacegroup("Fd-3m", Lattice.cubic(5.46873),
["Si"], [[0, 0, 0]])
self.structure2 = Structure.from_spacegroup("Fm-3m", Lattice.cubic(5.69169),
['Na', 'Cl'], [[0, 0, 0], [0, 0, 0.5]])
self.structure3 = Structure.from_spacegroup("Pm-3m", Lattice.cubic(3.88947),
['Ca', 'Ti', 'O'], [[0.5, 0.5, 0.5], [0, 0, 0], [0, 0, 0.5]])
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 test_validate(self):
s1 = Structure(Lattice.cubic(3.61), ['Mo', 'Mo'],
[[0., 0., 0.], [0.5, 0.5, 0.5]])
s2 = Structure(Lattice.cubic(3.61), ['Mo', 'Mo'],
[[0., 0., 0.], [0.6, 0.6, 0.5]])
s3 = Structure(Lattice.cubic(3.1), ['Mo', 'Mo'],
[[0., 0., 0.], [0.6, 0.6, 0.5]])
self.assertTrue(validate_structures([s1, s2]))
self.assertFalse(validate_structures([s1, s3]))
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 setUp(self):
self.unary_struct = Structure.from_spacegroup('Im-3m',
Lattice.cubic(3.4268),
[{
"Li": 1
}], [[0, 0, 0]])
self.binary_struct = Structure.from_spacegroup(
225, Lattice.cubic(5.69169), ['Na', 'Cl'],
[[0, 0, 0], [0, 0, 0.5]])
self.describer = SOAPDescriptor(cutoff=4.8, l_max=8, n_max=8)
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 setUp(self):
self.unary_struct = Structure.from_spacegroup("Im-3m",
Lattice.cubic(3.4268),
["Li"], [[0, 0, 0]])
self.binary_struct = Structure.from_spacegroup(
"Fm-3m", Lattice.cubic(5.69169), ['Na', 'Cl'],
[[0, 0, 0], [0, 0, 0.5]])
self.describer = SmoothOverlapAtomicPosition(cutoff=4.8,
l_max=8,
n_max=8)
def test_write_inputs(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))
fc = self.vis._process_structures(structs)[2].frac_coords
self.assertTrue(np.allclose(fc, [[0.5]*3,[0.9, 1.033333, 1.0333333]]))
def setUp(self):
self.structure1 = Structure.from_spacegroup("Fd-3m",
Lattice.cubic(5.46873),
["Si"], [[0, 0, 0]])
self.structure2 = Structure.from_spacegroup("Fm-3m",
Lattice.cubic(5.69169),
["Na", "Cl"],
[[0, 0, 0], [0, 0, 0.5]])
self.structure3 = Structure.from_spacegroup(
"Pm-3m", Lattice.cubic(3.88947), ["Ca", "Ti", "O"],
[[0.5, 0.5, 0.5], [0, 0, 0], [0, 0, 0.5]])
def test_write_inputs(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))
fc = self.vis._process_structures(structs)[2].frac_coords
self.assertTrue(
np.allclose(fc, [[0.5] * 3, [0.9, 1.033333, 1.0333333]]))
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_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):
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_and_occu), {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_and_occu), {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 setUp(self):
with open(os.path.join(test_dir, 'test_toec_data.json')) as f:
self.data_dict = json.load(f)
self.strains = [Strain(sm) for sm in self.data_dict['strains']]
self.pk_stresses = [Stress(d) for d in self.data_dict['pk_stresses']]
self.c2 = self.data_dict["C2_raw"]
self.c3 = self.data_dict["C3_raw"]
self.exp = ElasticTensorExpansion.from_voigt([self.c2, self.c3])
self.cu = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.623),
["Cu"], [[0] * 3])
indices = [(0, 0), (0, 1), (3, 3)]
values = [167.8, 113.5, 74.5]
cu_c2 = ElasticTensor.from_values_indices(values,
indices,
structure=self.cu,
populate=True)
indices = [(0, 0, 0), (0, 0, 1), (0, 1, 2), (0, 3, 3), (0, 5, 5),
(3, 4, 5)]
values = [-1507., -965., -71., -7., -901., 45.]
cu_c3 = Tensor.from_values_indices(values,
indices,
structure=self.cu,
populate=True)
self.exp_cu = ElasticTensorExpansion([cu_c2, cu_c3])
cu_c4 = Tensor.from_voigt(self.data_dict["Cu_fourth_order"])
self.exp_cu_4 = ElasticTensorExpansion([cu_c2, cu_c3, cu_c4])
warnings.simplefilter("ignore")
def test_apply_transformation(self):
trans = SubstituteSurfaceSiteTransformation("Au")
pt = Structure(Lattice.cubic(5), ["Pt"], [[0, 0, 0]]) # fictitious
slab = SlabTransformation([0, 0, 1], 20, 10).apply_transformation(pt)
out = trans.apply_transformation(slab)
self.assertEqual(out.composition.reduced_formula, "Pt3Au")
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_structure(self):
quartz = self.quartz.structure
np.testing.assert_array_almost_equal(
quartz.lattice.matrix,
[[4.913400, 0, 0], [-2.456700, 4.255129, 0], [0, 0, 5.405200]])
self.assertEqual(quartz.formula, "Si3 O6")
self.assertNotIn("molecule-ID", self.quartz.atoms.columns)
ethane = self.ethane.structure
np.testing.assert_array_almost_equal(ethane.lattice.matrix,
np.diag([10.0] * 3))
lbounds = np.array(self.ethane.box.bounds)[:, 0]
coords = self.ethane.atoms[["x", "y", "z"]].values - lbounds
np.testing.assert_array_almost_equal(ethane.cart_coords, coords)
np.testing.assert_array_almost_equal(ethane.site_properties["charge"],
self.ethane.atoms["q"])
tatb = self.tatb.structure
frac_coords = tatb.frac_coords[381]
real_frac_coords = frac_coords - np.floor(frac_coords)
np.testing.assert_array_almost_equal(
real_frac_coords, [0.01553397, 0.71487872, 0.14134139])
co = Structure.from_spacegroup(194,
Lattice.hexagonal(2.50078, 4.03333),
["Co"], [[1 / 3, 2 / 3, 1 / 4]])
ld_co = LammpsData.from_structure(co)
self.assertEqual(ld_co.structure.composition.reduced_formula, "Co")
ni = Structure.from_spacegroup(225, Lattice.cubic(3.50804), ["Ni"],
[[0, 0, 0]])
ld_ni = LammpsData.from_structure(ni)
self.assertEqual(ld_ni.structure.composition.reduced_formula, "Ni")
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 structure_analyzer_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_unordered_site(self):
s = Structure(Lattice.cubic(3), ['Mo', 'S'],
[[0, 0, 0], [0.5, 0.5, 0.5]])
udescriber = SiteElementProperty()
np.testing.assert_array_almost_equal(udescriber.transform_one(s),
np.array([[42, 16]]).T)
udescriber2 = SiteElementProperty(feature_dict={
16: [16, 16],
42: [42, 42]
})
np.testing.assert_array_almost_equal(udescriber2.transform_one(s),
np.array([[42, 42], [16, 16]]))
self.assertTrue(udescriber.describer_type == 'site')
udescriber = SiteElementProperty(output_weights=True)
vec, weight = udescriber.transform_one(s)
np.testing.assert_array_almost_equal(vec, np.array([[42, 16]]).T)
np.testing.assert_array_almost_equal(weight, np.array([1, 1]))
s2 = s.copy()
s2.replace_species({"Mo": {"S": 0.1, "Mo": 0.9}})
self.assertRaises(ValueError, udescriber2.transform_one, s2)
vec, weight = udescriber.transform_one(s2)
np.testing.assert_array_almost_equal(vec, np.array([[16, 42, 16]]).T)
np.testing.assert_array_almost_equal(weight, np.array([0.1, 0.9, 1]))
def setUp(self):
element_profile = {"Ni": {"r": 0.5, "w": 1}}
describer1 = BispectrumCoefficients(rcutfac=4.1,
twojmax=8,
element_profile=element_profile,
quadratic=False,
pot_fit=True)
model1 = SKLModel(describer=describer1, model=LinearRegression())
model1.model.coef_ = coeff
model1.model.intercept_ = intercept
snap1 = SNAPotential(model=model1)
self.ff_settings1 = snap1
describer2 = BispectrumCoefficients(rcutfac=4.1,
twojmax=8,
element_profile=element_profile,
quadratic=True,
pot_fit=True)
model2 = SKLModel(describer=describer2, model=LinearRegression())
model2.model.coef_ = coeff
model2.model.intercept_ = intercept
snap2 = SNAPotential(model=model2)
self.ff_settings2 = snap2
self.struct = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.506),
["Ni"], [[0, 0, 0]])
def setUp(self):
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)
self.NiO_AFM_111.add_spin_by_site([-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)
self.NiO_AFM_001.add_spin_by_site([-5, 5, 0, 0])
parser = CifParser(os.path.join(test_dir, 'Fe3O4.cif'))
self.Fe3O4 = parser.get_structures()[0]
trans = AutoOxiStateDecorationTransformation()
self.Fe3O4_oxi = trans.apply_transformation(self.Fe3O4)
parser = CifParser(os.path.join(test_dir, 'Li8Fe2NiCoO8.cif'))
self.Li8Fe2NiCoO8 = parser.get_structures()[0]
self.Li8Fe2NiCoO8.remove_oxidation_states()
warnings.simplefilter("ignore")
def test_sulfide_type(self):
# NaS2 -> polysulfide
latt = Lattice.tetragonal(9.59650, 11.78850)
species = ["Na"] * 2 + ["S"] * 2
coords = [[0.00000, 0.00000, 0.17000], [0.27600, 0.25000, 0.12500],
[0.03400, 0.25000, 0.29600], [0.14700, 0.11600, 0.40000]]
struct = Structure.from_spacegroup(122, latt, species, coords)
self.assertEqual(sulfide_type(struct), "polysulfide")
# NaCl type NaS -> sulfide
latt = Lattice.cubic(5.75)
species = ["Na", "S"]
coords = [[0.00000, 0.00000, 0.00000], [0.50000, 0.50000, 0.50000]]
struct = Structure.from_spacegroup(225, latt, species, coords)
self.assertEqual(sulfide_type(struct), "sulfide")
# Na2S2O3 -> None (sulfate)
latt = Lattice.monoclinic(6.40100, 8.10000, 8.47400, 96.8800)
species = ["Na"] * 2 + ["S"] * 2 + ["O"] * 3
coords = [[0.29706, 0.62396, 0.08575], [0.37673, 0.30411, 0.45416],
[0.52324, 0.10651, 0.21126], [0.29660, -0.04671, 0.26607],
[0.17577, 0.03720, 0.38049], [0.38604, -0.20144, 0.33624],
[0.16248, -0.08546, 0.11608]]
struct = Structure.from_spacegroup(14, latt, species, coords)
self.assertEqual(sulfide_type(struct), None)
# Na3PS3O -> sulfide
latt = Lattice.orthorhombic(9.51050, 11.54630, 5.93230)
species = ["Na"] * 2 + ["S"] * 2 + ["P", "O"]
coords = [[0.19920, 0.11580, 0.24950], [0.00000, 0.36840, 0.29380],
[0.32210, 0.36730, 0.22530], [0.50000, 0.11910, 0.27210],
[0.50000, 0.29400, 0.35500], [0.50000, 0.30300, 0.61140]]
struct = Structure.from_spacegroup(36, latt, species, coords)
self.assertEqual(sulfide_type(struct), "sulfide")
def setUp(self):
element_profile = {'Ni': {'r': 0.5, 'w': 1}}
describer1 = BispectrumCoefficients(rcutfac=4.1,
twojmax=8,
element_profile=element_profile,
quadratic=False,
pot_fit=True)
model1 = LinearModel(describer=describer1)
model1.model.coef_ = coeff
model1.model.intercept_ = intercept
snap1 = SNAPotential(model=model1)
snap1.specie = Element('Ni')
self.ff_settings1 = snap1
describer2 = BispectrumCoefficients(rcutfac=4.1,
twojmax=8,
element_profile=element_profile,
quadratic=True,
pot_fit=True)
model2 = LinearModel(describer=describer2)
model2.model.coef_ = coeff
model2.model.intercept_ = intercept
snap2 = SNAPotential(model=model2)
snap2.specie = Element('Ni')
self.ff_settings2 = snap2
self.struct = Structure.from_spacegroup('Fm-3m', Lattice.cubic(3.506),
['Ni'], [[0, 0, 0]])
def test_init(self):
filepath = os.path.join(test_dir, 'PROCAR.simple')
p = Procar(filepath)
self.assertAlmostEqual(p.get_occupation(0, 'd')[Spin.up], 0)
self.assertAlmostEqual(
p.get_occupation(0, 's')[Spin.up], 0.35381249999999997)
self.assertAlmostEqual(p.get_occupation(0, 'p')[Spin.up], 1.19540625)
self.assertRaises(ValueError, p.get_occupation, 1, 'm')
self.assertEqual(p.nbands, 10)
self.assertEqual(p.nkpoints, 10)
self.assertEqual(p.nions, 3)
lat = Lattice.cubic(3.)
s = Structure(lat, ["Li", "Na", "K"],
[[0., 0., 0.], [0.25, 0.25, 0.25], [0.75, 0.75, 0.75]])
d = p.get_projection_on_elements(s)
self.assertAlmostEqual(d[Spin.up][2][2], {
'Na': 0.042,
'K': 0.646,
'Li': 0.042
})
filepath = os.path.join(test_dir, 'PROCAR')
p = Procar(filepath)
self.assertAlmostEqual(
p.get_occupation(0, 'dxy')[Spin.up], 0.96214813853000025)
self.assertAlmostEqual(
p.get_occupation(0, 'dxy')[Spin.down], 0.85796295426000124)
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_structure(self):
quartz = self.quartz.structure
np.testing.assert_array_equal(quartz.lattice.matrix,
[[4.913400, 0, 0],
[-2.456700, 4.255129, 0],
[0, 0, 5.405200]])
self.assertEqual(quartz.formula, "Si3 O6")
self.assertNotIn("molecule-ID", self.quartz.atoms.columns)
ethane = self.ethane.structure
np.testing.assert_array_equal(ethane.lattice.matrix,
np.diag([10.0] * 3))
lbounds = np.array(self.ethane.box.bounds)[:, 0]
coords = self.ethane.atoms[["x", "y", "z"]].values - lbounds
np.testing.assert_array_equal(ethane.cart_coords, coords)
np.testing.assert_array_equal(ethane.site_properties["charge"],
self.ethane.atoms["q"])
tatb = self.tatb.structure
frac_coords = tatb.frac_coords[381]
real_frac_coords = frac_coords - np.floor(frac_coords)
np.testing.assert_array_almost_equal(real_frac_coords,
[0.01553397,
0.71487872,
0.14134139])
co = Structure.from_spacegroup(194,
Lattice.hexagonal(2.50078, 4.03333),
["Co"], [[1/3, 2/3, 1/4]])
ld_co = LammpsData.from_structure(co)
self.assertEqual(ld_co.structure.composition.reduced_formula, "Co")
ni = Structure.from_spacegroup(225, Lattice.cubic(3.50804),
["Ni"], [[0, 0, 0]])
ld_ni = LammpsData.from_structure(ni)
self.assertEqual(ld_ni.structure.composition.reduced_formula, "Ni")
def test_max_disordered_sites(self):
l = Lattice.cubic(4)
s_orig = Structure(l, [{"Li": 0.2, "Na": 0.2, "K": 0.6}, {"O": 1}],
[[0, 0, 0], [0.5, 0.5, 0.5]])
est = EnumerateStructureTransformation(max_cell_size=None,
max_disordered_sites=5)
s = est.apply_transformation(s_orig)
self.assertEqual(len(s), 8)
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_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_max_disordered_sites(self):
l = Lattice.cubic(4)
s_orig = Structure(l, [{"Li": 0.2, "Na": 0.2, "K": 0.6}, {"O": 1}],
[[0, 0, 0], [0.5, 0.5, 0.5]])
est = EnumerateStructureTransformation(max_cell_size=None,
max_disordered_sites=5)
dd = est.apply_transformation(s_orig, return_ranked_list=100)
self.assertEqual(len(dd), 9)
for d in dd:
self.assertEqual(len(d["structure"]), 10)
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_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_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_properties(self):
self.assertEqual(self.kpoint.frac_coords[0], 0.1)
self.assertEqual(self.kpoint.frac_coords[1], 0.4)
self.assertEqual(self.kpoint.frac_coords[2], -0.5)
self.assertEqual(self.kpoint.a, 0.1)
self.assertEqual(self.kpoint.b, 0.4)
self.assertEqual(self.kpoint.c, -0.5)
self.assertEqual(self.lattice, Lattice.cubic(10.0))
self.assertEqual(self.kpoint.cart_coords[0], 1.0)
self.assertEqual(self.kpoint.cart_coords[1], 4.0)
self.assertEqual(self.kpoint.cart_coords[2], -5.0)
self.assertEqual(self.kpoint.label, "X")
def setUp(self):
self.structure = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.5),
["Ni"], [[0, 0, 0]])
slabs = generate_all_slabs(self.structure, max_index=2,
min_slab_size=6.0, min_vacuum_size=15.0,
max_normal_search=1, center_slab=True)
self.slab_dict = {''.join([str(i) for i in slab.miller_index]):
slab for slab in slabs}
self.asf_211 = AdsorbateSiteFinder(self.slab_dict["211"])
self.asf_100 = AdsorbateSiteFinder(self.slab_dict["100"])
self.asf_111 = AdsorbateSiteFinder(self.slab_dict["111"])
self.asf_110 = AdsorbateSiteFinder(self.slab_dict["110"])
def setUp(self):
super(TestAdsorptionWorkflow, self).setUp()
self.struct_ir = Structure.from_spacegroup(
"Fm-3m", Lattice.cubic(3.875728), ["Ir"], [[0, 0, 0]])
sgp = {"max_index": 1, "min_slab_size": 7.0, "min_vacuum_size": 20.0}
self.slabs = generate_all_slabs(self.struct_ir, **sgp)
self.slab_100 = [slab for slab in self.slabs
if slab.miller_index==(1, 0, 0)][0]
self.wf_1 = get_wf_slab(self.slab_100, True,
[Molecule("H", [[0, 0, 0]])],
db_file=os.path.join(db_dir, "db.json"))
def setUp(self):
# 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))
# 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 as 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(os.path.dirname(__file__), "..", "..", "..",
'test_files/critic2/MoS2_critic2_stdout.txt')
with open(stdout_file, 'r') as f:
reference_stdout = f.read()
self.structure = Structure.from_file(os.path.join(os.path.dirname(__file__), "..", "..", "..",
'test_files/critic2/MoS2.cif'))
c2o = Critic2Output(self.structure, reference_stdout)
self.mos2_sg = c2o.structure_graph(edge_weight="bond_length", edge_weight_units="Å")
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()
def test_apply_transformation(self):
Li_bulk = Structure.from_spacegroup("Im-3m", Lattice.cubic(2.96771),
["Li"], [[0, 0, 0]])
gb_gen_params_s3 = {"rotation_axis": [1, 1, 1], "rotation_angle": 60.0,
"expand_times": 2, "vacuum_thickness": 0.0, "normal": True,
"ratio": None, "plane": None}
gbg = GBGenerator(Li_bulk)
gb_from_generator = gbg.gb_from_parameters(**gb_gen_params_s3)
gbt_s3 = GrainBoundaryTransformation(**gb_gen_params_s3)
gb_from_trans = gbt_s3.apply_transformation(Li_bulk)
self.assertArrayAlmostEqual(gb_from_generator.lattice.matrix,
gb_from_trans.lattice.matrix)
self.assertArrayAlmostEqual(gb_from_generator.cart_coords,
gb_from_trans.cart_coords)
def test_md(self):
s = Structure.from_spacegroup(225, Lattice.cubic(3.62126),
["Cu"], [[0, 0, 0]])
ld = LammpsData.from_structure(s, atom_style="atomic")
ff = "\n".join(["pair_style eam", "pair_coeff * * Cu_u3.eam"])
md = LammpsRun.md(data=ld, force_field=ff, temperature=1600.0,
nsteps=10000)
md.write_inputs(output_dir="md")
with open(os.path.join("md", "in.md")) as f:
md_script = f.read()
script_string = """# Sample input script template for MD
# Initialization
units metal
atom_style atomic
# Atom definition
read_data md.data
#read_restart md.restart
# Force field settings (consult official document for detailed formats)
pair_style eam
pair_coeff * * Cu_u3.eam
# Create velocities
velocity all create 1600.0 142857 mom yes rot yes dist gaussian
# Ensemble constraints
#fix 1 all nve
fix 1 all nvt temp 1600.0 1600.0 0.1
#fix 1 all npt temp 1600.0 1600.0 0.1 iso $pressure $pressure 1.0
# Various operations within timestepping
#fix ...
#compute ...
# Output settings
#thermo_style custom ... # control the thermo data type to output
thermo 100 # output thermo data every N steps
#dump 1 all atom 100 traj.*.gz # dump a snapshot every 100 steps
# Actions
run 10000
"""
self.assertEqual(md_script, script_string)
self.assertTrue(os.path.exists(os.path.join("md", "md.data")))
def test_sulfide_type(self):
# NaS2 -> polysulfide
latt = Lattice.tetragonal(9.59650, 11.78850)
species = ["Na"] * 2 + ["S"] * 2
coords = [[0.00000, 0.00000, 0.17000],
[0.27600, 0.25000, 0.12500],
[0.03400, 0.25000, 0.29600],
[0.14700, 0.11600, 0.40000]]
struct = Structure.from_spacegroup(122, latt, species, coords)
self.assertEqual(sulfide_type(struct), "polysulfide")
# NaCl type NaS -> sulfide
latt = Lattice.cubic(5.75)
species = ["Na", "S"]
coords = [[0.00000, 0.00000, 0.00000],
[0.50000, 0.50000, 0.50000]]
struct = Structure.from_spacegroup(225, latt, species, coords)
self.assertEqual(sulfide_type(struct), "sulfide")
# Na2S2O3 -> None (sulfate)
latt = Lattice.monoclinic(6.40100, 8.10000, 8.47400, 96.8800)
species = ["Na"] * 2 + ["S"] * 2 + ["O"] * 3
coords = [[0.29706, 0.62396, 0.08575],
[0.37673, 0.30411, 0.45416],
[0.52324, 0.10651, 0.21126],
[0.29660, -0.04671, 0.26607],
[0.17577, 0.03720, 0.38049],
[0.38604, -0.20144, 0.33624],
[0.16248, -0.08546, 0.11608]]
struct = Structure.from_spacegroup(14, latt, species, coords)
self.assertEqual(sulfide_type(struct), None)
# Na3PS3O -> sulfide
latt = Lattice.orthorhombic(9.51050, 11.54630, 5.93230)
species = ["Na"] * 2 + ["S"] * 2 + ["P", "O"]
coords = [[0.19920, 0.11580, 0.24950],
[0.00000, 0.36840, 0.29380],
[0.32210, 0.36730, 0.22530],
[0.50000, 0.11910, 0.27210],
[0.50000, 0.29400, 0.35500],
[0.50000, 0.30300, 0.61140]]
struct = Structure.from_spacegroup(36, latt, species, coords)
self.assertEqual(sulfide_type(struct), "sulfide")
# test for unphysical cells
struct.scale_lattice(struct.volume*10)
self.assertEqual(sulfide_type(struct), "sulfide")
def test_init(self):
filepath = os.path.join(test_dir, "PROCAR.simple")
p = Procar(filepath)
self.assertAlmostEqual(p.get_occupation(0, "d")[Spin.up], 0)
self.assertAlmostEqual(p.get_occupation(0, "s")[Spin.up], 0.35381249999999997)
self.assertAlmostEqual(p.get_occupation(0, "p")[Spin.up], 1.19540625)
self.assertRaises(ValueError, p.get_occupation, 1, "m")
self.assertEqual(p.nbands, 10)
self.assertEqual(p.nkpoints, 10)
self.assertEqual(p.nions, 3)
lat = Lattice.cubic(3.0)
s = Structure(lat, ["Li", "Na", "K"], [[0.0, 0.0, 0.0], [0.25, 0.25, 0.25], [0.75, 0.75, 0.75]])
d = p.get_projection_on_elements(s)
self.assertAlmostEqual(d[Spin.up][2][2], {"Na": 0.042, "K": 0.646, "Li": 0.042})
filepath = os.path.join(test_dir, "PROCAR")
p = Procar(filepath)
self.assertAlmostEqual(p.get_occupation(0, "dxy")[Spin.up], 0.96214813853000025)
self.assertAlmostEqual(p.get_occupation(0, "dxy")[Spin.down], 0.85796295426000124)
def test_cluster(self):
lattice = Lattice.cubic(4)
pts = []
initial = [[0, 0, 0], [0.5, 0.5, 0.5], [0.25, 0.25, 0.25], [0.5, 0, 0]]
for c in initial:
for i in range(100):
pts.append(np.array(c) + np.random.randn(3) * 0.01 +
np.random.randint(3))
pts = np.array(pts)
k = KmeansPBC(lattice)
centroids, labels, ss = k.cluster(pts, 4)
for c1 in centroids:
found = False
for c2 in centroids:
if np.allclose(pbc_diff(c1, c2), [0, 0, 0], atol=0.1):
found = True
break
self.assertTrue(found)
def test_init(self):
filepath = os.path.join(test_dir, 'PROCAR.simple')
p = Procar(filepath)
self.assertAlmostEqual(p.get_occupation(1, 'd'), 0)
self.assertAlmostEqual(p.get_occupation(1, 's'), 0.3538125)
self.assertAlmostEqual(p.get_occupation(1, 'p'), 1.19540625)
self.assertRaises(ValueError, p.get_occupation, 1, 'm')
self.assertEqual(p.nb_bands, 10)
self.assertEqual(p.nb_kpoints, 10)
lat = Lattice.cubic(3.)
s = Structure(lat, ["Li", "Na", "K"], [[0., 0., 0.],
[0.25, 0.25, 0.25],
[0.75, 0.75, 0.75]])
d = p.get_projection_on_elements(s)
self.assertAlmostEqual(d[1][2][2], {'Na': 0.042, 'K': 0.646, 'Li': 0.042})
filepath = os.path.join(test_dir, 'PROCAR')
p = Procar(filepath)
self.assertAlmostEqual(p.get_occupation(0, 'd'), 4.3698147704200059)
self.assertAlmostEqual(p.get_occupation(0, 'dxy'), 0.85796295426000124)
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])
output = t.apply_transformation(s)
self.assertTrue(test_site in output.sites)
def test_apply_transformation(self):
s = self.get_structure("LiFePO4")
trans = SlabTransformation([0, 0, 1], 10, 10, shift = 0.25)
gen = SlabGenerator(s, [0, 0, 1], 10, 10)
slab_from_gen = gen.get_slab(0.25)
slab_from_trans = trans.apply_transformation(s)
self.assertArrayAlmostEqual(slab_from_gen.lattice.matrix,
slab_from_trans.lattice.matrix)
self.assertArrayAlmostEqual(slab_from_gen.cart_coords,
slab_from_trans.cart_coords)
fcc = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3), ["Fe"],
[[0, 0, 0]])
trans = SlabTransformation([1, 1, 1], 10, 10)
slab_from_trans = trans.apply_transformation(fcc)
gen = SlabGenerator(fcc, [1, 1, 1], 10, 10)
slab_from_gen = gen.get_slab()
self.assertArrayAlmostEqual(slab_from_gen.lattice.matrix,
slab_from_trans.lattice.matrix)
self.assertArrayAlmostEqual(slab_from_gen.cart_coords,
slab_from_trans.cart_coords)
def setUp(self):
with open(os.path.join(test_dir, 'test_toec_data.json')) as f:
self.data_dict = json.load(f)
self.strains = [Strain(sm) for sm in self.data_dict['strains']]
self.pk_stresses = [Stress(d) for d in self.data_dict['pk_stresses']]
self.c2 = self.data_dict["C2_raw"]
self.c3 = self.data_dict["C3_raw"]
self.exp = ElasticTensorExpansion.from_voigt([self.c2, self.c3])
self.cu = Structure.from_spacegroup("Fm-3m", Lattice.cubic(3.623),
["Cu"], [[0]*3])
indices = [(0, 0), (0, 1), (3, 3)]
values = [167.8, 113.5, 74.5]
cu_c2 = ElasticTensor.from_values_indices(values, indices, structure=self.cu,
populate=True)
indices = [(0, 0, 0), (0, 0, 1), (0, 1, 2),
(0, 3, 3), (0, 5, 5), (3, 4, 5)]
values = [-1507., -965., -71., -7., -901., 45.]
cu_c3 = Tensor.from_values_indices(values, indices, structure=self.cu,
populate=True)
self.exp_cu = ElasticTensorExpansion([cu_c2, cu_c3])
cu_c4 = Tensor.from_voigt(self.data_dict["Cu_fourth_order"])
self.exp_cu_4 = ElasticTensorExpansion([cu_c2, cu_c3, cu_c4])
def setUp(self):
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)
self.NiO_AFM_111.add_spin_by_site([-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)
self.NiO_AFM_001.add_spin_by_site([-5, 5, 0, 0])
parser = CifParser(os.path.join(test_dir, 'Fe3O4.cif'))
self.Fe3O4 = parser.get_structures()[0]
trans = AutoOxiStateDecorationTransformation()
self.Fe3O4_oxi = trans.apply_transformation(self.Fe3O4)
parser = CifParser(os.path.join(test_dir, 'Li8Fe2NiCoO8.cif'))
self.Li8Fe2NiCoO8 = parser.get_structures()[0]
self.Li8Fe2NiCoO8.remove_oxidation_states()
warnings.simplefilter("ignore")
def setUp(self):
self.lattice = Lattice.cubic(10.0)
self.kpoint = Kpoint([0.1, 0.4, -0.5], self.lattice, label="X")
