exerpy 0.0.1__py3-none-any.whl

exerpy/components/heat_exchanger/steam_generator.py

@@ -0,0 +1,264 @@
+import logging
+
+from exerpy.components.component import Component
+from exerpy.components.component import component_registry
+
+
+@component_registry
+class SteamGenerator(Component):
+    r"""
+    Class for exergy analysis of steam generators.
+
+    This class performs exergy analysis calculations for steam generators.
+    The component has several input and output streams as follows:
+
+        Inlet streams:
+            - inl[0]: Feed water inlet (high pressure)
+            - inl[1]: Steam inlet (intermediate pressure)
+            - inl[2]: Heat inlet (providing the heat input Q)
+            - inl[3]: Water injection (high pressure)
+            - inl[4]: Water injection (intermediate pressure)
+
+        Outlet streams:
+            - outl[0]: Superheated steam outlet (high pressure)
+            - outl[1]: Superheated steam outlet (intermediate pressure)
+            - outl[2]: Drain / Blow down outlet
+
+    The exergy product is defined as:
+
+    .. math::
+        \dot{E}_P = \Bigl[ \dot{m}_{\mathrm{out,HP}}\,e_{\mathrm{out,HP}}
+        - \dot{m}_{\mathrm{in,HP}}\,e_{\mathrm{in,HP}} \Bigr]
+        + \Bigl[ \dot{m}_{\mathrm{out,IP}}\,e_{\mathrm{out,IP}}
+        - \dot{m}_{\mathrm{in,IP}}\,e_{\mathrm{in,IP}} \Bigr]
+        - \dot{m}_{\mathrm{w,HP}}\,e_{\mathrm{w,HP}}
+        - \dot{m}_{\mathrm{w,IP}}\,e_{\mathrm{w,IP}}
+
+    where:
+        - \(\dot{m}\) is the mass flow rate and \(e\) is the specific exergy of the stream.
+        - The subscripts HP and IP denote high and intermediate pressure streams,
+          respectively, and 'w' stands for water injection.
+
+    The exergy fuel is computed from the heat input as:
+
+    .. math::
+        \dot{E}_F = E_q = Q \left( 1 - \frac{T_b}{T_0} \right)
+
+    with the thermodynamic temperature difference defined by
+
+    .. math::
+        T_b = \frac{h_{\mathrm{out,HP}} - h_{\mathrm{in,HP}}}{s_{\mathrm{out,HP}} - s_{\mathrm{in,HP}}}
+
+    where:
+        - \(h\) and \(s\) are the specific enthalpy and entropy,
+        - \(T_0\) is the ambient temperature.
+
+    The exergy destruction and efficiency are then given by:
+
+    .. math::
+        \dot{E}_D = \dot{E}_F - \dot{E}_P \quad\mathrm{and}\quad \varepsilon = \frac{\dot{E}_P}{\dot{E}_F}
+
+    Parameters
+    ----------
+    **kwargs : dict
+        Arbitrary keyword arguments passed to the parent class.
+
+    Attributes
+    ----------
+    E_F : float
+        Exergy fuel of the component :math:`\dot{E}_F` in :math:`\mathrm{W}`.
+    E_P : float
+        Exergy product of the component :math:`\dot{E}_P` in :math:`\mathrm{W}`.
+    E_D : float
+        Exergy destruction of the component :math:`\dot{E}_D` in :math:`\mathrm{W}`.
+    epsilon : float
+        Exergetic efficiency :math:`\varepsilon`.
+    inl : dict
+        Dictionary containing inlet streams.
+    outl : dict
+        Dictionary containing outlet streams.
+    """
+
+    def __init__(self, **kwargs):
+        r"""Initialize steam generator component with given parameters."""
+        self.dissipative = False
+        super().__init__(**kwargs)
+
+    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
+        r"""
+        Calculate the exergy balance of the steam generator.
+
+        This method computes the exergy fuel from the heat inlet using the relation
+
+        .. math::
+            E_F = Q \left(1 - \frac{T_b}{T_0}\right),
+            \quad T_b = \frac{h_{\mathrm{out,HP}} - h_{\mathrm{in,HP}}}{s_{\mathrm{out,HP}} - s_{\mathrm{in,HP}}}
+
+        and the exergy product as
+
+        .. math::
+            E_P = \Bigl[ \dot{m}_{\mathrm{out,HP}}\,e_{\mathrm{out,HP}} -
+            \dot{m}_{\mathrm{in,HP}}\,e_{\mathrm{in,HP}} \Bigr]
+            + \Bigl[ \dot{m}_{\mathrm{out,IP}}\,e_{\mathrm{out,IP}} -
+            \dot{m}_{\mathrm{in,IP}}\,e_{\mathrm{in,IP}} \Bigr]
+            - \dot{m}_{\mathrm{w,HP}}\,e_{\mathrm{w,HP}}
+            - \dot{m}_{\mathrm{w,IP}}\,e_{\mathrm{w,IP}}
+
+        The exergy destruction is given by
+
+        .. math::
+            E_D = E_F - E_P
+
+        and the exergetic efficiency is
+
+        .. math::
+            \varepsilon = \frac{E_P}{E_F}
+
+        Parameters
+        ----------
+        T0 : float
+            Ambient temperature in Kelvin.
+        """
+        # Ensure that all necessary streams exist
+        required_inlets = [0]
+        required_outlets = [0, 2]
+        for idx in required_inlets:
+            if idx not in self.inl:
+                raise ValueError(f"Missing inlet stream with index {idx}.")
+        for idx in required_outlets:
+            if idx not in self.outl:
+                raise ValueError(f"Missing outlet stream with index {idx}.")
+
+        # Calculate T_b for high pressure streams: from superheated steam outlet (HP) and feed water inlet (HP)
+        try:
+            T_b = (self.outl[0]['h'] - self.inl[0]['h']) / (self.outl[0]['s'] - self.inl[0]['s'])
+        except ZeroDivisionError:
+            raise ZeroDivisionError("Division by zero encountered in calculating T_b. Check entropy differences.")
+       
+        if split_physical_exergy:
+            exergy_type = 'e_T'
+        else:
+            exergy_type = 'e_PH'
+
+        # Calculate exergy fuel
+        # High pressure part: Superheated steam outlet (HP) minus Feed water inlet (HP)
+        E_F_HP = self.outl[0]['m'] * self.outl[0][exergy_type] - self.inl[0]['m'] * self.inl[0][exergy_type]
+        # Intermediate pressure part: Superheated steam outlet (IP) minus Steam inlet (IP)
+        E_F_IP = self.outl.get(1, {}).get('m', 0) * self.outl.get(1, {}).get(exergy_type, 0) - self.inl.get(1, {}).get('m', 0) * self.inl.get(1, {}).get(exergy_type, 0)
+        # Water injection contributions (assumed to be negative)
+        E_F_w_inj = self.inl.get(2, {}).get('m', 0) * self.inl.get(2, {}).get(exergy_type, 0) + self.inl.get(3, {}).get('m', 0) * self.inl.get(3, {}).get(exergy_type, 0)
+        self.E_F = E_F_HP + E_F_IP - E_F_w_inj
+        logging.warning(f"Since the temperature level of the heat source of the steam generator is unknown, "
+                        "the exergy fuel of this component is calculated based on the thermal exergy value of the water streams.")
+        # Calculate exergy product
+        # High pressure part: Superheated steam outlet (HP) minus Feed water inlet (HP)
+        E_P_HP = self.outl[0]['m'] * self.outl[0]['e_PH'] - self.inl[0]['m'] * self.inl[0]['e_PH']
+        # Intermediate pressure part: Superheated steam outlet (IP) minus Steam inlet (IP)
+        E_P_IP = self.outl.get(1, {}).get('m', 0) * self.outl.get(1, {}).get('e_PH', 0) - self.inl.get(1, {}).get('m', 0) * self.inl.get(1, {}).get('e_PH', 0)
+        # Water injection contributions (assumed to be negative)
+        E_P_w_inj = self.inl.get(2, {}).get('m', 0) * self.inl.get(2, {}).get('e_PH', 0) + self.inl.get(3, {}).get('m', 0) * self.inl.get(3, {}).get('e_PH', 0)
+        self.E_P = E_P_HP + E_P_IP - E_P_w_inj
+
+        # Calculate exergy destruction and efficiency
+        self.E_D = self.E_F - self.E_P
+        self.epsilon = self.calc_epsilon()
+
+        # Log the results
+        logging.info(
+            f"SteamGenerator exergy balance calculated: "
+            f"E_P = {self.E_P:.2f} W, E_F = {self.E_F:.2f} W, "
+            f"E_D = {self.E_D:.2f} W, Efficiency = {self.epsilon:.2%}"
+        )
+
+
+    def aux_eqs(self, A, b, counter, T0, equations, chemical_exergy_enabled):
+        """
+        Auxiliary equations for the steam generator.
+        
+        This function adds rows to the cost matrix A and the right-hand-side vector b to enforce
+        the following auxiliary cost relations:
+        
+        (1) c_T(heat_source)/E_F = c_T(HP_outlet)/E_T(HP) + c_T(IP_outlet)/E_T(IP)
+            - P-principle: thermal exergy costs from heat source are distributed to steam outlets
+            
+        (2) 1/E_M_in(HP) * C_M_in(HP) - 1/E_M_out(HP) * C_M_out(HP) = 0
+            - F-principle: specific mechanical exergy costs equalized between HP inlet/outlet
+            
+        (3) 1/E_M_in(IP) * C_M_in(IP) - 1/E_M_out(IP) * C_M_out(IP) = 0
+            - F-principle: specific mechanical exergy costs equalized between IP inlet/outlet
+            
+        (4-5) Chemical exergy cost equations (if enabled) for HP and IP 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.
+        """
+
+    def exergoeconomic_balance(self, T0):
+        """
+        Perform exergoeconomic balance calculations for the steam generator.
+        
+        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.
+        """
+        # 1) Product cost rate: HP and IP steam net physical exergy costs, minus injection
+        C_P_hp = (self.outl[0]['m'] * self.outl[0]['C_PH']
+                  - self.inl[0]['m'] * self.inl[0]['C_PH'])
+        C_P_ip = 0.0
+        if 1 in self.outl and 1 in self.inl:
+            C_P_ip = (self.outl[1]['m'] * self.outl[1]['C_PH']
+                      - self.inl[1]['m'] * self.inl[1]['C_PH'])
+        # Subtract water injection costs
+        C_P_w = 0.0
+        if 3 in self.inl:
+            C_P_w += self.inl[3]['m'] * self.inl[3]['C_PH']
+        if 4 in self.inl:
+            C_P_w += self.inl[4]['m'] * self.inl[4]['C_PH']
+        self.C_P = C_P_hp + C_P_ip - C_P_w
+
+        # 2) Fuel cost rate: cost of heat exergy stream
+        self.C_F = self.inl[2]['C_T']
+
+        # 3) Specific costs and destruction cost
+        self.c_F = self.C_F / self.E_F if self.E_F != 0 else float('nan')
+        self.c_P = self.C_P / self.E_P if self.E_P != 0 else float('nan')
+        self.C_D = self.C_F - self.C_P
+        self.r = (self.c_P - self.c_F) / self.c_F if self.c_F != 0 else float('nan')
+        self.f = self.Z_costs / (self.Z_costs + self.C_D) if (self.Z_costs + self.C_D) != 0 else float('nan')

exerpy/components/helpers/cycle_closer.py

@@ -0,0 +1,104 @@
+import logging
+
+import numpy as np
+
+from exerpy.components.component import Component
+from exerpy.components.component import component_registry
+
+
+@component_registry
+class CycleCloser(Component):
+    r"""
+    Component for closing cycles. This component is not analyzed in exergy analysis.
+    """
+    def __init__(self, **kwargs):
+        r"""Initialize CycleCloser component with given parameters."""
+        super().__init__(**kwargs)
+
+    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
+        r"""
+        The CycleCloser component does not have an exergy balance calculation.
+        """      
+        self.E_D = np.nan
+        self.E_F = np.nan
+        self.E_P = np.nan
+        self.E_L = np.nan
+        self.epsilon = np.nan
+
+        # Log the results
+        logging.info(
+            f"The exergy balance of a CycleCloser component is skipped."
+        )
+
+    
+    def aux_eqs(self, A, b, counter, T0, equations, chemical_exergy_enabled):
+        """
+        Auxiliary equations for the cycle closer.
+        
+        This function adds two rows to the cost matrix A and the right-hand side vector b to enforce 
+        the following auxiliary cost relations:
+        
+        (1) 1/E_M_in * C_M_in - 1/E_M_out * C_M_out = 0
+        (2) 1/E_T_in * C_T_in - 1/E_T_out * C_T_out = 0
+        
+        These equations ensure that the specific mechanical and thermal costs are equalized between 
+        the inlet and outlet of the cycle closer. Chemical exergy is not considered for the cycle closer.
+        
+        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 (not used in this component).
+        equations : list or dict
+            Data structure for storing equation labels.
+        chemical_exergy_enabled : bool
+            Flag indicating whether chemical exergy auxiliary equations should be added.
+            This flag is ignored for CycleCloser.
+        
+        Returns
+        -------
+        A : numpy.ndarray
+            The updated cost matrix.
+        b : numpy.ndarray
+            The updated right-hand-side vector.
+        counter : int
+            The updated row index (increased by 2).
+        equations : list or dict
+            Updated structure with equation labels.
+        """
+        # Mechanical cost equality equation:
+        A[counter, self.inl[0]["CostVar_index"]["M"]] = (1 / self.inl[0]["e_M"]) if self.inl[0]["e_M"] != 0 else 1
+        A[counter, self.outl[0]["CostVar_index"]["M"]] = (-1 / self.outl[0]["e_M"]) if self.outl[0]["e_M"] != 0 else -1
+        equations[counter] = f"aux_cyclecloser_mech"
+        b[counter] = 0
+
+        # Thermal cost equality equation:
+        A[counter+1, self.inl[0]["CostVar_index"]["T"]] = (1 / self.inl[0]["e_T"]) if self.inl[0]["e_T"] != 0 else 1
+        A[counter+1, self.outl[0]["CostVar_index"]["T"]] = (-1 / self.outl[0]["e_T"]) if self.outl[0]["e_T"] != 0 else -1
+        equations[counter+1] = f"aux_cyclecloser_thermal"
+        b[counter+1] = 0
+
+        counter += 2
+        return A, b, counter, equations
+    
+    def exergoeconomic_balance(self, T0):
+        """
+        Placeholder for exergoeconomic balance calculations.
+        
+        The CycleCloser component is not considered in exergoeconomic analysis
+        and all calculations are skipped. NaN values are assigned to all
+        exergoeconomic parameters.
+        """
+
+        self.C_P = np.nan
+        self.C_F = np.nan   
+        self.c_F = np.nan 
+        self.c_P = np.nan 
+        self.C_D = np.nan 
+        self.r = np.nan 
+        self.f = np.nan 

exerpy/components/nodes/deaerator.py

@@ -0,0 +1,318 @@
+import logging
+
+import numpy as np
+
+from exerpy.components.component import Component
+from exerpy.components.component import component_registry
+
+
+@component_registry
+class Deaerator(Component):
+    r"""
+    Class for exergy analysis of deaerators.
+
+    This class performs exergy analysis calculations for deaerators with multiple 
+    inlet streams and one outlet stream. The exergy product and fuel definitions 
+    vary based on the temperature relationships between inlet streams, outlet 
+    stream, and ambient conditions.
+
+    Parameters
+    ----------
+    **kwargs : dict
+        Arbitrary keyword arguments passed to parent class.
+
+    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 streams data with temperature, mass flows,
+        and specific exergies.
+    outl : dict
+        Dictionary containing outlet stream data with temperature, mass flows,
+        and specific exergies.
+
+    Notes
+    -----
+    The exergy analysis accounts for physical exergy only. The equations for exergy
+    product and fuel are defined based on temperature relationships:
+
+    .. math::
+
+        \dot{E}_\mathrm{P} =
+        \begin{cases}
+        \begin{cases}
+        \sum_i \dot{m}_i \cdot (e_\mathrm{out}^\mathrm{PH} -
+        e_{\mathrm{in,}i}^\mathrm{PH})
+        & T_{\mathrm{in,}i} < T_\mathrm{out} \mathrm{ & }
+        T_{\mathrm{in,}i} \geq T_0 \\
+        \sum_i \dot{m}_i \cdot e_\mathrm{out}^\mathrm{PH}
+        & T_{\mathrm{in,}i} < T_\mathrm{out} \mathrm{ & }
+        T_{\mathrm{in,}i} < T_0 \\
+        \end{cases} & T_\mathrm{out} > T_0\\
+        \mathrm{not defined (nan)} & T_\mathrm{out} = T_0\\
+        \begin{cases}
+        \sum_i \dot{m}_i \cdot e_\mathrm{out}^\mathrm{PH}
+        & T_{\mathrm{in,}i} > T_\mathrm{out} \mathrm{ & }
+        T_{\mathrm{in,}i} \geq T_0 \\
+        \sum_i \dot{m}_i \cdot (e_\mathrm{out}^\mathrm{PH} -
+        e_{\mathrm{in,}i}^\mathrm{PH})
+        & T_{\mathrm{in,}i} > T_\mathrm{out} \mathrm{ & }
+        T_{\mathrm{in,}i} < T_0 \\
+        \end{cases} & T_\mathrm{out} < T_0\\
+        \end{cases}
+
+        \dot{E}_\mathrm{F} =
+        \begin{cases}
+        \begin{cases}
+        \sum_i \dot{m}_i \cdot (e_{\mathrm{in,}i}^\mathrm{PH} -
+        e_\mathrm{out}^\mathrm{PH})
+        & T_{\mathrm{in,}i} > T_\mathrm{out} \\
+        \sum_i \dot{m}_i \cdot e_{\mathrm{in,}i}^\mathrm{PH}
+        & T_{\mathrm{in,}i} < T_\mathrm{out} \mathrm{ & }
+        T_{\mathrm{in,}i} < T_0 \\
+        \end{cases} & T_\mathrm{out} > T_0\\
+        \sum_i \dot{m}_i \cdot e_{\mathrm{in,}i}^\mathrm{PH}
+        & T_\mathrm{out} = T_0\\
+        \begin{cases}
+        \sum_i \dot{m}_i \cdot e_{\mathrm{in,}i}^\mathrm{PH}
+        & T_{\mathrm{in,}i} > T_\mathrm{out} \mathrm{ & }
+        T_{\mathrm{in,}i} \geq T_0 \\
+        \sum_i \dot{m}_i \cdot (e_{\mathrm{in,}i}^\mathrm{PH} -
+        e_\mathrm{out}^\mathrm{PH})
+        & T_{\mathrm{in,}i} < T_\mathrm{out} \\
+        \end{cases} & T_\mathrm{out} < T_0\\
+        \end{cases}
+
+        \forall i \in \mathrm{deaerator inlets}
+    """
+
+    def __init__(self, **kwargs):
+        r"""Initialize deaerator 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 deaerator.
+
+        Performs exergy balance calculations considering the temperature relationships
+        between inlet streams, outlet stream, and ambient conditions.
+
+        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.
+        """      
+        # Ensure that the component has both inlet and outlet streams
+        if len(self.inl) < 2 or len(self.outl) < 1:
+            raise ValueError("Deaerator requires at least two inlets and one outlet.")
+
+        self.E_P = 0
+        self.E_F = 0
+
+        # Case 1: Outlet temperature is greater than T0
+        if self.outl[0]['T'] > T0:
+            for _, inlet in self.inl.items():
+                if inlet['T'] < self.outl[0]['T']:  # Tin < Tout
+                    if inlet['T'] >= T0:  # and Tin >= T0
+                        self.E_P += inlet['m'] * (self.outl[0]['e_PH'] - inlet['e_PH'])
+                    else:  # and Tin < T0
+                        self.E_P += inlet['m'] * self.outl[0]['e_PH']
+                        self.E_F += inlet['m'] * inlet['e_PH']
+                else:  # Tin > Tout
+                    self.E_F += inlet['m'] * (inlet['e_PH'] - self.outl[0]['e_PH'])
+
+        # Case 2: Outlet temperature is equal to T0
+        elif self.outl[0]['T'] == T0:
+            self.E_P = np.nan
+            for _, inlet in self.inl.items():
+                self.E_F += inlet['m'] * inlet['e_PH']
+
+        # Case 3: Outlet temperature is less than T0
+        else:
+            for _, inlet in self.inl.items():
+                if inlet['T'] > self.outl[0]['T']:  # Tin > Tout
+                    if inlet['T'] >= T0:  # and Tin >= T0
+                        self.E_P += inlet['m'] * self.outl[0]['e_PH']
+                        self.E_F += inlet['m'] * inlet['e_PH']
+                    else:  # and Tin < T0
+                        self.E_P += inlet['m'] * (self.outl[0]['e_PH'] - inlet['e_PH'])
+                else:  # Tin < Tout
+                    self.E_F += inlet['m'] * (inlet['e_PH'] - self.outl[0]['e_PH'])
+
+        # Calculate exergy destruction and efficiency
+        if np.isnan(self.E_P):
+            self.E_D = self.E_F
+        else:
+            self.E_D = self.E_F - self.E_P
+        self.epsilon = self.calc_epsilon()
+
+        # Log the results
+        logging.info(
+            f"Deaerator 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 deaerator.
+        
+        This function adds rows to the cost matrix A and the right-hand-side vector b to enforce
+        the following auxiliary cost relations:
+        
+        (1) Mixing equation for chemical exergy costs (if enabled):
+            - The outlet's specific chemical exergy cost is calculated as a mass-weighted 
+              average of the inlet streams' specific chemical exergy costs
+            - This enforces proper chemical exergy cost distribution through the deaerator
+        
+        (2) Mixing equation for mechanical exergy costs:
+            - The outlet's specific mechanical exergy cost is calculated as a mass-weighted
+              average of the inlet streams' specific mechanical exergy costs
+            - This ensures mechanical exergy costs are properly conserved in the mixing process
+            
+        Both equations implement the proportionality rule for mixing processes where
+        the outlet's specific costs should reflect the contribution of each inlet stream.
+        
+        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 (provided for consistency; not used in this function).
+        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 (increased by 2 if chemical exergy is enabled, or by 1 otherwise).
+        equations : dict
+            Updated dictionary with equation labels.
+        """
+        # --- Chemical cost auxiliary equation (conditionally added) ---
+        if chemical_exergy_enabled:
+            if self.outl[0]["e_CH"] != 0:
+                A[counter, self.outl[0]["CostVar_index"]["CH"]] = -1 / self.outl[0]["E_CH"]
+                # Iterate over inlet streams for chemical mixing.
+                for inlet in self.inl.values():
+                    if inlet["e_CH"] != 0:
+                        A[counter, inlet["CostVar_index"]["CH"]] = inlet["m"] / (self.outl[0]["m"] * inlet["E_CH"])
+                    else:
+                        A[counter, inlet["CostVar_index"]["CH"]] = 1
+            else:
+                # Outlet chemical exergy is zero: assign fallback for all inlets.
+                for inlet in self.inl.values():
+                    A[counter, inlet["CostVar_index"]["CH"]] = 1
+            equations[counter] = f"aux_mixing_chem_{self.outl[0]['name']}"
+            chem_row = 1  # One row added for chemical equation.
+        else:
+            chem_row = 0  # No row added.
+
+        # --- Mechanical cost auxiliary equation ---
+        mech_row = 0  # This row will always be added.
+        if self.outl[0]["e_M"] != 0:
+            A[counter + chem_row, self.outl[0]["CostVar_index"]["M"]] = -1 / self.outl[0]["E_M"]
+            # Iterate over inlet streams for mechanical mixing.
+            for inlet in self.inl.values():
+                if inlet["e_M"] != 0:
+                    A[counter + chem_row, inlet["CostVar_index"]["M"]] = inlet["m"] / (self.outl[0]["m"] * inlet["E_M"])
+                else:
+                    A[counter + chem_row, inlet["CostVar_index"]["M"]] = 1
+        else:
+            for inlet in self.inl.values():
+                A[counter + chem_row, inlet["CostVar_index"]["M"]] = 1
+        equations[counter + chem_row] = f"aux_mixing_mech_{self.outl[0]['name']}"
+
+        # Set the right-hand side entries to zero for the added rows.
+        if chemical_exergy_enabled:
+            b[counter] = 0
+            b[counter + 1] = 0
+            counter += 2  # Two rows were added.
+        else:
+            b[counter] = 0
+            counter += 1  # Only one row was added.
+
+        return A, b, counter, equations
+
+    def exergoeconomic_balance(self, T0):
+        """
+        Perform exergoeconomic balance calculations for the deaerator.
+        
+        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.
+        """
+        self.C_P = 0
+        self.C_F = 0
+        if self.outl[0]["T"] > T0:
+            for i in self.inl:
+                if i["T"] < self.outl[0]["T"]:
+                    # cold inlets
+                    self.C_F += i["C_M"] + i["C_CH"]
+                else:
+                    # hot inlets
+                    self.C_F += - i["M"] * i["C_T"] * i["e_T"] + (
+                        i["C_T"] + i["C_M"] + i["C_CH"])
+            self.C_F += (-self.outl[0]["C_M"] - self.outl[0]["C_CH"])
+        elif self.outl[0]["T"] - 1e-6 < T0 and self.outl[0]["T"] + 1e-6 > T0:
+            # dissipative
+            for i in self.inl:
+                self.C_F += i["C_TOT"]
+        else:
+            for i in self.inl:
+                if i["T"] > self.outl[0]["T"]:
+                    # hot inlets
+                    self.C_F += i["C_M"] + i["C_CH"]
+                else:
+                    # cold inlets
+                    self.C_F += - i["M"] * i["C_T"] * i["e_T"] + (
+                        i["C_T"] + i["C_M"] + i["C_CH"])
+            self.C_F += (-self.outl[0]["C_M"] - self.outl[0]["C_CH"])
+        self.C_P = self.C_F + self.Z_costs      # +1/num_serving_comps * C_diff
+        # ToDo: add case that merge profits from dissipative component(s)
+
+
+        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)