Figure 4.27:

Overall and per-pass conversion of A as a function of fractional recycle, \alpha .

Code for Figure 4.27

Text of the GNU GPL.

main.py

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
# Converted from pfr_sep_cstr.m
import numpy as np
from scipy.optimize import fsolve
from misc import octave_save

k = 1.0; theta = 1.0
ktheta = k*theta
xpfr = 1 - np.exp(-ktheta)
xcstr = ktheta/(1 + ktheta)

class P:
    pass

def recycle_reactor(x, p):
    Na1, Na2 = x[0], x[1]
    if p.ntype == 1:
        Na3 = x[2]
        alpha = p.alpha
    else:
        Na3 = p.Na3
        alpha = x[2]
    return [
        (1 + ktheta/Na1)*Na2 - Na1,
        alpha*Na2 + 1 - Na1,
        Na3 - (1-alpha)*Na2
    ]

p = P(); p.ntype = 1; p.ktheta = ktheta; p.Na3 = np.nan

nalpha = 250
xalpha = np.linspace(0, 1, nalpha)
x_sol = np.array([1., 1/(1+ktheta), 1/(1+ktheta)])
xrec = np.zeros(nalpha)
xpass = np.zeros(nalpha)

for i, a in enumerate(xalpha):
    p.alpha = a
    xs = fsolve(lambda x: recycle_reactor(x, p), x_sol)
    x_sol = xs
    Na1, Na2, Na3 = xs
    xrec[i] = 1 - Na3
    xpass[i] = (Na1 - Na2)/Na1

table = np.column_stack([xalpha, xrec, xpass])

p.ntype = 2; p.Na3 = 1 - xpfr; p.alpha = np.nan
xs2 = fsolve(lambda x: recycle_reactor(x, p),
             np.array([1., 1/(1+ktheta), 0.]))
alpha_pfr = xs2[2]
auxtable = np.array([
    [0., xpfr, xcstr, alpha_pfr, 0.],
    [1., xpfr, xcstr, alpha_pfr, 1.]
])
octave_save('pfr_sep_cstr.dat', ('table', table), ('auxtable', auxtable))