GraphAtoms 2.0.0__tar.gz → 2.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphatoms
-Version: 2.0.0
+Version: 2.1.0
 Summary: The Chemical Core Class for Graph Theory Analysis.
 Keywords: chemistry,graph theory,reaction,event,KMC
 Author: LiuGaoyong
@@ -29,12 +29,8 @@ Requires-Dist: python-snappy>=0.7.3
 Requires-Dist: tomli ; python_full_version < '3.11'
 Requires-Dist: tomli-w
 Requires-Dist: typing-extensions
-Requires-Dist: plotext
-Requires-Dist: plotext-plus
-Requires-Dist: matplotlib
 Requires-Dist: executorlib
 Requires-Dist: hydra-core
-Requires-Dist: pipefunc
 Requires-Dist: typer
 Requires-Dist: loguru
 Requires-Python: >=3.12
@@ -62,6 +58,14 @@ The `graphatoms` is a Python library designed for chemical graph theory analysis
 - **Dataclasses**: Pydantic-based data models for type-safe data handling
 - **Array API Compatibility**: Full support for array API standard for cross-framework compatibility (NumPy, PyTorch, JAX, CuPy, etc.)
 - **Subgraph Operations**: Backend-agnostic subgraph extraction with relabeling support using array-api-compat and array-api-extra
+- **CLI Entry Points**: Three console scripts for configuration, execution, and inspection:
+  - `graphatoms-config`: Resolve and print the Hydra/OmegaConf run configuration
+  - `graphatoms-run`: Launch a run
+    - `run_type=otfkmc` for on-the-fly kinetic Monte Carlo simulation
+    - `run_type=rxngen` for reaction network generation
+  - `graphatoms-network`: Inspect and visualize a stored reaction network
+- **Hydra-driven Configuration**: Composable, override-friendly config via Hydra/OmegaConf with grouped groups (`atoms`, `bonds`, `calculator`)
+- **Pluggable Parallel Backends**: Switch executors at the config level — `serial`, `multiprocessing`, `ray`, `dask`, `executorlib` — for distributed/on-the-fly KMC workflows
 
 ## Module Structure
 
@@ -69,18 +73,33 @@ The `graphatoms` is a Python library designed for chemical graph theory analysis
 src/graphatoms/
 ├── arrayapi/        # Array API compatibility layer
 ├── dataclasses/     # Pydantic-based data models
+├── enterpoint/      # Entry points: CLI, config, runners, network, parallel
+│   ├── config/      # Hydra/OmegaConf configuration (atoms, bonds, calculator)
+│   ├── network/     # Reaction network: scheduler, recorder, metadata
+│   ├── parallel/    # Pluggable executors (serial, multiprocessing, ray, dask, executorlib)
+│   ├── runner/      # Runners (otfkmc, rxngen) and helpers
+│   ├── steps/       # Step primitives for runners
+│   └── view.py      # CLI viewer for reactions
 ├── geometry/        # Geometric operations
 ├── reaction/        # Reaction classes and KMC events
-│   ├── base/        # Abstract base classes
-│   ├── event/       # KMC events (adsorption, desorption, reaction)
-│   ├── mcmove/      # Monte Carlo moves
-│   ├── mdwarpper/   # MD wrapper
-│   └── network/     # Reaction network
+│   ├── _event.py    # Event base and event info
+│   ├── reaction.py  # Reaction class
+│   └── xxsorption.py # Adsorption/Desorption events
 ├── system/          # Core system classes
-│   ├── atoms/       # Atomic structure handling
-│   ├── database/    # Database storage backends
-│   └── graph/       # Graph-based system representation
+│   ├── atoms.py     # Atomic structure handling
+│   ├── bonds.py     # Bond list operations
+│   ├── graph.py     # Graph-based system representation
+│   ├── system.py    # System abstract base
+│   ├── sysCluster.py # Cluster system
+│   ├── sysGas.py    # Gas molecule system
+│   └── database/    # Database storage backends (HDF5, SQLite, folder)
 └── utils/           # Utility functions
+    ├── adsorption.py # Adsorption site helper
+    ├── asetools.py  # ASE-related tools
+    ├── bytestool.py # Byte-level helpers
+    ├── logger.py    # Logging setup
+    ├── parser.py    # Hydra argument parsing
+    ├── rdutils.py   # RDKit utilities
     └── subgraph.py  # Array API compatible subgraph operations
 ```
 
@@ -103,6 +122,10 @@ src/graphatoms/
 - pydantic >= 2.10
 - python-snappy >= 0.7.3
 - loguru
+- pandas >= 2
+- scipy >= 1.10
+- typer
+- executorlib
 
 ## Installation
 

{graphatoms-2.0.0 → graphatoms-2.1.0}/README.md

@@ -17,6 +17,14 @@ The `graphatoms` is a Python library designed for chemical graph theory analysis
 - **Dataclasses**: Pydantic-based data models for type-safe data handling
 - **Array API Compatibility**: Full support for array API standard for cross-framework compatibility (NumPy, PyTorch, JAX, CuPy, etc.)
 - **Subgraph Operations**: Backend-agnostic subgraph extraction with relabeling support using array-api-compat and array-api-extra
+- **CLI Entry Points**: Three console scripts for configuration, execution, and inspection:
+  - `graphatoms-config`: Resolve and print the Hydra/OmegaConf run configuration
+  - `graphatoms-run`: Launch a run
+    - `run_type=otfkmc` for on-the-fly kinetic Monte Carlo simulation
+    - `run_type=rxngen` for reaction network generation
+  - `graphatoms-network`: Inspect and visualize a stored reaction network
+- **Hydra-driven Configuration**: Composable, override-friendly config via Hydra/OmegaConf with grouped groups (`atoms`, `bonds`, `calculator`)
+- **Pluggable Parallel Backends**: Switch executors at the config level — `serial`, `multiprocessing`, `ray`, `dask`, `executorlib` — for distributed/on-the-fly KMC workflows
 
 ## Module Structure
 
@@ -24,18 +32,33 @@ The `graphatoms` is a Python library designed for chemical graph theory analysis
 src/graphatoms/
 ├── arrayapi/        # Array API compatibility layer
 ├── dataclasses/     # Pydantic-based data models
+├── enterpoint/      # Entry points: CLI, config, runners, network, parallel
+│   ├── config/      # Hydra/OmegaConf configuration (atoms, bonds, calculator)
+│   ├── network/     # Reaction network: scheduler, recorder, metadata
+│   ├── parallel/    # Pluggable executors (serial, multiprocessing, ray, dask, executorlib)
+│   ├── runner/      # Runners (otfkmc, rxngen) and helpers
+│   ├── steps/       # Step primitives for runners
+│   └── view.py      # CLI viewer for reactions
 ├── geometry/        # Geometric operations
 ├── reaction/        # Reaction classes and KMC events
-│   ├── base/        # Abstract base classes
-│   ├── event/       # KMC events (adsorption, desorption, reaction)
-│   ├── mcmove/      # Monte Carlo moves
-│   ├── mdwarpper/   # MD wrapper
-│   └── network/     # Reaction network
+│   ├── _event.py    # Event base and event info
+│   ├── reaction.py  # Reaction class
+│   └── xxsorption.py # Adsorption/Desorption events
 ├── system/          # Core system classes
-│   ├── atoms/       # Atomic structure handling
-│   ├── database/    # Database storage backends
-│   └── graph/       # Graph-based system representation
+│   ├── atoms.py     # Atomic structure handling
+│   ├── bonds.py     # Bond list operations
+│   ├── graph.py     # Graph-based system representation
+│   ├── system.py    # System abstract base
+│   ├── sysCluster.py # Cluster system
+│   ├── sysGas.py    # Gas molecule system
+│   └── database/    # Database storage backends (HDF5, SQLite, folder)
 └── utils/           # Utility functions
+    ├── adsorption.py # Adsorption site helper
+    ├── asetools.py  # ASE-related tools
+    ├── bytestool.py # Byte-level helpers
+    ├── logger.py    # Logging setup
+    ├── parser.py    # Hydra argument parsing
+    ├── rdutils.py   # RDKit utilities
     └── subgraph.py  # Array API compatible subgraph operations
 ```
 
@@ -58,6 +81,10 @@ src/graphatoms/
 - pydantic >= 2.10
 - python-snappy >= 0.7.3
 - loguru
+- pandas >= 2
+- scipy >= 1.10
+- typer
+- executorlib
 
 ## Installation
 

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.0.0"
+version = "2.1.0"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 license-files = ["src/LICENSE"]
@@ -42,12 +42,8 @@ dependencies = [
     "tomli; python_version < '3.11'",
     "tomli-w",
     "typing-extensions",
-    "plotext",
-    "plotext-plus",
-    "matplotlib",
     "executorlib",
     "hydra-core",
-    "pipefunc",
     "typer",
     "loguru",
 ]

{graphatoms-2.0.0 → graphatoms-2.1.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.0.0"
+version = "2.1.0"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]
@@ -60,12 +60,8 @@ dependencies = [
     "typing-extensions",
 
     # Other
-    "plotext",
-    "plotext-plus",
-    "matplotlib",
     "executorlib",
     "hydra-core",
-    "pipefunc",
     "typer",
     "loguru",
 ]

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

@@ -110,6 +110,7 @@ class _MetaDataTable(BaseModel):
         *,
         cluster_key: str | None = None,
         system_key: str | None = None,
+        exclude_gas: bool = False,
         **kwargs,
     ) -> int:
         if cluster_key is not None:
@@ -117,7 +118,10 @@ class _MetaDataTable(BaseModel):
                 [
                     self.count[i]
                     for i, ck in enumerate(self.for_cluster)
-                    if ck == cluster_key
+                    if (
+                        ck == cluster_key
+                        and ((not exclude_gas) or self.key_g[i] is None)
+                    )
                 ]
                 + [0]
             )
@@ -126,7 +130,10 @@ class _MetaDataTable(BaseModel):
                 [
                     self.count[i]
                     for i, sk in enumerate(self.for_system)
-                    if sk == system_key
+                    if (
+                        sk == system_key
+                        and ((not exclude_gas) or self.key_g[i] is None)
+                    )
                 ]
                 + [0]
             )

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

@@ -106,7 +106,7 @@ class _OldNewRecorder(OurBaseModel):
 class Recorder(OurBaseModel):
     system: set[str] = set()
     cluster: dict[str, _OldNewRecorder] = defaultdict(_OldNewRecorder)
-    adsorption: set[str] = set()
+    adsorption: dict[str, _OldNewRecorder] = defaultdict(_OldNewRecorder)
     bulk: set[str] = set()
 
     @override

{graphatoms-2.0.0 → graphatoms-2.1.0}/src/graphatoms/enterpoint/runner/_base.py

@@ -164,6 +164,7 @@ class RunnerABC:
                 ),
                 raise_when_fail=True,
                 allow_hash_change=False,
+                allow_not_connected=False,
                 run_vibration=True,
                 deep_copy=True,
             )
@@ -370,6 +371,7 @@ class ExplorationABC(RunnerABC):
                             graph_label=label,
                             graph=sysgraph,
                             allow_hash_change=False,
+                            allow_not_connected=False,
                             raise_when_fail=False,
                         )
                     )
@@ -441,10 +443,13 @@ class ExplorationABC(RunnerABC):
                 system_key=system_key,
             )
         if len(lst_4adsorption) > 0:
-            self._second_step_adsorption(
-                lst_4adsorption,
-                system_key=system_key,
-            )
+            for cluster in lst_4adsorption:
+                for gas in self.gas_lst:
+                    self._second_step_adsorption(
+                        gas=gas,
+                        cluster=cluster,
+                        system_key=system_key,
+                    )
         if len(lst_4surface) > 0:
             for cluster in lst_4surface:
                 self._second_step_surface(
@@ -579,6 +584,7 @@ class ExplorationABC(RunnerABC):
                 confidence=confidence,
                 min_found=self.network.metadata.table.get_minconut_for(
                     cluster_key=cluster_key,
+                    exclude_gas=True,
                 ),
             ):
                 msg = f"Finish exploration for {cluster_key} with "
@@ -588,103 +594,122 @@ class ExplorationABC(RunnerABC):
                 for future in futures:
                     self.executor.cancel(future)
                 break
-
         self.network.persistence()
 
     def _second_step_adsorption(
         self,
-        lst: list[Cluster],
+        gas: Gas,
+        cluster: Cluster,
         system_key: str = "",
     ) -> None:
         """The second step for the on-the-fly KMC simulation."""
-        start: float = perf_counter()
+        cluster_key = cluster.get_key_for_metadata(True)
+        gas_key = gas.get_key_for_metadata(False)
+
+        # ---------------------------------------------
+        # check if the adsorption has been explored
+        # ---------------------------------------------
+        graph_label = f"{cluster_key}_{gas_key}"
+        if graph_label in self.network.recorder.adsorption:
+            msg = f"The adsorption for {cluster_key} with "
+            msg += f"{gas_key} has been explored."
+            self.logger.info(self._reformat_message(msg))
+            return
+
+        # ---------------------------------------------
+        # build helper for adsorption
+        # ---------------------------------------------
+        assert cluster.ncore > 0, "graph must have core"
+        adsorption_helper = Helper(
+            atoms=cluster.to_ase(
+                exclude_bond_attibutes=True,
+                exclude_energetics=True,
+            ).copy(),
+            adsorbate=gas,
+            core=np.unique(cluster.idx_core),
+            nfibonacci=int(self.config.exploration.nfibonacci),
+            use_direct=True,
+            use_raw=True,
+        )
+
+        # ---------------------------------------------
+        # submit adsorption tasks to executor
+        # ---------------------------------------------
         futures: list = []
-        for cluster in lst:
-            for gas in self.gas_lst:
-                cluster_key = cluster.get_key_for_metadata(True)
-                gas_key = gas.get_key_for_metadata(False)
-
-                # ---------------------------------------------
-                # check if the adsorption has been explored
-                # ---------------------------------------------
-                label = f"{cluster_key}_{gas_key}"
-                if label in self.network.recorder.adsorption:
-                    msg = f"The adsorption for {cluster_key} with "
-                    msg += f"{gas_key} has been explored."
-                    self.logger.info(self._reformat_message(msg))
-                    continue
-                # ---------------------------------------------
-                # build helper for adsorption
-                # ---------------------------------------------
-                assert cluster.ncore > 0, "graph must have core"
-                adsorption_helper = Helper(
-                    atoms=cluster.to_ase(
-                        exclude_bond_attibutes=True,
-                        exclude_energetics=True,
-                    ).copy(),
-                    adsorbate=gas,
-                    core=np.unique(cluster.idx_core),
-                    nfibonacci=int(self.config.exploration.nfibonacci),
-                    use_direct=True,
-                    use_raw=True,
-                )
-                # ---------------------------------------------
-                # submit adsorption tasks to executor
-                # ---------------------------------------------
-                self.network.recorder.adsorption.add(label)
-                nrun: int = adsorption_helper.nrun
-                nrun: int = min(nrun, self.config.exploration.maxtry)
-                for irun in range(nrun):
-                    futures.append(
-                        self.executor.submit(
-                            helper_adsorption,
-                            config=self.config,
-                            graph=cluster,
-                            gas=gas,
-                            irun=irun,
-                            graph_label=None,
-                            allow_hash_change=True,
-                            raise_when_fail=False,
-                            deep_copy=True,
-                        )
-                    )
-                self.logger.info(
-                    self._reformat_message(
-                        f"Submit {nrun} adsorption tasks for "
-                        f"{cluster_key} with {gas_key}"
-                    )
+        start: float = perf_counter()
+        nrun: int = adsorption_helper.nrun
+        maxtry: int = self.config.exploration.maxtry
+        if nrun <= maxtry:
+            lst = np.asarray(range(nrun))
+        else:
+            lst = np.random.randint(nrun, size=maxtry)
+        np.random.shuffle(lst)
+        for irun in lst:
+            futures.append(
+                self.executor.submit(
+                    helper_adsorption,
+                    config=self.config,
+                    graph=cluster,
+                    gas=gas,
+                    irun=irun,
+                    graph_label=graph_label,
+                    allow_hash_change=True,
+                    raise_when_fail=False,
+                    deep_copy=True,
                 )
-
+            )
         self.logger.info(
             self._reformat_message(
-                f"Submit {len(futures)} adsorption tasks by "
+                f"Submit {nrun} adsorption tasks by "
                 f"{perf_counter() - start:.2f} seconds"
+                f" for {cluster_key} with {gas_key}"
             )
         )
 
         # -----------------------------------------------------------
         # wait for the adsorption tasks to finish
         # -----------------------------------------------------------
+        old_new = self.network.recorder.adsorption[graph_label]
+        confidence = self.config.exploration.maxconfidence
         while len(futures) > 0:
             future_result, futures = self.executor.wait(futures)  # type: ignore
-            event, label, cost_time, _ = future_result
-            label = self.network.found(
+            event, _, cost_time, _ = future_result
+            event_label = self.network.found(
                 event,
                 for_cluster=None,
                 for_system=system_key,
                 persist=True,
             )
-            if label.startswith("fail"):
-                msg = f"Adsorption search {label} by {cost_time:.2f}"
+            if event_label.startswith("fail"):
+                msg = f"Adsorption search {event_label} by {cost_time:.2f}"
                 msg += f" seconds because of {event}"
                 self.logger.info(self._reformat_message(msg))
+                old_new.found_fail()
             else:
                 msg = "Adsorption search successfully, and got "
-                msg += f"{label} by {cost_time:.2f} seconds."
-                if str(event) not in label:
+                msg += f"{event_label} by {cost_time:.2f} seconds."
+                if str(event) not in event_label:
                     msg += f" Simplify original {event} by threshold "
                     msg += f"{self.config.event.simplified_threshold:.2f}"
                 self.logger.info(self._reformat_message(msg))
+                if "new" in event_label:
+                    old_new.found_new()
+                else:
+                    old_new.found_old()
+            if old_new.exploration_can_be_finished(
+                confidence=confidence,
+                min_found=self.network.metadata.table.get_minconut_for(
+                    cluster_key=cluster_key,
+                    exclude_gas=False,
+                ),
+            ):
+                msg = f"Finish exploration for {cluster_key} and {gas_key}"
+                msg += f"with confidence {confidence:.2f}. {len(futures)}"
+                msg += " adsorption tasks left. They will be canceled."
+                self.logger.info(self._reformat_message(msg))
+                for future in futures:
+                    self.executor.cancel(future)
+                break
         self.network.persistence()
 
     def _second_step_bulk(

{graphatoms-2.0.0 → graphatoms-2.1.0}/src/graphatoms/enterpoint/runner/_helper.py

@@ -87,6 +87,7 @@ def helper_optimization(
     *,
     graph_label: Any | None = None,
     allow_hash_change: bool = True,
+    allow_not_connected: bool = False,
     raise_when_fail: bool = False,
     run_vibration: bool = True,
     deep_copy: bool = True,
@@ -152,6 +153,15 @@ def helper_optimization(
         parse_bonds=config.bonds,  # type: ignore
         deep=deep_copy,
     )
+    if (not allow_not_connected) and (not result.is_connected):
+        e = HelperException(
+            msg="graph is not connected after optimization",
+            label=graph_label,
+        )
+        if raise_when_fail:
+            raise e
+        else:
+            return str(e), graph_label, perf_counter() - start
     if not allow_hash_change and graph.hash != result.hash:
         e = HelperException(
             msg="hash changed after optimization",
@@ -362,6 +372,7 @@ def helper_dimer(
     # ------------------------------------------------------------
     cost_time = perf_counter() - start
     if not product_result.is_connected:
+        # TODO: parse Desorption
         e = HelperException(
             msg="product is not connected",
             label=graph_label,
@@ -442,7 +453,7 @@ def helper_adsorption(
     """
     if graph_label is None:
         graph_label = graph.get_key_for_metadata()
-    graph_label += f"_{gas.get_key_for_metadata(False)}"
+        graph_label += f"_{gas.get_key_for_metadata(False)}"
 
     # -----------------------------------------
     #       call adsorption initial positions

{graphatoms-2.0.0 → graphatoms-2.1.0}/src/graphatoms/enterpoint/runner/otfkmc.py

@@ -71,6 +71,7 @@ class OTFKMC(ExplorationABC):
 
         while True:
             otfkmc_info = OTFKMCInfo()
+            self.istep = len(df_data) - 1
             self.logger.info("=" * self._log_length)
             self.logger.info(f"Step {self.istep} Start")
             self.logger.info("-" * self._log_length)

{graphatoms-2.0.0 → graphatoms-2.1.0}/src/graphatoms/reaction/__init__.py

@@ -1,9 +1,8 @@
 # ruff: noqa: F401
 
-from graphatoms.reaction.adsorption import Adsorption
-from graphatoms.reaction.desorption import Desorption
 from graphatoms.reaction._event import EventBase, EventInfo
 from graphatoms.reaction.reaction import ReactionER, ReactionLH
+from graphatoms.reaction.xxsorption import Adsorption, Desorption
 
 __all__ = [
     "EventBase",

{graphatoms-2.0.0 → graphatoms-2.1.0}/src/graphatoms/reaction/_event.py

@@ -224,6 +224,10 @@ class RTGP(OurFrozenModel):
         # print(f"geom_moved: {geom_moved}")
 
         moved: np.ndarray = np.asarray(list(graph_node_moved), dtype=int)
+        nmax = max(len(self.R), len(self.P))
+        nmin = min(len(self.R), len(self.P))
+        gas_moved = list(range(nmin, nmax))
+        moved = np.setdiff1d(moved, gas_moved)
         pos = self.R.positions[moved, :].reshape(-1, len(moved), 3)
         v = self.R.positions[:, np.newaxis, :] - pos
         d = np.linalg.norm(v, axis=-1).min(-1)
@@ -234,6 +238,10 @@ class RTGP(OurFrozenModel):
             if i is None or isinstance(i, Gas):
                 rtgp.append(i)
             elif isinstance(i, SysGraph):
+                if len(i) == nmax:
+                    sub = np.append(sub, gas_moved)
+                else:
+                    sub = np.setdiff1d(sub, gas_moved)
                 rtgp.append(
                     Cluster.select(
                         i,

graphatoms-2.0.0/src/graphatoms/reaction/desorption.py → graphatoms-2.1.0/src/graphatoms/reaction/xxsorption.py

@@ -9,6 +9,101 @@ from graphatoms.reaction._event import EventBase, h, kB
 from graphatoms.system.system import System
 
 
+class Adsorption(EventBase):
+    @model_validator(mode="after")
+    def __check_something(self) -> Self:
+        assert self.G is not None, "The gas must be not None."
+        assert self.T is None, "The transition state must be None."
+        assert len(self.P) == len(self.R) + len(self.G), (
+            "The product state must be the sum of the "  #
+            "reactant state and the gas molecule."
+        )
+        return self
+
+    @property
+    @override
+    def reversed(self) -> "Desorption":
+        return Desorption(R=self.P, G=self.G, T=self.T, P=self.R)
+
+    @override
+    def apply(
+        self,
+        atoms: System | Atoms,
+        *args,
+        matched_indxs: list[int] | np.ndarray | None = None,
+        **kwargs,
+    ) -> tuple[Atoms, float]:
+        atoms, rmsd = super().apply(atoms, *args, matched_indxs, **kwargs)
+        patoms: Atoms = self.P.to_ase(exclude_energetics=True)
+        mask = np.arange(len(self.P)) >= len(self.R)
+        atoms.extend(patoms[mask])
+        return atoms, rmsd
+
+    @override
+    def get_Ea(self, *args, **kwargs) -> float:  # type: ignore
+        """The adsorption reaction does not have an activation energy.
+
+        Returns:
+            np.inf
+        """
+        return np.inf
+
+    @override
+    def get_dE(
+        self,
+        temperature: float = 300.0,
+        *args,
+        pressure: float | None = None,
+        **kwargs,
+    ) -> float:
+        assert self.G is not None, "The gas must be not None."
+        e_P = self.P.get_free_energy(fqmin=30.0, temp=temperature)
+        e_R = self.R.get_free_energy(fqmin=30.0, temp=temperature)
+        if pressure is None:
+            pressure = self.G.pressure
+        assert pressure is not None, "The pressure must be not None."
+        e_G = self.G.get_free_energy(
+            fqmin=30.0,
+            temp=temperature,
+            pressure=pressure,
+        )
+        return e_P - e_R - e_G
+
+    @override
+    def get_rate(
+        self,
+        temperature: float = 300.0,
+        *args,
+        pressure: float | None = None,
+        sticking: float | None = None,
+        **kwargs,
+    ) -> float:
+        """Get the rate of the reaction by the collision theory.
+
+        Ref: Dominic R. Alfonso; Kinetic Monte Carlo Simul-
+            ation of CO Adsorption on Sulfur-Covered Pd(100).
+            J. Phys. Chem. A  2014, 118, 7306-7313.
+        Eq:
+                          S*A
+            rate = -------------------
+                    sqrt(2*pi*m*kB*T)
+        """
+        assert self.G is not None, "The gas must be not None."
+        kBT = kB * temperature
+        m = np.sum(MASS[self.G.numbers])
+        A = abs(self.G.area + self.R.area - self.P.area) / 2.0
+
+        if sticking is None:
+            sticking = self.G.sticking
+        assert sticking is not None, (
+            "The sticking coefficient must be not None."
+        )
+        if pressure is None:
+            pressure = self.G.pressure
+        assert pressure is not None, "The pressure must be not None."
+        return (sticking * A * pressure) / np.sqrt(2 * np.pi * m * kBT)
+
+
 class Desorption(EventBase):
     @model_validator(mode="after")
     def __check_something(self) -> Self:
@@ -20,6 +115,11 @@ class Desorption(EventBase):
         )
         return self
 
+    @property
+    @override
+    def reversed(self) -> "Adsorption":
+        return Adsorption(R=self.P, G=self.G, T=self.T, P=self.R)
+
     @override
     def apply(
         self,

{graphatoms-2.0.0 → graphatoms-2.1.0}/src/graphatoms/system/sysGas.py

@@ -179,6 +179,7 @@ class Gas(System):
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
             return IdealGasThermo(
+                atoms=Atoms(self.numbers, self.positions),
                 vib_energies=evib,  # type: ignore
                 geometry=self.__geometry_type,
                 symmetrynumber=self.nsymmetry,

graphatoms-2.0.0/src/graphatoms/reaction/adsorption.py

@@ -1,99 +0,0 @@
-from typing import Self, override
-
-import numpy as np
-from ase import Atoms
-from ase.data import atomic_masses as MASS
-from pydantic import model_validator
-
-from graphatoms.reaction._event import EventBase, kB
-from graphatoms.system.system import System
-
-
-class Adsorption(EventBase):
-    @model_validator(mode="after")
-    def __check_something(self) -> Self:
-        assert self.G is not None, "The gas must be not None."
-        assert self.T is None, "The transition state must be None."
-        assert len(self.P) == len(self.R) + len(self.G), (
-            "The product state must be the sum of the "  #
-            "reactant state and the gas molecule."
-        )
-        return self
-
-    @override
-    def apply(
-        self,
-        atoms: System | Atoms,
-        *args,
-        matched_indxs: list[int] | np.ndarray | None = None,
-        **kwargs,
-    ) -> tuple[Atoms, float]:
-        atoms, rmsd = super().apply(atoms, *args, matched_indxs, **kwargs)
-        patoms: Atoms = self.P.to_ase(exclude_energetics=True)
-        mask = np.arange(len(self.P)) >= len(self.R)
-        atoms.extend(patoms[mask])
-        return atoms, rmsd
-
-    @override
-    def get_Ea(self, *args, **kwargs) -> float:  # type: ignore
-        """The adsorption reaction does not have an activation energy.
-
-        Returns:
-            np.inf
-        """
-        return np.inf
-
-    @override
-    def get_dE(
-        self,
-        temperature: float = 300.0,
-        *args,
-        pressure: float | None = None,
-        **kwargs,
-    ) -> float:
-        assert self.G is not None, "The gas must be not None."
-        e_P = self.P.get_free_energy(fqmin=30.0, temp=temperature)
-        e_R = self.R.get_free_energy(fqmin=30.0, temp=temperature)
-        if pressure is None:
-            pressure = self.G.pressure
-        assert pressure is not None, "The pressure must be not None."
-        e_G = self.G.get_free_energy(
-            fqmin=30.0,
-            temp=temperature,
-            pressure=pressure,
-        )
-        return e_P - e_R - e_G
-
-    @override
-    def get_rate(
-        self,
-        temperature: float = 300.0,
-        *args,
-        pressure: float | None = None,
-        sticking: float | None = None,
-        **kwargs,
-    ) -> float:
-        """Get the rate of the reaction by the collision theory.
-
-        Ref: Dominic R. Alfonso; Kinetic Monte Carlo Simul-
-            ation of CO Adsorption on Sulfur-Covered Pd(100).
-            J. Phys. Chem. A  2014, 118, 7306-7313.
-        Eq:
-                          S*A
-            rate = -------------------
-                    sqrt(2*pi*m*kB*T)
-        """
-        assert self.G is not None, "The gas must be not None."
-        kBT = kB * temperature
-        m = np.sum(MASS[self.G.numbers])
-        A = abs(self.G.area + self.R.area - self.P.area) / 2.0
-
-        if sticking is None:
-            sticking = self.G.sticking
-        assert sticking is not None, (
-            "The sticking coefficient must be not None."
-        )
-        if pressure is None:
-            pressure = self.G.pressure
-        assert pressure is not None, "The pressure must be not None."
-        return (sticking * A * pressure) / np.sqrt(2 * np.pi * m * kBT)