Download data/cuwp/strap/systems.py from introvoyz045/CUWP: direct link, hf CLI and curl.
- Browser
- Download file 28.3 kB
-
https://huggingface.co/datasets/introvoyz045/CUWP/resolve/main/data/cuwp/strap/systems.py
- Command line
-
hf download hf://datasets/introvoyz045/CUWP/data/cuwp/strap/systems.py
-
curl -L -o systems.py https://huggingface.co/datasets/introvoyz045/CUWP/resolve/main/data/cuwp/strap/systems.py
28.3 kB
| # -*- coding: utf-8 -*- | |
| """ | |
| """ | |
| import biosteam as bst | |
| import thermo as tm | |
| import thermosteam as tmo | |
| import numpy as np | |
| from biorefineries import cellulosic | |
| from warnings import warn | |
| import biorefineries as br | |
| from .property_package import create_property_package | |
| from .units import ( | |
| PseudoContinuousPlasticDissolutionTank, BatchPlasticDissolution, Shredding, | |
| Precipitator, JacketedSurgeTank, PrecipitatorFilter, CandleFilter, VacuumDryer, ScrewPressDegasser, | |
| SeedTrain, CoFermentation, HandSorting, EddyCurrent, Vecoplan, Magnet, Crumble, | |
| ) | |
| s = bst.stream_kwargs | |
| __all__ = ( | |
| # 'create_psuedo_continuous_system', | |
| 'create_single_layer_batch_separation_system', | |
| 'create_multilayer_batch_separation_system', | |
| ) | |
| # TODO: | |
| # [-] Make sure feed and product storage is well accounted for | |
| def create_preprocessing_system(ins, outs): | |
| feed, = ins | |
| MSW_residue, = outs | |
| HE_Loss = bst.Splitter('hand_sorting_loss', ins=feed, outs=('','sorting_loss'), split=0.98) | |
| S1 = HandSorting('hand_sorting', ins=HE_Loss-0, outs=('sorted_material','EC_feed'), split={'HandSorted':1}) | |
| S2 = EddyCurrent('eddy_current', ins=S1-1, outs=('nonferrous_metal','vecoplan_feed'), split={'Metal':0.82}) | |
| VS_Loss = bst.Splitter('vecoplan_loss', ins=S2-1, outs=('','vecoplan_loss'), split=0.993) | |
| S3 = Vecoplan('vecoplan', ins=VS_Loss-0, outs=('magnet_feed')) | |
| MC_Loss = bst.Splitter('MC_Loss', ins=S3-0, outs=('','crumble_loss'), split=0.98) | |
| S4 = Magnet('magnet', ins=MC_Loss-0, outs=('ferrous_metal','crumble_feed'), split={'Metal':1}) | |
| S5 = Crumble('crumble', ins=S4-1, outs=('overs', 'unders', MSW_residue)) | |
| # TODO: Update prices | |
| S1.outs[0].price = 1e-16 | |
| S2.outs[0].price = 1e-16 | |
| S4.outs[0].price = 1e-16 | |
| S5.outs[0].price = 1e-16 | |
| S5.outs[1].price = 1e-16 | |
| def create_multilayer_batch_separation_system( | |
| ins, outs, | |
| dissolution_steps, | |
| precipitation_steps, | |
| shred=True, | |
| facilities=False, | |
| core_facilities=True, | |
| precipitation_configuration=None, | |
| turbogenerator=True, | |
| cooling_tower=True, | |
| ): | |
| # TODO: Work on solvent and plastic prices | |
| solvents = [bst.Stream(i.solvent, price=2.17) for i in dissolution_steps] | |
| products = [bst.Stream(i.plastic + '_resin', price=2.4023) for i in precipitation_steps] | |
| ins.extend(solvents) | |
| outs.extend(products) | |
| first = True | |
| plastic = ins[0] | |
| for ds, ps, solvent, product in zip(dissolution_steps, precipitation_steps, solvents, products): | |
| intermediate = bst.Stream() | |
| sys = create_single_layer_batch_separation_system( | |
| ins=[plastic, solvent], | |
| outs=[intermediate, product], | |
| shred=first, mockup=True, | |
| dissolution_step=ds, | |
| precipitation_step=ps, | |
| burn_leftover_plastic=False, | |
| facilities=first and facilities, | |
| core_facilities=first and core_facilities, | |
| turbogenerator=first and turbogenerator, | |
| precipitation_configuration=precipitation_configuration, | |
| cooling_tower=cooling_tower, | |
| ) | |
| plastic = intermediate | |
| first = False | |
| sys.outs[0] = outs[0] | |
| def create_STRAPMSW_system( | |
| ins, outs, | |
| dissolution_step, precipitation_step, precipitation_configuration, | |
| preprocessing=True | |
| ): | |
| MSW, = ins | |
| PEPP, ethanol = outs | |
| PEPP.register_alias('product') | |
| PEPP.register_alias(dissolution_step.plastic) | |
| if preprocessing: | |
| sys = create_preprocessing_system( | |
| ins=MSW, | |
| area=100, | |
| ) | |
| # Add preprocessing non-residues | |
| residue = MSW.F_mass | |
| total = residue / 0.78 | |
| MSW.imass['HandSorted', 'Metal', 'Overs', 'Unders'] = total * np.array([10.10, 2.382, 2.823, 6.382]) / 100 | |
| MSW = sys.outs[-1] # Actual MSW-Residue | |
| n = 100 if preprocessing else 0 | |
| sys = create_single_layer_batch_separation_system( | |
| ins=MSW, | |
| outs=['biogenics_and_plastic', PEPP], | |
| dissolution_step=dissolution_step, | |
| precipitation_step=precipitation_step, | |
| precipitation_configuration=precipitation_configuration, | |
| mockup=True, | |
| area=100 + n, | |
| core_facilities=False, | |
| ) | |
| biogenics_and_plastic, PEPP = sys.outs | |
| PRxn = bst.PRxn | |
| Rxn = bst.Rxn | |
| saccharification_reactions = PRxn([ | |
| Rxn('Glucan + H2O -> Glucose', 'Glucan', 0.9000), | |
| Rxn('Glucan -> GlucoseOligomer', 'Glucan', 0.0400), | |
| Rxn('Xylan + H2O -> Xylose', 'Xylan', 0.9000), | |
| Rxn('Xylan + H2O -> XyloseOligomer', 'Xylan', 0.0240), | |
| ]) | |
| splitter = bst.Splitter(100 + n, ins=biogenics_and_plastic, split=1) | |
| splitter.register_alias('incineration_splitter') | |
| splitter.outs[1].ID = 'to_boiler' # This tell's BioSTEAM to send it to CH&P | |
| cellulosic_fermentation_sys, cfdct = cellulosic.create_cellulosic_fermentation_system( | |
| ins=(splitter-0,), | |
| outs=['vent', 'beer', 'lignin'], | |
| mockup=True, | |
| udct=True, | |
| kind='Saccharification and Co-Fermentation', | |
| saccharification_reactions=saccharification_reactions, | |
| SeedTrain=SeedTrain, | |
| CoFermentation=CoFermentation, | |
| insoluble_solids_loading=0.23, | |
| add_nutrients=False, | |
| solids_loading=0.23, # 30 wt/vol % solids content in saccharification | |
| include_scrubber=True, | |
| area=200 + n, | |
| ) | |
| seed_splitter = cfdct['S304'] | |
| pressure_filter = cfdct['S303'] | |
| pressure_filter.outs[1] = bst.Stream() | |
| pressure_filter.strict_moisture_content = False | |
| mixer = bst.Mixer(200 + n, ins=[pressure_filter.outs[1], 'dilution_water'], outs=seed_splitter.ins[0]) | |
| cellulase_mixer = cfdct['M301'] | |
| hydrolysis = cfdct['R301'] | |
| seed_train = cfdct['R302'] | |
| fermentor = cfdct['R303'] # Cofermentation | |
| cellulosic.add_urea_nutrient(fermentor, seed_train, area=200 + n) | |
| seed_train.register_alias('seed_train') | |
| fermentor.register_alias('fermentor') | |
| hydrolysis.register_alias('hydrolysis') | |
| seed_splitter.register_alias('seed_splitter') | |
| cellulase_mixer.register_alias('cellulase_mixer') | |
| def get_titer(): | |
| s = fermentor.outs[1] | |
| return (s.imass['Ethanol']) / s.F_vol # kg / m3 | |
| fermentor.get_titer = get_titer | |
| def get_additional_dilution_water(): | |
| target = fermentor.titer | |
| current = get_titer() | |
| effluent = fermentor.outs[1] | |
| T = effluent.T | |
| P = effluent.P | |
| rho = fermentor.chemicals.Water.rho('l', T, P) | |
| return (1./target - 1./current) * effluent.imass['Ethanol'] * rho | |
| def adjust_titer(): | |
| fermentor.run() | |
| dilution_stream = mixer.ins[1] | |
| new_dilution_water = dilution_stream.imass['Water'] + get_additional_dilution_water() | |
| if new_dilution_water < 0 : | |
| # TODO: Add evaporation if needed | |
| # raise RuntimeError('need evaporation') | |
| new_dilution_water = 0 | |
| warn('need evaporation') | |
| dilution_stream.imass['Water'] = new_dilution_water | |
| productivity = fermentor.productivity | |
| fermentor.tau = fermentor.titer / productivity | |
| vent, beer, lignin = cellulosic_fermentation_sys.outs | |
| cellulosic_beer_distillation_sys = br.ethanol.create_beer_distillation_system( | |
| ins=beer, | |
| outs=[''], | |
| mockup=True, | |
| area=200 + n, | |
| ) | |
| stripper_process_water = bst.Stream('') | |
| distilled_beer, stillage = cellulosic_beer_distillation_sys.outs | |
| ethanol_purification_sys, ep_dct = br.ethanol.create_ethanol_purification_system_after_beer_column( | |
| ins=distilled_beer, | |
| outs=[ethanol, stripper_process_water], | |
| mockup=True, | |
| udct=True, | |
| area=200 + n, | |
| ) | |
| bst.SolidsCentrifuge(200 + n, stillage, | |
| split={'Cellmass': 0.99}, solids=('Cellmass',)) | |
| bst.create_all_facilities( | |
| feedstock=biogenics_and_plastic, | |
| WWT_kwargs=dict( | |
| kind='high-rate', | |
| area=300 + n, | |
| ), | |
| HXN=False, | |
| # HXN_kwargs=dict( | |
| # ID=500 + n, | |
| # Qmin=1e3, | |
| # force_ideal_thermo=True, | |
| # cache_network=True, | |
| # acceptable_energy_balance_error=0.01, | |
| # ), | |
| area=400 + n, | |
| ) | |
| BT = bst.F(bst.BoilerTurbogenerator) | |
| BT.register_alias('BT') | |
| for i in bst.F(bst.SolidsSeparator): | |
| i.strict_moisture_content = False | |
| def create_single_layer_batch_separation_system( | |
| ins, outs, | |
| dissolution_step=None, | |
| precipitation_step=None, | |
| shred=True, | |
| vent_sink=None, | |
| facilities=False, | |
| core_facilities=True, | |
| solvent_loss=1e-4, | |
| burn_leftover_plastic=True, | |
| precipitation_configuration=None, | |
| turbogenerator=True, | |
| cooling_tower=True, | |
| ): | |
| """This configuration follows recommendations from the Michigan | |
| Technological University (MTU). Because centrifugation and ultrafiltrations | |
| is performed between every plastic dissolution, it can handle extreemly | |
| small plastic sizes.""" | |
| if precipitation_configuration is None: | |
| precipitation_configuration = 'solvent mixing' | |
| # TODO: Make prices part of the dissolution and precipitation step variables | |
| if len(ins) == 1: | |
| plastic, = ins | |
| solvent = bst.Stream(dissolution_step.solvent, price=2.17) | |
| solvent.register_alias('solvent', override=False, safe=False) | |
| ins.append(solvent) | |
| else: | |
| plastic, solvent = ins | |
| plastic.register_alias('feedstock', override=False, safe=False) | |
| if len(outs) == 1: | |
| undissolved_plastic, = outs | |
| product = bst.Stream(precipitation_step.plastic + '_resin', price=2.4023) | |
| outs.append(product) | |
| else: | |
| undissolved_plastic, product = outs | |
| product.register_alias('product', override=False, safe=False) | |
| plastic_storage = bst.StorageTank( | |
| ins=plastic, tau=7 * 24, vessel_material="Carbon steel" | |
| ) | |
| plastic = plastic_storage-0 | |
| if shred: | |
| shredder = Shredding(ins=plastic_storage-0) | |
| plastic = shredder-0 | |
| storage = bst.StorageTank( | |
| ins=solvent, tau=7 * 24, vessel_material="Carbon steel", | |
| vessel_type='Floating roof', | |
| ) | |
| pump = bst.Pump(ins=storage-0, P=2 * 101325) | |
| recycle = bst.Stream() | |
| solvent_mixer = bst.Mixer(ins=[pump-0, recycle]) | |
| surge_tank = bst.StorageTank( | |
| ins=solvent_mixer-0, vessel_type='Floating roof', | |
| vessel_material="Stainless steel", tau=0.15, | |
| ) | |
| surge_tank.line = 'Surge tank' | |
| splitter = bst.Splitter(ins=surge_tank-0, outs=('solvent_purge', ''), split=solvent_loss) | |
| splitter.register_alias('solvent_loss') | |
| splitter.register_alias(dissolution_step.solvent + '_loss') | |
| adsorption_column = bst.AdsorptionColumn( | |
| ins=[splitter-1, '', 'activated_carbon'], | |
| cycle_time=168, # h | |
| superficial_velocity=14.4, # m / h | |
| isotherm_model='Freundlich', | |
| isotherm_args = (48.4, 2.58), # K, n | |
| # k = 0.00931, # [1 / hr] | |
| void_fraction=1 - 0.38 / 0.8, | |
| C_final_scaled=0.05, # Breakthrough condition | |
| adsorbate='Solubles', | |
| LUB_forced=0.6096, # For faster simulation | |
| ) | |
| adsorption_column.register_alias('adsorption_column') | |
| adsorption_column.outs[2].ID = 'spent_activated_carbon' | |
| solvent_pump = bst.Pump(ins=adsorption_column-0, P=10 * 101325) | |
| solvent2dissolution = solvent_pump-0 | |
| solvent_dissolution_heater = bst.HXutility( | |
| ins=solvent2dissolution, heat_only=True, T=dissolution_step.T | |
| ) | |
| def adjust_temperature(): | |
| solvent_dissolution_heater.T = dissolution_step.T | |
| dissolution = BatchPlasticDissolution( | |
| ins=(plastic, solvent_dissolution_heater-0), | |
| vessel_material="Stainless steel 304", | |
| dissolution_step=dissolution_step, | |
| minimum_solvent_to_feed=4, | |
| adiabatic=True | |
| ) | |
| dissolution.register_alias('dissolution_vessel') | |
| # dissolution.breakpoint = False | |
| def adjust_fresh_solvent_flow(mixer, dissolution, step, hx): | |
| feed, solvent = dissolution.ins | |
| solvent_key = step.solvent | |
| # if dissolution.breakpoint: breakpoint() | |
| solvent_recycled = solvent.imol[solvent_key] | |
| dissolution.run() | |
| solvent_out = dissolution.outs[0].imol[solvent_key] | |
| solvent_loss = solvent_out - solvent_recycled | |
| if solvent_loss < 0: | |
| recycle.F_mass *= solvent.imol[solvent_key] / solvent_recycled | |
| solvent_loss = 0 | |
| storage.ins[0].imol[solvent_key] = solvent_loss | |
| mixer.run_until(dissolution, inclusive=True) | |
| mixed = solvent + feed | |
| H_actual = mixed.H | |
| mixed.T = dissolution_step.T | |
| H_target = mixed.H | |
| solvent.H += H_target - H_actual | |
| hx.T = solvent.T | |
| mixer.run_until(dissolution, inclusive=True) | |
| effluent, = dissolution.outs | |
| surge_tank = JacketedSurgeTank( | |
| ins=effluent, vessel_type='Floating roof', | |
| vessel_material="Carbon steel", tau=dissolution.tau, | |
| ) | |
| # TODO: Add option for design specification | |
| # @surge_tank.add_design_specification(design=True) | |
| # def adjust_surge_time(): | |
| # surge_tank.tau = dissolution.design_results['Batch time'] | |
| surge_tank.line = 'Jacketed surge tank' | |
| pump = bst.Pump(ins=surge_tank-0, P=2 * 101325) | |
| centrifuge = bst.Centrifilter( | |
| ins=pump-0, | |
| moisture_content=dissolution_step.solvent_content, | |
| solvent=dissolution_step.solvent, | |
| solid_polymer='Plastic', | |
| solutes=('Solutes', dissolution_step.dissolved_plastic), | |
| ) | |
| def adjust_moisture(centrifuge): | |
| centrifuge.moisture_content = dissolution_step.solvent_content | |
| centrifuge.register_alias('filter_centrifuge') | |
| solids = [i.ID for i in centrifuge.chemicals if i.locked_state == 's'] | |
| # centrifuge.isplit[solids] = 0.999 | |
| dummy = bst.Stream(None) | |
| dummy.imol[dissolution_step.solvent] = 1 | |
| P = 0.1 * 101325 | |
| bp = dummy.bubble_point_at_P(P) | |
| dryer0 = VacuumDryer( | |
| ins=centrifuge-0, | |
| split=0, | |
| T=50 + bp.T, # TODO: expose assumption as a parameter | |
| moisture_content=0, | |
| moisture_ID=dissolution_step.solvent, | |
| P=P | |
| ) | |
| condensate = dryer0-1 | |
| # @flash.add_specification(args=(flash,)) | |
| # def use_CEOS(flash): | |
| # inlet = flash.ins[0] | |
| # chemicals = inlet.available_chemicals | |
| # IDs = [i.ID for i in chemicals] | |
| # flows = inlet.imol[IDs] | |
| # F_mol = flows.sum() | |
| # zs = flows / F_mol | |
| # zs = zs.tolist() | |
| # T = flash.T | |
| # P = flash.P | |
| # # Use equations of state for the gas and liquid phases. | |
| # flashpkg = tmo.equilibrium.FlashPackage( | |
| # chemicals=chemicals, | |
| # G=tm.CEOSGas, L=tm.CEOSLiquid, S=tm.GibbsExcessSolid, | |
| # GE=tm.UNIFAC, GEkw=dict(version=1), Gkw=dict(eos_class=tm.PRMIX), | |
| # ) | |
| # flasher = flashpkg.flasher(N_liquid=1) | |
| # PT = flasher.flash(zs=zs, T=T, P=P) | |
| # V = PT.VF | |
| # gas_zs = PT.gas.zs | |
| # vapor, liquid = flash.outs | |
| # for i in (vapor, liquid): | |
| # i.T = T | |
| # i.P = P | |
| # vapor.imol[IDs] = vapor_flows = F_mol * V * np.asarray(gas_zs) | |
| # liquid.imol[IDs] = flows - vapor_flows | |
| # vapor.imol['N2', 'O2'] += liquid.imol['N2', 'O2'] | |
| # liquid.imol['N2', 'O2'] = 0. | |
| microfilter = CandleFilter( | |
| ins=centrifuge-1, | |
| split=0, | |
| moisture_ID=dissolution_step.solvent, | |
| moisture_content=0, | |
| ) | |
| mixer = bst.Mixer(ins=(microfilter-0, dryer0-0), outs=undissolved_plastic) | |
| precipitation_tank = Precipitator( | |
| ins=microfilter-1, | |
| precipitation_step=precipitation_step, | |
| ) | |
| microfilter.isplit[solids] = 1.0 | |
| # TODO: Cost this as a filter press instead | |
| centrifuge = PrecipitatorFilter( | |
| ins=precipitation_tank-0, | |
| mesh_size=10, # um | |
| moisture_content=precipitation_step.precipitate_solvent_content, | |
| solvent=precipitation_step.solvent, | |
| solid_polymer='Plastic', | |
| ) | |
| def adjust_moisture(centrifuge): | |
| centrifuge.moisture_content = precipitation_step.precipitate_solvent_content | |
| melt_vacuum = bst.Flash( | |
| ins=centrifuge-0, P=0.2 * 101325, | |
| V=0.999, # TODO: Make this multiple stages and adjust model to vaporize set fraction at a T and P | |
| thermo=centrifuge.thermo.ideal(), # Avoid VLLE | |
| has_vapor_condenser=True, | |
| ) | |
| melt_vacuum.line = 'Melt degasser' | |
| degasser = ScrewPressDegasser( | |
| ins=melt_vacuum-1, | |
| outs=[product, ''], | |
| split=0, | |
| T=50 + bp.T, # TODO: expose assumption as a parameter | |
| moisture_content=1e-9, | |
| moisture_ID=precipitation_step.solvent, | |
| P=101325 * 0.05 | |
| ) | |
| condenser = bst.HXutility(ins=degasser-1, V=0, rigorous=True) | |
| liq_mixer = bst.Mixer( | |
| ins=[centrifuge-1, condensate, melt_vacuum-0, condenser-0], | |
| outs=[recycle], | |
| ) | |
| CHP = bst.BoilerTurbogenerator if turbogenerator else bst.Boiler | |
| if facilities: | |
| bst.create_all_facilities( | |
| HXN=False, CIP=False, WWT=False, PWC=False, | |
| CT=cooling_tower, CWP=cooling_tower, | |
| CHP_kwargs=dict(autopopulate=burn_leftover_plastic, | |
| gas_feed=False, | |
| cls=CHP), | |
| ) | |
| elif core_facilities: | |
| bst.create_all_facilities( | |
| HXN=False, CIP=False, WWT=False, PWC=False, CHP=False, | |
| CT=cooling_tower, CWP=cooling_tower, | |
| ) | |
| match precipitation_configuration: | |
| case 'solvent mixing': | |
| splitter = bst.Splitter( | |
| ins=solvent2dissolution, | |
| split=0.5 | |
| ) | |
| Tm = splitter.chemicals[precipitation_step.solvent].Tm | |
| hx = bst.HXutilities( | |
| ins=splitter-0, | |
| T=Tm + 10, | |
| rigorous=False, | |
| ) | |
| mixer = bst.Mixer( | |
| ins=[hx-0, microfilter-1], | |
| ) | |
| solvent_dissolution_heater.ins[0] = splitter-1 | |
| precipitation_tank.ins[0] = mixer-0 | |
| def adjust_split_to_meet_precipitation_temperature(mixer, hx): | |
| # sum(Hin) = Hout | |
| # F_0 * h_in_0 + F_1 * h_in_1 = (F_0 * h_out_0) + (F_1 * h_out_1) | |
| # F_0 * (h_in_0 - h_out_0) = F_1 * h_out_1 - F_1 * h_in_1 | |
| # F_0 = (F_1 * h_out_1 - F_1 * h_in_1) / (h_in_0 - h_out_0) | |
| s0, s1 = mixer.ins | |
| s0.T = hx.T | |
| s0.empty() | |
| s0.imol[precipitation_step.solvent] = 1 | |
| s0_out = s0.copy() | |
| s1_out = s1.copy() | |
| s0_out.T = s1_out.T = precipitation_step.T | |
| h_in_0 = s0.h | |
| h_in_1 = s1.h | |
| h_out_0 = s0_out.h | |
| h_out_1 = s1_out.h | |
| F_1 = s1.F_mol | |
| F_0 = (F_1 * h_out_1 - F_1 * h_in_1) / (h_in_0 - h_out_0) | |
| s0.F_mol = F_0 | |
| mixer.simulate() | |
| s_out = mixer.outs[0] | |
| assert ( | |
| abs(s_out.F_mol - (F_1 + F_0)) < 1e-3 and | |
| abs(s_out.T - precipitation_step.T) < 1e-3 | |
| ) | |
| F_mol_recycle = splitter.ins[0].F_mol | |
| if F_mol_recycle < F_0: | |
| splitter.split[:] = 1 | |
| else: | |
| splitter.split[:] = F_0 / F_mol_recycle | |
| case 'integrated heat transfer': | |
| hot_solvent = microfilter-1 | |
| cooling = hot_solvent.sink | |
| cold_solvent = solvent2dissolution | |
| heating = cold_solvent.sink | |
| hx_integration = bst.HXprocess(ins=(hot_solvent, cold_solvent), outs=('cooled_solvent', 'heated_solvent'), phase0='l', phase1='l') | |
| cooling.ins[0], heating.ins[0] = hx_integration.outs | |
| case _: | |
| raise ValueError("precipitation_configuration must be either 'integrated heat transfer' or 'solvent mixing'") | |
| # for i in recycles: bst.mark_disjunction(i) # Flow is completely determined by dissolution tank | |
| # @bst.SystemFactory( | |
| # ID='psuedo_continuous_sys', | |
| # ins=[s("plastic", Plastic=300, units="kg/hr")], | |
| # outs=[s("product", price=2.4023)], | |
| # fthermo=create_property_package, | |
| # ) | |
| # def create_psuedo_continuous_system( | |
| # ins, outs, | |
| # dissolution_steps=None, | |
| # precipitation_steps=None, | |
| # ): | |
| # """This configuration may only work with big plastic packing. Otherwise, | |
| # best to use the batch system with ultrafiltration.""" | |
| # #: TODO: Cost filter. | |
| # plastic, = ins | |
| # undissolved_plastic, = outs | |
| # if dissolution_steps is None: | |
| # dissolution_steps = [EVOH_dissolution(), PE_dissolution()] | |
| # if precipitation_steps is None: | |
| # precipitation_steps = [EVOH_precipitation(), PE_precipitation()] | |
| # # TODO: Make prices part of the dissolution and precipitation step variables | |
| # solvents = [bst.Stream(i.solvent, price=2.17) for i in dissolution_steps] | |
| # products = [bst.Stream(i.plastic, price=2.4023) for i in precipitation_steps] | |
| # ins.extend(solvents) | |
| # outs.extend(products) | |
| # plastic_storage = bst.StorageTank( | |
| # ins=plastic, tau=7 * 24, vessel_material="Carbon steel" | |
| # ) | |
| # conveyor = bst.ConveyingBelt(ins=plastic_storage-0) | |
| # mixers = [] | |
| # recycles = [] | |
| # solvents2dissolution = [] | |
| # dissolution_times = [i.tau for i in dissolution_steps] | |
| # drying_time = 0.05 | |
| # surge_time = sum(dissolution_times) + len(dissolution_times) * drying_time # This is also the cycle time | |
| # for solvent in solvents: | |
| # storage = bst.StorageTank( | |
| # ins=solvent, tau=7 * 24, vessel_material="Carbon steel", | |
| # vessel_type='Floating roof', | |
| # ) | |
| # pump = bst.Pump(ins=storage-0, P=2 * 101325) | |
| # recycle = bst.Stream() | |
| # recycles.append(recycle) | |
| # mixer = bst.Mixer(ins=[pump-0, recycle]) | |
| # mixers.append(mixer) | |
| # surge_tank = bst.StorageTank( | |
| # ins=mixer-0, vessel_type='Floating roof', | |
| # vessel_material="Stainless steel", tau=surge_time, | |
| # ) | |
| # surge_tank.line = 'Surge tank' | |
| # pump = bst.Pump(ins=surge_tank-0, P=10 * 101325) | |
| # solvents2dissolution.append(pump-0) | |
| # dissolution_tanks = PseudoContinuousPlasticDissolutionTank( | |
| # ins=(conveyor-0, *solvents2dissolution, 'air'), | |
| # outs=(undissolved_plastic, *len(solvents2dissolution) * [''], 'vent'), | |
| # vessel_material="Stainless steel 304", | |
| # dissolution_steps=dissolution_steps, drying_time=drying_time | |
| # ) | |
| # for mixer, solvent, step in zip(mixers, solvents2dissolution, dissolution_steps): | |
| # @mixer.add_specification(run=True, args=(mixer, solvent, step)) | |
| # def adjust_fresh_solvent_flow(mixer, solvent, step): | |
| # fresh, recycle = mixer.ins | |
| # fresh.imol[step.solvent] = solvent.imol[step.solvent] - recycle.imol[step.solvent] | |
| # plastic, *dissolved_plastics, vent = dissolution_tanks.outs | |
| # vents = [] | |
| # for dissolved_plastic, precipitation_step, recycle, product in zip(dissolved_plastics, precipitation_steps, recycles, products): | |
| # surge_tank = bst.StorageTank( | |
| # ins=dissolved_plastic, vessel_type='Floating roof', | |
| # vessel_material="Carbon steel", tau=surge_time, | |
| # ) | |
| # surge_tank.line = 'Surge tank' | |
| # pump = bst.Pump(ins=surge_tank-0, P=2 * 101325) | |
| # cooler = bst.HXutility(ins=pump-0, T=precipitation_step.T) | |
| # @cooler.add_specification(args=(cooler, precipitation_step,)) | |
| # def precipitate(cooler, precipitation_step): | |
| # cooler.T = precipitation_step.T | |
| # cooler.run() | |
| # precipitation_step.precipitate(cooler.outs[0]) | |
| # centrifuge = PrecipitatorFilter( | |
| # ins=cooler-0, | |
| # moisture_content=precipitation_step.solvent_content, | |
| # solvent=precipitation_step.solvent, | |
| # solid_polymer='Plastic', | |
| # ) | |
| # screw_press = bst.ScrewPress( | |
| # ins=centrifuge-0, | |
| # split=1, | |
| # moisture_content=precipitation_step.solvent_contents[1], | |
| # moisture_ID=precipitation_step.solvent | |
| # ) | |
| # pellet_mill = bst.PelletMill(ins=screw_press-0) | |
| # dummy = bst.Stream(None) | |
| # dummy.imol[precipitation_step.solvent] = 1 | |
| # bp = dummy.bubble_point_at_P() | |
| # dryer = bst.DrumDryer( | |
| # ins=pellet_mill-0, | |
| # outs=(product, '', ''), | |
| # split=0, | |
| # R=1.4, | |
| # H=20, | |
| # length_to_diameter=25, | |
| # T=10 + bp.T, | |
| # moisture_content=precipitation_step.solvent_contents[2], | |
| # moisture_ID=precipitation_step.solvent, | |
| # gas_composition=[('N2', 1.0)], | |
| # utility_agent="Steam", | |
| # ) | |
| # flash = bst.Flash( | |
| # ins=dryer-1, | |
| # T=precipitation_step.T_condensation, | |
| # P=101325 | |
| # ) | |
| # @flash.add_specification(args=(flash,)) | |
| # def use_CEOS(flash): | |
| # inlet = flash.ins[0] | |
| # chemicals = inlet.available_chemicals | |
| # IDs = [i.ID for i in chemicals] | |
| # flows = inlet.imol[IDs] | |
| # F_mol = flows.sum() | |
| # zs = flows / F_mol | |
| # zs = zs.tolist() | |
| # T = flash.T | |
| # P = flash.P | |
| # # Use activity coefficients for the liquid phase | |
| # # and equations of state for the gas phase. | |
| # flashpkg = tmo.equilibrium.FlashPackage( | |
| # chemicals=chemicals, | |
| # G=tm.CEOSGas, L=tm.GibbsExcessLiquid, S=tm.GibbsExcessSolid, | |
| # GE=tm.UNIFAC, GEkw=dict(version=1), Gkw=dict(eos_class=tm.PRMIX), | |
| # ) | |
| # flasher = flashpkg.flasher(N_liquid=1) | |
| # PT = flasher.flash(zs=zs, T=T, P=P) | |
| # V = PT.VF | |
| # gas_zs = PT.gas.zs | |
| # vapor, liquid = flash.outs | |
| # for i in (vapor, liquid): | |
| # i.T = T | |
| # i.P = P | |
| # vapor.imol[IDs] = vapor_flows = F_mol * V * np.asarray(gas_zs) | |
| # liquid.imol[IDs] = flows - vapor_flows | |
| # vents.append(flash-0) | |
| # mixer = bst.Mixer( | |
| # ins=[centrifuge-1, screw_press-1, flash-1], | |
| # outs=recycle | |
| # ) | |
| # mixer = bst.Mixer(ins=vents) | |
| # bst.ThermalOxidizer(ins=mixer-0) | |
| # # for i in recycles: bst.mark_disjunction(i) # Flow is completely determined by dissolution tank | |