rsspolymlp 0.4.1__tar.gz → 0.4.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsspolymlp
-Version: 0.4.1
+Version: 0.4.3
 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,9 @@ Dynamic: license-file
 
 # Framework for random structure search using polynomial machine learning potentials
 
-## 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` is a Python code designed to conduct random structure searches (RSS) using polynomial machine learning potentials (MLPs). 
+The code provides functionalities for generating initial random structures, performing geometry optimization using polynomial MLPs, and eliminating duplicate structures. 
+The formulation and development of polynomial MLPs are detailed in [`pypolymlp`](https://github.com/sekocha/pypolymlp).
 
 ## Installation
 
@@ -89,6 +71,7 @@ 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)
@@ -107,3 +90,26 @@ pip install rsspolymlp
      - 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.3}/README.md

@@ -1,26 +1,8 @@
 # Framework for random structure search using polynomial machine learning potentials
 
-## 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` is a Python code designed to conduct random structure searches (RSS) using polynomial machine learning potentials (MLPs). 
+The code provides functionalities for generating initial random structures, performing geometry optimization using polynomial MLPs, and eliminating duplicate structures. 
+The formulation and development of polynomial MLPs are detailed in [`pypolymlp`](https://github.com/sekocha/pypolymlp).
 
 ## Installation
 
@@ -58,6 +40,7 @@ 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)
@@ -75,4 +58,27 @@ pip install rsspolymlp
    - [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)
+   - [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.3}/pyproject.toml

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

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

@@ -9,15 +9,14 @@ from time import time
 from typing import Optional
 
 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 (
+    StructRepGenerator,
+    StructReps,
 )
-from rsspolymlp.analysis.struct_matcher.struct_match import (
-    UniqueStructIdentifier,
+from rsspolymlp.analysis.struct_matcher.identify_uniqstr import (
     identify_unique_structure,
 )
 from rsspolymlp.common.composition import compute_composition
@@ -58,7 +57,7 @@ class RSSResultSummarizer:
         self.update_parent = update_parent
 
         self.pressure = None
-        self.analyzer = UniqueStructIdentifier()
+        self.analyzer = None
 
     def run_summarize(self):
         os.makedirs("json", exist_ok=True)
@@ -92,8 +91,6 @@ class RSSResultSummarizer:
 
         for comp_tag, res_paths in json_paths_c.items():
             print(f"Composition {comp_tag}: summarizing...")
-            self.analyzer = UniqueStructIdentifier()
-
             time_start = time()
 
             processed_paths = set()
@@ -196,8 +193,6 @@ class RSSResultSummarizer:
 
         for comp_tag, res_paths in json_paths_c.items():
             print(f"Composition {comp_tag}: summarizing...")
-            self.analyzer = UniqueStructIdentifier()
-
             if not self.parse_vasp:
                 axis_tol = 0.03
                 pos_tol = 0.03
@@ -210,7 +205,7 @@ class RSSResultSummarizer:
                 print(f" - Processing result file (parent): {res_path}")
                 self.analyzer = identify_unique_structure(
                     rss_results_c[comp_tag][res_path],
-                    standardize_axis=True,
+                    normalize_axis=True,
                     keep_unique=True,
                     axis_tol=axis_tol,
                     pos_tol=pos_tol,
@@ -264,15 +259,17 @@ class RSSResultSummarizer:
             r["dupstr_paths"] = set(r["dupstr_paths"])
 
         print("   - Converting reduced crystal structure representation...")
-        redreps_list = generate_redreps_parallel(
-            rss_results,
+        generator = StructRepGenerator(
             num_process=self.num_process,
             backend=self.backend,
-            symprec_set1=self.symprec_set,
+            primitive_symprecs=self.primitive_symprecs,
+        )
+        struct_reps_list = generator.generate_struct_reps_parallel(
+            rss_results,
         )
         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 +277,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 +458,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 +485,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 +505,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 +520,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 +531,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 +578,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.3/src/rsspolymlp/analysis/struct_matcher/assignment_algo.py

@@ -0,0 +1,181 @@
+import time
+
+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,
+    axis_abc: np.ndarray,
+    pos_tol: float,
+    verbose: bool = False,
+):
+    # 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_axis(pos_reps, elements, axis):
+        pos_reps = np.asarray(pos_reps)
+        sorted_reps = np.empty_like(pos_reps[:, :, axis])
+        start = 0
+        for el in unique_elements:
+            idx = np.flatnonzero(elements == el)
+            n = len(idx)
+            sorted_reps[:, start : start + n] = np.sort(
+                pos_reps[:, idx, axis],
+                axis=1,
+            )
+            start += n
+        return sorted_reps
+
+    matched = np.ones(
+        (len(pos_reps1), len(pos_reps2)),
+        dtype=bool,
+    )
+    for axis in range(3):
+        rows, cols = np.where(matched)
+        if len(rows) == 0:
+            break
+
+        t_start_s = time.time()
+        pos1_axis = sort_positions_axis(pos_reps1, elements1, axis)
+        pos2_axis = sort_positions_axis(pos_reps2, elements2, axis)
+        if verbose:
+            print(f"code: sort_match_screen (axis {axis})")
+            print(f"  Sorting: {round((time.time() - t_start_s) * 1000, 2)} ms")
+
+        t_start_m = time.time()
+        diff = pos1_axis[rows] - pos2_axis[cols]
+        diff -= axis_abc[axis] * np.round(diff / axis_abc[axis])
+        matched[rows, cols] = np.all(np.abs(diff) <= pos_tol, axis=1)
+        if verbose:
+            print(f"  Matching: {round((time.time() - t_start_m) * 1000, 2)} ms")
+            print(f"  Candidate matches: {np.count_nonzero(matched)}")
+    return matched
+
+
+def greedy_match(
+    pos1: np.ndarray,
+    pos2: np.ndarray,
+    elements1: np.ndarray,
+    elements2: np.ndarray,
+    axis_abc: np.ndarray,
+    pos_tol: float,
+    verbose: bool = False,
+):
+    judge = True
+    inv_axis_abc = 1 / axis_abc
+
+    t_start_g = time.time()
+    for el in np.unique(elements1):
+        if not judge:
+            break
+        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.abs(pos2[targets2] - pos1[i])
+            diff -= axis_abc * np.round(inv_axis_abc * diff)
+            diff_max = np.max(np.abs(diff), axis=1)
+            diff[used] = np.inf
+            j = np.argmin(diff_max)
+            if diff_max[j] >= pos_tol:
+                judge = False
+                break
+            used[j] = True
+    if verbose:
+        print("code: greedy_match")
+        print(f"  Matching: {round((time.time() - t_start_g) * 1000, 2)} ms")
+
+    if judge:
+        return True
+    else:
+        return False
+
+
+def bottleneck_assignment(
+    pos1: np.ndarray,
+    pos2: np.ndarray,
+    elements1: np.ndarray,
+    elements2: np.ndarray,
+    axis_abc: np.ndarray,
+    pos_tol: float,
+    best_matching: bool = False,
+    verbose: bool = False,
+):
+    inv_axis_abc = 1 / axis_abc
+    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]
+
+        t_start_d = time.time()
+        diff = pos1_sub[:, None, :] - pos2_sub[None, :, :]
+        diff -= axis_abc * np.round(diff * inv_axis_abc)
+        pos_d = np.max(np.abs(diff), axis=2)
+        n = pos_d.shape[0]
+        if verbose:
+            print("code: bottleneck_assignment")
+            print(
+                f"  Difference Calc.: {round((time.time() - t_start_d) * 1000, 2)} ms"
+            )
+
+        t_start_m = time.time()
+        if best_matching:
+            # 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 = pos_d[np.arange(n), matching].tolist()
+            if verbose:
+                print(f"  Matching: {round((time.time() - t_start_m) * 1000, 2)} ms")
+            if max(pos_max_diffs) > pos_tol:
+                return False
+        else:
+            t_start_m = time.time()
+            rows, cols = np.where(pos_d <= pos_tol)
+            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 verbose:
+                print(f"  Matching: {round((time.time() - t_start_m) * 1000, 2)} ms")
+            if not np.all(matching >= 0):
+                return False
+    return True