def step2(**kwargs):
"""
post process:
get energies from the jobs in the previous step and
generate the phase diagram
"""
chkfile = kwargs['checkpoint_files'][0]
all_jobs = jobs_from_file(chkfile)
entries = []
# add endpoint data
Al = Composition("Al1O0")
energy_al = -3.36
O = Composition("Al0O1")
energy_o = -2.58
entries.append(PDEntry(Al, energy_al))
entries.append(PDEntry(O, energy_o))
# get data and create entries
for job in all_jobs:
comp = job.vis.mplmp.structure.composition
energy = job.final_energy
entries.append(PDEntry(comp, energy))
pd = PhaseDiagram(entries)
plotter = PDPlotter(pd, show_unstable=True)
plotter.write_image('Al_O_phasediagram.jpg')
return None
def pd_plot(system='Ni-Nb'):
object_file = pickle.load(open('form_en_gbsave_v25h', "rb"))
output = []
l = system.split('-')
comb = []
for i in range(len(l)):
comb += itertools.combinations(l, i + 1)
comb_list = [list(t) for t in comb]
# comb_list=['Zn','O','Zn-O']
with MPRester("") as m:
for i in comb_list:
dd = '-'.join(i)
print dd
data = m.get_data(dd)
for d in data:
x = {}
x['material_id'] = str(d['material_id'])
structure = m.get_structure_by_material_id(x['material_id'])
X = get_comp_descp(struct=structure)
print "X", X
pred = object_file.predict(X)
print structure.composition.reduced_formula, pred[0], d[
'formation_energy_per_atom'], str(d['material_id'])
output.append(
PDEntry(Composition(structure.composition),
float(pred[0])))
pd = PhaseDiagram(output)
print output
plotter = PDPlotter(pd, show_unstable=True)
name = str(system) + str('_phasediagram.png')
plotter.write_image(name, image_format="png")
def test_get_stability(self):
entries = self.rester.get_entries_in_chemsys(["Fe", "O"])
modified_entries = []
for entry in entries:
# Create modified entries with energies that are 0.01eV higher
# than the corresponding entries.
if entry.composition.reduced_formula == "Fe2O3":
modified_entries.append(
ComputedEntry(entry.composition,
entry.uncorrected_energy + 0.01,
parameters=entry.parameters,
entry_id="mod_{}".format(entry.entry_id)))
rest_ehulls = self.rester.get_stability(modified_entries)
all_entries = entries + modified_entries
compat = MaterialsProjectCompatibility()
all_entries = compat.process_entries(all_entries)
pd = PhaseDiagram(all_entries)
a = PDAnalyzer(pd)
for e in all_entries:
if str(e.entry_id).startswith("mod"):
for d in rest_ehulls:
if d["entry_id"] == e.entry_id:
data = d
break
self.assertAlmostEqual(a.get_e_above_hull(e),
data["e_above_hull"])
def test_1d_pd(self):
entry = PDEntry('H', 0)
pd = PhaseDiagram([entry])
pda = PDAnalyzer(pd)
decomp, e = pda.get_decomp_and_e_above_hull(PDEntry('H', 1))
self.assertAlmostEqual(e, 1)
self.assertAlmostEqual(decomp[entry], 1.0)
def extract_phase_diagram_info(self, MP_phase_diagram_json_data_filename):
computed_entries = self._extract_MP_data(
MP_phase_diagram_json_data_filename)
processed_entries = self.compat.process_entries(computed_entries)
pd = PhaseDiagram(processed_entries)
self.phase_diagram_analyser = PDAnalyzer(pd)
return
class PhaseDiagramTest(unittest.TestCase):
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(self.elements, self.entries) = \
PDEntryIO.from_csv(os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(self.entries)
def test_init(self):
#Ensure that a bad set of entries raises a PD error. Remove all Li
#from self.entries.
entries = filter(
lambda e: (not e.composition.is_element) or e.composition.elements[
0] != Element("Li"), self.entries)
self.assertRaises(PhaseDiagramError, PhaseDiagram, entries,
self.elements)
def test_stable_entries(self):
stable_formulas = [
ent.composition.reduced_formula for ent in self.pd.stable_entries
]
expected_stable = [
"Fe2O3", "Li5FeO4", "LiFeO2", "Fe3O4", "Li", "Fe", "Li2O", "O2",
"FeO"
]
for formula in expected_stable:
self.assertTrue(formula in stable_formulas,
formula + " not in stable entries!")
def test_get_formation_energy(self):
stable_formation_energies = {
ent.composition.reduced_formula: self.pd.get_form_energy(ent)
for ent in self.pd.stable_entries
}
expected_formation_energies = {
'Li5FeO4': -164.8117344866667,
'Li2O2': -14.119232793333332,
'Fe2O3': -16.574164339999996,
'FeO': -5.7141519966666685,
'Li': 0.0,
'LiFeO2': -7.732752316666666,
'Li2O': -6.229303868333332,
'Fe': 0.0,
'Fe3O4': -22.565714456666683,
'Li2FeO3': -45.67166036000002,
'O2': 0.0
}
for formula, energy in expected_formation_energies.items():
self.assertAlmostEqual(energy, stable_formation_energies[formula],
7)
def test_all_entries_hulldata(self):
self.assertEqual(len(self.pd.all_entries_hulldata), 492)
def test_str(self):
self.assertIsNotNone(str(self.pd))
def test_planar_inputs(self):
e1 = PDEntry('H', 0)
e2 = PDEntry('He', 0)
e3 = PDEntry('Li', 0)
e4 = PDEntry('Be', 0)
e5 = PDEntry('B', 0)
e6 = PDEntry('Rb', 0)
pd = PhaseDiagram([e1, e2, e3, e4, e5, e6],
map(Element, ['Rb', 'He', 'B', 'Be', 'Li', 'H']))
self.assertEqual(len(pd.facets), 1)
def __init__(self, entries, working_ion_entry):
"""
Create a new InsertionElectrode.
Args:
entries:
A list of ComputedStructureEntries (or subclasses) representing
the different topotactic states of the battery, e.g. TiO2 and
LiTiO2.
working_ion_entry:
A single ComputedEntry or PDEntry representing the element that
carries charge across the battery, e.g. Li.
"""
self._entries = entries
self._working_ion = working_ion_entry.composition.elements[0]
self._working_ion_entry = working_ion_entry
#Prepare to make phase diagram: determine elements and set their energy
#to be very high
elements = set()
map(elements.update, [entry.composition.elements for entry in entries])
#Set an artificial energy for each element for convex hull generation
element_energy = max([entry.energy_per_atom for entry in entries]) + 10
pdentries = []
pdentries.extend(entries)
pdentries.extend(
[PDEntry(Composition({el: 1}), element_energy) for el in elements])
#Make phase diagram to determine which entries are stable vs. unstable
pd = PhaseDiagram(pdentries)
lifrac = lambda e: e.composition.get_atomic_fraction(self._working_ion)
#stable entries ordered by amount of Li asc
self._stable_entries = tuple(
sorted([e for e in pd.stable_entries if e in entries], key=lifrac))
#unstable entries ordered by amount of Li asc
self._unstable_entries = tuple(
sorted([e for e in pd.unstable_entries if e in entries],
key=lifrac))
#create voltage pairs
self._vpairs = tuple([
InsertionVoltagePair(self._stable_entries[i],
self._stable_entries[i + 1],
working_ion_entry)
for i in range(len(self._stable_entries) - 1)
])
def test_planar_inputs(self):
e1 = PDEntry('H', 0)
e2 = PDEntry('HLiB', 0)
e3 = PDEntry('He', 0)
e4 = PDEntry('Li', 0)
e5 = PDEntry('Be', 0)
e6 = PDEntry('B', 0)
e7 = PDEntry('HBe', 0)
e8 = PDEntry('Rb', 0)
pd = PhaseDiagram([e1, e2, e3, e4, e5, e6, e7, e8],
map(Element,
['Rb', 'He', 'B', 'Be', 'Li', 'He', 'H']))
def test_dim1(self):
#Ensure that dim 1 PDs can eb generated.
for el in ["Li", "Fe", "O2"]:
entries = [
e for e in self.entries if e.composition.reduced_formula == el
]
pd = PhaseDiagram(entries)
self.assertEqual(len(pd.stable_entries), 1)
a = PDAnalyzer(pd)
for e in entries:
decomp, ehull = a.get_decomp_and_e_above_hull(e)
self.assertGreaterEqual(ehull, 0)
plotter = PDPlotter(pd)
lines, stable_entries, unstable_entries = plotter.pd_plot_data
self.assertEqual(lines[0][1], [0, 0])
class PhaseDiagramTest(unittest.TestCase):
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(self.elements, self.entries) = \
PDEntryIO.from_csv(os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(self.entries)
def test_init(self):
#Ensure that a bad set of entries raises a PD error. Remove all Li
#from self.entries.
entries = filter(lambda e: (not e.composition.is_element) or
e.composition.elements[0] != Element("Li"),
self.entries)
self.assertRaises(PhaseDiagramError, PhaseDiagram, entries,
self.elements)
def test_stable_entries(self):
stable_formulas = [ent.composition.reduced_formula
for ent in self.pd.stable_entries]
expected_stable = ["Fe2O3", "Li5FeO4", "LiFeO2", "Fe3O4", "Li", "Fe",
"Li2O", "O2", "FeO"]
for formula in expected_stable:
self.assertTrue(formula in stable_formulas,
formula + " not in stable entries!")
def test_get_formation_energy(self):
stable_formation_energies = {ent.composition.reduced_formula:
self.pd.get_form_energy(ent)
for ent in self.pd.stable_entries}
expected_formation_energies = {'Li5FeO4': -164.8117344866667,
'Li2O2': -14.119232793333332,
'Fe2O3': -16.574164339999996,
'FeO': -5.7141519966666685, 'Li': 0.0,
'LiFeO2': -7.732752316666666,
'Li2O': -6.229303868333332,
'Fe': 0.0, 'Fe3O4': -22.565714456666683,
'Li2FeO3': -45.67166036000002,
'O2': 0.0}
for formula, energy in expected_formation_energies.items():
self.assertAlmostEqual(energy, stable_formation_energies[formula],
7)
def test_all_entries_hulldata(self):
self.assertEqual(len(self.pd.all_entries_hulldata), 492)
def test_str(self):
self.assertIsNotNone(str(self.pd))
def from_composition_and_entries(comp,
entries_in_chemsys,
working_ion_symbol="Li"):
"""
Convenience constructor to make a ConversionElectrode from a
composition and all entries in a chemical system.
Args:
comp: Starting composition for ConversionElectrode, e.g.,
Composition("FeF3")
entries_in_chemsys: Sequence containing all entries in a
chemical system. E.g., all Li-Fe-F containing entries.
working_ion_symbol: Element symbol of working ion. Defaults to Li.
"""
pd = PhaseDiagram(entries_in_chemsys)
return ConversionElectrode.from_composition_and_pd(
comp, pd, working_ion_symbol)
def get_decomp(o_chem_pot, mycomp, verbose=1):
"""Get decomposition from open phase diagram
Args:
o_chem_pot <float>: Oxygen chemical potential
mycomp <pymatgen Composition>: Composition
verbose <int>: 1 - verbose (default)
0 - silent
Returns:
decomposition string
"""
a = MPRester("<YOUR_MPREST_API_KEY_HERE>")
elements = mycomp.elements
ellist = map(str, elements)
entries = a.get_entries_in_chemsys(ellist)
#entries = a.get_entries_in_chemsys(['La', 'Mn', 'O', 'Fe'])
pd = PhaseDiagram(entries)
gppd = GrandPotentialPhaseDiagram(entries,
{Element('O'): float(o_chem_pot)})
print gppd
#plotter = PDPlotter(gppd)
#plotter.show()
gppda = PDAnalyzer(gppd)
#mychempots = gppda.get_composition_chempots(mycomp)
#print "My chem pots:"
#print mychempots
mydecompgppd = gppda.get_decomposition(mycomp)
#pdentry = PDEntry(mycomp, 0)
#print "Decomp and energy:"
#decompandenergy = gppda.get_decomp_and_e_above_hull(pdentry)
#print decompandenergy
#mydecomppd = pda.get_decomposition(mycomp)
#print "Mn profile:"
#mnprof= gppda.get_element_profile(Element('Mn'),mycomp)
#print mnprof
if verbose:
for (entry, amount) in mydecompgppd.iteritems():
print "%s: %3.3f" % (entry.name, amount)
#mymurangegppd = gppda.getmu_range_stability_phase(Composition(entry.name),Element('O'))
#print mymurangegppd
#for (entry,amount) in mydecomppd.iteritems():
# print "%s: %3.3f" % (entry.name, amount)
print ""
return mydecompgppd
class PhaseDiagramTest(unittest.TestCase):
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(self.elements, self.entries) = PDEntryIO.from_csv(os.path.join(module_dir,"pdentries_test.csv"))
self.pd = PhaseDiagram(self.entries)
def test_stable_entries(self):
stable_formulas = [ent.composition.reduced_formula for ent in self.pd.stable_entries]
expected_stable = ["Fe2O3", "Li5FeO4", "LiFeO2", "Fe3O4", "Li", "Fe", "Li2O", "O2", "FeO"]
for formula in expected_stable:
self.assertTrue(formula in stable_formulas, formula + " not in stable entries!")
def test_get_formation_energy(self):
stable_formation_energies = {ent.composition.reduced_formula:self.pd.get_form_energy(ent) for ent in self.pd.stable_entries}
expected_formation_energies = {'Li5FeO4': -164.8117344866667, 'Li2O2': -14.119232793333332, 'Fe2O3': -16.574164339999996, 'FeO': -5.7141519966666685, 'Li': 0.0, 'LiFeO2': -7.732752316666666, 'Li2O': -6.229303868333332, 'Fe': 0.0, 'Fe3O4': -22.565714456666683, 'Li2FeO3': -45.67166036000002, 'O2': 0.0}
for formula, energy in expected_formation_energies.items():
self.assertAlmostEqual(energy, stable_formation_energies[formula], 7, "Calculated formation for " + formula + " is not correct!")
def get_equilibrium_reaction_energy(self, entry):
"""
Provides the reaction energy of a stable entry from the neighboring
equilibrium stable entries (also known as the inverse distance to
hull).
Args:
entry: A PDEntry like object
Returns:
Equilibrium reaction energy of entry. Stable entries should have
equilibrium reaction energy <= 0.
"""
if entry not in self._pd.stable_entries:
raise ValueError("Equilibrium reaction energy is available only "
"for stable entries.")
if entry.is_element:
return 0
entries = [e for e in self._pd.stable_entries if e != entry]
modpd = PhaseDiagram(entries, self._pd.elements)
analyzer = PDAnalyzer(modpd)
return analyzer.get_decomp_and_e_above_hull(entry,
allow_negative=True)[1]
def get_lowest_decomposition(self, composition):
"""
Get the decomposition leading to lowest cost
Args:
composition:
Composition as a pymatgen.core.structure.Composition
Returns:
Decomposition as a dict of {Entry: amount}
"""
entries_list = []
elements = [e.symbol for e in composition.elements]
for i in range(len(elements)):
for combi in itertools.combinations(elements, i + 1):
chemsys = [Element(e) for e in combi]
x = self.costdb.get_entries(chemsys)
entries_list.extend(x)
try:
pd = PhaseDiagram(entries_list)
return PDAnalyzer(pd).get_decomposition(composition)
except IndexError:
raise ValueError("Error during PD building; most likely, "
"cost data does not exist!")
criteria=criteria,
projection=projection,
collection="compositions",
contributor_only=False,
)[0]
# append spectra to output PDF
plotly_urls = doc[cid]["LBNL"][str(cid)]["plotly_urls"]
for plotly_url in plotly_urls:
image_bytes = requests.get("{}.pdf".format(plotly_url)).content
merger.append(StringIO(image_bytes))
# get phase diagram from MP and append to PDF
chemsys = ["Co", "Fe", "V"] # ["Ni", "Fe", "Pt"] # alphabetic
cmap = ["Reds", "Blues", "Greens"]
entries = mpr.get_entries_in_chemsys(chemsys)
pd = PhaseDiagram(entries)
plotter = PDPlotter(pd)
# grid
gx, gy = [], []
n = 20
fn = float(n)
for i in range(0, n, 1):
for k in range(n - i + 1, 0, -1):
j = n + 1 - i - k
x0, x1, x2 = i / fn, k / fn, j / fn
gx.append(x0 +
x2 / 2.0) # NOTE x0 might need to be replace with x1
gy.append(x2 * math.sqrt(3.0) / 2.0)
grid_triang = tri.Triangulation(gx, gy)
def main(comp="La0.5Sr0.5MnO3", energy=-43.3610, ostart="", oend="", ostep=""):
"""Get energy above hull for a composition
Args:
comp <str>: Composition in string form
energy <float>: Energy PER FORMULA UNIT of composition given
(Leave the following arguments blank for a non-grand potential
phase diagram.)
ostart <float>: Starting oxygen chemical potential.
oend <float>: Ending oxygen chemical potential.
ostep <float>: Step for oxygen chemical potential
Returns:
Prints to screen
"""
#a = MPRester("<YOUR_MPREST_API_KEY_HERE>")
a = MPRester("wfmUu5VSsDCvIrhz")
mycomp = Composition(comp)
print "Composition: ", mycomp
myenergy = energy
print "Energy: ", myenergy
myPDEntry = PDEntry(mycomp, myenergy)
elements = mycomp.elements
ellist = map(str, elements)
chemsys_entries = a.get_entries_in_chemsys(ellist)
#For reference: other ways of getting entries
#entries = a.mpquery(criteria={'elements':{'$in':['La','Mn'],'$all':['O']},'nelements':3})
#entries = a.mpquery(criteria={'elements':{'$in':['La','Mn','O'],'$all':['O']}},properties=['pretty_formula'])
#entries = a.get_entries_in_chemsys(['La', 'Mn', 'O', 'Sr'])
if ostart == "": #Regular phase diagram
entries = list(chemsys_entries)
entries.append(myPDEntry)
pd = PhaseDiagram(entries)
#plotter = PDPlotter(gppd)
#plotter.show()
ppda = PDAnalyzer(pd)
eabove = ppda.get_decomp_and_e_above_hull(myPDEntry)
print "Energy above hull: ", eabove[1]
print "Decomposition: ", eabove[0]
return eabove
else: #Grand potential phase diagram
orange = np.arange(
ostart, oend + ostep,
ostep) #add ostep because otherwise the range ends before oend
for o_chem_pot in orange:
entries = list(chemsys_entries)
myGrandPDEntry = GrandPotPDEntry(
myPDEntry, {Element('O'): float(o_chem_pot)
}) #need grand pot pd entry for GPPD
entries.append(myGrandPDEntry)
gppd = GrandPotentialPhaseDiagram(
entries, {Element('O'): float(o_chem_pot)})
gppda = PDAnalyzer(gppd)
geabove = gppda.get_decomp_and_e_above_hull(myGrandPDEntry, True)
print "******** Decomposition for mu_O = %s eV ********" % o_chem_pot
print "%30s%1.4f" % ("mu_O: ", o_chem_pot)
print "%30s%1.4f" % ("Energy above hull (eV): ", geabove[1])
decomp = geabove[0]
#print "Decomp: ", decomp
print "%30s" % "Decomposition: "
for dkey in decomp.keys():
print "%30s:%1.4f" % (dkey.composition, decomp[dkey])
return
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(self.elements, self.entries) = \
PDEntryIO.from_csv(os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(self.entries)
def setUp(self):
(elements, entries) = PDEntryIO.from_csv(
os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(entries)
self.plotter = PDPlotter(self.pd)
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(elements, entries) = PDEntryIO.from_csv(
os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(entries)
self.analyzer = PDAnalyzer(self.pd)
class PhaseDiagramTest(unittest.TestCase):
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(self.elements, self.entries) = \
PDEntryIO.from_csv(os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(self.entries)
def test_init(self):
#Ensure that a bad set of entries raises a PD error. Remove all Li
#from self.entries.
entries = filter(
lambda e: (not e.composition.is_element) or e.composition.elements[
0] != Element("Li"), self.entries)
self.assertRaises(PhaseDiagramError, PhaseDiagram, entries,
self.elements)
def test_dim1(self):
#Ensure that dim 1 PDs can eb generated.
for el in ["Li", "Fe", "O2"]:
entries = [
e for e in self.entries if e.composition.reduced_formula == el
]
pd = PhaseDiagram(entries)
self.assertEqual(len(pd.stable_entries), 1)
a = PDAnalyzer(pd)
for e in entries:
decomp, ehull = a.get_decomp_and_e_above_hull(e)
self.assertGreaterEqual(ehull, 0)
plotter = PDPlotter(pd)
lines, stable_entries, unstable_entries = plotter.pd_plot_data
self.assertEqual(lines[0][1], [0, 0])
def test_stable_entries(self):
stable_formulas = [
ent.composition.reduced_formula for ent in self.pd.stable_entries
]
expected_stable = [
"Fe2O3", "Li5FeO4", "LiFeO2", "Fe3O4", "Li", "Fe", "Li2O", "O2",
"FeO"
]
for formula in expected_stable:
self.assertTrue(formula in stable_formulas,
formula + " not in stable entries!")
def test_get_formation_energy(self):
stable_formation_energies = {
ent.composition.reduced_formula: self.pd.get_form_energy(ent)
for ent in self.pd.stable_entries
}
expected_formation_energies = {
'Li5FeO4': -164.8117344866667,
'Li2O2': -14.119232793333332,
'Fe2O3': -16.574164339999996,
'FeO': -5.7141519966666685,
'Li': 0.0,
'LiFeO2': -7.732752316666666,
'Li2O': -6.229303868333332,
'Fe': 0.0,
'Fe3O4': -22.565714456666683,
'Li2FeO3': -45.67166036000002,
'O2': 0.0
}
for formula, energy in expected_formation_energies.items():
self.assertAlmostEqual(energy, stable_formation_energies[formula],
7)
def test_all_entries_hulldata(self):
self.assertEqual(len(self.pd.all_entries_hulldata), 492)
def test_planar_inputs(self):
e1 = PDEntry('H', 0)
e2 = PDEntry('He', 0)
e3 = PDEntry('Li', 0)
e4 = PDEntry('Be', 0)
e5 = PDEntry('B', 0)
e6 = PDEntry('Rb', 0)
pd = PhaseDiagram([e1, e2, e3, e4, e5, e6],
map(Element, ['Rb', 'He', 'B', 'Be', 'Li', 'H']))
self.assertEqual(len(pd.facets), 1)
def test_str(self):
self.assertIsNotNone(str(self.pd))
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(self.elements, self.entries) = \
PDEntryIO.from_csv(os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(self.entries)
class PhaseDiagramTest(unittest.TestCase):
def setUp(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
(self.elements, self.entries) = \
PDEntryIO.from_csv(os.path.join(module_dir, "pdentries_test.csv"))
self.pd = PhaseDiagram(self.entries)
def test_init(self):
#Ensure that a bad set of entries raises a PD error. Remove all Li
#from self.entries.
entries = filter(lambda e: (not e.composition.is_element) or
e.composition.elements[0] != Element("Li"),
self.entries)
self.assertRaises(PhaseDiagramError, PhaseDiagram, entries,
self.elements)
def test_dim1(self):
#Ensure that dim 1 PDs can eb generated.
for el in ["Li", "Fe", "O2"]:
entries = [e for e in self.entries
if e.composition.reduced_formula == el]
pd = PhaseDiagram(entries)
self.assertEqual(len(pd.stable_entries), 1)
a = PDAnalyzer(pd)
for e in entries:
decomp, ehull = a.get_decomp_and_e_above_hull(e)
self.assertGreaterEqual(ehull, 0)
plotter = PDPlotter(pd)
lines, stable_entries, unstable_entries = plotter.pd_plot_data
self.assertEqual(lines[0][1], [0, 0])
def test_stable_entries(self):
stable_formulas = [ent.composition.reduced_formula
for ent in self.pd.stable_entries]
expected_stable = ["Fe2O3", "Li5FeO4", "LiFeO2", "Fe3O4", "Li", "Fe",
"Li2O", "O2", "FeO"]
for formula in expected_stable:
self.assertTrue(formula in stable_formulas,
formula + " not in stable entries!")
def test_get_formation_energy(self):
stable_formation_energies = {ent.composition.reduced_formula:
self.pd.get_form_energy(ent)
for ent in self.pd.stable_entries}
expected_formation_energies = {'Li5FeO4': -164.8117344866667,
'Li2O2': -14.119232793333332,
'Fe2O3': -16.574164339999996,
'FeO': -5.7141519966666685, 'Li': 0.0,
'LiFeO2': -7.732752316666666,
'Li2O': -6.229303868333332,
'Fe': 0.0, 'Fe3O4': -22.565714456666683,
'Li2FeO3': -45.67166036000002,
'O2': 0.0}
for formula, energy in expected_formation_energies.items():
self.assertAlmostEqual(energy, stable_formation_energies[formula],
7)
def test_all_entries_hulldata(self):
self.assertEqual(len(self.pd.all_entries_hulldata), 492)
def test_planar_inputs(self):
e1 = PDEntry('H', 0)
e2 = PDEntry('HLiB', 0)
e3 = PDEntry('He', 0)
e4 = PDEntry('Li', 0)
e5 = PDEntry('Be', 0)
e6 = PDEntry('B', 0)
e7 = PDEntry('HBe', 0)
e8 = PDEntry('Rb', 0)
pd = PhaseDiagram([e1, e2, e3, e4, e5, e6, e7, e8],
map(Element, ['Rb', 'He', 'B', 'Be','Li', 'He', 'H']))
def test_str(self):
self.assertIsNotNone(str(self.pd))
def material_load_binary(d, sep='-', p=prop):
return_data = []
d = d.split(sep)
# Create a phase diagram object for the following system:
entry = mp.get_entries_in_chemsys(
[d[0], d[1]]) # gets the entries of the chemical system
pd = PhaseDiagram(entry) # creates a phasediagram object
pd_analyse = PDAnalyzer(pd) # creates a phase Diagram analysis object
# Get the features for various proportions Using the get_hull_energy method;
# (Need to add documentation)
for i in range(0, len(p)):
temp_data = {}
prop_a = p[i]
prop_b = p[-(i + 1)]
try:
temp_data['system'] = d[0] + '-' + d[1]
temp_data['A'] = d[0]
temp_data['B'] = d[1]
temp_data[d[0] + '_prop'] = prop_a
temp_data[d[1] + '_prop'] = prop_b
temp_data['formation_energy'] = pd_analyse.get_hull_energy(
Composition.from_dict({
d[0]: prop_a,
d[1]: prop_b
}))
# Element Property extraction
temp_data['avg_atomic_mass'] = prop_a * elements.loc[
d[0]].mass + prop_b * elements.loc[d[1]].mass
temp_data['avg_row'] = prop_a * elements.loc[
d[0]].period + prop_b * elements.loc[d[1]].period
temp_data['avg_col'] = prop_a * elements.loc[
d[0]].group + prop_b * elements.loc[d[1]].group
temp_data['max_z_diff'] = abs(
elements.loc[d[0]].z -
elements.loc[d[1]].z) # Max Difference in atomic number
temp_data['avg_z'] = prop_a * elements.loc[
d[0]].z + prop_b * elements.loc[d[1]].z
temp_data['max_radius_diff'] = abs(
elements.loc[d[0]].atomic_radii -
elements.loc[d[1]].atomic_radii
) # Max Difference in atomic radius
temp_data['avg_radius'] = prop_a * elements.loc[
d[0]].atomic_radii + prop_b * elements.loc[d[1]].atomic_radii
temp_data['max_en_diff'] = abs(
elements.loc[d[0]].electronegativity -
elements.loc[d[1]].electronegativity
) # Max Difference in electronegativity
temp_data['avg_en'] = prop_a * elements.loc[
d[0]].electronegativity + prop_b * elements.loc[d[
1]].electronegativity # Avg Difference in electronegativity
temp_data['avg_s_elec'] = prop_a * elements.loc[
d[0]].s_elec + prop_b * elements.loc[d[1]].s_elec
temp_data['avg_p_elec'] = prop_a * elements.loc[
d[0]].p_elec + prop_b * elements.loc[d[1]].p_elec
temp_data['avg_d_elec'] = prop_a * elements.loc[
d[0]].d_elec + prop_b * elements.loc[d[1]].d_elec
temp_data['avg_f_elec'] = prop_a * elements.loc[
d[0]].f_elec + prop_b * elements.loc[d[1]].f_elec
temp_sum = temp_data['avg_s_elec'] + temp_data[
'avg_p_elec'] + temp_data['avg_d_elec'] + temp_data[
'avg_f_elec']
temp_data['prop_s_elec'] = temp_data['avg_s_elec'] / temp_sum
temp_data['prop_p_elec'] = temp_data['avg_p_elec'] / temp_sum
temp_data['prop_d_elec'] = temp_data['avg_d_elec'] / temp_sum
temp_data['prop_f_elec'] = temp_data['avg_f_elec'] / temp_sum
return_data.append(temp_data)
except:
pass
return return_data, temp_data['system']