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) 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(pd.get_e_above_hull(e), data["e_above_hull"])
def get_mp_phase_graph(): mpr = check_apikey() compat = MaterialsProjectCompatibility() print("input the elements list") wait_sep() in_str = wait() elements = in_str.split() web = "materials.org" proc_str = "Reading Data From " + web + " ..." step_count = 1 procs(proc_str, step_count, sp='-->>') unprocessed_entries = mpr.get_entries_in_chemsys(elements) processed_entries = compat.process_entries(unprocessed_entries) pd = PhaseDiagram(processed_entries) pdp = PDPlotter(pd, show_unstable=True) try: pdp.show() except: pass finally: step_count += 1 filename = 'phase' + '-'.join(elements) + '.png' proc_str = "Writing Data to " + filename + " File..." procs(proc_str, step_count, sp='-->>') pdp.write_image(filename) return True
def getEhull(new=''): drone = VaspToComputedEntryDrone() queen = BorgQueen(drone, './', 4) entriesorig = queen.get_data() queen.load_data( os.path.join(os.path.dirname(__file__), '../ML/data/missingels.json')) entriesextra = queen.get_data() if new != '': compat = MaterialsProjectCompatibility(check_potcar=False) entriesorig = compat.process_entries(entriesorig) for entry in entriesorig: name = entry.name line = re.findall('[A-Z][^A-Z]*', name.replace('(', '').replace(')', '')) searchset = set(re.sub('\d', ' ', ' '.join(line)).split()) entries = filter( lambda e: set( re.sub('\d', ' ', str(e.composition).replace(' ', '')).split()) == searchset, entriesorig) entriesextra = filter( lambda e: set( re.sub('\d', ' ', str(e.composition).replace(' ', '')).split()) & searchset, entriesextra) a = MPRester("s2vUo6mzETOHLdbu") all_entries = a.get_entries_in_chemsys( set(searchset)) + list(entries) + list(entriesextra) pd = PhaseDiagram(all_entries) #,None for e in pd.stable_entries: if e.entry_id == None: reaction = pd.get_equilibrium_reaction_energy(e) return str(reaction) + ' None' for e in pd.unstable_entries: decomp, e_above_hull = pd.get_decomp_and_e_above_hull(e) pretty_decomp = [("{}:{}".format(k.composition.reduced_formula, k.entry_id), round(v, 2)) for k, v in decomp.items()] if e.entry_id == None: return str(e_above_hull) + ' ' + str(pretty_decomp)
def get_ehull(structure_type, tot_e, species, unmix_entries=None, all_entries=None, debug=False): """ Get Ehull predicted under given total energy and species. The composition can be either given by the species dict(for garnet only) or a formula. Args: tot_e (float): total energy, the unit is in accordance with given composition. species (dict): species in dictionary. unmix_entries (list): additional list of unmix entries. Returns: ehull (float): energy above hull. """ formula = spe2form(structure_type, species) composition = Composition(formula) unmix_entries = [] if unmix_entries is None else unmix_entries if not all_entries: all_entries = m.get_entries_in_chemsys([el.name for el in composition], inc_structure=True) all_entries = filter_entries(structure_type, all_entries, species) all_calc_entries = [e for e in CALC_ENTRIES[structure_type] if set(e.composition).issubset(set(composition)) \ and e.name != composition.reduced_formula] if all_calc_entries: all_entries = all_entries + all_calc_entries compat = MaterialsProjectCompatibility() all_entries = compat.process_entries(all_entries) if not all_entries: raise ValueError("Incomplete") entry = prepare_entry(structure_type, tot_e, species) if debug: return entry, all_entries phase_diagram = PhaseDiagram(all_entries + [entry] + unmix_entries) return phase_diagram.get_decomp_and_e_above_hull(entry)
def calculate_phase_stability(args): #This initializes the REST adaptor. a = MPRester(args.api_key) drone = VaspToComputedEntryDrone() entry = drone.assimilate(args.directory) compat = MaterialsProjectCompatibility() entry = compat.process_entry(entry) if not entry: print "Calculation parameters are not consistent with Materials " + \ "Project parameters." sys.exit() syms = [el.symbol for el in entry.composition.elements] #This gets all entries belonging to the relevant system. entries = a.get_entries_in_chemsys(syms) entries.append(entry) #Process entries with Materials Project compatibility. entries = compat.process_entries(entries) print [e.composition.reduced_formula for e in entries]
from pymatgen.analysis.phase_diagram import PhaseDiagram, PDPlotter, PDEntry from pymatgen.core.periodic_table import Element from pymatgen.core.composition import Composition from pymatgen.io.vasp.outputs import Vasprun import sys print("Usage: get_phase_diagram_from_MP.py 'Element1,Element2,Element3,...'") system = [el for el in sys.argv[1].split(',')] # system we want to get PD for MAPI_KEY = 'DSR45TfHVuyuB1WvP1' # You must change this to your Materials API key! (or set MAPI_KEY env variable) system_name = '-'.join(system) mpr = MPRester(MAPI_KEY) # object for connecting to MP Rest interface compat = MaterialsProjectCompatibility( ) # sets energy corrections and +U/pseudopotential choice unprocessed_entries = mpr.get_entries_in_chemsys(system, inc_structure=True) processed_entries = compat.process_entries( unprocessed_entries) # filter and add energy corrections pd = PhaseDiagram(processed_entries) pd_dict = pd.as_dict() filename = f'PD_{system_name}.json' with open(filename, 'w') as f: json.dump(pd_dict, f) print(f"PhaseDiagram object saved as dict in {filename}")
from pymatgen.ext.matproj import MPRester from pymatgen.apps.borg.hive import VaspToComputedEntryDrone from pymatgen.apps.borg.queen import BorgQueen from pymatgen.entries.compatibility import MaterialsProjectCompatibility from pymatgen.analysis.phase_diagram import PhaseDiagram from pymatgen.analysis.phase_diagram import PDPlotter # Assimilate VASP calculations into ComputedEntry object. Let's assume that # the calculations are for a series of new LixFeyOz phases that we want to # know the phase stability. drone = VaspToComputedEntryDrone() queen = BorgQueen(drone, rootpath=".") entries = queen.get_data() # Obtain all existing Li-Fe-O phases using the Materials Project REST API with MPRester("key") as m: mp_entries = m.get_entries_in_chemsys(["Li", "Sn", "S"]) # Combined entry from calculated run with Materials Project entries entries.extend(mp_entries) # Process entries using the MaterialsProjectCompatibility compat = MaterialsProjectCompatibility() entries = compat.process_entries(entries) # Generate and plot Li-Fe-O phase diagram pd = PhaseDiagram(entries) plotter = PDPlotter(pd) plotter.show()
def get_phase_diagram_data(self): """ Returns grand potential phase diagram data to external plot Assumes openelement specific element equals None :return: Data to external plot """ open_elements_specific = None open_element_all = Element(self.open_element) mpr = MPRester("key") # import do dados dos arquivos tipo vasp drone = VaspToComputedEntryDrone() queen = BorgQueen(drone, rootpath=".") entries = queen.get_data() # Get data to make phase diagram mp_entries = mpr.get_entries_in_chemsys(self.system, compatible_only=True) entries.extend(mp_entries) compat = MaterialsProjectCompatibility() entries = compat.process_entries(entries) #explanation_output = open("explain.txt",'w') entries_output = open("entries.txt", 'w') compat.explain(entries[0]) print(entries, file=entries_output) #print(entries) if open_elements_specific: gcpd = GrandPotentialPhaseDiagram(entries, open_elements_specific) self.plot_phase_diagram(gcpd, False) self.analyze_phase_diagram(gcpd) if open_element_all: pd = PhaseDiagram(entries) chempots = pd.get_transition_chempots(open_element_all) #print(chempots) #all_gcpds = list() toplot = [] # dic = {} for idx in range(len(chempots)): if idx == len(chempots) - 1: avgchempot = chempots[idx] - 0.1 else: avgchempot = 0.5 * (chempots[idx] + chempots[idx + 1]) gcpd = GrandPotentialPhaseDiagram( entries, {open_element_all: avgchempot}, pd.elements) # toplot.append(self.get_grand_potential_phase_diagram(gcpd)) min_chempot = None if idx == len(chempots) - 1 else chempots[ idx + 1] max_chempot = chempots[idx] #gcpd = GrandPotentialPhaseDiagram(entries, {open_element_all: max_chempot}, pd.elements) toplot.append(self.get_grand_potential_phase_diagram(gcpd)) #toplot.append(max_chempot) #self.plot_phase_diagram(gcpd, False) #print({open_element_all: max_chempot}) # Data to plot phase diagram return toplot
def test_process_entries(self): compat = MaterialsProjectCompatibility() entries = compat.process_entries([self.entry1, self.entry2, self.entry3]) self.assertEqual(len(entries), 2)
def get_phase_diagram_data(self): """ Returns grand potential phase diagram data to external plot Assumes openelement specific element equals None :return: Data to external plot """ open_elements_specific = None open_element_all = Element(self.open_element) mpr = MPRester(settings.apiKey) drone = VaspToComputedEntryDrone() queen = BorgQueen(drone, rootpath=".") entries = queen.get_data() # Get data to make phase diagram mp_entries = mpr.get_entries_in_chemsys(self.system, compatible_only=True) entries.extend(mp_entries) compat = MaterialsProjectCompatibility() entries = compat.process_entries(entries) #explanation_output = open("explain.txt",'w') #entries_output = open("entries.txt", 'w') compat.explain(entries[0]) #print(entries, file=entries_output) if open_elements_specific: gcpd = GrandPotentialPhaseDiagram(entries, open_elements_specific) self.plot_phase_diagram(gcpd, False) self.analyze_phase_diagram(gcpd) if open_element_all: pd = PhaseDiagram(entries) chempots = pd.get_transition_chempots(open_element_all) # print(chempots) #all_gcpds = list() toplot = [] # dic = {} for idx in range(len(chempots)): if idx == len(chempots) - 1: avgchempot = chempots[idx] - 0.1 else: avgchempot = 0.5 * (chempots[idx] + chempots[idx + 1]) gcpd = GrandPotentialPhaseDiagram( entries, {open_element_all: avgchempot}, pd.elements) # min_chempot = None if idx == len( # chempots) - 1 else chempots[idx + 1] # max_chempot = chempots[idx] #gcpd = GrandPotentialPhaseDiagram(entries, {open_element_all: max_chempot}, pd.elements) toplot.append(self.get_grand_potential_phase_diagram(gcpd)) # toplot.append(max_chempot) #self.plot_phase_diagram(gcpd, False) #print({open_element_all: max_chempot}) all_phase_diagrams = toplot # print(all_phase_diagrams) number_of_phase_diagrams = len(all_phase_diagrams) #pd3 = PhaseDiagram(entries) chempot_list = pd.get_transition_chempots(open_element_all) pd_index = 0 chempots_range_of_each_phase = {} for particular_phase_diagram in all_phase_diagrams: chempot = chempot_list[pd_index] if pd_index is not number_of_phase_diagrams - 1: next_chempot = chempot_list[pd_index + 1] else: next_chempot = chempot_list[pd_index] - 2.0 chempot_range = [chempot, next_chempot] phases_list = particular_phase_diagram[0] for phase in phases_list: if phase in chempots_range_of_each_phase.keys(): chempots_range_of_each_phase[phase][1] = next_chempot.copy( ) else: chempots_range_of_each_phase[phase] = chempot_range.copy() pd_index = pd_index + 1 return chempots_range_of_each_phase
class AnalyseMaterialsProjectJsonDataWithComputedEntries(): """ Class which will wrap around boilerplate analysis of MaterialsProject-like json files, containing data extracted using borgs and queens. It will be assumed that we are providing ComputedEntries objects directly. """ def __init__(self): # some MP analysis power tools self.compat = MaterialsProjectCompatibility() return def extract_alkali_energy(self, computed_Alkali_entry ): processed_Alkali_entry = self.compat.process_entry(computed_Alkali_entry) self.E_Alkali = processed_Alkali_entry.energy return def extract_phase_diagram_info(self,MP_phase_diagram_json_data_filename): computed_entries = self._extract_MP_data(MP_phase_diagram_json_data_filename) processed_entries = self.compat.process_entries(computed_entries) pd = PhaseDiagram(processed_entries) self.phase_diagram_analyser = PDAnalyzer(pd) return def extract_processed_entries(self,computed_entries): processed_entries = self.compat.process_entries(computed_entries) return processed_entries def extract_energies_above_hull(self,computed_entries,alkali): processed_entries = self.extract_processed_entries(computed_entries) list_energy_above_hull = [] list_alkali_content = [] for entry in processed_entries: decomposition_dict, energy_above_hull = \ self.phase_diagram_analyser.get_decomp_and_e_above_hull(entry, allow_negative=True) list_energy_above_hull.append(energy_above_hull) list_alkali_content.append(entry.composition[alkali]) list_energy_above_hull = np.array(list_energy_above_hull) list_alkali_content = np.array(list_alkali_content ) return list_alkali_content, list_energy_above_hull def extract_energies(self,computed_entries,alkali): processed_entries = self.extract_processed_entries(computed_entries) list_energy = [] list_alkali_content = [] for entry in processed_entries: list_energy.append(entry.energy) list_alkali_content.append(entry.composition[alkali]) list_energy = np.array(list_energy) list_alkali_content = np.array(list_alkali_content ) I = np.argsort(list_alkali_content ) return list_alkali_content[I], list_energy[I] def _extract_MP_data(self,MP_data_filename): drone = VaspToComputedEntryDrone() queen = BorgQueen(drone, "dummy", 1) queen.load_data(MP_data_filename) computed_entries = queen.get_data() del drone del queen return computed_entries
class MaterialsProjectCompatibilityTest(unittest.TestCase): def setUp(self): self.entry1 = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.entry_sulfide = ComputedEntry( 'FeS', -1, 0.0, parameters={'is_hubbard': False, 'run_type': 'GGA', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE S 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.entry2 = ComputedEntry( 'Fe3O4', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.entry3 = ComputedEntry( 'FeO', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 4.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.compat = MaterialsProjectCompatibility(check_potcar_hash=False) self.ggacompat = MaterialsProjectCompatibility("GGA", check_potcar_hash=False) def test_process_entry(self): #Correct parameters self.assertIsNotNone(self.compat.process_entry(self.entry1)) self.assertIsNone(self.ggacompat.process_entry(self.entry1)) #Correct parameters entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': False, "hubbards": {}, 'run_type': 'GGA', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) self.assertIsNotNone(self.ggacompat.process_entry(entry)) entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNotNone(self.compat.process_entry(entry)) def test_correction_values(self): #test_corrections self.assertAlmostEqual(self.compat.process_entry(self.entry1).correction, - 2.733 * 2 - 0.70229 * 3) entry = ComputedEntry( 'FeF3', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'F': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE F 08Apr2002', 'hash': '180141c33d032bfbfff30b3bea9d23dd'}]}) self.assertIsNotNone(self.compat.process_entry(entry)) #Check actual correction self.assertAlmostEqual(self.compat.process_entry(entry).correction, -2.733) self.assertAlmostEqual(self.compat.process_entry( self.entry_sulfide).correction, -0.66346) def test_U_values(self): #Wrong U value entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.2, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) #GGA run of U entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': False, 'hubbards': None, 'run_type': 'GGA', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) #GGA+U run of non-U entry = ComputedEntry( 'Al2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Al': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel': 'PAW_PBE Al 06Sep2000', 'hash': '805c888bbd2793e462311f6a20d873d9'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) #Materials project should not have a U for sulfides entry = ComputedEntry( 'FeS2', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'S': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {"titel": 'PAW_PBE S 08Apr2002', 'hash': "f7f8e4a74a6cbb8d63e41f4373b54df2"}]}) self.assertIsNone(self.compat.process_entry(entry)) def test_wrong_psp(self): #Wrong psp entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe 06Sep2000', 'hash': '9530da8244e4dac17580869b4adab115'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) def test_element_processing(self): entry = ComputedEntry( 'O', -1, 0.0, parameters={'is_hubbard': False, 'hubbards': {}, 'potcar_spec': [{'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}], 'run_type': 'GGA'}) entry = self.compat.process_entry(entry) # self.assertEqual(entry.entry_id, -8) self.assertAlmostEqual(entry.energy, -1) self.assertAlmostEqual(self.ggacompat.process_entry(entry).energy, -1) def test_get_corrections_dict(self): compat = MaterialsProjectCompatibility(check_potcar_hash=False) ggacompat = MaterialsProjectCompatibility("GGA", check_potcar_hash=False) #Correct parameters entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': "7a25bc5b9a5393f46600a4939d357982"}]}) c = compat.get_corrections_dict(entry) self.assertAlmostEqual(c["MP Anion Correction"], -2.10687) self.assertAlmostEqual(c["MP Advanced Correction"], -5.466) entry.parameters["is_hubbard"] = False del entry.parameters["hubbards"] c = ggacompat.get_corrections_dict(entry) self.assertNotIn("MP Advanced Correction", c) def test_process_entries(self): entries = self.compat.process_entries([self.entry1, self.entry2, self.entry3]) self.assertEqual(len(entries), 2)
class AnalyseMaterialsProjectJsonDataWithComputedEntries(): """ Class which will wrap around boilerplate analysis of MaterialsProject-like json files, containing data extracted using borgs and queens. It will be assumed that we are providing ComputedEntries objects directly. """ def __init__(self): # some MP analysis power tools self.compat = MaterialsProjectCompatibility() return def extract_alkali_energy(self, computed_Alkali_entry): processed_Alkali_entry = self.compat.process_entry( computed_Alkali_entry) self.E_Alkali = processed_Alkali_entry.energy return def extract_phase_diagram_info(self, MP_phase_diagram_json_data_filename): computed_entries = self._extract_MP_data( MP_phase_diagram_json_data_filename) processed_entries = self.compat.process_entries(computed_entries) pd = PhaseDiagram(processed_entries) self.phase_diagram_analyser = PDAnalyzer(pd) return def extract_processed_entries(self, computed_entries): processed_entries = self.compat.process_entries(computed_entries) return processed_entries def extract_energies_above_hull(self, computed_entries, alkali): processed_entries = self.extract_processed_entries(computed_entries) list_energy_above_hull = [] list_alkali_content = [] for entry in processed_entries: decomposition_dict, energy_above_hull = \ self.phase_diagram_analyser.get_decomp_and_e_above_hull(entry, allow_negative=True) list_energy_above_hull.append(energy_above_hull) list_alkali_content.append(entry.composition[alkali]) list_energy_above_hull = np.array(list_energy_above_hull) list_alkali_content = np.array(list_alkali_content) return list_alkali_content, list_energy_above_hull def extract_energies(self, computed_entries, alkali): processed_entries = self.extract_processed_entries(computed_entries) list_energy = [] list_alkali_content = [] for entry in processed_entries: list_energy.append(entry.energy) list_alkali_content.append(entry.composition[alkali]) list_energy = np.array(list_energy) list_alkali_content = np.array(list_alkali_content) I = np.argsort(list_alkali_content) return list_alkali_content[I], list_energy[I] def _extract_MP_data(self, MP_data_filename): drone = VaspToComputedEntryDrone() queen = BorgQueen(drone, "dummy", 1) queen.load_data(MP_data_filename) computed_entries = queen.get_data() del drone del queen return computed_entries
class MaterialsProjectCompatibilityTest(unittest.TestCase): def setUp(self): self.entry1 = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.entry2 = ComputedEntry( 'Fe3O4', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.entry3 = ComputedEntry( 'FeO', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 4.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.compat = MaterialsProjectCompatibility(check_potcar_hash=False) self.ggacompat = MaterialsProjectCompatibility("GGA", check_potcar_hash=False) def test_process_entry(self): #Correct parameters self.assertIsNotNone(self.compat.process_entry(self.entry1)) self.assertIsNone(self.ggacompat.process_entry(self.entry1)) #Correct parameters entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': False, "hubbards": {}, 'run_type': 'GGA', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) self.assertIsNotNone(self.ggacompat.process_entry(entry)) entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNotNone(self.compat.process_entry(entry)) def test_correction_values(self): #test_corrections self.assertAlmostEqual(self.compat.process_entry(self.entry1).correction, - 2.733 * 2 - 0.70229 * 3) entry = ComputedEntry( 'FeF3', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'F': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE F 08Apr2002', 'hash': '180141c33d032bfbfff30b3bea9d23dd'}]}) self.assertIsNotNone(self.compat.process_entry(entry)) #Check actual correction self.assertAlmostEqual(self.compat.process_entry(entry).correction, -2.733) def test_U_values(self): #Wrong U value entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.2, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) #GGA run of U entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': False, 'hubbards': None, 'run_type': 'GGA', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) #GGA+U run of non-U entry = ComputedEntry( 'Al2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Al': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel': 'PAW_PBE Al 06Sep2000', 'hash': '805c888bbd2793e462311f6a20d873d9'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) #Materials project should not have a U for sulfides entry = ComputedEntry( 'FeS2', -2, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'S': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {"titel": 'PAW_PBE S 08Apr2002', 'hash': "f7f8e4a74a6cbb8d63e41f4373b54df2"}]}) self.assertIsNone(self.compat.process_entry(entry)) def test_wrong_psp(self): #Wrong psp entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe 06Sep2000', 'hash': '9530da8244e4dac17580869b4adab115'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}]}) self.assertIsNone(self.compat.process_entry(entry)) def test_element_processing(self): entry = ComputedEntry( 'O', -1, 0.0, parameters={'is_hubbard': False, 'hubbards': {}, 'potcar_spec': [{'titel': 'PAW_PBE O 08Apr2002', 'hash': '7a25bc5b9a5393f46600a4939d357982'}], 'run_type': 'GGA'}) entry = self.compat.process_entry(entry) # self.assertEqual(entry.entry_id, -8) self.assertAlmostEqual(entry.energy, -1) self.assertAlmostEqual(self.ggacompat.process_entry(entry).energy, -1) def test_get_corrections_dict(self): compat = MaterialsProjectCompatibility(check_potcar_hash=False) ggacompat = MaterialsProjectCompatibility("GGA", check_potcar_hash=False) #Correct parameters entry = ComputedEntry( 'Fe2O3', -1, 0.0, parameters={'is_hubbard': True, 'hubbards': {'Fe': 5.3, 'O': 0}, 'run_type': 'GGA+U', 'potcar_spec': [{'titel':'PAW_PBE Fe_pv 06Sep2000', 'hash': '994537de5c4122b7f1b77fb604476db4'}, {'titel': 'PAW_PBE O 08Apr2002', 'hash': "7a25bc5b9a5393f46600a4939d357982"}]}) c = compat.get_corrections_dict(entry) self.assertAlmostEqual(c["MP Gas Correction"], -2.10687) self.assertAlmostEqual(c["MP Advanced Correction"], -5.466) entry.parameters["is_hubbard"] = False del entry.parameters["hubbards"] c = ggacompat.get_corrections_dict(entry) self.assertNotIn("MP Advanced Correction", c) def test_process_entries(self): entries = self.compat.process_entries([self.entry1, self.entry2, self.entry3]) self.assertEqual(len(entries), 2)
#!/home/universe/local_env/anaconda3/envs/abinit/bin/python from pymatgen.entries.compatibility import MaterialsProjectCompatibility compat = MaterialsProjectCompatibility() processed_entries=compat.process_entries(unprocessed_entr)