def test_unconnected_case():
f.set_flowsheet('unconnected_case')
settings.set_thermo(['Water'], cache=True)
feedstock_a = Stream('feedstock_a', Water=1000)
water_a = Stream('water_a', Water=10)
byproduct_a = Stream('byproduct_a')
product_a = Stream('product_a')
M1_a = Mixer('M1_a', [feedstock_a, water_a])
S1_a = Splitter('S1_a', M1_a - 0, [product_a, byproduct_a], split=0.5)
feedstock_b = Stream('feedstock_b', Water=1000)
water_b = Stream('water_b', Water=10)
byproduct_b = Stream('byproduct_b')
product_b = Stream('product_b')
M1_b = Mixer('M1_b', [feedstock_b, water_b])
S1_b = Splitter('S1_b', M1_b - 0, [product_b, byproduct_b], split=0.5)
parallel_sys = f.create_system('parallel_sys')
network = parallel_sys.to_network()
actual_network = Network([M1_a, S1_a, M1_b, S1_b])
assert network == actual_network
parallel_sys.simulate()
parallel_sys.flatten()
assert parallel_sys.path == (M1_a, S1_a, M1_b, S1_b)
parallel_sys.empty_recycles()
parallel_sys.simulate()
f.clear()
def test_feed_forward_recycle_loop():
f.set_flowsheet('feed_forward_recycle_loop')
settings.set_thermo(['Water'], cache=True)
feedstock = Stream('feedstock', Water=1000)
water = Stream('water', Water=10)
recycle = Stream('recycle')
inner_recycle = Stream('inner_recycle')
product = Stream('product')
P1 = Pump('P1', feedstock)
P2 = Pump('P2', water)
M1 = Mixer('M1', [P1 - 0, recycle, inner_recycle])
S1 = Splitter('S1', M1 - 0, ['', recycle], split=0.5)
M2 = Mixer('M2', [P2 - 0, S1 - 0])
S2 = Splitter('S2', M2 - 0, [inner_recycle, product], split=0.5)
P3 = Pump('P3', product)
recycle_loop_sys = f.create_system('recycle_loop_sys')
network = recycle_loop_sys.to_network()
actual_network = (Network(
[P1, P2,
Network([M1, S1, M2, S2], recycle={S2 - 0, S1 - 1}), P3]))
assert network == actual_network
recycle_loop_sys.simulate()
x_nested_solution = np.vstack([recycle.mol, inner_recycle.mol])
recycle_loop_sys.flatten()
assert recycle_loop_sys.path == (P1, P2, M1, S1, M2, S2, P3)
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = np.vstack([recycle.mol, inner_recycle.mol])
assert_allclose(x_nested_solution, x_flat_solution, rtol=1e-2)
f.clear()
def test_corn_ethanol_biorefinery_system_creation():
from biorefineries.corn import flowsheet as f
corn_sys = f.create_system('corn_sys')
corn_sys.empty_recycles()
corn_sys.simulate()
bst.process_tools.default()
f.clear()
def test_two_recycle_loops_with_complete_overlap():
f.set_flowsheet('two_recycle_loops_with_complete_overlap')
settings.set_thermo(['Water'], cache=True)
feedstock = Stream('feedstock', Water=1000)
water = Stream('water', Water=10)
recycle = Stream('recycle')
inner_recycle = Stream('inner_recycle')
product = Stream('product')
inner_water = Stream('inner_water', Water=10)
P1 = Pump('P1', feedstock)
P2 = Pump('P2', water)
P3 = Pump('P3', inner_water)
M1 = Mixer('M1', [P1 - 0, P2 - 0, recycle])
M2 = Mixer('M2', [M1 - 0, P3 - 0, inner_recycle])
S2 = Splitter('S2', M2 - 0, ['', inner_recycle], split=0.5)
S1 = Splitter('S1', S2 - 0, [product, recycle], split=0.5)
recycle_loop_sys = f.create_system('recycle_loop_sys')
network = recycle_loop_sys.to_network()
actual_network = Network([
P1, P2, P3,
Network([M1, Network([M2, S2], recycle=inner_recycle), S1],
recycle=recycle)
])
assert network == actual_network
recycle_loop_sys.simulate()
x_nested_solution = np.vstack([recycle.mol, inner_recycle.mol])
recycle_loop_sys.flatten()
assert recycle_loop_sys.path == (P1, P2, P3, M1, M2, S2, S1)
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = np.vstack([recycle.mol, inner_recycle.mol])
assert_allclose(x_nested_solution, x_flat_solution, rtol=1e-2)
f.clear()
def test_inner_recycle_loop_with_bifurcated_feed():
f.set_flowsheet('simple_recycle_loop_with_bifurcated_feed')
settings.set_thermo(['Water'], cache=True)
feedstock = Stream('feedstock', Water=1000)
water = Stream('water', Water=10)
recycle = Stream('recycle')
product = Stream('product')
side_product = Stream('side_product')
P1 = Pump('P1', feedstock)
P2 = Pump('P2', water)
S1 = Splitter('S1', P2 - 0, split=0.5)
M1 = Mixer('M1', [P1 - 0, S1 - 1, recycle])
S2 = Splitter('S2', M1 - 0, [side_product, ''], split=0.5)
M2 = Mixer('M2', [S1 - 0, S2 - 1])
S3 = Splitter('S3', M2 - 0, [product, recycle], split=0.5)
recycle_loop_sys = f.create_system('recycle_loop_sys')
network = recycle_loop_sys.to_network()
actual_network = Network(
[P1, P2, S1, Network([M1, S2, M2, S3], recycle=S3 - 1)])
assert network == actual_network
recycle_loop_sys.simulate()
x_nested_solution = recycle.mol.copy()
recycle_loop_sys.flatten()
assert recycle_loop_sys.path == (P1, P2, S1, M1, S2, M2, S3)
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = recycle.mol.copy()
assert_allclose(x_nested_solution, x_flat_solution, rtol=1e-2)
f.clear()
def test_unconnected_recycle_loops():
f.set_flowsheet('unconnected_recycle_loops')
settings.set_thermo(['Water'], cache=True)
feedstock_a = Stream('feedstock_a', Water=1000)
water_a = Stream('water_a', Water=10)
recycle_a = Stream('recycle_a')
product_a = Stream('product_a')
M1_a = Mixer('M1_a', [feedstock_a, water_a, recycle_a])
S1_a = Splitter('S1_a', M1_a - 0, [product_a, recycle_a], split=0.5)
feedstock_b = Stream('feedstock_b', Water=800)
water_b = Stream('water_b', Water=10)
recycle_b = Stream('recycle_b')
product_b = Stream('product_b')
M1_b = Mixer('M1_b', [feedstock_b, water_b, recycle_b])
S1_b = Splitter('S1_b', M1_b - 0, [product_b, recycle_b], split=0.5)
recycle_loop_sys = f.create_system('recycle_loop_sys')
network = recycle_loop_sys.to_network()
actual_network = Network([
Network([M1_a, S1_a], recycle=S1_a - 1),
Network([M1_b, S1_b], recycle=S1_b - 1)
])
assert network == actual_network
recycle_loop_sys.simulate()
x_nested_solution = np.vstack([recycle_a.mol, recycle_b.mol])
recycle_loop_sys.flatten()
assert recycle_loop_sys.path == (M1_a, S1_a, M1_b, S1_b)
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = np.vstack([recycle_a.mol, recycle_b.mol])
assert_allclose(x_nested_solution, x_flat_solution, rtol=1e-2)
f.clear()
def test_trivial_case():
f.set_flowsheet('trivial_case')
settings.set_thermo(['Water'], cache=True)
trivial_sys_a = f.create_system('trivial_sys_a')
network_a = trivial_sys_a.to_network()
Stream('feedstock', Water=1000)
Stream('water', Water=10)
trivial_sys_b = f.create_system('trivial_sys_b')
network_b = trivial_sys_b.to_network()
actual_network = Network([])
assert network_a == network_b == actual_network
trivial_sys_b.simulate()
trivial_sys_b.flatten()
assert trivial_sys_b.path == ()
trivial_sys_b.empty_recycles()
trivial_sys_b.simulate()
f.clear()
def test_linear_case():
f.set_flowsheet('linear_case')
settings.set_thermo(['Water'], cache=True)
feedstock = Stream('feedstock', Water=1000)
water = Stream('water', Water=10)
byproduct = Stream('byproduct')
product = Stream('product')
M1 = Mixer('M1', [feedstock, water])
S1 = Splitter('S1', M1 - 0, [product, byproduct], split=0.5)
linear_sys = f.create_system('linear_sys')
network = linear_sys.to_network()
actual_network = Network([M1, S1])
assert network == actual_network
linear_sys.simulate()
linear_sys.flatten()
assert linear_sys.path == (M1, S1)
linear_sys.empty_recycles()
linear_sys.simulate()
f.clear()
def test_bifurcated_recycle_loops():
f.set_flowsheet('bifurcated_recycle_loops')
settings.set_thermo(['Water'], cache=True)
feed_a = Stream('feed_a', Water=10)
water_a = Stream('water_a', Water=10)
recycle_a = Stream('recycle_a')
P1_a = Pump('P1_a', feed_a)
P2_a = Pump('P2_a', water_a)
S1_a = Splitter('S1_a', P2_a - 0, split=0.5)
M1_a = Mixer('M1_a', [P1_a - 0, S1_a - 1, recycle_a])
S2_a = Splitter('S2_a', M1_a - 0, split=0.5)
M2_a = Mixer('M2_a', [S1_a - 0, S2_a - 1])
S3_a = Splitter('S3_a', M2_a - 0, ['', recycle_a], split=0.5)
feedstock_b = Stream('feedstock_b', Water=1000)
recycle_b = Stream('recycle_b')
product_b = Stream('product_b')
side_product_b = Stream('side_product_b')
P1_b = Pump('P1_b', feedstock_b)
P2_b = Pump('P2_b', S2_a - 0)
S1_b = Splitter('S1_b', P2_b - 0, split=0.5)
M1_b = Mixer('M1_b', [P1_b - 0, S1_b - 1, recycle_b])
S2_b = Splitter('S2_b', M1_b - 0, [side_product_b, ''], split=0.5)
M2_b = Mixer('M2_b', [S1_b - 0, S2_b - 1, S3_a - 0])
S3_b = Splitter('S3_b', M2_b - 0, [product_b, recycle_b], split=0.5)
recycle_loop_sys = f.create_system('recycle_loop_sys')
network = recycle_loop_sys.to_network()
actual_network = Network([
P1_b, P1_a, P2_a, S1_a,
Network([M1_a, S2_a, M2_a, S3_a], recycle=S3_a - 1), P2_b, S1_b,
Network([M1_b, S2_b, M2_b, S3_b], recycle=S3_b - 1)
])
assert network == actual_network
recycle_loop_sys.simulate()
x_nested_solution = np.vstack([recycle_a.mol, recycle_b.mol])
recycle_loop_sys.flatten()
assert recycle_loop_sys.path == (P1_b, P1_a, P2_a, S1_a, M1_a, S2_a, M2_a,
S3_a, P2_b, S1_b, M1_b, S2_b, M2_b, S3_b)
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = np.vstack([recycle_a.mol, recycle_b.mol])
assert_allclose(x_nested_solution, x_flat_solution, rtol=1e-2)
f.clear()
def test_sugarcane_ethanol_biorefinery_network():
from biorefineries.sugarcane import flowsheet as f
sugarcane_sys = f.create_system('sugarcane_sys')
globals().update(f.unit.__dict__)
network = sugarcane_sys.to_network()
actual_network = Network([
U101, U102, U103, T201,
Network([U201, S201, M201],
recycle=M201 - 0), T202, H201, T203, P201, T204, T205, P202,
Network([M202, H202, T206, C201, C202, P203], recycle=P203 - 0), S202,
S301, F301, P306, M301, H301, T305, R301, T301, C301, M302, P301,
Network([H302, D302, P302], recycle=P302 - 0),
Network([M303, D303, H303, U301], recycle=U301 - 0), H304, T302, P304,
T303, P305, M304, T304, D301, P303, M305, U202
])
assert network == actual_network
sugarcane_sys.empty_recycles()
sugarcane_sys.simulate()
bst.process_tools.default()
def test_simple_recycle_loop():
f.set_flowsheet('simple_recycle_loop')
settings.set_thermo(['Water'], cache=True)
feedstock = Stream('feedstock', Water=1000)
water = Stream('water', Water=10)
recycle = Stream('recycle')
product = Stream('product')
M1 = Mixer('M1', [feedstock, water, recycle])
S1 = Splitter('S1', M1 - 0, [product, recycle], split=0.5)
recycle_loop_sys = f.create_system('recycle_loop_sys')
network = recycle_loop_sys.to_network()
actual_network = Network([M1, S1], recycle=recycle)
assert network == actual_network
recycle_loop_sys.simulate()
x_nested_solution = recycle.mol.copy()
recycle_loop_sys.flatten()
assert recycle_loop_sys.path == (M1, S1)
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = recycle.mol.copy()
assert_allclose(x_nested_solution, x_flat_solution, rtol=1e-2)
def test_separate_recycle_loops():
f.set_flowsheet('separate_recycle_loops')
settings.set_thermo(['Water'], cache=True)
feedstock_a = Stream('feedstock_a', Water=1000)
water_a = Stream('water_a', Water=10)
recycle_a = Stream('recycle_a')
product_a = Stream('product_a')
P1_a = Pump('P1_a', feedstock_a)
P2_a = Pump('P2_a', water_a)
M1_a = Mixer('M1_a', [P1_a - 0, P2_a - 0, recycle_a])
S1_a = Splitter('S1_a', M1_a - 0, [product_a, recycle_a], split=0.5)
feedstock_b = Stream('feedstock_b', Water=1000)
water_b = Stream('water_b', Water=10)
recycle_b = Stream('recycle_b')
product_b = Stream('product_b')
P1_b = Pump('P1_b', feedstock_b)
P2_b = Pump('P2_b', water_b)
M1_b = Mixer('M1_b', [P1_b - 0, P2_b - 0, recycle_b])
S1_b = Splitter('S1_b', M1_b - 0, [product_b, recycle_b], split=0.5)
recycles = [recycle_a, recycle_b]
recycle_loop_sys = f.create_system('recycle_loop_sys')
recycle_loop_sys.simulate()
network = recycle_loop_sys.to_network()
actual_network = Network([
P1_a, P2_a,
Network([M1_a, S1_a], recycle=S1_a - 1), P1_b, P2_b,
Network([M1_b, S1_b], recycle=S1_b - 1)
])
assert network == actual_network
x_nested_solution = np.vstack([i.mol for i in recycles])
recycle_loop_sys.flatten()
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = np.vstack([i.mol for i in recycles])
assert_allclose(x_nested_solution, x_flat_solution, rtol=1e-2)
assert recycle_loop_sys.path == (P1_a, P2_a, M1_a, S1_a, P1_b, P2_b, M1_b,
S1_b)
f.clear()
def test_nested_recycle_loops():
f.set_flowsheet('nested_recycle_loops')
settings.set_thermo(['Water'], cache=True)
feedstock = Stream('feedstock', Water=1000)
recycle_1, recycle_2, recycle_3, recycle_4, recycle_5 = recycles = [
Stream('recycle_1'),
Stream('recycle_2'),
Stream('recycle_3'),
Stream('recycle_4'),
Stream('recycle_5'),
]
feed_1 = Stream('feed_1', Water=10)
feed_2 = Stream('feed_2', Water=10)
feed_3 = Stream('feed_3', Water=10)
feed_4 = Stream('feed_4', Water=10)
inner_recycle = Stream('inner_recycle')
product = Stream('product')
P1 = Pump('P1', feedstock)
M1 = Mixer('M1', [P1 - 0, recycle_1])
P2 = Pump('P2', M1 - 0)
H1 = HXprocess('H1', [P2 - 0, recycle_2])
P3 = Pump('P3', feed_1)
M3 = Mixer('M3', [H1 - 0, P3 - 0], recycle_2)
P4 = Pump('P4', H1 - 1)
M4 = Mixer('M4', [P4 - 0, recycle_3])
P5 = Pump('P5', feed_2)
P6 = Pump('P6', feed_3)
M5 = Mixer('M5', [M4 - 0, P5 - 0, P6 - 0])
H2 = HXprocess('H2', [M5 - 0, recycle_4])
P7 = Pump('P7', feed_4)
M6 = Mixer('M6', [H2 - 0, P7 - 0])
S1 = Splitter('S1', M6 - 0, [recycle_4, ''], split=0.5)
S2 = Splitter('S2', H2 - 1, split=0.5)
P8 = Pump('P8', S2 - 1)
S3 = Splitter('S3', P8 - 0, split=0.5)
H3 = HXprocess('H3', [S2 - 0, recycle_5], ['', recycle_3])
M7 = Mixer('M7', [H3 - 0, S3 - 0])
S4 = Splitter('S4', M7 - 0, ['', recycle_5], split=0.5)
S5 = Splitter('S5', S4 - 0, ['', recycle_1], split=0.5)
M8 = Mixer('M8', [S3 - 1, S1 - 1, S5 - 0], product)
recycle_loop_sys = f.create_system('recycle_loop_sys')
recycle_loop_sys.simulate()
network = recycle_loop_sys.to_network()
actual_network = Network([
P1, P3, P5, P6, P7,
Network([
M1, P2,
Network([H1, M3], recycle=M3 - 0), P4,
Network([
M4, M5,
Network([H2, M6, S1], recycle=S1 - 0), S2,
Network([M7, S4, H3], recycle=H3 - 0), P8, S3
],
recycle=H3 - 1), S5
],
recycle=S5 - 1), M8
])
assert network == actual_network
x_nested_solution = np.vstack([i.mol for i in recycles])
recycle_loop_sys.flatten()
recycle_loop_sys.empty_recycles()
recycle_loop_sys.simulate()
x_flat_solution = np.vstack([i.mol for i in recycles])
assert_allclose(x_nested_solution, x_flat_solution, rtol=5e-2)
f.clear()
def create_ethanol_subsystem_example():
"""
Test BioSTEAM by creating a conventional sugarcane fermentation and ethanol
purification process.
Examples
--------
>>> ethanol_sys = create_ethanol_subsystem_example()
>>> # The sugarcane_example_subsystem flowsheet may help for accessing units
>>> from biosteam import main_flowsheet as F
>>> fs = F.flowsheet['ethanol_subsystem_example']
>>> fs.unit # Check unit operation registry
Register:
<Fermentation: R301>
<StorageTank: T301>
<VentScrubber: D301>
<SolidsCentrifuge: C301>
<Mixer: M302>
<Pump: P301>
<HXprocess: H302>
<BinaryDistillation: D302>
<Pump: P302>
<Mixer: M303>
<BinaryDistillation: D303>
<Pump: P303>
<HXutility: H303>
<MolecularSieve: U301>
>>> R301 = fs.unit.R301 # Get unit operation
"""
original_flowsheet = main_flowsheet.get_flowsheet()
main_flowsheet.set_flowsheet('ethanol_subsystem_example')
### Create property package ###
chemicals = tmo.Chemicals(
['Water', 'Ethanol', 'Glucose',
'Sucrose', 'H3PO4', 'P4O10',
'CO2', 'Octane', 'O2']
)
Water, Ethanol, Glucose, Sucrose, H3PO4, P4O10, CO2, Octane, O2 = chemicals
CO2.at_state(phase='g')
H3PO4.at_state(phase='s')
P4O10.at_state(phase='s')
Glucose.at_state(phase='s')
Sucrose.at_state(phase='s')
DryYeast = tmo.Chemical('DryYeast', MW=1., phase='s',
search_db=False, default=True, CAS='Yeast')
chemicals.append(DryYeast)
Ash = tmo.Chemical('Ash', MW=1., search_db=False, phase='s', default=True)
chemicals.append(Ash)
# Insolubles occupy a significant volume
insoluble_solids = (Ash, DryYeast)
# Solubles don't occupy much volume
soluble_solids = (H3PO4, Glucose, Sucrose)
for chemical in insoluble_solids:
V = fn.rho_to_V(rho=1540, MW=chemical.MW)
chemical.V.add_model(V, top_priority=True)
for chemical in soluble_solids:
V = fn.rho_to_V(rho=1e5, MW=chemical.MW)
chemical.V.add_model(V, top_priority=True)
# Add constant models for molar heat capacity of solids
Ash.Cn.add_model(0.09 * 4.184 * Ash.MW)
for chemical in chemicals: chemical.default()
bst.settings.set_thermo(chemicals)
chemicals.set_synonym('Water', 'H2O')
### Create fresh streams ###
# Fresh water
stripping_water = bst.Stream('stripping_water', Water=5000, units='kg/hr')
fermentation_feed = bst.Stream('fermentation_feed', phase='l',
Glucose=21.11,
Sucrose=125.9,
Water=1370 + 4409,
H3PO4=0.7575,
DryYeast=1.03e+04)
# Ethanol Production
R301 = units.Fermentation('R301', outs=('CO2', ''), tau=9, efficiency=0.90, N=4)
T301 = units.StorageTank('T301', tau=4, vessel_material='Carbon steel')
T301.line = 'Beer tank'
D301 = units.VentScrubber('D301', ins=(stripping_water, R301-0), gas=('CO2',))
# Separate 99% of yeast
C301 = units.SolidsCentrifuge('C301', outs=('recycle_yeast', ''),
split=(1, 0.99999, 1, 0.96, 0.01),
order=('Ethanol', 'Glucose', 'H3PO4',
'Water', 'DryYeast'),
solids=('DryYeast',))
C301.split[:] = 1. - C301.split
# Mix in Water
M302 = units.Mixer('M302')
P301 = units.Pump('P301')
# Heat up before beer column
# Exchange heat with stillage
H302 = units.HXprocess('H302', outs=('', 'stillage'),
phase0='l', phase1='l', U=1.28)
# Beer column
x_bot = 3.910570816782338e-06
y_top = 0.34508430224337167
D302 = units.BinaryDistillation('D302', P=101325,
y_top=y_top, x_bot=x_bot, k=1.25,
LHK=('Ethanol', 'Water'))
D302.tray_material = 'Stainless steel 304'
D302.vessel_material = 'Stainless steel 304'
D302.boiler.U = 1.85
P302 = units.Pump('P302')
# Mix ethanol Recycle (Set-up)
M303 = units.Mixer('M303')
x_bot = 3.910570816782338e-06
y_top = 0.7906528373264998
D303 = units.BinaryDistillation('D303', P=101325,
y_top=y_top, x_bot=x_bot, k=1.25,
LHK=('Ethanol', 'Water'),
tray_material='Stainless steel 304',
vessel_material='Stainless steel 304',
is_divided=True)
D303.boiler.U = 1.85
P303 = units.Pump('P303')
# Superheat vapor for mol sieve
H303 = units.HXutility('H303', T=115+273.15, V=1)
# Molecular sieve
U301 = units.MolecularSieve('U301',
split=(2165.14/13356.04, 1280.06/1383.85),
order=('Ethanol', 'Water'))
fermentation_feed-R301-1-T301-0-C301
(C301-1, D301-1)-M302-P301
(P301-0, P302-0)-H302-0-D302-1-P302
(D302-0, U301-0)-M303-0-D303-0-H303-U301
D303-1-P303
ethanol_subsystem_example = main_flowsheet.create_system('ethanol_subsystem_example')
ethanol_subsystem_example.simulate()
main_flowsheet.set_flowsheet(original_flowsheet)
return ethanol_subsystem_example
