GraphAtoms 2.1.0__tar.gz → 2.2.0__tar.gz

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

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

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.1.0"
+version = "2.2.0"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 license-files = ["src/LICENSE"]
@@ -72,6 +72,7 @@ dev = [
     "jupyterlab",
     "chemiscope",
     "nglview",
+    "grpcio",
     "ray",
 ]
 

{graphatoms-2.1.0 → graphatoms-2.2.0}/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.2.0"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]
@@ -76,6 +76,7 @@ dev = [
     "chemiscope",
     # "playwright>=1.52", # chemiscope [headless]
     "nglview",
+    "grpcio",
     "ray",
 ]
 

{graphatoms-2.1.0 → graphatoms-2.2.0}/src/graphatoms/arrayapi/typing.py

@@ -4243,8 +4243,8 @@ class abs[TArray: Array](Protocol):
     .. note::
        For complex floating-point operands, conforming implementations should take care to avoid undue overflow or underflow during intermediate stages of computation.
 
-    ..
-       TODO: once ``hypot`` is added to the specification, remove the special cases for complex floating-point operands and the note concerning guarding against undue overflow/underflow, and state that special cases must be handled as if implemented as ``hypot(real(x), imag(x))``.
+    .. note::
+       Once ``hypot`` is added to the specification, remove the special cases for complex floating-point operands and the note concerning guarding against undue overflow/underflow, and state that special cases must be handled as if implemented as ``hypot(real(x), imag(x))``.
 
     Parameters
     ----------
@@ -9679,7 +9679,7 @@ class ArrayNamespace[TArray: Array, TDtype, TDevice](Protocol):
     sort: sort[TArray,]
     "Returns a sorted copy of an input array ``x``.\n\n.. note::\n   For backward compatibility, conforming implementations may support complex numbers; however, inequality comparison of complex numbers is unspecified and thus implementation-dependent (see :ref:`complex-number-ordering`).\n\nParameters\n----------\nx: array\n    input array. Should have a real-valued data type.\naxis: int\n    axis along which to sort. If set to ``-1``, the function must sort along the last axis. Default: ``-1``.\ndescending: bool\n    sort order. If ``True``, the array must be sorted in descending order (by value). If ``False``, the array must be sorted in ascending order (by value). Default: ``False``.\nstable: bool\n    sort stability. If ``True``, the returned array must maintain the relative order of ``x`` values which compare as equal. If ``False``, the returned array may or may not maintain the relative order of ``x`` values which compare as equal (i.e., the relative order of ``x`` values which compare as equal is implementation-dependent). Default: ``True``.\n\nReturns\n-------\nout : array\n    a sorted array. The returned array must have the same data type and shape as ``x``."
     abs: abs[TArray,]
-    "Calculates the absolute value for each element ``x_i`` of the input array ``x``.\n\nFor real-valued input arrays, the element-wise result has the same magnitude as the respective element in ``x`` but has positive sign.\n\n.. note::\n   For signed integer data types, the absolute value of the minimum representable integer is implementation-dependent.\n\n.. note::\n   For complex floating-point operands, the complex absolute value is known as the norm, modulus, or magnitude and, for a complex number :math:`z = a + bj` is computed as\n\n   .. math::\n      \\operatorname{abs}(z) = \\sqrt{a^2 + b^2}\n\n.. note::\n   For complex floating-point operands, conforming implementations should take care to avoid undue overflow or underflow during intermediate stages of computation.\n\n..\n   TODO: once ``hypot`` is added to the specification, remove the special cases for complex floating-point operands and the note concerning guarding against undue overflow/underflow, and state that special cases must be handled as if implemented as ``hypot(real(x), imag(x))``.\n\nParameters\n----------\nx: array\n    input array. Should have a numeric data type.\n\nReturns\n-------\nout: array\n    an array containing the absolute value of each element in ``x``. If ``x`` has a real-valued data type, the returned array must have the same data type as ``x``. If ``x`` has a complex floating-point data type, the returned array must have a real-valued floating-point data type whose precision matches the precision of ``x`` (e.g., if ``x`` is ``complex128``, then the returned array must have a ``float64`` data type).\n\nNotes\n-----\n\n**Special Cases**\n\nFor real-valued floating-point operands,\n\n- If ``x_i`` is ``NaN``, the result is ``NaN``.\n- If ``x_i`` is ``-0``, the result is ``+0``.\n- If ``x_i`` is ``-infinity``, the result is ``+infinity``.\n\nFor complex floating-point operands, let ``a = real(x_i)``, ``b = imag(x_i)``, and\n\n- If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is any value (including ``NaN``), the result is ``+infinity``.\n- If ``a`` is any value (including ``NaN``) and ``b`` is either ``+infinity`` or ``-infinity``, the result is ``+infinity``.\n- If ``a`` is either ``+0`` or ``-0``, the result is equal to ``abs(b)``.\n- If ``b`` is either ``+0`` or ``-0``, the result is equal to ``abs(a)``.\n- If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN``.\n- If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN``.\n- If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN``.\n\n.. versionchanged:: 2022.12\n   Added complex data type support."
+    "Calculates the absolute value for each element ``x_i`` of the input array ``x``.\n\nFor real-valued input arrays, the element-wise result has the same magnitude as the respective element in ``x`` but has positive sign.\n\n.. note::\n   For signed integer data types, the absolute value of the minimum representable integer is implementation-dependent.\n\n.. note::\n   For complex floating-point operands, the complex absolute value is known as the norm, modulus, or magnitude and, for a complex number :math:`z = a + bj` is computed as\n\n   .. math::\n      \\operatorname{abs}(z) = \\sqrt{a^2 + b^2}\n\n.. note::\n   For complex floating-point operands, conforming implementations should take care to avoid undue overflow or underflow during intermediate stages of computation.\n\n..\n   once ``hypot`` is added to the specification, remove the special cases for complex floating-point operands and the note concerning guarding against undue overflow/underflow, and state that special cases must be handled as if implemented as ``hypot(real(x), imag(x))``.\n\nParameters\n----------\nx: array\n    input array. Should have a numeric data type.\n\nReturns\n-------\nout: array\n    an array containing the absolute value of each element in ``x``. If ``x`` has a real-valued data type, the returned array must have the same data type as ``x``. If ``x`` has a complex floating-point data type, the returned array must have a real-valued floating-point data type whose precision matches the precision of ``x`` (e.g., if ``x`` is ``complex128``, then the returned array must have a ``float64`` data type).\n\nNotes\n-----\n\n**Special Cases**\n\nFor real-valued floating-point operands,\n\n- If ``x_i`` is ``NaN``, the result is ``NaN``.\n- If ``x_i`` is ``-0``, the result is ``+0``.\n- If ``x_i`` is ``-infinity``, the result is ``+infinity``.\n\nFor complex floating-point operands, let ``a = real(x_i)``, ``b = imag(x_i)``, and\n\n- If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is any value (including ``NaN``), the result is ``+infinity``.\n- If ``a`` is any value (including ``NaN``) and ``b`` is either ``+infinity`` or ``-infinity``, the result is ``+infinity``.\n- If ``a`` is either ``+0`` or ``-0``, the result is equal to ``abs(b)``.\n- If ``b`` is either ``+0`` or ``-0``, the result is equal to ``abs(a)``.\n- If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN``.\n- If ``a`` is a finite number and ``b`` is ``NaN``, the result is ``NaN``.\n- If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN``.\n\n.. versionchanged:: 2022.12\n   Added complex data type support."
     acos: acos[TArray,]
     "Calculates an implementation-dependent approximation of the principal value of the inverse cosine for each element ``x_i`` of the input array ``x``.\n\nEach element-wise result is expressed in radians.\n\n.. note::\n   The principal value of the arc cosine of a complex number :math:`z` is\n\n   .. math::\n      \\operatorname{acos}(z) = \\frac{1}{2}\\pi + j\\ \\ln(zj + \\sqrt{1-z^2})\n\n   For any :math:`z`,\n\n   .. math::\n      \\operatorname{acos}(z) = \\pi - \\operatorname{acos}(-z)\n\n.. note::\n   For complex floating-point operands, ``acos(conj(x))`` must equal ``conj(acos(x))``.\n\n.. note::\n   The inverse cosine (or arc cosine) is a multi-valued function and requires a branch cut on the complex plane. By convention, a branch cut is placed at the line segments :math:`(-\\infty, -1)` and :math:`(1, \\infty)` of the real axis.\n\n   Accordingly, for complex arguments, the function returns the inverse cosine in the range of a strip unbounded along the imaginary axis and in the interval :math:`[0, \\pi]` along the real axis.\n\n   *Note: branch cuts follow C99 and have provisional status* (see :ref:`branch-cuts`).\n\nParameters\n----------\nx: array\n    input array. Should have a floating-point data type.\n\nReturns\n-------\nout: array\n    an array containing the inverse cosine of each element in ``x``. The returned array must have a floating-point data type determined by :ref:`type-promotion`.\n\nNotes\n-----\n\n**Special cases**\n\nFor real-valued floating-point operands,\n\n- If ``x_i`` is ``NaN``, the result is ``NaN``.\n- If ``x_i`` is greater than ``1``, the result is ``NaN``.\n- If ``x_i`` is less than ``-1``, the result is ``NaN``.\n- If ``x_i`` is ``1``, the result is ``+0``.\n\nFor complex floating-point operands, let ``a = real(x_i)``, ``b = imag(x_i)``, and\n\n- If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``+0``, the result is ``π/2 - 0j``.\n- If ``a`` is either ``+0`` or ``-0`` and ``b`` is ``NaN``, the result is ``π/2 + NaN j``.\n- If ``a`` is a finite number and ``b`` is ``+infinity``, the result is ``π/2 - infinity j``.\n- If ``a`` is a nonzero finite number and ``b`` is ``NaN``, the result is ``NaN + NaN j``.\n- If ``a`` is ``-infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``π - infinity j``.\n- If ``a`` is ``+infinity`` and ``b`` is a positive (i.e., greater than ``0``) finite number, the result is ``+0 - infinity j``.\n- If ``a`` is ``-infinity`` and ``b`` is ``+infinity``, the result is ``3π/4 - infinity j``.\n- If ``a`` is ``+infinity`` and ``b`` is ``+infinity``, the result is ``π/4 - infinity j``.\n- If ``a`` is either ``+infinity`` or ``-infinity`` and ``b`` is ``NaN``, the result is ``NaN ± infinity j`` (sign of the imaginary component is unspecified).\n- If ``a`` is ``NaN`` and ``b`` is a finite number, the result is ``NaN + NaN j``.\n- If ``a`` is ``NaN`` and ``b`` is ``+infinity``, the result is ``NaN - infinity j``.\n- If ``a`` is ``NaN`` and ``b`` is ``NaN``, the result is ``NaN + NaN j``.\n\n.. versionchanged:: 2022.12\n   Added complex data type support."
     acosh: acosh[TArray,]

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

@@ -1,4 +1,5 @@
 import os
+from collections import defaultdict
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
@@ -29,6 +30,7 @@ class ExplConfig:
     maxtry: int = 1000
     maxconfidence: float = 10
     max_ncore_for_surface: int = 3  # 4, 5, 6
+    optimization_for_system: bool = True
     surface_only_explore_single_core: bool = True
     allow_multiple_adsorption: bool = False
     allow_explore_bulk: bool = False
@@ -45,9 +47,6 @@ class EventConfig:
     min_frequency_for_ts: float = 20.0  # cm^-1
     simplified_threshold: float = 7.0  # the simplified threshold for event
     gas_sticking: dict[str, float] = field(default_factory=dict)
-    gas_pressure: dict[str, float] = field(default_factory=dict)
-    default_pressure: float = 101325
-    default_sticking: float = 1.0
     temperature: float = 300
 
 
@@ -66,10 +65,17 @@ 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
+    gas_pressure_cache_box_length: float = 1e4  # in Angstrom
+    initial_gas_pressure: dict[str, float] = field(default_factory=dict)
+    # the initial gas pressure only effect for `OTFKMC`, and the key of
+    # `initial_gas_pressure` must be the same as the key of `gas_sticking`
+    # 2. if the key of `initial_gas_pressure` is not in `gas_sticking`, then the initial gas pressure is 0.0    # noqa: E501
+    # 1. if the key of `gas_sticking` is not in `initial_gas_pressure`, then the gas sticking is 1.0            # noqa: E501
+
     parallel_workers: int = 0  # 0 means use all cores
     parallel: str = "serial"  # serial, multiprocessing, ray, dask, executorlib
     loglevel: str = "info"  # Literal["debug", "info", "warning", "error"]
@@ -98,8 +104,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 +111,3 @@ hydra:
     dir: ${outputs}
   verbose: ${debug}
 """)
-    rmtree(Path(cfg.outputs))

{graphatoms-2.1.0 → graphatoms-2.2.0}/src/graphatoms/enterpoint/config/example.yaml

@@ -64,7 +64,6 @@ event:
   gas_sticking:
     CO: 0.5
     CO2: 0.5
-  gas_pressure: {}
   temperature: 300.0
 optimizer:
   method: "lbfgs"

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

@@ -1,27 +1,33 @@
 import dataclasses as dc
 import pickle
 from pathlib import Path
-from typing import Literal
+from typing import Literal, Self
 
 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
 from ._metadata import _MetaDataBasic as MetaDataBasic
-from ._recorder import Recorder
+from ._recorder import Recorder, RecorderInfo
 from ._scheduler import Scheduler
 
 __all__ = [
-    "RxNet",
     "MetaData",
     "Recorder",
     "Scheduler",
+    "ReactionNetwork",
 ]
 
 
-class RxNet:
+class ReactionNetwork:
     def __init__(
         self,
         path: Path | str,
@@ -32,6 +38,7 @@ class RxNet:
         **kwargs,
     ) -> None:
         self.__path = path = Path(path)
+        self.__path_exploration_recorder = path / "exploration.csv"
         if config is not None:
             metadata_basic = MetaDataBasic(
                 **(
@@ -56,6 +63,10 @@ class RxNet:
                 f"The path `{self.__path}` does not exist."
                 + " Please create it or use `restart=False`."
             )
+            assert self.__path_exploration_recorder.exists(), (
+                f"The path `{self.__path_exploration_recorder}` does not exist."
+                + " Please create it or use `restart=False`."
+            )
             self.scheduler = Scheduler.read_npz(path / "scheduler.npz")
             self.recorder = Recorder.read_json(path / "recorder.json")
             self.metadata = MetaData.from_storage(path)
@@ -73,28 +84,74 @@ class RxNet:
                 f"The path `{self.__path}` does exist."
                 + " Please delete it or use `restart=True`."
             )
+            self.__path.mkdir(parents=True, exist_ok=True)
+            self.__path_exploration_recorder.write_text(
+                RecorderInfo.get_csv_title() + "\n"
+            )
             self.recorder: Recorder = Recorder()
             self.scheduler: Scheduler = Scheduler()
             if metadata_basic is not None:
                 self.metadata: MetaData = MetaData(basic=metadata_basic)
             else:
                 self.metadata: MetaData = MetaData()
+        self.__format = format
 
         # 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,
+                use_positions_uuid=use_positions_uuid,
             )
-            for prefix in ["ts", "gas", "minima"]
+            for prefix, use_positions_uuid in [
+                ("ts", True),
+                ("gas", False),
+                ("minima", True),
+                ("cluster", False),
+                ("system", False),
+            ]
         ]
-        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)
+
+    @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,
+        )
 
     def summary(self) -> str:
         """Return the summary of the network."""
-        return "fasdasdgase"
+        msg = f"ReactionNetwork: {self.__path} (format={self.__format})\n"
+        msg += f"    #System    :{len(self.db_system)}\n"
+        msg += f"    #Cluster   :{len(self.db_cluster)}\n"
+        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"
+        return msg
 
     def persistence(self) -> None:
         """Persist the data to the database."""
@@ -102,16 +159,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.")
@@ -119,20 +184,36 @@ class RxNet:
     def found(
         self,
         event: EventBase | str,
+        for_gas: str | None,
+        for_cluster: str,
         *,
-        for_cluster: str | None = None,
         for_system: str | None = None,
         persist: bool = True,
         **kwargs,
     ) -> Literal["new", "old", "fail"] | str:
+        if for_system is None:
+            for_system = ""
+        if for_gas is None:
+            for_gas = ""
+            old_new = self.recorder.cluster[for_cluster]
+            min_found = self.metadata.table.get_minconut_for(
+                cluster_key=for_cluster,
+                system_key=for_system,
+                gas_key=None,
+            )
+        else:
+            old_new = self.recorder.adsorption[f"{for_cluster}_{for_gas}"]
+            min_found = self.metadata.table.get_minconut_for(
+                cluster_key=for_cluster,
+                system_key=for_system,
+                gas_key=for_gas,
+            )
+
         if isinstance(event, str):
-            return "fail"
+            old_new.found_fail()
+            result = "fail"
         elif isinstance(event, EventBase):
             simplified_threshold = self.metadata.basic.simplified_threshold
-            if for_system is None:
-                for_system = ""
-            if for_cluster is None:
-                for_cluster = event.R.get_key_for_metadata()
             if simplified_threshold > 0:
                 try:
                     event = event.simplify(simplified_threshold)
@@ -143,18 +224,33 @@ class RxNet:
                     fname.write_bytes(pickle.dumps(event))
                     fname.with_suffix(".err").write_text(msg)
                     raise ValueError(msg)
-            is_new = self._write(
+            if self.write_event(
                 event,
                 for_cluster,
                 for_system,
                 persist=persist,
                 **kwargs,
-            )
-            return f"{'new' if is_new else 'old'} {event}"
+            ):
+                old_new.found_new()
+                result = f"new {event}"
+            else:
+                old_new.found_old()
+                result = f"old {event}"
         else:
             raise ValueError(f"Unknown event type: {type(event)}")
 
-    def _write(
+        info = RecorderInfo.from_oldnew(
+            oldnew=old_new,
+            min_found=min_found,
+            for_cluster=for_cluster,
+            for_system=for_system,
+            for_gas=for_gas,
+        )
+        with self.__path_exploration_recorder.open("a") as f:
+            f.write(info.to_csv_line() + "\n")
+        return result
+
+    def write_event(
         self,
         event: EventBase,
         for_cluster: str,
@@ -164,18 +260,31 @@ class RxNet:
         **kwargs,
     ) -> bool:
         """Write the event to the database."""
+        if isinstance(event, Desorption):
+            event = event.reversed
+        assert isinstance(event, Adsorption | Reaction), (
+            f"Unknown event type: {type(event)}. Only "  #
+            "Adsorption and Reaction are supported, "  #
+            "and the Desorption will be reversed."
+        )
+        if event.G is not None:
+            assert event.R.natoms < event.P.natoms, (
+                f"Event {event._string()} is not Adsorption. "
+                "The R must have fewer atoms than P."
+            )
+
         if self.metadata.has(event):
             self.metadata.rxn_count_add_one(event)
             return False
         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 +310,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=False)
+        elif type.lower() == "cluster":
+            return self.db_cluster.add(sysgraph, check_positions=False)
         else:
             raise ValueError(f"Unknown type: {type}")

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

@@ -7,47 +7,25 @@ import pandas as pd
 from pydantic import (
     BaseModel,
     NonNegativeFloat,
-    computed_field,
     model_validator,
 )
 
 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"]
 
 
-class _GasInfo(BaseModel):
-    name: str
-    sticking: float
-    pressure: float
-
-
 class _MetaDataBasic(OurBaseModel, EventConfig):
     gas_sticking: dict[str, NonNegativeFloat] = {}
-    gas_pressure: dict[str, NonNegativeFloat] = {}
     temperature: float = 300
 
     @override
     def _string(self) -> str:
         return ", ".join([f"{k}={v}" for k, v in self.model_dump().items()])
 
-    @computed_field
-    @property
-    def gas_info_lst(self) -> list[_GasInfo]:
-        result: list[_GasInfo] = []
-        for name, sticking in self.gas_sticking.items():
-            pressure = self.gas_pressure.get(name, self.default_pressure)
-            result.append(
-                _GasInfo(
-                    name=name,
-                    sticking=sticking,
-                    pressure=pressure,
-                )
-            )
-        return result
-
 
 class _MetaDataTable(BaseModel):
     key_rxn: list[str] = []
@@ -110,7 +88,7 @@ class _MetaDataTable(BaseModel):
         *,
         cluster_key: str | None = None,
         system_key: str | None = None,
-        exclude_gas: bool = False,
+        gas_key: str | None = None,
         **kwargs,
     ) -> int:
         if cluster_key is not None:
@@ -120,7 +98,7 @@ class _MetaDataTable(BaseModel):
                     for i, ck in enumerate(self.for_cluster)
                     if (
                         ck == cluster_key
-                        and ((not exclude_gas) or self.key_g[i] is None)
+                        and ((gas_key is None) or self.key_g[i] is gas_key)
                     )
                 ]
                 + [0]
@@ -132,7 +110,7 @@ class _MetaDataTable(BaseModel):
                     for i, sk in enumerate(self.for_system)
                     if (
                         sk == system_key
-                        and ((not exclude_gas) or self.key_g[i] is None)
+                        and ((gas_key is None) or self.key_g[i] is gas_key)
                     )
                 ]
                 + [0]
@@ -163,6 +141,9 @@ class MetaData(BaseModel):
     def bkl_solver(
         self,
         matching_dct: dict[tuple[str, bool], np.ndarray],
+        *args,
+        env_pressure: dict[str, float] = {},
+        **kwargs,
     ) -> tuple[pd.DataFrame, str, bool, float, float]:
         """Solve the BKL equation to select the reaction.
 
@@ -181,9 +162,13 @@ 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]
+                key_g = self.table.key_g[i]
+                if key_g is not None:
+                    rate *= env_pressure.get(key_g, 0.0)
             else:
                 rate = self.table.rate_reversed[i]
             lst.append((rxn_key, is_forward, nmatched, rate))