exerpy 0.0.1__py3-none-any.whl

exerpy/components/turbomachinery/pump.py

@@ -0,0 +1,310 @@
+import logging
+
+import numpy as np
+
+from exerpy.components.component import Component
+from exerpy.components.component import component_registry
+
+
+@component_registry
+class Pump(Component):
+    r"""
+    Class for exergy analysis of pumps.
+
+    This class performs exergy analysis calculations for pumps, with definitions
+    of exergy product and fuel varying based on the temperature relationships between
+    inlet stream, 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:`-`.
+    P : float
+        Power input to the pump in :math:`\mathrm{W}`.
+    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 cases based on temperature relationships:
+
+    Case 1 - **Both temperatures above ambient** (:math:`T_\mathrm{in}, T_\mathrm{out} > T_0`):
+
+    .. math::
+
+        \dot{E}_\mathrm{P} &= \dot{m} \cdot (e_\mathrm{out}^\mathrm{PH} -
+        e_\mathrm{in}^\mathrm{PH})\\
+        \dot{E}_\mathrm{F} &= |\dot{W}|
+
+    Case 2 - **Inlet below, outlet above ambient** (:math:`T_\mathrm{in} < T_0 < T_\mathrm{out}`):
+
+    .. math::
+
+        \dot{E}_\mathrm{P} &= |\dot{W}| + (e_\mathrm{out}^\mathrm{PH} -
+        e_\mathrm{in}^\mathrm{M})\\
+        \dot{E}_\mathrm{F} &= e_\mathrm{in}^\mathrm{M} + e_\mathrm{in}^\mathrm{PH}
+
+    Case 3 - **Both temperatures below ambient** (:math:`T_\mathrm{in}, T_\mathrm{out} \leq T_0`):
+
+    .. math::
+
+        \dot{E}_\mathrm{P} &= e_\mathrm{out}^\mathrm{M} - e_\mathrm{in}^\mathrm{M}\\
+        \dot{E}_\mathrm{F} &= e_\mathrm{in}^\mathrm{PH} - e_\mathrm{out}^\mathrm{PH}
+
+    For all valid cases, the exergy destruction is:
+
+    .. math::
+
+        \dot{E}_\mathrm{D} = \dot{E}_\mathrm{F} - \dot{E}_\mathrm{P}
+
+    where:
+        - :math:`\dot{W}`: Power input
+        - :math:`e^\mathrm{PH}`: Physical exergy
+        - :math:`e^\mathrm{M}`: Mechanical exergy
+    """
+
+    def __init__(self, **kwargs):
+        r"""Initialize pump component with given parameters."""
+        super().__init__(**kwargs)
+        self.P = None
+
+    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
+        r"""
+        Calculate the exergy balance of the pump.
+
+        Performs exergy balance calculations considering the temperature relationships
+        between inlet stream, 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.
+
+        """
+        # Get power flow if not already available
+        if self.P is None:
+            self.P = self.outl[0]['m'] * (self.outl[0]['h'] - self.inl[0]['h'])
+
+        # First, check for the invalid case: outlet temperature smaller than inlet temperature.
+        if self.inl[0]['T'] > self.outl[0]['T']:
+            logging.warning(
+                f"Exergy balance of pump '{self.name}' where outlet temperature ({self.outl[0]['T']}) "
+                f"is smaller than inlet temperature ({self.inl[0]['T']}) is not implemented."
+            )
+            self.E_P = np.nan
+            self.E_F = np.nan
+
+        # Case 1: Both temperatures above ambient
+        elif round(self.inl[0]['T'], 5) >= T0 and round(self.outl[0]['T'], 5) > T0:
+            self.E_P = self.outl[0]['m'] * (self.outl[0]['e_PH'] - self.inl[0]['e_PH'])
+            self.E_F = abs(self.P)
+
+        # Case 2: Inlet below, outlet above ambient
+        elif round(self.inl[0]['T'], 5) < T0 and round(self.outl[0]['T'], 5) > T0:
+            if split_physical_exergy:
+                self.E_P = (self.outl[0]['m'] * self.outl[0]['e_T'] +
+                            self.outl[0]['m'] * (self.outl[0]['e_M'] - self.inl[0]['e_M']))
+                self.E_F = abs(self.P) + self.inl[0]['m'] * self.inl[0]['e_T']
+            else:
+                logging.warning("While dealing with pump below ambient, "
+                                "physical exergy should be split into thermal and mechanical components!")
+                self.E_P = self.outl[0]['m'] * (self.outl[0]['e_PH'] - self.inl[0]['e_PH'])
+                self.E_F = abs(self.P)
+
+        # Case 3: Both temperatures below ambient
+        elif round(self.inl[0]['T'], 5) < T0 and round(self.outl[0]['T'], 5) <= T0:
+            if split_physical_exergy:
+                self.E_P = self.outl[0]['m'] * (self.outl[0]['e_M'] - self.inl[0]['e_M'])
+                self.E_F = abs(self.P) + self.inl[0]['m'] * (self.inl[0]['e_T'] -
+                                                            self.outl[0]['e_T'])
+            else:
+                logging.warning("While dealing with pump below ambient, "
+                                "physical exergy should be split into thermal and mechanical components!")
+                self.E_P = self.outl[0]['m'] * (self.outl[0]['e_PH'] - self.inl[0]['e_PH'])
+                self.E_F = abs(self.P)
+
+        # Invalid case: outlet temperature smaller than inlet
+        else:
+            logging.warning(
+                'Exergy balance of a pump where outlet temperature is smaller '
+                'than inlet temperature is not implemented.'
+            )
+            self.E_P = np.nan
+            self.E_F = np.nan
+
+        # 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"Pump 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 pump.
+        
+        This function adds rows to the cost matrix A and the right-hand-side vector b to enforce
+        the following auxiliary cost relations:
+        
+        (1) 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
+            
+        (2) Thermal/Mechanical exergy cost equations (based on temperature conditions):
+            
+            Case 1 (T_in > T0, T_out > T0):
+            1/dET * C_T_out - 1/dET * C_T_in - 1/dEM * C_M_out + 1/dEM * C_M_in = 0
+            - P-principle: relates inlet/outlet thermal and mechanical exergy costs
+            
+            Case 2 (T_in ≤ T0, T_out > T0):
+            1/E_T_out * C_T_out - 1/dEM * C_M_out + 1/dEM * C_M_in = 0
+            - P-principle: relates outlet thermal and inlet/outlet mechanical exergy costs
+            
+            Case 3 (T_in ≤ T0, T_out ≤ T0):
+            1/E_T_out * C_T_out - 1/E_T_in * C_T_in = 0
+            - F-principle: specific thermal 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 : list or dict
+            Data structure 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 : list or dict
+            Updated structure with equation labels.
+        """
+        # --- Chemical equality equation (row added only if enabled) ---
+        if chemical_exergy_enabled:
+            # Set the chemical cost equality:
+            A[counter, self.inl[0]["CostVar_index"]["CH"]] = (1 / self.inl[0]["E_CH"]) if self.inl[0]["e_CH"] != 0 else 1
+            A[counter, self.outl[0]["CostVar_index"]["CH"]] = (-1 / self.outl[0]["E_CH"]) if self.outl[0]["e_CH"] != 0 else 1
+            equations[counter] = f"aux_equality_chem_{self.outl[0]['name']}"
+            chem_row = 1
+        else:
+            chem_row = 0
+
+        # --- Thermal/Mechanical cost equation ---
+        # Compute differences in thermal and mechanical exergy:
+        dET = self.outl[0]["E_T"] - self.inl[0]["E_T"]
+        dEM = self.outl[0]["E_M"] - self.inl[0]["E_M"]
+        
+        # The row for the thermal/mechanical equation:
+        row_index = counter + chem_row
+        if self.inl[0]["T"] > T0 and self.outl[0]["T"] > T0:
+            if dET != 0 and dEM != 0:
+                A[row_index, self.inl[0]["CostVar_index"]["T"]] = -1 / dET
+                A[row_index, self.outl[0]["CostVar_index"]["T"]] = 1 / dET
+                A[row_index, self.inl[0]["CostVar_index"]["M"]] = 1 / dEM
+                A[row_index, self.outl[0]["CostVar_index"]["M"]] = -1 / dEM
+                equations[row_index] = f"aux_p_rule_{self.name}"
+            else:
+                logging.warning("Case where thermal or mechanical exergy difference is zero is not implemented.")
+        elif self.inl[0]["T"] <= T0 and self.outl[0]["T"] > T0:
+            A[row_index, self.outl[0]["CostVar_index"]["T"]] = 1 / self.outl[0]["E_T"]
+            A[row_index, self.inl[0]["CostVar_index"]["M"]] = 1 / dEM
+            A[row_index, self.outl[0]["CostVar_index"]["M"]] = -1 / dEM
+            equations[row_index] = f"aux_p_rule_{self.name}"
+        else:
+            A[row_index, self.inl[0]["CostVar_index"]["T"]] = -1 / self.inl[0]["E_T"]
+            A[row_index, self.outl[0]["CostVar_index"]["T"]] = 1 / self.outl[0]["E_T"]
+            equations[row_index] = f"aux_f_rule_{self.name}"
+        
+        # Set the right-hand side entry for the thermal/mechanical row to zero.
+        b[row_index] = 0
+
+        # Update the counter accordingly.
+        if chemical_exergy_enabled:
+            new_counter = counter + 2
+        else:
+            new_counter = counter + 1
+
+        return A, b, new_counter, equations
+
+    def exergoeconomic_balance(self, T0):
+        """
+        Perform exergoeconomic balance calculations for the pump.
+        
+        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.
+        """
+        # Retrieve the cost of power from the inlet stream of kind "power"
+        power_cost = None
+        for stream in self.inl.values():
+            if stream.get("kind") == "power":
+                power_cost = stream.get("C_TOT")
+                break
+        if power_cost is None:
+            logging.error("No inlet power stream found to determine power cost (C_TOT).")
+            raise ValueError("No inlet power stream found for exergoeconomic_balance.")
+
+        # Compute product and fuel costs depending on inlet/outlet temperatures relative to T0.
+        if self.inl[0]["T"] >= T0 and self.outl[0]["T"] >= T0:
+            self.C_P = self.outl[0]["C_PH"] - self.inl[0]["C_PH"]
+            self.C_F = power_cost
+        elif self.inl[0]["T"] <= T0 and self.outl[0]["T"] > T0:
+            self.C_P = self.outl[0]["C_T"] + (self.outl[0]["C_M"] - self.inl[0]["C_M"])
+            self.C_F = power_cost + self.inl[0]["C_T"]
+        elif self.inl[0]["T"] <= T0 and self.outl[0]["T"] <= T0:
+            self.C_P = self.outl[0]["C_M"] - self.inl[0]["C_M"]
+            self.C_F = power_cost + (self.inl[0]["C_T"] - self.outl[0]["C_T"])
+
+        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/turbomachinery/turbine.py

@@ -0,0 +1,351 @@
+import logging
+
+import numpy as np
+
+from exerpy.components.component import Component
+from exerpy.components.component import component_registry
+
+
+@component_registry
+class Turbine(Component):
+    r"""
+    Class for exergy analysis of turbines.
+
+    This class performs exergy analysis calculations for turbines, with definitions
+    of exergy product and fuel varying based on the temperature relationships between
+    inlet stream, 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:`-`.
+    P : float
+        Power output of the turbine in :math:`\mathrm{W}`.
+    inl : dict
+        Dictionary containing inlet stream data with temperature, mass flows,
+        enthalpies, and specific exergies. Must have at least one inlet.
+    outl : dict
+        Dictionary containing outlet streams data with temperature, mass flows,
+        enthalpies, and specific exergies. Can have multiple outlets, their
+        properties will be summed up in the calculations.
+
+    Notes
+    -----
+    The exergy analysis considers three cases based on temperature relationships:
+
+    .. math::
+
+        \dot{E}_\mathrm{P} =
+        \begin{cases}
+        -P & T_\mathrm{in}, T_\mathrm{out} \geq T_0\\
+        -P + \dot{E}_\mathrm{out}^\mathrm{T}
+        & T_\mathrm{in} > T_0 \geq T_\mathrm{out}\\
+        -P + \dot{E}_\mathrm{out}^\mathrm{T} - \dot{E}_\mathrm{in}^\mathrm{T}
+        & T_0 \geq T_\mathrm{in}, T_\mathrm{out}
+        \end{cases}
+
+        \dot{E}_\mathrm{F} =
+        \begin{cases}
+        \dot{E}_\mathrm{in}^\mathrm{PH} - \dot{E}_\mathrm{out}^\mathrm{PH}
+        & T_\mathrm{in}, T_\mathrm{out} \geq T_0\\
+        \dot{E}_\mathrm{in}^\mathrm{T} + \dot{E}_\mathrm{in}^\mathrm{M} -
+        \dot{E}_\mathrm{out}^\mathrm{M}
+        & T_\mathrm{in} > T_0 \geq T_\mathrm{out}\\
+        \dot{E}_\mathrm{in}^\mathrm{M} - \dot{E}_\mathrm{out}^\mathrm{M}
+        & T_0 \geq T_\mathrm{in}, T_\mathrm{out}
+        \end{cases}
+    """
+
+    def __init__(self, **kwargs):
+        r"""Initialize turbine component with given parameters."""
+        super().__init__(**kwargs)
+        self.P = None
+
+    def calc_exergy_balance(self, T0: float, p0: float, split_physical_exergy) -> None:
+        r"""
+        Calculate the exergy balance of the turbine.
+
+        Performs exergy balance calculations considering the temperature relationships
+        between inlet stream, 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.
+        """
+        # Get power flow if not already available
+        if self.P is None:
+            self.P = self._total_outlet('m', 'h') - self.inl[0]['m'] * self.inl[0]['h']
+
+        # Case 1: Both temperatures above ambient
+        if self.inl[0]['T'] >= T0 and self.outl[0]['T'] >= T0 and self.inl[0]['T'] >= self.outl[0]['T']:
+            self.E_P = abs(self.P)
+            self.E_F = (self.inl[0]['m'] * self.inl[0]['e_PH'] -
+                        self._total_outlet('m', 'e_PH'))
+
+        # Case 2: Inlet above, outlet at/below ambient
+        elif self.inl[0]['T'] > T0 and self.outl[0]['T'] <= T0:
+            if split_physical_exergy:
+                self.E_P = abs(self.P) + self._total_outlet('m', 'e_T')
+                self.E_F = (self.inl[0]['m'] * self.inl[0]['e_T'] +
+                            self.inl[0]['m'] * self.inl[0]['e_M'] -
+                            self._total_outlet('m', 'e_M'))
+            else:
+                logging.warning("While dealing with expander below ambient, "
+                                "physical exergy should be split into thermal and mechanical components!")
+                self.E_P = np.nan
+                self.E_F = np.nan
+
+        # Case 3: Both temperatures at/below ambient
+        elif self.inl[0]['T'] <= T0 and self.outl[0]['T'] <= T0:
+            if split_physical_exergy:
+                self.E_P = abs(self.P) + (
+                    self._total_outlet('m', 'e_T') - self.inl[0]['m'] * self.inl[0]['e_T'])
+                self.E_F = (self.inl[0]['m'] * self.inl[0]['e_M'] -
+                            self._total_outlet('m', 'e_M'))
+            else:
+                logging.warning("While dealing with expander below ambient, "
+                                "physical exergy should be split into thermal and mechanical components!")
+                self.E_P = np.nan
+                self.E_F = np.nan
+        # Invalid case: outlet temperature larger than inlet
+        else:
+            logging.warning(
+                'Exergy balance of a turbine where outlet temperature is larger '
+                'than inlet temperature is not implemented.'
+            )
+            self.E_P = np.nan
+            self.E_F = np.nan
+
+        # Calculate exergy destruction and efficiency
+        self.E_D = self.E_F - self.E_P
+        if self.E_F == np.nan:
+            self.E_D = self.inl[0]['m'] * self.inl[0]['e_PH'] - self._total_outlet('m', 'e_PH') - abs(self.P)
+        self.epsilon = self.calc_epsilon()
+
+        # Log the results
+        logging.info(
+            f"Turbine 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 _total_outlet(self, mass_flow: str, property_name: str) -> float:
+        r"""
+        Calculate the sum of mass flow times property across all outlets.
+
+        Parameters
+        ----------
+        mass_flow : str
+            Key for the mass flow value.
+        property_name : str
+            Key for the property to be summed.
+
+        Returns
+        -------
+        float
+            Sum of mass flow times property across all outlets.
+        """
+        total = 0.0
+        for outlet in self.outl.values():
+            if outlet and mass_flow in outlet and property_name in outlet:
+                total += outlet[mass_flow] * outlet[property_name]
+        return total
+    
+
+    def aux_eqs(self, A, b, counter, T0, equations, chemical_exergy_enabled):
+        """
+        Auxiliary equations for the turbine.
+        
+        This function adds rows to the cost matrix A and the right-hand-side vector b to enforce
+        the following auxiliary cost relations:
+        
+        For each material outlet (when inlet and first outlet are above ambient temperature T0):
+        
+        (1) 1/E_T_in * C_T_in - 1/E_T_out * C_T_out = 0
+            - F-principle: specific thermal exergy costs equalized between inlet and each outlet
+            
+        (2) 1/E_M_in * C_M_in - 1/E_M_out * C_M_out = 0
+            - F-principle: specific mechanical exergy costs equalized between inlet and each outlet
+            
+        (3) 1/E_CH_in * C_CH_in - 1/E_CH_out * C_CH_out = 0 (if chemical_exergy_enabled)
+            - F-principle: specific chemical exergy costs equalized between inlet and each outlet
+        
+        For power outlets (with both source and target components):
+        
+        (4) 1/E_ref * C_ref - 1/E_out * C_out = 0
+            - P-principle: specific power exergy costs equalized across all power 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 : list or dict
+            Data structure 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 after adding all auxiliary equations.
+        equations : list or dict
+            Updated structure with equation labels.
+        """
+        # Process only if the inlet and the first outlet are above T0.
+        if self.inl[0]["T"] > T0 and self.outl[0]["T"] > T0:
+            # Filter material outlets
+            material_outlets = [outlet for outlet in self.outl.values() if outlet.get("kind") == "material"]
+            # Determine number of rows per outlet.
+            num_rows_per_outlet = 3 if chemical_exergy_enabled else 2
+
+            for i, outlet in enumerate(material_outlets):
+                row_offset = num_rows_per_outlet * i
+
+                # --- Thermal exergy equation ---
+                A[counter + row_offset, self.inl[0]["CostVar_index"]["T"]] = (
+                    1 / self.inl[0]["E_T"] if self.inl[0]["e_T"] != 0 else 1
+                )
+                A[counter + row_offset, outlet["CostVar_index"]["T"]] = (
+                    -1 / outlet["E_T"] if outlet["e_T"] != 0 else -1
+                )
+                equations[counter + row_offset] = f"aux_f_rule_{outlet['name']}"
+
+                # --- Mechanical exergy equation ---
+                A[counter + row_offset + 1, self.inl[0]["CostVar_index"]["M"]] = (
+                    1 / self.inl[0]["E_M"] if self.inl[0]["e_M"] != 0 else 1
+                )
+                A[counter + row_offset + 1, outlet["CostVar_index"]["M"]] = (
+                    -1 / outlet["E_M"] if outlet["e_M"] != 0 else -1
+                )
+                equations[counter + row_offset + 1] = f"aux_f_rule_{outlet['name']}"
+
+                # --- Chemical exergy equation (conditionally added) ---
+                if chemical_exergy_enabled:
+                    A[counter + row_offset + 2, self.inl[0]["CostVar_index"]["CH"]] = (
+                        1 / self.inl[0]["E_CH"] if self.inl[0]["e_CH"] != 0 else 1
+                    )
+                    A[counter + row_offset + 2, outlet["CostVar_index"]["CH"]] = (
+                        -1 / outlet["E_CH"] if outlet["e_CH"] != 0 else -1
+                    )
+                    equations[counter + row_offset + 2] = f"aux_f_rule_{outlet['name']}"
+            
+            # Update counter based on number of rows added for all material outlets.
+            num_material_rows = num_rows_per_outlet * len(material_outlets)
+            for j in range(num_material_rows):
+                b[counter + j] = 0
+            counter += num_material_rows
+        else:
+            logging.warning("Turbine with outlet below T0 not implemented in exergoeconomics yet!")
+        
+        # --- Auxiliary equation for shaft power equality ---
+        power_outlets = [outlet for outlet in self.outl.values()
+                        if outlet.get("kind") == "power" and outlet.get("source_component") and outlet.get("target_component")]
+        if len(power_outlets) > 1:
+            ref = power_outlets[0]
+            ref_idx = ref["CostVar_index"]["exergy"]
+            for outlet in power_outlets[1:]:
+                cur_idx = outlet["CostVar_index"]["exergy"]
+                A[counter, ref_idx] = 1 / ref["E"] if ref["E"] != 0 else 1
+                A[counter, cur_idx] = -1 / outlet["E"] if outlet["E"] != 0 else -1
+                b[counter] = 0
+                equations[counter] = f"aux_p_rule_power_{self.name}_{outlet['name']}"
+                counter += 1
+
+        return A, b, counter, equations
+
+    def exergoeconomic_balance(self, T0):
+        """
+        Perform exergoeconomic balance calculations for the turbine.
+
+        The turbine may have multiple power outputs and multiple material outputs. In this
+        function the cost of power is computed as the sum of C_TOT from all inlet streams of kind "power".
+        Material outlet costs are summed over all outlets of kind "material". The cost balance is then
+        computed according to the following cases:
+
+        Case 1 (both inlet and first outlet above T0):
+            C_P = (total power cost)
+            C_F = C_PH_inlet - (sum of C_PH from material outlets)
+
+        Case 2 (inlet above T0, outlet at or below T0):
+            C_P = (total power cost) + (sum of C_T from material outlets)
+            C_F = C_T_inlet + (C_M_inlet - (sum of C_M from material outlets))
+
+        Case 3 (both inlet and outlet at or below T0):
+            C_P = (total power cost) + ((sum of C_T from material outlets) - C_T_inlet)
+            C_F = C_M_inlet - (sum of C_M from material outlets)
+
+        Finally, the specific fuel cost (c_F), specific product cost (c_P), total cost destruction (C_D),
+        relative difference (r), and exergoeconomic factor (f) are calculated.
+
+        Parameters
+        ----------
+        T0 : float
+            Ambient temperature.
+
+        Raises
+        ------
+        ValueError
+            If required cost values are missing.
+        """
+        # Sum the cost of all outlet power streams.
+        C_power_out = sum(stream.get("C_TOT", 0) for stream in self.outl.values() if stream.get("kind") == "power")
+        # Assume a single primary inlet for material cost properties.
+        inlet = self.inl[0]
+        # Filter material outlets and sum their cost components.
+        material_outlets = [out for out in self.outl.values() if out.get("kind") == "material"]
+        sum_C_PH_out = sum(out.get("C_PH", 0) for out in material_outlets)
+        sum_C_T_out = sum(out.get("C_T", 0) for out in material_outlets)
+        sum_C_M_out = sum(out.get("C_M", 0) for out in material_outlets)
+
+        # Case 1: Both inlet and first outlet above ambient.
+        if inlet["T"] >= T0 and self.outl[0]["T"] >= T0:
+            self.C_P = C_power_out
+            self.C_F = inlet.get("C_PH", 0) - sum_C_PH_out
+
+        # Case 2: Inlet above ambient and outlet at or below ambient.
+        elif inlet["T"] > T0 and self.outl[0]["T"] <= T0:
+            self.C_P = C_power_out + sum_C_T_out
+            self.C_F = inlet.get("C_T", 0) + (inlet.get("C_M", 0) - sum_C_M_out)
+
+        # Case 3: Both inlet and outlet at or below ambient.
+        elif inlet["T"] <= T0 and self.outl[0]["T"] <= T0:
+            self.C_P = C_power_out + (sum_C_T_out - inlet.get("C_T", 0))
+            self.C_F = inlet.get("C_M", 0) - sum_C_M_out
+
+        else:
+            logging.warning("Exergoeconomic balance of a turbine with outlet temperature larger than inlet is not implemented.")
+            self.C_P = np.nan
+            self.C_F = np.nan
+
+        # Calculate the specific cost terms and exergoeconomic parameters.
+        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)