rsspolymlp 0.4.2__tar.gz → 0.4.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rsspolymlp
-Version: 0.4.2
+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,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,26 @@ 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.

{rsspolymlp-0.4.2 → rsspolymlp-0.4.3}/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,26 @@ 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.

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

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

{rsspolymlp-0.4.2 → 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_struct_rep import (
+    StructRepGenerator,
     StructReps,
-    generate_struct_reps_parallel,
 )
 from rsspolymlp.analysis.struct_matcher.identify_uniqstr import (
-    UniqueStructIdentifier,
     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,11 +259,13 @@ class RSSResultSummarizer:
             r["dupstr_paths"] = set(r["dupstr_paths"])
 
         print("   - Converting reduced crystal structure representation...")
-        struct_reps_list = generate_struct_reps_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...")

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