WitZuk 0.1.0__tar.gz

witzuk-0.1.0/LICENSE_NOT_SELECTED.txt

@@ -0,0 +1,3 @@
+No license has been selected yet.
+Before public release, choose and add a LICENSE file and corresponding metadata in pyproject.toml.
+Without a license, copyright remains with the author and reuse rights are not granted automatically.

witzuk-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE*
+recursive-include src/witzuk py.typed

witzuk-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: WitZuk
+Version: 0.1.0
+Summary: Scientific and engineering simulation functions by Witold Zukowski
+Author: Witold Zukowski
+Keywords: chemical-engineering,fluidized-bed,Kato-Wen,formic-acid,HCOOH
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE_NOT_SELECTED.txt
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: pandas>=2.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.1; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# WitZuk
+
+Biblioteka funkcji naukowych i inżynierskich autorstwa Witolda Żukowskiego.
+
+## Moduł `hcooh_fbr`
+
+Model płuczki z kwasem mrówkowym i reaktora fluidyzacyjnego Kato-Wena.
+
+### Instalacja
+
+```bash
+python -m pip install WitZuk
+```
+
+### Minimalny przykład z płuczką
+
+```python
+from witzuk.hcooh_fbr import simulate_scrubber, simulate_fluidized_bed
+
+feed = simulate_scrubber()
+result = simulate_fluidized_bed(feed, return_profile=False)
+print(result["conversion"]["HCOOH"])
+```
+
+### Minimalny przykład bez płuczki
+
+```python
+from witzuk.hcooh_fbr import stream_from_feed, simulate_fluidized_bed
+
+feed = stream_from_feed(
+    molar_fractions={"HCOOH": 0.02, "N2": 0.98},
+    total_flow_mol_s=5.0e-4,
+)
+result = simulate_fluidized_bed(feed, return_profile=False)
+```
+
+### Bilans cieplny i pierwiastkowy
+
+```python
+from witzuk.hcooh_fbr import calculate_reactor_heat_effect, check_element_balance
+
+heat = calculate_reactor_heat_effect(feed, result["outlet_stream"])
+balance = check_element_balance(feed, result["outlet_stream"])
+```
+
+## Status
+
+Wersja 0.1.0 (alpha). Przed publikacją wybierz licencję i uzupełnij metadane projektu.

witzuk-0.1.0/README.md

@@ -0,0 +1,48 @@
+# WitZuk
+
+Biblioteka funkcji naukowych i inżynierskich autorstwa Witolda Żukowskiego.
+
+## Moduł `hcooh_fbr`
+
+Model płuczki z kwasem mrówkowym i reaktora fluidyzacyjnego Kato-Wena.
+
+### Instalacja
+
+```bash
+python -m pip install WitZuk
+```
+
+### Minimalny przykład z płuczką
+
+```python
+from witzuk.hcooh_fbr import simulate_scrubber, simulate_fluidized_bed
+
+feed = simulate_scrubber()
+result = simulate_fluidized_bed(feed, return_profile=False)
+print(result["conversion"]["HCOOH"])
+```
+
+### Minimalny przykład bez płuczki
+
+```python
+from witzuk.hcooh_fbr import stream_from_feed, simulate_fluidized_bed
+
+feed = stream_from_feed(
+    molar_fractions={"HCOOH": 0.02, "N2": 0.98},
+    total_flow_mol_s=5.0e-4,
+)
+result = simulate_fluidized_bed(feed, return_profile=False)
+```
+
+### Bilans cieplny i pierwiastkowy
+
+```python
+from witzuk.hcooh_fbr import calculate_reactor_heat_effect, check_element_balance
+
+heat = calculate_reactor_heat_effect(feed, result["outlet_stream"])
+balance = check_element_balance(feed, result["outlet_stream"])
+```
+
+## Status
+
+Wersja 0.1.0 (alpha). Przed publikacją wybierz licencję i uzupełnij metadane projektu.

witzuk-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "WitZuk"
+version = "0.1.0"
+description = "Scientific and engineering simulation functions by Witold Zukowski"
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Witold Zukowski" }]
+dependencies = [
+  "numpy>=1.24",
+  "scipy>=1.10",
+  "pandas>=2.0",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Intended Audience :: Education",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Scientific/Engineering :: Chemistry",
+]
+keywords = ["chemical-engineering", "fluidized-bed", "Kato-Wen", "formic-acid", "HCOOH"]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2",
+  "twine>=5.1",
+  "pytest>=8.0",
+  "ruff>=0.6",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

witzuk-0.1.0/setup.cfg

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

witzuk-0.1.0/src/WitZuk.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: WitZuk
+Version: 0.1.0
+Summary: Scientific and engineering simulation functions by Witold Zukowski
+Author: Witold Zukowski
+Keywords: chemical-engineering,fluidized-bed,Kato-Wen,formic-acid,HCOOH
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Education
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE_NOT_SELECTED.txt
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: pandas>=2.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5.1; extra == "dev"
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Dynamic: license-file
+
+# WitZuk
+
+Biblioteka funkcji naukowych i inżynierskich autorstwa Witolda Żukowskiego.
+
+## Moduł `hcooh_fbr`
+
+Model płuczki z kwasem mrówkowym i reaktora fluidyzacyjnego Kato-Wena.
+
+### Instalacja
+
+```bash
+python -m pip install WitZuk
+```
+
+### Minimalny przykład z płuczką
+
+```python
+from witzuk.hcooh_fbr import simulate_scrubber, simulate_fluidized_bed
+
+feed = simulate_scrubber()
+result = simulate_fluidized_bed(feed, return_profile=False)
+print(result["conversion"]["HCOOH"])
+```
+
+### Minimalny przykład bez płuczki
+
+```python
+from witzuk.hcooh_fbr import stream_from_feed, simulate_fluidized_bed
+
+feed = stream_from_feed(
+    molar_fractions={"HCOOH": 0.02, "N2": 0.98},
+    total_flow_mol_s=5.0e-4,
+)
+result = simulate_fluidized_bed(feed, return_profile=False)
+```
+
+### Bilans cieplny i pierwiastkowy
+
+```python
+from witzuk.hcooh_fbr import calculate_reactor_heat_effect, check_element_balance
+
+heat = calculate_reactor_heat_effect(feed, result["outlet_stream"])
+balance = check_element_balance(feed, result["outlet_stream"])
+```
+
+## Status
+
+Wersja 0.1.0 (alpha). Przed publikacją wybierz licencję i uzupełnij metadane projektu.

witzuk-0.1.0/src/WitZuk.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+LICENSE_NOT_SELECTED.txt
+MANIFEST.in
+README.md
+pyproject.toml
+src/WitZuk.egg-info/PKG-INFO
+src/WitZuk.egg-info/SOURCES.txt
+src/WitZuk.egg-info/dependency_links.txt
+src/WitZuk.egg-info/requires.txt
+src/WitZuk.egg-info/top_level.txt
+src/witzuk/__init__.py
+src/witzuk/_version.py
+src/witzuk/py.typed
+src/witzuk/hcooh_fbr/__init__.py
+src/witzuk/hcooh_fbr/element_balance.py
+src/witzuk/hcooh_fbr/fluidized_bed.py
+src/witzuk/hcooh_fbr/heat_effect.py
+src/witzuk/hcooh_fbr/py.typed
+src/witzuk/hcooh_fbr/scrubber.py
+src/witzuk/hcooh_fbr/stream_from_feed.py
+tests/test_imports.py
+tests/test_public_api.py

witzuk-0.1.0/src/WitZuk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

witzuk-0.1.0/src/WitZuk.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy>=1.24
+scipy>=1.10
+pandas>=2.0
+
+[dev]
+build>=1.2
+twine>=5.1
+pytest>=8.0
+ruff>=0.6

witzuk-0.1.0/src/WitZuk.egg-info/top_level.txt

@@ -0,0 +1 @@
+witzuk

witzuk-0.1.0/src/witzuk/__init__.py

@@ -0,0 +1,5 @@
+"""WitZuk scientific and engineering library."""
+
+from ._version import __version__
+
+__all__ = ["__version__"]

witzuk-0.1.0/src/witzuk/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

witzuk-0.1.0/src/witzuk/hcooh_fbr/__init__.py

@@ -0,0 +1,19 @@
+"""HCOOH scrubber and fluidized-bed reactor models."""
+
+from .element_balance import check_element_balance, elemental_molar_flows
+from .fluidized_bed import Params, simulate_fluidized_bed
+from .heat_effect import calculate_reactor_heat_effect, stream_enthalpy_flow_W
+from .scrubber import simulate_scrubber
+from .stream_from_feed import reactor_feed_from_stream, stream_from_feed
+
+__all__ = [
+    "Params",
+    "calculate_reactor_heat_effect",
+    "check_element_balance",
+    "elemental_molar_flows",
+    "reactor_feed_from_stream",
+    "simulate_fluidized_bed",
+    "simulate_scrubber",
+    "stream_enthalpy_flow_W",
+    "stream_from_feed",
+]

witzuk-0.1.0/src/witzuk/hcooh_fbr/element_balance.py

@@ -0,0 +1,47 @@
+"""Bilans molowy pierwiastkow dla uniwersalnych strumieni gazowych."""
+
+import math
+
+ATOMS = {
+    "HCOOH": {"C": 1, "O": 2, "H": 2},
+    "CO":    {"C": 1, "O": 1, "H": 0},
+    "H2O":   {"C": 0, "O": 1, "H": 2},
+    "CO2":   {"C": 1, "O": 2, "H": 0},
+    "H2":    {"C": 0, "O": 0, "H": 2},
+    "CH4":   {"C": 1, "O": 0, "H": 4},
+    "N2":    {"C": 0, "O": 0, "H": 0},
+}
+
+
+def elemental_molar_flows(stream):
+    """Zwraca strumienie molowe atomow C, O i H w mol_atom/s."""
+    flows = stream["molar_flows"]
+    return {
+        element: sum(
+            float(flows.get(species, 0.0)) * composition[element]
+            for species, composition in ATOMS.items()
+        )
+        for element in ("C", "O", "H")
+    }
+
+
+def check_element_balance(inlet_stream, outlet_stream, rtol=1e-6, atol=1e-12):
+    """Sprawdza bilans C, O i H pomiedzy wlotem i wylotem reaktora."""
+    inlet = elemental_molar_flows(inlet_stream)
+    outlet = elemental_molar_flows(outlet_stream)
+    result = {}
+
+    for element in ("C", "O", "H"):
+        difference = outlet[element] - inlet[element]
+        relative_error = difference / inlet[element] if abs(inlet[element]) > atol else 0.0
+        result[element] = {
+            "in_mol_atom_s": inlet[element],
+            "out_mol_atom_s": outlet[element],
+            "difference_mol_atom_s": difference,
+            "relative_error": relative_error,
+            "relative_error_percent": 100.0 * relative_error,
+            "balanced": math.isclose(outlet[element], inlet[element], rel_tol=rtol, abs_tol=atol),
+        }
+
+    result["all_balanced"] = all(result[e]["balanced"] for e in ("C", "O", "H"))
+    return result

witzuk-0.1.0/src/witzuk/hcooh_fbr/fluidized_bed.py

@@ -0,0 +1,131 @@
+"""Niezależny model reaktora fluidyzacyjnego Kato-Wena dla HCOOH/N2."""
+
+import math
+from dataclasses import dataclass, fields
+
+import numpy as np
+import pandas as pd
+from scipy.integrate import solve_ivp, trapezoid
+
+from .stream_from_feed import SPECIES, R, reactor_feed_from_stream, stream_from_feed
+
+G, P0, T0 = 9.81, 1e5, 298.15
+IDX = {s: i for i, s in enumerate(SPECIES)}
+NS = len(SPECIES)
+NU = np.array([[-1.,-1.,0.],[1.,0.,-1.],[1.,0.,1.],[0.,1.,0.],
+               [0.,1.,-3.],[0.,0.,1.],[0.,0.,0.]])
+DNU = NU.sum(axis=0)
+MW = np.array([46.0254,28.0101,18.01528,44.0095,2.01588,16.0425,28.0134])/1000
+FULLER_V = np.array([41.,18.,13.1,26.9,6.12,25.15,18.5])
+SIGMA = np.array([4.2,3.69,2.64,3.996,2.92,3.78,3.798])
+EPSK = np.array([470.,91.7,809.1,190.,59.7,148.6,71.4])
+
+@dataclass
+class Params:
+    T_reactor: float=573.15; p: float=101325.; D_col: float=0.034
+    H: float=0.096; dp: float=0.00011; rho_s: float=1235.; eps_mf: float=0.43
+    k1_dehydr: float=1.5; k2_dehyd: float=1.; k3_meth: float=1e6
+    r3_reversible: bool=True; hole_density: float=125000.; d_hole: float=0.0006
+    Dbmax: float=0.020; Db0min: float=0.001; Db0max: float=0.010; alphaD: float=0.30
+    n_points: int=151; variable_viscosity: bool=True; add_equilibrium_diag: bool=True
+
+def _omega(t): return 1.16145*t**-0.14874+0.52487*np.exp(-0.77320*t)+2.16178*np.exp(-2.43787*t)
+def _pure_mu(T,M,s,e): return 2.6693e-6*math.sqrt(M*T)/(s*s*_omega(T/e))
+def _gas_mu(p,y):
+    if not p.variable_viscosity: return 2e-5
+    mu=np.array([_pure_mu(p.T_reactor,MW[i]*1000,SIGMA[i],EPSK[i]) for i in range(NS)])
+    y=np.maximum(np.asarray(y),0); y=y/y.sum(); phi=np.ones((NS,NS))
+    for i in range(NS):
+        for j in range(NS):
+            phi[i,j]=(1+math.sqrt(mu[i]/mu[j])*(MW[j]/MW[i])**0.25)**2/math.sqrt(8*(1+MW[i]/MW[j]))
+    return float(sum(y[i]*mu[i]/sum(y[j]*phi[i,j] for j in range(NS)) for i in range(NS)))
+def _gas_rho(p,y): return p.p*float(np.dot(y,MW))/(R*p.T_reactor)
+def _umf(p,rho,mu):
+    Ar=max(p.dp**3*rho*(p.rho_s-rho)*G/mu**2,0); Re=math.sqrt(33.7**2+0.0408*Ar)-33.7
+    return Re*mu/(rho*p.dp),Ar,Re
+
+def _fuller(T,p,Mi,Mj,Vi,Vj):
+    d=1e-3*T**1.75*math.sqrt(1/(Mi*1000)+1/(Mj*1000))/((p/101325)*(Vi**(1/3)+Vj**(1/3))**2)
+    return d*1e-4
+def _dbin(p):
+    D=np.zeros((NS,NS))
+    for i in range(NS):
+        for j in range(NS): D[i,j]=np.nan if i==j else _fuller(p.T_reactor,p.p,MW[i],MW[j],FULLER_V[i],FULLER_V[j])
+    return D
+def _dmix(i,y,D): return (1-y[i])/max(sum(y[j]/D[i,j] for j in range(NS) if j!=i),1e-30)
+
+# Wartości Kp jak w aplikacji v7.1.
+SH={'CO':[25.56759,6.096130,4.054656,-2.671301,.131021,-118.0089,227.3665,-110.5271],
+'CO2':[24.99735,55.18696,-33.69137,7.948387,-.136638,-403.6075,228.2431,-393.5224],
+'H2':[33.066178,-11.363417,11.432816,-2.772874,-.158558,-9.980797,172.707974,0],
+'H2O':[30.092,6.832514,6.793435,-2.53448,.082139,-250.881,223.3967,-241.8264],
+'CH4':[-.703029,108.4773,-42.52157,5.862788,.678565,-76.84376,158.7163,-74.8731]}
+HF={'CO':-110.5271,'CO2':-393.5224,'H2':0.,'H2O':-241.8264,'CH4':-74.8731,'HCOOH':-378.6}
+def _sh(T,c):
+    A,B,C,D,E,F,S,H=c; t=T/1000
+    return A*t+B*t*t/2+C*t**3/3+D*t**4/4-E/t+F-H, A*math.log(t)+B*t+C*t*t/2+D*t**3/3-E/(2*t*t)+S
+def _hcooh(T):
+    k=1.380649e-23; h=6.62607015e-34; c=299792458.; Na=6.02214076e23; m=46.0254e-3/Na
+    rot=[2.58548,.40211,.34745]; vib=[3570,2943,1770,1387,1229,1105,625,1033,638]
+    St=R*(math.log(((2*math.pi*m*k*T)/(h*h))**1.5*(k*T/P0))+2.5)
+    th=[h*c*(b*100)/k for b in rot]; Sr=R*(math.log(math.sqrt(math.pi)*T**1.5/math.sqrt(np.prod(th)))+1.5)
+    def sv(x): return sum(R*((q:=h*c*(v*100)/(k*x))/(math.exp(q)-1)-math.log(1-math.exp(-q))) for v in vib)
+    def hv(x): return sum(R*(h*c*(v*100)/k)/(math.exp((h*c*(v*100)/k)/x)-1) for v in vib)/1000
+    return 4*R*(T-T0)/1000+hv(T)-hv(T0),St+Sr+sv(T)
+def _kp(T):
+    gf={}
+    for s,c in SH.items(): H,S=_sh(T,c); gf[s]=HF[s]+H-T*S/1000
+    H,S=_hcooh(T); gf['HCOOH']=HF['HCOOH']+H-T*S/1000
+    rx=[{'CO':1,'H2O':1,'HCOOH':-1},{'CO2':1,'H2':1,'HCOOH':-1},{'CH4':1,'H2O':1,'CO':-1,'H2':-3}]
+    return [math.exp(-sum(n*gf[s] for s,n in r.items())*1000/(R*T)) for r in rx]
+def _qp3(y,p):
+    co,h2,ch4,h2o=y[IDX['CO']],y[IDX['H2']],y[IDX['CH4']],y[IDX['H2O']]
+    if co<=1e-30 or h2<=1e-30: return 0. if ch4*h2o<=1e-30 else 1e300
+    return max(ch4,0)*max(h2o,0)/(co*h2**3)*(p/P0)**-2
+
+def _reconstruct(x):
+    y=np.zeros(NS); y[:-1]=x; y[-1]=1-y[:-1].sum(); y=np.maximum(y,0)
+    return y/y.sum()
+def _db0(p,a,Q): return min(max(1.38*((Q/a['Nh'] if a['Nh']>0 else Q)**2/G)**.2,p.Db0min),p.Db0max)
+def _hydro(p,a,z,FTb,yb,ye):
+    FT=FTb+a['FTe']; yt=(FTb*yb+a['FTe']*ye)/FT; u0=FT/(a['A']*a['CT']); Ub=FTb/(a['A']*a['CT'])
+    dbmax=min(p.Dbmax,.6*p.D_col); d0=_db0(p,a,u0*a['A']); db=min(max(dbmax-(dbmax-d0)*math.exp(-(p.alphaD/p.D_col)*z),p.Db0min),dbmax)
+    ubr=.711*math.sqrt(G*db); up=max(Ub+ubr,1e-12); delta=min(max(Ub/up,1e-8),.95); ab=6*delta/db
+    rho=_gas_rho(p,yt); mu=_gas_mu(p,yt); umf,Ar,Re=_umf(p,rho,mu)
+    return dict(FT=FT,yt=yt,u0=u0,Ub=Ub,Ue=a['umf0'],Db=db,ubr=ubr,up=up,delta=delta,ab=ab,rho_g=rho,mu_g=mu,umf_diag=umf,Ar=Ar,Re=Re,Nf=u0/umf)
+def _rates(p,a,z,FTb,yb,ye):
+    h=_hydro(p,a,z,FTb,yb,ye); eps=(1-h['delta'])*p.eps_mf; C=a['CT']*ye; yh2=max(ye[IDX['H2']],0)
+    r1=eps*p.k1_dehydr*C[IDX['HCOOH']]; r2=eps*p.k2_dehyd*C[IDX['HCOOH']]
+    rf=eps*p.k3_meth*C[IDX['CO']]*yh2**3; q=_qp3(ye,p.p); drive=1-q/a['Kp'][2] if p.r3_reversible else 1.; r3=rf*drive
+    rv=np.array([r1,r2,r3]); Rsp=NU@rv; Rtot=float(DNU@rv); MT=-Rtot
+    ym=(yb+ye)/2; ym/=ym.sum(); Dm=np.array([_dmix(i,ym,a['Dbin']) for i in range(NS)]); K=4*Dm/h['Db']+.5*a['umf0']
+    M=K*h['ab']*a['CT']*(yb-ye)+(ye if MT<0 else yb)*MT
+    h.update(r1=r1,r2=r2,r3=r3,r3_forward=rf,r3_reverse_equiv=rf*q/a['Kp'][2] if p.r3_reversible else 0.,r3_drive=drive,Qp3_e_local=q,Kp3_thermo=a['Kp'][2],Rsp=Rsp,Rtot=Rtot,MT=MT,M=M,K=K,Dm=Dm)
+    return h
+
+def simulate_fluidized_bed(inlet_stream, return_profile=True, **kwargs):
+    """Symuluje reaktor. Niepodane argumenty przyjmują wartości z aplikacji v7.1."""
+    valid={f.name for f in fields(Params)}; unknown=set(kwargs)-valid
+    if unknown: raise TypeError(f"Nieznane parametry: {sorted(unknown)}")
+    p=Params(**kwargs); fd=reactor_feed_from_stream(inlet_stream,p); y0=fd['y0']; F0=fd['F0']
+    rho=_gas_rho(p,y0); mu=_gas_mu(p,y0); umf,Ar,Re=_umf(p,rho,mu); FTe=fd['A']*fd['CT']*umf
+    Nh=p.hole_density*fd['A']; Ah=math.pi*p.d_hole**2/4
+    a={**fd,'rho0':rho,'mu0':mu,'umf0':umf,'Ar0':Ar,'Re0':Re,'FTe':FTe,'Nh':Nh,'Ah':Ah,'Aop':Nh*Ah,'Dbin':_dbin(p),'Kp':_kp(p.T_reactor)}
+    if FTe>=.98*F0: raise ValueError(f"FTe={FTe:.3e} mol/s jest zbyt duże względem F0={F0:.3e} mol/s.")
+    FTb0=F0-FTe; Y0=np.r_[FTb0,y0[:-1],y0[:-1]]
+    def ode(z,Y):
+        FTb=max(float(Y[0]),1e-20); yb=_reconstruct(Y[1:NS]); ye=_reconstruct(Y[NS:2*NS-1]); h=_rates(p,a,z,FTb,yb,ye)
+        dF=fd['A']*h['Rtot']; return np.r_[dF,(-fd['A']*h['M'][:-1]-yb[:-1]*dF)/FTb,fd['A']*(h['M'][:-1]+h['Rsp'][:-1])/FTe]
+    sol=solve_ivp(ode,(0,p.H),Y0,t_eval=np.linspace(0,p.H,int(p.n_points)),method='BDF',rtol=1e-6,atol=1e-9)
+    if not sol.success: raise RuntimeError(sol.message)
+    rows=[]; FH0=F0*y0[IDX['HCOOH']]
+    for k,z in enumerate(sol.t):
+        FTb=max(float(sol.y[0,k]),1e-20); yb=_reconstruct(sol.y[1:NS,k]); ye=_reconstruct(sol.y[NS:2*NS-1,k]); h=_rates(p,a,float(z),FTb,yb,ye)
+        F=FTb*yb+FTe*ye; FT=float(F.sum()); row={'z_m':float(z),'FT_mol_s':FT,'FTb_mol_s':FTb,'FTe_mol_s':FTe,'X_HCOOH':(FH0-F[IDX['HCOOH']])/FH0 if FH0>0 else np.nan,'u0_m_s':h['u0'],'Db_m':h['Db'],'delta_b':h['delta'],'r1_dehydr_mol_m3_s':h['r1'],'r2_dehyd_mol_m3_s':h['r2'],'r3_net_mol_m3_s':h['r3']}
+        for i,s in enumerate(SPECIES): row[f'F_{s}_mol_s']=F[i]; row[f'y_{s}_total']=F[i]/FT; row[f'C_{s}_total_mol_m3']=fd['CT']*F[i]/FT
+        rows.append(row)
+    profile=pd.DataFrame(rows); out=profile.iloc[-1]
+    outlet=stream_from_feed(molar_flows={s:float(out[f'F_{s}_mol_s']) for s in SPECIES},temperature_K=p.T_reactor,pressure_Pa=p.p)
+    outlet['concentrations_mol_m3']={s:float(out[f'C_{s}_total_mol_m3']) for s in SPECIES}
+    summary={'X_HCOOH':float(out['X_HCOOH']),'solid_mass_kg':float(math.pi*p.D_col**2/4*trapezoid((1-profile['delta_b'])*(1-p.eps_mf)*p.rho_s, profile['z_m'])),'Kp':a['Kp']}
+    return {'outlet_stream':outlet,'conversion':{'HCOOH':float(out['X_HCOOH'])},'outlet':out.to_dict(),'profile':profile if return_profile else None,'summary':summary,'parameters':{f.name:getattr(p,f.name) for f in fields(p)}}

witzuk-0.1.0/src/witzuk/hcooh_fbr/heat_effect.py

@@ -0,0 +1,106 @@
+"""Niezalezny bilans entalpii strumieni gazowych reaktora.
+
+Konwencja znaku:
+    heat_duty_W > 0  - cieplo nalezy doprowadzic do reaktora,
+    heat_duty_W < 0  - cieplo nalezy odprowadzic z reaktora.
+"""
+
+import math
+
+R = 8.314462618
+T0 = 298.15
+P0 = 1.0e5
+SPECIES = ("HCOOH", "CO", "H2O", "CO2", "H2", "CH4", "N2")
+
+# Standardowe entalpie tworzenia gazow w 298.15 K [kJ/mol].
+HF298_KJ_MOL = {
+    "HCOOH": -378.6,
+    "CO": -110.5271,
+    "H2O": -241.8264,
+    "CO2": -393.5224,
+    "H2": 0.0,
+    "CH4": -74.87310,
+    "N2": 0.0,
+}
+
+# Wspolczynniki Shomate: A, B, C, D, E, F, G, H.
+SHOMATE = {
+    "CO":  [25.56759, 6.096130, 4.054656, -2.671301, 0.131021, -118.0089, 227.3665, -110.5271],
+    "CO2": [24.99735, 55.18696, -33.69137, 7.948387, -0.136638, -403.6075, 228.2431, -393.5224],
+    "H2":  [33.066178, -11.363417, 11.432816, -2.772874, -0.158558, -9.980797, 172.707974, 0.0],
+    "H2O": [30.09200, 6.832514, 6.793435, -2.534480, 0.082139, -250.8810, 223.3967, -241.8264],
+    "CH4": [-0.703029, 108.4773, -42.52157, 5.862788, 0.678565, -76.84376, 158.7163, -74.87310],
+    "N2":  [28.98641, 1.853978, -9.647459, 16.63537, 0.000117, -8.671914, 226.4168, 0.0],
+}
+
+
+def _shomate_h_increment_kj_mol(T_K, coeff):
+    A, B, C, D, E, F, _G, H = coeff
+    t = T_K / 1000.0
+    return A*t + B*t*t/2.0 + C*t**3/3.0 + D*t**4/4.0 - E/t + F - H
+
+
+def _hcooh_h_increment_kj_mol(T_K):
+    """Przyrost entalpii HCOOH(g) zgodny z modelem termodynamicznym v7.1."""
+    kB = 1.380649e-23
+    h = 6.62607015e-34
+    c = 299792458.0
+    vib_cm = (3570, 2943, 1770, 1387, 1229, 1105, 625, 1033, 638)
+
+    def hv(T):
+        return sum(
+            R * (h*c*(nu*100.0)/kB) /
+            (math.exp((h*c*(nu*100.0)/kB)/T) - 1.0)
+            for nu in vib_cm
+        ) / 1000.0
+
+    return 4.0*R*(T_K - T0)/1000.0 + hv(T_K) - hv(T0)
+
+
+def species_enthalpy_J_mol(species, temperature_K):
+    """Entalpia molowa gazu obejmujaca tworzenie i czesc jawna [J/mol]."""
+    if species not in SPECIES:
+        raise ValueError(f"Nieznany skladnik: {species}")
+    T = float(temperature_K)
+    if not math.isfinite(T) or T <= 0.0:
+        raise ValueError("temperature_K musi byc dodatnia i skonczona.")
+    dh = (_hcooh_h_increment_kj_mol(T) if species == "HCOOH"
+          else _shomate_h_increment_kj_mol(T, SHOMATE[species]))
+    return 1000.0 * (HF298_KJ_MOL[species] + dh)
+
+
+def stream_enthalpy_flow_W(stream):
+    """Zwraca strumien entalpii chemicznej i jawnej [W = J/s]."""
+    if not isinstance(stream, dict) or "molar_flows" not in stream:
+        raise TypeError("stream musi zawierac slownik molar_flows.")
+    T = float(stream["temperature_K"])
+    return sum(
+        float(stream["molar_flows"].get(sp, 0.0)) * species_enthalpy_J_mol(sp, T)
+        for sp in SPECIES
+    )
+
+
+def calculate_reactor_heat_effect(inlet_stream, outlet_stream, heat_loss_W=0.0, **kwargs):
+    """Oblicza efekt cieplny reaktora z bilansu entalpii wlot-wylot.
+
+    Wynik dodatni oznacza wymagane doprowadzenie ciepla. Parametr
+    ``heat_loss_W`` jest dodatni dla strat ciepla z reaktora do otoczenia.
+    """
+    H_in = stream_enthalpy_flow_W(inlet_stream)
+    H_out = stream_enthalpy_flow_W(outlet_stream)
+    loss = float(heat_loss_W)
+    duty = H_out - H_in + loss
+    F_hcooh_in = float(inlet_stream["molar_flows"].get("HCOOH", 0.0))
+    conversion = None
+    if F_hcooh_in > 0.0:
+        conversion = 1.0 - float(outlet_stream["molar_flows"].get("HCOOH", 0.0)) / F_hcooh_in
+    return {
+        "enthalpy_in_W": H_in,
+        "enthalpy_out_W": H_out,
+        "heat_loss_W": loss,
+        "heat_duty_W": duty,
+        "heat_duty_kW": duty / 1000.0,
+        "thermal_character": "endothermic" if duty > 0 else "exothermic" if duty < 0 else "neutral",
+        "HCOOH_conversion": conversion,
+        "specific_heat_duty_kJ_per_mol_HCOOH_in": duty / F_hcooh_in / 1000.0 if F_hcooh_in > 0 else None,
+    }

witzuk-0.1.0/src/witzuk/hcooh_fbr/scrubber.py

@@ -0,0 +1,46 @@
+"""Model nasycania azotu parami kwasu mrówkowego w płuczce."""
+
+from .stream_from_feed import stream_from_feed
+
+R = 8.314462618
+
+
+def antoine_formic_acid_bar(T_K):
+    A, B, C = 2.00121, 515.0, -139.408
+    return 10 ** (A - B / (T_K + C))
+
+
+def simulate_scrubber(Q_N2_L_min=0.5, T_flow_ref=298.15,
+                      p_flow_ref=101325.0, T_bubbler_C=15.0,
+                      acid_activity=1.0, saturation_factor=0.650,
+                      pressure_Pa=101325.0, temperature_K=573.15,
+                      HCOOH_in_override=None, **kwargs):
+    """Symuluje płuczkę; niepodane parametry mają wartości z aplikacji v7.1."""
+    Q_N2 = float(Q_N2_L_min) * 1e-3 / 60.0
+    F_N2 = float(p_flow_ref) * Q_N2 / (R * float(T_flow_ref))
+    psat = antoine_formic_acid_bar(float(T_bubbler_C) + 273.15) * 1e5
+
+    if HCOOH_in_override is None:
+        p_hcooh = min(float(saturation_factor) * float(acid_activity) * psat,
+                      0.95 * float(pressure_Pa))
+        F_HCOOH = F_N2 * p_hcooh / max(float(pressure_Pa) - p_hcooh, 1e-30)
+    else:
+        y = float(HCOOH_in_override)
+        if not 0.0 <= y < 1.0:
+            raise ValueError("HCOOH_in_override musi należeć do [0, 1).")
+        p_hcooh = y * float(pressure_Pa)
+        F_HCOOH = F_N2 * y / max(1.0 - y, 1e-30)
+
+    stream = stream_from_feed(
+        molar_flows={"HCOOH": F_HCOOH, "N2": F_N2},
+        temperature_K=temperature_K,
+        pressure_Pa=pressure_Pa,
+    )
+    stream["scrubber"] = {
+        "T_bubbler_C": float(T_bubbler_C),
+        "psat_HCOOH_Pa": psat,
+        "pHCOOH_feed_Pa": p_hcooh,
+        "acid_activity": float(acid_activity),
+        "saturation_factor": float(saturation_factor),
+    }
+    return stream

witzuk-0.1.0/src/witzuk/hcooh_fbr/stream_from_feed.py

@@ -0,0 +1,89 @@
+"""Tworzenie uniwersalnego strumienia gazowego z podanego zasilania."""
+
+import math
+
+import numpy as np
+
+R = 8.314462618
+SPECIES = ("HCOOH", "CO", "H2O", "CO2", "H2", "CH4", "N2")
+
+
+def stream_from_feed(*, molar_flows=None, molar_fractions=None,
+                     total_flow_mol_s=None, temperature_K=573.15,
+                     pressure_Pa=101325.0, **kwargs):
+    """Zwraca ujednolicony strumien gazowy.
+
+    Podaj albo ``molar_flows``, albo parę ``molar_fractions`` i
+    ``total_flow_mol_s``. Brakujące składniki są przyjmowane jako zero.
+    Dodatkowe argumenty nazwane są ignorowane, co ułatwia wspólne API.
+    """
+    temperature_K = float(temperature_K)
+    pressure_Pa = float(pressure_Pa)
+    if not math.isfinite(temperature_K) or temperature_K <= 0:
+        raise ValueError("temperature_K musi być dodatnie.")
+    if not math.isfinite(pressure_Pa) or pressure_Pa <= 0:
+        raise ValueError("pressure_Pa musi być dodatnie.")
+
+    if molar_flows is not None:
+        if not isinstance(molar_flows, dict):
+            raise TypeError("molar_flows musi być słownikiem.")
+        unknown = set(molar_flows) - set(SPECIES)
+        if unknown:
+            raise ValueError(f"Nieznane składniki: {sorted(unknown)}")
+        flows = {s: float(molar_flows.get(s, 0.0)) for s in SPECIES}
+    elif molar_fractions is not None and total_flow_mol_s is not None:
+        if not isinstance(molar_fractions, dict):
+            raise TypeError("molar_fractions musi być słownikiem.")
+        unknown = set(molar_fractions) - set(SPECIES)
+        if unknown:
+            raise ValueError(f"Nieznane składniki: {sorted(unknown)}")
+        fractions = {s: float(molar_fractions.get(s, 0.0)) for s in SPECIES}
+        sy = sum(fractions.values())
+        if not math.isfinite(sy) or sy <= 0:
+            raise ValueError("Suma ułamków molowych musi być dodatnia.")
+        fractions = {s: y / sy for s, y in fractions.items()}
+        total = float(total_flow_mol_s)
+        flows = {s: total * fractions[s] for s in SPECIES}
+    else:
+        raise ValueError("Podaj molar_flows albo molar_fractions i total_flow_mol_s.")
+
+    if any((not math.isfinite(v) or v < 0) for v in flows.values()):
+        raise ValueError("Strumienie molowe muszą być nieujemne i skończone.")
+    total = sum(flows.values())
+    if total <= 0:
+        raise ValueError("Całkowity strumień molowy musi być dodatni.")
+    fractions = {s: flows[s] / total for s in SPECIES}
+    return {
+        "type": "gas_stream",
+        "temperature_K": temperature_K,
+        "pressure_Pa": pressure_Pa,
+        "total_flow_mol_s": total,
+        "molar_flows": flows,
+        "molar_fractions": fractions,
+    }
+
+
+def reactor_feed_from_stream(inlet_stream, params):
+    """Konwertuje uniwersalny strumień na dane wewnętrzne reaktora."""
+    if "molar_flows" in inlet_stream:
+        stream = stream_from_feed(
+            molar_flows=inlet_stream["molar_flows"],
+            temperature_K=inlet_stream.get("temperature_K", params.T_reactor),
+            pressure_Pa=inlet_stream.get("pressure_Pa", params.p),
+        )
+    else:
+        stream = stream_from_feed(
+            molar_fractions=inlet_stream["molar_fractions"],
+            total_flow_mol_s=inlet_stream["total_flow_mol_s"],
+            temperature_K=inlet_stream.get("temperature_K", params.T_reactor),
+            pressure_Pa=inlet_stream.get("pressure_Pa", params.p),
+        )
+    flows = np.array([stream["molar_flows"][s] for s in SPECIES], dtype=float)
+    F0 = float(flows.sum())
+    return {
+        "A": math.pi * params.D_col**2 / 4.0,
+        "CT": params.p / (R * params.T_reactor),
+        "F0": F0,
+        "y0": flows / F0,
+        "species_flows": flows,
+    }

witzuk-0.1.0/tests/test_imports.py

@@ -0,0 +1,4 @@
+def test_public_imports():
+    import witzuk
+    import witzuk.hcooh_fbr
+    assert witzuk.__version__

witzuk-0.1.0/tests/test_public_api.py

@@ -0,0 +1,27 @@
+import math
+
+from witzuk.hcooh_fbr import (
+    calculate_reactor_heat_effect,
+    check_element_balance,
+    simulate_fluidized_bed,
+    simulate_scrubber,
+    stream_from_feed,
+)
+
+
+def test_stream_from_feed_normalizes():
+    stream = stream_from_feed(
+        molar_fractions={"HCOOH": 2.0, "N2": 98.0},
+        total_flow_mol_s=5e-4,
+    )
+    assert math.isclose(sum(stream["molar_fractions"].values()), 1.0)
+
+
+def test_default_scrubber_and_reactor():
+    feed = simulate_scrubber()
+    result = simulate_fluidized_bed(feed, return_profile=False)
+    outlet = result["outlet_stream"]
+    assert 0.0 <= result["conversion"]["HCOOH"] <= 1.0
+    assert math.isclose(sum(outlet["molar_fractions"].values()), 1.0, rel_tol=1e-8)
+    assert check_element_balance(feed, outlet)["all_balanced"]
+    assert math.isfinite(calculate_reactor_heat_effect(feed, outlet)["heat_duty_W"])