rsspolymlp 0.4.2__tar.gz → 0.4.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsspolymlp
-Version: 0.4.2
+Version: 0.4.4
 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,25 +31,9 @@ Dynamic: license-file
 
 # Framework for random structure search using polynomial machine learning potentials
 
-## 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)
-
+`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
 
@@ -88,6 +72,21 @@ 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
+ - 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.

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

@@ -1,24 +1,8 @@
 # Framework for random structure search using polynomial machine learning potentials
 
-## 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)
-
+`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
 
@@ -57,6 +41,21 @@ 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
+ - 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.

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

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

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

@@ -6,15 +6,15 @@ import xml.etree.ElementTree as ET
 from collections import defaultdict
 from pathlib import Path
 from time import time
-from typing import Optional
+from typing import Literal, 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_struct_rep import (
+    StructRepGenerator,
     StructReps,
-    generate_struct_reps_parallel,
 )
 from rsspolymlp.analysis.struct_matcher.identify_uniqstr import (
     UniqueStructIdentifier,
@@ -38,6 +38,7 @@ class RSSResultSummarizer:
         element_order: list = None,
         num_process: int = -1,
         backend: str = "loky",
+        assign_method: Literal["redrep", "greedy", "HK", "pymatgen"] = "redrep",
         primitive_symprecs: list[float] = [1e-5, 1e-4, 1e-3, 1e-2],
         output_poscar: bool = False,
         thresholds: list[float] = None,
@@ -51,6 +52,7 @@ class RSSResultSummarizer:
         self.element_order = element_order
         self.num_process = num_process
         self.backend = backend
+        self.assign_method = assign_method
         self.primitive_symprecs = primitive_symprecs
         self.output_poscar = output_poscar
         self.thresholds = thresholds
@@ -58,7 +60,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)
@@ -90,10 +92,13 @@ class RSSResultSummarizer:
             axis_tol = 0.1
             pos_tol = 0.1
 
+        self.analyzer = UniqueStructIdentifier(
+            axis_tol=axis_tol,
+            pos_tol=pos_tol,
+            assign_method=self.assign_method,
+        )
         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()
@@ -119,6 +124,7 @@ class RSSResultSummarizer:
                             rss_results_c[comp_tag][res_path],
                             axis_tol=axis_tol,
                             pos_tol=pos_tol,
+                            assign_method=self.assign_method,
                             pre_analyzer=self.analyzer,
                         )
 
@@ -127,11 +133,11 @@ class RSSResultSummarizer:
             unique_structs = self.analyzer.unique_str
             unique_str_prop = self.analyzer.unique_str_prop
             enthalpies = np.array([s["energy"] for s in unique_str_prop])
-            distances = np.array([s["least_distance"] for s in unique_str_prop])
             sort_idx = np.argsort(enthalpies)
 
             if not self.parse_vasp:
                 os.makedirs("ghost_minima", exist_ok=True)
+                distances = np.array([s["least_distance"] for s in unique_str_prop])
                 is_ghost_minima, ghost_minima_info = detect_ghost_minima(
                     enthalpies[sort_idx], distances[sort_idx]
                 )
@@ -196,8 +202,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,10 +214,11 @@ 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,
+                    assign_method=self.assign_method,
                     pre_analyzer=self.analyzer,
                 )
             time_finish = time() - time_start
@@ -225,7 +230,7 @@ class RSSResultSummarizer:
             sort_idx = np.argsort(enthalpies)
             sort_idx = sorted(
                 sort_idx,
-                key=lambda i: len(unique_str_sorted[i]),
+                key=lambda i: len(unique_structs[i]),
                 reverse=True,
             )
             unique_str_sorted = [unique_structs[i] for i in sort_idx]
@@ -264,11 +269,13 @@ class RSSResultSummarizer:
             r["dupstr_paths"] = set(r["dupstr_paths"])
 
         print("   - Converting reduced crystal structure representation...")
-        struct_reps_list = generate_struct_reps_parallel(
+        generator = StructRepGenerator(
+            primitive_symprecs=self.primitive_symprecs,
+        )
+        struct_reps_list = generator.generate_struct_reps_parallel(
             rss_results,
             num_process=self.num_process,
             backend=self.backend,
-            symprec_set1=self.symprec_set,
         )
         if self.update_parent:
             print("   - Eliminating duplicate structures...")
@@ -589,6 +596,14 @@ def log_all_unique_structures(
     with open(file_name, "a") as f:
         print("unique_structures:", file=f)
         for idx1, _str in enumerate(unique_structs):
+            if unique_str_prop is not None:
+                sorted_data = sorted(
+                    zip(unique_structs[idx1], unique_str_prop[idx1]),
+                    key=lambda x: x[1]["energy"],
+                )
+                unique_structs[idx1], unique_str_prop[idx1] = map(
+                    list, zip(*sorted_data)
+                )
             print(f"  - struct_No: {idx1 + 1}", file=f)
             print("    structures:", file=f)
             for idx2, _str in enumerate(unique_structs[idx1]):
@@ -600,7 +615,9 @@ def log_all_unique_structures(
                 objprop = PropUtil(polymlp_st.axis.T, polymlp_st.positions.T)
                 print(f"    - sub_struct_No: '{idx1 + 1}_{idx2 + 1}'", file=f)
                 print(f"      struct_path: {_str.struct_path}", file=f)
-                print(f"      pressure: {_str.pressure}", file=f)
+                print(
+                    f"      pressure: {unique_str_prop[idx1][idx2]['pressure']}", file=f
+                )
                 print(f"      enthalpy: {e}", file=f)
                 print(f"      axis: {objprop.abc}", file=f)
                 print(
@@ -630,7 +647,7 @@ def log_all_unique_structures(
             if unique_other_prop is not None:
                 print("    properties:", unique_other_prop[idx1], file=f)
 
-    comp_res = compute_composition(unique_structs[0][0].original_structure.elements)
+    comp_res = compute_composition(unique_structs[0][0].original_polymlp_st.elements)
 
     rss_result_all = {
         "elements": comp_res.unique_elements.tolist(),

rsspolymlp-0.4.4/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