improve size_batch func and add documentation; also add N reactor option to bioreactos

Author: yoelcortes

biosteam/_system.py

@@ -3853,7 +3853,7 @@ def get_product_impact(self,
 
         .. code-block:: python
             
-           >>> bst.settings.define_impact_indicator('GWP', 'kgCO2e')
+           >>> bst.settings.define_impact_indicator('GWP', 'kg*CO2e')
            >>> system.get_property_allocated_impact(
            ...     product, key='GWP', allocation_method='mass', basis='kg'
            ... ) # -> GWP [kgCO2e / kg-product]
@@ -3910,7 +3910,7 @@ def get_property_allocated_impact(self, key, name, basis=None, ignored=None, pro
 
         .. code-block:: python
             
-           >>> bst.settings.define_impact_indicator('GWP', 'kgCO2e')
+           >>> bst.settings.define_impact_indicator('GWP', 'kg*CO2e')
            >>> system.get_property_allocated_impact(
            ...     key='GWP', name='mass', basis='kg'
            ... ) # -> GWP [kgCO2e / kg-products]

biosteam/units/abstract_stirred_tank_reactor.py

@@ -65,7 +65,7 @@ class AbstractStirredTankReactor(PressureVessel, Unit, isabstract=True):
         Defaults to `continuous`.
     tau_0 : 
         Cleaning and unloading time (if batch mode). Defaults to 3 hr.
-    N_reactors :
+    N :
         Number of reactors.
     heat_exchanger_configuration : 
         What kind of heat exchanger to default to (if any). Valid options include 
@@ -77,6 +77,8 @@ class AbstractStirredTankReactor(PressureVessel, Unit, isabstract=True):
     loading_time :
         Loading time of batch reactor. If not given, it will assume each vessel is constantly
         being filled.
+    N_vessels :
+        Number of vessels.
 
     Notes
     -----
@@ -232,6 +234,9 @@ class AbstractStirredTankReactor(PressureVessel, Unit, isabstract=True):
     #: Default maximum volume of a reactor in m3.
     V_max_default: float = 355
 
+    #: Default number of vessels.
+    N_default: Optional[int] = None
+    
     #: Default length to diameter ratio.
     length_to_diameter_default: float = 3
 
@@ -283,10 +288,16 @@ def _init(
             jacket_annular_diameter: Optional[float]=None,
             reactions: Optional[bst.ReactionSystem]=None,
             loading_time: Optional[float]=None,
+            N: Optional[int]=None, 
         ):
         if adiabatic is None: adiabatic = False
         self.adiabatic = adiabatic
         self.reactions = reactions
+        self.N = (
+            self.N_default 
+            if (N is None and not adiabatic) else 
+            N
+        )
         self.T = (
             self.T_default 
             if (T is None and not adiabatic) else 
@@ -414,23 +425,27 @@ def _design(self, size_only=False):
             tau_0 = self.tau_0
             V_wf = self.V_wf
             Design = self.design_results
-            V_max = self.V_max
-            N = v_0 / V_max / V_wf * (tau + tau_0) + 1
-            if N < 2:
-                N = 2
-            else:
-                N = ceil(N)
-            Design.update(size_batch(v_0, tau, tau_0, N, V_wf, self.loading_time))
+            Design.update(
+                size_batch(
+                    v_0, tau, tau_0, V_wf, 
+                    self.V_max, self.N, self.loading_time
+                )
+            )
             V_reactor = Design['Reactor volume']
+            N = Design['Number of reactors']
         else:
-            V_total = ins_F_vol * self.tau / self.V_wf
-            N = ceil(V_total/self.V_max)
-            if N == 0:
-                V_reactor = 0
+            if self.N is None:
+                V_total = ins_F_vol * self.tau / self.V_wf
+                N = ceil(V_total/self.V_max)
+                if N == 0:
+                    V_reactor = 0
+                else:
+                    V_reactor = V_total / N
             else:
-                V_reactor = V_total / N
+                V_total = ins_F_vol * self.tau / self.V_wf
+                V_reactor = V_total / self.N
             Design['Reactor volume'] = V_reactor
-        self.N_reactors = N
+            Design['Number of reactors'] = N
         D = cylinder_diameter_from_volume(V_reactor, self.length_to_diameter)
         D *= 3.28084 # Convert from m to ft
         L = D * length_to_diameter

biosteam/units/aerated_bioreactor.py

@@ -90,7 +90,7 @@ class AeratedBioreactor(AbstractStirredTankReactor):
         Defaults to `continuous`.
     tau_0 : 
         Cleaning and unloading time (if batch mode). Defaults to 3 hr.
-    N_reactors :
+    N :
         Number of reactors.
     heat_exchanger_configuration : 
         What kind of heat exchanger to default to (if any). Valid options include 
@@ -550,7 +550,7 @@ class GasFedBioreactor(AbstractStirredTankReactor):
         Defaults to `continuous`.
     tau_0 : 
         Cleaning and unloading time (if batch mode). Defaults to 3 hr.
-    N_reactors :
+    N :
         Number of reactors.
     heat_exchanger_configuration : 
         What kind of heat exchanger to default to (if any). Valid options include 

biosteam/units/anaerobic_bioreactor.py

@@ -56,7 +56,7 @@ class AnaerobicBioreactor(AbstractStirredTankReactor):
         Defaults to `continuous`.
     tau_0 : 
         Cleaning and unloading time (if batch mode). Defaults to 3 hr.
-    N_reactors :
+    N :
         Number of reactors.
     heat_exchanger_configuration : 
         What kind of heat exchanger to default to (if any). Valid options include 

biosteam/units/design_tools/batch.py

@@ -9,10 +9,13 @@
 General functional algorithms for batch design.
 
 """
+from math import ceil
+from flexsolve import wegstein
 
 __all__ = ('size_batch',)
 
-def size_batch(F_vol, tau_reaction, tau_cleaning, N_reactors, V_wf, loading_time=None) -> dict:
+def size_batch(F_vol, tau_reaction, tau_cleaning, V_wf, 
+               V_max=None, N_reactors=None, loading_time=None) -> dict:
     r"""
     Solve for batch reactor volume, cycle time, and loading time.
     
@@ -24,10 +27,12 @@ def size_batch(F_vol, tau_reaction, tau_cleaning, N_reactors, V_wf, loading_time
         Reaction time.
     tau_cleaning : float
         Cleaning in place time.
-    N_reactors : int
-        Number of reactors.
     V_wf : float
         Fraction of working volume.
+    V_max : int
+        Maximum volume of a reactor.
+    N_reactors : int
+        Number of reactors.
     loading_time :
         Loading time of batch reactor. If not given, it will assume each vessel is constantly
         being filled.
@@ -44,24 +49,34 @@ def size_batch(F_vol, tau_reaction, tau_cleaning, N_reactors, V_wf, loading_time
     By assuming no downtime, the total volume of all reactors is:
         
     .. math::
+        
         V_T = F_{vol}(\tau_{reaction} + \tau_{cleaning} + \tau_{loading})
         
-    where :math:`V_T` is the total volume of all reactors, :math:`F_{vol}` is the 
+    where :math:`V_T` is the total volume required, :math:`F_{vol}` is the 
     volumetric flow rate of the feed, :math:`\tau_{reaction}` is the 
     reaction time, :math:`\tau_{cleaning}` is the cleaning and unloading time, 
     and :math:`\tau_{loading}` is the time required to load a vessel. This
     equation makes the conservative assumption that no reaction takes place 
     when the tank is being filled.
     
+    The number of reactors is:
+    
+    .. math::
+        
+        N_{reactors} = ceil(\frac{V_T}{V_{max} \cdot V_{wf}})
+    
+    where :math:`N_{reactors}` is the number of reactor vessels, 
+    :math:`V_{max}` is the maximum reactor volume, and 
+    :math:`V_{wf}` is the fraction of working volume in a reactor.
+    
     The working volume of an individual reactor is:
     
     .. math::
     
         V_{i,working} = \frac{V_T}{N_{reactors}}
     
-    where :math:`N_{reactors}` is the number of reactor vessels.
-    
-    The time required to load a reactor (assuming no downtime) is:
+    If there is no upstream storage and a vessel is constantly being filled,
+    the time required to load a reactor is:
         
     .. math::
 
@@ -72,39 +87,116 @@ def size_batch(F_vol, tau_reaction, tau_cleaning, N_reactors, V_wf, loading_time
     .. math::
 
         V_i = \frac{V_{i,working}}{f}
-        
-    where f is the fraction of working volume in a reactor.
     
     Plugging in and solving for the total volume, :math:`V_{T}`, we have: 
     
     .. math::
 
         V_T = F_{vol}\frac{\tau_{reaction} + \tau_{cleaning}}{1 - \frac{1}{N_{reactors}}}
     
-    Using this equation, :math:`V_T` is first calculated, then :math:`V_{i, working}`, 
-    :math:`\tau_{loading}`, and :math:`V_i`.
+    If the number of reactors is specified but not the loading time, :math:`V_T` is first calculated, 
+    then :math:`V_{i, working}`, :math:`\tau_{loading}`, and :math:`V_i`. 
+    
+    If neither the number of reactors nor the loading time are specified, we solve the equations iteratively
+    until :math:`\tau_{loading}` converges.
+    
+    If the loading time is given but not the number of reactors, 
+    then the equation for :math:`tau_{loading}` does not apply and 
+    we first compute :math:`N_reactors` given :math:`V_{max}.
     
     Units of measure may vary so long as they are consistent. The loading time
     can be considered the cycle time in this scenario.
     
+    Examples
+    --------
+    Size batch given a maximum reactor volume of 1,000 m3 and zero loading time:
+    
+    >>> from biosteam.units.design_tools import size_batch
+    >>> F_vol = 1e3; tau_reaction = 30; tau_cleaning = 3; V_wf = 0.95
+    >>> size_batch(
+    ...     F_vol, tau_reaction, tau_cleaning, V_wf, 
+    ...     V_max=1e3, loading_time=0
+    ... )
+    {'Reactor volume': 992.48,
+     'Batch time': 33,
+     'Loading time': 0,
+     'Number of reactors': 35}
+    
+    Size batch given 35 reactors and zero loading time:
+    
+    >>> size_batch(
+    ...     F_vol, tau_reaction, tau_cleaning, V_wf, 
+    ...     N_reactors=35, loading_time=0
+    ... )
+    {'Reactor volume': 992.48,
+     'Batch time': 33,
+     'Loading time': 0,
+     'Number of reactors': 35}
+    
+    Size batch given a maximum reactor volume of 1,000 m3 and assume
+    the constant loading:
+    
+    >>> size_batch(
+    ...     F_vol, tau_reaction, tau_cleaning, V_wf, 
+    ...     V_max=1000,
+    ... )    
+    {'Reactor volume': 992.4812030075188,
+     'Batch time': 33.94285714285714,
+     'Loading time': 0.9428571428571428,
+     'Number of reactors': 36}
+    
+    Size batch given 36 reactors and assume
+    the constant loading:
+    
+    >>> size_batch(
+    ...     F_vol, tau_reaction, tau_cleaning, V_wf, 
+    ...     N_reactors=36
+    ... )    
+    {'Reactor volume': 992.4812030075188,
+     'Batch time': 33.94285714285714,
+     'Loading time': 0.9428571428571428,
+     'Number of reactors': 36}
+    
+    
     """
+    if sum([i is None for i in [N_reactors, V_max]]) != 1:
+        raise ValueError('must pass either `N_reactors` or `V_max`')
     if loading_time is None:
-        # Total volume of all reactors, assuming no downtime
-        V_T = F_vol * (tau_reaction + tau_cleaning) / (1 - 1 / N_reactors)
-        
-        # Volume of an individual reactor
-        V_i = V_T/N_reactors
-        
-        # Time required to load a reactor
-        tau_loading = V_i/F_vol
+        if N_reactors is None:
+            # Solve iteratively
+            def f(tau_loading):
+                N_reactors = ceil(F_vol * (tau_reaction + tau_cleaning + tau_loading) / (V_max * V_wf))
+                if N_reactors == 1: N_reactors = 2 # Minimum
+                V_T = F_vol * (tau_reaction + tau_cleaning) / (1 - 1 / N_reactors)
+                V_i = V_T/N_reactors
+                tau_loading = V_i/F_vol
+                return tau_loading
+            
+            tau_loading = wegstein(f, 0)
+            N_reactors = ceil(F_vol * (tau_reaction + tau_cleaning + tau_loading) / (V_max * V_wf))
+            V_T = F_vol * (tau_reaction + tau_cleaning + tau_loading)
+            V_i = V_T / N_reactors
+        else:
+            # Total volume of all reactors, assuming no downtime
+            V_T = F_vol * (tau_reaction + tau_cleaning) / (1 - 1 / N_reactors)
+            
+            # Volume of an individual reactor
+            V_i = V_T / N_reactors
+            
+            # Time required to load a reactor
+            tau_loading = V_i / F_vol
     else:
         tau_loading = loading_time
 
+        if N_reactors is None:
+            # Number of reactors
+            N_reactors = ceil(F_vol * (tau_reaction + tau_cleaning + tau_loading) / (V_max * V_wf))
+
         # Total volume of all reactors
         V_T = F_vol * (tau_reaction + tau_cleaning + tau_loading)
 
         # Volume of an individual reactor
-        V_i = V_T/N_reactors
+        V_i = V_T / N_reactors
 
     # Total batch time
     tau_batch = tau_reaction + tau_cleaning + tau_loading
@@ -114,6 +206,7 @@ def size_batch(F_vol, tau_reaction, tau_cleaning, N_reactors, V_wf, loading_time
 
     return {'Reactor volume': V_i,
             'Batch time': tau_batch,
-            'Loading time': tau_loading}
+            'Loading time': tau_loading,
+            'Number of reactors': N_reactors}
 
 

biosteam/units/nrel_bioreactor.py

@@ -119,9 +119,6 @@ class NRELAnaerobicBatchBioreactor(Unit, isabstract=True):
               'Recirculation flow rate': 'm3/hr'}
     _N_ins = _N_outs = 2
 
-    #: [bool] If True, number of reactors (N) is chosen as to minimize installation cost in every simulation. Otherwise, N remains constant.
-    autoselect_N = False
-    
     #: [float] Cleaning and unloading time (hr).
     tau_0 = 3
 
@@ -212,22 +209,6 @@ def tau(self):
     @tau.setter
     def tau(self, tau):
         self._tau = tau
-    
-    @property
-    def N_at_minimum_capital_cost(self):
-        cost_old = np.inf
-        self.autoselect_N = False
-        self._N, N = 2, self._N
-        cost_new = self.purchase_cost
-        self._summary()
-        while cost_new < cost_old:
-            self._N += 1
-            self._summary()
-            cost_old = cost_new
-            cost_new = self.purchase_cost
-        self._N, N = N, self._N
-        self.autoselect_N = True
-        return N - 1
 
     def _design(self):
         effluent = self.effluent
@@ -236,19 +217,13 @@ def _design(self):
         tau_0 = self.tau_0
         V_wf = self.V_wf
         Design = self.design_results
-        if self.autoselect_N:
-            N = self.N_at_minimum_capital_cost
-        elif self.V_max:
-            N = v_0 / self.V_max / V_wf * (tau + tau_0) + 1
-            if N < 2:
-                N = 2
-            else:
-                N = ceil(N)
-        else:
-            N = self._N
-        Design.update(size_batch(v_0, tau, tau_0, N, V_wf, self.loading_time))
-        Design['Number of reactors'] = N
-        Design['Recirculation flow rate'] = v_0 / N
+        Design.update(
+            size_batch(
+                v_0, tau, tau_0, V_wf, 
+                self.V_max, self.N, self.loading_time
+            )
+        )
+        Design['Recirculation flow rate'] = v_0 / Design['Number of reactors']
         duty = self.Hnet
         Design['Reactor duty'] = duty
         self.add_heat_utility(duty, self.T)