exerpy 0.0.2__py3-none-any.whl → 0.0.3__py3-none-any.whl

exerpy/components/heat_exchanger/condenser.py

@@ -1,7 +1,8 @@
 import logging
 
-from exerpy.components.component import Component
-from exerpy.components.component import component_registry
+import numpy as np
+
+from exerpy.components.component import Component, component_registry
 
 
 @component_registry
@@ -10,8 +11,8 @@ class Condenser(Component):
     Class for exergy and exergoeconomic analysis of condensers (only dissipative).
 
     This class performs exergy and exergoeconomic analysis calculations for condenser components,
-    accounting for two inlet and two outlet streams. This class should be used only for dissipative 
-    condensers. For non-dissipative condensers, use components that are modeled in ExerPy using the 
+    accounting for two inlet and two outlet streams. This class should be used only for dissipative
+    condensers. For non-dissipative condensers, use components that are modeled in ExerPy using the
     `HeatExchanger` class.
 
     Attributes
@@ -52,7 +53,7 @@ class Condenser(Component):
             - Z_costs (float): investment cost rate in currency/h, default 0.0
         """
         super().__init__(**kwargs)
-    
+
     def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
         r"""
         Compute the exergy balance of the condenser.
@@ -74,8 +75,8 @@ class Condenser(Component):
             - \dot{E}^{\mathrm{PH}}_{\mathrm{out},1}
             - \dot{E}_{\mathrm{L}}
 
-        However, these value can only be accessed via the attributes `E_L` and `E_D` of the component. 
-        In the table of final results of the exergy analysis of the system, the exergy destruction of 
+        However, these value can only be accessed via the attributes `E_L` and `E_D` of the component.
+        In the table of final results of the exergy analysis of the system, the exergy destruction of
         the condenser is counted as the exergy loss and the exergetic destruction due to heat transfer.
 
         Parameters
@@ -95,21 +96,24 @@ class Condenser(Component):
         # Ensure that the component has both inlet and outlet streams
         if len(self.inl) < 2 or len(self.outl) < 2:
             raise ValueError("Condenser requires two inlets and two outlets.")
-        
+
         # Calculate exergy loss (E_L) for the heat transfer process
-        self.E_L = self.outl[1]['m'] * (self.outl[1]['e_PH'] - self.inl[1]['e_PH'])
+        self.E_L = self.outl[1]["m"] * (self.outl[1]["e_PH"] - self.inl[1]["e_PH"])
 
         # Calculate exergy destruction (E_D)
-        self.E_D = self.outl[0]['m'] * (self.inl[0]['e_PH'] - self.outl[0]['e_PH']) - self.E_L
+        self.E_D = self.outl[0]["m"] * (self.inl[0]["e_PH"] - self.outl[0]["e_PH"]) - self.E_L
 
         # Exergy fuel and product are not typically defined for a condenser
-        self.E_F = None
-        self.E_P = None
-        self.epsilon = None
-
-        # Log the exergy balance results
-        logging.info(f"Condenser exergy balance calculated: E_D={self.E_D}, E_L={self.E_L}")
+        self.E_F = np.nan
+        self.E_P = np.nan
+        self.epsilon = np.nan
 
+        # Log the results
+        logging.info(
+            f"Exergy balance of Condenser {self.name} calculated: "
+            f"E_P={self.E_P:.2f}, E_F={self.E_F:.2f}, E_D={self.E_D:.2f}, "
+            f"Efficiency={self.epsilon:.2%}"
+        )
 
     def aux_eqs(self, A, b, counter, T0, equations, chemical_exergy_enabled):
         r"""
@@ -162,7 +166,7 @@ class Condenser(Component):
             + \frac{1}{\dot{E}^{\mathrm{T}}_{\mathrm{in},1}}\,\dot{C}^{\mathrm{T}}_{\mathrm{in},1}
             = 0
 
-        Case 6: Hot stream always above and cold stream always below ambiente temperature (dissipative case): 
+        Case 6: Hot stream always above and cold stream always below ambiente temperature (dissipative case):
 
         The dissipative is not handeld here!
 
@@ -213,6 +217,7 @@ class Condenser(Component):
         ValueError
             If required cost variable indices are missing.
         """
+
         # Equality equation for mechanical and chemical exergy costs.
         def set_equal(A, row, in_item, out_item, var):
             if in_item["e_" + var] != 0 and out_item["e_" + var] != 0:
@@ -269,65 +274,101 @@ class Condenser(Component):
         # Case 1: All temperatures > T0.
         if all([c["T"] > T0 for c in list(self.inl.values()) + list(self.outl.values())]):
             set_thermal_f_hot(A, counter + 0)
-            equations[counter] = f"aux_f_rule_hot_{self.name}"
+            self.equations[counter] = {
+                "kind": "aux_f_rule_hot",
+                "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                "property": "c_T",
+            }
         # Case 2: All temperatures <= T0.
         elif all([c["T"] <= T0 for c in list(self.inl.values()) + list(self.outl.values())]):
             set_thermal_f_cold(A, counter + 0)
-            equations[counter] = f"aux_f_rule_cold_{self.name}"
+            self.equations[counter] = {
+                "kind": "aux_f_rule_cold",
+                "objects": [self.name, self.inl[1]["name"], self.outl[1]["name"]],
+                "property": "c_T",
+            }
             logging.warning(
-                f"All temperatures in {self.name} are below ambient temperature. " \
+                f"All temperatures in {self.name} are below ambient temperature. "
                 "This is not a typical case for a dissipative condenser."
             )
         # Case 3: Both stream crossing T0 (hot inlet and cold outlet > T0, hot outlet and cold inlet <= T0)
-        elif (self.inl[0]["T"] > T0 and self.outl[1]["T"] > T0 and
-            self.outl[0]["T"] <= T0 and self.inl[1]["T"] <= T0):
+        elif self.inl[0]["T"] > T0 and self.outl[1]["T"] > T0 and self.outl[0]["T"] <= T0 and self.inl[1]["T"] <= T0:
             set_thermal_p_rule(A, counter + 0)
-            equations[counter] = f"aux_p_rule_{self.name}"
+            equations[counter] = {
+                "kind": "aux_p_rule",
+                "objects": [self.name, self.outl[0]["name"], self.outl[1]["name"]],
+                "property": "c_T",
+            }
             logging.warning(
-                f"Hot inlet and cold outlet in {self.name} are above ambient temperature, " \
-                "while hot outlet and cold inlet are below. This is not a typical case for a dissipative condenser." \
+                f"Hot inlet and cold outlet in {self.name} are above ambient temperature, "
+                "while hot outlet and cold inlet are below. This is not a typical case for a dissipative condenser."
                 "The exergoeconomic analysis is counting the outlets as products."
             )
         # Case 4: Only hot inlet > T0
-        elif (self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and
-            self.outl[0]["T"] <= T0 and self.outl[1]["T"] <= T0):
+        elif self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and self.outl[0]["T"] <= T0 and self.outl[1]["T"] <= T0:
             set_thermal_f_cold(A, counter + 0)
-            equations[counter] = f"aux_f_rule_cold_{self.name}"
+            equations[counter] = {
+                "kind": "aux_f_rule_cold",
+                "objects": [self.name, self.inl[1]["name"], self.outl[1]["name"]],
+                "property": "c_T",
+            }
             logging.warning(
-                f"Cold inlet in {self.name} is below ambient temperature. " \
+                f"Cold inlet in {self.name} is below ambient temperature. "
                 "This is not a typical case for a dissipative condenser."
             )
         # Case 5: Only cold inlet <= T0
-        elif (self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and
-            self.outl[0]["T"] > T0 and self.outl[1]["T"] > T0):
+        elif self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and self.outl[0]["T"] > T0 and self.outl[1]["T"] > T0:
             set_thermal_f_hot(A, counter + 0)
-            equations[counter] = f"aux_f_rule_hot_{self.name}"
+            equations[counter] = {
+                "kind": "aux_f_rule_hot",
+                "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                "property": "c_T",
+            }
             logging.warning(
-                f"Cold inlet in {self.name} is below ambient temperature. " \
+                f"Cold inlet in {self.name} is below ambient temperature. "
                 "This is not a typical case for a dissipative condenser."
             )
         # Case 6: hot stream always above T0, cold stream always below T0
-        elif (self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and
-            self.outl[0]["T"] > T0 and self.outl[1]["T"] <= T0):
+        elif self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and self.outl[0]["T"] > T0 and self.outl[1]["T"] <= T0:
             print("you shouldn't see this")
             return
         # Case 7: Default case.
         else:
             set_thermal_f_hot(A, counter + 0)
-            equations[counter] = f"aux_f_rule_hot_{self.name}"
-        
+            equations[counter] = {
+                "kind": "aux_f_rule_hot",
+                "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                "property": "c_T",
+            }
+
         # Mechanical equations (always added)
         set_equal(A, counter + 1, self.inl[0], self.outl[0], "M")
         set_equal(A, counter + 2, self.inl[1], self.outl[1], "M")
-        equations[counter + 1] = f"aux_equality_mech_{self.outl[0]['name']}"
-        equations[counter + 2] = f"aux_equality_mech_{self.outl[1]['name']}"
-        
+        equations[counter + 1] = {
+            "kind": "aux_equality",
+            "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+            "property": "c_M",
+        }
+        equations[counter + 2] = {
+            "kind": "aux_equality",
+            "objects": [self.name, self.inl[1]["name"], self.outl[1]["name"]],
+            "property": "c_M",
+        }
+
         # Only add chemical auxiliary equations if chemical exergy is enabled.
         if chemical_exergy_enabled:
             set_equal(A, counter + 3, self.inl[0], self.outl[0], "CH")
             set_equal(A, counter + 4, self.inl[1], self.outl[1], "CH")
-            equations[counter + 3] = f"aux_equality_chem_{self.outl[0]['name']}"
-            equations[counter + 4] = f"aux_equality_chem_{self.outl[1]['name']}"
+            equations[counter + 3] = {
+                "kind": "aux_equality",
+                "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                "property": "c_CH",
+            }
+            equations[counter + 4] = {
+                "kind": "aux_equality",
+                "objects": [self.name, self.inl[1]["name"], self.outl[1]["name"]],
+                "property": "c_M",
+            }
             num_aux_eqs = 5
         else:
             # Skip chemical auxiliary equations.
@@ -337,13 +378,13 @@ class Condenser(Component):
             b[counter + i] = 0
 
         return A, b, counter + num_aux_eqs, equations
-    
-    def exergoeconomic_balance(self, T0):
+
+    def exergoeconomic_balance(self, T0, chemical_exergy_enabled=False):
         r"""
         Perform exergoeconomic cost balance for the condenser.
 
         Even though this class should only consider dissipative condensers, the exergoeconomic balance is
-        still performed to ensure consistency. Please note that same of the following cases cases are not 
+        still performed to ensure consistency. Please note that same of the following cases cases are not
         typical for dissipative condensers. This may change in a future version of ExerPy.
 
         .. math::
@@ -438,34 +479,29 @@ class Condenser(Component):
                     - \dot{C}^{\mathrm{PH}}_{\mathrm{out},1}\bigr)
             - \dot{C}^{\mathrm{PH}}_{\mathrm{out},2}
             + \dot{C}^{\mathrm{PH}}_{\mathrm{in},2}
-        
+
         Parameters
         ----------
         T0 : float
             Ambient temperature (K).
+        chemical_exergy_enabled : bool, optional
+            If True, chemical exergy is considered in the calculations.
         """
         if all([c["T"] > T0 for c in list(self.inl.values()) + list(self.outl.values())]):
             self.C_P = self.outl[1]["C_T"] - self.inl[1]["C_T"]
-            self.C_F = self.inl[0]["C_PH"] - self.outl[0]["C_PH"] + (
-                self.inl[1]["C_M"] - self.outl[1]["C_M"])
+            self.C_F = self.inl[0]["C_PH"] - self.outl[0]["C_PH"] + (self.inl[1]["C_M"] - self.outl[1]["C_M"])
         elif all([c["T"] <= T0 for c in list(self.inl.values()) + list(self.outl.values())]):
             self.C_P = self.outl[0]["C_T"] - self.inl[0]["C_T"]
-            self.C_F = self.inl[1]["C_PH"] - self.outl[1]["C_PH"] + (
-                self.inl[0]["C_M"] - self.outl[0]["C_M"])
-        elif (self.inl[0]["T"] > T0 and self.outl[1]["T"] > T0 and
-              self.outl[0]["T"] <= T0 and self.inl[1]["T"] <= T0):
+            self.C_F = self.inl[1]["C_PH"] - self.outl[1]["C_PH"] + (self.inl[0]["C_M"] - self.outl[0]["C_M"])
+        elif self.inl[0]["T"] > T0 and self.outl[1]["T"] > T0 and self.outl[0]["T"] <= T0 and self.inl[1]["T"] <= T0:
             self.C_P = self.outl[0]["C_T"] + self.outl[1]["C_T"]
-            self.C_F = self.inl[0]["C_PH"] + self.inl[1]["C_PH"] - (
-                self.outl[0]["C_M"] + self.outl[1]["C_M"])
-        elif (self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and
-              self.outl[0]["T"] <= T0 and self.outl[1]["T"] <= T0):
+            self.C_F = self.inl[0]["C_PH"] + self.inl[1]["C_PH"] - (self.outl[0]["C_M"] + self.outl[1]["C_M"])
+        elif self.inl[0]["T"] > T0 and self.inl[1]["T"] <= T0 and self.outl[0]["T"] <= T0 and self.outl[1]["T"] <= T0:
             self.C_P = self.outl[0]["C_T"]
-            self.C_F = self.inl[0]["C_PH"] + self.inl[1]["C_PH"] - (
-               self.outl[1]["C_PH"] + self.outl[0]["C_M"])
+            self.C_F = self.inl[0]["C_PH"] + self.inl[1]["C_PH"] - (self.outl[1]["C_PH"] + self.outl[0]["C_M"])
         else:
             self.C_P = self.outl[1]["C_T"]
-            self.C_F = self.inl[0]["C_PH"] - self.outl[0]["C_PH"] + (
-                self.inl[1]["C_PH"] - self.outl[1]["C_M"])
+            self.C_F = self.inl[0]["C_PH"] - self.outl[0]["C_PH"] + (self.inl[1]["C_PH"] - self.outl[1]["C_M"])
 
         self.c_F = self.C_F / self.E_F
         self.c_P = self.C_P / self.E_P