GraphAtoms 2.1.1__tar.gz → 2.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: graphatoms
-Version: 2.1.1
+Version: 2.3.0
 Summary: The Chemical Core Class for Graph Theory Analysis.
 Keywords: chemistry,graph theory,reaction,event,KMC
 Author: LiuGaoyong
@@ -29,6 +29,7 @@ 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: joblib
 Requires-Dist: executorlib
 Requires-Dist: hydra-core
 Requires-Dist: typer

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "graphatoms"
-version = "2.1.1"
+version = "2.3.0"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 license-files = ["src/LICENSE"]
@@ -42,6 +42,7 @@ dependencies = [
     "tomli; python_version < '3.11'",
     "tomli-w",
     "typing-extensions",
+    "joblib",
     "executorlib",
     "hydra-core",
     "typer",
@@ -72,6 +73,7 @@ dev = [
     "jupyterlab",
     "chemiscope",
     "nglview",
+    "grpcio",
     "ray",
 ]
 
@@ -164,7 +166,9 @@ hydra-core = ">=1.3.2,<2"
 tomli-w = ">=1.2.0,<2"
 loguru = ">=0.7.3,<0.8"
 jupyterlab = ">=4.5.8,<5"
+joblib = ">=1.1.0,<2"
 ovld = ">=0.5.15,<0.6"
 pytest-xdist = ">=3.8.0,<4"
 executorlib = ">=1.8,<2"
 typer = ">=0.20,<1"
+grpcio = ">=1.52.0,<2"

{graphatoms-2.1.1 → graphatoms-2.3.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.3.0"
 readme = "README.md"
 description = "The Chemical Core Class for Graph Theory Analysis."
 authors = [{ name = "LiuGaoyong", email = "liugaoyong_88@163.com" }]
@@ -60,6 +60,7 @@ dependencies = [
     "typing-extensions",
 
     # Other
+    "joblib",
     "executorlib",
     "hydra-core",
     "typer",
@@ -76,6 +77,7 @@ dev = [
     "chemiscope",
     # "playwright>=1.52", # chemiscope [headless]
     "nglview",
+    "grpcio",
     "ray",
 ]
 
@@ -163,7 +165,9 @@ hydra-core = ">=1.3.2,<2"
 tomli-w = ">=1.2.0,<2"
 loguru = ">=0.7.3,<0.8"
 jupyterlab = ">=4.5.8,<5"
+joblib = ">=1.1.0,<2"
 ovld = ">=0.5.15,<0.6"
 pytest-xdist = ">=3.8.0,<4"
 executorlib = ">=1.8,<2"
 typer = ">=0.20,<1"
+grpcio = ">=1.52.0,<2"

{graphatoms-2.1.1 → graphatoms-2.3.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.3.0}/src/graphatoms/enterpoint/config/__init__.py

@@ -29,11 +29,15 @@ 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
     thetacutoff: float = -1  # 0-180, -1 means no cutoff
-    nfibonacci: int = 200
+    step_distance: float = 0.4  # the step distance for adsorption
+    min_distance: float = 1.0  # the minimum distance for adsorption
+    max_distance: float = 3.0  # the maximum distance for adsorption
+    nfibonacci: int = 10  # the number of fibonacci points for adsorption
 
 
 @dataclass
@@ -44,10 +48,7 @@ class EventConfig:
     min_frequency: float = 10.0  # cm^-1
     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
+    gas_sticking: dict[str, float] = field(default_factory=dict)  # MISSING
     temperature: float = 300
 
 
@@ -70,7 +71,15 @@ 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_ncpus_for_tasks: int = 1  # the number of cpus for tasks, only effect for `parallel=ray` # noqa: E501
     parallel: str = "serial"  # serial, multiprocessing, ray, dask, executorlib
     loglevel: str = "info"  # Literal["debug", "info", "warning", "error"]
     logfile: str = "log.txt"

{graphatoms-2.1.1 → graphatoms-2.3.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.3.0/src/graphatoms/enterpoint/network/__init__.py

@@ -0,0 +1,11 @@
+from ._clsnetwork import ReactionNetwork
+from ._metadata import MetaData
+from ._recorder import Recorder
+from ._scheduler import Scheduler
+
+__all__ = [
+    "MetaData",
+    "Recorder",
+    "Scheduler",
+    "ReactionNetwork",
+]