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

exerpy/components/heat_exchanger/simple.py

@@ -2,26 +2,17 @@ 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
 class SimpleHeatExchanger(Component):
     r"""
-    Class for exergy analysis of simple heat exchangers.
+    Class for exergy and exergoeconomic analysis of simple heat exchangers.
 
-    This class performs exergy analysis calculations for simple heat exchangers with
-    one primary flow stream and heat transfer. The exergy product and fuel definitions
-    vary based on the direction of heat transfer and temperature levels relative to
-    ambient temperature.
-
-    Parameters
-    ----------
-    **kwargs : dict
-        Arbitrary keyword arguments passed to parent class.
-        Optional parameter 'dissipative' (bool) to indicate if the component
-        is considered fully dissipative.
+    This class performs exergy and exergoeconomic analysis calculations for heat exchanger components,
+    accounting for one inlet and one outlet stream across various temperature regimes, including
+    above and below ambient temperature, and optional dissipative behavior.
 
     Attributes
     ----------
@@ -34,119 +25,263 @@ class SimpleHeatExchanger(Component):
     epsilon : float
         Exergetic efficiency of the component :math:`\varepsilon` in :math:`-`.
     inl : dict
-        Dictionary containing inlet stream data with temperature, mass flows,
-        enthalpies, and specific exergies.
+        Dictionary containing inlet stream data with mass flows and specific exergies.
     outl : dict
-        Dictionary containing outlet stream data with temperature, mass flows,
-        enthalpies, and specific exergies.
+        Dictionary containing outlet stream data with mass flows and specific exergies.
+    Z_costs : float
+        Investment cost rate of the component in currency/h.
+    C_P : float
+        Cost of product stream :math:`\dot{C}_P` in currency/h.
+    C_F : float
+        Cost of fuel stream :math:`\dot{C}_F` in currency/h.
+    C_D : float
+        Cost of exergy destruction :math:`\dot{C}_D` in currency/h.
+    c_P : float
+        Specific cost of product stream (currency per unit exergy).
+    c_F : float
+        Specific cost of fuel stream (currency per unit exergy).
+    r : float
+        Relative cost difference, :math:`(c_P - c_F)/c_F`.
+    f : float
+        Exergoeconomic factor, :math:`\dot{Z}/(\dot{Z} + \dot{C}_D)`.
+    Ex_C_col : dict
+        Custom cost coefficients collection passed via `kwargs`.
+    """
+
+    def __init__(self, **kwargs):
+        r"""
+        Initialize the heat exchanger component.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Arbitrary keyword arguments. Recognized keys:
+            - dissipative (bool): whether component has dissipative behavior, default False
+            - Ex_C_col (dict): custom cost coefficients, default {}
+            - Z_costs (float): investment cost rate in currency/h, default 0.0
+        """
+        super().__init__(**kwargs)
 
-    Notes
-    -----
-    The exergy analysis considers three main cases based on heat transfer direction
-    and temperatures relative to ambient temperature :math:`T_0`:
+    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
+        r"""
+        Compute the exergy balance of the simple heat exchanger.
 
-    Case 1 - **Heat Release** (:math:`\dot{Q} < 0`):
+        **Heat release** :math:\dot{Q}<0
 
-    a) Both temperatures above ambient:
+        Case 1: Both streams above ambient temperature
 
-    .. math::
-        \dot{E}_\mathrm{P} &= \dot{m} \cdot (e^\mathrm{T}_\mathrm{in} - 
-        e^\mathrm{T}_\mathrm{out})\\
-        \dot{E}_\mathrm{F} &= \dot{m} \cdot (e^\mathrm{PH}_\mathrm{in} - 
-        e^\mathrm{PH}_\mathrm{out})
+        If split_physical_exergy=True:
 
-    b) Inlet above, outlet below ambient:
+        .. math::
 
-    .. math::
-        \dot{E}_\mathrm{P} &= \dot{m}_\mathrm{out} \cdot e^\mathrm{T}_\mathrm{out}\\
-        \dot{E}_\mathrm{F} &= \dot{m}_\mathrm{in} \cdot e^\mathrm{T}_\mathrm{in} + 
-        \dot{m}_\mathrm{out} \cdot e^\mathrm{T}_\mathrm{out} + 
-        (\dot{m}_\mathrm{in} \cdot e^\mathrm{M}_\mathrm{in} - 
-        \dot{m}_\mathrm{out} \cdot e^\mathrm{M}_\mathrm{out})
+            \dot{E}_{\mathrm{P}}
+            = \dot{E}^{\mathrm{T}}_{\mathrm{out}}
+            - \dot{E}^{\mathrm{T}}_{\mathrm{in}}
 
-    c) Both temperatures below ambient:
+        .. math::
 
-    .. math::
-        \dot{E}_\mathrm{P} &= \dot{m}_\mathrm{out} \cdot 
-        (e^\mathrm{T}_\mathrm{out} - e^\mathrm{T}_\mathrm{in})\\
-        \dot{E}_\mathrm{F} &= \dot{E}_\mathrm{P} + \dot{m}_\mathrm{in} \cdot 
-        (e^\mathrm{M}_\mathrm{in} - e^\mathrm{M}_\mathrm{out})
+            \dot{E}_{\mathrm{F}}
+            = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
 
-    Case 2 - **Heat Addition** (:math:`\dot{Q} > 0`):
+        Else:
 
-    a) Both temperatures above ambient:
+        .. math::
 
-    .. math::
-        \dot{E}_\mathrm{P} &= \dot{m}_\mathrm{out} \cdot 
-        (e^\mathrm{PH}_\mathrm{out} - e^\mathrm{PH}_\mathrm{in})\\
-        \dot{E}_\mathrm{F} &= \dot{m}_\mathrm{out} \cdot 
-        (e^\mathrm{T}_\mathrm{out} - e^\mathrm{T}_\mathrm{in})
+            \dot{E}_{\mathrm{P}}
+            = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
 
-    b) Inlet below, outlet above ambient:
+        .. math::
 
-    .. math::
-        \dot{E}_\mathrm{P} &= \dot{m}_\mathrm{out} \cdot 
-        (e^\mathrm{T}_\mathrm{out} + e^\mathrm{T}_\mathrm{in})\\
-        \dot{E}_\mathrm{F} &= \dot{m}_\mathrm{in} \cdot e^\mathrm{T}_\mathrm{in} + 
-        (\dot{m}_\mathrm{in} \cdot e^\mathrm{M}_\mathrm{in} - 
-        \dot{m}_\mathrm{out} \cdot e^\mathrm{M}_\mathrm{out})
+            \dot{E}_{\mathrm{F}}
+            = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
 
-    c) Both temperatures below ambient:
+        Case 2: Inlet above and outlet below ambient temperature
 
-    .. math::
-        \dot{E}_\mathrm{P} &= \dot{m}_\mathrm{in} \cdot 
-        (e^\mathrm{T}_\mathrm{in} - e^\mathrm{T}_\mathrm{out}) + 
-        (\dot{m}_\mathrm{out} \cdot e^\mathrm{M}_\mathrm{out} - 
-        \dot{m}_\mathrm{in} \cdot e^\mathrm{M}_\mathrm{in})\\
-        \dot{E}_\mathrm{F} &= \dot{m}_\mathrm{in} \cdot 
-        (e^\mathrm{T}_\mathrm{in} - e^\mathrm{T}_\mathrm{out})
+        If split_physical_exergy=True:
 
-    Case 3 - **Dissipative** (it is not possible to specify the exergy product :math:`\dot{E}_\mathrm{P}` for this component):
+        .. math::
 
-    .. math::
-        \dot{E}_\mathrm{P} &= \mathrm{NaN}\\
-        \dot{E}_\mathrm{F} &= \dot{m}_\mathrm{in} \cdot 
-        (e^\mathrm{PH}_\mathrm{in} - e^\mathrm{PH}_\mathrm{out})
+            \dot{E}_{\mathrm{P}}
+            = \dot{E}^{\mathrm{T}}_{\mathrm{out}}
 
-    For all cases, the exergy destruction is calculated as:
+        .. math::
 
-    .. math::
-        \dot{E}_\mathrm{D} = \dot{E}_\mathrm{F} - \dot{E}_\mathrm{P}
+            \dot{E}_{\mathrm{F}}
+            = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
+            + \dot{E}^{\mathrm{T}}_{\mathrm{out}}
+            + \bigl(\dot{E}^{\mathrm{M}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{M}}_{\mathrm{out}}\bigr)
 
-    Where:
-        - :math:`e^\mathrm{T}`: Thermal exergy
-        - :math:`e^\mathrm{PH}`: Physical exergy
-        - :math:`e^\mathrm{M}`: Mechanical exergy
-    """
+        Else:
 
-    def __init__(self, **kwargs):
-        r"""Initialize simple heat exchanger component with given parameters."""
-        super().__init__(**kwargs)
+        .. math::
 
-    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
-        r"""
-        Calculate the exergy balance of the simple heat exchanger.
+            \dot{E}_{\mathrm{P}}
+            = \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
+
+        .. math::
+
+            \dot{E}_{\mathrm{F}}
+            = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+
+        Case 3: Both streams below ambient temperature
+
+        If split_physical_exergy=True:
+
+        .. 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)
+
+        Else:
+
+        .. 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{PH}}_{\mathrm{out}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+
+        **Heat injection** :math:\dot{Q}>0
+
+        Case 1: Both streams above ambient temperature
+
+        If split_physical_exergy=True:
+
+        .. 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}}
+
+        Else:
 
-        Performs exergy balance calculations considering both heat transfer direction
-        and temperature levels relative to 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{PH}}_{\mathrm{out}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+
+        Case 2: Inlet below and outlet above ambient temperature
+
+        If split_physical_exergy=True:
+
+        .. 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}}
+            - \dot{E}^{\mathrm{M}}_{\mathrm{out}}\bigr)
+
+        Else:
+
+        .. 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{PH}}_{\mathrm{out}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+
+        Case 3: Both streams below ambient temperature
+
+        If split_physical_exergy=True:
+
+        .. math::
+
+            \dot{E}_{\mathrm{P}}
+            = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{T}}_{\mathrm{out}}
+            + \bigl(\dot{E}^{\mathrm{M}}_{\mathrm{out}}
+            - \dot{E}^{\mathrm{M}}_{\mathrm{in}}\bigr)
+
+        .. math::
+
+            \dot{E}_{\mathrm{F}}
+            = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{T}}_{\mathrm{out}}
+
+        Else:
+
+        .. math::
+
+            \dot{E}_{\mathrm{P}}
+            = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
+
+        .. math::
+
+            \dot{E}_{\mathrm{F}}
+            = \dot{E}^{\mathrm{PH}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{out}}
+
+        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}}
 
         Parameters
         ----------
         T0 : float
-            Ambient temperature in :math:`\mathrm{K}`.
+            Ambient temperature (K).
         p0 : float
-            Ambient pressure in :math:`\mathrm{Pa}`.
+            Ambient pressure (Pa).
         split_physical_exergy : bool
-            Flag indicating whether physical exergy is split into thermal and mechanical components.
+            Whether to split thermal and mechanical exergy.
 
         Raises
         ------
         ValueError
-            If the required inlet and outlet streams are not properly defined or
-            exceed the maximum allowed number.
-        """      
+            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)
@@ -160,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
@@ -168,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):
@@ -252,107 +396,313 @@ 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.
         """
-        Auxiliary equations for the simple heat exchanger.
-        
-        This function adds rows to the cost matrix A and the right-hand-side vector b to enforce
-        the following auxiliary cost relations:
-        
-        (1) Thermal exergy cost equation:
-            - For heat release (T_in > T_out > T0): F-principle is applied
-              1/E_T_in * C_T_in - 1/E_T_out * C_T_out = 0
-            - For heat addition (T_in < T_out > T0): P-principle is applied
-              1/ΔE_T * (C_T_out - C_T_in) = 1/ΔE_M * (C_M_out - C_M_in)
-        
-        (2) Mechanical exergy cost equation:
-            1/E_M_in * C_M_in - 1/E_M_out * C_M_out = 0
-            - F-principle: specific mechanical exergy costs equalized between inlet/outlet
-            
-        (3) Chemical exergy cost equation (if enabled):
-            1/E_CH_in * C_CH_in - 1/E_CH_out * C_CH_out = 0
-            - F-principle: specific chemical exergy costs equalized between inlet/outlet
-        
+
+        # Extract inlet and outlet
+        inlet = self.inl[0]
+        outlet = self.outl[0]
+
+        # 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
+
+        # 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
+
+        # 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!"
+                )
+
+            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!"
+                )
+
+        # 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!"
+                )
+
+            # 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, 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}}
+            - \dot{C}^{\mathrm{T}}_{\mathrm{out}}
+            - \dot{C}^{\mathrm{M}}_{\mathrm{out}}
+            + \dot{Z}
+            = 0
+
+        In case the chemical exergy of the streams is known:
+
+        .. math::
+            \dot{C}^{\mathrm{CH}}_{\mathrm{in}} =
+            \dot{C}^{\mathrm{CH}}_{\mathrm{out}}
+
+        This method computes cost rates for product and fuel, and derives
+        exergoeconomic indicators based on the operating conditions.
+
+        **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}}
+
+        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}}
+            + \bigl(\dot{E}^{\mathrm{M}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{M}}_{\mathrm{out}}\bigr)
+
+        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} > 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}}
+
+        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}}
+            - \dot{E}^{\mathrm{M}}_{\mathrm{out}}\bigr)
+
+        Case 3: Both streams below ambient temperature
+
+        .. math::
+            \dot{E}_{\mathrm{P}}
+            = \dot{E}^{\mathrm{T}}_{\mathrm{in}}
+            - \dot{E}^{\mathrm{T}}_{\mathrm{out}}
+            + \bigl(\dot{E}^{\mathrm{M}}_{\mathrm{out}}
+            - \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`
+
+        .. 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
         ----------
-        A : numpy.ndarray
-            The current cost matrix.
-        b : numpy.ndarray
-            The current right-hand-side vector.
-        counter : int
-            The current row index in the matrix.
         T0 : float
-            Ambient temperature.
-        equations : dict
-            Dictionary for storing equation labels.
-        chemical_exergy_enabled : bool
-            Flag indicating whether chemical exergy auxiliary equations should be added.
-        
-        Returns
-        -------
-        A : numpy.ndarray
-            The updated cost matrix.
-        b : numpy.ndarray
-            The updated right-hand-side vector.
-        counter : int
-            The updated row index.
-        equations : dict
-            Updated dictionary with equation labels.
+            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).
         """
-        # --- Thermal cost equation (row counter) ---
-        if self.inl[0]["T"] > T0 and self.outl[0]["T"] > T0:
-            if self.inl[0]["T"] > self.outl[0]["T"]:
-                # Heat is released (turbine-like behavior, f‑rule).
-                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_f_rule_{self.name}"
-            elif self.inl[0]["T"] < self.outl[0]["T"]:
-                # Heat is injected (compressor-like behavior, p‑rule):
-                dET = self.outl[0]["e_T"] - self.inl[0]["e_T"]
-                dEM = self.outl[0]["e_M"] - self.inl[0]["e_M"]
-                if dET != 0 and dEM != 0:
-                    A[counter, self.inl[0]["CostVar_index"]["T"]] = -1 / dET
-                    A[counter, self.outl[0]["CostVar_index"]["T"]] = 1 / dET
-                    A[counter, self.inl[0]["CostVar_index"]["M"]] = 1 / dEM
-                    A[counter, self.outl[0]["CostVar_index"]["M"]] = -1 / dEM
-                    equations[counter] = f"aux_p_rule_{self.name}"
-                else:
-                    logging.warning("SimpleHeatExchanger: dET or dEM is zero; case not implemented.")
-                    equations[counter] = "aux_unimpl_HEX"
+        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:
-                logging.warning("SimpleHeatExchanger: Inlet and outlet temperatures are equal; case not implemented.")
-                equations[counter] = "aux_unimpl_HEX"
-        else:
-            logging.warning("SimpleHeatExchanger: Cases with T_in or T_out below T0 are not implemented.")
-            equations[counter] = "aux_unimpl_HEX"
-        b[counter] = 0
+                self.C_P = np.nan
+                self.C_F = np.nan
 
-        # --- Mechanical cost equality (row counter+1) ---
-        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:
+            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
 
-        # --- Chemical cost equality (conditionally added) ---
-        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
+        # Case 3: Fully dissipative or Q == 0
         else:
-            counter += 2
-
-        return A, b, counter, equations
+            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