pypolymer 0.2.0__tar.gz

pypolymer-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sebygaa
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pypolymer-0.2.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+include pyproject.toml
+recursive-include tests *.py

pypolymer-0.2.0/PKG-INFO

@@ -0,0 +1,135 @@
+Metadata-Version: 2.1
+Name: pypolymer
+Version: 0.2.0
+Summary: LDPE polymerization reactor simulation (moments + chain-length distribution) and reinforcement-learning operating-condition optimisation.
+Home-page: https://github.com/sebygaa/polymer-reactor
+Author: sebygaa
+Author-email: sebyga@gmail.com
+License: MIT
+Project-URL: Homepage, https://github.com/sebygaa/polymer-reactor
+Project-URL: Repository, https://github.com/sebygaa/polymer-reactor
+Project-URL: Issues, https://github.com/sebygaa/polymer-reactor/issues
+Keywords: polymerization,reactor,LDPE,chemical-engineering,method-of-moments,chain-length-distribution,reinforcement-learning
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: plot
+Provides-Extra: dev
+License-File: LICENSE
+
+# pypolymer
+
+Simulation and reinforcement-learning optimisation of free-radical
+polymerization reactors (LDPE-type chemistry), in pure NumPy + SciPy.
+
+`pypolymer` provides one reactor class, `PolyRxn`, that simulates **Batch**,
+**CSTR**, and tubular **PFR** reactors by the **method of moments**, plus a
+**chain-length-distribution (CLD)** batch solver that integrates every chain
+length explicitly to recover the full molecular-weight distribution. A set of
+REINFORCE-based helpers optimise reactor operating conditions.
+
+## Installation
+
+```bash
+pip install pypolymer
+# with plotting extras (matplotlib):
+pip install "pypolymer[plot]"
+```
+
+From a local checkout:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Reaction model
+
+Free-radical polymerization with initiator decay, propagation, chain transfer
+to monomer / polymer / agent (CTA), and termination by combination and
+disproportionation:
+
+| Step | Reaction |
+|------|----------|
+| Initiation | `I → 2 R·`, `R· + M → P₁` |
+| Propagation | `Pₙ + M → Pₙ₊₁` |
+| Transfer to monomer | `Pₙ + M → Dₙ + P₁` |
+| Transfer to polymer | `Pₙ + Dₘ → Dₙ + Pₘ` |
+| Transfer to agent (CTA) | `Pₙ + S → Dₙ + P₁` |
+| Termination (combination) | `Pₙ + Pₘ → Dₙ₊ₘ` |
+| Termination (disproportionation) | `Pₙ + Pₘ → Dₙ + Dₘ` |
+
+## Quick start
+
+### Method-of-moments batch
+
+```python
+from pypolymer import PolyRxn
+
+rx = PolyRxn(kd=0.8, kp=15.0, ktc=0.02, ktd=0.02, ktrm=15e-3,
+             ktrp=10e-3, kca=5e-3, f=0.8, dH_p=-1.0e5, Mw_mono=28.05)
+rx.set_batch_params(Tc_const=473.15, rho=1.0e4, Cp_ass=1.5, U_heat=400.0, D=0.05)
+
+out = rx.run_batch(mono_0=8000.0, ini_0=50.0, CTA_0=20.0,
+                   T_0=473.15, t_end=5.0, dt=0.01)
+print(out["Mn_final"], out["Mw_final"], out["PDI_final"])
+```
+
+### Chain-length-distribution (CLD) batch
+
+`run_batch_cld` resolves every active (`Pₙ`) and dead (`Dₙ`) chain length up to
+`N_max`, so the molecular-weight distribution and its **exact** moments come out
+directly — no Hulburt–Katz closure. It is isothermal and needs no
+`set_batch_params`.
+
+```python
+from pypolymer import PolyRxn
+
+rx = PolyRxn(kd=10.0, kp=2.0, ktc=1e-3, ktd=1e-3, ktrm=8e-3,
+             ktrp=1e-3, kca=0.0, f=1.0, dH_p=-1.0e5, Mw_mono=28.05)
+
+out = rx.run_batch_cld(mono_0=180.0, ini_0=5e-2,
+                       t_end=20.0, dt=0.1, N_max=1400)
+
+print(out["Mn_final"], out["Mw_final"], out["PDI_final"])  # ≈ 6100, 12500, 2.05
+mwd  = out["MWD_final"]          # full chain-length distribution P + D
+nvec = out["chain_length"]       # 1 .. N_max
+```
+
+**Choosing `N_max`.** Faster propagation produces longer chains; pick `N_max`
+large enough that the distribution has decayed to ~0 at the boundary (check
+`out["MWD_final"][-1]` is small relative to the peak). Cost grows with `N_max`
+(an `N_max × N_max` outer product per RHS evaluation).
+
+### Operating-condition optimisation (RL)
+
+```python
+from pypolymer import run_batch_rl, run_cstr_rl, run_pfr_rl
+
+run_batch_rl(n_eps=120)          # Batch
+run_cstr_rl(n_eps=120)           # CSTR
+run_pfr_rl(n_eps=150, plot=True) # LDPE PFR (heavier)
+```
+
+Or from the command line:
+
+```bash
+python -m pypolymer            # Batch + CSTR optimisation
+python -m pypolymer pfr        # LDPE PFR optimisation
+python -m pypolymer all        # all three
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+
+

pypolymer-0.2.0/README.md

@@ -0,0 +1,104 @@
+# pypolymer
+
+Simulation and reinforcement-learning optimisation of free-radical
+polymerization reactors (LDPE-type chemistry), in pure NumPy + SciPy.
+
+`pypolymer` provides one reactor class, `PolyRxn`, that simulates **Batch**,
+**CSTR**, and tubular **PFR** reactors by the **method of moments**, plus a
+**chain-length-distribution (CLD)** batch solver that integrates every chain
+length explicitly to recover the full molecular-weight distribution. A set of
+REINFORCE-based helpers optimise reactor operating conditions.
+
+## Installation
+
+```bash
+pip install pypolymer
+# with plotting extras (matplotlib):
+pip install "pypolymer[plot]"
+```
+
+From a local checkout:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Reaction model
+
+Free-radical polymerization with initiator decay, propagation, chain transfer
+to monomer / polymer / agent (CTA), and termination by combination and
+disproportionation:
+
+| Step | Reaction |
+|------|----------|
+| Initiation | `I → 2 R·`, `R· + M → P₁` |
+| Propagation | `Pₙ + M → Pₙ₊₁` |
+| Transfer to monomer | `Pₙ + M → Dₙ + P₁` |
+| Transfer to polymer | `Pₙ + Dₘ → Dₙ + Pₘ` |
+| Transfer to agent (CTA) | `Pₙ + S → Dₙ + P₁` |
+| Termination (combination) | `Pₙ + Pₘ → Dₙ₊ₘ` |
+| Termination (disproportionation) | `Pₙ + Pₘ → Dₙ + Dₘ` |
+
+## Quick start
+
+### Method-of-moments batch
+
+```python
+from pypolymer import PolyRxn
+
+rx = PolyRxn(kd=0.8, kp=15.0, ktc=0.02, ktd=0.02, ktrm=15e-3,
+             ktrp=10e-3, kca=5e-3, f=0.8, dH_p=-1.0e5, Mw_mono=28.05)
+rx.set_batch_params(Tc_const=473.15, rho=1.0e4, Cp_ass=1.5, U_heat=400.0, D=0.05)
+
+out = rx.run_batch(mono_0=8000.0, ini_0=50.0, CTA_0=20.0,
+                   T_0=473.15, t_end=5.0, dt=0.01)
+print(out["Mn_final"], out["Mw_final"], out["PDI_final"])
+```
+
+### Chain-length-distribution (CLD) batch
+
+`run_batch_cld` resolves every active (`Pₙ`) and dead (`Dₙ`) chain length up to
+`N_max`, so the molecular-weight distribution and its **exact** moments come out
+directly — no Hulburt–Katz closure. It is isothermal and needs no
+`set_batch_params`.
+
+```python
+from pypolymer import PolyRxn
+
+rx = PolyRxn(kd=10.0, kp=2.0, ktc=1e-3, ktd=1e-3, ktrm=8e-3,
+             ktrp=1e-3, kca=0.0, f=1.0, dH_p=-1.0e5, Mw_mono=28.05)
+
+out = rx.run_batch_cld(mono_0=180.0, ini_0=5e-2,
+                       t_end=20.0, dt=0.1, N_max=1400)
+
+print(out["Mn_final"], out["Mw_final"], out["PDI_final"])  # ≈ 6100, 12500, 2.05
+mwd  = out["MWD_final"]          # full chain-length distribution P + D
+nvec = out["chain_length"]       # 1 .. N_max
+```
+
+**Choosing `N_max`.** Faster propagation produces longer chains; pick `N_max`
+large enough that the distribution has decayed to ~0 at the boundary (check
+`out["MWD_final"][-1]` is small relative to the peak). Cost grows with `N_max`
+(an `N_max × N_max` outer product per RHS evaluation).
+
+### Operating-condition optimisation (RL)
+
+```python
+from pypolymer import run_batch_rl, run_cstr_rl, run_pfr_rl
+
+run_batch_rl(n_eps=120)          # Batch
+run_cstr_rl(n_eps=120)           # CSTR
+run_pfr_rl(n_eps=150, plot=True) # LDPE PFR (heavier)
+```
+
+Or from the command line:
+
+```bash
+python -m pypolymer            # Batch + CSTR optimisation
+python -m pypolymer pfr        # LDPE PFR optimisation
+python -m pypolymer all        # all three
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pypolymer-0.2.0/pyproject.toml

@@ -0,0 +1,8 @@
+# Package metadata lives in setup.py. This file only declares the build
+# backend (PEP 517) and tool configuration.
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pypolymer-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pypolymer-0.2.0/setup.py

@@ -0,0 +1,84 @@
+"""Setup script for the pypolymer package.
+
+Metadata lives here; pyproject.toml keeps only the build-system declaration and
+tool configuration. The version is read from src/pypolymer/reactor.py so that
+__version__ remains the single source of truth.
+"""
+
+import pathlib
+import re
+
+from setuptools import find_packages, setup
+
+HERE = pathlib.Path(__file__).parent
+
+# Long description shown on the PyPI project page.
+long_description = (HERE / "README.md").read_text(encoding="utf-8")
+
+
+def _read_version():
+    """Parse __version__ from reactor.py without importing (no numpy needed)."""
+    src = (HERE / "src" / "pypolymer" / "reactor.py").read_text(encoding="utf-8")
+    match = re.search(r'^__version__\s*=\s*["\']([^"\']+)["\']', src, re.M)
+    if not match:
+        raise RuntimeError("Unable to find __version__ in reactor.py")
+    return match.group(1)
+
+
+setup(
+    name="pypolymer",
+    version=_read_version(),
+    description=(
+        "LDPE polymerization reactor simulation (moments + chain-length "
+        "distribution) and reinforcement-learning operating-condition "
+        "optimisation."
+    ),
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="sebygaa",
+    author_email="sebyga@gmail.com",
+    license="MIT",
+    url="https://github.com/sebygaa/polymer-reactor",
+    project_urls={
+        "Homepage": "https://github.com/sebygaa/polymer-reactor",
+        "Repository": "https://github.com/sebygaa/polymer-reactor",
+        "Issues": "https://github.com/sebygaa/polymer-reactor/issues",
+    },
+    keywords=[
+        "polymerization",
+        "reactor",
+        "LDPE",
+        "chemical-engineering",
+        "method-of-moments",
+        "chain-length-distribution",
+        "reinforcement-learning",
+    ],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Science/Research",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Scientific/Engineering",
+        "Topic :: Scientific/Engineering :: Chemistry",
+    ],
+    package_dir={"": "src"},
+    packages=find_packages(where="src"),
+    python_requires=">=3.9",
+    install_requires=[
+        "numpy>=1.21",
+        "scipy>=1.7",
+    ],
+    extras_require={
+        "plot": ["matplotlib>=3.4"],
+        "dev": ["pytest>=7.0", "build>=1.0", "matplotlib>=3.4"],
+    },
+    entry_points={
+        "console_scripts": [
+            "pypolymer = pypolymer.reactor:main",
+        ],
+    },
+)

pypolymer-0.2.0/src/pypolymer/__init__.py

@@ -0,0 +1,58 @@
+"""pypolymer — LDPE polymerization reactor simulation & RL optimisation.
+
+Public API
+----------
+Simulation
+    PolyRxn               Batch / CSTR / PFR (method of moments) + a
+                          chain-length-distribution (CLD) batch solver
+                          (PolyRxn.run_batch_cld).
+
+Reinforcement learning
+    run_pfr_rl            LDPE PFR operating-condition optimisation.
+    run_batch_rl          Batch operating-condition optimisation.
+    run_cstr_rl           CSTR operating-condition optimisation.
+    GaussianMLP           Gaussian-policy MLP used by the RL drivers.
+    compute_reward        PFR multi-objective reward.
+    BATCH_TARGETS         Batch reward target windows.
+    CSTR_TARGETS          CSTR reward target windows.
+    run_pfr               Fast standalone LDPE PFR simulator.
+    main                  Command-line entry point.
+
+Examples
+--------
+>>> from pypolymer import PolyRxn
+>>> rx = PolyRxn(kd=10.0, kp=2.0, ktc=1e-3, ktd=1e-3, ktrm=8e-3,
+...              ktrp=1e-3, kca=0.0, f=1.0, dH_p=-1.0e5, Mw_mono=28.05)
+>>> out = rx.run_batch_cld(mono_0=180.0, ini_0=5e-2, t_end=20.0,
+...                        dt=0.1, N_max=1400)
+>>> round(out["PDI_final"], 2)
+2.05
+"""
+
+from .reactor import (
+    BATCH_TARGETS,
+    CSTR_TARGETS,
+    GaussianMLP,
+    PolyRxn,
+    __version__,
+    compute_reward,
+    main,
+    run_batch_rl,
+    run_cstr_rl,
+    run_pfr,
+    run_pfr_rl,
+)
+
+__all__ = [
+    "BATCH_TARGETS",
+    "CSTR_TARGETS",
+    "GaussianMLP",
+    "PolyRxn",
+    "__version__",
+    "compute_reward",
+    "main",
+    "run_batch_rl",
+    "run_cstr_rl",
+    "run_pfr",
+    "run_pfr_rl",
+]

pypolymer-0.2.0/src/pypolymer/__main__.py

@@ -0,0 +1,6 @@
+"""Enable ``python -m pypolymer`` to run the RL command-line demo."""
+
+from .reactor import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())