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

exerpy/components/heat_exchanger/steam_generator.py

@@ -1,123 +1,134 @@
 import logging
 
-from exerpy.components.component import Component
-from exerpy.components.component import component_registry
+from exerpy.components.component import Component, component_registry
 
 
 @component_registry
 class SteamGenerator(Component):
     r"""
-    Class for exergy analysis of steam generators.
+    Class for exergy and exergoeconomic analysis of heat exchangers.
 
-    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.
+    This class performs exergy and exergoeconomic analysis calculations for heat exchanger components,
+    accounting for two inlet and two outlet streams across various temperature regimes, including
+    above and below ambient temperature, and optional dissipative behavior.
 
     Attributes
     ----------
     E_F : float
-        Exergy fuel of the component :math:`\dot{E}_F` in :math:`\mathrm{W}`.
+        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}_P` in :math:`\mathrm{W}`.
+        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}_D` in :math:`\mathrm{W}`.
+        Exergy destruction of the component :math:`\dot{E}_\mathrm{D}` in :math:`\mathrm{W}`.
     epsilon : float
-        Exergetic efficiency :math:`\varepsilon`.
+        Exergetic efficiency of the component :math:`\varepsilon` in :math:`-`.
     inl : dict
-        Dictionary containing inlet streams.
+        Dictionary containing inlet stream data with mass flows and specific exergies.
     outl : dict
-        Dictionary containing outlet streams.
+        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`.
+
+    Notes
+    -----
+    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
+
     """
 
     def __init__(self, **kwargs):
-        r"""Initialize steam generator component with given parameters."""
-        self.dissipative = False
+        r"""
+        Initialize the steam generator component.
+
+        Parameters
+        ----------
+        **kwargs : dict
+            Arbitrary keyword arguments. Recognized keys:
+            - Ex_C_col (dict): custom cost coefficients, default {}
+            - Z_costs (float): investment cost rate in currency/h, default 0.0
+        """
         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.
+        Compute the exergy balance of the steam generator.
 
-        This method computes the exergy fuel from the heat inlet using the relation
+        The exergy fuel is defined as follows.
+
+        If `split_physical_exergy` is `True`:
 
         .. 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}}}
+            \dot{E}_{\mathrm{F}}
+            = \bigl[\dot{E}^{\mathrm{T}}_{\mathrm{out,HP}} - \dot{E}^{\mathrm{T}}_{\mathrm{in,HP}}\bigr]
+            + \bigl[\dot{E}^{\mathrm{T}}_{\mathrm{out,IP}} - \dot{E}^{\mathrm{T}}_{\mathrm{in,IP}}\bigr]
+            - \dot{E}^{\mathrm{T}}_{\mathrm{w,HP}}
+            - \dot{E}^{\mathrm{T}}_{\mathrm{w,IP}}
 
-        and the exergy product as
+        If `split_physical_exergy` is `False`:
 
         .. 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}}
+            \dot{E}_{\mathrm{F}}
+            = \bigl[\dot{E}^{\mathrm{PH}}_{\mathrm{out,HP}} - \dot{E}^{\mathrm{PH}}_{\mathrm{in,HP}}\bigr]
+            + \bigl[\dot{E}^{\mathrm{PH}}_{\mathrm{out,IP}} - \dot{E}^{\mathrm{PH}}_{\mathrm{in,IP}}\bigr]
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{w,HP}}
+            - \dot{E}^{\mathrm{PH}}_{\mathrm{w,IP}}
 
-        The exergy destruction is given by
+        The exergy product is defined as:
 
         .. math::
-            E_D = E_F - E_P
 
-        and the exergetic efficiency is
+            \dot{E}_\mathrm{P} = \Bigl[ \dot E^{\mathrm{PH}}_{\mathrm{out,HP}}
+            - \dot E^{\mathrm{PH}}_{\mathrm{in,HP}} \Bigr]
+            + \Bigl[ \dot E^{\mathrm{PH}}_{\mathrm{out,IP}}
+            - \dot E^{\mathrm{PH}}_{\mathrm{in,IP}} \Bigr]
+            - \dot E^{\mathrm{PH}}_{\mathrm{w,HP}}
+            - \dot E^{\mathrm{PH}}_{\mathrm{w,IP}}
 
-        .. math::
-            \varepsilon = \frac{E_P}{E_F}
+        where the subscripts HP and IP denote high and intermediate pressure streams,
+        respectively, and w stands for water injection.
 
         Parameters
         ----------
         T0 : float
-            Ambient temperature in Kelvin.
+            Ambient temperature (K).
+        p0 : float
+            Ambient pressure (Pa).
+        split_physical_exergy : bool
+            Whether to split thermal and mechanical exergy.
+
+        Raises
+        ------
+        ValueError
+            If required inlets or outlets are missing.
         """
         # Ensure that all necessary streams exist
         required_inlets = [0]
@@ -129,34 +140,35 @@ class SteamGenerator(Component):
             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'
+        exergy_type = "e_T" if split_physical_exergy else "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]
+        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)
+        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)
+        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.")
+        logging.warning(
+            "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']
+        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)
+        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)
+        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
@@ -165,31 +177,39 @@ class SteamGenerator(Component):
 
         # Log the results
         logging.info(
-            f"SteamGenerator exergy balance calculated: "
+            f"Exergy balance of SteamGenerator {self.name} 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):
+        r"""
+        This function must be implemented in the future.
+
+        The exergoeconomic analysis of SteamGenerator is not implemented yet.
+        """
+        logging.error(
+            "The exergoeconomic analysis of SteamGenerator is not implemented yet. "
+            "This method will be implemented in a future release."
+        )
         """
         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
@@ -204,7 +224,7 @@ class SteamGenerator(Component):
             Dictionary for storing equation labels.
         chemical_exergy_enabled : bool
             Flag indicating whether chemical exergy auxiliary equations should be added.
-        
+
         Returns
         -------
         A : numpy.ndarray
@@ -217,48 +237,58 @@ class SteamGenerator(Component):
             Updated dictionary with equation labels.
         """
 
-    def exergoeconomic_balance(self, T0):
+    def exergoeconomic_balance(self, T0, chemical_exergy_enabled=False):
+        r"""
+        This function must be implemented in the future.
+
+        The exergoeconomic analysis of SteamGenerator is not implemented yet.
+        """
+
+        logging.error(
+            "The exergoeconomic analysis of SteamGenerator is not implemented yet. "
+            "This method will be implemented in a future release."
+        )
         """
         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
-            
+        chemical_exergy_enabled : bool, optional
+            If True, chemical exergy is considered in the calculations.
+
         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_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'])
+            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']
+            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']
+            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']
+        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_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')
+        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

@@ -2,15 +2,15 @@ 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 CycleCloser(Component):
     r"""
-    Component for closing cycles. This component is not analyzed in exergy analysis.
+    Component for closing cycles. This component is not considered in exergy analysis, but it is used in exergoeconomic analysis.
     """
+
     def __init__(self, **kwargs):
         r"""Initialize CycleCloser component with given parameters."""
         super().__init__(**kwargs)
@@ -18,7 +18,7 @@ class CycleCloser(Component):
     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
@@ -26,24 +26,21 @@ class CycleCloser(Component):
         self.epsilon = np.nan
 
         # Log the results
-        logging.info(
-            f"The exergy balance of a CycleCloser component is skipped."
-        )
+        logging.info(f"The exergy balance of a CycleCloser {self.name} 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 
+
+        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 
+
+        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
@@ -59,7 +56,7 @@ class CycleCloser(Component):
         chemical_exergy_enabled : bool
             Flag indicating whether chemical exergy auxiliary equations should be added.
             This flag is ignored for CycleCloser.
-        
+
         Returns
         -------
         A : numpy.ndarray
@@ -74,31 +71,61 @@ class CycleCloser(Component):
         # 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"
+        equations[counter] = {
+            "kind": "aux_equality",
+            "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+            "property": "c_M",
+        }
         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
+        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] = {
+            "kind": "aux_equality",
+            "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+            "property": "c_T",
+        }
+        b[counter + 1] = 0
 
         counter += 2
+
+        if chemical_exergy_enabled:
+            # Chemical cost equality equation:
+            A[counter, self.inl[0]["CostVar_index"]["CH"]] = (1 / self.inl[0]["e_C"]) if self.inl[0]["e_CH"] != 0 else 1
+            A[counter, self.outl[0]["CostVar_index"]["CH"]] = (
+                (-1 / self.outl[0]["e_C"]) if self.outl[0]["e_CH"] != 0 else -1
+            )
+            equations[counter] = {
+                "kind": "aux_equality",
+                "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                "property": "c_CH",
+            }
+            b[counter] = 0
+
+            counter += 1
+
         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.
+
+    def exergoeconomic_balance(self, T0, chemical_exergy_enabled=False) -> None:
         """
+        Exergoeconomic balance for the CycleCloser is not defined.
+
+        This component does not generate or consume exergy, so all cost terms are undefined.
 
+        Parameters
+        ----------
+        T0 : float
+            Ambient temperature (unused).
+        chemical_exergy_enabled : bool, optional
+            If True, chemical exergy is considered in the calculations.
+        """
+        self.C_F = np.nan
         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 
+        self.C_D = np.nan
+        self.c_TOT = np.nan
+        self.C_TOT = np.nan
+        self.r = np.nan
+        self.f = np.nan

exerpy/components/helpers/power_bus.py

@@ -0,0 +1,117 @@
+import logging
+
+import numpy as np
+
+from exerpy.components.component import Component, component_registry
+
+
+@component_registry
+class PowerBus(Component):
+    r"""
+    Component for power busses. This component is not considered in exergy analysis, but it is used in exergoeconomic 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 PowerBus 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 PowerBus {self.name} 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.
+        """
+
+        # Splitter case
+        if len(self.inl) >= 1 and len(self.outl) <= 1:
+            logging.info(f"PowerBus {self.name} has only one output, no auxiliary equations added.")
+
+        # Mixer case
+        elif len(self.inl) == 1 and len(self.outl) > 1:
+            logging.info(f"PowerBus {self.name} has multiple outputs, auxiliary equations will be added.")
+            for out in list(self.outl.values())[:]:
+                A[counter, self.inl[0]["CostVar_index"]["exergy"]] = (
+                    (1 / self.inl[0]["E"]) if self.inl[0]["E"] != 0 else 1
+                )
+                A[counter, out["CostVar_index"]["exergy"]] = (-1 / out["E"]) if out["E"] != 0 else -1
+                equations[counter] = {
+                    "kind": "aux_power_eq",
+                    "objects": [self.name, self.inl[0]["name"], out["name"]],
+                    "property": "c_TOT",
+                }
+                b[counter] = 0
+                counter += 1
+
+        # Mixer case with multiple inputs and outputs
+        else:
+            logging.error(f"PowerBus {self.name} has multiple inputs and outputs, which has not been implemented yet.")
+
+        return A, b, counter, equations
+
+    def exergoeconomic_balance(self, T0, chemical_exergy_enabled=False) -> None:
+        """
+        Exergoeconomic balance for the PowerBus is not defined.
+
+        This component does not convert or destroy exergy, so all cost terms are undefined.
+
+        Parameters
+        ----------
+        T0 : float
+            Ambient temperature (unused).
+        chemical_exergy_enabled : bool, optional
+            If True, chemical exergy is considered in the calculations.
+        """
+        self.C_F = np.nan
+        self.C_P = np.nan
+        self.C_D = np.nan
+        self.c_TOT = np.nan
+        self.C_TOT = np.nan
+        self.r = np.nan
+        self.f = np.nan