Flash#

class Flash(ID='', ins=None, outs=(), thermo=None, **kwargs)[source]#

Create an equlibrium based flash drum with the option of having light non-keys and heavy non-keys completly separate into their respective phases. Design procedure is based on heuristics by Wayne D. Monnery & William Y. Svrcek [1]. Purchase costs are based on correlations by Mulet et al. [2] [3] as compiled by Warren et. al. [4].

Parameters:

ins (Stream], optional) – Inlet fluid.
outs (Stream], optional) –
- [0] Vapor product
- [1] Liquid product
P=None (float) – Operating pressure [Pa].
Q=None (float) – Duty [kJ/hr].
T=None (float) – Operating temperature [K].
V=None (float) – Molar vapor fraction.
x=None (float) – Molar composition of liquid (for binary mixtures).
y=None (float) – Molar composition of vapor (for binary mixtures).
vessel_material (str, optional) – Vessel construction material. Defaults to ‘Carbon steel’.
vacuum_system_preference ('Liquid-ring pump', 'Steam-jet ejector', or 'Dry-vacuum pump') – If a vacuum system is needed, it will choose one according to this preference. Defaults to ‘Liquid-ring pump’.
has_glycol_groups=False (bool) – True if glycol groups are present in the mixture.
has_amine_groups=False (bool) – True if amine groups are present in the mixture.
vessel_type=None ('Horizontal' or 'Vertical', optional) – Vessel separation type. If not specified, the vessel type will be chosen according to heuristics.
holdup_time=15.0 (float) – Time it takes to raise liquid to half full [min].
surge_time=7.5 (float) – Time it takes to reach from normal to maximum liquied level [min].
has_mist_eliminator (bool) – True if using a mist eliminator pad.

Notes

You may only specify two of the following parameters: P, Q, T, V, x, and y. Additionally, If x or y is specified, the other parameter must be either P or T (e.g., x and V is invalid).

Examples

>>> from biosteam.units import Flash
>>> from biosteam import Stream, settings
>>> settings.set_thermo(['Water', 'Glycerol'], cache=True)
>>> feed = Stream('feed', Glycerol=300, Water=1000)
>>> bp = feed.bubble_point_at_P() # Feed at bubble point T
>>> feed.T = bp.T
>>> F1 = Flash('F1',
...            ins=feed,
...            outs=('vapor', 'crude_glycerin'),
...            P=101325, # Pa
...            T=410.15) # K
>>> F1.simulate()
>>> F1.show(T='degC', P='atm')
Flash: F1
ins...
[0] feed
    phase: 'l', T: 100.67 degC, P: 1 atm
    flow (kmol/hr): Water     1e+03
                    Glycerol  300
outs...
[0] vapor
    phase: 'g', T: 137 degC, P: 1 atm
    flow (kmol/hr): Water     958
                    Glycerol  2.32
[1] crude_glycerin
    phase: 'l', T: 137 degC, P: 1 atm
    flow (kmol/hr): Water     42.4
                    Glycerol  298
>>> F1.results()
Flash                                                   Units            F1
Medium pressure steam Duty                              kJ/hr      4.81e+07
                      Flow                            kmol/hr      1.33e+03
                      Cost                             USD/hr           366
Design                Vessel type                                Horizontal
                      Length                               ft          8.46
                      Diameter                             ft           5.5
                      Weight                               lb      2.51e+03
                      Wall thickness                       in         0.312
                      Vessel material                          Carbon steel
Purchase cost         Horizontal pressure vessel          USD      1.47e+04
                      Platform and ladders                USD      3.22e+03
                      Heat exchanger - Floating head      USD      4.48e+04
Total purchase cost                                       USD      6.26e+04
Utility cost                                           USD/hr           366

References

auxiliary_unit_names: tuple[str, ...] = ('heat_exchanger', 'vacuum_system')#: class-attribute Name of attributes that are auxiliary units. These units will be accounted for in the purchase and installed equipment costs without having to add these costs in the baseline_purchase_costs dictionary. Heat and power utilities are also automatically accounted for.

property P#: Operating pressure (Pa).

property vapor#: Outlet vapor stream (equivalent to outs[0]).

property liquid#: Outlet liquid stream (equivalent to outs[1]).

line: str = 'Flash'#: class-attribute Name denoting the type of Unit class. Defaults to the class name of the first child class

heat_utilities: list[HeatUtility, ...]#: All heat utilities associated to unit. Cooling and heating requirements are stored here (including auxiliary requirements).

power_utility: PowerUtility#: Electric utility associated to unit (including auxiliary requirements).

F_BM: dict[str, float]#: All bare-module factors for each purchase cost. Defaults to values in the class attribute _F_BM_default.

F_D: dict[str, float]#: All design factors for each purchase cost item in baseline_purchase_costs.

F_P: dict[str, float]#: All pressure factors for each purchase cost item in baseline_purchase_costs.

F_M: dict[str, float]#: All material factors for each purchase cost item in baseline_purchase_costs.

design_results: dict[str, object]#: All design requirements excluding utility requirements and detailed auxiliary unit requirements.

baseline_purchase_costs: dict[str, float]#: All baseline purchase costs without accounting for design, pressure, and material factors.

purchase_costs: dict[str, float]#: Itemized purchase costs (including auxiliary units) accounting for design, pressure, and material factors (i.e., F_D, F_P, F_M). Items here are automatically updated at the end of unit simulation.

installed_costs: dict[str, float]#: All installed costs accounting for bare module, design, pressure, and material factors. Items here are automatically updated at the end of unit simulation.

equipment_lifetime: int | dict[str, int]#: Lifetime of equipment. Defaults to values in the class attribute _default_equipment_lifetime. Use an integer to specify the lifetime for all items in the unit purchase costs. Use a dictionary to specify the lifetime of each purchase cost item.

run_after_specifications: bool#: Whether to run mass and energy balance after calling specification functions

prioritize: bool#: Whether to prioritize unit operation specification within recycle loop (if any).

parallel: dict[str, int]#: Name-number pairs of baseline purchase costs and auxiliary unit operations in parallel. Use ‘self’ to refer to the main unit. Capital and heat and power utilities in parallel will become proportional to this value.

responses: set[GenericResponse]#: Unit design decisions that must be solved to satisfy specifications. While adding responses is optional, simulations benefit from responses by being able to predict better guesses.