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

exerpy/components/heat_exchanger/simple.py

@@ -2,8 +2,7 @@ import logging
 
 import numpy as np
 
-from exerpy.components.component import Component
-from exerpy.components.component import component_registry
+from exerpy.components.component import Component, component_registry
 
 
 @component_registry
@@ -282,7 +281,7 @@ class SimpleHeatExchanger(Component):
             If required inlet or outlet are missing.
         """
         # Validate the number of inlets and outlets
-        if not hasattr(self, 'inl') or not hasattr(self, 'outl') or len(self.inl) < 1 or len(self.outl) < 1:
+        if not hasattr(self, "inl") or not hasattr(self, "outl") or len(self.inl) < 1 or len(self.outl) < 1:
             msg = "SimpleHeatExchanger requires at least one inlet and one outlet as well as one heat flow."
             logging.error(msg)
             raise ValueError(msg)
@@ -296,7 +295,7 @@ class SimpleHeatExchanger(Component):
         outlet = self.outl[0]
 
         # Calculate heat transfer Q
-        Q = outlet['m'] * outlet['h'] - inlet['m'] * inlet['h']
+        Q = outlet["m"] * outlet["h"] - inlet["m"] * inlet["h"]
 
         # Initialize E_P and E_F
         self.E_P = 0.0
@@ -304,78 +303,87 @@ class SimpleHeatExchanger(Component):
 
         # Case 1: Heat is released (Q < 0)
         if Q < 0:
-            if inlet['T'] >= T0 and outlet['T'] >= T0:
+            if inlet["T"] >= T0 and outlet["T"] >= T0:
                 if split_physical_exergy:
-                    self.E_P = np.nan if getattr(self, 'dissipative', False) else inlet['m'] * (inlet['e_T'] - outlet['e_T'])
+                    self.E_P = (
+                        np.nan if getattr(self, "dissipative", False) else inlet["m"] * (inlet["e_T"] - outlet["e_T"])
+                    )
                 else:
-                    self.E_P = np.nan if getattr(self, 'dissipative', False) else inlet['m'] * (inlet['e_PH'] - outlet['e_PH'])
-                self.E_F = inlet['m'] * (inlet['e_PH'] - outlet['e_PH'])
+                    self.E_P = (
+                        np.nan if getattr(self, "dissipative", False) else inlet["m"] * (inlet["e_PH"] - outlet["e_PH"])
+                    )
+                self.E_F = inlet["m"] * (inlet["e_PH"] - outlet["e_PH"])
 
-            elif inlet['T'] >= T0 and outlet['T'] < T0:
+            elif inlet["T"] >= T0 and outlet["T"] < T0:
                 if split_physical_exergy:
-                    self.E_P = outlet['m'] * outlet['e_T']
-                    self.E_F = (inlet['m'] * inlet['e_T'] + outlet['m'] * outlet['e_T'] +
-                            (inlet['m'] * inlet['e_M'] - outlet['m'] * outlet['e_M']))
+                    self.E_P = outlet["m"] * outlet["e_T"]
+                    self.E_F = (
+                        inlet["m"] * inlet["e_T"]
+                        + outlet["m"] * outlet["e_T"]
+                        + (inlet["m"] * inlet["e_M"] - outlet["m"] * outlet["e_M"])
+                    )
                 else:
-                    self.E_P = outlet['m'] * outlet['e_PH']
-                    self.E_F = inlet['m'] * inlet['e_PH']
+                    self.E_P = outlet["m"] * outlet["e_PH"]
+                    self.E_F = inlet["m"] * inlet["e_PH"]
 
-            elif inlet['T'] <= T0 and outlet['T'] <= T0:
+            elif inlet["T"] <= T0 and outlet["T"] < T0:
                 if split_physical_exergy:
-                    self.E_P = outlet['m'] * (outlet['e_T'] - inlet['e_T'])
-                    self.E_F = self.E_P + inlet['m'] * (inlet['e_M'] - outlet['m'] * outlet['e_M'])
+                    self.E_P = outlet["m"] * (outlet["e_T"] - inlet["e_T"])
+                    self.E_F = self.E_P + inlet["m"] * (inlet["e_M"] - outlet["m"] * outlet["e_M"])
                 else:
-                    self.E_P = np.nan if getattr(self, 'dissipative', False) else \
-                        outlet['m'] * (outlet['e_PH'] - inlet['e_PH'])
-                    self.E_F = outlet['m'] * (outlet['e_PH'] - inlet['e_PH'])
+                    self.E_P = (
+                        np.nan
+                        if getattr(self, "dissipative", False)
+                        else outlet["m"] * (outlet["e_PH"] - inlet["e_PH"])
+                    )
+                    self.E_F = outlet["m"] * (outlet["e_PH"] - inlet["e_PH"])
 
             else:
                 # Unimplemented corner case
-                logging.warning(
-                    "SimpleHeatExchanger: unimplemented case (Q < 0, T_in < T0 < T_out?)."
-                )
+                logging.warning("SimpleHeatExchanger: unimplemented case (Q < 0, T_in < T0 < T_out?).")
                 self.E_P = np.nan
                 self.E_F = np.nan
 
         # Case 2: Heat is added (Q > 0)
         elif Q > 0:
-            if inlet['T'] >= T0 and outlet['T'] >= T0:
+            if inlet["T"] >= T0 and outlet["T"] >= T0:
                 if split_physical_exergy:
-                    self.E_P = outlet['m'] * (outlet['e_PH'] - inlet['e_PH'])
-                    self.E_F = outlet['m'] * (outlet['e_T'] - inlet['e_T'])
+                    self.E_P = outlet["m"] * (outlet["e_PH"] - inlet["e_PH"])
+                    self.E_F = outlet["m"] * (outlet["e_T"] - inlet["e_T"])
                 else:
-                    self.E_P = outlet['m'] * (outlet['e_PH'] - inlet['e_PH'])
-                    self.E_F = outlet['m'] * (outlet['e_PH'] - inlet['e_PH'])
-            elif inlet['T'] < T0 and outlet['T'] > T0:
+                    self.E_P = outlet["m"] * (outlet["e_PH"] - inlet["e_PH"])
+                    self.E_F = outlet["m"] * (outlet["e_PH"] - inlet["e_PH"])
+            elif inlet["T"] < T0 and outlet["T"] >= T0:
                 if split_physical_exergy:
-                    self.E_P = outlet['m'] * (outlet['e_T'] + inlet['e_T'])
-                    self.E_F = (inlet['m'] * inlet['e_T'] +
-                            (inlet['m'] * inlet['e_M'] - outlet['m'] * outlet['e_M']))
+                    self.E_P = outlet["m"] * (outlet["e_T"] + inlet["e_T"])
+                    self.E_F = inlet["m"] * inlet["e_T"] + (inlet["m"] * inlet["e_M"] - outlet["m"] * outlet["e_M"])
                 else:
-                    self.E_P = outlet['m'] * (outlet['e_PH'] - inlet['e_PH'])
-                    self.E_F = outlet['m'] * (outlet['e_PH'] - inlet['e_PH'])
+                    self.E_P = outlet["m"] * (outlet["e_PH"] - inlet["e_PH"])
+                    self.E_F = outlet["m"] * (outlet["e_PH"] - inlet["e_PH"])
 
-            elif inlet['T'] < T0 and outlet['T'] < T0:
+            elif inlet["T"] < T0 and outlet["T"] <= T0:
                 if split_physical_exergy:
-                    self.E_P = np.nan if getattr(self, 'dissipative', False) else \
-                        inlet['m'] * (inlet['e_T'] - outlet['e_T']) + \
-                        (outlet['m'] * outlet['e_M'] - inlet['m'] * inlet['e_M'])
-                    self.E_F = inlet['m'] * (inlet['e_T'] - outlet['e_T'])
+                    self.E_P = (
+                        np.nan
+                        if getattr(self, "dissipative", False)
+                        else inlet["m"] * (inlet["e_T"] - outlet["e_T"])
+                        + (outlet["m"] * outlet["e_M"] - inlet["m"] * inlet["e_M"])
+                    )
+                    self.E_F = inlet["m"] * (inlet["e_T"] - outlet["e_T"])
                 else:
-                    self.E_P = np.nan if getattr(self, 'dissipative', False) else \
-                        inlet['m'] * (inlet['e_PH'] - outlet['e_PH'])
-                    self.E_F = inlet['m'] * (inlet['e_PH'] - outlet['e_PH'])
+                    self.E_P = (
+                        np.nan if getattr(self, "dissipative", False) else inlet["m"] * (inlet["e_PH"] - outlet["e_PH"])
+                    )
+                    self.E_F = inlet["m"] * (inlet["e_PH"] - outlet["e_PH"])
             else:
-                logging.warning(
-                    "SimpleHeatExchanger: unimplemented case (Q > 0, T_in > T0 > T_out?)."
-                )
+                logging.warning("SimpleHeatExchanger: unimplemented case (Q > 0, T_in > T0 > T_out?).")
                 self.E_P = np.nan
                 self.E_F = np.nan
 
         # Case 3: Fully dissipative or Q == 0
         else:
             self.E_P = np.nan
-            self.E_F = inlet['m'] * (inlet['e_PH'] - outlet['e_PH'])
+            self.E_F = inlet["m"] * (inlet["e_PH"] - outlet["e_PH"])
 
         # Calculate exergy destruction
         if np.isnan(self.E_P):
@@ -388,93 +396,112 @@ class SimpleHeatExchanger(Component):
 
         # Log the results
         logging.info(
-            f"SimpleHeatExchanger exergy balance calculated: "
+            f"Exergy balance of SimpleHeatExchanger {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"""
         This function must be implemented in the future.
 
         The exergoeconomic analysis of SimpleHeatExchanger is not implemented yet.
         """
-        
-        logging.error(
-                    "The exergoeconomic analysis of SimpleHeatExchanger is not implemented yet. "
-                    "This method will be implemented in a future release."
-                )
-        r"""
-        Add auxiliary cost equations for the heat exchanger.
-
-        For all cases:
-
-        .. math::
-            -\frac{1}{\dot{E}^{\mathrm{T}}_{\mathrm{out}}}\,\dot{C}^{\mathrm{T}}_{\mathrm{out}}
-            + \frac{1}{\dot{E}^{\mathrm{T}}_{\mathrm{in}}}\,\dot{C}^{\mathrm{Tc}}_{\mathrm{in}}
-            = 0
 
-        F rule for mechanical exergy:
-
-        .. math::
-            -\frac{1}{\dot{E}^{\mathrm{M}}_{\mathrm{out}}\,\dot{C}^{\mathrm{M}}_{\mathrm{out}}
-            + \frac{1}{\dot{E}^{\mathrm{M}}_{\mathrm{in}}\,\dot{C}^{\mathrm{M}}_{\mathrm{in}}
-            = 0
+        # Extract inlet and outlet
+        inlet = self.inl[0]
+        outlet = self.outl[0]
 
-        F rule for chemical exergy:
+        # Calculate heat transfer Q
+        Q = outlet["m"] * outlet["h"] - inlet["m"] * inlet["h"]
+
+        # Extract temperatures
+        T_in = inlet["T"]
+        T_out = outlet["T"]
+
+        # Equality equation for mechanical exergy costs (c_M,in = c_M,out)
+        A[counter, inlet["CostVar_index"]["M"]] = 1 / inlet["E_M"] if inlet["e_M"] != 0 else 1
+        A[counter, outlet["CostVar_index"]["M"]] = -1 / outlet["E_M"] if outlet["e_M"] != 0 else -1
+        equations[counter] = {
+            "kind": "aux_equality",
+            "objects": [self.name, inlet["name"], outlet["name"]],
+            "property": "c_M",
+        }
+        b[counter] = 0
+        counter += 1
 
-        .. math::
-            -\frac{1}{\dot{E}^{\mathrm{CH}}_{\mathrm{out}}}\,\dot{C}^{\mathrm{CH}}_{\mathrm{out}}
-            + \frac{1}{\dot{E}^{\mathrm{CH}}_{\mathrm{in}}}\,\dot{C}^{\mathrm{CH}}_{\mathrm{in}}
-            = 0
+        # Equality equation for chemical exergy costs (c_CH,in = c_CH,out)
+        if chemical_exergy_enabled:
+            A[counter, inlet["CostVar_index"]["CH"]] = 1 / inlet["E_CH"] if inlet["e_CH"] != 0 else 1
+            A[counter, outlet["CostVar_index"]["CH"]] = -1 / outlet["E_CH"] if outlet["e_CH"] != 0 else -1
+            equations[counter] = {
+                "kind": "aux_equality",
+                "objects": [self.name, inlet["name"], outlet["name"]],
+                "property": "c_CH",
+            }
+            b[counter] = 0
+            counter += 1
+
+        # Thermal exergy cost equations
 
-        """         
-        """# For all cases: c_Tin = c_Tout
-        A[counter, self.inl[0]["CostVar_index"]["T"]] = (1 / self.inl[0]["e_T"] 
-                                                        if self.inl[0]["e_T"] != 0 else 1)
-        A[counter, self.outl[0]["CostVar_index"]["T"]] = (-1 / self.outl[0]["e_T"]
-                                                        if self.outl[0]["e_T"] != 0 else -1)
-        equations[counter] = f"aux_equality_therm_{self.outl[0]['name']}"
+        # Case 1: Heat is released (Q < 0)
+        if Q < 0:
+            # Case 1.1: Both streams above ambient temperature
+            if T_in >= T0 and T_out >= T0:
+                # Apply F-rule to thermal exergy (c_T,in = c_T,out)
+                A[counter, inlet["CostVar_index"]["T"]] = 1 / inlet["E_T"] if inlet["e_T"] != 0 else 1
+                A[counter, outlet["CostVar_index"]["T"]] = -1 / outlet["E_T"] if outlet["e_T"] != 0 else -1
+                equations[counter] = {
+                    "kind": "aux_f_rule",
+                    "objects": [self.name, inlet["name"], outlet["name"]],
+                    "property": "c_T",
+                }
+                b[counter] = 0
+                counter += 1
+
+            elif T_in >= T0 and T_out < T0:
+                # Tricky case: inlet above T0, outlet below T0
+                logging.warning(
+                    f"SimpleHeatExchanger '{self.name}': Stream crossing ambient temperature "
+                    f"during heat release not implemented in exergoeconomics yet!"
+                )
 
-        b[counter] = 0
+            else:
+                # Tricky case: both streams below T0 while heat is released
+                logging.warning(
+                    f"SimpleHeatExchanger '{self.name}': Both streams below T0 during heat release "
+                    f"not implemented in exergoeconomics yet!"
+                )
 
-        # For alle cases: c_Min = c_Mout
-        A[counter+1, self.inl[0]["CostVar_index"]["M"]] = (1 / self.inl[0]["e_M"]
-                                                            if self.inl[0]["e_M"] != 0 else 1)
-        A[counter+1, self.outl[0]["CostVar_index"]["M"]] = (-1 / self.outl[0]["e_M"]
-                                                            if self.outl[0]["e_M"] != 0 else 1)
-        equations[counter+1] = f"aux_equality_mech_{self.outl[0]['name']}"
-        b[counter+1] = 0
+        # Case 2: Heat is added (Q > 0)
+        elif Q > 0:
+            # Case 2.1: Both streams below ambient temperature
+            if T_in < T0 and T_out < T0:
+                # No auxiliary equation needed for thermal exergy
+                # The cost balance will determine c_T,out based on c_T,in and c_heat
+                pass
+
+            elif T_in < T0 and T_out >= T0:
+                # Tricky case: inlet below T0, outlet above T0
+                logging.warning(
+                    f"SimpleHeatExchanger '{self.name}': Stream crossing ambient temperature "
+                    f"during heat absorption not implemented in exergoeconomics yet!"
+                )
 
-        # For all cases: c_CHin = c_CHout
-        if chemical_exergy_enabled:
-            A[counter+2, self.inl[0]["CostVar_index"]["CH"]] = (1 / self.inl[0]["e_CH"]
-                                                                if self.inl[0]["e_CH"] != 0 else 1)
-            A[counter+2, self.outl[0]["CostVar_index"]["CH"]] = (-1 / self.outl[0]["e_CH"]
-                                                                if self.outl[0]["e_CH"] != 0 else 1)
-            equations[counter+2] = f"aux_equality_chem_{self.outl[0]['name']}"
-            b[counter+2] = 0
-            counter += 3
-        else:
-            counter += 2
+            # Case 2.2: Both streams above ambient temperature
+            elif T_in >= T0 and T_out >= T0:
+                # No auxiliary equation needed for thermal exergy
+                # The cost balance will determine c_T,out based on c_T,in and c_heat
+                pass
 
-        return A, b, counter, equations"""
-    
-    def exergoeconomic_balance(self, T0):
-        r"""
-        This function must be implemented in the future.
+        return A, b, counter, equations
 
-        The exergoeconomic analysis of SimpleHeatExchanger is not implemented yet.
-        """
-        
-        logging.error(
-                    "The exergoeconomic analysis of SimpleHeatExchanger is not implemented yet. "
-                    "This method will be implemented in a future release."
-                )
+    def exergoeconomic_balance(self, T0, chemical_exergy_enabled=False):
         r"""
         Perform exergoeconomic cost balance for the simple heat exchanger.
 
+        The general exergoeconomic balance equation is:
+
         .. math::
             \dot{C}^{\mathrm{T}}_{\mathrm{in}}
             + \dot{C}^{\mathrm{M}}_{\mathrm{in}}
@@ -483,30 +510,25 @@ class SimpleHeatExchanger(Component):
             + \dot{Z}
             = 0
 
-        In case the chemical exergy of the streams is know:
+        In case the chemical exergy of the streams is known:
 
         .. math::
-            \dot{C}^{\mathrm{CH}}_{\mathrm{in},1} =
-            \dot{C}^{\mathrm{CH}}_{\mathrm{out},1}
+            \dot{C}^{\mathrm{CH}}_{\mathrm{in}} =
+            \dot{C}^{\mathrm{CH}}_{\mathrm{out}}
 
-        .. math::
-            \dot{C}^{\mathrm{CH}}_{\mathrm{in},2} =
-            \dot{C}^{\mathrm{CH}}_{\mathrm{out},2}
+        This method computes cost rates for product and fuel, and derives
+        exergoeconomic indicators based on the operating conditions.
 
-        This method computes cost coefficients and ratios:
-
-        **Heat release** :math:\dot{Q}<0
+        **Heat release** (:math:`\dot{Q} < 0`)
 
         Case 1: Both streams above ambient temperature
 
         .. math::
-
             \dot{E}_{\mathrm{P}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{out}}
             - \dot{E}^{\mathrm{T}}_{\mathrm{in}}
 
         .. math::
-
             \dot{E}_{\mathrm{F}}
             = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
             - \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
@@ -514,12 +536,10 @@ class SimpleHeatExchanger(Component):
         Case 2: Inlet above and outlet below ambient temperature
 
         .. math::
-
             \dot{E}_{\mathrm{P}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{out}}
 
         .. math::
-
             \dot{E}_{\mathrm{F}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
             + \dot{E}^{\mathrm{T}}_{\mathrm{out}}
@@ -529,31 +549,27 @@ class SimpleHeatExchanger(Component):
         Case 3: Both streams below ambient temperature
 
         .. math::
-
             \dot{E}_{\mathrm{P}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{out}}
             - \dot{E}^{\mathrm{T}}_{\mathrm{in}}
 
         .. math::
-
             \dot{E}_{\mathrm{F}}
             = \bigl(\dot{E}^{\mathrm{T}}_{\mathrm{out}}
             - \dot{E}^{\mathrm{T}}_{\mathrm{in}}\bigr)
             + \bigl(\dot{E}^{\mathrm{M}}_{\mathrm{in}}
             - \dot{E}^{\mathrm{M}}_{\mathrm{out}}\bigr)
 
-        **Heat injection** :math:\dot{Q}
+        **Heat injection** (:math:`\dot{Q} > 0`)
 
         Case 1: Both streams above ambient temperature
 
         .. math::
-
             \dot{E}_{\mathrm{P}}
             = \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
             - \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
 
         .. math::
-
             \dot{E}_{\mathrm{F}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{out}}
             - \dot{E}^{\mathrm{T}}_{\mathrm{in}}
@@ -561,13 +577,11 @@ class SimpleHeatExchanger(Component):
         Case 2: Inlet below and outlet above ambient temperature
 
         .. math::
-
             \dot{E}_{\mathrm{P}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{out}}
             + \dot{E}^{\mathrm{T}}_{\mathrm{in}}
 
         .. math::
-
             \dot{E}_{\mathrm{F}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
             + \bigl(\dot{E}^{\mathrm{M}}_{\mathrm{in}}
@@ -576,7 +590,6 @@ class SimpleHeatExchanger(Component):
         Case 3: Both streams below ambient temperature
 
         .. math::
-
             \dot{E}_{\mathrm{P}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
             - \dot{E}^{\mathrm{T}}_{\mathrm{out}}
@@ -584,25 +597,112 @@ class SimpleHeatExchanger(Component):
             - \dot{E}^{\mathrm{M}}_{\mathrm{in}}\bigr)
 
         .. math::
-
             \dot{E}_{\mathrm{F}}
             = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
             - \dot{E}^{\mathrm{T}}_{\mathrm{out}}
 
-        Fully dissipative or :math:\dot{Q}=0
+        **Fully dissipative or** :math:`\dot{Q} = 0`
 
         .. math::
-
             \dot{E}_{\mathrm{P}} = \mathrm{NaN}
 
         .. math::
-
             \dot{E}_{\mathrm{F}}
             = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
             - \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
-        
+
+        **Calculated exergoeconomic indicators:**
+
+        .. math::
+            c_{\mathrm{F}} = \frac{\dot{C}_{\mathrm{F}}}{\dot{E}_{\mathrm{F}}}
+
+        .. math::
+            c_{\mathrm{P}} = \frac{\dot{C}_{\mathrm{P}}}{\dot{E}_{\mathrm{P}}}
+
+        .. math::
+            \dot{C}_{\mathrm{D}} = c_{\mathrm{F}} \cdot \dot{E}_{\mathrm{D}}
+
+        .. math::
+            r = \frac{c_{\mathrm{P}} - c_{\mathrm{F}}}{c_{\mathrm{F}}}
+
+        .. math::
+            f = \frac{\dot{Z}}{\dot{Z} + \dot{C}_{\mathrm{D}}}
+
         Parameters
         ----------
         T0 : float
             Ambient temperature (K).
+        chemical_exergy_enabled : bool, optional
+            If True, chemical exergy is considered in the calculations.
+            Default is False.
+
+        Attributes Set
+        --------------
+        C_P : float
+            Cost rate of product (currency/time).
+        C_F : float
+            Cost rate of fuel (currency/time).
+        c_P : float
+            Specific cost of product (currency/energy).
+        c_F : float
+            Specific cost of fuel (currency/energy).
+        C_D : float
+            Cost rate of exergy destruction (currency/time).
+        r : float
+            Relative cost difference (dimensionless).
+        f : float
+            Exergoeconomic factor (dimensionless).
         """
+        inlet = self.inl[0]
+        outlet = self.outl[0]
+
+        # Determine heat transfer direction
+        Q = outlet["m"] * outlet["h"] - inlet["m"] * inlet["h"]
+
+        # Case 1: Heat is released (Q < 0)
+        if Q < 0:
+            if inlet["T"] >= T0 and outlet["T"] >= T0:
+                # Both streams above ambient
+                self.C_P = outlet["C_T"] - inlet["C_T"]
+                self.C_F = inlet["C_PH"] - outlet["C_PH"]
+            elif inlet["T"] >= T0 and outlet["T"] < T0:
+                # Inlet above, outlet below ambient
+                self.C_P = outlet["C_T"]
+                self.C_F = inlet["C_T"] + outlet["C_T"] + (inlet["C_M"] - outlet["C_M"])
+            elif inlet["T"] <= T0 and outlet["T"] < T0:
+                # Both streams below ambient
+                self.C_P = outlet["C_T"] - inlet["C_T"]
+                self.C_F = self.C_P + (inlet["C_M"] - outlet["C_M"])
+            else:
+                self.C_P = np.nan
+                self.C_F = np.nan
+
+        # Case 2: Heat is added (Q > 0)
+        elif Q > 0:
+            if inlet["T"] >= T0 and outlet["T"] >= T0:
+                # Both streams above ambient
+                self.C_P = outlet["C_PH"] - inlet["C_PH"]
+                self.C_F = outlet["C_T"] - inlet["C_T"]
+            elif inlet["T"] < T0 and outlet["T"] >= T0:
+                # Inlet below, outlet above ambient
+                self.C_P = outlet["C_T"] + inlet["C_T"]
+                self.C_F = inlet["C_T"] + (inlet["C_M"] - outlet["C_M"])
+            elif inlet["T"] < T0 and outlet["T"] <= T0:
+                # Both streams below ambient
+                self.C_P = inlet["C_T"] - outlet["C_T"] + (outlet["C_M"] - inlet["C_M"])
+                self.C_F = inlet["C_T"] - outlet["C_T"]
+            else:
+                self.C_P = np.nan
+                self.C_F = np.nan
+
+        # Case 3: Fully dissipative or Q == 0
+        else:
+            self.C_P = np.nan
+            self.C_F = inlet["C_PH"] - outlet["C_PH"]
+
+        # Calculate specific costs and exergoeconomic indicators
+        self.c_F = self.C_F / self.E_F if self.E_F else np.nan
+        self.c_P = self.C_P / self.E_P if self.E_P else np.nan
+        self.C_D = self.c_F * self.E_D if self.E_D else np.nan
+        self.r = (self.c_P - self.c_F) / self.c_F if self.c_F else np.nan
+        self.f = self.Z_costs / (self.Z_costs + self.C_D) if self.C_D else np.nan