When the companies that supply motor fuel close the books on 2011, they will pay about $6.8 million in penalties to the Treasury because they failed to mix a special type of biofuel into their gasoline and diesel as required by law.

however…

[...]

the ingredient, cellulosic biofuel, does not exist.

A Fine for Not Using a Biofuel That Doesn’t Exist

For technology companies, the cost of labor is minimal compared with the expense of buying parts and managing supply chains that bring together components and services from hundreds of companies.

and

“The entire supply chain is in China now,” said another former high-ranking Apple executive. “You need a thousand rubber gaskets? That’s the factory next door. You need a million screws? That factory is a block away. You need that screw made a little bit different? It will take three hours.”

How U.S. Lost Out on iPhone Work

To be sure, it’s possible to shred wire in the United States. But unlike China, where there are plenty of manufacturers eager to buy large volumes of rubber and plastic insulation, the United States lacks such industrial demand, forcing U.S. recyclers to either landfill insulation or sell it to power plants as fuel. But the lack of a U.S. market for chopped plastic and mixed chopped copper and brass creates a counter-intuitive (for American environmentalists, at least) result: not only do Chinese recyclers recover more material from Christmas tree lights than Americans, they make more money, too. After all, they can sell the insulation, not pay for its interment.

The Chinese Town That Turns Your Old Christmas Tree Lights Into Slippers

 
 
The basics are this:  Suppose you have a stream of air contaminated with sulfur dioxide and you want to remove it, one way to do this is to pass the air through a stream of water, the sulfur dioxide is absorbed into the water.  In the specific example we want to reduce the SO2 concentration from 20 mol % to 2 mol %.  We have a particular tower geometry and packing material, and we assume the system stays constant at 25°C and 1atm, but we need to figure out how high to make the tower.

First off some notation, the mole fraction of SO2 in the bulk gas stream is y, in the bulk water stream is x. We know the flow rates of the water stream, L, and the air stream, V, these are the inert flow rates (i.e. SO2 not included). The tower has some cross sectional area, S, and the height, z, is the vertical distance from (1) to (2) (see the diagram).

I know:
S = 0.0929m²
V = 6.53×10^-4 kmol/s air
L = 4.20×10^-2 kmol/s water
y1 = 0.20
y2 = 0.02
x2 = 0.00 (pure water)

For this particular packing I also have the correlations for the film transfer coefficients:
and

Where the G’s are the total mass flow rate of gas or liquid per m² of tower cross-sectional area.

If we imagine some thin slice of the tower we can write a mole balance, namely the number of moles leaving the gas equals the total flux of moles across the interface between the two faces times the area of said interface:

Where is the total gas flow rate. We can write the flux in terms of film mass-transfer coefficients

where:

and the subscript i indicates the concentration at the interface between the air and water. We can also rewrite the right-hand side, expanding out in terms of the air flow rate:

 
Finally, equating the two:

 

 

This is the starting point of my problem solving procedure. I know the bounds of the integral, I know the flow rate of the gas, and the cross sectional area. What I need to figure out is how the integrand varies with y. To start with I’m going to figure out the operating line for the system, so that I can get x = f(y).

Again we do a mole balance but this time we look at the balance from the top of the tower, (2) to some point in the middle of the tower. Clearly the number of moles of SO2 entering in must equal the number of moles of SO2 exiting (since none are accumulating in the system), note this looks funny because the flows are counter-current:

 

 
solving for x:

 
you could note that x2 = 0 and simplify a lot:

but I’m going to keep the original since I want my code to be easily re-useable for instances where x2!=0.

Next I’m going to need the equilibrium line, and this is where the manual method would involve breaking out rulers and other such nonsense. Instead I found a table of equilibrium data at the temperature of interest, here it is as csv (I added some trailing zeroes to make everything line up nice):

"x"	"y"
0.0000000	0
0.0000562	0.000658
0.0001403	0.00158
0.0002800	0.00421
0.0004220	0.00763
0.0005640	0.0112
0.0008420	0.01855
0.0014030	0.0342
0.0019650	0.0513
0.0027900	0.0775
0.0042000	0.121
0.0069800	0.212
0.0138500	0.443
0.0206000	0.682
0.0273000	0.917

Now it is time to put on the techno, sit in a dark room, and start hacking. First off I import a bunch of stuff I know I’m going to use later, and set up the equilibrium line and operating line:

from numpy import *
from scipy.optimize import fsolve
from scipy.interpolate import interp1d
from scipy.integrate import quad

# Particular values for the problem
S = 0.0929#m^2
L = 4.2e-2#kmol/s water
V = 6.53e-4#kmol/s air
y1 = 0.2
y2 = 0.02
x2 = 0.0

# First I need some way to access the equilibrium line
eqdata = genfromtxt('data.csv',delimiter='\t')
eqdata = eqdata[1:] # the first row is the labels
xeq = eqdata[:,0]
yeq = eqdata[:,1]
eqLine = interp1d(yeq,xeq) # I want x = f(y)

# The operating line, taking the values at the exit as the reference
opLine = lambda y: (L*x2*(y2-1)*(y-1)+V*(x2-1)*(y2-y))/(L*(y2-1)*(y-1)+V*(x2-1)*(y2-y))

Note what I did here: interp1d class takes a set of data and returns a function, there are lots of types of interpolation I could have done but I just left it with the default linear interpolation. Since I have a function for the equilibrium line I can find where things intersect it using the regular sorts of methods.

As a performance note: The operating line calculation would be much more efficient if I pre-calculated all those constants, but since I want my code to be easily re-useable I just left it in it’s most general form.

Now I want to have those film transfer coefficients so I should figure out how to calculate the G’s, note I just assume that I will have some (x,y) point to work with.

# I'll need these to get mass flow rate
MWair = 29   #kg/kmol
MWSO2 = 64.1 #kg/kmol
MWwater = 18 #kg/kmol

# total mass fluxes in liquid and gas phase
Gy = lambda y: (V*MWair + V*MWSO2*(y/(1-y)))/S
Gx = lambda x: (L*MWwater + L*MWSO2*(x/(1-x)))/S

# empirical correlations for film transfer coefficients
def kya(x,y):    
    return 0.0594*pow(Gy(y),0.7)*pow(Gx(x),0.25)

def kxa(x):
    return 0.152*pow(Gx(x),0.82)

I use pow() instead of ** because I find it easier to read when it is part of a larger relation. Next I’ll figure out how to get those interface concentrations:

# Setting up the calculation of the interface concentration
def logMean(x,xi):
    return (x-xi)/log((1-xi)/(1-x))

def interfConc(x, y, tol=0.0001):
    err = 1
    m = -1*(kxa(x)/kya(x,y))
    slope = m*((1-y)/(1-x))
    yiOld = y
    while err > tol:
        f = lambda yi: (x-(y-yi)/slope) - eqLine(yi)
        yi = fsolve(f, yiOld)
        xi = (x-(y-yi)/slope)
        slope = m *(logMean(y,yi)/logMean(x,xi))
        err = abs(yi-yiOld)/yiOld
        yiOld = yi
    return yi

All I’m doing is what you would do with a ruler: I have a line starting at the operating line with the slope given and I find where it intersects the equilibrium line. This iterates a few times since the slope depends on the interface concentration. The thing to note here is that fsolve tries to find the point where the function f(y)=0, since the slope is re-calculated with each iteration I have to make a new f(y) each time. This approach has a performance penalty. I could have written an abstract f(y, slope) and used that, but I find this more compact and easy to read. I generally find lambda expressions in the context of all the variables easier to read than some other function somewhere else that you have to scroll to and read. I’m weird like that.

If this was part of a much larger project I might consider dropping all the lambdas and global variables and instead use higher order functions, greating the simpler functions by way of functools.partial(), but in this case I don’t have many global variables and that seems like overkill to me.

There are probably also much better ways of finding that intersection. Just off the top of my head, using linear interpolation to construct the functional form of the equilibrium line might be problematic as there are cusps, which will screw up the Newton-Raphson method (which I think fsolve() uses). Either I could use a higher order interpolation, or do something else. An obvious alternative is to instead use some search scheme to find which points in the raw data would bracket the intersection point then interpolate in there.

My main point is that this algorithm was something I banged out in a few minutes based entirely on what we already do. That is, in solving this problem with python, all I’m really doing is translating the math I would have done by hand into something python can understand.

Anyways you may have noticed that I am only mostly to an answer, I have all the parts to build that integrand, then I need to integrate it. This is the most tedious and irritating part of doing it by hand because you basically have to repeat everything I just did up to this point over and over again for several values of y. Here it is in python:

def integrand(y):
    x = opLine(y)
    yi = interfConc(x,y)
    return logMean(y,yi)/(kya(x,y)*(y-yi)*(1-y)**2)

z, zerr = quad(integrand,y2,y1) #this is the integration
z = V*z/S

The quad function is fairly robust general quadrature, it returns both the answer and an estimate of the error, in this case it comes out to be 1.718×10^-8m.

All togethor it is 64 lines of code (with whitespace), it took me 20-30min. to set up, and a few seconds to run. The answer this gives me is 1.57m, whereas the textbook (from which I took the numbers for this example) did it all by hand and came up with 1.59m, which is <1.2% difference. If I had done it by hand it probably would have taken me several hours.

Now that I have this script, however, I can do the same calculation for many different sorts of towers, it will only take a few minutes to change the parameters, and a few seconds to get an answer.

If you want the whole script in one easy to copy place:

from numpy import *
from scipy.optimize import fsolve
from scipy.interpolate import interp1d
from scipy.integrate import quad

# Particular values for the problem
S = 0.0929#m^2
L = 4.2e-2#kmol/s water
V = 6.53e-4#kmol/s air
y1 = 0.2
y2 = 0.02
x2 = 0.0

MWair = 29#kg/mol
MWSO2 = 64.1#kg/mol
MWwater = 18#kg/mol

# First I need some way to access the equilibrium line
eqdata = genfromtxt('data.csv',delimiter='\t')
eqdata = eqdata[1:]
xeq = eqdata[:,0]
yeq = eqdata[:,1]
eqLine = interp1d(yeq,xeq) # I want x = f(y)

# The operating line, taking the values at the exit as the reference
opLine = lambda y: (L*x2*(y2-1)*(y-1)+V*(x2-1)*(y2-y))/(L*(y2-1)*(y-1)+V*(x2-1)*(y2-y))

# total mass fluxes in liquid and gas phase
Gy = lambda y: (V*MWair + V*MWSO2*(y/(1-y)))/S
Gx = lambda x: (L*MWwater + L*MWSO2*(x/(1-x)))/S

# empirical correlations for film transfer coefficients
def kya(x,y):    
    return 0.0594*pow(Gy(y),0.7)*pow(Gx(x),0.25)

def kxa(x):
    return 0.152*pow(Gx(x),0.82)
    

# Setting up the calculation of the interface concentration
def logMean(x,xi):
    return (x-xi)/log((1-xi)/(1-x))

def interfConc(x, y, tol=0.0001):
    err = 1
    m = -1*(kxa(x)/kya(x,y))
    slope = m*((1-y)/(1-x))
    yiOld = y
    while err > tol:
        f = lambda yi: (x-(y-yi)/slope) - eqLine(yi)
        yi = fsolve(f, yiOld)
        xi = (x-(y-yi)/slope)
        slope = m *(logMean(y,yi)/logMean(x,xi))
        err = abs(yi-yiOld)/yiOld
        yiOld = yi
    return yi

def integrand(y):
    x = opLine(y)
    yi = interfConc(x,y)
    return logMean(y,yi)/(kya(x,y)*(y-yi)*(1-y)**2)

z, zerr = quad(integrand,y2,y1)
z = V*z/S