GraphAtoms 2.1.1__tar.gz → 2.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphatoms
-Version: 2.1.1
+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.1 → graphatoms-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.1.1"
+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.1 → 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.1"
+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.1 → 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.1 → 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
 
 
@@ -70,6 +69,13 @@ class Config:
     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"]

{graphatoms-2.1.1 → 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.1 → graphatoms-2.2.0}/src/graphatoms/enterpoint/network/__init__.py

@@ -1,7 +1,7 @@
 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 (
@@ -16,7 +16,7 @@ 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__ = [
@@ -38,6 +38,7 @@ class ReactionNetwork:
         **kwargs,
     ) -> None:
         self.__path = path = Path(path)
+        self.__path_exploration_recorder = path / "exploration.csv"
         if config is not None:
             metadata_basic = MetaDataBasic(
                 **(
@@ -62,6 +63,10 @@ class ReactionNetwork:
                 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)
@@ -79,12 +84,17 @@ class ReactionNetwork:
                 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
         (
@@ -99,8 +109,15 @@ class ReactionNetwork:
                 format=format,
                 prefix=prefix,
                 append=restart,
+                use_positions_uuid=use_positions_uuid,
             )
-            for prefix in ["ts", "gas", "minima", "cluster", "system"]
+            for prefix, use_positions_uuid in [
+                ("ts", True),
+                ("gas", False),
+                ("minima", True),
+                ("cluster", False),
+                ("system", False),
+            ]
         ]
         assert isinstance(self.db_ts, DatabaseABC)
         assert isinstance(self.db_gas, DatabaseABC)
@@ -108,9 +125,33 @@ class ReactionNetwork:
         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."""
@@ -143,20 +184,36 @@ class ReactionNetwork:
     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)
@@ -167,17 +224,32 @@ class ReactionNetwork:
                     fname.write_bytes(pickle.dumps(event))
                     fname.with_suffix(".err").write_text(msg)
                     raise ValueError(msg)
-            is_new = self.write_event(
+            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)}")
 
+        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,
@@ -188,6 +260,19 @@ class ReactionNetwork:
         **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
@@ -238,8 +323,8 @@ class ReactionNetwork:
         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)
+            return self.db_system.add(sysgraph, check_positions=False)
         elif type.lower() == "cluster":
-            return self.db_cluster.add(sysgraph, check_positions=True)
+            return self.db_cluster.add(sysgraph, check_positions=False)
         else:
             raise ValueError(f"Unknown type: {type}")

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

@@ -7,7 +7,6 @@ import pandas as pd
 from pydantic import (
     BaseModel,
     NonNegativeFloat,
-    computed_field,
     model_validator,
 )
 
@@ -19,36 +18,14 @@ 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] = []
@@ -111,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:
@@ -121,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]
@@ -133,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]
@@ -164,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.
 
@@ -186,6 +166,9 @@ class MetaData(BaseModel):
             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))

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

@@ -24,11 +24,11 @@ Ref:
 
 from collections import defaultdict
 from datetime import datetime
-from typing import Annotated, override
+from typing import Annotated, Self, override
 
 import pydantic
 
-from graphatoms.dataclasses import OurBaseModel  # type: ignore
+from graphatoms.dataclasses import OurBaseModel
 
 
 class _RecorderBase(pydantic.BaseModel):
@@ -48,50 +48,6 @@ class _RecorderBase(pydantic.BaseModel):
         """
         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
@@ -165,6 +121,49 @@ class _OldNewRecorder(OurBaseModel, _RecorderBase):
         self.fail += 1
 
 
+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 from_oldnew(
+        cls,
+        oldnew: _OldNewRecorder,
+        min_found: pydantic.NonNegativeInt,
+        *,
+        for_cluster: str = "",
+        for_system: str = "",
+        for_gas: str = "",
+    ) -> Self:
+        return cls(
+            old=oldnew.old,
+            new=oldnew.new,
+            fail=oldnew.fail,
+            skip=oldnew.skip,
+            continuous_old=oldnew.continuous_old,
+            continuous_nonnew=oldnew.continuous_nonnew,
+            confidence=oldnew.get_williams_confidence(min_found),
+            for_cluster=for_cluster,
+            for_system=for_system,
+            for_gas=for_gas,
+        )
+
+    @classmethod
+    def get_csv_title(cls) -> str:
+        msg = "old,new,fail,total,skip,continuous_old,continuous_nonnew"
+        return f"{msg},confidence,for_cluster,for_system,for_gas,create_at"
+
+    def to_csv_line(self) -> str:
+        msg = f"{self.old},{self.new},{self.fail},{self.total},"
+        msg += f"{self.skip},{self.continuous_old},{self.continuous_nonnew},"
+        msg += f"{self.confidence},{self.for_cluster},{self.for_system}"
+        create_at = self.create_at.strftime("%Y-%m-%d %H:%M:%S.%f")
+        return f"{msg},{self.for_gas},{create_at}"
+
+
 class Recorder(OurBaseModel):
     system: set[str] = set()
     cluster: dict[str, _OldNewRecorder] = defaultdict(_OldNewRecorder)

{graphatoms-2.1.1 → graphatoms-2.2.0}/src/graphatoms/enterpoint/runner/__init__.py

@@ -19,11 +19,15 @@ from .ray.rxngen import RayReactionNetworkGenerator
 )
 def run(cfg: Config) -> None:
     if str(cfg.run_type).lower() == "otfkmc":
+        OnTheFlyKMC(config=cfg).run()
+        return
         if str(cfg.parallel).lower() == "ray":
             RayOnTheFlyKMC(config=cfg).run()
         else:
             OnTheFlyKMC(config=cfg).run()
     elif str(cfg.run_type).lower() == "rxngen":
+        ReactionNetworkGenerator(config=cfg).run()
+        return
         if str(cfg.parallel).lower() == "ray":
             RayReactionNetworkGenerator(config=cfg).run()
         else: