rsspolymlp 0.4.1__tar.gz → 0.4.2__tar.gz

{rsspolymlp-0.4.1/src/rsspolymlp.egg-info → rsspolymlp-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsspolymlp
-Version: 0.4.1
+Version: 0.4.2
 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>
@@ -31,27 +31,25 @@ Dynamic: license-file
 
 # Framework for random structure search using polynomial machine learning potentials
 
-## Citation of rsspolymlp
+## How to use rsspolymlp
 
-If you use `rsspolymlp` in your study, please cite the following articles.
+ - [Workflow of RSS with polynomial MLPs](docs/rsspolymlp.md)
+   - Initial structure generation
+   - Global RSS with polynomial MLPs
+   - Unique structure identification and RSS result summarization
+   - Phase stability analysis
+ - [Development kit for polynomial MLPs](docs/rsspolymlp_dev.md)
+   - MLP dataset generation
+   - DFT dataset division
+   - Polynomial MLP development
+   - Pareto-optimal MLP selection
+ - Python API
+   - [RSS workflow](docs/api_rsspolymlp.md)
+   - [VASP calculation utilities](src/rsspolymlp/utils/vasp_util/readme.md)
+     - Single-point calculation
+     - Local geometry optimization
+   - [Matplotlib utilities](src/rsspolymlp/utils/matplot_util/readme.md)
 
-“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{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}
-}
-```
 
 ## Installation
 
@@ -89,21 +87,25 @@ conda install -c conda-forge scikit-learn joblib pypolymlp spglib symfc
 pip install rsspolymlp
 ```
 
-## How to use rsspolymlp
 
- - [Workflow of RSS with polynomial MLPs](docs/rsspolymlp.md)
-   - Initial structure generation
-   - Global RSS with polynomial MLPs
-   - Unique structure identification and RSS result summarization
-   - Phase stability analysis
- - [Development kit for polynomial MLPs](docs/rsspolymlp_dev.md)
-   - MLP dataset generation
-   - DFT dataset division
-   - Polynomial MLP development
-   - Pareto-optimal MLP selection
- - Python API
-   - [RSS workflow](docs/api_rsspolymlp.md)
-   - [VASP calculation utilities](src/rsspolymlp/utils/vasp_util/readme.md)
-     - Single-point calculation
-     - Local geometry optimization
-   - [Matplotlib utilities](src/rsspolymlp/utils/matplot_util/readme.md)
+## Citation of rsspolymlp
+
+If you use `rsspolymlp` in your study, please cite the following articles.
+
+“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{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}
+}
+```

{rsspolymlp-0.4.1 → rsspolymlp-0.4.2}/README.md

@@ -1,26 +1,24 @@
 # Framework for random structure search using polynomial machine learning potentials
 
-## Citation of rsspolymlp
+## How to use rsspolymlp
 
-If you use `rsspolymlp` in your study, please cite the following articles.
+ - [Workflow of RSS with polynomial MLPs](docs/rsspolymlp.md)
+   - Initial structure generation
+   - Global RSS with polynomial MLPs
+   - Unique structure identification and RSS result summarization
+   - Phase stability analysis
+ - [Development kit for polynomial MLPs](docs/rsspolymlp_dev.md)
+   - MLP dataset generation
+   - DFT dataset division
+   - Polynomial MLP development
+   - Pareto-optimal MLP selection
+ - Python API
+   - [RSS workflow](docs/api_rsspolymlp.md)
+   - [VASP calculation utilities](src/rsspolymlp/utils/vasp_util/readme.md)
+     - Single-point calculation
+     - Local geometry optimization
+   - [Matplotlib utilities](src/rsspolymlp/utils/matplot_util/readme.md)
 
-“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{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}
-}
-```
 
 ## Installation
 
@@ -58,21 +56,25 @@ conda install -c conda-forge scikit-learn joblib pypolymlp spglib symfc
 pip install rsspolymlp
 ```
 
-## How to use rsspolymlp
 
- - [Workflow of RSS with polynomial MLPs](docs/rsspolymlp.md)
-   - Initial structure generation
-   - Global RSS with polynomial MLPs
-   - Unique structure identification and RSS result summarization
-   - Phase stability analysis
- - [Development kit for polynomial MLPs](docs/rsspolymlp_dev.md)
-   - MLP dataset generation
-   - DFT dataset division
-   - Polynomial MLP development
-   - Pareto-optimal MLP selection
- - Python API
-   - [RSS workflow](docs/api_rsspolymlp.md)
-   - [VASP calculation utilities](src/rsspolymlp/utils/vasp_util/readme.md)
-     - Single-point calculation
-     - Local geometry optimization
-   - [Matplotlib utilities](src/rsspolymlp/utils/matplot_util/readme.md)
+## Citation of rsspolymlp
+
+If you use `rsspolymlp` in your study, please cite the following articles.
+
+“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{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}
+}
+```

{rsspolymlp-0.4.1 → rsspolymlp-0.4.2}/pyproject.toml

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

{rsspolymlp-0.4.1 → rsspolymlp-0.4.2}/src/rsspolymlp/analysis/rss_summarize.py

@@ -12,11 +12,11 @@ import numpy as np
 
 from pypolymlp.utils.vasp_utils import write_poscar_file
 from rsspolymlp.analysis.ghost_minima import detect_ghost_minima
-from rsspolymlp.analysis.struct_matcher.gen_redrep import (
-    ReducedStructReps,
-    generate_redreps_parallel,
+from rsspolymlp.analysis.struct_matcher.gen_struct_rep import (
+    StructReps,
+    generate_struct_reps_parallel,
 )
-from rsspolymlp.analysis.struct_matcher.struct_match import (
+from rsspolymlp.analysis.struct_matcher.identify_uniqstr import (
     UniqueStructIdentifier,
     identify_unique_structure,
 )
@@ -264,7 +264,7 @@ class RSSResultSummarizer:
             r["dupstr_paths"] = set(r["dupstr_paths"])
 
         print("   - Converting reduced crystal structure representation...")
-        redreps_list = generate_redreps_parallel(
+        struct_reps_list = generate_struct_reps_parallel(
             rss_results,
             num_process=self.num_process,
             backend=self.backend,
@@ -272,7 +272,7 @@ class RSSResultSummarizer:
         )
         if self.update_parent:
             print("   - Eliminating duplicate structures...")
-            for idx, redreps in enumerate(redreps_list):
+            for idx, redreps in enumerate(struct_reps_list):
                 self.analyzer.identify_duplicate_struct(
                     unique_struct=redreps,
                     other_properties=rss_results[idx],
@@ -280,7 +280,7 @@ class RSSResultSummarizer:
                     pos_tol=0.03,
                 )
         else:
-            self.analyzer._initialize_unique_structs(redreps_list, rss_results)
+            self.analyzer._initialize_unique_structs(struct_reps_list, rss_results)
 
         return set(processed_paths)
 
@@ -461,21 +461,22 @@ class RSSResultSummarizer:
 
 def dump_json_rss_results(
     file_name: str,
-    redreps_list: list[ReducedStructReps],
+    struct_reps_list: list[StructReps],
     enthalpy_lists: list[float],
     is_ghost_minima=None,
     pressure=None,
 ):
     if is_ghost_minima is None:
-        is_ghost_minima = np.full_like(redreps_list, False, dtype=bool)
+        is_ghost_minima = np.full_like(struct_reps_list, False, dtype=bool)
 
     rss_results = []
-    for idx, _str in enumerate(redreps_list):
+    for idx, _str in enumerate(struct_reps_list):
         polymlp_st = _str.original_polymlp_st
         objprop = PropUtil(polymlp_st.axis.T, polymlp_st.positions.T)
         rss_results.append(
             {
                 "struct_path": _str.struct_path,
+                "poscar_path": _str.struct_path,
                 "structure": polymlp_struct_to_dict(polymlp_st),
                 "energy": enthalpy_lists[idx],
                 "axis_abc": objprop.abc,
@@ -487,8 +488,8 @@ def dump_json_rss_results(
                 "is_ghost_minima": bool(is_ghost_minima[idx]),
             }
         )
-    if len(redreps_list) > 0:
-        comp_res = compute_composition(redreps_list[0].original_polymlp_st.elements)
+    if len(struct_reps_list) > 0:
+        comp_res = compute_composition(struct_reps_list[0].original_polymlp_st.elements)
         rss_result_all = {
             "elements": comp_res.unique_elements.tolist(),
             "comp_ratio": comp_res.comp_ratio,
@@ -507,13 +508,13 @@ def dump_json_rss_results(
 
 def log_unique_structures(
     file_name: str,
-    redreps_list: list[ReducedStructReps],
+    struct_reps_list: list[StructReps],
     enthalpy_lists: Optional[list[float]] = None,
     is_ghost_minima=None,
     unique_struct_iters=None,
 ):
     if is_ghost_minima is None:
-        is_ghost_minima = np.full_like(redreps_list, False, dtype=bool)
+        is_ghost_minima = np.full_like(struct_reps_list, False, dtype=bool)
     energy_min = None
     if enthalpy_lists is not None:
         for i in range(len(enthalpy_lists)):
@@ -522,9 +523,10 @@ def log_unique_structures(
                 break
 
     struct_num_max = max(
-        (_s.struct_tag for _s in redreps_list if _s.struct_tag is not None), default=0
+        (_s.struct_tag for _s in struct_reps_list if _s.struct_tag is not None),
+        default=0,
     )
-    for _s in redreps_list:
+    for _s in struct_reps_list:
         if _s.struct_tag is None:
             struct_num_max += 1
             _s.struct_tag = struct_num_max
@@ -532,7 +534,7 @@ def log_unique_structures(
     with open(file_name, "a") as f:
         print("unique_structures:", file=f)
         for is_ghost in [False, True]:
-            for idx, _str in enumerate(redreps_list):
+            for idx, _str in enumerate(struct_reps_list):
                 if energy_min is not None:
                     e_diff = round((enthalpy_lists[idx] - energy_min) * 1000, 2)
                     if (not is_ghost and e_diff < -300) or (
@@ -579,7 +581,7 @@ def log_unique_structures(
 
 def log_all_unique_structures(
     file_name,
-    unique_structs: list[list[ReducedStructReps]],
+    unique_structs: list[list[StructReps]],
     unique_str_prop: Optional[list[list[dict]]] = None,
     unique_other_prop=None,
 ):

rsspolymlp-0.4.2/src/rsspolymlp/analysis/struct_matcher/assignment_algo.py

@@ -0,0 +1,112 @@
+import numpy as np
+from scipy.sparse import csr_array
+from scipy.sparse.csgraph import maximum_bipartite_matching
+
+
+def sort_match_screen(
+    pos_reps1: np.ndarray,
+    pos_reps2: np.ndarray,
+    elements1: np.ndarray,
+    elements2: np.ndarray,
+    pos_tol: float,
+):
+    # pos1: (N1, n_atoms, 3)
+    # pos2: (N2, n_atoms, 3)
+    if len(elements1) != len(elements2):
+        return np.zeros((len(pos_reps1), len(pos_reps2)), dtype=bool)
+    unique_elements = np.unique(elements1)
+
+    def sort_positions(pos_reps, elements):
+        sorted_reps = []
+        for pos in pos_reps:
+            pos_sorted = []
+            for el in unique_elements:
+                pos_el = pos[elements == el]
+                pos_el = np.sort(pos_el, axis=0)
+                pos_sorted.append(pos_el)
+            sorted_reps.append(np.concatenate(pos_sorted, axis=0))
+        return np.asarray(sorted_reps)
+
+    pos1_sorted = sort_positions(pos_reps1, elements1)
+    pos2_sorted = sort_positions(pos_reps2, elements2)
+
+    diff = pos1_sorted[:, None, :, :] - pos2_sorted[None, :, :, :]
+    diff -= np.round(diff)
+    return np.all(np.abs(diff) <= pos_tol, axis=(2, 3))
+
+
+def greedy_match(
+    pos1: np.ndarray,
+    pos2: np.ndarray,
+    elements1: np.ndarray,
+    elements2: np.ndarray,
+    pos_tol: float,
+):
+    for el in np.unique(elements1):
+        targets1 = np.where(elements1 == el)[0]
+        targets2 = np.where(elements2 == el)[0]
+        used = np.zeros(len(targets1), dtype=bool)
+        for i in targets1:
+            diff = np.max(np.abs(pos2[targets2] - pos1[i]), axis=1)
+            diff -= np.round(diff)
+            diff[used] = np.inf
+            j = np.argmin(np.abs(diff))
+            if diff[j] >= pos_tol:
+                return False
+            used[j] = True
+    return True
+
+
+def bottleneck_assignment(
+    pos1: np.ndarray,
+    pos2: np.ndarray,
+    elements1: np.ndarray,
+    elements2: np.ndarray,
+    pos_tol: float,
+):
+    pos_max_diffs = []
+    for el in np.unique(elements1):
+        targets1 = np.where(elements1 == el)[0]
+        targets2 = np.where(elements2 == el)[0]
+        pos1_sub = pos1[targets1]
+        pos2_sub = pos2[targets2]
+
+        diff = pos1_sub[:, None, :] - pos2_sub[None, :, :]
+        diff -= np.round(diff)
+        pos_d = np.max(np.abs(diff), axis=2)
+        n = pos_d.shape[0]
+
+        # Sort distinct candidate distances
+        values = np.unique(pos_d)
+        left, right = 0, len(values) - 1
+        while left < right:
+            mid = (left + right) // 2
+            rows, cols = np.where(pos_d <= values[mid])
+            graph = csr_array(
+                (
+                    np.ones(len(rows), dtype=np.int8),
+                    (rows, cols),
+                ),
+                shape=pos_d.shape,
+            )
+            matching = maximum_bipartite_matching(graph, perm_type="column")
+            if np.all(matching >= 0):
+                right = mid
+            else:
+                left = mid + 1
+
+        threshold = values[left]
+        rows, cols = np.where(pos_d <= threshold)
+        graph = csr_array(
+            (
+                np.ones(len(rows), dtype=np.int8),
+                (rows, cols),
+            ),
+            shape=pos_d.shape,
+        )
+        matching = maximum_bipartite_matching(graph, perm_type="column")
+        pos_max_diffs.extend(pos_d[np.arange(n), matching].tolist())
+
+    if max(pos_max_diffs) < pos_tol:
+        judge = True
+    return judge