finish new indexer internals

biosteam/_system.py

@@ -1056,6 +1056,7 @@ def __init__(self,
         self._set_facility_recycle(facility_recycle)
         self._register(ID)
         self._save_configuration()
+        self._load_stream_links()
         self._state = None
         self._state_idx = None
         self._state_header = None
@@ -1201,6 +1202,7 @@ def __exit__(self, type, exception, traceback):
             raise RuntimeError('system cannot be modified before exiting `with` statement')
         else:
             self.update_configuration(dump)
+            self._load_stream_links()
             self.set_tolerance(
                 algorithm=self._algorithm,
                 method=self._method,
@@ -1346,6 +1348,9 @@ def set_tolerance(self, mol: Optional[float]=None, rmol: Optional[float]=None,
     set_outlet = MockSystem.set_outlet
     _load_flowsheet  = MockSystem._load_flowsheet
 
+    def _load_stream_links(self):
+        for u in self.units: u._load_stream_links()
+
     @property
     def TEA(self) -> TEA:
         """TEA object linked to the system."""
@@ -2334,6 +2339,7 @@ def _setup(self, update_configuration=False, units=None, load_configuration=True
             self._setup_units()
             self._remove_temporary_units()
             self._save_configuration()
+            self._load_stream_links()
         else:
             if load_configuration: self._load_configuration()
             self._create_temporary_connections()

biosteam/_unit.py

@@ -254,6 +254,9 @@ def __init_subclass__(cls,
     #: flexible operation (e.g., filtration membranes).
     _materials_and_maintenance: frozenset[str] = frozenset()
 
+    #: **class-attribute** Wether to link inlet and outlet streams.
+    _link_streams: bool = False
+
     #: **class-attribute** Lifetime of equipment. Defaults to lifetime of
     #: production venture. Use an integer to specify the lifetime for all
     #: items in the unit purchase costs. Use a dictionary to specify the 
@@ -317,6 +320,7 @@ def _create_material_balance_equations(self, composition_sensitive):
         list[tuple[dict, array]] Create material balance equations for 
         phenomena-oriented simulation.
         """
+        if self._link_streams: return []
         fresh_inlets, process_inlets, equations = self._begin_equations(composition_sensitive)
         outs = self.flat_outs
         N = self.chemicals.size
@@ -1153,6 +1157,9 @@ def reset_cache(self, isdynamic=None):
     def _get_design_info(self): 
         return ()
 
+    def _load_stream_links(self):
+        if self._link_streams: self._outs[0].link_with(self._ins[0])
+
     def _reevaluate(self):
         """Reevaluate design/cost/LCA results."""
         self._setup()
@@ -1294,6 +1301,7 @@ def simulate(self,
         self._check_setup()
         if run is None or run:
             for ps in self._specifications: ps.compile_path(self)
+            self._load_stream_links()
             self.run()
         self._summary(design_kwargs, cost_kwargs)
 

biosteam/units/_duplicator.py

@@ -64,3 +64,5 @@ def _load_stream_links(self):
         duplicated_outs = self.outs
         for stream in duplicated_outs:
             stream.link_with(feed)
+
+    def _run(self): pass

biosteam/units/_flash.py

@@ -668,7 +668,11 @@ def _run(self):
                 elif V > 1:
                     vapor.imol[chemical_ID] = f
                     liquid.imol[chemical_ID] = 0
-                    vapor.H = H
+                    try:
+                        vapor.H = H
+                    except RuntimeError: # Extrapolation failed
+                        vapor.phase = 'g'
+                        vapor.T = vapor.chemicals[chemical_ID].Tc
                 else:
                     vapor.imol[chemical_ID] = f * V
                     liquid.imol[chemical_ID] = (1 - V) * f

biosteam/units/aerated_bioreactor.py

@@ -587,11 +587,7 @@ def load_flow_rates(F_feeds):
             vent.empty()
             self._run_vent(vent, effluent)
 
-        try:
-            baseline_feed = bst.Stream.sum(self.normal_gas_feeds, energy_balance=False)
-        except:
-            breakpoint()
-            bst.Stream.sum(self.normal_gas_feeds, energy_balance=False)
+        baseline_feed = bst.Stream.sum(self.normal_gas_feeds, energy_balance=False)
         baseline_flows = baseline_feed.get_flow('mol/s', self.gas_substrates)
         bounds = np.array([[max(1.01 * SURs[i] - baseline_flows[i], 0), 10 * SURs[i]] for i in index])
         if self.optimize_power:
@@ -614,8 +610,9 @@ def gas_flow_rate_objective(F_substrates):
                 mask = STRs - F_ins > 0
                 STRs[mask] = F_ins[mask]
                 diff = SURs - STRs
-                diff[diff > 0] *= 1e6 # Force transfer rate to meet uptake rate
-                return (diff * diff).sum()
+                diff[diff > 0] *= 1e3 # Force transfer rate to meet uptake rate
+                SE = (diff * diff).sum()
+                return SE
 
             f = gas_flow_rate_objective
             with catch_warnings():

biosteam/units/heat_exchange.py

@@ -490,9 +490,9 @@ def total_heat_transfer(self):
     Q = total_heat_transfer  # Alias for backward compatibility
 
     def simulate_as_auxiliary_exchanger(self,
-                                        ins, outs=None, duty=None, vle=True, scale=None, hxn_ok=True,
-                                        P_in=None, P_out=None, update=False,
-                                        ):
+            ins, outs=None, duty=None, vle=True, scale=None, hxn_ok=True,
+            P_in=None, P_out=None, update=False,
+        ):
         inlet = self.ins[0]
         outlet = self.outs[0]
         if not inlet:

biosteam/utils/stream_link_options.py

@@ -7,29 +7,32 @@
 # for license details.
 """
 """
+from collections import namedtuple
 
 __all__ = ('static',
            'static_flow_and_phase')
 
 # %% Linking options
 
+
 def _run_static(self):
     self._outs[0].copy_like(self._ins[0])
 
-def _run_static_flow_and_phase(self):
+def static(cls=None):
+    if cls is None: return lambda cls: static(cls)
+    cls._link_streams = True
+    cls._run = _run_static
+    return cls
+
+def _run_static_flow(self):
     outlet = self._outs[0]
     inlet = self._ins[0]
     outlet.phases = inlet.phases
     outlet.copy_flow(inlet)
 
-def static(cls=None):
-    if cls is None: return lambda cls: static(cls)
-    if '_run' not in cls.__dict__:
-        cls._run = _run_static
-    return cls
-
 def static_flow_and_phase(cls):
     cls._N_ins = cls._N_outs = 1
-    if '_run' not in cls.__dict__:
-        cls._run = _run_static_flow_and_phase
+    if '_run' not in cls.__dict__: cls._run = cls._run_static_flow
     return cls
+
+del namedtuple

tests/test_unit.py

@@ -131,10 +131,13 @@ def adjust_flow_rate():
     H1.add_specification(lambda: None, run=True, impacted_units=[T2])
     H2.add_specification(lambda: None, run=True, impacted_units=[T1])
     sys.simulate()
-    assert sys.unit_path.index(H1) < sys.unit_path.index(T2)
-    assert H1.specifications[0].path == []
-    assert H2.specifications[0].path == [T1, H1, T2]
-    # Net simulation order is ..., T2, H2, T1, H1, T2, H2, ...
+    if sys.unit_path.index(H1) < sys.unit_path.index(T2):
+        assert H1.specifications[0].path == []
+        assert H2.specifications[0].path == [T1, H1, T2]
+        # Net simulation order is ..., T2, H2, T1, H1, T2, H2, ...
+    else:
+        assert H1.specifications[0].path == [T2, H2, T1]
+        assert H2.specifications[0].path == []
 
 def test_process_specifications_with_recycles():
     bst.F.set_flowsheet('bifurcated_recycle_loops')