GraphAtoms 2.3.0__tar.gz → 2.3.1__tar.gz

{graphatoms-2.3.0 → graphatoms-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphatoms
-Version: 2.3.0
+Version: 2.3.1
 Summary: The Chemical Core Class for Graph Theory Analysis.
 Keywords: chemistry,graph theory,reaction,event,KMC
 Author: LiuGaoyong

{graphatoms-2.3.0 → graphatoms-2.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.3.0"
+version = "2.3.1"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 license-files = ["src/LICENSE"]
@@ -56,7 +56,7 @@ Issues = "https://github.com/LiuGaoyong/GraphAtoms/issues/"
 
 [project.scripts]
 graphatoms-config = "graphatoms.enterpoint.config:print_config"
-graphatoms-network = "graphatoms.enterpoint.view:main"
+graphatoms-network = "graphatoms.enterpoint.network:main"
 graphatoms-run = "graphatoms.enterpoint.runner:run"
 
 [[project.authors]]

{graphatoms-2.3.0 → graphatoms-2.3.1}/pyproject.toml.orig

@@ -8,11 +8,11 @@ Repository = "https://github.com/LiuGaoyong/GraphAtoms"
 Issues = "https://github.com/LiuGaoyong/GraphAtoms/issues/"
 [project.scripts]
 graphatoms-config = "graphatoms.enterpoint.config:print_config"
-graphatoms-network = "graphatoms.enterpoint.view:main"
+graphatoms-network = "graphatoms.enterpoint.network:main"
 graphatoms-run = "graphatoms.enterpoint.runner:run"
 [project]
 name = "graphatoms"
-version = "2.3.0"
+version = "2.3.1"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]

{graphatoms-2.3.0 → graphatoms-2.3.1}/src/graphatoms/enterpoint/network/__init__.py

@@ -1,4 +1,5 @@
 from ._clsnetwork import ReactionNetwork
+from ._commands import main
 from ._metadata import MetaData
 from ._recorder import Recorder
 from ._scheduler import Scheduler
@@ -8,4 +9,5 @@ __all__ = [
     "Recorder",
     "Scheduler",
     "ReactionNetwork",
+    "main",
 ]

{graphatoms-2.3.0 → graphatoms-2.3.1}/src/graphatoms/enterpoint/network/_clsnetwork.py

@@ -1,12 +1,23 @@
 import pickle
 import time
+from collections.abc import Iterator, Mapping
 from pathlib import Path
-from typing import Literal, Self
+from typing import Literal, Self, override
 
 import numpy as np
 from ase import Atoms
 
 from graphatoms.enterpoint.config import Config, EventConfig
+from graphatoms.enterpoint.network._metadata import MetaData
+from graphatoms.enterpoint.network._metadata import (
+    _MetaDataBasic as MetaDataBasic,
+)
+from graphatoms.enterpoint.network._recorder import (
+    OldNewRecorder4Confidence,
+    Recorder,
+    RecorderInfo,
+)
+from graphatoms.enterpoint.network._scheduler import Scheduler
 from graphatoms.reaction import (
     Adsorption,
     Desorption,
@@ -17,11 +28,6 @@ from graphatoms.reaction import (
 from graphatoms.system import Cluster, Gas, SysGraph, System
 from graphatoms.system.database import DatabaseABC, get_db
 
-from ._metadata import MetaData
-from ._metadata import _MetaDataBasic as MetaDataBasic
-from ._recorder import OldNewRecorder4Confidence, Recorder, RecorderInfo
-from ._scheduler import Scheduler
-
 __all__ = [
     "MetaData",
     "Recorder",
@@ -31,7 +37,7 @@ __all__ = [
 NETWORK_PATH_PREFIX = "event"
 
 
-class ReactionNetwork:
+class ReactionNetwork(Mapping[str, tuple[EventInfo, EventBase]]):
     DB_USE_POSITION_UUID_DICT: dict[str, bool] = {
         "ts": True,
         "minima": True,
@@ -57,8 +63,8 @@ class ReactionNetwork:
             assert format in (
                 "sqlite",
                 "directory",
-                "dir",
                 "folder",
+                "dir",
                 "h5",
                 "hdf5",
             ), f"The format of `{format}` is not supported for restart."
@@ -118,6 +124,170 @@ class ReactionNetwork:
         assert isinstance(self.__db_cluster, DatabaseABC)
         assert isinstance(self.__db_system, DatabaseABC)
 
+    @classmethod
+    def from_config(
+        cls,
+        config: Config,
+        *args,
+        restart: bool | None = None,
+        remote_mode: bool = False,
+        **kwargs,
+    ) -> Self:  # type: ignore
+        """Create a network from a config file."""
+        if remote_mode is True:
+            # When remote_mode is True, some files may not exist or in write.
+            # We need to try to create the network again.
+            err = None
+            for _ in range(10):
+                try:
+                    return cls(
+                        path=Path(config.outputs) / NETWORK_PATH_PREFIX,
+                        restart=restart
+                        if restart is not None
+                        else config.restart,
+                        format=config.event.db_format,
+                        remote_mode=remote_mode,
+                        config=config.event,
+                        **kwargs,
+                    )
+                    break
+                except Exception as e:
+                    time.sleep(0.5)
+                    err = e
+            if err is not None:
+                raise RuntimeError(
+                    f"Failed to create the network in remote mode. {err}"
+                )
+        else:
+            return cls(
+                path=Path(config.outputs) / NETWORK_PATH_PREFIX,
+                restart=restart if restart is not None else config.restart,
+                format=config.event.db_format,
+                remote_mode=remote_mode,
+                config=config.event,
+                **kwargs,
+            )
+
+    @classmethod
+    def merge(
+        cls,
+        *networks: Self,
+        new_path: Path | str,
+        new_format: str | Literal["dir", "h5", "sqlite"] = "dir",
+        **kwargs,
+    ) -> Self:
+        """Merge the networks.
+
+        Note: the recorder will be set empty.
+        """
+        if len(networks) <= 1:
+            raise ValueError("At least two network is required.")
+        result = cls(
+            path=Path(new_path),
+            restart=False,
+            config=networks[0].metadata.basic,
+            format=new_format,
+        )
+        result.metadata.basic.db_format = new_format
+        for network in networks[1:]:
+            try:
+                network.metadata.basic.check_consistency(
+                    result.metadata.basic,
+                    exclude_keys={"db_format", "gas_sticking"},
+                )
+                for k, v in network.metadata.basic.gas_sticking.items():
+                    if k not in result.metadata.basic.gas_sticking:
+                        result.metadata.basic.gas_sticking[k] = v
+                    else:
+                        v0 = result.metadata.basic.gas_sticking[k]
+                        assert v0 == v, (
+                            f"Failed to merge the networks because the "
+                            f"gas sticking of {k} is not the same as "
+                            f"input. self={v0}, input={v}"
+                        )
+                    result.metadata.basic.gas_sticking[k] = v
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to merge the networks because "
+                    f"of check consistency failed: {e}"
+                )
+            for k, use_pos_uuid in cls.DB_USE_POSITION_UUID_DICT.items():
+                db_res: DatabaseABC = getattr(result, f"db_{k}")
+                db: DatabaseABC = getattr(network, f"db_{k}")
+                for _, v in db.items():
+                    graph = SysGraph.from_ase(v)
+                    graph_key = graph.get_key_for_metadata(use_pos_uuid)
+                    if graph_key not in db_res:
+                        db_res._save(graph_key, graph)
+            for i, rxn in enumerate(network.metadata.table.key_rxn):
+                if rxn not in result.metadata.table.key_rxn:
+                    key_r = network.metadata.table.key_r[i]
+                    key_p = network.metadata.table.key_p[i]
+                    key_g = network.metadata.table.key_g[i]
+                    key_ts = network.metadata.table.key_t[i]
+                    if key_r not in result.db_minima:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of reactant: {key_r}\n",
+                            flush=True,
+                        )
+                        continue
+                    elif key_g is not None and key_g not in result.db_gas:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of gas: {key_g}\n",
+                            flush=True,
+                        )
+                        continue
+                    elif key_ts is not None and key_ts not in result.db_ts:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of transition state: {key_ts}\n",
+                            flush=True,
+                        )
+                        continue
+                    elif key_p is not None and key_p not in result.db_minima:
+                        print(
+                            f"Find invalid key: {rxn}\n"
+                            f"  Missing key of product: {key_p}\n",
+                            flush=True,
+                        )
+                        continue
+                result.metadata.table.merge(  # Output duplicate info
+                    network.metadata.table, idxs=[i]
+                )
+        n = len(result.metadata.table.key_rxn)
+        print(f"Merge networks({n} events) done.", flush=True)
+        result.scheduler.clear()
+        result.recorder.clear()
+        result.persistence()
+        return result
+
+    @classmethod
+    def reformat_message(cls, msg: str) -> str:
+        return msg
+        __LOGURU_FORMAT_LENGTH: int = 37
+        __LOGURU_TOTAL_LENGTH: int = 120
+        len_msg = __LOGURU_TOTAL_LENGTH - __LOGURU_FORMAT_LENGTH
+        lst = wrap_line(msg, width_min=len_msg, width_max=len_msg + 20)
+        return ("\n" + " " * __LOGURU_FORMAT_LENGTH).join(lst)
+
+    @override
+    def __len__(self) -> int:
+        return len(self.metadata.table.key_rxn)
+
+    @override
+    def __contains__(self, key: str) -> bool:  # type: ignore
+        return key in self.metadata.table.key_rxn
+
+    @override
+    def __getitem__(self, key: str) -> tuple[EventInfo, EventBase]:
+        return self.read_event(key)
+
+    @override
+    def __iter__(self) -> Iterator[str]:
+        yield from self.metadata.table.key_rxn
+
     @property
     def path(self) -> Path:
         return self.__path
@@ -186,76 +356,6 @@ class ReactionNetwork:
             )
         return self.__db_ts
 
-    @classmethod
-    def from_config(
-        cls,
-        config: Config,
-        *args,
-        restart: bool | None = None,
-        remote_mode: bool = False,
-        **kwargs,
-    ) -> Self:  # type: ignore
-        """Create a network from a config file."""
-        if remote_mode is True:
-            # When remote_mode is True, some files may not exist or in write.
-            # We need to try to create the network again.
-            err = None
-            for _ in range(10):
-                try:
-                    return cls(
-                        path=Path(config.outputs) / NETWORK_PATH_PREFIX,
-                        restart=restart
-                        if restart is not None
-                        else config.restart,
-                        format=config.event.db_format,
-                        remote_mode=remote_mode,
-                        config=config.event,
-                        **kwargs,
-                    )
-                    break
-                except Exception as e:
-                    time.sleep(0.5)
-                    err = e
-            if err is not None:
-                raise RuntimeError(
-                    f"Failed to create the network in remote mode. {err}"
-                )
-        else:
-            return cls(
-                path=Path(config.outputs) / NETWORK_PATH_PREFIX,
-                restart=restart if restart is not None else config.restart,
-                format=config.event.db_format,
-                remote_mode=remote_mode,
-                config=config.event,
-                **kwargs,
-            )
-
-    @classmethod
-    def merge(
-        cls,
-        *networks: Self,
-        new_path: Path | str,
-        new_format: str | Literal["dir", "h5", "sqlite"] = "dir",
-        **kwargs,
-    ) -> Self:
-        """Merge the networks."""
-        raise NotImplementedError("Merge the networks.")
-        cls(
-            path=new_path,
-            restart=False,
-            config=networks[0].metadata.basic,
-            format=networks[0].__format,
-        )
-
-    @classmethod
-    def reformat_message(cls, msg: str) -> str:
-        return msg
-        __LOGURU_FORMAT_LENGTH: int = 37
-        __LOGURU_TOTAL_LENGTH: int = 120
-        len_msg = __LOGURU_TOTAL_LENGTH - __LOGURU_FORMAT_LENGTH
-        lst = wrap_line(msg, width_min=len_msg, width_max=len_msg + 20)
-        return ("\n" + " " * __LOGURU_FORMAT_LENGTH).join(lst)
-
     def exploration_can_be_finished(
         self,
         confidence: float,
@@ -311,7 +411,8 @@ class ReactionNetwork:
         msg += f"    #Minima    :{len(self.__db_minima)}\n"
         msg += f"    #Gas       :{len(self.__db_gas)}\n"
         msg += f"    #TS        :{len(self.__db_ts)}\n"
-        msg += f"#Event     :{len(self.__metadata.table)}\n"
+        msg += f"#Event         :{len(self.__metadata.table)}\n"
+        msg += f"Configuration  :{self.__metadata.basic.to_str(indent=4)}\n"
         return msg
 
     def persistence(self) -> None:
@@ -397,6 +498,7 @@ class ReactionNetwork:
         *,
         for_system: str | None = None,
         persist: bool = True,
+        env_hop: int = 1,  # TODO: make this into whole configuration
         **kwargs,
     ) -> Literal["new", "old", "fail"] | str:
         """Record the event as found.
@@ -425,13 +527,22 @@ class ReactionNetwork:
             simplified_threshold = self.__metadata.basic.simplified_threshold
             if simplified_threshold > 0:
                 try:
-                    event = event.simplify(simplified_threshold)
+                    event = event.simplify(
+                        env_radius=simplified_threshold,
+                        env_hop=env_hop,
+                    )
                 except Exception as e:
                     msg = f"Event {event._string()} failed "
                     msg += f"to simplify. because of {e}"
                     fname = self.__path / "event-simplify-fail.pkl"
-                    fname.write_bytes(pickle.dumps(event))
                     fname.with_suffix(".err").write_text(msg)
+                    fname.write_bytes(pickle.dumps(event))
+                    event.R.write_npz(fname.with_suffix(".R.npz"))
+                    event.P.write_npz(fname.with_suffix(".P.npz"))
+                    if event.G is not None:
+                        event.G.write_npz(fname.with_suffix(".G.npz"))
+                    if event.T is not None:
+                        event.T.write_npz(fname.with_suffix(".T.npz"))
                     raise ValueError(msg)
             if self.write_event(
                 event,
@@ -659,3 +770,31 @@ def wrap_line(
             lines.pop()
 
     return lines
+
+
+if __name__ == "__main__":
+    import json
+    import shutil
+    from pathlib import Path
+
+    this_dir = Path(__file__).parent
+    root_path = this_dir.parent.parent.parent.parent
+    print(root_path)
+
+    new_path = root_path / "zzzz-merged" / "event"
+    shutil.rmtree(new_path.parent, ignore_errors=True)
+
+    network_lst: list[ReactionNetwork] = []
+    for zzzz_path in root_path.glob("zzzz-*"):
+        if "merge" not in zzzz_path.name:
+            p = zzzz_path / "event"
+            (p / "recorder.json").unlink(missing_ok=True)
+            with open(p / "recorder.json", "w") as f:
+                json.dump({}, f, indent=4)
+            network_lst.append(
+                ReactionNetwork(
+                    zzzz_path / "event",
+                    restart=True,
+                )
+            )
+    new_network = ReactionNetwork.merge(*network_lst, new_path=new_path)

graphatoms-2.3.1/src/graphatoms/enterpoint/network/_commands.py

@@ -0,0 +1,139 @@
+import pathlib
+from typing import Annotated
+
+import pandas as pd
+import typer
+from ase import Atoms
+from ase.visualize import view as _ase_view
+
+from graphatoms.enterpoint.network import ReactionNetwork as Net
+from graphatoms.system import SysGraph
+
+__p_help__ = "Path to the network directory."
+Path = Annotated[str, typer.Option("--path", "-p", help=__p_help__)]
+pd.set_option("display.max_colwidth", None)  # don't truncate cell contents
+pd.set_option("display.max_columns", None)  # show all columns
+pd.set_option("display.max_rows", None)  # show all rows
+pd.set_option("display.width", None)  # don't wrap lines
+
+
+# --------------
+# Main command
+# --------------
+main = typer.Typer(no_args_is_help=True)
+
+
+@main.command()
+def summary(path: Path = ".") -> None:
+    assert pathlib.Path(path).exists()
+    net = Net(path, restart=True, format="dir")
+    print(net.summary())
+
+
+@main.command(no_args_is_help=True)
+def merge(
+    args: Annotated[
+        list[str],
+        typer.Argument(
+            help=f"{Net.__name__} directories to merge (one or more)"
+        ),
+    ],
+    path: Path = "./event",
+    db_format: Annotated[
+        str,
+        typer.Option(
+            "--db-format",
+            "-f",
+            help="Database format in the network.",
+        ),
+    ] = "dir",
+) -> None:
+    assert db_format == "dir", "Only `dir` format is supported now."
+    lst = [Net(p, restart=True, format=db_format) for p in args]
+    Net.merge(*lst, new_path=path)
+
+
+# ----------------
+# Table subcommand
+# ----------------
+show = typer.Typer(no_args_is_help=True)
+main.add_typer(show, name="show")
+
+
+@show.command(name="reaction")
+def show_reaction(arg: str, path: Path = ".") -> tuple[int, Net]:
+    net = Net(path, restart=True, format="dir")
+    df = net.metadata.table.dataframe
+    try:
+        i = int(arg)
+    except ValueError:
+        i = net.metadata.table.key_rxn.index(arg)
+    print(df.iloc[i])
+    return i, net
+
+
+@show.command()
+def table(path: Path = ".") -> None:
+    assert pathlib.Path(path).exists()
+    net = Net(path, restart=True, format="dir")
+    df = net.metadata.table.dataframe
+    col = [0, 5, 6, 7, 8, 11, 12]
+    print(df[df.columns[col]])
+
+
+# ----------------
+# View subcommand
+# ----------------
+view = typer.Typer(no_args_is_help=True)
+
+main.add_typer(view, name="view")
+
+
+@view.command(name="reaction")
+def view_reaction(
+    name: str,
+    path: Path = ".",
+    forward: bool = True,
+) -> None:
+    idx, net = show_reaction(name, path)
+    key_rxn = net.metadata.table.key_rxn[idx]
+    _, rxn = net.read_event(key_rxn)
+    if not forward:
+        rxn = rxn.reversed
+    return rxn.view()
+
+
+@view.command(name="structure")
+def view_structure(
+    name_or_path: str,
+    path: Path = ".",
+) -> None:
+    try:
+        fname = pathlib.Path(name_or_path)
+        if fname.name.count("*") == 0:
+            assert fname.exists() and fname.is_file()
+            return _ase_view(SysGraph.read_npz(fname).to_ase())
+        else:
+            return _ase_view(
+                [
+                    SysGraph.read_npz(i).to_ase()
+                    for i in fname.parent.glob(fname.name)
+                ]
+            )
+    except ValueError:
+        name = name_or_path
+
+    assert pathlib.Path(path).exists()
+    net = Net(path, restart=True, format="dir")
+    atoms: Atoms | None = None
+    for type in ("gas", "ts", "minima", "cluster", "system"):
+        if net.contain_sysgraph(name, type=type):
+            atoms = net.read_atoms(name, type=type)
+            break
+    if atoms is None:
+        raise ValueError(f"structure {name} is not in the database.")
+    return _ase_view(atoms)
+
+
+if __name__ == "__main__":
+    main()

{graphatoms-2.3.0 → graphatoms-2.3.1}/src/graphatoms/enterpoint/network/_metadata.py

@@ -21,12 +21,23 @@ class _MetaDataBasic(OurBaseModel, EventConfig):
     def from_config(cls, config: Config | EventConfig) -> Self:
         if isinstance(config, Config):
             config = config.event
+        if not isinstance(config, dict):
+            if isinstance(config, EventConfig):
+                config = dc.asdict(config)  # type: ignore
+            elif isinstance(config, _MetaDataBasic):
+                config = config.to_dict()
         return cls(**config)  # type: ignore
 
-    def check_consistency(self, config: EventConfig | Self) -> None:
+    def check_consistency(
+        self,
+        config: EventConfig | Self,
+        exclude_keys: set[str] = {"db_format"},
+    ) -> None:
         msg = r"The keys of {} must be the same as input, "
         msg += r"but we got {}(from self) and {}(from input)"
         for k in self.__pydantic_fields__:
+            if k in exclude_keys:
+                continue
             v1 = getattr(self, k)
             v2 = getattr(config, k)
             if not isinstance(v1, dict):
@@ -99,6 +110,41 @@ class _MetaDataTable(BaseModel):
     def from_dataframe(cls, df: pd.DataFrame) -> Self:
         return cls(**{k: df[k].to_list() for k in df.columns})
 
+    def merge(self, other: Self, idxs: list[int] | None = None) -> None:
+        if idxs is None:
+            idxs = list(range(len(other)))
+        for i in idxs:
+            k = other.key_rxn[i]
+            if k not in self.key_rxn:
+                self.key_rxn.append(k)
+                self.key_r.append(other.key_r[i])
+                self.key_g.append(other.key_g[i])
+                self.key_t.append(other.key_t[i])
+                self.key_p.append(other.key_p[i])
+                self.Ea_forword.append(other.Ea_forword[i])
+                self.rate_forword.append(other.rate_forword[i])
+                self.rate_reversed.append(other.rate_reversed[i])
+                self.Ea_reversed.append(other.Ea_reversed[i])
+                self.for_cluster.append(other.for_cluster[i])
+                self.for_system.append(other.for_system[i])
+                self.count.append(other.count[i])
+                self.dE.append(other.dE[i])
+            else:
+                idx = self.key_rxn.index(k)
+                self.count[idx] += other.count[i]
+                len(self.key_r[idx])
+                print(
+                    f"Find duplicate key: {k}\n"
+                    f"  dE:   (old={self.dE[idx]},new={other.dE[i]})\n"
+                    f"  Ea:   (old={self.Ea_forword[idx]},"
+                    f"new={other.Ea_forword[i]})\n"
+                    f"  key_r:(old={self.key_r[idx]},new={other.key_r[i]})\n"
+                    f"  key_g:(old={self.key_g[idx]},new={other.key_g[i]})\n"
+                    f"  key_t:(old={self.key_t[idx]},new={other.key_t[i]})\n"
+                    f"  key_p:(old={self.key_p[idx]},new={other.key_p[i]})\n",
+                    flush=True,
+                )
+
     def get_minconut_for(
         self,
         *,

{graphatoms-2.3.0 → graphatoms-2.3.1}/src/graphatoms/enterpoint/network/_recorder.py

@@ -22,6 +22,7 @@ Ref:
     Fe-H system. PhD thesis, University of Cambridge, 2024.
 """
 
+from abc import abstractmethod
 from collections import defaultdict
 from datetime import datetime
 from typing import Annotated, Any, Self, override
@@ -180,16 +181,32 @@ class RecorderBase(OurBaseModel):
             + "have been explored"
         )
 
+    @abstractmethod
+    def clear(self) -> None:
+        self.cluster.clear()
+
 
 class Recorder(RecorderBase):
     adsorption: set[str] = set()
     bulk: set[str] = set()
 
+    @override
+    def clear(self) -> None:
+        self.adsorption.clear()
+        self.bulk.clear()
+        super().clear()
+
 
 class RecorderV2(RecorderBase):
     adsorption: dict[tuple[str, str], set[str]] = defaultdict(set)
     bulk: dict[str, set[str]] = defaultdict(set)
 
+    @override
+    def clear(self) -> None:
+        self.adsorption.clear()
+        self.bulk.clear()
+        super().clear()
+
     def exploration_can_be_finished(
         self,
         cluster_key: str,

{graphatoms-2.3.0 → graphatoms-2.3.1}/src/graphatoms/enterpoint/network/_scheduler.py

@@ -20,6 +20,10 @@ class Scheduler(BaseModel):
         msg = " ".join(f"{k}:{len(v)}dR" for k, v in self.dR.items())
         return f"{self.__class__.__name__}({msg})"
 
+    def clear(self) -> None:
+        self.is_fixed.clear()
+        self.dR.clear()
+
     @validate_call
     def write_npz(
         self,