rsspolymlp 0.3.3__tar.gz → 0.4.0__tar.gz

{rsspolymlp-0.3.3/src/rsspolymlp.egg-info → rsspolymlp-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsspolymlp
-Version: 0.3.3
+Version: 0.4.0
 Summary: A framework for random structure search using polynomial MLPs
 Author-email: Hayato Wakai <wakai@cms.mtl.kyoto-u.ac.jp>
 Maintainer-email: Hayato Wakai <wakai@cms.mtl.kyoto-u.ac.jp>
@@ -35,17 +35,21 @@ Dynamic: license-file
 
 If you use `rsspolymlp` in your study, please cite the following articles.
 
-“Efficient global crystal structure prediction using polynomial machine learning potential in the binary Al–Cu alloy system”, [J. Ceram. Soc. Jpn. 131, 762 (2023)](https://www.jstage.jst.go.jp/article/jcersj2/131/10/131_23053/_article/-char/ja/)
+“Systematic global structure search of bismuth-based binary systems under pressure using machine learning potentials”, [Phys. Rev. Materials 10, 093801 (2026)](https://doi.org/10.1103/k9sg-v7hl)
 ```
-@article{HayatoWakai202323053,
-  title="{Efficient global crystal structure prediction using polynomial machine learning potential in the binary Al–Cu alloy system}",
-  author={Hayato Wakai and Atsuto Seko and Isao Tanaka},
-  journal={J. Ceram. Soc. Jpn.},
-  volume={131},
-  number={10},
-  pages={762-766},
-  year={2023},
-  doi={10.2109/jcersj2.23053}
+@article{Phys.Rev.Mater.10.093801,
+  title = {Systematic global structure search of bismuth-based binary systems under pressure using machine learning potentials},
+  author = {Wakai, Hayato and Ishiwata, Shintaro and Seko, Atsuto},
+  journal = {Phys. Rev. Mater.},
+  volume = {10},
+  issue = {9},
+  pages = {093801},
+  numpages = {28},
+  year = {2026},
+  month = {Sep},
+  publisher = {American Physical Society},
+  doi = {10.1103/k9sg-v7hl},
+  url = {https://link.aps.org/doi/10.1103/k9sg-v7hl}
 }
 ```
 
@@ -93,7 +97,7 @@ pip install rsspolymlp
    - Unique structure identification and RSS result summarization
    - Ghost minimum structure elimination
    - Phase stability analysis
- - [Development kit for polynomial MLPs](docs/rsspolymlp_devkit.md)
+ - [Development kit for polynomial MLPs](docs/rsspolymlp_dev.md)
    - MLP dataset generation
    - DFT dataset division
    - Polynomial MLP development

{rsspolymlp-0.3.3 → rsspolymlp-0.4.0}/README.md

@@ -4,17 +4,21 @@
 
 If you use `rsspolymlp` in your study, please cite the following articles.
 
-“Efficient global crystal structure prediction using polynomial machine learning potential in the binary Al–Cu alloy system”, [J. Ceram. Soc. Jpn. 131, 762 (2023)](https://www.jstage.jst.go.jp/article/jcersj2/131/10/131_23053/_article/-char/ja/)
+“Systematic global structure search of bismuth-based binary systems under pressure using machine learning potentials”, [Phys. Rev. Materials 10, 093801 (2026)](https://doi.org/10.1103/k9sg-v7hl)
 ```
-@article{HayatoWakai202323053,
-  title="{Efficient global crystal structure prediction using polynomial machine learning potential in the binary Al–Cu alloy system}",
-  author={Hayato Wakai and Atsuto Seko and Isao Tanaka},
-  journal={J. Ceram. Soc. Jpn.},
-  volume={131},
-  number={10},
-  pages={762-766},
-  year={2023},
-  doi={10.2109/jcersj2.23053}
+@article{Phys.Rev.Mater.10.093801,
+  title = {Systematic global structure search of bismuth-based binary systems under pressure using machine learning potentials},
+  author = {Wakai, Hayato and Ishiwata, Shintaro and Seko, Atsuto},
+  journal = {Phys. Rev. Mater.},
+  volume = {10},
+  issue = {9},
+  pages = {093801},
+  numpages = {28},
+  year = {2026},
+  month = {Sep},
+  publisher = {American Physical Society},
+  doi = {10.1103/k9sg-v7hl},
+  url = {https://link.aps.org/doi/10.1103/k9sg-v7hl}
 }
 ```
 
@@ -62,7 +66,7 @@ pip install rsspolymlp
    - Unique structure identification and RSS result summarization
    - Ghost minimum structure elimination
    - Phase stability analysis
- - [Development kit for polynomial MLPs](docs/rsspolymlp_devkit.md)
+ - [Development kit for polynomial MLPs](docs/rsspolymlp_dev.md)
    - MLP dataset generation
    - DFT dataset division
    - Polynomial MLP development

{rsspolymlp-0.3.3 → rsspolymlp-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rsspolymlp"
-version = "0.3.3"
+version = "0.4.0"
 description = "A framework for random structure search using polynomial MLPs"
 license = "MIT"
 authors = [

{rsspolymlp-0.3.3 → rsspolymlp-0.4.0}/src/rsspolymlp/analysis/eos.py

@@ -90,7 +90,7 @@ class EOSFit:
         else:
             self.parameters = result[0]
 
-        print(f"RMSE of EOS fit (energy): {self.rmse*1000:.6f} meV")
+        print(f"RMSE of EOS fit (energy): {self.rmse * 1000:.6f} meV")
 
     @property
     def rmse(self) -> float:

{rsspolymlp-0.3.3 → rsspolymlp-0.4.0}/src/rsspolymlp/analysis/ghost_minima.py

@@ -8,9 +8,8 @@ import shutil
 import numpy as np
 from sklearn.cluster import KMeans
 
-from pypolymlp.core.interface_vasp import Vasprun
 from pypolymlp.core.units import EVtoGPa
-from rsspolymlp.common.atomic_energy import atomic_energy
+from rsspolymlp.common.interface_vasp import parse_properties_from_vasprun
 
 
 def detect_ghost_minima(energies: np.array, distances: np.array):
@@ -165,7 +164,9 @@ def detect_actual_ghost_minima(dft_path):
         vasprun_get = False
         for vasprun in vasprun_paths:
             try:
-                vaspobj = Vasprun(vasprun)
+                structure, (energy_dft, _, stress_dft) = parse_properties_from_vasprun(
+                    vasprun, units="GPa"
+                )
                 vasprun_get = True
             except Exception:
                 continue
@@ -182,22 +183,17 @@ def detect_actual_ghost_minima(dft_path):
             )
             continue
 
-        energy_dft = vaspobj.energy
-        structure = vaspobj.structure
-        for element in structure.elements:
-            energy_dft -= atomic_energy(element)
-        energy_dft /= len(structure.elements)
         vol_per_atom = structure.volume / len(structure.elements)
 
-        # Subtract pressure term from MLP enthalpy
         mlp_energy = res["energy"]
         mlp_energy -= pressure * vol_per_atom / EVtoGPa
+        energy_dft /= len(structure.elements)
+        e_diff = mlp_energy - energy_dft
 
-        stress_dft = [(vaspobj.stress / 10).tolist()[i][i] for i in range(3)]
+        stress_dft = [stress_dft[i][i] for i in range(3)]
         press_diff = [pressure - stress_dft[i] for i in range(3)]
         stress_diff = np.max(np.abs(press_diff)) * vol_per_atom / EVtoGPa
 
-        e_diff = mlp_energy - energy_dft
         diff_all.append(
             {
                 "energy_diff": e_diff,
@@ -221,8 +217,8 @@ def detect_actual_ghost_minima(dft_path):
 
             print(f"  - structure: {poscar}", file=f)
             if not delta_e == "null":
-                print(f"    energy_diff_meV_per_atom: {delta_e*1000:.3f}", file=f)
-                print(f"    stress_diff_meV_per_atom: {delta_s*1000:.3f}", file=f)
+                print(f"    energy_diff_meV_per_atom: {delta_e * 1000:.3f}", file=f)
+                print(f"    stress_diff_meV_per_atom: {delta_s * 1000:.3f}", file=f)
                 e_threshold = -0.1  # unit: eV/atom
                 s_threshold = 0.5
                 if delta_e < e_threshold or delta_s > s_threshold:

{rsspolymlp-0.3.3 → rsspolymlp-0.4.0}/src/rsspolymlp/analysis/phase_analysis.py

@@ -1,3 +1,4 @@
+import ast
 import json
 import os
 from collections import defaultdict
@@ -6,9 +7,8 @@ import numpy as np
 import yaml
 from scipy.spatial import ConvexHull
 
-from pypolymlp.core.interface_vasp import Vasprun
-from rsspolymlp.common.atomic_energy import atomic_energy
 from rsspolymlp.common.composition import compute_composition
+from rsspolymlp.common.interface_vasp import parse_properties_from_vasprun
 
 
 class ConvexHullAnalyzer:
@@ -18,6 +18,7 @@ class ConvexHullAnalyzer:
         self.elements = np.array(elements)
         # Initialize per-composition storage
         self._composition_data = {}
+        self.endmember_energies = None
         # Convex hull object
         self.hull = None
         # Results for global minima on the hull
@@ -33,9 +34,9 @@ class ConvexHullAnalyzer:
     def composition_data(self, data):
         """
         composition_data maps each composition ratio (tuple) to a dict with keys:
-            'energy': np.ndarray of energies,
-            'input_path': np.ndarray of file paths,
-            'struct_tag': np.ndarray of structure tags.
+            - 'energy': np.ndarray of energies,
+            - 'input_path': np.ndarray of file paths,
+            - 'struct_tag': np.ndarray of structure tags.
         """
         if not isinstance(data, dict):
             raise TypeError("composition_data must be a dictionary.")
@@ -60,53 +61,53 @@ class ConvexHullAnalyzer:
         self._composition_data = data
 
     def run_analysis(self):
-        """Compute formation energies, build convex hull, and evaluate energies above hull."""
+        """
+        Construct the convex hull, compute formation energies, and evaluate energies above the hull.
+        The convex-hull results are stored in the following attributes:
+            - 'self.hull_energies': formation energies of structures on the hull
+            - 'self.hull_compositions': compositions of structures on the hull
+            - 'self.hull_paths': paths corresponding to structures on the hull
+        self._composition_data maps each composition ratio to a dictionary containing:
+            - 'formation_e': np.ndarray of formation energies
+            - 'fe_above_ch': np.ndarray of energies above the convex hull
+        """
         if len(self.elements) == 0:
             raise ValueError("elements is none. Please set elements.")
         if not self._composition_data:
             raise ValueError("composition_data is empty. Please set results first.")
-        self.compute_formation_energies()
+
+        self.set_endmember_energies()
         self.compute_convex_hull()
+        self.compute_formation_energies()
         self.compute_fe_above_ch()
 
-    def compute_formation_energies(self):
-        """Compute formation energy for each structure relative to pure elements."""
-        # Sort compositions for reproducible output
-        comps = np.array(list(self._composition_data.keys()))
-        order = np.lexsort(comps.T)
-        sorted_keys = [tuple(comps[i].tolist()) for i in order]
-        self._composition_data = {k: self._composition_data[k] for k in sorted_keys}
-
+    def set_endmember_energies(self):
         # Reference energies from pure elements (where any ratio == 1)
+        os.makedirs("phase_analysis/data", exist_ok=True)
+        comps = np.array(list(self._composition_data.keys()))
         pure = comps[np.any(comps == 1, axis=1)]
         pure_sorted = sorted(pure, key=lambda x: np.argmax(x))
-        ref_energies = [
+        self.endmember_energies = [
             np.min(self._composition_data[tuple(r)]["energy"]) for r in pure_sorted
         ]
-        ref_energies = np.array(ref_energies)
-
-        # Calculate and store formation energies
-        for ratio, data in self._composition_data.items():
-            formation = data["energy"] - np.dot(ref_energies, np.array(ratio))
-            data["formation_e"] = formation
-
-        # Save JSON and elements
-        os.makedirs("phase_analysis/data", exist_ok=True)
-        serial = {
-            str(r): {k: v.tolist() for k, v in d.items()}
-            for r, d in self._composition_data.items()
-        }
-        with open("phase_analysis/data/composition_data.json", "w") as f:
-            json.dump(serial, f)
-        np.save("phase_analysis/data/elements.npy", self.elements)
+        self.endmember_energies = np.array(self.endmember_energies)
 
     def compute_convex_hull(self):
         """Build the convex hull and extract vertex compositions and energies."""
+        os.makedirs("phase_analysis/data", exist_ok=True)
+        # Sort compositions for reproducible output
+        comps = np.array(list(self._composition_data.keys()))
+        order = np.lexsort(comps.T)
+        sorted_keys = [tuple(comps[i].tolist()) for i in order]
+        self._composition_data = {k: self._composition_data[k] for k in sorted_keys}
+
         comps, min_e, paths = [], [], []
         for ratio, data in self._composition_data.items():
             comps.append(ratio)
-            idx = np.argmin(data["formation_e"])
-            min_e.append(data["formation_e"][idx])
+            idx = np.argmin(data["energy"])
+            min_e.append(
+                data["energy"][idx] - np.dot(self.endmember_energies, np.array(ratio))
+            )
             paths.append(data["input_path"][idx])
 
         comp_arr = np.array(comps)
@@ -140,10 +141,28 @@ class ConvexHullAnalyzer:
                 f.write(f"    formation_e: {energy}\n")
 
         # Save NumPy arrays
-        os.makedirs("phase_analysis/data", exist_ok=True)
         np.save("phase_analysis/data/hull_e.npy", self.hull_energies)
         np.save("phase_analysis/data/hull_comp.npy", self.hull_compositions)
 
+    def compute_formation_energies(self, json_output=True):
+        """Compute formation energy for each structure relative to pure elements."""
+        # Calculate and store formation energies
+        for ratio, data in self._composition_data.items():
+            formation = data["energy"] - np.dot(
+                self.endmember_energies, np.array(ratio)
+            )
+            data["formation_e"] = formation
+
+        # Save JSON and elements
+        if json_output:
+            serial = {
+                str(r): {k: v.tolist() for k, v in d.items()}
+                for r, d in self._composition_data.items()
+            }
+            with open("phase_analysis/data/composition_data.json", "w") as f:
+                json.dump(serial, f)
+            np.save("phase_analysis/data/elements.npy", self.elements)
+
     def compute_fe_above_ch(self):
         """Compute each structure's energy above the convex hull."""
         for ratio, data in self._composition_data.items():
@@ -227,9 +246,9 @@ class ConvexHullAnalyzer:
     def parse_results(self, input_paths, ghost_minima_file=None, parse_vasp=False):
         """
         Populate composition_data by parsing RSS JSON or VASP vasprun.xml outputs.
-        :param input_paths: List of RSS JSON files or VASP directories.
-        :param ghost_minima_file: YAML file listing ghost minima to exclude (RSS only).
-        :param parse_vasp: If True, parse VASP outputs; otherwise parse RSS JSON.
+        input_paths: List of RSS JSON files or VASP directories.
+        ghost_minima_file: YAML file listing ghost minima to exclude (RSS only).
+        parse_vasp: If True, parse VASP outputs; otherwise parse RSS JSON.
         """
         if parse_vasp:
             self._parse_vasp_results(input_paths)
@@ -299,16 +318,17 @@ class ConvexHullAnalyzer:
         for dft_path in input_paths:
             vasprun_path = f"{dft_path}/vasprun.xml"
             try:
-                vaspobj = Vasprun(vasprun_path)
+                structure, (energy_dft, _, _) = parse_properties_from_vasprun(
+                    vasprun_path
+                )
             except Exception:
                 print(vasprun_path, "failed")
                 continue
 
-            energy_dft = vaspobj.energy
-            structure = vaspobj.structure
-            for element in structure.elements:
-                energy_dft -= atomic_energy(element)
             energy_dft /= len(structure.elements)
+            if energy_dft < -15:
+                print(vasprun_path, "exhibits very low energy:", energy_dft, "eV/atom")
+                continue
 
             comp_res = compute_composition(structure.elements, self.elements)
             comp_ratio = tuple(
@@ -338,3 +358,35 @@ class ConvexHullAnalyzer:
             }
 
         self._composition_data = dft_dict_array
+
+
+def load_convexhull_data(path="./phase_analysis", threshold=None):
+    res = {}
+
+    res["elements"] = np.load(f"{path}/data/elements.npy")
+    res["hull_comp"] = np.load(f"{path}/data/hull_comp.npy")
+    res["hull_e"] = np.load(f"{path}/data/hull_e.npy")
+    with open(f"{path}/data/composition_data.json", "r") as f:
+        data = json.load(f)
+    res["composition_data"] = convert_json_to_ndarray(data)
+
+    res["not_near_ch"] = None
+    res["near_ch"] = None
+    if threshold is not None:
+        thre = float(threshold)
+        with open(f"{path}/threshold_{thre}meV/not_near_ch.json", "r") as f:
+            data1 = json.load(f)
+        with open(f"{path}/threshold_{thre}meV/near_ch.json", "r") as f:
+            data2 = json.load(f)
+        res["not_near_ch"] = convert_json_to_ndarray(data1)
+        res["near_ch"] = convert_json_to_ndarray(data2)
+
+    return res
+
+
+def convert_json_to_ndarray(data):
+    converted = {
+        ast.literal_eval(k): {key: np.array(val) for key, val in v.items()}
+        for k, v in data.items()
+    }
+    return converted

{rsspolymlp-0.3.3 → rsspolymlp-0.4.0}/src/rsspolymlp/analysis/rss_summarize.py

@@ -9,7 +9,6 @@ from time import time
 
 import numpy as np
 
-from pypolymlp.core.interface_vasp import Vasprun
 from pypolymlp.utils.vasp_utils import write_poscar_file
 from rsspolymlp.analysis.ghost_minima import detect_ghost_minima
 from rsspolymlp.analysis.unique_struct import (
@@ -18,9 +17,9 @@ from rsspolymlp.analysis.unique_struct import (
     log_all_unique_structures,
     log_unique_structures,
 )
-from rsspolymlp.common.atomic_energy import atomic_energy
 from rsspolymlp.common.composition import compute_composition
 from rsspolymlp.common.convert_dict import polymlp_struct_from_dict
+from rsspolymlp.common.interface_vasp import Vasprun, parse_properties_from_vasprun
 from rsspolymlp.common.property import PropUtil
 
 
@@ -80,9 +79,7 @@ class RSSResultSummarizer:
             parent_path_ref[composition_tag] = json_path
 
         if not self.parse_vasp:
-            paths_same_comp, results_same_comp = self._parse_json_result(
-                parse_rss_result=True
-            )
+            paths_same_comp, results_same_comp = self._parse_json_result()
             axis_tol = 0.03
             pos_tol = 0.03
         else:
@@ -134,19 +131,22 @@ class RSSResultSummarizer:
             for ustr in unique_structs:
                 num_opt_str += len(list(ustr.dupstr_paths))
 
-            with open(composition_tag + ".yaml", "w") as f:
-                print("general_information:", file=f)
-                print(f"  sorting_time_sec:      {round(time_finish, 2)}", file=f)
-                print(f"  pressure_GPa:          {self.pressure}", file=f)
-                print(f"  num_optimized_structs: {num_opt_str}", file=f)
-                print(f"  num_unique_structs:    {len(unique_structs)}", file=f)
-                print("", file=f)
-
             energies = np.array([s.energy for s in unique_structs])
             distances = np.array([s.least_distance for s in unique_structs])
 
             sort_idx = np.argsort(energies)
             unique_str_sorted = [unique_structs[i] for i in sort_idx]
+            if self.thresholds is not None:
+                e_min = None
+                for idx, u in enumerate(unique_str_sorted):
+                    if e_min is None:
+                        e_min = u.energy
+                    if u.energy - e_min > self.thresholds[0] * 0.001:
+                        unique_str_sorted = unique_str_sorted[:idx]
+                        break
+                output_file = f"{composition_tag}_{self.thresholds[0]}"
+            else:
+                output_file = composition_tag
 
             if not self.parse_vasp:
                 os.makedirs("ghost_minima", exist_ok=True)
@@ -162,19 +162,27 @@ class RSSResultSummarizer:
             else:
                 is_ghost_minima = None
 
+            with open(output_file + ".yaml", "w") as f:
+                print("general_information:", file=f)
+                print(f"  sorting_time_sec:      {round(time_finish, 2)}", file=f)
+                print(f"  pressure_GPa:          {self.pressure}", file=f)
+                print(f"  num_optimized_structs: {num_opt_str}", file=f)
+                print(f"  num_unique_structs:    {len(unique_structs)}", file=f)
+                print("", file=f)
+
             rss_result_all = log_unique_structures(
-                composition_tag + ".yaml",
+                output_file + ".yaml",
                 unique_str_sorted,
                 is_ghost_minima,
                 pressure=self.pressure,
             )
 
-            with open(f"json/{composition_tag}.json", "w") as f:
+            with open(f"json/{output_file}.json", "w") as f:
                 json.dump(rss_result_all, f)
 
             if self.thresholds is not None or self.output_poscar is not False:
                 self.generate_poscars(
-                    f"json/{composition_tag}.json",
+                    f"json/{output_file}.json",
                     thresholds=self.thresholds,
                     output_poscar=self.output_poscar,
                 )
@@ -187,16 +195,25 @@ class RSSResultSummarizer:
         paths_same_comp, results_same_comp = self._parse_json_result()
 
         for composition_tag, res_paths in paths_same_comp.items():
+            print(f"Composition {composition_tag}: summarizing...")
             self.analyzer = UniqueStructureAnalyzer()
 
+            if not self.parse_vasp:
+                axis_tol = 0.03
+                pos_tol = 0.03
+            else:
+                axis_tol = 0.1
+                pos_tol = 0.1
+
             time_start = time()
             for res_path in res_paths:
+                print(f" - Processing result file (parent): {res_path}")
                 self.remove_duplicates_in_comp(
                     results_same_comp[composition_tag][res_path],
                     standardize_axis=True,
                     keep_unique=True,
-                    axis_tol=0.03,
-                    pos_tol=0.03,
+                    axis_tol=axis_tol,
+                    pos_tol=pos_tol,
                 )
             time_finish = time() - time_start
 
@@ -333,7 +350,7 @@ class RSSResultSummarizer:
 
             for res in rss_results:
                 if threshold is not None:
-                    diff = abs(e_min - res["energy"])
+                    diff = res["energy"] - e_min
                     if diff * 1000 > threshold:
                         continue
 
@@ -348,11 +365,10 @@ class RSSResultSummarizer:
                             shutil.copy(poscar_path, dest)
                         else:
                             try:
-                                vaspobj = Vasprun(res["struct_path"])
+                                polymlp_st = Vasprun(res["struct_path"]).structure
                             except Exception:
                                 print(res["struct_path"], "failed")
                                 continue
-                            polymlp_st = vaspobj.structure
                             write_poscar_file(polymlp_st, filename=dest)
                         shutil.copy(res["struct_path"], dest_vasp)
                     else:
@@ -364,16 +380,20 @@ class RSSResultSummarizer:
 
         return struct_counts
 
-    def _parse_json_result(self, parse_rss_result=False):
+    def _parse_json_result(self):
 
         def resolve_path(base: Path, p):
             cwd = Path.cwd()
+            target = Path(p)
             if p is None:
                 return None
-            p = Path(p)
-            target = (
-                base / p if "opt_struct" in p.parts else base / "opt_struct" / p.name
-            )
+            if not self.parse_vasp:
+                p = Path(p)
+                target = (
+                    base / p
+                    if "opt_struct" in p.parts
+                    else base / "opt_struct" / p.name
+                )
             return os.path.relpath(target, start=cwd)
 
         paths_same_comp = defaultdict(list)
@@ -382,15 +402,12 @@ class RSSResultSummarizer:
             with open(path_name) as f:
                 loaded_dict = json.load(f)
 
-            if parse_rss_result:
-                base = Path(path_name).parents[1]
-                for r in loaded_dict["rss_results"]:
-                    r["struct_path"] = resolve_path(base, r["struct_path"])
-                    r["dupstr_paths"] = {
-                        resolve_path(base, p) for p in r["dupstr_paths"]
-                    }
-                    r["structure"] = polymlp_struct_from_dict(r["structure"])
-                    r["struct_no"] = None
+            base = Path(path_name).parents[1]
+            for r in loaded_dict["rss_results"]:
+                r["struct_path"] = resolve_path(base, r["struct_path"])
+                r["dupstr_paths"] = {resolve_path(base, p) for p in r["dupstr_paths"]}
+                r["structure"] = polymlp_struct_from_dict(r["structure"])
+                r["struct_no"] = None
 
             target_elements = loaded_dict["elements"]
             comp_ratio = tuple(loaded_dict["comp_ratio"])
@@ -421,24 +438,21 @@ class RSSResultSummarizer:
                 "dupstr_paths": None,
             }
             try:
-                vaspobj = Vasprun(path_name + "/vasprun.xml")
+                polymlp_st, (energy_dft, _, _) = parse_properties_from_vasprun(
+                    path_name + "/vasprun.xml",
+                )
             except Exception:
                 print("ParseError:", path_name + "/vasprun.xml")
                 continue
 
-            polymlp_st = vaspobj.structure
-            objprop = PropUtil(polymlp_st.axis.T, polymlp_st.positions.T)
-            spg_list = objprop.analyze_space_group(polymlp_st.elements)
-
-            energy_dft = vaspobj.energy
-            for element in polymlp_st.elements:
-                energy_dft -= atomic_energy(element)
             energy_dft /= len(polymlp_st.elements)
-
             if energy_dft < -10:
                 print(path_name, "exhibits an unphysically low energy. Skipping.")
                 continue
 
+            objprop = PropUtil(polymlp_st.axis.T, polymlp_st.positions.T)
+            spg_list = objprop.analyze_space_group(polymlp_st.elements)
+
             res_dict["struct_path"] = os.path.relpath(
                 path_name + "/vasprun.xml", os.getcwd()
             )