def test_GCLP(self):
n_elem = self.calc.get_num_phases()
self.assertEqual(len(LookUpData.element_names), n_elem,
"Initial number"
" of phases should be equal to 112")
# Simple test: No phases.
NaCl = CompositionEntry("NaCl")
left, right = self.calc.run_GCLP(NaCl)
self.assertAlmostEqual(0.0, left, delta=1e-6)
self.assertEqual(2, len(right))
# Add in Na2Cl and NaCl2 to map.
self.calc.add_phase(CompositionEntry("Na2Cl"), -1)
self.calc.add_phase(CompositionEntry("NaCl2"), -1)
left, right = self.calc.run_GCLP(NaCl)
self.assertAlmostEqual(-1, left, delta=1e-6)
self.assertEqual(2, len(right))
# Add NaCl to the map.
self.calc.add_phase(NaCl, -2)
left, right = self.calc.run_GCLP(NaCl)
self.assertAlmostEqual(-2, left, delta=1e-6)
self.assertEqual(1, len(right))
# Make sure it can do systems not included in original.
left, right = self.calc.run_GCLP(
CompositionEntry("AlNiFeZrTiSiBrFOSeKHHe"))
self.assertAlmostEqual(0.0, left, delta=1e-6)
self.assertEqual(13, len(right))
def test_initialization(self):
n_elem = self.calc.get_num_phases()
self.assertEqual(
len(LookUpData.element_names), n_elem, "Initial "
"number"
" of phases should be equal to 112")
# Add in NaCl.
NaCl = CompositionEntry("NaCl")
self.calc.add_phase(NaCl, -1)
self.assertEqual(1 + n_elem, self.calc.get_num_phases())
# Add in a duplicate.
self.calc.add_phase(NaCl, -1)
self.assertEqual(1 + n_elem, self.calc.get_num_phases())
# See if energy is updated.
self.calc.add_phase(NaCl, 0)
self.assertAlmostEqual(-1, self.calc.phases[NaCl], delta=1e-6)
self.calc.add_phase(NaCl, -2)
self.assertAlmostEqual(-2, self.calc.phases[NaCl], delta=1e-6)
# Add many phases.
entries = CompositionEntry.import_composition_list(
os.path.join(self.abs_path, "small_set_comp.txt"))
energies = CompositionEntry.import_values_list(
os.path.join(self.abs_path, "small_set_delta_e.txt"))
self.calc.add_phases(entries, energies)
self.assertEqual(725, self.calc.get_num_phases(),
"Total number of phases should be equal.")
def test_Ba2As2S(self):
self.icf.set_nominal_composition(CompositionEntry(
composition="Ba2As2S"))
self.icf.set_maximum_distance(0.35)
self.icf.set_max_formula_unit_size(7)
# Make sure it finds Ba4As2S.
accepted = self.icf.find_all_compounds()
self.assertTrue(CompositionEntry(composition="Ba4As2S") in accepted)
def test_sort_and_normalize(self):
# Make an example composition.
elem = [1, 2, 3, 4, 5]
frac = [1.0, 2.0, 3.0, 4.0, 5.0]
# Make first composition.
entry = CompositionEntry(element_ids=elem, fractions=frac)
entry_elems = entry.get_element_ids()
entry_fracs = entry.get_element_fractions()
for i in range(5):
self.assertAlmostEqual(entry_fracs[i],
entry_elems[i] / 15.0,
delta=1e-6)
# Iterate through all permutations.
for perm in permutations([0, 1, 2, 3, 4]):
# Make a new version of elem and frac.
new_elem = list(elem)
new_frac = list(frac)
for i in range(len(new_elem)):
new_elem[i] = elem[perm[i]]
new_frac[i] = frac[perm[i]]
# Make sure it parses the same.
new_entry = CompositionEntry(element_ids=elem, fractions=frac)
self.assertEqual(new_entry, entry)
self.assertEqual(0, new_entry.__cmp__(entry))
np.assert_array_equal(entry_elems, new_entry.get_element_ids())
np.assert_array_almost_equal(entry_fracs,
new_entry.get_element_fractions())
def test_NaCl(self):
self.icf.set_nominal_composition(CompositionEntry(composition="NaCl"))
self.icf.set_maximum_distance(0.2)
self.icf.set_max_formula_unit_size(4)
# Make sure it finds only one.
accepted = self.icf.find_all_compounds()
self.assertEqual(1, len(accepted))
def test_label(self):
# Make sample list of CompositionEntry's.
entries =[CompositionEntry(composition="Fe50Al50"), CompositionEntry(
composition="Fe55Al45"), CompositionEntry(composition="Fe25Al75")]
# Make filter.
cdf = CompositionDistanceFilter()
cdf.set_target_composition(CompositionEntry(composition="Fe49Al51"))
cdf.set_distance_threshold(1.1)
# Test #1.
res = cdf.label(entries)
self.assertTrue(res[0])
self.assertFalse(res[1])
self.assertFalse(res[2])
# Test #2.
cdf.set_distance_threshold(7)
res = cdf.label(entries)
self.assertTrue(res[0])
self.assertTrue(res[1])
self.assertFalse(res[2])
def test_FeO(self):
self.icf.set_nominal_composition(CompositionEntry(composition="Fe2O"))
self.icf.set_maximum_distance(0.34)
self.icf.set_max_formula_unit_size(5)
# Make sure it finds only one (FeO).
accepted = self.icf.find_all_compounds()
self.assertEqual(1, len(accepted))
# Make sure it finds two (FeO, Fe2O3).
self.icf.set_maximum_distance(0.54)
accepted = self.icf.find_all_compounds()
self.assertEqual(2, len(accepted))
self.assertEqual("FeO", accepted[0].__str__())
def test_compare(self):
# this_file_path = os.path.dirname(__file__)
# abs_path = os.path.join(this_file_path, "../../test-files/")
abs_path = pkg_resources.resource_filename(
'chemml', os.path.join('datasets', 'data', 'magpie_python_test'))
entries = CompositionEntry.import_composition_list(
os.path.join(abs_path, "small_set_comp.txt"))
for e1 in range(len(entries)):
self.assertEqual(0, entries[e1].__cmp__(entries[e1]))
for e2 in range(e1 + 1, len(entries)):
self.assertEqual(entries[e1].__cmp__(entries[e2]),
-1 * entries[e2].__cmp__(entries[e1]))
if entries[e1].__cmp__(entries[e2]) == 0:
self.assertEqual(entries[e1].__hash__(),
entries[e2].__hash__())
self.assertTrue(entries[e1].__eq__(entries[e2]))
def test_guesser(self):
ox = OxidationStateGuesser()
ox.set_oxidationstates(LookUpData.load_property("OxidationStates"))
ox.set_electronegativity(LookUpData.load_property("Electronegativity"))
res = ox.get_possible_states(CompositionEntry(composition="NaCl"))
self.assertEqual(1, len(res))
np.assert_array_equal([1, -1], res[0])
res = ox.get_possible_states(CompositionEntry(composition="Fe2O3"))
self.assertEqual(1, len(res))
np.assert_array_equal([3, -2], res[0])
res = ox.get_possible_states(CompositionEntry(composition="NaHCO3"))
self.assertEqual(1, len(res))
np.assert_array_equal(
[10, 0, 5, 7],
CompositionEntry(composition="NaHCO3").get_element_ids())
np.assert_array_equal([1, 1, 4, -2], res[0])
res = ox.get_possible_states(CompositionEntry(composition="NH3"))
self.assertEqual(2, len(res))
np.assert_array_equal(
[0, 6],
CompositionEntry(composition="NH3").get_element_ids())
np.assert_array_equal([1, -3], res[0])
res = ox.get_possible_states(CompositionEntry(composition="NaAl"))
self.assertEqual(0, len(res))
res = ox.get_possible_states(CompositionEntry(composition="PbTiO3"))
self.assertEqual(2, len(res))
np.assert_array_equal(
[21, 81, 7],
CompositionEntry(composition="PbTiO3").get_element_ids())
np.assert_array_equal([4, 2, -2], res[0])
def test_distances(self):
# Test binary distance.
self.assertAlmostEqual(0.0,
CompositionDistanceFilter.compute_distance(
CompositionEntry(composition="Fe"),
CompositionEntry(composition="Fe"),
p=-1), delta=1e-6)
self.assertAlmostEqual(0.0,
CompositionDistanceFilter.compute_distance(
CompositionEntry(composition="Fe"),
CompositionEntry(composition="Fe"),
p=0), delta=1e-6)
self.assertAlmostEqual(0.0,
CompositionDistanceFilter.compute_distance(
CompositionEntry(composition="Fe"),
CompositionEntry(composition="Fe"),
p=2), delta=1e-6)
self.assertAlmostEqual(0.5,
CompositionDistanceFilter.compute_distance(
CompositionEntry(composition="FeO"),
CompositionEntry(composition="Fe"),
p=-1), delta=1e-6)
self.assertAlmostEqual(2.0,
CompositionDistanceFilter.compute_distance(
CompositionEntry(composition="FeO)"),
CompositionEntry(composition="Fe"),
p=0), delta=1e-6)
self.assertAlmostEqual(sqrt(0.5),
CompositionDistanceFilter.compute_distance(
CompositionEntry(composition="FeO"),
CompositionEntry(composition="Fe"),
p=2), delta=1e-6)
def test_set_composition(self):
# One element.
elem = [0]
frac = [1]
entry = CompositionEntry(element_ids=elem, fractions=frac)
self.assertEqual(1, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0,
entry.get_element_fraction(name="H"),
delta=1e-6)
# One element with duplicates.
elem = [0, 0]
frac = [0.5, 0.5]
entry = CompositionEntry(element_ids=elem, fractions=frac)
self.assertEqual(1, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0,
entry.get_element_fraction(name="H"),
delta=1e-6)
# One element with zero.
elem = [0, 1]
frac = [1, 0]
entry = CompositionEntry(element_ids=elem, fractions=frac)
self.assertEqual(1, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0,
entry.get_element_fraction(name="H"),
delta=1e-6)
# Two elements.
elem = [16, 10]
frac = [1, 1]
entry = CompositionEntry(element_ids=elem, fractions=frac)
self.assertEqual(2, len(entry.get_element_ids()))
self.assertAlmostEqual(0.5,
entry.get_element_fraction(name="Na"),
delta=1e-6)
self.assertAlmostEqual(0.5,
entry.get_element_fraction(name="Cl"),
delta=1e-6)
np.assert_array_equal([10, 16], entry.get_element_ids())
np.assert_array_almost_equal([0.5, 0.5], entry.get_element_fractions())
self.assertAlmostEqual(2, entry.number_in_cell, delta=1e-6)
# Two elements with duplicates.
elem = [11, 16, 16]
frac = [1, 1, 1]
entry = CompositionEntry(element_ids=elem, fractions=frac)
self.assertEqual(2, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 3,
entry.get_element_fraction(name="Mg"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 3,
entry.get_element_fraction(name="Cl"),
delta=1e-6)
np.assert_array_equal([11, 16], entry.get_element_ids())
np.assert_array_almost_equal([1.0 / 3, 2.0 / 3],
entry.get_element_fractions())
self.assertAlmostEqual(3, entry.number_in_cell, delta=1e-6)
# Two elements with zero.
elem = [11, 16, 16]
frac = [1, 2, 0]
entry = CompositionEntry(element_ids=elem, fractions=frac)
self.assertEqual(2, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 3,
entry.get_element_fraction(name="Mg"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 3,
entry.get_element_fraction(name="Cl"),
delta=1e-6)
np.assert_array_equal([11, 16], entry.get_element_ids())
np.assert_array_almost_equal([1.0 / 3, 2.0 / 3],
entry.get_element_fractions())
self.assertAlmostEqual(3, entry.number_in_cell, delta=1e-6)
def test_parsing(self):
entry = CompositionEntry(composition="Fe")
self.assertEqual(1, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0,
entry.get_element_fraction(name="Fe"),
delta=1e-6)
entry = CompositionEntry(composition="FeO0")
self.assertEqual(1, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0,
entry.get_element_fraction(name="Fe"),
delta=1e-6)
entry = CompositionEntry(composition="FeCl3")
self.assertEqual(2, len(entry.get_element_ids()))
self.assertAlmostEqual(0.25,
entry.get_element_fraction(name="Fe"),
delta=1e-6)
self.assertAlmostEqual(0.75,
entry.get_element_fraction(name="Cl"),
delta=1e-6)
entry = CompositionEntry(composition="Fe1Cl_3")
self.assertEqual(2, len(entry.get_element_ids()))
self.assertAlmostEqual(0.25,
entry.get_element_fraction(name="Fe"),
delta=1e-6)
self.assertAlmostEqual(0.75,
entry.get_element_fraction(name="Cl"),
delta=1e-6)
entry = CompositionEntry(composition="FeCl_3")
self.assertEqual(2, len(entry.get_element_ids()))
self.assertAlmostEqual(0.25,
entry.get_element_fraction(name="Fe"),
delta=1e-6)
self.assertAlmostEqual(0.75,
entry.get_element_fraction(name="Cl"),
delta=1e-6)
entry = CompositionEntry(composition="FeClCl2")
self.assertEqual(2, len(entry.get_element_ids()))
self.assertAlmostEqual(0.25,
entry.get_element_fraction(name="Fe"),
delta=1e-6)
self.assertAlmostEqual(0.75,
entry.get_element_fraction(name="Cl"),
delta=1e-6)
entry = CompositionEntry(composition="Ca(NO3)2")
self.assertEqual(3, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 9,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 9,
entry.get_element_fraction(name="N"),
delta=1e-6)
self.assertAlmostEqual(6.0 / 9,
entry.get_element_fraction(name="O"),
delta=1e-6)
entry = CompositionEntry(composition="Ca(N[O]3)2")
self.assertEqual(3, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 9,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 9,
entry.get_element_fraction(name="N"),
delta=1e-6)
self.assertAlmostEqual(6.0 / 9,
entry.get_element_fraction(name="O"),
delta=1e-6)
entry = CompositionEntry(composition="Ca(N(O1.5)2)2")
self.assertEqual(3, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 9,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 9,
entry.get_element_fraction(name="N"),
delta=1e-6)
self.assertAlmostEqual(6.0 / 9,
entry.get_element_fraction(name="O"),
delta=1e-6)
entry = CompositionEntry(composition="Ca{N{O1.5}2}2")
self.assertEqual(3, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 9,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 9,
entry.get_element_fraction(name="N"),
delta=1e-6)
self.assertAlmostEqual(6.0 / 9,
entry.get_element_fraction(name="O"),
delta=1e-6)
entry = CompositionEntry(composition="CaO-0.01Ni")
self.assertEqual(3, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 2.01,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(0.01 / 2.01,
entry.get_element_fraction(name="Ni"),
delta=1e-6)
self.assertAlmostEqual(1.0 / 2.01,
entry.get_element_fraction(name="O"),
delta=1e-6)
entry = CompositionEntry(composition="CaO" + str(chr(183)) + "0.01Ni")
self.assertEqual(3, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 2.01,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(0.01 / 2.01,
entry.get_element_fraction(name="Ni"),
delta=1e-6)
self.assertAlmostEqual(1.0 / 2.01,
entry.get_element_fraction(name="O"),
delta=1e-6)
entry = CompositionEntry(composition="Ca(N(O1.5)2)2-2H2O")
self.assertEqual(4, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 15,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 15,
entry.get_element_fraction(name="N"),
delta=1e-6)
self.assertAlmostEqual(8.0 / 15,
entry.get_element_fraction(name="O"),
delta=1e-6)
self.assertAlmostEqual(4.0 / 15,
entry.get_element_fraction(name="H"),
delta=1e-6)
entry = CompositionEntry(composition="Ca(N(O1.5)2)2-2.1(H)2O")
self.assertEqual(4, len(entry.get_element_ids()))
self.assertAlmostEqual(1.0 / 15.3,
entry.get_element_fraction(name="Ca"),
delta=1e-6)
self.assertAlmostEqual(2.0 / 15.3,
entry.get_element_fraction(name="N"),
delta=1e-6)
self.assertAlmostEqual(8.1 / 15.3,
entry.get_element_fraction(name="O"),
delta=1e-6)
self.assertAlmostEqual(4.2 / 15.3,
entry.get_element_fraction(name="H"),
delta=1e-6)
entry = CompositionEntry(composition="{[("
"Fe0.6Co0.4)0.75B0.2Si0.05]0.96Nb0.04}96Cr4")
self.assertEqual(6, len(entry.get_element_ids()))
self.assertAlmostEqual(0.41472,
entry.get_element_fraction(name="Fe"),
delta=1e-6)
self.assertAlmostEqual(0.27648,
entry.get_element_fraction(name="Co"),
delta=1e-6)
self.assertAlmostEqual(0.18432,
entry.get_element_fraction(name="B"),
delta=1e-6)
self.assertAlmostEqual(0.04608,
entry.get_element_fraction(name="Si"),
delta=1e-6)
self.assertAlmostEqual(0.0384,
entry.get_element_fraction(name="Nb"),
delta=1e-6)
self.assertAlmostEqual(0.04,
entry.get_element_fraction(name="Cr"),
delta=1e-6)