def __init__(self, package_options=None):
if SETTINGS.get("PMG_MAPI_KEY", "") != "":
self.materials_project_configuration = SETTINGS.get("PMG_MAPI_KEY", "")
else:
self.materials_project_configuration = None
if package_options is None:
self.package_options = self.DEFAULT_PACKAGE_OPTIONS
else:
self.package_options = package_options
def __init__(self, api_key=None,
endpoint="https://www.materialsproject.org/rest/v2"):
if api_key is not None:
self.api_key = api_key
else:
self.api_key = SETTINGS.get("MAPI_KEY", "")
self.preamble = endpoint
self.session = requests.Session()
self.session.headers = {"x-api-key": self.api_key}
def setUpClass(cls):
# TODO: update this for the latest pymatgen...
if not SETTINGS.get("VASP_PSP_DIR"):
SETTINGS["VASP_PSP_DIR"] = os.path.join(module_dir, "reference_files")
print('This system is not set up to run VASP jobs. '
'Please set VASP_PSP_DIR variable in your ~/.pmgrc.yaml file.')
cls.struct_si = PymatgenTest.get_structure("Si")
cls.scratch_dir = os.path.join(module_dir, "scratch")
def setUpClass(cls):
if not SETTINGS.get("VASP_PSP_DIR"):
SETTINGS["VASP_PSP_DIR"] = os.path.join(module_dir, "..", "..", "tests", "reference_files")
print(
"This system is not set up to run VASP jobs. "
"Please set VASP_PSP_DIR variable in your ~/.pmgrc.yaml file."
)
cls.struct_si = PymatgenTest.get_structure("Si")
cls.scratch_dir = os.path.join(module_dir, "scratch")
cls.raman_config = {"modes": [0, 1], "step_size": 0.005, "vasp_cmd": ">>vasp_cmd<<", "db_file": ">>db_file<<"}
cls.wf = wf_raman_spectra(cls.struct_si, cls.raman_config)
def setUpClass(cls):
if not SETTINGS.get("VASP_PSP_DIR"):
SETTINGS["VASP_PSP_DIR"] = os.path.join(module_dir, "..", "..", "tests", "reference_files")
print('This system is not set up to run VASP jobs. '
'Please set VASP_PSP_DIR variable in your ~/.pmgrc.yaml file.')
cls.struct_si = SpacegroupAnalyzer(
PymatgenTest.get_structure("Si")).get_conventional_standard_structure()
cls.scratch_dir = os.path.join(module_dir, "scratch")
cls.elastic_config = {"norm_deformations":[0.01],
"shear_deformations":[0.03],
"vasp_cmd": ">>vasp_cmd<<", "db_file": ">>db_file<<"}
cls.wf = wf_elastic_constant(cls.struct_si, cls.elastic_config)
def setUpClass(cls):
if not SETTINGS.get("VASP_PSP_DIR"):
SETTINGS["VASP_PSP_DIR"] = os.path.join(module_dir, "reference_files")
print(
"This system is not set up to run VASP jobs. "
"Please set VASP_PSP_DIR variable in your ~/.pmgrc.yaml file."
)
cls.struct_si = PymatgenTest.get_structure("Si")
cls.ref_incar = Incar.from_file(os.path.join(module_dir, "reference_files", "setup_test", "INCAR"))
cls.ref_poscar = Poscar.from_file(os.path.join(module_dir, "reference_files", "setup_test", "POSCAR"))
cls.ref_potcar = Potcar.from_file(os.path.join(module_dir, "reference_files", "setup_test", "POTCAR"))
cls.ref_kpoints = Kpoints.from_file(os.path.join(module_dir, "reference_files", "setup_test", "KPOINTS"))
cls.ref_incar_preserve = Incar.from_file(os.path.join(module_dir, "reference_files", "preserve_incar", "INCAR"))
def setUpClass(cls):
if not SETTINGS.get("VASP_PSP_DIR"):
raise unittest.SkipTest(
"This system is not set up to run VASP jobs. "
"Please set VASP_PSP_DIR variable in your ~/.pmgrc.yaml file."
)
coords = [[0, 0, 0], [0.75, 0.5, 0.75]]
lattice = Lattice(
[[3.8401979337, 0.00, 0.00], [1.9200989668, 3.3257101909, 0.00], [0.00, -2.2171384943, 3.1355090603]]
)
cls.struct_si = IStructure(lattice, ["Si"] * 2, coords)
cls.ref_incar = Incar.from_file(os.path.join(module_dir, "reference_files", "setup_test", "INCAR"))
cls.ref_poscar = Poscar.from_file(os.path.join(module_dir, "reference_files", "setup_test", "POSCAR"))
cls.ref_potcar = Potcar.from_file(os.path.join(module_dir, "reference_files", "setup_test", "POTCAR"))
cls.ref_kpoints = Kpoints.from_file(os.path.join(module_dir, "reference_files", "setup_test", "KPOINTS"))
def __init__(self, api_key=None,
endpoint="https://www.materialsproject.org/rest/v2"):
if api_key is not None:
self.api_key = api_key
else:
self.api_key = SETTINGS.get("PMG_MAPI_KEY", "")
self.preamble = endpoint
import requests
try:
from pybtex import __version__
except ImportError:
warnings.warn("If you query for structure data encoded using MP's "
"Structure Notation Language (SNL) format and you use "
"`mp_decode=True` (the default) for MPRester queries, "
"you should install dependencies via "
"`pip install pymatgen[matproj.snl]`.")
self.session = requests.Session()
self.session.headers = {"x-api-key": self.api_key}
def get_mprester(api_key=None, endpoint=None):
"""
Args:
api_key (str): A String API key for accessing the MaterialsProject
REST interface. Please apply on the Materials Project website for one.
If this is None, the code will check if there is a `PMG_MAPI_KEY` in
your .pmgrc.yaml. If so, it will use that environment
This makes easier for heavy users to simply add
this environment variable to their setups and MPRester can
then be called without any arguments.
endpoint (str): Url of endpoint to access the MaterialsProject REST interface.
Defaults to the standard Materials Project REST address, but
can be changed to other urls implementing a similar interface.
"""
if api_key is None:
api_key = SETTINGS.get("PMG_MAPI_KEY")
if api_key is None:
raise RuntimeError("Cannot find PMG_MAPI_KEY in pymatgen settings. Add it to $HOME/.pmgrc.yaml")
if endpoint is None: endpoint = MP_DEFAULT_ENDPOINT
return MyMPRester(api_key=api_key, endpoint=endpoint)
def setUp(self, lpad=True):
"""
Create scratch directory(removes the old one if there is one) and change to it.
Also initialize launchpad.
"""
if not SETTINGS.get("PMG_VASP_PSP_DIR"):
SETTINGS["PMG_VASP_PSP_DIR"] = os.path.abspath(os.path.join(MODULE_DIR, "..", "vasp", "test_files"))
print('This system is not set up to run VASP jobs. '
'Please set PMG_VASP_PSP_DIR variable in your ~/.pmgrc.yaml file.')
self.scratch_dir = os.path.join(MODULE_DIR, "scratch")
if os.path.exists(self.scratch_dir):
shutil.rmtree(self.scratch_dir)
os.makedirs(self.scratch_dir)
os.chdir(self.scratch_dir)
if lpad:
try:
self.lp = LaunchPad.from_file(os.path.join(DB_DIR, "my_launchpad.yaml"))
self.lp.reset("", require_password=False)
except:
raise unittest.SkipTest('Cannot connect to MongoDB! Is the database server running? '
'Are the credentials correct?')
def main():
parser = argparse.ArgumentParser(description="""
pmg is a convenient script that uses pymatgen to perform many
analyses, plotting and format conversions. This script works based on
several sub-commands with their own options. To see the options for the
sub-commands, type "pmg sub-command -h".""",
epilog="""
Author: Shyue Ping Ong
Version: {}
Last updated: {}""".format(__version__, __date__))
subparsers = parser.add_subparsers()
parser_config = subparsers.add_parser(
"config",
help="Tools for configuring pymatgen, e.g., "
"potcar setup, modifying .pmgrc.yaml "
"configuration file.")
groups = parser_config.add_mutually_exclusive_group(required=True)
groups.add_argument("-p",
"--potcar",
dest="potcar_dirs",
metavar="dir_name",
nargs=2,
help="Initial directory where downloaded VASP "
"POTCARs are extracted to, and the "
"output directory where the reorganized "
"potcars will be stored. The input "
"directory should be "
"the parent directory that contains the "
"POT_GGA_PAW_PBE or potpaw_PBE type "
"subdirectories.")
groups.add_argument("-i",
"--install",
dest="install",
metavar="package_name",
choices=["enumlib", "bader"],
help="Install various optional command line "
"tools needed for full functionality.")
groups.add_argument("-a",
"--add",
dest="var_spec",
nargs="+",
help="Variables to add in the form of space "
"separated key value pairs. E.g., "
"PMG_VASP_PSP_DIR ~/psps")
parser_config.set_defaults(func=configure_pmg)
parser_analyze = subparsers.add_parser(
"analyze", help="Vasp calculation analysis tools.")
parser_analyze.add_argument("directories",
metavar="dir",
default=".",
type=str,
nargs="*",
help="directory to process (default to .)")
parser_analyze.add_argument("-e",
"--energies",
dest="get_energies",
action="store_true",
help="Print energies")
parser_analyze.add_argument(
"-m",
"--mag",
dest="ion_list",
type=str,
nargs=1,
help="Print magmoms. ION LIST can be a range "
"(e.g., 1-2) or the string 'All' for all ions.")
parser_analyze.add_argument(
"-r",
"--reanalyze",
dest="reanalyze",
action="store_true",
help="Force reanalysis. Typically, vasp_analyzer"
" will just reuse a vasp_analyzer_data.gz if "
"present. This forces the analyzer to reanalyze "
"the data.")
parser_analyze.add_argument(
"-f",
"--format",
dest="format",
choices=tabulate_formats,
default="simple",
help="Format for table. Supports all options in tabulate package.")
parser_analyze.add_argument(
"-v",
"--verbose",
dest="verbose",
action="store_true",
help="Verbose mode. Provides detailed output on progress.")
parser_analyze.add_argument(
"-d",
"--detailed",
dest="detailed",
action="store_true",
help="Detailed, but slower mode. Parses vasprun.xml instead of "
"separate vasp outputs.")
parser_analyze.add_argument(
"-s",
"--sort",
dest="sort",
choices=["energy_per_atom", "filename"],
default="energy_per_atom",
help="Sort criteria. Defaults to energy / atom.")
parser_analyze.set_defaults(func=analyze)
parser_query = subparsers.add_parser(
"query",
help="Search for structures and data from the Materials Project.")
parser_query.add_argument(
"criteria",
metavar="criteria",
help="Search criteria. Supported formats in formulas, chemical "
"systems, Materials Project ids, etc.")
group = parser_query.add_mutually_exclusive_group(required=True)
group.add_argument(
"-s",
"--structure",
dest="structure",
metavar="format",
choices=["poscar", "cif", "cssr"],
type=str.lower,
help="Get structures from Materials Project and write them to a "
"specified format.")
group.add_argument(
"-e",
"--entries",
dest="entries",
metavar="filename",
help="Get entries from Materials Project and write them to "
"serialization file. JSON and YAML supported.")
group.add_argument(
"-d",
"--data",
dest="data",
metavar="fields",
nargs="*",
help="Print a summary of entries in the Materials Project satisfying "
"the criteria. Supply field names to include additional data. "
"By default, the Materials Project id, formula, spacegroup, "
"energy per atom, energy above hull are shown.")
parser_query.set_defaults(func=do_query)
parser_plot = subparsers.add_parser("plot",
help="Plotting tool for "
"DOS, CHGCAR, XRD, etc.")
group = parser_plot.add_mutually_exclusive_group(required=True)
group.add_argument('-d',
'--dos',
dest="dos_file",
metavar="vasprun.xml",
help="Plot DOS from a vasprun.xml")
group.add_argument('-c',
'--chgint',
dest="chgcar_file",
metavar="CHGCAR",
help="Generate charge integration plots from any "
"CHGCAR")
group.add_argument('-x',
'--xrd',
dest="xrd_structure_file",
metavar="structure_file",
help="Generate XRD plots from any supported structure "
"file, e.g., CIF, POSCAR, vasprun.xml, etc.")
parser_plot.add_argument("-s",
"--site",
dest="site",
action="store_const",
const=True,
help="Plot site projected DOS")
parser_plot.add_argument("-e",
"--element",
dest="element",
type=str,
nargs=1,
help="List of elements to plot as comma-separated"
" values e.g., Fe,Mn")
parser_plot.add_argument("-o",
"--orbital",
dest="orbital",
action="store_const",
const=True,
help="Plot orbital projected DOS")
parser_plot.add_argument("-i",
"--indices",
dest="inds",
type=str,
nargs=1,
help="Comma-separated list of indices to plot "
"charge integration, e.g., 1,2,3,4. If not "
"provided, the code will plot the chgint "
"for all symmetrically distinct atoms "
"detected.")
parser_plot.add_argument("-r",
"--radius",
dest="radius",
type=float,
default=3,
help="Radius of integration for charge "
"integration plot.")
parser_plot.add_argument("--out_file",
dest="out_file",
type=str,
help="Save plot to file instead of displaying.")
parser_plot.set_defaults(func=plot)
parser_structure = subparsers.add_parser(
"structure", help="Structure conversion and analysis tools.")
parser_structure.add_argument("-f",
"--filenames",
dest="filenames",
metavar="filename",
nargs="+",
help="List of structure files.")
groups = parser_structure.add_mutually_exclusive_group(required=True)
groups.add_argument("-c",
"--convert",
dest="convert",
action="store_true",
help="Convert from structure file 1 to structure "
"file 2. Format determined from filename. "
"Supported formats include POSCAR/CONTCAR, "
"CIF, CSSR, etc. If the keyword'prim' is within "
"the filename, the code will automatically attempt "
"to find a primitive cell.")
groups.add_argument("-s",
"--symmetry",
dest="symmetry",
metavar="tolerance",
type=float,
help="Determine the spacegroup using the "
"specified tolerance. 0.1 is usually a good "
"value for DFT calculations.")
groups.add_argument("-g",
"--group",
dest="group",
choices=["element", "species"],
metavar="mode",
help="Compare a set of structures for similarity. "
"Element mode does not compare oxidation states. "
"Species mode will take into account oxidations "
"states.")
groups.add_argument(
"-l",
"--localenv",
dest="localenv",
nargs="+",
help="Local environment analysis. Provide bonds in the format of"
"Center Species-Ligand Species=max_dist, e.g., H-O=0.5.")
parser_structure.set_defaults(func=analyze_structures)
parser_view = subparsers.add_parser("view", help="Visualize structures")
parser_view.add_argument("filename",
metavar="filename",
type=str,
nargs=1,
help="Filename")
parser_view.add_argument("-e",
"--exclude_bonding",
dest="exclude_bonding",
type=str,
nargs=1,
help="List of elements to exclude from bonding "
"analysis. E.g., Li,Na")
parser_view.set_defaults(func=parse_view)
parser_diff = subparsers.add_parser(
"diff", help="Diffing tool. For now, only INCAR supported.")
parser_diff.add_argument("-i",
"--incar",
dest="incars",
metavar="INCAR",
required=True,
nargs=2,
help="List of INCARs to compare.")
parser_diff.set_defaults(func=diff_incar)
parser_potcar = subparsers.add_parser("potcar", help="Generate POTCARs")
parser_potcar.add_argument("-f",
"--functional",
dest="functional",
type=str,
choices=sorted(Potcar.FUNCTIONAL_CHOICES),
default=SETTINGS.get("PMG_DEFAULT_FUNCTIONAL",
"PBE"),
help="Functional to use. Unless otherwise "
"stated (e.g., US), "
"refers to PAW psuedopotential.")
group = parser_potcar.add_mutually_exclusive_group(required=True)
group.add_argument("-s",
"--symbols",
dest="symbols",
type=str,
nargs="+",
help="List of POTCAR symbols. Use -f to set "
"functional. Defaults to PBE.")
group.add_argument("-r",
"--recursive",
dest="recursive",
type=str,
nargs="+",
help="Dirname to find and generate from POTCAR.spec.")
parser_potcar.set_defaults(func=generate_potcar)
try:
import argcomplete
argcomplete.autocomplete(parser)
except ImportError:
# argcomplete not present.
pass
args = parser.parse_args()
try:
getattr(args, "func")
except AttributeError:
parser.print_help()
sys.exit(0)
args.func(args)
from pymatgen.util.testing import PymatgenTest
"""
Created on Jun 9, 2012
"""
__author__ = "Shyue Ping Ong"
__copyright__ = "Copyright 2012, The Materials Project"
__version__ = "0.1"
__maintainer__ = "Shyue Ping Ong"
__email__ = "*****@*****.**"
__date__ = "Jun 9, 2012"
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"),
"PMG_MAPI_KEY environment variable not set.")
class MPResterTest(PymatgenTest):
_multiprocess_shared_ = True
def setUp(self):
self.rester = MPRester()
warnings.simplefilter("ignore")
def tearDown(self):
warnings.simplefilter("default")
def test_get_all_materials_ids_doc(self):
mids = self.rester.get_materials_ids("Al2O3")
random.shuffle(mids)
doc = self.rester.get_doc(mids.pop(0))
class PourbaixDiagramTest(unittest.TestCase):
_multiprocess_shared_ = True
@classmethod
def setUpClass(cls):
cls.test_data = loadfn(os.path.join(PymatgenTest.TEST_FILES_DIR, "pourbaix_test_data.json"))
cls.pbx = PourbaixDiagram(cls.test_data["Zn"], filter_solids=True)
cls.pbx_nofilter = PourbaixDiagram(cls.test_data["Zn"], filter_solids=False)
def test_pourbaix_diagram(self):
self.assertEqual(
set([e.name for e in self.pbx.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"},
"List of stable entries does not match",
)
self.assertEqual(
set([e.name for e in self.pbx_nofilter.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)", "ZnO2(s)", "ZnH(s)"},
"List of stable entries for unfiltered pbx does not match",
)
pbx_lowconc = PourbaixDiagram(self.test_data["Zn"], conc_dict={"Zn": 1e-8}, filter_solids=True)
self.assertEqual(
set([e.name for e in pbx_lowconc.stable_entries]),
{"Zn(HO)2(aq)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"},
)
def test_properties(self):
self.assertEqual(len(self.pbx.unstable_entries), 2)
def test_multicomponent(self):
# Assure no ions get filtered at high concentration
ag_n = [e for e in self.test_data["Ag-Te-N"] if "Te" not in e.composition]
highconc = PourbaixDiagram(ag_n, filter_solids=True, conc_dict={"Ag": 1e-5, "N": 1})
entry_sets = [set(e.entry_id) for e in highconc.stable_entries]
self.assertIn({"mp-124", "ion-17"}, entry_sets)
# Binary system
pd_binary = PourbaixDiagram(
self.test_data["Ag-Te"],
filter_solids=True,
comp_dict={"Ag": 0.5, "Te": 0.5},
conc_dict={"Ag": 1e-8, "Te": 1e-8},
)
self.assertEqual(len(pd_binary.stable_entries), 30)
test_entry = pd_binary.find_stable_entry(8, 2)
self.assertTrue("mp-499" in test_entry.entry_id)
# Find a specific multientry to test
self.assertEqual(pd_binary.get_decomposition_energy(test_entry, 8, 2), 0)
pd_ternary = PourbaixDiagram(self.test_data["Ag-Te-N"], filter_solids=True)
self.assertEqual(len(pd_ternary.stable_entries), 49)
# Fetch a solid entry and a ground state entry mixture
ag_te_n = self.test_data["Ag-Te-N"][-1]
ground_state_ag_with_ions = MultiEntry(
[self.test_data["Ag-Te-N"][i] for i in [4, 18, 30]],
weights=[1 / 3, 1 / 3, 1 / 3],
)
self.assertAlmostEqual(pd_ternary.get_decomposition_energy(ag_te_n, 2, -1), 2.767822855765)
self.assertAlmostEqual(pd_ternary.get_decomposition_energy(ag_te_n, 10, -2), 3.756840056890625)
self.assertAlmostEqual(pd_ternary.get_decomposition_energy(ground_state_ag_with_ions, 2, -1), 0)
# Test invocation of pourbaix diagram from ternary data
new_ternary = PourbaixDiagram(pd_ternary.all_entries)
self.assertEqual(len(new_ternary.stable_entries), 49)
self.assertAlmostEqual(new_ternary.get_decomposition_energy(ag_te_n, 2, -1), 2.767822855765)
self.assertAlmostEqual(new_ternary.get_decomposition_energy(ag_te_n, 10, -2), 3.756840056890625)
self.assertAlmostEqual(new_ternary.get_decomposition_energy(ground_state_ag_with_ions, 2, -1), 0)
def test_get_pourbaix_domains(self):
domains = PourbaixDiagram.get_pourbaix_domains(self.test_data["Zn"])
self.assertEqual(len(domains[0]), 7)
def test_get_decomposition(self):
# Test a stable entry to ensure that it's zero in the stable region
entry = self.test_data["Zn"][12] # Should correspond to mp-2133
self.assertAlmostEqual(
self.pbx.get_decomposition_energy(entry, 10, 1),
0.0,
5,
"Decomposition energy of ZnO is not 0.",
)
# Test an unstable entry to ensure that it's never zero
entry = self.test_data["Zn"][11]
ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-2, 4))
result = self.pbx_nofilter.get_decomposition_energy(entry, ph, v)
self.assertTrue((result >= 0).all(), "Unstable energy has hull energy of 0 or less")
# Test an unstable hydride to ensure HER correction works
self.assertAlmostEqual(self.pbx.get_decomposition_energy(entry, -3, -2), 3.6979147983333)
# Test a list of pHs
self.pbx.get_decomposition_energy(entry, np.linspace(0, 2, 5), 2)
# Test a list of Vs
self.pbx.get_decomposition_energy(entry, 4, np.linspace(-3, 3, 10))
# Test a set of matching arrays
ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-3, 3))
self.pbx.get_decomposition_energy(entry, ph, v)
def test_get_stable_entry(self):
entry = self.pbx.get_stable_entry(0, 0)
self.assertEqual(entry.entry_id, "ion-0")
def test_multielement_parallel(self):
# Simple test to ensure that multiprocessing is working
test_entries = self.test_data["Ag-Te-N"]
nproc = multiprocessing.cpu_count()
pbx = PourbaixDiagram(test_entries, filter_solids=True, nproc=nproc)
self.assertEqual(len(pbx.stable_entries), 49)
def test_solid_filter(self):
entries = self.test_data["Zn"]
pbx = PourbaixDiagram(entries, filter_solids=False)
oxidized_phase = pbx.find_stable_entry(10, 2)
self.assertEqual(oxidized_phase.name, "ZnO2(s)")
entries = self.test_data["Zn"]
pbx = PourbaixDiagram(entries, filter_solids=True)
oxidized_phase = pbx.find_stable_entry(10, 2)
self.assertEqual(oxidized_phase.name, "ZnO(s)")
def test_serialization(self):
d = self.pbx.as_dict()
new = PourbaixDiagram.from_dict(d)
self.assertEqual(
set([e.name for e in new.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"},
"List of stable entries does not match",
)
# Test with unprocessed entries included, this should result in the
# previously filtered entries being included
d = self.pbx.as_dict(include_unprocessed_entries=True)
new = PourbaixDiagram.from_dict(d)
self.assertEqual(
set([e.name for e in new.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)", "ZnO2(s)", "ZnH(s)"},
"List of stable entries for unfiltered pbx does not match",
)
pd_binary = PourbaixDiagram(
self.test_data["Ag-Te"],
filter_solids=True,
comp_dict={"Ag": 0.5, "Te": 0.5},
conc_dict={"Ag": 1e-8, "Te": 1e-8},
)
new_binary = PourbaixDiagram.from_dict(pd_binary.as_dict())
self.assertEqual(len(pd_binary.stable_entries), len(new_binary.stable_entries))
# The two tests below rely on the MP Rest interface.
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"), "PMG_MAPI_KEY environment variable not set.")
def test_heavy(self):
from pymatgen.ext.matproj import MPRester
mpr = MPRester()
entries = mpr.get_pourbaix_entries(["Li", "Mg", "Sn", "Pd"])
pbx = PourbaixDiagram(entries, nproc=4, filter_solids=False)
entries = mpr.get_pourbaix_entries(["Ba", "Ca", "V", "Cu", "F"])
pbx = PourbaixDiagram(entries, nproc=4, filter_solids=False)
entries = mpr.get_pourbaix_entries(["Ba", "Ca", "V", "Cu", "F", "Fe"])
pbx = PourbaixDiagram(entries, nproc=4, filter_solids=False)
entries = mpr.get_pourbaix_entries(["Na", "Ca", "Nd", "Y", "Ho", "F"])
pbx = PourbaixDiagram(entries, nproc=4, filter_solids=False)
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"), "PMG_MAPI_KEY environment variable not set.")
def test_mpr_pipeline(self):
from pymatgen.ext.matproj import MPRester
mpr = MPRester()
data = mpr.get_pourbaix_entries(["Zn"])
pbx = PourbaixDiagram(data, filter_solids=True, conc_dict={"Zn": 1e-8})
pbx.find_stable_entry(10, 0)
data = mpr.get_pourbaix_entries(["Ag", "Te"])
pbx = PourbaixDiagram(data, filter_solids=True, conc_dict={"Ag": 1e-8, "Te": 1e-8})
self.assertEqual(len(pbx.stable_entries), 30)
test_entry = pbx.find_stable_entry(8, 2)
self.assertAlmostEqual(test_entry.energy, 2.3894017960000009, 1)
# Test custom ions
entries = mpr.get_pourbaix_entries(["Sn", "C", "Na"])
ion = IonEntry(Ion.from_formula("NaO28H80Sn12C24+"), -161.676)
custom_ion_entry = PourbaixEntry(ion, entry_id="my_ion")
pbx = PourbaixDiagram(
entries + [custom_ion_entry],
filter_solids=True,
comp_dict={"Na": 1, "Sn": 12, "C": 24},
)
self.assertAlmostEqual(pbx.get_decomposition_energy(custom_ion_entry, 5, 2), 2.1209002582, 1)
# Test against ion sets with multiple equivalent ions (Bi-V regression)
entries = mpr.get_pourbaix_entries(["Bi", "V"])
pbx = PourbaixDiagram(entries, filter_solids=True, conc_dict={"Bi": 1e-8, "V": 1e-8})
self.assertTrue(all(["Bi" in entry.composition and "V" in entry.composition for entry in pbx.all_entries]))
class PourbaixDiagramTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.test_data = loadfn(os.path.join(test_dir, 'pourbaix_test_data.json'))
cls.pbx = PourbaixDiagram(cls.test_data['Zn'], filter_solids=True)
cls.pbx_nofilter = PourbaixDiagram(cls.test_data['Zn'],
filter_solids=False)
def test_pourbaix_diagram(self):
self.assertEqual(set([e.name for e in self.pbx.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"},
"List of stable entries does not match")
self.assertEqual(set([e.name for e in self.pbx_nofilter.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)",
"ZnO2(s)", "ZnH(s)"},
"List of stable entries for unfiltered pbx does not match")
pbx_lowconc = PourbaixDiagram(self.test_data['Zn'], conc_dict={"Zn": 1e-8},
filter_solids=True)
self.assertEqual(set([e.name for e in pbx_lowconc.stable_entries]),
{"Zn(HO)2(aq)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"})
def test_multicomponent(self):
# Binary system
pd_binary = PourbaixDiagram(self.test_data['Ag-Te'], filter_solids=True,
comp_dict={"Ag": 0.5, "Te": 0.5},
conc_dict={"Ag": 1e-8, "Te": 1e-8})
self.assertEqual(len(pd_binary.stable_entries), 30)
test_entry = pd_binary.find_stable_entry(8, 2)
self.assertTrue("mp-499" in test_entry.entry_id)
# Find a specific multientry to test
self.assertEqual(pd_binary.get_decomposition_energy(test_entry, 8, 2), 0)
self.assertEqual(pd_binary.get_decomposition_energy(
test_entry.entry_list[0], 8, 2), 0)
pd_ternary = PourbaixDiagram(self.test_data['Ag-Te-N'], filter_solids=True)
self.assertEqual(len(pd_ternary.stable_entries), 49)
ag = self.test_data['Ag-Te-N'][30]
self.assertAlmostEqual(pd_ternary.get_decomposition_energy(ag, 2, -1), 0)
self.assertAlmostEqual(pd_ternary.get_decomposition_energy(ag, 10, -2), 0)
def test_get_pourbaix_domains(self):
domains = PourbaixDiagram.get_pourbaix_domains(self.test_data['Zn'])
self.assertEqual(len(domains[0]), 7)
def test_get_decomposition(self):
# Test a stable entry to ensure that it's zero in the stable region
entry = self.test_data['Zn'][12] # Should correspond to mp-2133
self.assertAlmostEqual(self.pbx.get_decomposition_energy(entry, 10, 1),
0.0, 5, "Decomposition energy of ZnO is not 0.")
# Test an unstable entry to ensure that it's never zero
entry = self.test_data['Zn'][11]
ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-2, 4))
result = self.pbx_nofilter.get_decomposition_energy(entry, ph, v)
self.assertTrue((result >= 0).all(),
"Unstable energy has hull energy of 0 or less")
# Test an unstable hydride to ensure HER correction works
self.assertAlmostEqual(self.pbx.get_decomposition_energy(entry, -3, -2),
11.093744395)
# Test a list of pHs
self.pbx.get_decomposition_energy(entry, np.linspace(0, 2, 5), 2)
# Test a list of Vs
self.pbx.get_decomposition_energy(entry, 4, np.linspace(-3, 3, 10))
# Test a set of matching arrays
ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-3, 3))
self.pbx.get_decomposition_energy(entry, ph, v)
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"),
"PMG_MAPI_KEY environment variable not set.")
def test_mpr_pipeline(self):
from pymatgen import MPRester
mpr = MPRester()
data = mpr.get_pourbaix_entries(["Zn"])
pbx = PourbaixDiagram(data, filter_solids=True, conc_dict={"Zn": 1e-8})
pbx.find_stable_entry(10, 0)
data = mpr.get_pourbaix_entries(["Ag", "Te"])
pbx = PourbaixDiagram(data, filter_solids=True,
conc_dict={"Ag": 1e-8, "Te": 1e-8})
self.assertEqual(len(pbx.stable_entries), 30)
test_entry = pbx.find_stable_entry(8, 2)
self.assertAlmostEqual(test_entry.energy, 2.3936747835000016, 3)
# Test custom ions
entries = mpr.get_pourbaix_entries(["Sn", "C", "Na"])
ion = IonEntry(Ion.from_formula("NaO28H80Sn12C24+"), -161.676)
custom_ion_entry = PourbaixEntry(ion, entry_id='my_ion')
pbx = PourbaixDiagram(entries + [custom_ion_entry], filter_solids=True,
comp_dict={"Na": 1, "Sn": 12, "C": 24})
self.assertAlmostEqual(pbx.get_decomposition_energy(custom_ion_entry, 5, 2),
8.31202738629504, 2)
import unittest
from pymatgen.util.testing import PymatgenTest
from pymatgen import SETTINGS
from maml.data._mp import MaterialsProject
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"),
"PMG_MAPI_KEY environment variable not set")
class MaterialsProjectTest(PymatgenTest):
def test_get(self):
mp = MaterialsProject(SETTINGS.get("PMG_MAPI_KEY"))
features = [
"pretty_formula", "band_gap", "formation_energy_per_atom",
"e_above_hull", "elasticity.K_VRH"
]
df = mp.get(criteria={"nelements": 1}, properties=features)
assert df.shape[0] > 700
assert df.shape[1] == len(features)
assert set(df.columns) == set(features)
if __name__ == "__main__":
unittest.main()
def main():
parser = argparse.ArgumentParser(description="""
pmg is a convenient script that uses pymatgen to perform many
analyses, plotting and format conversions. This script works based on
several sub-commands with their own options. To see the options for the
sub-commands, type "pmg sub-command -h".""",
epilog="""
Author: Shyue Ping Ong
Version: {}
Last updated: {}""".format(__version__, __date__))
subparsers = parser.add_subparsers()
parser_config = subparsers.add_parser(
"config", help="Tools for configuring pymatgen, e.g., "
"potcar setup, modifying .pmgrc.yaml "
"configuration file.")
groups = parser_config.add_mutually_exclusive_group(required=True)
groups.add_argument("-p", "--potcar", dest="potcar_dirs",
metavar="dir_name",
nargs=2,
help="Initial directory where downloaded VASP "
"POTCARs are extracted to, and the "
"output directory where the reorganized "
"potcars will be stored. The input "
"directory should be "
"the parent directory that contains the "
"POT_GGA_PAW_PBE or potpaw_PBE type "
"subdirectories.")
groups.add_argument("-i", "--install", dest="install",
metavar="package_name",
choices=["enumlib", "bader"],
help="Install various optional command line "
"tools needed for full functionality.")
groups.add_argument("-a", "--add", dest="var_spec", nargs="+",
help="Variables to add in the form of space "
"separated key value pairs. E.g., "
"VASP_PSP_DIR ~/psps")
parser_config.set_defaults(func=configure_pmg)
parser_analyze = subparsers.add_parser(
"analyze", help="Vasp calculation analysis tools.")
parser_analyze.add_argument("directories", metavar="dir", default=".",
type=str, nargs="*",
help="directory to process (default to .)")
parser_analyze.add_argument("-e", "--energies", dest="get_energies",
action="store_true", help="Print energies")
parser_analyze.add_argument(
"-m", "--mag", dest="ion_list", type=str, nargs=1,
help="Print magmoms. ION LIST can be a range "
"(e.g., 1-2) or the string 'All' for all ions.")
parser_analyze.add_argument(
"-r", "--reanalyze", dest="reanalyze", action="store_true",
help="Force reanalysis. Typically, vasp_analyzer"
" will just reuse a vasp_analyzer_data.gz if "
"present. This forces the analyzer to reanalyze "
"the data.")
parser_analyze.add_argument(
"-f", "--format", dest="format", choices=tabulate_formats,
default="simple",
help="Format for table. Supports all options in tabulate package.")
parser_analyze.add_argument(
"-v", "--verbose", dest="verbose", action="store_true",
help="Verbose mode. Provides detailed output on progress.")
parser_analyze.add_argument(
"-d", "--detailed", dest="detailed", action="store_true",
help="Detailed, but slower mode. Parses vasprun.xml instead of "
"separate vasp outputs.")
parser_analyze.add_argument(
"-s", "--sort", dest="sort", choices=["energy_per_atom", "filename"],
default="energy_per_atom",
help="Sort criteria. Defaults to energy / atom.")
parser_analyze.set_defaults(func=analyze)
parser_query = subparsers.add_parser(
"query",
help="Search for structures and data from the Materials Project.")
parser_query.add_argument(
"criteria", metavar="criteria",
help="Search criteria. Supported formats in formulas, chemical "
"systems, Materials Project ids, etc.")
group = parser_query.add_mutually_exclusive_group(required=True)
group.add_argument(
"-s", "--structure", dest="structure", metavar="format",
choices=["poscar", "cif", "cssr"], type=str.lower,
help="Get structures from Materials Project and write them to a "
"specified format.")
group.add_argument(
"-e", "--entries", dest="entries", metavar="filename",
help="Get entries from Materials Project and write them to "
"serialization file. JSON and YAML supported.")
group.add_argument(
"-d", "--data", dest="data", metavar="fields", nargs="*",
help="Print a summary of entries in the Materials Project satisfying "
"the criteria. Supply field names to include additional data. "
"By default, the Materials Project id, formula, spacegroup, "
"energy per atom, energy above hull are shown.")
parser_query.set_defaults(func=do_query)
parser_plot = subparsers.add_parser("plot", help="Plotting tool for "
"DOS, CHGCAR, XRD, etc.")
group = parser_plot.add_mutually_exclusive_group(required=True)
group.add_argument('-d', '--dos', dest="dos_file", metavar="vasprun.xml",
help="Plot DOS from a vasprun.xml")
group.add_argument('-c', '--chgint', dest="chgcar_file", metavar="CHGCAR",
help="Generate charge integration plots from any "
"CHGCAR")
group.add_argument('-x', '--xrd', dest="xrd_structure_file",
metavar="structure_file",
help="Generate XRD plots from any supported structure "
"file, e.g., CIF, POSCAR, vasprun.xml, etc.")
parser_plot.add_argument("-s", "--site", dest="site", action="store_const",
const=True, help="Plot site projected DOS")
parser_plot.add_argument("-e", "--element", dest="element", type=str,
nargs=1,
help="List of elements to plot as comma-separated"
" values e.g., Fe,Mn")
parser_plot.add_argument("-o", "--orbital", dest="orbital",
action="store_const", const=True,
help="Plot orbital projected DOS")
parser_plot.add_argument("-i", "--indices", dest="inds", type=str,
nargs=1,
help="Comma-separated list of indices to plot "
"charge integration, e.g., 1,2,3,4. If not "
"provided, the code will plot the chgint "
"for all symmetrically distinct atoms "
"detected.")
parser_plot.add_argument("-r", "--radius", dest="radius", type=float,
default=3,
help="Radius of integration for charge "
"integration plot.")
parser_plot.add_argument("--out_file", dest="out_file", type=str,
help="Save plot to file instead of displaying.")
parser_plot.set_defaults(func=plot)
parser_structure = subparsers.add_parser(
"structure",
help="Structure conversion and analysis tools.")
parser_structure.add_argument(
"-f", "--filenames", dest="filenames",
metavar="filename", nargs="+",
help="List of structure files.")
groups = parser_structure.add_mutually_exclusive_group(required=True)
groups.add_argument("-c", "--convert", dest="convert", action="store_true",
help="Convert from structure file 1 to structure "
"file 2. Format determined from filename. "
"Supported formats include POSCAR/CONTCAR, "
"CIF, CSSR, etc. If the keyword'prim' is within "
"the filename, the code will automatically attempt "
"to find a primitive cell.")
groups.add_argument("-s", "--symmetry", dest="symmetry",
metavar="tolerance", type=float,
help="Determine the spacegroup using the "
"specified tolerance. 0.1 is usually a good "
"value for DFT calculations.")
groups.add_argument("-g", "--group", dest="group",
choices=["element", "species"],
metavar="mode",
help="Compare a set of structures for similarity. "
"Element mode does not compare oxidation states. "
"Species mode will take into account oxidations "
"states.")
groups.add_argument(
"-l", "--localenv", dest="localenv", nargs="+",
help="Local environment analysis. Provide bonds in the format of"
"Center Species-Ligand Species=max_dist, e.g., H-O=0.5.")
parser_structure.set_defaults(func=analyze_structures)
parser_view = subparsers.add_parser("view", help="Visualize structures")
parser_view.add_argument("filename", metavar="filename", type=str,
nargs=1, help="Filename")
parser_view.add_argument("-e", "--exclude_bonding", dest="exclude_bonding",
type=str, nargs=1,
help="List of elements to exclude from bonding "
"analysis. E.g., Li,Na")
parser_view.set_defaults(func=parse_view)
parser_diff = subparsers.add_parser(
"diff", help="Diffing tool. For now, only INCAR supported.")
parser_diff.add_argument("-i", "--incar", dest="incars",
metavar="INCAR", required=True,
nargs=2, help="List of INCARs to compare.")
parser_diff.set_defaults(func=diff_incar)
parser_potcar = subparsers.add_parser("potcar",
help="Generate POTCARs")
parser_potcar.add_argument("-f", "--functional", dest="functional",
type=str,
choices=sorted(Potcar.FUNCTIONAL_CHOICES),
default=SETTINGS.get("DEFAULT_FUNCTIONAL",
"PBE"),
help="Functional to use. Unless otherwise "
"stated (e.g., US), "
"refers to PAW psuedopotential.")
group = parser_potcar.add_mutually_exclusive_group(required=True)
group.add_argument("-s", "--symbols", dest="symbols",
type=str, nargs="+",
help="List of POTCAR symbols. Use -f to set "
"functional. Defaults to PBE.")
group.add_argument("-r", "--recursive", dest="recursive",
type=str, nargs="+",
help="Dirname to find and generate from POTCAR.spec.")
parser_potcar.set_defaults(func=generate_potcar)
args = parser.parse_args()
try:
getattr(args, "func")
except AttributeError:
parser.print_help()
sys.exit(0)
args.func(args)
from abipy.core.testing import AbipyTest
from pymatgen.core.structure import Structure
# from pymatgen.io.vasp.GWvaspinputsets import GWDFTDiagVaspInputSet, GWG0W0VaspInputSet, GWscDFTPrepVaspInputSet
from HTGW.flows.GWvaspinputsets import GWDFTDiagVaspInputSet, GWG0W0VaspInputSet, GWscDFTPrepVaspInputSet
from HTGW.flows.GWvaspinputsets import SingleVaspGWWork
from HTGW.flows.datastructures import GWSpecs, GWConvergenceData, get_spec
from HTGW.flows.codeinterfaces import AbinitInterface, VaspInterface, get_code_interface
from HTGW.flows.tests.test_helpers import structure
from abipy.abilab import Structure as AbiStructure
from HTGW.flows.GWworks import GWWork, SingleAbinitGWWork, VaspGWFWWorkFlow
from abipy.flowtk import Flow, ScfTask, NscfTask, SigmaTask
from abipy.flowtk.tasks import ScrTask # this does not import via flowtk
from pymatgen import SETTINGS
POTCAR_DIR = SETTINGS.get("VASP_PSP_DIR")
# TODO: These tests produce several files. The execution of the test should be done in a temp directory.
__author__ = 'setten'
class GWSpecTest(AbipyTest):
def test_GWspect(self):
"""
Testing the class GWSpecs()
"""
spec = GWSpecs()
self.assertEqual(len(spec.as_dict()), 10)
self.assertIsInstance(spec, GWSpecs)
self.assertEqual(spec.get_code(), 'ABINIT')
class PymatgenTest(unittest.TestCase):
"""
Extends unittest.TestCase with functions (taken from numpy.testing.utils)
that support the comparison of arrays.
"""
_multiprocess_shared_ = True
MODULE_DIR = Path(__file__).absolute().parent
STRUCTURES_DIR = MODULE_DIR / "structures"
TEST_FILES_DIR = MODULE_DIR / ".." / ".." / "test_files"
"""
Dict for test structures to aid testing.
"""
TEST_STRUCTURES = {}
for fn in STRUCTURES_DIR.iterdir():
TEST_STRUCTURES[fn.name.rsplit(".", 1)[0]] = loadfn(str(fn))
@classmethod
def get_structure(cls, name):
"""
Get a structure from the template directories.
:param name: Name of a structure.
:return: Structure
"""
return cls.TEST_STRUCTURES[name].copy()
@classmethod
@requires(SETTINGS.get("PMG_MAPI_KEY"), "PMG_MAPI_KEY needs to be set.")
def get_mp_structure(cls, mpid):
"""
Get a structure from MP.
:param mpid: Materials Project id.
:return: Structure
"""
m = MPRester()
return m.get_structure_by_material_id(mpid)
@staticmethod
def assertArrayAlmostEqual(actual,
desired,
decimal=7,
err_msg='',
verbose=True):
"""
Tests if two arrays are almost equal to a tolerance. The CamelCase
naming is so that it is consistent with standard unittest methods.
"""
return nptu.assert_almost_equal(actual, desired, decimal, err_msg,
verbose)
@staticmethod
def assertDictsAlmostEqual(actual,
desired,
decimal=7,
err_msg='',
verbose=True):
"""
Tests if two arrays are almost equal to a tolerance. The CamelCase
naming is so that it is consistent with standard unittest methods.
"""
for k, v in actual.items():
if k not in desired:
return False
v2 = desired[k]
if isinstance(v, dict):
pass_test = PymatgenTest.assertDictArraysAlmostEqual(
v, v2, decimal=decimal, err_msg=err_msg, verbose=verbose)
if not pass_test:
return False
elif isinstance(v, (list, tuple)):
pass_test = nptu.assert_almost_equal(v, v2, decimal, err_msg,
verbose)
if not pass_test:
return False
elif isinstance(v, (int, float)):
pass_test = PymatgenTest.assertAlmostEqual(v, v2)
if not pass_test:
return False
else:
assert v == v2
return True
@staticmethod
def assertArrayEqual(actual, desired, err_msg='', verbose=True):
"""
Tests if two arrays are equal. The CamelCase naming is so that it is
consistent with standard unittest methods.
"""
return nptu.assert_equal(actual,
desired,
err_msg=err_msg,
verbose=verbose)
@staticmethod
def assertStrContentEqual(actual, desired, err_msg='', verbose=True):
"""
Tests if two strings are equal, ignoring things like trailing spaces,
etc.
"""
lines1 = actual.split("\n")
lines2 = desired.split("\n")
if len(lines1) != len(lines2):
return False
failed = []
for l1, l2 in zip(lines1, lines2):
if l1.strip() != l2.strip():
failed.append("%s != %s" % (l1, l2))
return len(failed) == 0
def serialize_with_pickle(self, objects, protocols=None, test_eq=True):
"""
Test whether the object(s) can be serialized and deserialized with
pickle. This method tries to serialize the objects with pickle and the
protocols specified in input. Then it deserializes the pickle format
and compares the two objects with the __eq__ operator if
test_eq == True.
Args:
objects: Object or list of objects.
protocols: List of pickle protocols to test. If protocols is None,
HIGHEST_PROTOCOL is tested.
Returns:
Nested list with the objects deserialized with the specified
protocols.
"""
# Use the python version so that we get the traceback in case of errors
import pickle as pickle
from pymatgen.util.serialization import pmg_pickle_load, \
pmg_pickle_dump
# Build a list even when we receive a single object.
got_single_object = False
if not isinstance(objects, (list, tuple)):
got_single_object = True
objects = [objects]
if protocols is None:
# protocols = set([0, 1, 2] + [pickle.HIGHEST_PROTOCOL])
protocols = [pickle.HIGHEST_PROTOCOL]
# This list will contains the object deserialized with the different
# protocols.
objects_by_protocol, errors = [], []
for protocol in protocols:
# Serialize and deserialize the object.
mode = "wb"
fd, tmpfile = tempfile.mkstemp(text="b" not in mode)
try:
with open(tmpfile, mode) as fh:
pmg_pickle_dump(objects, fh, protocol=protocol)
except Exception as exc:
errors.append("pickle.dump with protocol %s raised:\n%s" %
(protocol, str(exc)))
continue
try:
with open(tmpfile, "rb") as fh:
new_objects = pmg_pickle_load(fh)
except Exception as exc:
errors.append("pickle.load with protocol %s raised:\n%s" %
(protocol, str(exc)))
continue
# Test for equality
if test_eq:
for old_obj, new_obj in zip(objects, new_objects):
self.assertEqual(old_obj, new_obj)
# Save the deserialized objects and test for equality.
objects_by_protocol.append(new_objects)
if errors:
raise ValueError("\n".join(errors))
# Return nested list so that client code can perform additional tests.
if got_single_object:
return [o[0] for o in objects_by_protocol]
else:
return objects_by_protocol
def tmpfile_write(self, string):
"""
Write string to a temporary file. Returns the name of the temporary
file.
"""
fd, tmpfile = tempfile.mkstemp(text=True)
with open(tmpfile, "w") as fh:
fh.write(string)
return tmpfile
def assertMSONable(self, obj, test_if_subclass=True):
"""
Tests if obj is MSONable and tries to verify whether the contract is
fulfilled.
By default, the method tests whether obj is an instance of MSONable.
This check can be deactivated by setting test_if_subclass to False.
"""
if test_if_subclass:
self.assertIsInstance(obj, MSONable)
self.assertDictEqual(obj.as_dict(),
obj.__class__.from_dict(obj.as_dict()).as_dict())
json.loads(obj.to_json(), cls=MontyDecoder)
class PourbaixDiagramTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.test_data = loadfn(os.path.join(test_dir, 'pourbaix_test_data.json'))
cls.pbx = PourbaixDiagram(cls.test_data['Zn'], filter_solids=True)
cls.pbx_nofilter = PourbaixDiagram(cls.test_data['Zn'],
filter_solids=False)
def test_pourbaix_diagram(self):
self.assertEqual(set([e.name for e in self.pbx.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"},
"List of stable entries does not match")
self.assertEqual(set([e.name for e in self.pbx_nofilter.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)",
"ZnO2(s)", "ZnH(s)"},
"List of stable entries for unfiltered pbx does not match")
pbx_lowconc = PourbaixDiagram(self.test_data['Zn'], conc_dict={"Zn": 1e-8},
filter_solids=True)
self.assertEqual(set([e.name for e in pbx_lowconc.stable_entries]),
{"Zn(HO)2(aq)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"})
def test_properties(self):
self.assertEqual(len(self.pbx.unstable_entries), 2)
def test_multicomponent(self):
# Assure no ions get filtered at high concentration
ag_n = [e for e in self.test_data['Ag-Te-N']
if not "Te" in e.composition]
highconc = PourbaixDiagram(ag_n, filter_solids=True,
conc_dict={"Ag": 1e-5, "N": 1})
entry_sets = [set(e.entry_id) for e in highconc.stable_entries]
self.assertIn({"mp-124", "ion-17"}, entry_sets)
# Binary system
pd_binary = PourbaixDiagram(self.test_data['Ag-Te'], filter_solids=True,
comp_dict={"Ag": 0.5, "Te": 0.5},
conc_dict={"Ag": 1e-8, "Te": 1e-8})
self.assertEqual(len(pd_binary.stable_entries), 30)
test_entry = pd_binary.find_stable_entry(8, 2)
self.assertTrue("mp-499" in test_entry.entry_id)
# Find a specific multientry to test
self.assertEqual(pd_binary.get_decomposition_energy(test_entry, 8, 2), 0)
self.assertEqual(pd_binary.get_decomposition_energy(
test_entry.entry_list[0], 8, 2), 0)
pd_ternary = PourbaixDiagram(self.test_data['Ag-Te-N'], filter_solids=True)
self.assertEqual(len(pd_ternary.stable_entries), 49)
ag = self.test_data['Ag-Te-N'][30]
self.assertAlmostEqual(pd_ternary.get_decomposition_energy(ag, 2, -1), 0)
self.assertAlmostEqual(pd_ternary.get_decomposition_energy(ag, 10, -2), 0)
# Test invocation of pourbaix diagram from ternary data
new_ternary = PourbaixDiagram(pd_ternary.all_entries)
self.assertEqual(len(new_ternary.stable_entries), 49)
self.assertAlmostEqual(new_ternary.get_decomposition_energy(ag, 2, -1), 0)
self.assertAlmostEqual(new_ternary.get_decomposition_energy(ag, 10, -2), 0)
def test_get_pourbaix_domains(self):
domains = PourbaixDiagram.get_pourbaix_domains(self.test_data['Zn'])
self.assertEqual(len(domains[0]), 7)
def test_get_decomposition(self):
# Test a stable entry to ensure that it's zero in the stable region
entry = self.test_data['Zn'][12] # Should correspond to mp-2133
self.assertAlmostEqual(self.pbx.get_decomposition_energy(entry, 10, 1),
0.0, 5, "Decomposition energy of ZnO is not 0.")
# Test an unstable entry to ensure that it's never zero
entry = self.test_data['Zn'][11]
ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-2, 4))
result = self.pbx_nofilter.get_decomposition_energy(entry, ph, v)
self.assertTrue((result >= 0).all(),
"Unstable energy has hull energy of 0 or less")
# Test an unstable hydride to ensure HER correction works
self.assertAlmostEqual(self.pbx.get_decomposition_energy(entry, -3, -2),
11.093744395)
# Test a list of pHs
self.pbx.get_decomposition_energy(entry, np.linspace(0, 2, 5), 2)
# Test a list of Vs
self.pbx.get_decomposition_energy(entry, 4, np.linspace(-3, 3, 10))
# Test a set of matching arrays
ph, v = np.meshgrid(np.linspace(0, 14), np.linspace(-3, 3))
self.pbx.get_decomposition_energy(entry, ph, v)
def test_multielement_parallel(self):
# Simple test to ensure that multiprocessing is working
test_entries = self.test_data["Ag-Te-N"]
nproc = multiprocessing.cpu_count()
pbx = PourbaixDiagram(test_entries, filter_solids=True, nproc=nproc)
self.assertEqual(len(pbx.stable_entries), 49)
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"),
"PMG_MAPI_KEY environment variable not set.")
def test_mpr_pipeline(self):
from pymatgen import MPRester
mpr = MPRester()
data = mpr.get_pourbaix_entries(["Zn"])
pbx = PourbaixDiagram(data, filter_solids=True, conc_dict={"Zn": 1e-8})
pbx.find_stable_entry(10, 0)
data = mpr.get_pourbaix_entries(["Ag", "Te"])
pbx = PourbaixDiagram(data, filter_solids=True,
conc_dict={"Ag": 1e-8, "Te": 1e-8})
self.assertEqual(len(pbx.stable_entries), 30)
test_entry = pbx.find_stable_entry(8, 2)
self.assertAlmostEqual(test_entry.energy, 2.3936747835000016, 3)
# Test custom ions
entries = mpr.get_pourbaix_entries(["Sn", "C", "Na"])
ion = IonEntry(Ion.from_formula("NaO28H80Sn12C24+"), -161.676)
custom_ion_entry = PourbaixEntry(ion, entry_id='my_ion')
pbx = PourbaixDiagram(entries + [custom_ion_entry], filter_solids=True,
comp_dict={"Na": 1, "Sn": 12, "C": 24})
self.assertAlmostEqual(pbx.get_decomposition_energy(custom_ion_entry, 5, 2),
8.31202738629504, 2)
def test_nofilter(self):
entries = self.test_data['Ag-Te']
pbx = PourbaixDiagram(entries)
pbx.get_decomposition_energy(entries[0], 0, 0)
def test_solid_filter(self):
entries = self.test_data['Ag-Te-N']
pbx = PourbaixDiagram(entries, filter_solids=True)
pbx.get_decomposition_energy(entries[0], 0, 0)
def test_serialization(self):
d = self.pbx.as_dict()
new = PourbaixDiagram.from_dict(d)
self.assertEqual(set([e.name for e in new.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)"},
"List of stable entries does not match")
# Test with unprocessed entries included, this should result in the
# previously filtered entries being included
d = self.pbx.as_dict(include_unprocessed_entries=True)
new = PourbaixDiagram.from_dict(d)
self.assertEqual(
set([e.name for e in new.stable_entries]),
{"ZnO(s)", "Zn[2+]", "ZnHO2[-]", "ZnO2[2-]", "Zn(s)", "ZnO2(s)", "ZnH(s)"},
"List of stable entries for unfiltered pbx does not match")
pd_binary = PourbaixDiagram(self.test_data['Ag-Te'], filter_solids=True,
comp_dict={"Ag": 0.5, "Te": 0.5},
conc_dict={"Ag": 1e-8, "Te": 1e-8})
new_binary = PourbaixDiagram.from_dict(pd_binary.as_dict())
self.assertEqual(len(pd_binary.stable_entries),
len(new_binary.stable_entries))
from matplotlib import rc
from monty.json import MontyDecoder, MontyEncoder
from pymatgen import Composition, SETTINGS, Element, MPRester
from pymatgen.analysis.phase_diagram import PhaseDiagram, GrandPotentialPhaseDiagram
from pymatgen.analysis.reaction_calculator import ComputedReaction
from pymatgen.entries.computed_entries import ComputedEntry
__author__ = "Yizhou Zhu"
__copyright__ = ""
__version__ = "2.2"
__maintainer__ = "Yizhou Zhu"
__email__ = "*****@*****.**"
__status__ = "Production"
__date__ = "Jun 10, 2018"
PD_PRELOAD_PATH = SETTINGS.get("PMG_PD_PRELOAD_PATH")
# if PD_PRELOAD_PATH is None:
# trypreload = False
plt.rcParams['mathtext.default'] = 'regular'
rc('font', **{'family': 'sans-serif', 'sans-serif': ['Helvetica'], 'size': 15})
class VirtualEntry(ComputedEntry):
def __init__(self, composition, energy, attribute=None, name=None):
super(VirtualEntry, self).__init__(Composition(composition), energy, attribute=attribute)
if name:
self.name = name
@classmethod
def from_composition(cls, comp, energy=0, name=None):
"""
__author__ = "Shyue Ping Ong"
__copyright__ = "Copyright 2012, The Materials Project"
__version__ = "0.1"
__maintainer__ = "Shyue Ping Ong"
__email__ = "*****@*****.**"
__date__ = "Jun 9, 2012"
test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..",
'test_files')
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"), "PMG_MAPI_KEY environment variable not set.")
class MPResterTest(unittest.TestCase):
def setUp(self):
self.rester = MPRester()
warnings.simplefilter("ignore")
def tearDown(self):
warnings.resetwarnings()
def test_get_all_materials_ids_doc(self):
mids = self.rester.get_materials_ids("Al2O3")
random.shuffle(mids)
doc = self.rester.get_doc(mids.pop(0))
self.assertEqual(doc["pretty_formula"], "Al2O3")
def get_basis_and_potential(species, d, cardinality="DZVP", functional="PBE"):
"""
Given a specie and a potential/basis type, this function accesses the available basis sets and potentials.
Generally, the GTH potentials are used with the GTH basis sets.
Args:
species: (list) list of species for which to get the potential/basis strings
d: (dict) a dictionary specifying how bases and/or potentials should be assigned to species
E.g. {'Si': {'cardinality': 'DZVP', 'sr': True}, 'O': {'cardinality': 'TZVP'}}
functional: (str) functional type. Default: 'PBE'
basis_type: (str) the basis set type. Default: 'MOLOPT'
cardinality: (str) basis set cardinality. Default: 'DZVP'
Returns:
(dict) of the form {'specie': {'potential': potential, 'basis': basis}...}
"""
potential_filename = SETTINGS.get("PMG_DEFAULT_CP2K_POTENTIAL_FILE",
"GTH_POTENTIALS")
basis_filenames = ["BASIS_MOLOPT", "BASIS_MOLOPT_UCL"]
functional = functional or SETTINGS.get("PMG_DEFAULT_FUNCTIONAL", "PBE")
cardinality = cardinality or SETTINGS.get("PMG_DEFAULT_BASIS_CARDINALITY",
"DZVP")
basis_and_potential = {
"basis_filenames": basis_filenames,
"potential_filename": potential_filename,
}
for s in species:
if s not in d:
d[s] = {}
if "sr" not in d[s]:
d[s]["sr"] = True
if "cardinality" not in d[s]:
d[s]["cardinality"] = cardinality
with open(os.path.join(MODULE_DIR, "basis_molopt.yaml"), "rt") as f:
data_b = yaml.load(f, Loader=yaml.Loader)
with open(os.path.join(MODULE_DIR, "gth_potentials.yaml"), "rt") as f:
data_p = yaml.load(f, Loader=yaml.Loader)
for s in species:
basis_and_potential[s] = {}
b = [_ for _ in data_b[s] if d[s]["cardinality"] in _.split("-")]
if d[s]["sr"] and any(["SR" in _ for _ in b]):
b = [_ for _ in b if "SR" in _]
else:
b = [_ for _ in b if "SR" not in _]
if "q" in d[s]:
b = [_ for _ in b if d[s]["q"] in _]
else:
def srt(x):
return int(x.split("q")[-1])
b = sorted(b, key=srt)[-1:]
if len(b) == 0:
raise LookupError("NO BASIS OF THAT TYPE AVAILABLE")
if len(b) > 1:
raise LookupError("AMBIGUITY IN BASIS. PLEASE SPECIFY FURTHER")
basis_and_potential[s]["basis"] = b[0]
p = [_ for _ in data_p[s] if functional in _.split("-")]
if len(p) == 0:
raise LookupError("NO PSEUDOPOTENTIAL OF THAT TYPE AVAILABLE")
if len(p) > 1:
raise LookupError("AMBIGUITY IN POTENTIAL. PLEASE SPECIFY FURTHER")
basis_and_potential[s]["potential"] = p[0]
return basis_and_potential
BandStructureSymmLine,
BandStructure,
)
from pymatgen.entries.compatibility import MaterialsProjectCompatibility
from pymatgen.analysis.phase_diagram import PhaseDiagram
from pymatgen.analysis.pourbaix_diagram import PourbaixEntry, PourbaixDiagram
from pymatgen.analysis.wulff import WulffShape
from pymatgen.analysis.reaction_calculator import Reaction
from pymatgen.io.cif import CifParser
from pymatgen.phonon.bandstructure import PhononBandStructureSymmLine
from pymatgen.phonon.dos import CompletePhononDos
from pymatgen.util.testing import PymatgenTest
@unittest.skipIf(
not SETTINGS.get("PMG_MAPI_KEY"), "PMG_MAPI_KEY environment variable not set."
)
class MPResterTest(PymatgenTest):
_multiprocess_shared_ = True
def setUp(self):
self.rester = MPRester()
warnings.simplefilter("ignore")
def tearDown(self):
warnings.simplefilter("default")
self.rester.session.close()
def test_get_all_materials_ids_doc(self):
mids = self.rester.get_materials_ids("Al2O3")
random.shuffle(mids)
class PymatgenTest(unittest.TestCase):
"""
Extends unittest.TestCase with functions (taken from numpy.testing.utils)
that support the comparison of arrays.
"""
MODULE_DIR = os.path.dirname(os.path.abspath(__file__))
STRUCTURES_DIR = os.path.join(MODULE_DIR, "structures")
"""
Dict for test structures to aid testing.
"""
TEST_STRUCTURES = {}
for fn in os.listdir(STRUCTURES_DIR):
TEST_STRUCTURES[fn.rsplit(".", 1)[0]] = loadfn(os.path.join(
STRUCTURES_DIR, fn), cls=MontyDecoder)
@classmethod
def get_structure(cls, name):
return cls.TEST_STRUCTURES[name].copy()
@classmethod
@requires(SETTINGS.get("PMG_MAPI_KEY"), "PMG_MAPI_KEY needs to be set.")
def get_mp_structure(cls, mpid):
m = MPRester()
return m.get_structure_by_material_id(mpid)
@staticmethod
def assertArrayAlmostEqual(actual, desired, decimal=7, err_msg='',
verbose=True):
"""
Tests if two arrays are almost equal to a tolerance. The CamelCase
naming is so that it is consistent with standard unittest methods.
"""
return nptu.assert_almost_equal(actual, desired, decimal, err_msg,
verbose)
@staticmethod
def assertArrayEqual(actual, desired, err_msg='', verbose=True):
"""
Tests if two arrays are equal. The CamelCase naming is so that it is
consistent with standard unittest methods.
"""
return nptu.assert_equal(actual, desired, err_msg=err_msg,
verbose=verbose)
def serialize_with_pickle(self, objects, protocols=None, test_eq=True):
"""
Test whether the object(s) can be serialized and deserialized with
pickle. This method tries to serialize the objects with pickle and the
protocols specified in input. Then it deserializes the pickle format
and compares the two objects with the __eq__ operator if
test_eq == True.
Args:
objects: Object or list of objects.
protocols: List of pickle protocols to test. If protocols is None,
HIGHEST_PROTOCOL is tested.
Returns:
Nested list with the objects deserialized with the specified
protocols.
"""
# Use the python version so that we get the traceback in case of errors
import pickle as pickle
from pymatgen.util.serialization import pmg_pickle_load, \
pmg_pickle_dump
# Build a list even when we receive a single object.
got_single_object = False
if not isinstance(objects, (list, tuple)):
got_single_object = True
objects = [objects]
if protocols is None:
# protocols = set([0, 1, 2] + [pickle.HIGHEST_PROTOCOL])
protocols = [pickle.HIGHEST_PROTOCOL]
# This list will contains the object deserialized with the different
# protocols.
objects_by_protocol, errors = [], []
for protocol in protocols:
# Serialize and deserialize the object.
mode = "wb"
fd, tmpfile = tempfile.mkstemp(text="b" not in mode)
try:
with open(tmpfile, mode) as fh:
pmg_pickle_dump(objects, fh, protocol=protocol)
except Exception as exc:
errors.append("pickle.dump with protocol %s raised:\n%s" %
(protocol, str(exc)))
continue
try:
with open(tmpfile, "rb") as fh:
new_objects = pmg_pickle_load(fh)
except Exception as exc:
errors.append("pickle.load with protocol %s raised:\n%s" %
(protocol, str(exc)))
continue
# Test for equality
if test_eq:
for old_obj, new_obj in zip(objects, new_objects):
self.assertEqual(old_obj, new_obj)
# Save the deserialized objects and test for equality.
objects_by_protocol.append(new_objects)
if errors:
raise ValueError("\n".join(errors))
# Return nested list so that client code can perform additional tests.
if got_single_object:
return [o[0] for o in objects_by_protocol]
else:
return objects_by_protocol
def tmpfile_write(self, string):
"""
Write string to a temporary file. Returns the name of the temporary
file.
"""
fd, tmpfile = tempfile.mkstemp(text=True)
with open(tmpfile, "w") as fh:
fh.write(string)
return tmpfile
def assertMSONable(self, obj, test_if_subclass=True):
"""
Tests if obj is MSONable and tries to verify whether the contract is
fulfilled.
By default, the method tests whether obj is an instance of MSONable.
This check can be deactivated by setting test_if_subclass to False.
"""
if test_if_subclass:
self.assertIsInstance(obj, MSONable)
self.assertDictEqual(obj.as_dict(), obj.__class__.from_dict(
obj.as_dict()).as_dict())
json.loads(obj.to_json(), cls=MontyDecoder)
"""
__author__ = "Shyue Ping Ong"
__copyright__ = "Copyright 2012, The Materials Project"
__version__ = "0.1"
__maintainer__ = "Shyue Ping Ong"
__email__ = "*****@*****.**"
__date__ = "Jun 9, 2012"
test_dir = os.path.join(os.path.dirname(__file__), "..", "..", "..",
'test_files')
@unittest.skipIf(not SETTINGS.get("PMG_MAPI_KEY"), "PMG_MAPI_KEY environment variable not set.")
class MPResterTest(unittest.TestCase):
def setUp(self):
self.rester = MPRester()
warnings.simplefilter("ignore")
def tearDown(self):
warnings.resetwarnings()
def test_get_all_materials_ids_doc(self):
mids = self.rester.get_materials_ids("Al2O3")
random.shuffle(mids)
doc = self.rester.get_doc(mids.pop(0))
self.assertEqual(doc["pretty_formula"], "Al2O3")
)
from pymatgen.electronic_structure.dos import CompleteDos
from pymatgen.entries.compatibility import MaterialsProjectCompatibility
from pymatgen.entries.computed_entries import ComputedEntry
from pymatgen.ext.matproj import MPRester, MPRestError, TaskType
from pymatgen.io.cif import CifParser
from pymatgen.phonon.bandstructure import PhononBandStructureSymmLine
from pymatgen.phonon.dos import CompletePhononDos
from pymatgen.util.testing import PymatgenTest
website_is_up = requests.get(
"https://www.materialsproject.org").status_code == 200
@unittest.skipIf(
(not SETTINGS.get("PMG_MAPI_KEY")) or (not website_is_up),
"PMG_MAPI_KEY environment variable not set or MP is down.",
)
class MPResterTest(PymatgenTest):
_multiprocess_shared_ = True
def setUp(self):
self.rester = MPRester()
warnings.simplefilter("ignore")
def tearDown(self):
warnings.simplefilter("default")
self.rester.session.close()
def test_get_all_materials_ids_doc(self):
mids = self.rester.get_materials_ids("Al2O3")
