def _test_from_pm(self): """ MPのデータをプロット """ ent_list = [] mpr = MPRester("WTxsDhRV7g2Mcbqw") composition = ['Fe', 'Ni', 'Si'] entries = mpr.get_entries_in_chemsys(composition) for entry in entries: formula = entry.as_dict()['data']['unit_cell_formula'] formation_e = entry.as_dict()['data']['formation_energy_per_atom'] if formation_e <= 0: single_data = [] sum_atoms = 0 for elements, index in formula.items(): sum_atoms += index for element in composition: try: single_data.append(formula[element] / sum_atoms) except KeyError: single_data.append(0) single_data.append(formation_e * 96.485344520851) ent_list.append(single_data) initial_base = [[x[0], x[1], x[3]] for x in ent_list[0:3]] not_base = [[x[0], x[1], x[3]] for x in ent_list[3:]] fig = pylab.figure() ax = Axes3D(fig) convex_hull.draw_convex_hull(ax, initial_base, not_base, ['Fe', 'Ni', 'Si'], [-60, 5], color='magenta') #pint(not_base) pylab.show()
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 create_fle_entry_ion(el_0,el_1): """ Creates a directory and creates 3 files: ion_data_1: contains ion_data for el_0 relevent to Pourbaix Diagrams ion_data_2: contains ion_data for el_1 relevent to Pourbaix Diagrams mp_entries.txt: entry data from Materials Project Args: el_0: Elemental symbol (type: string) of first element el_1: Elemental symbol (type: string) of second element """ fle_nme = el_0+'_'+el_1 os.makedirs(fle_nme) os.chdir(fle_nme) mpr = MPRester('TA7RCwHn3PGaN2m1') if el_0==el_1: entries = mpr.get_entries_in_chemsys([el_0, 'O', 'H']) else: entries = mpr.get_entries_in_chemsys([el_0, el_1, 'O', 'H']) ion_dict_1 = mpr._make_request('/pourbaix_diagram/reference_data/'+el_0) ion_dict_2 = mpr._make_request('/pourbaix_diagram/reference_data/'+el_1) ## Writing the Material Project entries to file ## tmp = json.dumps(entries, cls=MontyEncoder) f = open('mp_entries.txt','w') f.write(tmp) f.close() ## Writing ion data to file ## f = open('ion_data_1.txt','w') json.dump(ion_dict_1, f) f.close() f = open('ion_data_2.txt','w') json.dump(ion_dict_2, f) f.close() os.chdir('..')
def _test_from_pm_volume(self): """ MPのデータ volume をプリント MD 計算の初期値用 """ ent_list = [] mpr = MPRester("WTxsDhRV7g2Mcbqw") composition = ['Fe', 'P'] entries = mpr.get_entries_in_chemsys(composition) for entry in entries: if entry.as_dict()['data']['e_above_hull'] == 0: print(entry.as_dict()['data']['pretty_formula']) print(entry.as_dict()['data']['volume']/entry.as_dict()['data']['nsites'])
def _test_from_pm_volume(self): """ MPのデータ volume をプリント MD 計算の初期値用 """ ent_list = [] mpr = MPRester("WTxsDhRV7g2Mcbqw") composition = ["Fe", "P"] entries = mpr.get_entries_in_chemsys(composition) for entry in entries: if entry.as_dict()["data"]["e_above_hull"] == 0: print(entry.as_dict()["data"]["pretty_formula"]) print(entry.as_dict()["data"]["volume"] / entry.as_dict()["data"]["nsites"])
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
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
def test(): """for test""" #This initializes the REST adaptor. Put your own API key in. mpr = MPRester("WTxsDhRV7g2Mcbqw") #Entries are the basic unit for thermodynamic #and other analyses in pymatgen. #This gets all entries belonging to the Ca-C-O system. composition = ['Fe', 'Ni', 'Si'] entries = mpr.get_entries_in_chemsys(composition) # entryの内容を確認 entry = entries[0] print(entry.as_dict()) print(entry.as_dict()['data']['volume']/6) #With entries, you can do many sophisticated analyses, #like creating phase diagrams. pd = PhaseDiagram(entries) #pylint: disable=C0103 #print(dir(pd)) #print(pd.get_form_energy_per_atom(list(pd.stable_entries)[0])) plotter = PDPlotter(pd)
def calculate_phase_stability(args): #This initializes the REST adaptor. a = MPRester(args.api_key) drone = VaspToComputedEntryDrone() entry = drone.assimilate(args.directory) compat = MaterialsProjectCompatibility() entry = compat.process_entry(entry) if not entry: print "Calculation parameters are not consistent with Materials " + \ "Project parameters." sys.exit() syms = [el.symbol for el in entry.composition.elements] #This gets all entries belonging to the relevant system. entries = a.get_entries_in_chemsys(syms) entries.append(entry) #Process entries with Materials Project compatibility. entries = compat.process_entries(entries) print [e.composition.reduced_formula for e in entries]
criteria = {prefix: {'$exists': 1}} projection = {'{}.plotly_urls'.format(prefix): 1} doc[cid] = mpr.query_contributions( 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.) # NOTE x0 might need to be replace with x1 gy.append(x2*math.sqrt(3.)/2.) grid_triang = tri.Triangulation(gx, gy)
class MPResterTest(unittest.TestCase): def setUp(self): self.rester = MPRester() def test_get_data(self): props = ["energy", "energy_per_atom", "formation_energy_per_atom", "nsites", "unit_cell_formula", "pretty_formula", "is_hubbard", "elements", "nelements", "e_above_hull", "hubbards", "is_compatible", "task_ids", "density", "icsd_ids", "total_magnetization"] # unicode literals have been reintroduced in py>3.2 expected_vals = [-191.33812137, -6.833504334642858, -2.551358929370749, 28, {k: v for k, v in {'P': 4, 'Fe': 4, 'O': 16, 'Li': 4}.items()}, "LiFePO4", True, ['Li', 'O', 'P', 'Fe'], 4, 0.0, {k: v for k, v in {'Fe': 5.3, 'Li': 0.0, 'O': 0.0, 'P': 0.0}.items()}, True, [u'mp-601412', u'mp-19017', u'mp-796535', u'mp-797820', u'mp-540081', u'mp-797269'], 3.4662026991351147, [159107, 154117, 160776, 99860, 181272, 166815, 260571, 92198, 165000, 155580, 38209, 161479, 153699, 260569, 260570, 200155, 260572, 181341, 181342, 72545, 56291, 97764, 162282, 155635], 16.0002716] for (i, prop) in enumerate(props): if prop not in ['hubbards', 'unit_cell_formula', 'elements', 'icsd_ids', 'task_ids']: val = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertAlmostEqual(expected_vals[i], val) elif prop in ["elements", "icsd_ids", "task_ids"]: self.assertEqual(set(expected_vals[i]), set(self.rester.get_data("mp-19017", prop=prop)[0][prop])) else: self.assertEqual(expected_vals[i], self.rester.get_data("mp-19017", prop=prop)[0][prop]) props = ['structure', 'initial_structure', 'final_structure', 'entry'] for prop in props: print(prop) obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] if prop.endswith("structure"): self.assertIsInstance(obj, Structure) elif prop == "entry": obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertIsInstance(obj, ComputedEntry) #Test chemsys search data = self.rester.get_data('Fe-Li-O', prop='unit_cell_formula') self.assertTrue(len(data) > 1) elements = {Element("Li"), Element("Fe"), Element("O")} for d in data: self.assertTrue( set(Composition(d['unit_cell_formula']).elements).issubset( elements)) self.assertRaises(MPRestError, self.rester.get_data, "Fe2O3", "badmethod") def test_get_materials_id_from_task_id(self): self.assertEqual(self.rester.get_materials_id_from_task_id( "mp-540081"), "mp-19017") def test_get_materials_id_references(self): # nosetests pymatgen/matproj/tests/test_rest.py:MPResterTest.test_get_materials_id_references m = MPRester() data = m.get_materials_id_references('mp-123') self.assertTrue(len(data) > 1000) def test_find_structure(self): # nosetests pymatgen/matproj/tests/test_rest.py:MPResterTest.test_find_structure m = MPRester() ciffile = os.path.join(test_dir, 'Fe3O4.cif') data = m.find_structure(ciffile) self.assertTrue(len(data) > 1) s = CifParser(ciffile).get_structures()[0] data = m.find_structure(s) self.assertTrue(len(data) > 1) def test_get_entries_in_chemsys(self): syms = ["Li", "Fe", "O"] entries = self.rester.get_entries_in_chemsys(syms) elements = set([Element(sym) for sym in syms]) for e in entries: self.assertIsInstance(e, ComputedEntry) self.assertTrue(set(e.composition.elements).issubset(elements)) def test_get_structure_by_material_id(self): s1 = self.rester.get_structure_by_material_id("mp-1") self.assertEqual(s1.formula, "Cs1") def test_get_entry_by_material_id(self): e = self.rester.get_entry_by_material_id("mp-19017") self.assertIsInstance(e, ComputedEntry) self.assertTrue(e.composition.reduced_formula, "LiFePO4") def test_query(self): criteria = {'elements': {'$in': ['Li', 'Na', 'K'], '$all': ['O']}} props = ['pretty_formula', 'energy'] data = self.rester.query(criteria=criteria, properties=props) self.assertTrue(len(data) > 6) data = self.rester.query(criteria="*2O", properties=props) self.assertGreaterEqual(len(data), 52) self.assertIn("Li2O", (d["pretty_formula"] for d in data)) def test_get_exp_thermo_data(self): data = self.rester.get_exp_thermo_data("Fe2O3") self.assertTrue(len(data) > 0) for d in data: self.assertEqual(d.formula, "Fe2O3") def test_get_dos_by_id(self): dos = self.rester.get_dos_by_material_id("mp-2254") self.assertIsInstance(dos, CompleteDos) def test_get_bandstructure_by_material_id(self): bs = self.rester.get_bandstructure_by_material_id("mp-2254") self.assertIsInstance(bs, BandStructureSymmLine) def test_get_structures(self): structs = self.rester.get_structures("Mn3O4") self.assertTrue(len(structs) > 0) def test_get_entries(self): entries = self.rester.get_entries("TiO2") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.composition.reduced_formula, "TiO2") entries = self.rester.get_entries("TiO2", inc_structure="final") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.structure.composition.reduced_formula, "TiO2") all_entries = self.rester.get_entries("Fe", compatible_only=False) entries = self.rester.get_entries("Fe", compatible_only=True) self.assertTrue(len(entries) < len(all_entries)) entries = self.rester.get_entries("Fe", compatible_only=True, property_data=["cif"]) self.assertIn("cif", entries[0].data) def test_get_exp_entry(self): entry = self.rester.get_exp_entry("Fe2O3") self.assertEqual(entry.energy, -825.5) def test_submit_query_delete_snl(self): s = Structure([[5, 0, 0], [0, 5, 0], [0, 0, 5]], ["Fe"], [[0, 0, 0]]) # d = self.rester.submit_snl( # [s, s], remarks=["unittest"], # authors="Test User <*****@*****.**>") # self.assertEqual(len(d), 2) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 2) # snlids = [d["_id"] for d in data] # self.rester.delete_snl(snlids) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 0) 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_get_reaction(self): rxn = self.rester.get_reaction(["Li", "O"], ["Li2O"]) self.assertIn("Li2O", rxn["Experimental_references"]) def test_get_substrates(self): substrate_data = self.rester.get_substrates('mp-123', 5, [1, 0, 0]) substrates = [sub_dict['sub_id'] for sub_dict in substrate_data] self.assertIn("mp-2534", substrates) def test_parse_criteria(self): crit = MPRester.parse_criteria("mp-1234 Li-*") self.assertIn("Li-O", crit["$or"][1]["chemsys"]["$in"]) self.assertIn({"task_id": "mp-1234"}, crit["$or"]) crit = MPRester.parse_criteria("Li2*") self.assertIn("Li2O", crit["pretty_formula"]["$in"]) self.assertIn("Li2I", crit["pretty_formula"]["$in"]) self.assertIn("CsLi2", crit["pretty_formula"]["$in"]) crit = MPRester.parse_criteria("Li-*-*") self.assertIn("Li-Re-Ru", crit["chemsys"]["$in"]) self.assertNotIn("Li-Li", crit["chemsys"]["$in"]) comps = MPRester.parse_criteria("**O3")["pretty_formula"]["$in"] for c in comps: self.assertEqual(len(Composition(c)), 3, "Failed in %s" % c) chemsys = MPRester.parse_criteria("{Fe,Mn}-O")["chemsys"]["$in"] self.assertEqual(len(chemsys), 2) comps = MPRester.parse_criteria("{Fe,Mn,Co}O")["pretty_formula"]["$in"] self.assertEqual(len(comps), 3, comps) #Let's test some invalid symbols self.assertRaises(ValueError, MPRester.parse_criteria, "li-fe") self.assertRaises(ValueError, MPRester.parse_criteria, "LO2") crit = MPRester.parse_criteria("POPO2") self.assertIn("P2O3", crit["pretty_formula"]["$in"])
class MPResterTest(unittest.TestCase): def setUp(self): self.rester = MPRester() def test_get_data(self): props = [ "energy", "energy_per_atom", "formation_energy_per_atom", "nsites", "unit_cell_formula", "pretty_formula", "is_hubbard", "elements", "nelements", "e_above_hull", "hubbards", "is_compatible", "task_ids", "density", "icsd_ids", "total_magnetization" ] # unicode literals have been reintroduced in py>3.2 expected_vals = [ -191.33812137, -6.833504334642858, -2.551358929370749, 28, {k: v for k, v in { 'P': 4, 'Fe': 4, 'O': 16, 'Li': 4 }.items()}, "LiFePO4", True, ['Li', 'O', 'P', 'Fe'], 4, 0.0, { k: v for k, v in { 'Fe': 5.3, 'Li': 0.0, 'O': 0.0, 'P': 0.0 }.items() }, True, [ u'mp-601412', u'mp-19017', u'mp-796535', u'mp-797820', u'mp-540081', u'mp-797269' ], 3.4662026991351147, [ 159107, 154117, 160776, 99860, 181272, 166815, 260571, 92198, 165000, 155580, 38209, 161479, 153699, 260569, 260570, 200155, 260572, 181341, 181342, 72545, 56291, 97764, 162282, 155635 ], 16.0002716 ] for (i, prop) in enumerate(props): if prop not in [ 'hubbards', 'unit_cell_formula', 'elements', 'icsd_ids', 'task_ids' ]: val = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertAlmostEqual(expected_vals[i], val) elif prop in ["elements", "icsd_ids", "task_ids"]: self.assertEqual( set(expected_vals[i]), set(self.rester.get_data("mp-19017", prop=prop)[0][prop])) else: self.assertEqual( expected_vals[i], self.rester.get_data("mp-19017", prop=prop)[0][prop]) props = ['structure', 'initial_structure', 'final_structure', 'entry'] for prop in props: obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] if prop.endswith("structure"): self.assertIsInstance(obj, Structure) elif prop == "entry": obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertIsInstance(obj, ComputedEntry) #Test chemsys search data = self.rester.get_data('Fe-Li-O', prop='unit_cell_formula') self.assertTrue(len(data) > 1) elements = {Element("Li"), Element("Fe"), Element("O")} for d in data: self.assertTrue( set(Composition( d['unit_cell_formula']).elements).issubset(elements)) self.assertRaises(MPRestError, self.rester.get_data, "Fe2O3", "badmethod") def test_get_materials_id_from_task_id(self): self.assertEqual( self.rester.get_materials_id_from_task_id("mp-540081"), "mp-19017") def test_get_materials_id_references(self): # nosetests pymatgen/matproj/tests/test_rest.py:MPResterTest.test_get_materials_id_references m = MPRester() data = m.get_materials_id_references('mp-123') self.assertTrue(len(data) > 1000) def test_find_structure(self): # nosetests pymatgen/matproj/tests/test_rest.py:MPResterTest.test_find_structure m = MPRester() ciffile = os.path.join(test_dir, 'Fe3O4.cif') data = m.find_structure(ciffile) self.assertTrue(len(data) > 1) s = CifParser(ciffile).get_structures()[0] data = m.find_structure(s) self.assertTrue(len(data) > 1) def test_get_entries_in_chemsys(self): syms = ["Li", "Fe", "O"] entries = self.rester.get_entries_in_chemsys(syms) elements = set([Element(sym) for sym in syms]) for e in entries: self.assertIsInstance(e, ComputedEntry) self.assertTrue(set(e.composition.elements).issubset(elements)) def test_get_structure_by_material_id(self): s1 = self.rester.get_structure_by_material_id("mp-1") self.assertEqual(s1.formula, "Cs1") def test_get_entry_by_material_id(self): e = self.rester.get_entry_by_material_id("mp-19017") self.assertIsInstance(e, ComputedEntry) self.assertTrue(e.composition.reduced_formula, "LiFePO4") def test_query(self): criteria = {'elements': {'$in': ['Li', 'Na', 'K'], '$all': ['O']}} props = ['pretty_formula', 'energy'] data = self.rester.query(criteria=criteria, properties=props) self.assertTrue(len(data) > 6) data = self.rester.query(criteria="*2O", properties=props) self.assertGreaterEqual(len(data), 52) self.assertIn("Li2O", (d["pretty_formula"] for d in data)) def test_get_exp_thermo_data(self): data = self.rester.get_exp_thermo_data("Fe2O3") self.assertTrue(len(data) > 0) for d in data: self.assertEqual(d.formula, "Fe2O3") def test_get_dos_by_id(self): dos = self.rester.get_dos_by_material_id("mp-2254") self.assertIsInstance(dos, CompleteDos) def test_get_bandstructure_by_material_id(self): bs = self.rester.get_bandstructure_by_material_id("mp-2254") self.assertIsInstance(bs, BandStructureSymmLine) def test_get_structures(self): structs = self.rester.get_structures("Mn3O4") self.assertTrue(len(structs) > 0) def test_get_entries(self): entries = self.rester.get_entries("TiO2") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.composition.reduced_formula, "TiO2") entries = self.rester.get_entries("TiO2", inc_structure="final") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.structure.composition.reduced_formula, "TiO2") all_entries = self.rester.get_entries("Fe", compatible_only=False) entries = self.rester.get_entries("Fe", compatible_only=True) self.assertTrue(len(entries) < len(all_entries)) entries = self.rester.get_entries("Fe", compatible_only=True, property_data=["cif"]) self.assertIn("cif", entries[0].data) def test_get_exp_entry(self): entry = self.rester.get_exp_entry("Fe2O3") self.assertEqual(entry.energy, -825.5) def test_submit_query_delete_snl(self): s = Structure([[5, 0, 0], [0, 5, 0], [0, 0, 5]], ["Fe"], [[0, 0, 0]]) # d = self.rester.submit_snl( # [s, s], remarks=["unittest"], # authors="Test User <*****@*****.**>") # self.assertEqual(len(d), 2) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 2) # snlids = [d["_id"] for d in data] # self.rester.delete_snl(snlids) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 0) 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_get_reaction(self): rxn = self.rester.get_reaction(["Li", "O"], ["Li2O"]) self.assertIn("Li2O", rxn["Experimental_references"]) def test_parse_criteria(self): crit = MPRester.parse_criteria("mp-1234 Li-*") self.assertIn("Li-O", crit["$or"][1]["chemsys"]["$in"]) self.assertIn({"task_id": "mp-1234"}, crit["$or"]) crit = MPRester.parse_criteria("Li2*") self.assertIn("Li2O", crit["pretty_formula"]["$in"]) self.assertIn("Li2I", crit["pretty_formula"]["$in"]) self.assertIn("CsLi2", crit["pretty_formula"]["$in"]) crit = MPRester.parse_criteria("Li-*-*") self.assertIn("Li-Re-Ru", crit["chemsys"]["$in"]) self.assertNotIn("Li-Li", crit["chemsys"]["$in"]) comps = MPRester.parse_criteria("**O3")["pretty_formula"]["$in"] for c in comps: self.assertEqual(len(Composition(c)), 3, "Failed in %s" % c) chemsys = MPRester.parse_criteria("{Fe,Mn}-O")["chemsys"]["$in"] self.assertEqual(len(chemsys), 2) comps = MPRester.parse_criteria("{Fe,Mn,Co}O")["pretty_formula"]["$in"] self.assertEqual(len(comps), 3, comps) #Let's test some invalid symbols self.assertRaises(ValueError, MPRester.parse_criteria, "li-fe") self.assertRaises(ValueError, MPRester.parse_criteria, "LO2") crit = MPRester.parse_criteria("POPO2") self.assertIn("P2O3", crit["pretty_formula"]["$in"])
class MPResterTest(unittest.TestCase): def setUp(self): self.rester = MPRester() def test_get_data(self): props = ["energy", "energy_per_atom", "formation_energy_per_atom", "nsites", "unit_cell_formula", "pretty_formula", "is_hubbard", "elements", "nelements", "e_above_hull", "hubbards", "is_compatible", "task_ids", "density", "icsd_ids", "total_magnetization"] expected_vals = [-191.33812137, -6.833504334642858, -2.551358929370749, 28, {u'P': 4, u'Fe': 4, u'O': 16, u'Li': 4}, "LiFePO4", True, [u'Li', u'O', u'P', u'Fe'], 4, 0.0, {u'Fe': 5.3, u'Li': 0.0, u'O': 0.0, u'P': 0.0}, True, ['mp-540081', 'mp-601412', 'mp-19017'], 3.4662026991351147, [159107, 154117, 160776, 99860, 181272, 166815, 260571, 92198, 165000, 155580, 38209, 161479, 153699, 260569, 260570, 200155, 260572, 181341, 181342, 72545, 56291, 97764, 162282, 155635], 16.0002716] for (i, prop) in enumerate(props): if prop not in ['hubbards', 'unit_cell_formula', 'elements', 'icsd_ids', 'task_ids']: val = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertAlmostEqual(expected_vals[i], val) elif prop in ["elements", "icsd_ids", "task_ids"]: self.assertEqual(set(expected_vals[i]), set(self.rester.get_data("mp-19017", prop=prop)[0][prop])) else: self.assertEqual(expected_vals[i], self.rester.get_data("mp-19017", prop=prop)[0][prop]) props = ['structure', 'initial_structure', 'final_structure', 'entry'] for prop in props: obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] if prop.endswith("structure"): self.assertIsInstance(obj, Structure) elif prop == "entry": obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertIsInstance(obj, ComputedEntry) #Test chemsys search data = self.rester.get_data('Fe-Li-O', prop='unit_cell_formula') self.assertTrue(len(data) > 1) elements = {Element("Li"), Element("Fe"), Element("O")} for d in data: self.assertTrue( set(Composition(d['unit_cell_formula']).elements).issubset( elements)) self.assertRaises(MPRestError, self.rester.get_data, "Fe2O3", "badmethod") def test_get_materials_id_from_task_id(self): self.assertEqual(self.rester.get_materials_id_from_task_id( "mp-540081"), "mp-19017") def test_get_entries_in_chemsys(self): syms = ["Li", "Fe", "O"] all_entries = self.rester.get_entries_in_chemsys(syms, False) entries = self.rester.get_entries_in_chemsys(syms) self.assertTrue(len(entries) <= len(all_entries)) elements = set([Element(sym) for sym in syms]) for e in entries: self.assertIsInstance(e, ComputedEntry) self.assertTrue(set(e.composition.elements).issubset(elements)) def test_get_structure_by_material_id(self): s1 = self.rester.get_structure_by_material_id("mp-1") self.assertEqual(s1.formula, "Cs1") def test_get_entry_by_material_id(self): e = self.rester.get_entry_by_material_id("mp-19017") self.assertIsInstance(e, ComputedEntry) self.assertTrue(e.composition.reduced_formula, "LiFePO4") def test_query(self): criteria = {'elements': {'$in': ['Li', 'Na', 'K'], '$all': ['O']}} props = ['formula', 'energy'] data = self.rester.query(criteria=criteria, properties=props) self.assertTrue(len(data) > 6) def test_get_exp_thermo_data(self): data = self.rester.get_exp_thermo_data("Fe2O3") self.assertTrue(len(data) > 0) for d in data: self.assertEqual(d.formula, "Fe2O3") def test_get_dos_by_id(self): dos = self.rester.get_dos_by_material_id("mp-2254") self.assertIsInstance(dos, CompleteDos) def test_get_bandstructure_by_material_id(self): bs = self.rester.get_bandstructure_by_material_id("mp-2254") self.assertIsInstance(bs, BandStructureSymmLine) def test_get_structures(self): structs = self.rester.get_structures("Mn3O4") self.assertTrue(len(structs) > 0) def test_get_entries(self): entries = self.rester.get_entries("TiO2") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.composition.reduced_formula, "TiO2") entries = self.rester.get_entries("TiO2", inc_structure="final") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.structure.composition.reduced_formula, "TiO2") def test_get_exp_entry(self): entry = self.rester.get_exp_entry("Fe2O3") self.assertEqual(entry.energy, -825.5) def test_submit_query_delete_snl(self): s = Structure([[5, 0, 0], [0, 5, 0], [0, 0, 5]], ["Fe"], [[0, 0, 0]]) # d = self.rester.submit_snl( # [s, s], remarks=["unittest"], # authors="Test User <*****@*****.**>") # self.assertEqual(len(d), 2) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 2) # snlids = [d["_id"] for d in data] # self.rester.delete_snl(snlids) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 0) def test_get_stability(self): entries = self.rester.get_entries("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_get_reaction(self): rxn = self.rester.get_reaction(["Li", "O"], ["Li2O"]) self.assertIn("Li2O", rxn["Experimental_references"])
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
class MPResterTest(unittest.TestCase): def setUp(self): self.rester = MPRester() def test_get_data(self): props = ["energy", "energy_per_atom", "formation_energy_per_atom", "nsites", "unit_cell_formula", "pretty_formula", "is_hubbard", "elements", "nelements", "e_above_hull", "hubbards", "is_compatible", "task_ids", "density", "icsd_id", "total_magnetization"] expected_vals = [-191.33812137, -6.833504334642858, -2.551358929370749, 28, {u'P': 4, u'Fe': 4, u'O': 16, u'Li': 4}, "LiFePO4", True, [u'Li', u'O', u'P', u'Fe'], 4, 0.0, {u'Fe': 5.3, u'Li': 0.0, u'O': 0.0, u'P': 0.0}, True, ['mp-540081', 'mp-601412', 'mp-19017'], 3.4662026991351147, [159107, 154117, 160776, 99860, 181272, 166815, 260571, 92198, 165000, 155580, 38209, 161479, 153699, 260569, 260570, 200155, 260572, 181341, 181342, 72545, 56291, 97764, 162282, 155635], 16.0002716] for (i, prop) in enumerate(props): if prop not in ['hubbards', 'unit_cell_formula', 'elements', 'icsd_id']: val = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertAlmostEqual(expected_vals[i], val) elif prop in ["elements", "icsd_id"]: self.assertEqual(set(expected_vals[i]), set(self.rester.get_data("mp-19017", prop=prop)[0][prop])) else: self.assertEqual(expected_vals[i], self.rester.get_data("mp-19017", prop=prop)[0][prop]) props = ['structure', 'initial_structure', 'final_structure', 'entry'] for prop in props: obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] if prop.endswith("structure"): self.assertIsInstance(obj, Structure) elif prop == "entry": obj = self.rester.get_data("mp-19017", prop=prop)[0][prop] self.assertIsInstance(obj, ComputedEntry) #Test chemsys search data = self.rester.get_data('Fe-Li-O', prop='unit_cell_formula') self.assertTrue(len(data) > 1) elements = {Element("Li"), Element("Fe"), Element("O")} for d in data: self.assertTrue( set(Composition(d['unit_cell_formula']).elements).issubset( elements)) self.assertRaises(MPRestError, self.rester.get_data, "Fe2O3", "badmethod") def test_get_materials_id_from_task_id(self): self.assertEqual(self.rester.get_materials_id_from_task_id( "mp-540081"), "mp-19017") def test_get_entries_in_chemsys(self): syms = ["Li", "Fe", "O"] all_entries = self.rester.get_entries_in_chemsys(syms, False) entries = self.rester.get_entries_in_chemsys(syms) self.assertTrue(len(entries) <= len(all_entries)) elements = set([Element(sym) for sym in syms]) for e in entries: self.assertIsInstance(e, ComputedEntry) self.assertTrue(set(e.composition.elements).issubset(elements)) def test_get_structure_by_material_id(self): s1 = self.rester.get_structure_by_material_id("mp-1") self.assertEqual(s1.formula, "Cs1") def test_get_entry_by_material_id(self): e = self.rester.get_entry_by_material_id("mp-19017") self.assertIsInstance(e, ComputedEntry) self.assertTrue(e.composition.reduced_formula, "LiFePO4") def test_mpquery(self): criteria = {'elements': {'$in': ['Li', 'Na', 'K'], '$all': ['O']}} props = ['formula', 'energy'] data = self.rester.mpquery(criteria=criteria, properties=props) self.assertTrue(len(data) > 6) def test_get_exp_thermo_data(self): data = self.rester.get_exp_thermo_data("Fe2O3") self.assertTrue(len(data) > 0) for d in data: self.assertEqual(d.formula, "Fe2O3") def test_get_dos_by_id(self): dos = self.rester.get_dos_by_material_id("mp-2254") self.assertIsInstance(dos, CompleteDos) def test_get_bandstructure_by_material_id(self): bs = self.rester.get_bandstructure_by_material_id("mp-2254") self.assertIsInstance(bs, BandStructureSymmLine) def test_get_structures(self): structs = self.rester.get_structures("Mn3O4") self.assertTrue(len(structs) > 0) for s in structs: self.assertEqual(s.composition.reduced_formula, "Mn3O4") def test_get_entries(self): entries = self.rester.get_entries("TiO2") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.composition.reduced_formula, "TiO2") entries = self.rester.get_entries("TiO2", inc_structure="final") self.assertTrue(len(entries) > 1) for e in entries: self.assertEqual(e.structure.composition.reduced_formula, "TiO2") def test_get_exp_entry(self): entry = self.rester.get_exp_entry("Fe2O3") self.assertEqual(entry.energy, -825.5) def test_submit_query_delete_snl(self): s = Structure([[5, 0, 0], [0, 5, 0], [0, 0, 5]], ["Fe"], [[0, 0, 0]]) # d = self.rester.submit_snl( # [s, s], remarks=["unittest"], # authors="Test User <*****@*****.**>") # self.assertEqual(len(d), 2) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 2) # snlids = [d["_id"] for d in data] # self.rester.delete_snl(snlids) # data = self.rester.query_snl({"about.remarks": "unittest"}) # self.assertEqual(len(data), 0) def test_get_stability(self): entries = self.rester.get_entries("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 entry_data(mtnme_1, mtnme_2, direct_0, mprester_key): """ Obtaining entry and ion data from local source. If the data cannot be found, it will do an HTTP request to the Materials Project database. Args: mtnme_1: Material 1 mtnme_2: Material 2 direct_0: Directory of entry database for binary systems """ #| - entry_data from pymatgen.matproj.rest import MPRester # Access species in MP import warnings; import json; from monty.json import MontyDecoder warnings.filterwarnings('ignore') # Ignore errors related to HTTP request mpr = MPRester(mprester_key) # REST api adaptor, INPUT try: direct_0 = direct_0 #INPUT# direct = direct_0+mtnme_1+'_'+mtnme_2+'/' entries = json.loads(open(direct+'mp_entries.txt','r').read(), cls=MontyDecoder) ion_dict_1 = json.loads(open(direct+'ion_data_1.txt','r').read()) if not mtnme_1==mtnme_2: ion_dict_2 = json.loads(open(direct+'ion_data_2.txt','r').read()) except: pass ################################################################################ ## Obtains all entries in MP corresponding to input element, O and H if mtnme_1==mtnme_2: try: entries = entries except: print 'pd_make.entry_data - made http request line 64' entries = mpr.get_entries_in_chemsys([mtnme_1, 'O', 'H']) ## Dictionary of reference state:experimental formation energy try: ion_dict_1 = ion_dict_1 except: print 'pd_make.entry_data - made http request line 69' ion_dict_1 = mpr._make_request('/pourbaix_diagram/reference_data/'+mtnme_1) out_dict = {"entries" : entries, "ion_dict_1" : ion_dict_1} return out_dict if not mtnme_1==mtnme_2: try: entries = entries except: print 'pd_make.entry_data - made http request - line 146' ## Obtains all entries in MP corresponding to input element, O and H entries = mpr.get_entries_in_chemsys([mtnme_1, mtnme_2, 'O', 'H']) ## Dictionary of reference state:experimental formation energy try: ion_dict_1 == ion_dict_1 ion_dict_2 == ion_dict_2 except: print 'pd_make.entry_data - made http request - line 154' ion_dict_1 = mpr._make_request('/pourbaix_diagram/reference_data/'+mtnme_1) ion_dict_2 = mpr._make_request('/pourbaix_diagram/reference_data/'+mtnme_2) out_dict = {"entries" : entries, "ion_dict_1" : ion_dict_1, "ion_dict_2" : ion_dict_2} return out_dict
doc[cid] = mpr.query_contributions( 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 __init__(self, elements): mpr = MPRester("WTxsDhRV7g2Mcbqw") self.elements = elements self.entries = mpr.get_entries_in_chemsys(elements)