exerpy 0.0.1__py3-none-any.whl

exerpy/components/heat_exchanger/condenser.py

@@ -0,0 +1,323 @@
+import logging
+
+from exerpy.components.component import Component
+from exerpy.components.component import component_registry
+
+
+@component_registry
+class Condenser(Component):
+    """
+    Condenser component class.
+
+    This class represents a condenser within the system, responsible for
+    calculating the exergy balance specific to condensation processes.
+    It evaluates the exergy interactions between multiple inlet and outlet
+    streams to determine exergy loss and exergy destruction.
+
+    Attributes
+    ----------
+    E_L : float
+        Exergy loss associated with heat transfer (difference in physical exergy 
+        between specific outlet and inlet streams).
+    E_D : float
+        Exergy destruction, calculated as the difference between the primary 
+        inlet and outlet streams minus exergy loss (E_L), representing
+        irreversibilities in the condensation process.
+    E_P : None
+        Exergy product, not defined for a condenser as there is no exergy output
+        intended for productive use.
+    E_F : None
+        Exergy fuel, typically undefined for a condenser as it does not involve 
+        an external exergy input for production purposes.
+    epsilon : None
+        Exergy efficiency, not applicable to a condenser due to the nature of 
+        exergy interactions focused on loss and destruction.
+
+    Methods
+    -------
+    __init__(**kwargs)
+        Initializes the Condenser component with given parameters.
+    calc_exergy_balance(T0, p0)
+        Calculates the exergy balance of the condenser.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize the Condenser component.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Arbitrary keyword arguments passed to the base class initializer.
+        """
+        super().__init__(**kwargs)
+    
+    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
+        """
+        Calculate the exergy balance of the condenser.
+
+        This method computes exergy loss and exergy destruction based on the inlet
+        and outlet streams involved in the condensation process.
+
+        Parameters
+        ----------
+        T0 : float
+            Reference temperature in Kelvin.
+        p0 : float
+            Reference pressure in Pascals.
+        split_physical_exergy : bool
+            Flag indicating whether physical exergy is split into thermal and mechanical components.
+
+        Raises
+        ------
+        ValueError
+            If the condenser does not have exactly two inlets and two outlets.
+
+        Calculation Details
+        -------------------
+        The exergy balance is determined based on exergy transfer due to heat loss (`E_L`)
+        and the exergy destruction within the system:
+
+        - **Exergy Loss (E_L)**:
+            \[
+            E_L = \dot{m}_{\mathrm{out,1}} \cdot (e_{\mathrm{PH,out,1}} - e_{\mathrm{PH,in,1}})
+            \]
+            Represents the exergy loss due to heat transfer from the process.
+
+        - **Exergy Destruction (E_D)**:
+            \[
+            E_D = \dot{m}_{\mathrm{out,0}} \cdot (e_{\mathrm{PH,in,0}} - e_{\mathrm{PH,out,0}}) - E_L
+            \]
+            Accounts for the irreversibilities and losses in the condenser.
+
+        Note
+        ----
+        Exergy product (E_P) and exergy fuel (E_F) are generally undefined in a
+        condenser due to the focus on exergy loss rather than productive exergy usage.
+        """
+        # 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'])
+
+        # 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
+
+        # 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}")
+
+
+    def aux_eqs(self, A, b, counter, T0, equations, chemical_exergy_enabled):
+        """
+        Auxiliary equations for the condenser.
+        
+        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 auxiliary equation based on temperature cases:
+            - Case 1 (T > T0): c_T(hot_inlet)/E_T(hot_in) = c_T(hot_outlet)/E_T(hot_out)
+              F-principle: specific thermal exergy costs equalized in hot stream
+            - Case 2 (T <= T0): c_T(cold_inlet)/E_T(cold_in) = c_T(cold_outlet)/E_T(cold_out)
+              F-principle: specific thermal exergy costs equalized in cold stream
+            - Case 3 (mixed temperatures): c_T(hot_outlet)/E_T(hot_out) = c_T(cold_outlet)/E_T(cold_out)
+              P-principle: equal specific costs of thermal exergy in outlets
+            
+        (2) c_M(hot_inlet)/E_M(hot_in) = c_M(hot_outlet)/E_M(hot_out)
+            - F-principle: specific mechanical exergy costs equalized in hot stream
+            
+        (3) c_M(cold_inlet)/E_M(cold_in) = c_M(cold_outlet)/E_M(cold_out)
+            - F-principle: specific mechanical exergy costs equalized in cold stream
+            
+        (4-5) Chemical exergy cost equations (if enabled) for hot and cold streams
+            - F-principle: specific chemical exergy costs equalized between inlets/outlets
+        
+        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.
+        """
+        # 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:
+                A[row, in_item["CostVar_index"][var]] = 1 / in_item["e_" + var]
+                A[row, out_item["CostVar_index"][var]] = -1 / out_item["e_" + var]
+            elif in_item["e_" + var] == 0 and out_item["e_" + var] != 0:
+                A[row, in_item["CostVar_index"][var]] = 1
+            elif in_item["e_" + var] != 0 and out_item["e_" + var] == 0:
+                A[row, out_item["CostVar_index"][var]] = 1
+            else:
+                A[row, in_item["CostVar_index"][var]] = 1
+                A[row, out_item["CostVar_index"][var]] = -1
+
+        # Thermal fuel rule on hot stream: c_T_in0 = c_T_out0.
+        def set_thermal_f_hot(A, row):
+            if self.inl[0]["e_T"] != 0 and self.outl[0]["e_T"] != 0:
+                A[row, self.inl[0]["CostVar_index"]["T"]] = 1 / self.inl[0]["E_T"]
+                A[row, self.outl[0]["CostVar_index"]["T"]] = -1 / self.outl[0]["E_T"]
+            elif self.inl[0]["e_T"] == 0 and self.outl[0]["e_T"] != 0:
+                A[row, self.inl[0]["CostVar_index"]["T"]] = 1
+            elif self.inl[0]["e_T"] != 0 and self.outl[0]["e_T"] == 0:
+                A[row, self.outl[0]["CostVar_index"]["T"]] = 1
+            else:
+                A[row, self.inl[0]["CostVar_index"]["T"]] = 1
+                A[row, self.outl[0]["CostVar_index"]["T"]] = -1
+
+        # Thermal fuel rule on cold stream: c_T_in1 = c_T_out1.
+        def set_thermal_f_cold(A, row):
+            if self.inl[1]["e_T"] != 0 and self.outl[1]["e_T"] != 0:
+                A[row, self.inl[1]["CostVar_index"]["T"]] = 1 / self.inl[1]["E_T"]
+                A[row, self.outl[1]["CostVar_index"]["T"]] = -1 / self.outl[1]["E_T"]
+            elif self.inl[1]["e_T"] == 0 and self.outl[1]["e_T"] != 0:
+                A[row, self.inl[1]["CostVar_index"]["T"]] = 1
+            elif self.inl[1]["e_T"] != 0 and self.outl[1]["e_T"] == 0:
+                A[row, self.outl[1]["CostVar_index"]["T"]] = 1
+            else:
+                A[row, self.inl[1]["CostVar_index"]["T"]] = 1
+                A[row, self.outl[1]["CostVar_index"]["T"]] = -1
+
+        # Thermal product rule: Equate the two outlet thermal costs (c_T_out0 = c_T_out1).
+        def set_thermal_p_rule(A, row):
+            if self.outl[0]["e_T"] != 0 and self.outl[1]["e_T"] != 0:
+                A[row, self.outl[0]["CostVar_index"]["T"]] = 1 / self.outl[0]["E_T"]
+                A[row, self.outl[1]["CostVar_index"]["T"]] = -1 / self.outl[1]["E_T"]
+            elif self.outl[0]["e_T"] == 0 and self.outl[1]["e_T"] != 0:
+                A[row, self.outl[0]["CostVar_index"]["T"]] = 1
+            elif self.outl[0]["e_T"] != 0 and self.outl[1]["e_T"] == 0:
+                A[row, self.outl[1]["CostVar_index"]["T"]] = 1
+            else:
+                A[row, self.outl[0]["CostVar_index"]["T"]] = 1
+                A[row, self.outl[1]["CostVar_index"]["T"]] = -1
+
+        # Determine the thermal case based on temperatures.
+        # 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}"
+        # Case 2: All temperatures <= T0.
+        elif all([c["T"] <= T0 for c in self.inl + self.outl]):
+            set_thermal_f_cold(A, counter + 0)
+            equations[counter] = f"aux_f_rule_cold_{self.name}"
+        # Case 3: Mixed temperatures: inl[0]["T"] > T0 and outl[1]["T"] > T0, while outl[0]["T"] <= T0 and 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}"
+        # Case 4: Mixed temperatures: inl[0]["T"] > T0, inl[1]["T"] <= T0, and both outl[0]["T"] and 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}"
+        # Case 5: Mixed temperatures: inl[0]["T"] > T0, inl[1]["T"] <= T0, and both outl[0]["T"] and 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}"
+        # Case 6: Mixed temperatures (dissipative case): inl[0]["T"] > T0, inl[1]["T"] <= T0, outl[0]["T"] > T0, and 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}"
+        
+        # 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']}"
+        
+        # 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']}"
+            num_aux_eqs = 5
+        else:
+            # Skip chemical auxiliary equations.
+            num_aux_eqs = 3
+
+        for i in range(num_aux_eqs):
+            b[counter + i] = 0
+
+        return A, b, counter + num_aux_eqs, equations
+    
+    def exergoeconomic_balance(self, T0):
+        """
+        Perform exergoeconomic balance calculations for the condenser.
+        
+        This method calculates various exergoeconomic parameters including:
+        - Cost rates of product (C_P) and fuel (C_F)
+        - Specific cost of product (c_P) and fuel (c_F)
+        - Cost rate of exergy destruction (C_D)
+        - Relative cost difference (r)
+        - Exergoeconomic factor (f)
+        
+        Parameters
+        ----------
+        T0 : float
+            Ambient temperature
+            
+        Notes
+        -----
+        The exergoeconomic balance considers thermal (T), chemical (CH),
+        and mechanical (M) exergy components for the inlet and outlet streams.
+        """
+        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"])
+        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_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_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"])
+        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.C_F / self.E_F
+        self.c_P = self.C_P / self.E_P
+        self.C_D = self.c_F * self.E_D
+        self.r = (self.c_P - self.c_F) / self.c_F
+        self.f = self.Z_costs / (self.Z_costs + self.C_D)

exerpy/components/heat_exchanger/simple.py

@@ -0,0 +1,358 @@
+import logging
+
+import numpy as np
+
+from exerpy.components.component import Component
+from exerpy.components.component import component_registry
+
+
+@component_registry
+class SimpleHeatExchanger(Component):
+    r"""
+    Class for exergy 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.
+
+    Attributes
+    ----------
+    E_F : float
+        Exergy fuel of the component :math:`\dot{E}_\mathrm{F}` in :math:`\mathrm{W}`.
+    E_P : float
+        Exergy product of the component :math:`\dot{E}_\mathrm{P}` in :math:`\mathrm{W}`.
+    E_D : float
+        Exergy destruction of the component :math:`\dot{E}_\mathrm{D}` in :math:`\mathrm{W}`.
+    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.
+    outl : dict
+        Dictionary containing outlet stream data with temperature, mass flows,
+        enthalpies, and specific exergies.
+
+    Notes
+    -----
+    The exergy analysis considers three main cases based on heat transfer direction
+    and temperatures relative to ambient temperature :math:`T_0`:
+
+    Case 1 - **Heat Release** (:math:`\dot{Q} < 0`):
+
+    a) Both temperatures above ambient:
+
+    .. 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})
+
+    b) Inlet above, outlet below ambient:
+
+    .. 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})
+
+    c) Both temperatures below ambient:
+
+    .. 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})
+
+    Case 2 - **Heat Addition** (:math:`\dot{Q} > 0`):
+
+    a) Both temperatures above ambient:
+
+    .. 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})
+
+    b) Inlet below, outlet above ambient:
+
+    .. 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})
+
+    c) Both temperatures below ambient:
+
+    .. 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})
+
+    Case 3 - **Dissipative** (it is not possible to specify the exergy product :math:`\dot{E}_\mathrm{P}` for this component):
+
+    .. 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})
+
+    For all cases, the exergy destruction is calculated as:
+
+    .. math::
+        \dot{E}_\mathrm{D} = \dot{E}_\mathrm{F} - \dot{E}_\mathrm{P}
+
+    Where:
+        - :math:`e^\mathrm{T}`: Thermal exergy
+        - :math:`e^\mathrm{PH}`: Physical exergy
+        - :math:`e^\mathrm{M}`: Mechanical exergy
+    """
+
+    def __init__(self, **kwargs):
+        r"""Initialize simple heat exchanger component with given parameters."""
+        super().__init__(**kwargs)
+
+    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
+        r"""
+        Calculate the exergy balance of the simple heat exchanger.
+
+        Performs exergy balance calculations considering both heat transfer direction
+        and temperature levels relative to ambient temperature.
+
+        Parameters
+        ----------
+        T0 : float
+            Ambient temperature in :math:`\mathrm{K}`.
+        p0 : float
+            Ambient pressure in :math:`\mathrm{Pa}`.
+        split_physical_exergy : bool
+            Flag indicating whether physical exergy is split into thermal and mechanical components.
+
+        Raises
+        ------
+        ValueError
+            If the required inlet and outlet streams are not properly defined or
+            exceed the maximum allowed number.
+        """      
+        # 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:
+            msg = "SimpleHeatExchanger requires at least one inlet and one outlet as well as one heat flow."
+            logging.error(msg)
+            raise ValueError(msg)
+        if len(self.inl) > 2 or len(self.outl) > 2:
+            msg = "SimpleHeatExchanger requires a maximum of two inlets and two outlets."
+            logging.error(msg)
+            raise ValueError(msg)
+
+        # Extract inlet and outlet streams
+        inlet = self.inl[0]
+        outlet = self.outl[0]
+
+        # Calculate heat transfer Q
+        Q = outlet['m'] * outlet['h'] - inlet['m'] * inlet['h']
+
+        # Initialize E_P and E_F
+        self.E_P = 0.0
+        self.E_F = 0.0
+
+        # Case 1: Heat is released (Q < 0)
+        if Q < 0:
+            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'])
+                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'])
+
+            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']))
+                else:
+                    self.E_P = outlet['m'] * outlet['e_PH']
+                    self.E_F = inlet['m'] * 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 = 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'])
+
+            else:
+                # Unimplemented corner case
+                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 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'])
+                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:
+                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']))
+                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:
+                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'])
+                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'])
+            else:
+                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'])
+
+        # Calculate exergy destruction
+        if np.isnan(self.E_P):
+            self.E_D = self.E_F
+        else:
+            self.E_D = self.E_F - self.E_P
+
+        # Calculate exergy efficiency
+        self.epsilon = self.calc_epsilon()
+
+        # Log the results
+        logging.info(
+            f"SimpleHeatExchanger exergy balance 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):
+        """
+        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
+        
+        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.
+        """
+        # --- 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"
+            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
+
+        # --- 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
+
+        # --- 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
+        else:
+            counter += 2
+
+        return A, b, counter, equations