File size: 10,818 Bytes
eb1a751 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 | Quickstart
==========
The canonical hensmith example is a small methanol/water system: a shortcut
distillation column (divided into a separately-costed rectifier and stripper)
whose condenser and reboiler are auxiliary exchangers, a cooler on each of the
column's two products, and a flash whose feed is heated by its own auxiliary
exchanger. A
:class:`~hensmith.HeatExchangerNetwork` facility added to that system
integrates every heating and cooling utility in it. Once biosteam is imported
the simulation takes about a second, and every number, table and figure below
is output of the code shown on this page.
Build the flowsheet
-------------------
.. literalinclude:: /../_demo_src/examples/ch01_quickstart.py
:language: python
:start-after: # [start:build]
:end-before: # [end:build]
:dedent:
``bst.settings.set_thermo`` fixes the chemicals and the property package used
for every stream that follows; ``cache=True`` reuses cached chemical objects
rather than recreating them. The two feeds are given as molar flow rates in
kmol/hr, in the order the chemicals were declared: ``feed1`` is 8000 water,
100 methanol and 25 glycerol, and ``feed2`` is 10000 water, 1000 methanol and
10 glycerol.
``D1`` separates methanol (light key) from water (heavy key) with a shortcut
method. Its condenser and reboiler are always auxiliary ``HXutility`` units of
the column, each with its own heat utility, and the network integrates each of
them like any other exchanger. ``is_divided=True`` costs the rectifier and
stripper as two separate vessels rather than one, and matches the
:class:`~hensmith.HeatExchangerNetwork` docstring example. ``D1_H1`` and
``D1_H2`` cool the bottoms product and the distillate to 300 K, and each is a
stand-alone exchanger in its own right. ``F1`` flashes ``feed2`` to 90 % vapor
at 101325 Pa; the heating its feed needs is carried by an auxiliary exchanger
of the flash, created when the flash is constructed and simulated as part of
the flash's own run.
Add the network
---------------
.. literalinclude:: /../_demo_src/examples/ch01_quickstart.py
:language: python
:start-after: # [start:network]
:end-before: # [end:network]
:dedent:
``T_min_app=5.`` is the minimum approach temperature in K: no synthesized
process exchanger is allowed to transfer heat across a temperature difference
smaller than this. It is the one thermodynamic knob that sets how much
integration is feasible, and it is revisited in :doc:`02_pinch_analysis`.
``bst.System.from_units`` builds the system from the units given, sorting the
process units into a simulation order and setting the facility aside; the
network is listed among the units but is not connected to any of them.
.. code-block:: python
sys.diagram()
.. figure:: /_static/images/examples/tutorial_01_quickstart_flowsheet_light.png
:figclass: only-light
:width: 720
:alt: Flowsheet of the quickstart system: feed1 enters the divided distillation column D1, whose distillate and bottoms product go to the heat exchangers D1_H2 and D1_H1; feed2 enters the flash F1, which produces vapor and liquid; the HXN heat exchanger network sits apart as an unconnected block.
The quickstart system. ``HXN`` appears as a facility with no material
streams: it neither receives nor produces process material, and only reads
the heat utilities of the other units. Besides the two visible exchangers
``D1_H1`` and ``D1_H2``, the column's condenser and reboiler and the flash's
feed exchanger are auxiliary exchangers inside their owner units, and the
network integrates those as well -- 5 streams in total, of which 3 are
auxiliaries.
.. figure:: /_static/images/examples/tutorial_01_quickstart_flowsheet_dark.png
:figclass: only-dark
:width: 720
:alt: Flowsheet of the quickstart system: feed1 enters the divided distillation column D1, whose distillate and bottoms product go to the heat exchangers D1_H2 and D1_H1; feed2 enters the flash F1, which produces vapor and liquid; the HXN heat exchanger network sits apart as an unconnected block.
The quickstart system. ``HXN`` appears as a facility with no material
streams: it neither receives nor produces process material, and only reads
the heat utilities of the other units. Besides the two visible exchangers
``D1_H1`` and ``D1_H2``, the column's condenser and reboiler and the flash's
feed exchanger are auxiliary exchangers inside their owner units, and the
network integrates those as well -- 5 streams in total, of which 3 are
auxiliaries.
Because :class:`~hensmith.HeatExchangerNetwork` is a BioSTEAM ``Facility``, it
is simulated only after every process unit in the system has converged, so it
always works with final duties. Its ``network_priority = -2`` is the lowest of
the standard facilities, which places it first among them: the chilled water
package, cooling tower and boiler that follow are then sized on the loads the
network has already reduced.
Simulate
--------
.. literalinclude:: /../_demo_src/examples/ch01_quickstart.py
:language: python
:start-after: # [start:simulate]
:end-before: # [end:simulate]
:dedent:
Converging the process units comes first; the network's pinch analysis,
synthesis and costing all run afterwards, in its costing step. The original
streams and heat exchangers of the system are left untouched -- the stream
copies and the new exchangers the network creates live in a separate flowsheet
named ``sys_HXN``, after the ID of the system.
Read the savings
----------------
.. literalinclude:: /../_demo_src/examples/ch01_quickstart.py
:language: python
:start-after: # [start:results]
:end-before: # [end:results]
:dedent:
.. literalinclude:: /_generated/ch01_results.txt
:language: text
Every utility row of this table is a *difference*, not a requirement: the
facility's ``heat_utilities`` are the utilities of the new network summed with
the reversed original ones, that is new - original. A negative cost is
therefore a saving, and all three agents show one here: -389 USD/hr of low
pressure steam, -211 USD/hr of chilled water and -5.98 USD/hr of cooling water,
for a total utility cost of -605 USD/hr. The flow rows are negative for all
three agents as well, so less of each utility is consumed. The duty rows carry
the sign convention of the agent they belong to: the steam duty is
-6.32e+07 kJ/hr, exactly the reduction in heating load reported below, while
the chilled and cooling water duties are positive (4.21e+07 and
1.79e+07 kJ/hr) because cooling duties are negative to begin with, so a
positive difference again means less cooling.
The capital rows are differences too, but clipped at zero. Both the network's
``installed_costs['Heat exchangers']`` and ``purchase_costs['Heat exchangers']``
are ``max(0, new - original)``, the *added* exchanger cost -- 1.11e+06 USD
here. Clipping at zero means a network
whose exchangers happen to be cheaper than the ones it replaces is reported as
adding nothing, rather than as a capital credit.
.. literalinclude:: /../_demo_src/examples/ch01_quickstart.py
:language: python
:start-after: # [start:loads]
:end-before: # [end:loads]
:dedent:
.. literalinclude:: /_generated/ch01_loads.txt
:language: text
The heating load falls from 3.609e+08 to 2.977e+08 kJ/hr, a reduction of
17.5 %; the ratio of the two, 0.82, is the value checked by the
:class:`~hensmith.HeatExchangerNetwork` docstring example. The cooling load
falls from 6.201e+07 to 1.936e+06 kJ/hr, a reduction of 96.9 %: nearly all of
the cooling duty of this system can be recovered into a stream that needed
heating. Four process exchangers do that work, and they are the ``new_HXs`` of
the network. The energy balance error, -1.8e-11 %, checks that the synthesized
network moves exactly as much heat as the original one; it is computed on
every synthesis and compared against ``acceptable_energy_balance_error``.
The last line is the verdict of the synthesis, ``HXN.synthesis_info['status']``:
``mer`` means that the utilities of this network equal the minimum energy
requirement (MER) targets of the pinch analysis -- no network of process
exchangers operating with a 5 K approach can use less heating or cooling.
:doc:`02_pinch_analysis` computes those targets and compares them with the
network line by line.
Draw the pinch diagram
----------------------
.. literalinclude:: /../_demo_src/examples/ch01_quickstart.py
:language: python
:start-after: # [start:pinch]
:end-before: # [end:pinch]
:dedent:
.. figure:: /_static/images/examples/tutorial_01_quickstart_pinch_diagram.png
:class: white-bg
:width: 100%
:alt: Pinch diagram of the synthesized quickstart network: two blue cold streams above three red hot streams, joined by four vertical process-exchanger connectors labelled 5.05E6, 3.71E7, 3.34E4 and 1.79E7 kJ/hr, all to the right of the dashed pinch line, with hot utility circles at the outlet of both cold streams and one cold utility circle on the hot stream D1_H1 (bottoms_product).
The synthesized network, read as a pinch diagram. The two cold streams
(blue, drawn left to right) are ``0`` ``D1 - reboiler`` and ``1``
``F1 - heat_exchanger (feed2)``; the three hot streams (red, drawn right to
left) are ``2`` ``D1_H1 (bottoms_product)``, ``3``
``D1 - condenser (vapor)`` and ``4`` ``D1_H2 (distillate)``. Each stream is
annotated with its inlet and outlet temperature and enthalpy flow. The four
vertical connectors are the process exchangers, each labelled with its duty
in kJ/hr: 5.05E6 between streams 1 and 2, 3.71E7 between 0 and 2, 3.34E4
between 1 and 4, and 1.79E7 between 1 and 3. Columns are ordered so that a
stream meets its exchangers in flow direction, which is why stream 1 reads
5.05E6, 3.34E4, 1.79E7 from left to right. The dashed line is the pinch,
separating the cold-side design on its left from the hot-side design on its
right; all four exchangers of this network lie on the hot side. The open
circles are the utility exchangers that finish each stream: a hot utility
(red) at the outlet of both cold streams, and a single cold utility (blue)
on stream 2. Streams 3 and 4 carry no circle because their remaining
cooling duty is zero -- process heat exchange alone brings them to their
outlet temperature.
Where to next
-------------
- :doc:`02_pinch_analysis` -- where the utility targets above come from, and
what ``T_min_app`` changes.
- :doc:`03_network_anatomy` -- the exchangers and stream life cycles behind
the diagram, unit by unit.
- :doc:`04_configuring` -- the constructor options of the facility, and
applying it to a larger system.
- :doc:`../concepts` -- the pinch concepts and terminology used throughout.
- :doc:`../API/api` -- the full API reference.
|