def mp_id(mpid):
"""
materials project の ID から POSCAR を作成
"""
mpr = MPRester("WTxsDhRV7g2Mcbqw")
strctr = mpr.get_structure_by_material_id(mpid)
poscar = Poscar(strctr)
poscar.write_file('POSCAR_{0}'.format(mpid))
def get_INCARs(comp_name, mp_api_key, SOC):
from pymatgen.matproj.rest import MPRester
matproj = MPRester(mp_api_key)
structure = matproj.get_structure_by_material_id(comp_name)
from pymatgen.io.vasp.sets import MPVaspInputSet
from pymatgen.io.vasp.sets import MPGGAVaspInputSet # +U is turned off (if any)
from pymatgen.io.vasp.sets import MPHSEVaspInputSet
from pymatgen.io.vasp.sets import MPStaticVaspInputSet
from pymatgen.io.vasp.sets import MPNonSCFVaspInputSet
from pymatgen.io.vasp.sets import MPStaticDielectricDFPTVaspInputSet
from pymatgen.io.vasp.sets import MPBSHSEVaspInputSet
from pymatgen.io.vasp.sets import MPOpticsNonSCFVaspInputSet
v = MPVaspInputSet()
indic = v.get_incar(structure)
k = v.get_all_vasp_input(structure,generate_potcar = False)
incar_file = open('INCAR','w')
if SOC in ['TRUE', 'True', 'true']:
indic['LMAXMIX'] = 4
indic['NBANDS'] = 128
indic['LSORBIT'] = '.TRUE.'
indic.pop('MAGMOM', None)
incar_file.write(str(indic))
self = MPStaticVaspInputSet()
indic = self.get_incar(structure)
indic['NEDOS'] = 9001
incar_file = open('INCAR_SELF','w')
if SOC in ['TRUE', 'True', 'true']:
indic['LMAXMIX'] = 4
indic['NBANDS'] = 128
indic['LSORBIT'] = '.TRUE.'
indic.pop('MAGMOM', None)
incar_file.write(str(indic))
user_incar_settings = {"NBANDS" : 100}
nself = MPNonSCFVaspInputSet(user_incar_settings)
indic = nself.get_incar(structure)
incar_file = open('INCAR_NSELF','w')
if SOC in ['TRUE', 'True', 'true']:
indic['LMAXMIX'] = 4
indic['NBANDS'] = 128
indic['LSORBIT'] = '.TRUE.'
indic.pop('MAGMOM', None)
incar_file.write(str(indic))
HSE = MPHSEVaspInputSet()
indic = HSE.get_incar(structure)
incar_file = open('INCAR_HSE','w')
if SOC in ['TRUE', 'True', 'true']:
indic['LMAXMIX'] = 4
indic['NBANDS'] = 128
indic['LSORBIT'] = '.TRUE.'
indic.pop('MAGMOM', None)
incar_file.write(str(indic))
def get_INCARs(comp_name, mp_api_key, SOC):
from pymatgen.matproj.rest import MPRester
matproj = MPRester(mp_api_key)
structure = matproj.get_structure_by_material_id(comp_name)
from pymatgen.io.vasp.sets import MPVaspInputSet
from pymatgen.io.vasp.sets import MPGGAVaspInputSet # +U is turned off (if any)
from pymatgen.io.vasp.sets import MPHSEVaspInputSet
from pymatgen.io.vasp.sets import MPStaticVaspInputSet
from pymatgen.io.vasp.sets import MPNonSCFVaspInputSet
from pymatgen.io.vasp.sets import MPStaticDielectricDFPTVaspInputSet
from pymatgen.io.vasp.sets import MPBSHSEVaspInputSet
from pymatgen.io.vasp.sets import MPOpticsNonSCFVaspInputSet
v = MPVaspInputSet()
indic = v.get_incar(structure)
k = v.get_all_vasp_input(structure, generate_potcar=False)
incar_file = open('INCAR', 'w')
# if SOC in ['TRUE', 'True', 'true']:
# indic['LMAXMIX'] = 4
# indic['NBANDS'] = soc_NBANDS
# indic['LSORBIT'] = '.TRUE.'
# indic.pop('MAGMOM', None)
incar_file.write(str(indic))
self = MPStaticVaspInputSet()
indic = self.get_incar(structure)
indic['NEDOS'] = 9001
incar_file = open('INCAR_SELF', 'w')
if SOC in ['TRUE', 'True', 'true']:
indic['LMAXMIX'] = 4
indic['NBANDS'] = soc_NBANDS
indic['LSORBIT'] = '.TRUE.'
indic.pop('MAGMOM', None)
incar_file.write(str(indic))
user_incar_settings = {"NBANDS": 100}
nself = MPNonSCFVaspInputSet(user_incar_settings)
indic = nself.get_incar(structure)
incar_file = open('INCAR_NSELF', 'w')
if SOC in ['TRUE', 'True', 'true']:
indic['LMAXMIX'] = 4
indic['NBANDS'] = soc_NBANDS
indic['LSORBIT'] = '.TRUE.'
indic.pop('MAGMOM', None)
incar_file.write(str(indic))
HSE = MPHSEVaspInputSet()
indic = HSE.get_incar(structure)
incar_file = open('INCAR_HSE', 'w')
if SOC in ['TRUE', 'True', 'true']:
indic['LMAXMIX'] = 4
indic['NBANDS'] = soc_NBANDS
indic['LSORBIT'] = '.TRUE.'
indic.pop('MAGMOM', None)
incar_file.write(str(indic))
def benchmark_input_scf(request):
pseudos = abidata.pseudos("14si.pspnc", "6c.pspnc", "3li.pspnc", "9f.pspnc",
"12mg.pspnc", "8o.pspnc", "31ga.pspnc", "7n.pspnc")
rest = MPRester()
structure = rest.get_structure_by_material_id(request.param)
try:
return ebands_input(structure, pseudos, kppa=100, ecut=6).split_datasets()[0]
except:
#to deal with missing pseudos
pytest.skip('Cannot create input for material {}.'.format(request.param))
def benchmark_input_scf(request):
pseudos = abidata.pseudos("14si.pspnc", "6c.pspnc", "3li.pspnc", "9f.pspnc",
"12mg.pspnc", "8o.pspnc", "31ga.pspnc", "7n.pspnc")
rest = MPRester()
structure = rest.get_structure_by_material_id(request.param)
try:
return ebands_input(structure, pseudos, kppa=100, ecut=6).split_datasets()[0]
except:
#to deal with missing pseudos
pytest.skip('Cannot create input for material {}.'.format(request.param))
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"])
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"])
from pymatgen.io.vaspio.vasp_input import Kpoints,Incar
from pymatgen.io.vaspio.vasp_output import Outcar, Vasprun
from pymatgen.io.vaspio_set import MPNonSCFVaspInputSet, MPStaticVaspInputSet
import os
if __name__ == '__main__':
mpr = MPRester(api_key="UhlZvcEux2kmJSQx")
id_expgap = open("ids.txt", "r")
for line in id_expgap:
words=line.split()
print words
id_line=words[0]
vasp_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), str(id_line))
vasp_run = Vasprun(os.path.join(vasp_dir,"vasprun.xml")).to_dict
nband = int(vasp_run['input']['parameters']['NBANDS'])
os.chdir(id_line)
user_incar_settings={"EDIFF":1E-4,"NBANDS":nband,"NSW":0}
mpvis = MPNonSCFVaspInputSet(user_incar_settings=user_incar_settings)
s = mpr.get_structure_by_material_id(id_line)
mpvis.get_kpoints(s).write_file('KPOINTS')
mpvis.get_incar(s).write_file('INCAR')
os.chdir('..')
id_expgap.close()
def run_task(self, fw_spec):
logging.basicConfig(
filename='chemenv_structure_environments.log',
format='%(levelname)s:%(module)s:%(funcName)s:%(message)s',
level=logging.DEBUG)
lgf = LocalGeometryFinder()
lgf.setup_parameters(
centering_type='centroid',
include_central_site_in_centroid=True,
structure_refinement=lgf.STRUCTURE_REFINEMENT_NONE)
if 'chemenv_parameters' in fw_spec:
for param, value in fw_spec['chemenv_parameters'].items():
lgf.setup_parameter(param, value)
identifier = fw_spec['identifier']
if 'structure' in fw_spec:
structure = fw_spec['structure']
else:
if identifier[
'source'] == 'MaterialsProject' and 'material_id' in identifier:
if not 'mapi_key' in fw_spec:
raise ValueError(
'The mapi_key should be provided to get the structure from the Materials Project'
)
a = MPRester(fw_spec['mapi_key'])
structure = a.get_structure_by_material_id(
identifier['material_id'])
else:
raise ValueError(
'Either structure or identifier with source = MaterialsProject and material_id '
'should be provided')
info = {}
# Compute the structure environments
lgf.setup_structure(structure)
if 'valences' in fw_spec:
valences = fw_spec['valences']
else:
try:
bva = BVAnalyzer()
valences = bva.get_valences(structure=structure)
info['valences'] = {'origin': 'BVAnalyzer'}
except:
valences = 'undefined'
info['valences'] = {'origin': 'None'}
excluded_atoms = None
if 'excluded_atoms' in fw_spec:
excluded_atoms = fw_spec['excluded_atoms']
se = lgf.compute_structure_environments(only_cations=False,
valences=valences,
excluded_atoms=excluded_atoms)
# Write to json file
if 'json_file' in fw_spec:
json_file = fw_spec['json_file']
else:
json_file = 'structure_environments.json'
f = open(json_file, 'w')
json.dump(se.as_dict(), f)
f.close()
# Save to database
if 'mongo_database' in fw_spec:
database = fw_spec['mongo_database']
entry = {
'identifier':
identifier,
'elements':
[elmt.symbol for elmt in structure.composition.elements],
'nelements':
len(structure.composition.elements),
'pretty_formula':
structure.composition.reduced_formula,
'nsites':
len(structure)
}
saving_option = fw_spec['saving_option']
if saving_option == 'gridfs':
gridfs_msonables = {
'structure': structure,
'structure_environments': se
}
elif saving_option == 'storefile':
gridfs_msonables = None
if 'se_prefix' in fw_spec:
se_prefix = fw_spec['se_prefix']
if not se_prefix.isalpha():
raise ValueError(
'Prefix for structure_environments file is "{}" '
'while it should be alphabetic'.format(se_prefix))
else:
se_prefix = ''
if se_prefix:
se_rfilename = '{}_{}.json'.format(
se_prefix, fw_spec['storefile_basename'])
else:
se_rfilename = '{}.json'.format(
fw_spec['storefile_basename'])
se_rfilepath = '{}/{}'.format(fw_spec['storefile_dirpath'],
se_rfilename)
storage_server = fw_spec['storage_server']
storage_server.put(localpath=json_file,
remotepath=se_rfilepath,
overwrite=True,
makedirs=False)
entry['structure_environments_file'] = se_rfilepath
else:
raise ValueError(
'Saving option is "{}" while it should be '
'"gridfs" or "storefile"'.format(saving_option))
criteria = {'identifier': identifier}
if database.collection.find(criteria).count() == 1:
database.update_entry(query=criteria,
entry_update=entry,
gridfs_msonables=gridfs_msonables)
else:
database.insert_entry(entry=entry,
gridfs_msonables=gridfs_msonables)
def run_task(self, fw_spec):
logging.basicConfig(filename='chemenv_structure_environments.log',
format='%(levelname)s:%(module)s:%(funcName)s:%(message)s',
level=logging.DEBUG)
lgf = LocalGeometryFinder()
lgf.setup_parameters(centering_type='centroid', include_central_site_in_centroid=True,
structure_refinement=lgf.STRUCTURE_REFINEMENT_NONE)
if 'chemenv_parameters' in fw_spec:
for param, value in fw_spec['chemenv_parameters'].items():
lgf.setup_parameter(param, value)
identifier = fw_spec['identifier']
if 'structure' in fw_spec:
structure = fw_spec['structure']
else:
if identifier['source'] == 'MaterialsProject' and 'material_id' in identifier:
if not 'mapi_key' in fw_spec:
raise ValueError('The mapi_key should be provided to get the structure from the Materials Project')
# FIXME: Use MPRester from pymatgen
from pymatgen.matproj.rest import MPRester
a = MPRester(fw_spec['mapi_key'])
structure = a.get_structure_by_material_id(identifier['material_id'])
else:
raise ValueError('Either structure or identifier with source = MaterialsProject and material_id '
'should be provided')
info = {}
# Compute the structure environments
lgf.setup_structure(structure)
if 'valences' in fw_spec:
valences = fw_spec['valences']
else:
try:
bva = BVAnalyzer()
valences = bva.get_valences(structure=structure)
info['valences'] = {'origin': 'BVAnalyzer'}
except:
valences = 'undefined'
info['valences'] = {'origin': 'None'}
excluded_atoms = None
if 'excluded_atoms' in fw_spec:
excluded_atoms = fw_spec['excluded_atoms']
se = lgf.compute_structure_environments(only_cations=False, valences=valences, excluded_atoms=excluded_atoms)
# Write to json file
if 'json_file' in fw_spec:
json_file = fw_spec['json_file']
else:
json_file = 'structure_environments.json'
f = open(json_file, 'w')
json.dump(se.as_dict(), f)
f.close()
# Save to database
if 'mongo_database' in fw_spec:
database = fw_spec['mongo_database']
entry = {'identifier': identifier,
'elements': [elmt.symbol for elmt in structure.composition.elements],
'nelements': len(structure.composition.elements),
'pretty_formula': structure.composition.reduced_formula,
'nsites': len(structure)
}
saving_option = fw_spec['saving_option']
if saving_option == 'gridfs':
gridfs_msonables = {'structure': structure,
'structure_environments': se}
elif saving_option == 'storefile':
gridfs_msonables = None
if 'se_prefix' in fw_spec:
se_prefix = fw_spec['se_prefix']
if not se_prefix.isalpha():
raise ValueError('Prefix for structure_environments file is "{}" '
'while it should be alphabetic'.format(se_prefix))
else:
se_prefix = ''
if se_prefix:
se_rfilename = '{}_{}.json'.format(se_prefix, fw_spec['storefile_basename'])
else:
se_rfilename = '{}.json'.format(fw_spec['storefile_basename'])
se_rfilepath = '{}/{}'.format(fw_spec['storefile_dirpath'], se_rfilename)
storage_server = fw_spec['storage_server']
storage_server.put(localpath=json_file, remotepath=se_rfilepath, overwrite=True, makedirs=False)
entry['structure_environments_file'] = se_rfilepath
else:
raise ValueError('Saving option is "{}" while it should be '
'"gridfs" or "storefile"'.format(saving_option))
criteria = {'identifier': identifier}
if database.collection.find(criteria).count() == 1:
database.update_entry(query=criteria, entry_update=entry,
gridfs_msonables=gridfs_msonables)
else:
database.insert_entry(entry=entry, gridfs_msonables=gridfs_msonables)
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"])
