GraphAtoms 2.1.0__tar.gz → 2.1.1__tar.gz

{graphatoms-2.1.0 → graphatoms-2.1.1}/PKG-INFO

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

{graphatoms-2.1.0 → graphatoms-2.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.1.0"
+version = "2.1.1"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 license-files = ["src/LICENSE"]

{graphatoms-2.1.0 → graphatoms-2.1.1}/pyproject.toml.orig

@@ -12,7 +12,7 @@ graphatoms-network = "graphatoms.enterpoint.view:main"
 graphatoms-run = "graphatoms.enterpoint.runner:run"
 [project]
 name = "graphatoms"
-version = "2.1.0"
+version = "2.1.1"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]

{graphatoms-2.1.0 → graphatoms-2.1.1}/src/graphatoms/enterpoint/config/__init__.py

@@ -66,7 +66,7 @@ class Config:
 
     calculator: CalcConfig = MISSING
 
-    outputs: str = "./zzz"
+    outputs: str = "."
     max_steps: int = 100000
     max_times: float = 1000.0  # seconds
     run_type: str = "otfkmc"  # otfkmc, rxngen
@@ -98,8 +98,6 @@ cs.store(group="calculator", name="calc_nequip", node=NequipConfig)
     version_base=None,
 )
 def print_config(cfg: Config) -> None:
-    from shutil import rmtree
-
     print(OmegaConf.to_yaml(cfg))
     print("""
 hydra:
@@ -107,4 +105,3 @@ hydra:
     dir: ${outputs}
   verbose: ${debug}
 """)
-    rmtree(Path(cfg.outputs))

{graphatoms-2.1.0 → graphatoms-2.1.1}/src/graphatoms/enterpoint/network/__init__.py

@@ -4,8 +4,14 @@ from pathlib import Path
 from typing import Literal
 
 from graphatoms.enterpoint.config import EventConfig
-from graphatoms.reaction import EventBase, EventInfo, Reaction
-from graphatoms.system import Cluster, SysGraph
+from graphatoms.reaction import (
+    Adsorption,
+    Desorption,
+    EventBase,
+    EventInfo,
+    Reaction,
+)
+from graphatoms.system import Gas, SysGraph
 from graphatoms.system.database import DatabaseABC, get_db
 
 from ._metadata import MetaData
@@ -14,14 +20,14 @@ from ._recorder import Recorder
 from ._scheduler import Scheduler
 
 __all__ = [
-    "RxNet",
     "MetaData",
     "Recorder",
     "Scheduler",
+    "ReactionNetwork",
 ]
 
 
-class RxNet:
+class ReactionNetwork:
     def __init__(
         self,
         path: Path | str,
@@ -81,16 +87,26 @@ class RxNet:
                 self.metadata: MetaData = MetaData()
 
         # initialize the databases
-        lst: list[DatabaseABC] = [
+        (
+            self.db_ts,
+            self.db_gas,
+            self.db_minima,
+            self.db_cluster,
+            self.db_system,
+        ) = [
             get_db(
                 path=path,
                 format=format,
                 prefix=prefix,
                 append=restart,
             )
-            for prefix in ["ts", "gas", "minima"]
+            for prefix in ["ts", "gas", "minima", "cluster", "system"]
         ]
-        self.db_ts, self.db_gas, self.db_minima = lst
+        assert isinstance(self.db_ts, DatabaseABC)
+        assert isinstance(self.db_gas, DatabaseABC)
+        assert isinstance(self.db_minima, DatabaseABC)
+        assert isinstance(self.db_cluster, DatabaseABC)
+        assert isinstance(self.db_system, DatabaseABC)
 
     def summary(self) -> str:
         """Return the summary of the network."""
@@ -102,16 +118,24 @@ class RxNet:
         self.scheduler.write_npz(self.__path / "scheduler.npz")
         self.metadata.persistence(self.__path)
 
-    def read(self, key: str) -> tuple[EventInfo, EventBase]:
+    def read_event(self, key: str) -> tuple[EventInfo, EventBase]:
+        """Read the event from the database."""
         if self.metadata.has(key):
             info = self.metadata.read(key)
             if info.key_g is not None:
-                raise NotImplementedError("Ads/Des is not supported.")
+                assert info.key_t is None
+                g = Gas.from_ase(self.db_gas[info.key_g])
+                r = SysGraph.from_ase(self.db_minima[info.key_r])
+                p = SysGraph.from_ase(self.db_minima[info.key_p])
+                if r.natoms < p.natoms:
+                    return info, Adsorption(G=g, R=r, P=p)
+                else:
+                    return info, Desorption(G=g, R=r, P=p)
             else:
                 assert info.key_t is not None
-                ts = Cluster.from_ase(self.db_ts[info.key_t])
-                r = Cluster.from_ase(self.db_minima[info.key_r])
-                p = Cluster.from_ase(self.db_minima[info.key_p])
+                ts = SysGraph.from_ase(self.db_ts[info.key_t])
+                r = SysGraph.from_ase(self.db_minima[info.key_r])
+                p = SysGraph.from_ase(self.db_minima[info.key_p])
                 return info, Reaction(T=ts, R=r, P=p)
         else:
             raise ValueError(f"Event {key} is not in the database.")
@@ -143,7 +167,7 @@ class RxNet:
                     fname.write_bytes(pickle.dumps(event))
                     fname.with_suffix(".err").write_text(msg)
                     raise ValueError(msg)
-            is_new = self._write(
+            is_new = self.write_event(
                 event,
                 for_cluster,
                 for_system,
@@ -154,7 +178,7 @@ class RxNet:
         else:
             raise ValueError(f"Unknown event type: {type(event)}")
 
-    def _write(
+    def write_event(
         self,
         event: EventBase,
         for_cluster: str,
@@ -170,12 +194,12 @@ class RxNet:
         else:
             self.metadata.write(event, for_cluster, for_system)
             try:
-                self.__write(event.R, "minima")
-                self.__write(event.P, "minima")
+                self.write_sysgraph(event.R, "minima")
+                self.write_sysgraph(event.P, "minima")
                 if event.G is not None:
-                    self.__write(event.G, "gas")
+                    self.write_sysgraph(event.G, "gas")
                 if event.T is not None:
-                    self.__write(event.T, "ts")
+                    self.write_sysgraph(event.T, "ts")
                 if persist:
                     self.persistence()
                 return True
@@ -201,17 +225,21 @@ class RxNet:
                 self.persistence()
                 raise e
 
-    def __write(
+    def write_sysgraph(
         self,
         sysgraph: SysGraph,
-        type: Literal["minima", "ts", "gas"] | str,
+        type: Literal["minima", "ts", "gas", "cluster", "system"] | str,
     ) -> bool:
         """Return True if the value is new, False otherwise."""
-        if type == "minima":
+        if type.lower() == "minima":
             return self.db_minima.add(sysgraph, check_positions=True)
-        elif type == "ts":
+        elif type.lower() == "ts":
             return self.db_ts.add(sysgraph, check_positions=True)
-        elif type == "gas":
+        elif type.lower() == "gas":
             return self.db_gas.add(sysgraph, check_positions=False)
+        elif type.lower() == "system":
+            return self.db_system.add(sysgraph, check_positions=True)
+        elif type.lower() == "cluster":
+            return self.db_cluster.add(sysgraph, check_positions=True)
         else:
             raise ValueError(f"Unknown type: {type}")

{graphatoms-2.1.0 → graphatoms-2.1.1}/src/graphatoms/enterpoint/network/_metadata.py

@@ -14,6 +14,7 @@ from pydantic import (
 from graphatoms.dataclasses import OurBaseModel
 from graphatoms.enterpoint.config import EventConfig
 from graphatoms.reaction import EventBase, EventInfo
+from graphatoms.system.bonds import matchmode2nmatch
 
 __all__ = ["MetaData"]
 
@@ -181,7 +182,8 @@ class MetaData(BaseModel):
         names = ["rxn_key", "is_forward", "nmatched", "rate"]
         for (rxn_key, is_forward), single_match_res in matching_dct.items():
             i: int = self.table.key_rxn.index(rxn_key)
-            nmatched = int(single_match_res.shape[0])
+            # Eliminate the overestimation caused by permutation symmetry.
+            nmatched = matchmode2nmatch(single_match_res)
             if is_forward:
                 rate = self.table.rate_forword[i]
             else:

{graphatoms-2.1.0 → graphatoms-2.1.1}/src/graphatoms/enterpoint/network/_recorder.py

@@ -23,14 +23,15 @@ Ref:
 """
 
 from collections import defaultdict
-from typing import override
+from datetime import datetime
+from typing import Annotated, override
 
 import pydantic
 
 from graphatoms.dataclasses import OurBaseModel  # type: ignore
 
 
-class _OldNewRecorder(OurBaseModel):
+class _RecorderBase(pydantic.BaseModel):
     old: pydantic.NonNegativeInt = 0
     new: pydantic.NonNegativeInt = 0
     fail: pydantic.NonNegativeInt = 0
@@ -47,6 +48,70 @@ class _OldNewRecorder(OurBaseModel):
         """
         return sum([self.old, self.new, self.fail])
 
+class RecorderInfo(_RecorderBase):
+    create_at: datetime = pydantic.Field(default_factory=lambda: datetime.now())
+    confidence: Annotated[float, pydantic.Field(ge=0.5, lt=1.0)]
+    for_cluster: str = pydantic.Field(default="")
+    for_system: str = pydantic.Field(default="")
+    for_gas: str = pydantic.Field(default="")
+
+    @classmethod
+    def get_csv_title(cls) -> str:
+        return ",".join(
+            [
+                "old",
+                "new",
+                "fail",
+                "total",
+                "skip",
+                "continuous_old",
+                "continuous_nonnew",
+                "confidence",
+                "create_at",
+                "for_cluster",
+                "for_system",
+                "for_gas",
+            ]
+        )
+
+    def to_csv_line(self) -> str:
+        return ",".join(
+            [
+                f"{self.old}",
+                f"{self.new}",
+                f"{self.fail}",
+                f"{self.total}",
+                f"{self.skip}",
+                f"{self.continuous_old}",
+                f"{self.continuous_nonnew}",
+                f"{self.confidence}",
+                f"{self.create_at.strftime('%Y-%m-%d %H:%M:%S.%f')}",
+                f"{self.for_cluster}",
+                f"{self.for_system}",
+                f"{self.for_gas}",
+            ]
+        )
+
+
+class _OldNewRecorder(OurBaseModel, _RecorderBase):
+    @pydantic.validate_call
+    def get_williams_confidence(
+        self, min_found: pydantic.NonNegativeInt
+    ) -> Annotated[float, pydantic.Field(ge=0.5, lt=1.0)]:
+        """The Williams confidence formula.
+
+        Args:
+            min_found: The minimum time found for all events.
+
+        Returns:
+            The confidence value.
+        """
+        m = self.continuous_nonnew
+        factor = min_found / self.total
+        factor2 = 1 / (1 + factor)
+        value = 1 / (1 + factor2**m)
+        return value
+
     @pydantic.validate_call
     def exploration_can_be_finished(
         self,
@@ -61,10 +126,7 @@ class _OldNewRecorder(OurBaseModel):
                 "min_found must be provided for Williams"
                 + " formula (i.e. confidence < 1)."
             )
-            m = self.continuous_nonnew
-            factor = min_found / self.total
-            factor2 = 1 / (1 + factor)
-            value = 1 / (1 + factor2**m)
+            value = self.get_williams_confidence(min_found)
         else:
             # Use Xu-Henkelman formula
             value = self.continuous_old
@@ -119,8 +181,10 @@ class Recorder(OurBaseModel):
 
 
 if __name__ == "__main__":
+    from io import StringIO
     from pathlib import Path
 
+    import pandas as pd
     obj = Recorder()
     obj.system.add("fdsafs")
     obj.cluster["fdsafs"].new += 1
@@ -128,3 +192,17 @@ if __name__ == "__main__":
     print(obj)
     print(repr(obj))
     obj.write_json(Path("a.json"))
+
+    io = StringIO()
+    io.write(RecorderInfo.get_csv_title() + "\n")
+    a = RecorderInfo(confidence=0.6)
+    io.write(RecorderInfo(confidence=0.5).to_csv_line() + "\n")
+    io.write(RecorderInfo(confidence=0.5).to_csv_line() + "\n")
+    io.write(a.to_csv_line() + "\n")
+
+    s = io.getvalue()
+    print(s)
+    df = pd.read_csv(StringIO(s))
+    print("df:")
+    print(df)
+    print(df.sort_values(by="create_at", ascending=True))

graphatoms-2.1.1/src/graphatoms/enterpoint/runner/__init__.py

@@ -0,0 +1,32 @@
+import os
+
+os.environ["HYDRA_FULL_ERROR"] = "1"
+
+import hydra
+
+from graphatoms.enterpoint.config import CONFIG_DIR, Config
+
+from .general.otfkmc import OTFKMC as OnTheFlyKMC
+from .general.rxngen import ReactionNetworkGenerator
+from .ray.otfkmc import RayOTFKMC as RayOnTheFlyKMC
+from .ray.rxngen import RayReactionNetworkGenerator
+
+
+@hydra.main(
+    config_path=CONFIG_DIR.as_posix(),
+    config_name="run",
+    version_base=None,
+)
+def run(cfg: Config) -> None:
+    if str(cfg.run_type).lower() == "otfkmc":
+        if str(cfg.parallel).lower() == "ray":
+            RayOnTheFlyKMC(config=cfg).run()
+        else:
+            OnTheFlyKMC(config=cfg).run()
+    elif str(cfg.run_type).lower() == "rxngen":
+        if str(cfg.parallel).lower() == "ray":
+            RayReactionNetworkGenerator(config=cfg).run()
+        else:
+            ReactionNetworkGenerator(config=cfg).run()
+    else:
+        raise ValueError(f" run_type `{cfg.run_type}` is not supported.")

graphatoms-2.1.1/src/graphatoms/enterpoint/runner/common/__init__.py

@@ -0,0 +1,21 @@
+from ._base import RunnerABC
+from ._errors import CheckVibrationFailed, HelperException, OptimizationFailed
+from ._helper import (
+    helper_adsorption,
+    helper_apply,
+    helper_dimer,
+    helper_match,
+    helper_optimization,
+)
+
+__all__ = [
+    "RunnerABC",
+    "CheckVibrationFailed",
+    "HelperException",
+    "OptimizationFailed",
+    "helper_adsorption",
+    "helper_apply",
+    "helper_dimer",
+    "helper_match",
+    "helper_optimization",
+]

graphatoms-2.1.1/src/graphatoms/enterpoint/runner/common/_base.py

@@ -0,0 +1,262 @@
+import os
+import sys
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any
+
+os.environ["LOGURU_FORMAT"] = LOGURU_FORMAT = (
+    "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green>"
+    + " | <level>{level: ^8}</level> | "
+    + "<level>{message}</level>"
+)
+
+import hydra
+import numpy as np
+from ase import Atoms
+from loguru._logger import Core, Logger
+from omegaconf import DictConfig, OmegaConf
+
+from graphatoms.enterpoint.config import Config
+from graphatoms.enterpoint.network import ReactionNetwork
+from graphatoms.enterpoint.parallel import get_executor
+from graphatoms.system import (  # type: ignore  # type: ignore
+    Gas,
+    System,
+)
+from graphatoms.utils.parser import hydra_parse
+
+from ._helper import helper_optimization
+
+
+class RunnerABC:
+    """The base class for all classes.
+
+    It provides:
+        1. basic configuration (omegaconf.DictConfig)
+        2. output directory (pathlib.Path)
+    """
+
+    __LOGURU_FORMAT_LENGTH: int = 37
+    __LOGURU_TOTAL_LENGTH: int = 120
+
+    @classmethod
+    def _reformat_message(cls, msg: str) -> str:
+        return msg
+        len_msg = cls.__LOGURU_TOTAL_LENGTH - cls.__LOGURU_FORMAT_LENGTH
+        lst = wrap_line(msg, width_min=len_msg, width_max=len_msg + 20)
+        return ("\n" + " " * cls.__LOGURU_FORMAT_LENGTH).join(lst)
+
+    def __init__(self, *, config: Config) -> None:
+        assert isinstance(config, DictConfig | Config)
+        self.config: Config = config
+        self.path = Path(config.outputs)
+        self.path.mkdir(parents=True, exist_ok=True)
+
+        # Logger Configuration
+        loglevel = str(config.loglevel).upper()
+        try:
+            hydracfg = hydra.core.hydra_config.HydraConfig.get()  # type: ignore
+            outlogfile = str(hydracfg.job_logging.handlers.file.filename)
+        except Exception:
+            outlogfile = hydracfg = None
+        outlogfile = config.logfile
+        assert outlogfile is not None
+        outlogfile = str(outlogfile)
+
+        # Logger Setting
+        self.logger = log = Logger(
+            core=Core(),
+            exception=None,
+            depth=0,
+            record=False,
+            lazy=False,
+            colors=False,
+            raw=False,
+            capture=True,
+            patchers=[],
+            extra={},
+        )
+        log.add(sys.stderr, level=loglevel, format=LOGURU_FORMAT)
+        logname = Path(outlogfile).name
+        if logname != "-":
+            logfile = self.path.joinpath(logname)
+            log.add(logfile, level=loglevel, format=LOGURU_FORMAT)
+
+        # logging directory configuration
+        if hydracfg is not None:
+            output_dir = hydracfg.runtime.output_dir
+        else:
+            output_dir = config.outputs
+        output_dir = Path(output_dir).absolute()
+        self._log_length = int(  # the maximum length of the line in loguru
+            self.__LOGURU_TOTAL_LENGTH  # 80
+            - self.__LOGURU_FORMAT_LENGTH
+        )
+        log.info("=" * self._log_length)
+        log.info("The Configuration:\n" + OmegaConf.to_yaml(config))
+        log.info(f"Working floder   : {os.getcwd()}")
+        log.info(f"self.path floder : {self.path}")
+        log.info(f"Output floder    : {output_dir}")
+        log.info(f"Output logfile   : {outlogfile}")
+        log.info(f"Output loglevel  : {loglevel.upper()}")
+        log.info("=" * self._log_length)
+
+        # restart/initialize configuration
+        self.network: ReactionNetwork = ReactionNetwork(
+            path=self.path / "event",
+            config=config.event,
+            format=config.event.db_format,
+            restart=config.restart,
+        )
+
+        # check parallel mode
+        parallel = str(config.parallel).lower()
+        if hydracfg is not None and hydracfg.mode == "MULTIRUN":
+            if parallel != "serial":
+                msg = (
+                    "Please delete '--multirun,-m' option "
+                    "when running this script. The multirun "
+                    "mode is not supported because this program "
+                    f"will be parallelized by '{parallel}' innerly."
+                )
+                self.logger.error(self._reformat_message(msg))
+                raise ValueError(msg)
+        if parallel not in [
+            "serial",
+            "multiprocessing",
+            "ray",
+            "dask",
+            "executorlib",
+        ]:
+            msg = (
+                f"Invalid parallel mode: {parallel}. Please choose one from "
+                "'serial', 'multiprocessing', 'ray', 'dask', 'executorlib'."
+            )
+            self.logger.error(self._reformat_message(msg))
+            raise ValueError(msg)
+        pworkers = int(self.config.parallel_workers)
+        pworkers: int | None = None if pworkers <= 0 else pworkers
+        self.executor = get_executor(parallel, pworkers)
+
+        self.__gas_lst: list[Gas] = []
+        for gas_info in self.network.metadata.basic.gas_info_lst:
+            gas, _, cost_time = helper_optimization(
+                config=self.config,
+                graph=Gas.from_name(
+                    gas_info.name,
+                    sticking=gas_info.sticking,
+                    pressure=gas_info.pressure,
+                    parse_bonds=self.config.bonds,  # type: ignore
+                ),
+                raise_when_fail=True,
+                allow_hash_change=False,
+                allow_not_connected=False,
+                run_vibration=True,
+                deep_copy=True,
+            )
+            if isinstance(gas, Gas):
+                self.logger.info(
+                    self._reformat_message(
+                        f"Optimized gas({gas_info.name}) "
+                        f"in {cost_time:.2f} seconds."
+                    )
+                )
+                self.__gas_lst.append(gas)
+                self.network.db_gas.add(gas)
+            else:
+                msg = f"Failed to optimize gas({gas_info.name})."
+                self.logger.error(self._reformat_message(msg))
+                raise ValueError(msg)
+        # persist the network for restart. [gas list]
+        self.network.persistence()
+
+    @property
+    def gas_lst(self) -> list[Gas]:
+        if len(self.network.metadata.basic.gas_info_lst) != 0:
+            return self.__gas_lst
+        else:
+            return []
+
+    @abstractmethod
+    def run(self, *args, **kwargs) -> Any:
+        """Run the class."""
+
+    def get_system_for(self, inp: Atoms | None) -> System:
+        if inp is None:
+            # parse system for first step
+            try:
+                result: System = hydra_parse(self.config.system, System)
+            except Exception:
+                atoms = hydra_parse(self.config.system, Atoms)
+                result: System = System.from_ase(
+                    atoms=atoms,
+                    parse_bonds=self.config.bonds,  # type: ignore
+                    parse_atoms_is_outer_or_not=True,
+                )
+            if self.config.system.get("attach_is_adsorbate", True):
+                result = result.model_copy(
+                    update=dict(
+                        is_adsorbate=np.zeros_like(
+                            result.is_outer,
+                            dtype=bool,
+                        )
+                    ),
+                    deep=False,
+                )
+        elif isinstance(inp, Atoms):
+            result: System = System.from_ase(
+                atoms=inp,
+                parse_bonds=self.config.bonds,  # type: ignore
+                parse_atoms_is_outer_or_not=True,
+            )
+        else:
+            msg = f"Unknown type of input: {type(inp)}"
+            self.logger.error(self._reformat_message(msg))
+            raise ValueError(msg)
+
+        assert isinstance(result, System)
+        assert result.pair is not None
+        assert result.is_outer is not None
+        self.logger.info(self._reformat_message(f"Read the system: {result}"))
+        return result
+
+
+def wrap_line(
+    text: str,
+    width_min: int = 80,
+    width_max: int = 100,
+) -> list[str]:
+    """Make a line of text fit in a given width.
+
+    Args:
+        text: The text to wrap.
+        width_min: The minimum width of the line.
+        width_max: The maximum width of the line.
+
+    Returns:
+        The wrapped lines.
+    """
+    words = text.split()
+    if not words:
+        return [""]
+
+    lines = []
+    cur = ""
+    for w in words:
+        if not cur:
+            cur = w
+        elif len(cur) + 1 + len(w) <= width_max:
+            cur += " " + w
+        else:
+            lines.append(cur)
+            cur = w
+    if cur:
+        lines.append(cur)
+
+    if len(lines) >= 2 and len(lines[-1]) < width_min:
+        merged = lines[-2] + " " + lines[-1]
+        if len(merged) <= width_max:
+            lines[-2] = merged
+            lines.pop()
+
+    return lines