rsspolymlp 0.0.2__tar.gz

rsspolymlp-0.0.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hayato Wakai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rsspolymlp-0.0.2/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: rsspolymlp
+Version: 0.0.2
+Summary: A framework for random structure search using polynomial MLPs
+Author-email: Hayato Wakai <wakai@cms.mtl.kyoto-u.ac.jp>
+License: MIT
+Project-URL: homepage, https://github.com/hytwakai/rsspolymlp
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: pypolymlp
+Requires-Dist: symfc
+Requires-Dist: spglib
+Requires-Dist: joblib
+Provides-Extra: pymatgen
+Requires-Dist: pymatgen; extra == "pymatgen"
+Provides-Extra: matplotlib
+Requires-Dist: matplotlib; extra == "matplotlib"
+Provides-Extra: seaborn
+Requires-Dist: seaborn; extra == "seaborn"
+Provides-Extra: tools
+Requires-Dist: pymatgen; extra == "tools"
+Requires-Dist: matplotlib; extra == "tools"
+Requires-Dist: seaborn; extra == "tools"
+Dynamic: license-file
+
+# A framework for random structure search (RSS) using polynomial MLPs
+
+## Citation of rsspolymlp
+
+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/)
+```
+@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}
+}
+```
+
+## Installation
+
+### Required libraries and python modules
+
+- python >= 3.9
+- pypolymlp
+- symfc
+- spglib
+- joblib
+
+[Optional]
+- matplotlib (if plotting RSS results)
+- seaborn (if plotting RSS results)
+
+### How to install
+
+```shell
+git clone https://github.com/hytwakai/rsspolymlp.git
+cd rsspolymlp
+conda create -n rsspolymlp
+conda activate rsspolymlp
+conda install -c conda-forge pypolymlp symfc spglib joblib
+pip install .
+```
+
+## Usage
+
+The command-line interface of `rsspolylmp` is organized into three sections, each corresponding to a different phase of the workflow:
+1. Generating initial structures (`rss-init-struct`)
+2. Performing parallel geometry optimization (`rss-parallel`)
+3. Analyzing RSS results (`rss-analysis`)
+
+### Example Commands
+
+```shell
+rss-init-struct --elements Al Cu --atom_counts 4 4 --num_init_str 2000
+rss-parallel --pot polymlp.yaml --num_opt_str 1000
+rss-analysis
+```
+
+#### Arguments
+- `--elements`: List of element symbols (e.g., `Al Cu`).
+- `--atom_counts`: Number of atoms for each element (must match the order of `--elements`).
+- `--num_init_str`: Number of random initial structures to generate. *(default: 5000)*
+- `--pot`: Path to the polynomial MLP potential file. *(default: polymlp.yaml)*
+- `--num_opt_str`: Maximum number of optimized structures to obtain from RSS. *(default: 1000)*
+- [Additional information is here](docs/rss.md)

rsspolymlp-0.0.2/README.md

@@ -0,0 +1,67 @@
+# A framework for random structure search (RSS) using polynomial MLPs
+
+## Citation of rsspolymlp
+
+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/)
+```
+@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}
+}
+```
+
+## Installation
+
+### Required libraries and python modules
+
+- python >= 3.9
+- pypolymlp
+- symfc
+- spglib
+- joblib
+
+[Optional]
+- matplotlib (if plotting RSS results)
+- seaborn (if plotting RSS results)
+
+### How to install
+
+```shell
+git clone https://github.com/hytwakai/rsspolymlp.git
+cd rsspolymlp
+conda create -n rsspolymlp
+conda activate rsspolymlp
+conda install -c conda-forge pypolymlp symfc spglib joblib
+pip install .
+```
+
+## Usage
+
+The command-line interface of `rsspolylmp` is organized into three sections, each corresponding to a different phase of the workflow:
+1. Generating initial structures (`rss-init-struct`)
+2. Performing parallel geometry optimization (`rss-parallel`)
+3. Analyzing RSS results (`rss-analysis`)
+
+### Example Commands
+
+```shell
+rss-init-struct --elements Al Cu --atom_counts 4 4 --num_init_str 2000
+rss-parallel --pot polymlp.yaml --num_opt_str 1000
+rss-analysis
+```
+
+#### Arguments
+- `--elements`: List of element symbols (e.g., `Al Cu`).
+- `--atom_counts`: Number of atoms for each element (must match the order of `--elements`).
+- `--num_init_str`: Number of random initial structures to generate. *(default: 5000)*
+- `--pot`: Path to the polynomial MLP potential file. *(default: polymlp.yaml)*
+- `--num_opt_str`: Maximum number of optimized structures to obtain from RSS. *(default: 1000)*
+- [Additional information is here](docs/rss.md)

rsspolymlp-0.0.2/pyproject.toml

@@ -0,0 +1,49 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rsspolymlp"
+version = "0.0.2"
+description = "A framework for random structure search using polynomial MLPs"
+license = {text = "MIT"}
+authors = [
+    {name = "Hayato Wakai", email = "wakai@cms.mtl.kyoto-u.ac.jp"},
+]
+readme = {file = "README.md", content-type = "text/markdown"}
+requires-python = ">=3.9"
+dependencies = [
+    "numpy",
+    "scipy",
+    "pypolymlp",
+    "symfc",
+    "spglib",
+    "joblib",
+]
+
+[project.optional-dependencies]
+pymatgen = ["pymatgen"]
+matplotlib = ["matplotlib"]
+seaborn = ["seaborn"]
+tools = ["pymatgen", "matplotlib", "seaborn"]
+
+[project.urls]
+homepage = "https://github.com/hytwakai/rsspolymlp"
+
+[project.scripts]
+rss-init-struct = "rsspolymlp.rss.random_struct:run"
+rss-single-srun = "rsspolymlp.rss.rss_parallel:run_single_srun"
+rss-parallel = "rsspolymlp.rss.rss_parallel:run"
+rss-analysis = "rsspolymlp.rss.rss_analysis:run"
+rss-summarize = "rsspolymlp.analysis.rss_summarize:run"
+rss-outlier = "rsspolymlp.analysis.outlier_cands:run"
+plot-binary = "rsspolymlp.analysis.plot.binary:run"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+rsspolymlp = ["py.typed"]

rsspolymlp-0.0.2/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rsspolymlp-0.0.2/src/rsspolymlp/__init__.py

@@ -0,0 +1 @@
+# src/rss_polymlp/__init__.py

rsspolymlp-0.0.2/src/rsspolymlp/analysis/__init__.py

@@ -0,0 +1 @@
+# src/rss_polymlp/analysis/__init__.py

rsspolymlp-0.0.2/src/rsspolymlp/analysis/convex_hull.py

@@ -0,0 +1,117 @@
+import numpy as np
+from scipy.spatial import ConvexHull
+
+from rsspolymlp.analysis.rss_summarize import (
+    extract_composition_ratio,
+    load_rss_results,
+)
+
+
+class ConvexHullAnalyzer:
+
+    def __init__(self, elements, result_paths):
+
+        self.elements = elements
+        self.result_paths = result_paths
+        self.rss_result_fe = {}
+        self.ch_obj = None
+        self.fe_ch = None
+        self.comp_ch = None
+        self.poscar_ch = None
+
+    def run_calc(self):
+        self.calc_formation_e()
+        self.calc_convex_hull()
+        self.calc_fe_above_convex_hull()
+
+    def calc_formation_e(self):
+        for res_path in self.result_paths:
+            comp_res = extract_composition_ratio(res_path, self.elements)
+            comp_ratio = tuple(
+                np.round(np.array(comp_res.comp_ratio) / sum(comp_res.comp_ratio), 10)
+            )
+
+            rss_results = load_rss_results(
+                res_path, absolute_path=True, get_warning=True
+            )
+            rss_results_valid = [r for r in rss_results if not r["is_strong_outlier"]]
+            rss_results_array = {
+                "formation_e": np.array([r["enthalpy"] for r in rss_results_valid]),
+                "poscars": np.array([r["poscar"] for r in rss_results_valid]),
+                "is_outliers": np.array(
+                    [r["is_weak_outlier"] for r in rss_results_valid]
+                ),
+            }
+            self.rss_result_fe[comp_ratio] = rss_results_array
+
+        e_ends = []
+        keys = np.array(list(self.rss_result_fe))
+        valid_keys = keys[np.any(keys == 1, axis=1)]
+        sorted_keys = sorted(valid_keys, key=lambda x: np.argmax(x))
+        for key in sorted_keys:
+            key_tuple = tuple(key)
+            is_outlier = self.rss_result_fe[key_tuple]["is_outliers"]
+            first_valid_index = np.where(~is_outlier)[0][0]
+            energy = self.rss_result_fe[key_tuple]["formation_e"][first_valid_index]
+            e_ends.append(energy)
+        e_ends = np.array(e_ends)
+
+        for key in self.rss_result_fe:
+            self.rss_result_fe[key]["formation_e"] -= np.dot(e_ends, np.array(key))
+
+    def calc_convex_hull(self):
+        rss_result_fe = self.rss_result_fe
+
+        comp_list, e_min_list, label_list = [], [], []
+        for key, dicts in rss_result_fe.items():
+            comp_list.append(key)
+            first_idx = np.where(~dicts["is_outliers"])[0][0]
+            e_min_list.append(dicts["formation_e"][first_idx])
+            label_list.append(dicts["poscars"][first_idx])
+
+        comp_array = np.array(comp_list)
+        e_min_array = np.array(e_min_list).reshape(-1, 1)
+        label_array = np.array(label_list)
+
+        data_ch = np.hstack([comp_array[:, 1:], e_min_array])
+        self.ch_obj = ConvexHull(data_ch)
+
+        v_convex = np.unique(self.ch_obj.simplices)
+        _fe_ch = e_min_array[v_convex].astype(float)
+        mask = np.where(_fe_ch <= 1e-10)[0]
+
+        _comp_ch = comp_array[v_convex][mask]
+        sort_idx = np.lexsort(_comp_ch[:, ::-1].T)
+
+        self.fe_ch = _fe_ch[mask][sort_idx]
+        self.comp_ch = _comp_ch[sort_idx]
+        self.poscar_ch = label_array[v_convex][mask][sort_idx]
+
+    def calc_fe_above_convex_hull(self):
+        rss_result_fe = self.rss_result_fe
+        for key in rss_result_fe:
+            _ehull = self._calc_fe_convex_hull(key)
+            fe_above_ch = rss_result_fe[key]["formation_e"] - _ehull
+            rss_result_fe[key]["fe_above_ch"] = fe_above_ch
+
+    def _calc_fe_convex_hull(self, comp_ratio):
+        ehull = -1e10
+        for eq in self.ch_obj.equations:
+            face_val_comp = -(np.dot(eq[:-2], comp_ratio[1:]) + eq[-1])
+            ehull_trial = face_val_comp / eq[-2]
+            if ehull_trial > ehull and abs(ehull_trial) > 1e-8:
+                ehull = ehull_trial
+
+        return ehull
+
+    def get_struct_near_convex_hull(self, threshold):
+        near_ch = {}
+        rss_result_fe = self.rss_result_fe
+        for key in rss_result_fe:
+            is_near = rss_result_fe[key]["fe_above_ch"] < threshold / 1000
+            near_ch[key]["formation_e"] = rss_result_fe[key]["formation_e"][is_near]
+            near_ch[key]["poscars"] = rss_result_fe[key]["poscars"][is_near]
+            near_ch[key]["is_outliers"] = rss_result_fe[key]["is_outliers"][is_near]
+            near_ch[key]["fe_above_ch"] = rss_result_fe[key]["fe_above_ch"][is_near]
+
+        return near_ch

rsspolymlp-0.0.2/src/rsspolymlp/analysis/outlier_cands.py

@@ -0,0 +1,76 @@
+import argparse
+import os
+import shutil
+
+import numpy as np
+
+
+def detect_outlier(energies: np.array):
+    """
+    Detect outliers and potential outliers in a 1D energy array.
+
+    Returns
+    -------
+    is_strong_outlier: np.ndarray of bool
+        Boolean array marking strong outliers (energy diff > 1.0).
+    is_weak_outlier : np.ndarray of bool
+        Boolean array marking potential outliers (energy diff > 0.2).
+    """
+    is_strong_outlier = np.full(energies.shape, False, dtype=bool)
+    is_weak_outlier = np.full(energies.shape, False, dtype=bool)
+    window = 5
+
+    n = len(energies)
+    if n < 2:
+        return is_strong_outlier, is_weak_outlier
+
+    for i in range(n - 1):
+        end = min(i + 1 + window, n)
+        energy_diff = np.abs(energies[i] - energies[i + 1 : end])
+        if np.any(energy_diff > 1.0):
+            is_strong_outlier[i] = True
+        if np.any(energy_diff > 0.1):
+            is_weak_outlier[i] = True
+        else:
+            break
+
+    return is_strong_outlier, is_weak_outlier
+
+
+def run():
+    from rsspolymlp.analysis.rss_summarize import load_rss_results
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--result_paths",
+        nargs="*",
+        type=str,
+        required=True,
+        help="Path(s) to RSS result log file(s).",
+    )
+    args = parser.parse_args()
+
+    # Prepare output directory: remove existing files if already exists
+    out_dir = "outlier_candidates"
+    if os.path.exists(out_dir):
+        for filename in os.listdir(out_dir):
+            if "POSCAR" in filename:
+                file_path = os.path.join(out_dir, filename)
+                if os.path.isfile(file_path):
+                    os.remove(file_path)
+    else:
+        os.makedirs(out_dir)
+
+    # Copy weak outlier POSCARs
+    for res_path in args.result_paths:
+        logname = os.path.basename(res_path).split(".log")[0]
+        rss_results = load_rss_results(res_path, absolute_path=True, get_warning=True)
+
+        for idx, result in enumerate(rss_results):
+            if result.get("is_weak_outlier"):
+                dest = f"outlier_candidates/POSCAR_{logname}_No{idx + 1}"
+                shutil.copy(result["poscar"], dest)
+
+
+if __name__ == "__main__":
+    run()

rsspolymlp-0.0.2/src/rsspolymlp/analysis/plot/binary.py

@@ -0,0 +1,114 @@
+import argparse
+
+import numpy as np
+
+from rsspolymlp.analysis.convex_hull import ConvexHullAnalyzer
+from rsspolymlp.utils.matplot_util.custom_plt import CustomPlt
+from rsspolymlp.utils.matplot_util.make_plot import MakePlot
+
+
+def run():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--elements",
+        nargs=2,
+        type=str,
+        required=True,
+        help="Two chemical elements, e.g., La Bi",
+    )
+    parser.add_argument(
+        "--result_paths",
+        nargs="+",
+        type=str,
+        required=True,
+        help="Paths to RSS result log files",
+    )
+    parser.add_argument(
+        "--threshold",
+        type=float,
+        default=-1,
+        help="Threshold for energy above the convex hull in meV/atom "
+        "(default: -1 means no threshold applied)",
+    )
+    args = parser.parse_args()
+
+    custom_template = CustomPlt(
+        label_size=8,
+        label_pad=3.0,
+        legend_size=7,
+        xtick_size=7,
+        ytick_size=7,
+        xtick_pad=3.0,
+        ytick_pad=3.0,
+    )
+    plt = custom_template.get_custom_plt()
+    plotter = MakePlot(
+        plt=plt,
+        column_size=1,
+        height_ratio=0.8,
+    )
+    plotter.initialize_ax()
+
+    ch_analyzer = ConvexHullAnalyzer(args.elements, args.result_paths)
+    ch_analyzer.run_calc()
+
+    fe_ch = ch_analyzer.fe_ch
+    comp_ch = ch_analyzer.comp_ch
+    rss_result_fe = ch_analyzer.rss_result_fe
+
+    plotter.set_visuality(n_color=4, n_line=4, n_marker=1, color_type="grad")
+    plotter.ax_plot(
+        comp_ch[:, 1],
+        fe_ch,
+        plot_type="closed",
+        label=None,
+        plot_size=0.7,
+        line_size=1,
+        zorder=2,
+    )
+    fe_min = np.min(fe_ch)
+
+    for key, _dict in rss_result_fe.items():
+        plotter.set_visuality(n_color=3, n_line=0, n_marker=0, color_type="grad")
+        if not args.threshold == -1:
+            is_not_near = (
+                _dict["fe_above_ch"][~_dict["is_outliers"]] > args.threshold / 1000
+            )
+            _energies = _dict["formation_e"][~_dict["is_outliers"]][is_not_near]
+            _comps = np.full_like(_energies, fill_value=key[1])
+            plotter.ax_scatter(
+                _comps, _energies, plot_type="open", label=None, plot_size=0.4
+            )
+
+            plotter.set_visuality(n_color=1, n_line=0, n_marker=1)
+            _energies = _dict["formation_e"][~_dict["is_outliers"]][~is_not_near]
+            _comps = np.full_like(_energies, fill_value=key[1])
+            plotter.ax_scatter(
+                _comps, _energies, plot_type="open", label=None, plot_size=0.5
+            )
+        else:
+            _energies = _dict["formation_e"][~_dict["is_outliers"]]
+            _comps = np.full_like(_energies, fill_value=key[1])
+            plotter.ax_scatter(
+                _comps, _energies, plot_type="open", label=None, plot_size=0.4
+            )
+
+    plotter.finalize_ax(
+        xlabel=rf"$x$ in {args.elements[0]}$_{{1-x}}${args.elements[1]}$_{{x}}$",
+        ylabel="Formation energy (eV/atom)",
+        x_limits=[0, 1],
+        x_grid=[0.2, 0.1],
+        y_limits=[fe_min * 1.1, 0],
+    )
+
+    plt.tight_layout()
+    plt.savefig(
+        f"{args.elements[0]}{args.elements[1]}.png",
+        bbox_inches="tight",
+        pad_inches=0.01,
+        dpi=600,
+    )
+
+
+if __name__ == "__main__":
+    run()