class BoilerTurbogenerator(ID='', ins=None, outs=('emissions', 'rejected_water_and_blowdown', 'ash_disposal'), thermo=None, *, boiler_efficiency=None, turbogenerator_efficiency=None, side_steam=None, agent=None, other_agents=None, natural_gas_price=None, ash_disposal_price=None, T_emissions=None, satisfy_system_electricity_demand=None, boiler_efficiency_basis=None)[source]#

Create a BoilerTurbogenerator object that will calculate electricity generation from burning the feed. It also takes into account how much steam is being produced, and the required cooling utility of the turbo generator. All capital cost correlations are based on [1].

  • ins (Stream], optional) –

    • [0] Liquid/solid feed that will be burned.

    • [1] Gas feed that will be burned.

    • [2] Make-up water.

    • [3] Natural gas to satisfy steam and power requirement.

    • [4] Lime for flue gas desulfurization.

    • [5] Boiler chemicals.

  • outs (Stream], optional) –

    • [0] Total emissions produced.

    • [1] Blowdown water.

    • [2] Ash disposal.

  • boiler_efficiency (float, optional) – Fraction of heat transferred to steam. Defaults to 0.8.

  • turbo_generator_efficiency (float, optional) – Fraction of steam heat converted to electricity. Defaults to 0.85.

  • agent (UtilityAgent, optional) – Steam produced. Defaults to low pressure steam.

  • () (other_agents =) – Other steams produced. Defaults to all other heating agents.

  • natural_gas_price (float, optional) – Price of natural gas [USD/kg]. Same as bst.stream_utility_prices[‘Natural gas’], which defaults to 0.218.

  • ash_disposal_price (float, optional) – Price of disposing ash [USD/kg]. Same as bst.stream_utility_prices[‘Ash disposal’], which defaults to -0.0318.

  • satisfy_system_electricity_demand (bool, optional) – Whether to purchase natural gas to satisfy system electricity demand if there is not enough heat from process feeds (i.e., inlets 0 and 1). If True, natural gas is purchased to satisfy system heat and electricity demand when there is not enough heat from the feed and gas. If False, natural gas is only purchased to satisfy system heat demand and electricity will be purchased from the grid if there is not enough heat from the feeds. In either case, if there is excess heat from the process feeds, electricity will still be produced.

  • boiler_efficiency_basis (str, optional) – Basis of boiler efficiency. Defaults to ‘LHV’ (i.e., lower heating value). ‘HHV’ (i.e., higher heating value) is also a valid basis.


Create a boiler-turbogenerator system that uses sugarcane bagasse to produce steam for a distillation unit and any excess steam for surplus electricity:

>>> import biosteam as bst
>>> from biorefineries import cane
>>> chemicals = cane.create_sugarcane_chemicals()
>>> chemicals.define_group(
...     name='Fiber',
...     IDs=['Cellulose', 'Hemicellulose', 'Lignin'],
...     composition=[0.4704 , 0.2775, 0.2520],
...     wt=True, # Composition is given as weight
... )
>>> bst.settings.set_thermo(chemicals)
>>> dilute_ethanol = bst.Stream('dilute_ethanol', Water=1390, Ethanol=590)
>>> bagasse = bst.Stream('bagasse', Water=0.4, Fiber=0.6, total_flow=8e4, units='kg/hr')
>>> with bst.System('sys') as sys:
...     D1 = bst.BinaryDistillation('D1', ins=dilute_ethanol, Lr=0.999, Hr=0.89, k=1.25, LHK=('Ethanol', 'Water'))
...     BT = bst.BoilerTurbogenerator('BT')
...     BT.ins[0] = bagasse
>>> sys.simulate()
>>> BT.results() # Steam and electricity are produced, so costs are negative
Boiler turbogenerator                                      Units        BT
Electricity           Power                                   kW -1.31e+05
                      Cost                                USD/hr -1.02e+04
Low pressure steam    Duty                                 kJ/hr -7.32e+07
                      Flow                               kmol/hr -1.89e+03
                      Cost                                USD/hr      -450
Cooling water         Duty                                 kJ/hr -8.42e+07
                      Flow                               kmol/hr  5.75e+04
                      Cost                                USD/hr      28.1
Natural gas (inlet)   Flow                                 kg/hr         0
                      Cost                                USD/hr         0
Ash disposal (outlet) Flow                                 kg/hr     0.737
                      Cost                                USD/hr    0.0234
Design                Flow rate                            kg/hr  2.93e+05
                      Work                                    kW  1.33e+05
                      Ash disposal                         kg/hr     0.737
Purchase cost         Baghouse bags                          USD      81.1
                      Boiler                                 USD  3.33e+07
                      Deaerator                              USD  3.58e+05
                      Amine addition pkg                     USD  4.69e+04
                      Hot process water softener system      USD  9.16e+04
                      Turbogenerator                         USD  1.94e+07
Total purchase cost                                          USD  5.32e+07
Utility cost                                              USD/hr -1.07e+04


The flow rate of natural gas, lime, and boiler chemicals (streams 3-5) is set by the BoilerTurbogenerator object during simulation.


property makeup_water#

[Stream] Makeup water due to boiler blowdown.

property natural_gas#

[Stream] Natural gas to satisfy steam and electricity requirements.

property ash_disposal#

[Stream] Ash disposal.

property natural_gas_price#

[Float] Price of natural gas, same as bst.stream_utility_prices[‘Natural gas’].

property ash_disposal_price#

[Float] Price of ash disposal, same as bst.stream_utility_prices[‘Ash disposal’].

line: str = 'Boiler turbogenerator'#

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.