exerpy 0.0.2__py3-none-any.whl → 0.0.4__py3-none-any.whl

exerpy/components/heat_exchanger/steam_generator.py

@@ -1,7 +1,6 @@
 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
@@ -76,14 +75,14 @@ class SteamGenerator(Component):
             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"""
         Compute the exergy balance of the steam generator.
 
-        The exergy fuel is defined as follows. 
+        The exergy fuel is defined as follows.
 
         If `split_physical_exergy` is `True`:
 
@@ -141,28 +140,35 @@ class SteamGenerator(Component):
             if idx not in self.outl:
                 raise ValueError(f"Missing outlet stream with index {idx}.")
 
-        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
@@ -171,12 +177,11 @@ 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.
@@ -189,22 +194,22 @@ class SteamGenerator(Component):
         )
         """
         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
@@ -219,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
@@ -232,58 +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