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

exerpy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.3"
+__version__ = "0.0.4"
 
 import importlib.resources
 import os

exerpy/analyses.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 
+import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 from tabulate import tabulate
@@ -71,6 +72,10 @@ class ExergyAnalysis:
         Creates an instance from a JSON file containing system data.
     exergy_results(print_results=True)
         Displays and returns tables of exergy analysis results.
+    plot_exergy_waterfall(title=None, figsize=(12, 10), exclude_components=None, show_plot=True)
+        Creates an exergy destruction waterfall diagram visualizing exergy flow through the system.
+    print_exergy_summary()
+        Prints a concise text summary of the exergy analysis results.
     export_to_json(output_path)
         Exports the model and analysis results to a JSON file.
     _serialize()
@@ -193,6 +198,13 @@ class ExergyAnalysis:
             else:
                 # Calculate E_F, E_D, E_P
                 component.calc_exergy_balance(self.Tamb, self.pamb, self.split_physical_exergy)
+
+                # Update is_dissipative flag based on actual E_P value for Valve components
+                # This is needed because when split_physical_exergy=False, valves may become
+                # dissipative (E_P = nan) even if not initially marked as such based on temperatures
+                if component.__class__.__name__ == "Valve" and np.isnan(component.E_P):
+                    component.is_dissipative = True
+
                 # Safely calculate y and y* avoiding division by zero
                 if self.E_F != 0:
                     component.y = component.E_D / self.E_F
@@ -563,6 +575,214 @@ class ExergyAnalysis:
 
         return df_component_results, df_material_connection_results, df_non_material_connection_results
 
+    def plot_exergy_waterfall(self, title=None, figsize=(12, 10), exclude_components=None, show_plot=True):
+        """
+        Create an exergy destruction waterfall diagram.
+
+        This method visualizes the exergy flow through the system as a waterfall chart,
+        showing how exergy is destroyed in each component from the exergetic fuel (100%)
+        down to the exergetic product and losses.
+
+        Parameters
+        ----------
+        title : str, optional
+            Title for the plot. If None, no title is displayed.
+        figsize : tuple, optional
+            Figure size as (width, height) in inches. Default is (12, 10).
+        exclude_components : list, optional
+            List of component names to exclude from the diagram.
+            By default, all components with NaN E_F (Exergetic Fuel) are excluded,
+            as well as CycleCloser and PowerBus components.
+        show_plot : bool, optional
+            Whether to display the plot immediately. Default is True.
+
+        Returns
+        -------
+        fig : matplotlib.figure.Figure
+            The figure object containing the waterfall diagram.
+        ax : matplotlib.axes.Axes
+            The axes object of the waterfall diagram.
+
+        Raises
+        ------
+        RuntimeError
+            If the exergy analysis has not been performed yet (analyse() not called).
+
+        Notes
+        -----
+        - The waterfall diagram displays exergy values as percentages of the total fuel exergy.
+        - Components are sorted by their exergy destruction rate (y [%]) in descending order.
+        - Each bar represents the remaining exergy after destruction in that component.
+        - Red bars indicate exergy destruction in components.
+        - Blue bar represents the initial exergetic fuel (100%).
+        - Green bar represents the final exergetic product.
+
+        Examples
+        --------
+        >>> analysis = ExergyAnalysis.from_tespy(network, Tamb=288.15, pamb=101325)  # doctest: +SKIP
+        >>> analysis.analyse(E_F={'inputs': ['fuel']}, E_P={'outputs': ['power']})  # doctest: +SKIP
+        >>> fig, ax = analysis.plot_exergy_waterfall(title='Power Plant Exergy Waterfall')  # doctest: +SKIP
+        >>> fig.savefig('exergy_waterfall.pdf')  # doctest: +SKIP
+
+        See Also
+        --------
+        exergy_results : Display tabular exergy analysis results.
+        print_exergy_summary : Print a text summary of exergy analysis.
+        """
+        # Check if analysis has been performed
+        if not hasattr(self, "epsilon") or self.epsilon is None:
+            raise RuntimeError("Exergy analysis has not been performed yet. Please call analyse() first.")
+
+        # Get component results without printing
+        df_component_results, _, _ = self.exergy_results(print_results=False)
+
+        # Default exclusions: empty list, but filter for valid E_F
+        if exclude_components is None:
+            exclude_components = []
+
+        # Get total values from df_component_results
+        total_row = df_component_results[df_component_results["Component"] == "TOT"].iloc[0]
+        epsilon_total = total_row["ε [%]"]
+        E_L_total = total_row["E_L [kW]"]
+        E_F_total = total_row["E_F [kW]"]
+        exergetic_loss_percent = (E_L_total / E_F_total) * 100 if E_F_total != 0 else 0
+
+        # Filter components (exclude TOT, components with NaN E_F, and specified components)
+        component_data = df_component_results[
+            (df_component_results["Component"] != "TOT")
+            & (df_component_results["E_F [kW]"].notna())
+            & (~df_component_results["Component"].isin(exclude_components))
+            & (df_component_results["y [%]"].notna())
+        ].copy()
+
+        # Sort by y [%] in descending order
+        component_data = component_data.sort_values("y [%]", ascending=False)
+
+        # Create bar values: Start at 100%, decrease by each component's y [%]
+        bar_values = [100.0]
+        current_value = 100.0
+        for y in component_data["y [%]"]:
+            current_value -= y
+            bar_values.append(current_value)
+        bar_values.append(epsilon_total)  # Final bar is the exergetic product
+
+        # Create labels for spaces between bars
+        space_labels = ["Exergetic fuel"] + list(component_data["Component"]) + ["Exergetic loss", "Exergetic product"]
+
+        # Create the figure
+        fig, ax = plt.subplots(figsize=figsize)
+
+        # Number of bars and spaces
+        n_bars = len(bar_values)
+
+        # Create horizontal bars at positions 0, 1, 2, ..., n_bars-1
+        bar_positions = np.arange(n_bars)
+        bar_colors = ["#1565C0"] + ["#D32F2F"] * (n_bars - 2) + ["#2E7D32"]
+        # Blue for fuel, red for destruction, green for product
+
+        for i, (pos, value, color) in enumerate(zip(bar_positions, bar_values, bar_colors, strict=False)):
+            ax.barh(pos, value, color=color, alpha=0.8, height=0.6)
+            # Add value label inside the bar on the right
+            ax.text(
+                value - 2, pos, f"{value:.2f}%", va="center", ha="right", fontsize=9, fontweight="bold", color="white"
+            )
+
+        # Add space labels between bars
+        # Space positions: between bars, so at 0.5, 1.5, 2.5, ..., and above/below
+        space_positions = [-0.5] + [i + 0.5 for i in range(n_bars - 1)] + [n_bars - 0.5]
+
+        for i, (space_pos, label) in enumerate(zip(space_positions, space_labels, strict=False)):
+            if i == 0:  # Exergetic fuel - above first bar
+                ax.text(2, space_pos, label, va="center", ha="left", fontsize=10, fontweight="bold", style="italic")
+            elif i == len(space_labels) - 2:  # Exergetic loss
+                loss_label = f"{label} (-{exergetic_loss_percent:.2f}%)"
+                ax.text(
+                    2, space_pos, loss_label, va="center", ha="left", fontsize=10, fontweight="bold", style="italic"
+                )
+            elif i == len(space_labels) - 1:  # Exergetic product - below last bar
+                ax.text(2, space_pos, label, va="center", ha="left", fontsize=10, fontweight="bold", style="italic")
+            else:  # Component labels
+                component_idx = i - 1
+                destruction_rate = component_data.iloc[component_idx]["y [%]"]
+                label_with_rate = f"{label} (-{destruction_rate:.2f}%)"
+                ax.text(2, space_pos, label_with_rate, va="center", ha="left", fontsize=10, fontweight="bold")
+
+        # Customize plot
+        ax.set_yticks(bar_positions)
+        ax.set_yticklabels([""] * n_bars)  # Empty labels since we have custom labels
+        ax.set_xlabel("Exergy [%]", fontsize=12, fontweight="bold")
+
+        if title is not None:
+            ax.set_title(title, fontsize=14, fontweight="bold", pad=20)
+
+        ax.set_xlim(0, 100)
+        ax.set_ylim(-1, n_bars)
+        ax.grid(axis="x", alpha=0.3, linestyle="--")
+        ax.axvline(x=0, color="black", linewidth=0.8)
+        ax.invert_yaxis()  # Invert so highest bar is at top
+
+        plt.tight_layout()
+
+        if show_plot:
+            plt.show()
+
+        return fig, ax
+
+    def print_exergy_summary(self):
+        """
+        Print a text summary of the exergy analysis results.
+
+        This method provides a concise summary of the overall system exergy performance,
+        including fuel exergy, total destruction, losses, and efficiency.
+
+        Raises
+        ------
+        RuntimeError
+            If the exergy analysis has not been performed yet (analyse() not called).
+
+        Notes
+        -----
+        The summary includes:
+        - Exergetic Fuel: Normalized to 100%
+        - Total Exergy Destruction: Sum of all component exergy destructions as % of fuel
+        - Exergetic Loss: Exergy losses to the environment as % of fuel
+        - Exergetic Product (ε): Overall system exergy efficiency as %
+
+        Examples
+        --------
+        >>> analysis = ExergyAnalysis.from_tespy(network, Tamb=288.15, pamb=101325)  # doctest: +SKIP
+        >>> analysis.analyse(E_F={'inputs': ['fuel']}, E_P={'outputs': ['power']})  # doctest: +SKIP
+        >>> analysis.print_exergy_summary()  # doctest: +SKIP
+        Exergy Analysis Summary:
+        Exergetic Fuel: 100.00%
+        Total Exergy Destruction: 35.42%
+        Exergetic Loss: 5.12%
+        Exergetic Product (ε): 59.46%
+
+        See Also
+        --------
+        exergy_results : Display detailed tabular results.
+        plot_exergy_waterfall : Create a visual waterfall diagram.
+        """
+        # Check if analysis has been performed
+        if not hasattr(self, "epsilon") or self.epsilon is None:
+            raise RuntimeError("Exergy analysis has not been performed yet. Please call analyse() first.")
+
+        # Get component results without printing
+        df_component_results, _, _ = self.exergy_results(print_results=False)
+
+        total_row = df_component_results[df_component_results["Component"] == "TOT"].iloc[0]
+        epsilon_total = total_row["ε [%]"]
+        E_L_total = total_row["E_L [kW]"]
+        E_F_total = total_row["E_F [kW]"]
+        exergetic_loss_percent = (E_L_total / E_F_total) * 100 if E_F_total != 0 else 0
+
+        print("\nExergy Analysis Summary:")
+        print("Exergetic Fuel: 100.00%")
+        print(f"Total Exergy Destruction: {100 - epsilon_total - exergetic_loss_percent:.2f}%")
+        print(f"Exergetic Loss: {exergetic_loss_percent:.2f}%")
+        print(f"Exergetic Product (epsilon): {epsilon_total:.2f}%")
+
     def export_to_json(self, output_path):
         """
         Export the model to a JSON file.
@@ -581,6 +801,7 @@ class ExergyAnalysis:
         -----
         This method serializes the model using the internal _serialize method
         and writes the resulting data to a JSON file with indentation.
+        NaN values are converted to null for valid JSON output.
         """
         data = self._serialize()
         with open(output_path, "w") as json_file:
@@ -610,21 +831,21 @@ class ExergyAnalysis:
             for comp_name, comp_data in comps.items():
                 comp = self.components[comp_name]
                 comp_data["exergy_results"] = {
-                    "E_F": getattr(comp, "E_F", None),
-                    "E_P": getattr(comp, "E_P", None),
-                    "E_D": getattr(comp, "E_D", None),
-                    "epsilon": getattr(comp, "epsilon", None),
-                    "y": getattr(comp, "y", None),
-                    "y_star": getattr(comp, "y_star", None),
+                    "E_F": _nan_to_none(getattr(comp, "E_F", None)),
+                    "E_P": _nan_to_none(getattr(comp, "E_P", None)),
+                    "E_D": _nan_to_none(getattr(comp, "E_D", None)),
+                    "epsilon": _nan_to_none(getattr(comp, "epsilon", None)),
+                    "y": _nan_to_none(getattr(comp, "y", None)),
+                    "y_star": _nan_to_none(getattr(comp, "y_star", None)),
                 }
 
         # add overall system exergy results
         export["system_results"] = {
-            "E_F": getattr(self, "E_F", None),
-            "E_P": getattr(self, "E_P", None),
-            "E_D": getattr(self, "E_D", None),
-            "E_L": getattr(self, "E_L", None),
-            "epsilon": getattr(self, "epsilon", None),
+            "E_F": _nan_to_none(getattr(self, "E_F", None)),
+            "E_P": _nan_to_none(getattr(self, "E_P", None)),
+            "E_D": _nan_to_none(getattr(self, "E_D", None)),
+            "E_L": _nan_to_none(getattr(self, "E_L", None)),
+            "epsilon": _nan_to_none(getattr(self, "epsilon", None)),
         }
 
         return export
@@ -748,6 +969,13 @@ def _construct_components(component_data, connection_data, Tamb):
     return components  # Return the dictionary of created components
 
 
+def _nan_to_none(value):
+    """Convert NaN/Inf floats to None for valid JSON serialization."""
+    if isinstance(value, float) and not np.isfinite(value):
+        return None
+    return value
+
+
 def _load_json(json_path):
     """
     Load and validate a JSON file.
@@ -1184,7 +1412,15 @@ class ExergoeconomicAnalysis:
                         self.equations[counter] = {"kind": "boundary", "object": [name], "property": "c_TOT"}
                         counter += 1
                     else:
-                        continue
+                        # When there are power outlets, we still need at least one boundary condition
+                        # for power inlets to fix the absolute cost value. The aux_power_eq only
+                        # equalizes specific costs but doesn't set the actual value.
+                        if conn.get("C_TOT"):
+                            idx = conn["CostVar_index"]["exergy"]
+                            self._A[counter, idx] = 1
+                            self._b[counter] = conn.get("C_TOT", 0)
+                            self.equations[counter] = {"kind": "boundary", "object": [name], "property": "c_TOT"}
+                            counter += 1
 
         # 3. Auxiliary equations for the equality of the specific costs
         # of all power flows at the input or output of the system.
@@ -1320,26 +1556,26 @@ class ExergoeconomicAnalysis:
                     E_M = m_val * e_M  # mechanical exergy flow [kW]
 
                     conn["C_T"] = C_solution[conn["CostVar_index"]["T"]]
-                    conn["c_T"] = conn["C_T"] / E_T if E_T != 0 else np.nan
+                    conn["c_T"] = conn["C_T"] / E_T if E_T != 0 else 0.0
 
                     conn["C_M"] = C_solution[conn["CostVar_index"]["M"]]
-                    conn["c_M"] = conn["C_M"] / E_M if E_M != 0 else np.nan
+                    conn["c_M"] = conn["C_M"] / E_M if E_M != 0 else 0.0
 
                     conn["C_PH"] = conn["C_T"] + conn["C_M"]
-                    conn["c_PH"] = conn["C_PH"] / (E_T + E_M) if (E_T + E_M) != 0 else np.nan
+                    conn["c_PH"] = conn["C_PH"] / (E_T + E_M) if (E_T + E_M) != 0 else 0.0
 
                     if self.chemical_exergy_enabled:
                         e_CH = conn.get("e_CH", 0)  # chemical specific exergy [kJ/kg]
                         E_CH = m_val * e_CH  # chemical exergy flow [kW]
                         conn["C_CH"] = C_solution[conn["CostVar_index"]["CH"]]
-                        conn["c_CH"] = conn["C_CH"] / E_CH if E_CH != 0 else np.nan
+                        conn["c_CH"] = conn["C_CH"] / E_CH if E_CH != 0 else 0.0
                         conn["C_TOT"] = conn["C_T"] + conn["C_M"] + conn["C_CH"]
                         total_E = E_T + E_M + E_CH
-                        conn["c_TOT"] = conn["C_TOT"] / total_E if total_E != 0 else np.nan
+                        conn["c_TOT"] = conn["C_TOT"] / total_E if total_E != 0 else 0.0
                     else:
                         conn["C_TOT"] = conn["C_T"] + conn["C_M"]
                         total_E = E_T + E_M
-                        conn["c_TOT"] = conn["C_TOT"] / total_E if total_E != 0 else np.nan
+                        conn["c_TOT"] = conn["C_TOT"] / total_E if total_E != 0 else 0.0
                 elif kind in {"heat", "power"}:
                     conn["C_TOT"] = C_solution[conn["CostVar_index"]["exergy"]]
                     conn["c_TOT"] = conn["C_TOT"] / conn.get("E", 1)
@@ -1465,7 +1701,7 @@ class ExergoeconomicAnalysis:
         dict
             Mapping from component name to tuple (balance, is_balanced),
             where balance is the residual and is_balanced is True if
-            |balance| <= tol.
+            abs(balance) <= tol.
         """
         from .components.helpers.cycle_closer import CycleCloser
 
@@ -1476,10 +1712,20 @@ class ExergoeconomicAnalysis:
             inlet_sum = 0.0
             outlet_sum = 0.0
             for conn in self.connections.values():
+                # Use sum of cost components instead of C_TOT, because C_TOT may have been
+                # modified by loss attribution (Step 6) which is not part of the matrix equation.
+                kind = conn.get("kind", "material")
+                if kind == "material":
+                    cost = (conn.get("C_T", 0) or 0) + (conn.get("C_M", 0) or 0)
+                    if self.chemical_exergy_enabled:
+                        cost += conn.get("C_CH", 0) or 0
+                else:
+                    # For heat/power streams, use C_TOT directly (no loss attribution applies)
+                    cost = conn.get("C_TOT", 0) or 0
                 if conn.get("target_component") == name:
-                    inlet_sum += conn.get("C_TOT", 0) or 0
+                    inlet_sum += cost
                 if conn.get("source_component") == name:
-                    outlet_sum += conn.get("C_TOT", 0) or 0
+                    outlet_sum += cost
             comp.C_in = inlet_sum
             comp.C_out = outlet_sum
             z_cost = getattr(comp, "Z_costs", 0)
@@ -1489,11 +1735,11 @@ class ExergoeconomicAnalysis:
 
         all_ok = all(flag for _, flag in balances.values())
         if all_ok:
-            print("Everything is fine: all component cost balances are fulfilled.")
+            logging.info("All component cost balances are fulfilled.")
         else:
             for name, (bal, ok) in balances.items():
                 if not ok:
-                    print(f"Balance for component {name} not fulfilled: residual = {bal:.6f}")
+                    logging.warning(f"Balance for component {name} not fulfilled: residual = {bal:.6f}")
 
         return balances
 
@@ -1522,7 +1768,6 @@ class ExergoeconomicAnalysis:
         self.solve_exergoeconomic_analysis(Tamb)
         logging.info("Exergoeconomic analysis completed successfully.")
         self.check_cost_balance()
-        print("stop")
 
     def print_equations(self):
         """

exerpy/components/heat_exchanger/base.py

@@ -498,8 +498,8 @@ class HeatExchanger(Component):
         # Equality equation for mechanical and chemical exergy costs.
         def set_equal(A, row, in_item, out_item, var):
             if in_item["e_" + var] != 0 and out_item["e_" + var] != 0:
-                A[row, in_item["CostVar_index"][var]] = 1 / in_item["e_" + var]
-                A[row, out_item["CostVar_index"][var]] = -1 / out_item["e_" + var]
+                A[row, in_item["CostVar_index"][var]] = 1 / in_item["E_" + var]
+                A[row, out_item["CostVar_index"][var]] = -1 / out_item["E_" + var]
             elif in_item["e_" + var] == 0 and out_item["e_" + var] != 0:
                 A[row, in_item["CostVar_index"][var]] = 1
             elif in_item["e_" + var] != 0 and out_item["e_" + var] == 0:

exerpy/components/heat_exchanger/condenser.py

@@ -221,8 +221,8 @@ class Condenser(Component):
         # Equality equation for mechanical and chemical exergy costs.
         def set_equal(A, row, in_item, out_item, var):
             if in_item["e_" + var] != 0 and out_item["e_" + var] != 0:
-                A[row, in_item["CostVar_index"][var]] = 1 / in_item["e_" + var]
-                A[row, out_item["CostVar_index"][var]] = -1 / out_item["e_" + var]
+                A[row, in_item["CostVar_index"][var]] = 1 / in_item["E_" + var]
+                A[row, out_item["CostVar_index"][var]] = -1 / out_item["E_" + var]
             elif in_item["e_" + var] == 0 and out_item["e_" + var] != 0:
                 A[row, in_item["CostVar_index"][var]] = 1
             elif in_item["e_" + var] != 0 and out_item["e_" + var] == 0:

exerpy/components/turbomachinery/compressor.py

@@ -269,17 +269,45 @@ class Compressor(Component):
             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] = {
-                "kind": "aux_p_rule",
-                "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
-                "property": "c_T, c_M",
-            }
+            # Case 2: Inlet at/below ambient, outlet above ambient
+            # Handle potential zero values for robustness
+            if self.outl[0]["e_T"] != 0 and dEM != 0:
+                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] = {
+                    "kind": "aux_p_rule",
+                    "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                    "property": "c_T, c_M",
+                }
+            else:
+                logging.warning(
+                    f"Compressor '{self.name}' Case 2: outlet thermal exergy or mechanical exergy "
+                    "difference is zero, auxiliary equation may be degenerate."
+                )
+                # Fallback: set identity equation for thermal cost
+                A[row_index, self.outl[0]["CostVar_index"]["T"]] = 1
+                equations[row_index] = {
+                    "kind": "aux_p_rule",
+                    "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                    "property": "c_T",
+                }
         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"]
+            # Case 3: Both temperatures at or below ambient - apply F-rule for thermal exergy
+            # Handle zero thermal exergy cases to avoid division by zero
+            if self.inl[0]["e_T"] != 0 and self.outl[0]["e_T"] != 0:
+                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"]
+            elif self.inl[0]["e_T"] == 0 and self.outl[0]["e_T"] != 0:
+                # Inlet thermal exergy is zero, constrain C_T_in = 0
+                A[row_index, self.inl[0]["CostVar_index"]["T"]] = 1
+            elif self.inl[0]["e_T"] != 0 and self.outl[0]["e_T"] == 0:
+                # Outlet thermal exergy is zero, constrain C_T_out = 0
+                A[row_index, self.outl[0]["CostVar_index"]["T"]] = 1
+            else:
+                # Both thermal exergies are zero, set identity equation
+                A[row_index, self.inl[0]["CostVar_index"]["T"]] = 1
+                A[row_index, self.outl[0]["CostVar_index"]["T"]] = -1
             equations[row_index] = {
                 "kind": "aux_f_rule",
                 "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],

exerpy/components/turbomachinery/pump.py

@@ -262,17 +262,45 @@ class Pump(Component):
             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] = {
-                "kind": "aux_p_rule",
-                "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
-                "property": "c_T, c_M",
-            }
+            # Case 2: Inlet at/below ambient, outlet above ambient
+            # Handle potential zero values for robustness
+            if self.outl[0]["e_T"] != 0 and dEM != 0:
+                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] = {
+                    "kind": "aux_p_rule",
+                    "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                    "property": "c_T, c_M",
+                }
+            else:
+                logging.warning(
+                    f"Pump '{self.name}' Case 2: outlet thermal exergy or mechanical exergy "
+                    "difference is zero, auxiliary equation may be degenerate."
+                )
+                # Fallback: set identity equation for thermal cost
+                A[row_index, self.outl[0]["CostVar_index"]["T"]] = 1
+                equations[row_index] = {
+                    "kind": "aux_p_rule",
+                    "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],
+                    "property": "c_T",
+                }
         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"]
+            # Case 3: Both temperatures at or below ambient - apply F-rule for thermal exergy
+            # Handle zero thermal exergy cases to avoid division by zero
+            if self.inl[0]["e_T"] != 0 and self.outl[0]["e_T"] != 0:
+                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"]
+            elif self.inl[0]["e_T"] == 0 and self.outl[0]["e_T"] != 0:
+                # Inlet thermal exergy is zero, constrain C_T_in = 0
+                A[row_index, self.inl[0]["CostVar_index"]["T"]] = 1
+            elif self.inl[0]["e_T"] != 0 and self.outl[0]["e_T"] == 0:
+                # Outlet thermal exergy is zero, constrain C_T_out = 0
+                A[row_index, self.outl[0]["CostVar_index"]["T"]] = 1
+            else:
+                # Both thermal exergies are zero, set identity equation
+                A[row_index, self.inl[0]["CostVar_index"]["T"]] = 1
+                A[row_index, self.outl[0]["CostVar_index"]["T"]] = -1
             equations[row_index] = {
                 "kind": "aux_f_rule",
                 "objects": [self.name, self.inl[0]["name"], self.outl[0]["name"]],

exerpy/cost_estimation/__init__.py

@@ -0,0 +1,65 @@
+"""
+Cost estimation module for ExerPy.
+
+This module provides cost estimation functionality for exergoeconomic analysis.
+Different cost estimation methods can be implemented as separate classes.
+
+Available Estimators
+--------------------
+TurtonCostEstimator : Turton 2008 correlations (requires proprietary data files)
+    Uses correlations from "Analysis, Synthesis, and Design of Chemical Processes"
+    by Turton et al. (2008) with CEPCI cost index adjustment.
+
+Notes
+-----
+The TurtonCostEstimator requires proprietary data files that are not distributed
+with ExerPy due to copyright restrictions. Users can:
+
+1. Provide their own cost data files in the expected format
+2. Provide costs directly to ExergoeconomicAnalysis.run() without using an estimator
+3. Implement their own cost estimator class
+
+Example of providing costs directly::
+
+    execo = ExergoeconomicAnalysis(exergy_analysis)
+    costs = {
+        "pump_1_Z": 5.0,      # EUR/h
+        "hx_1_Z": 12.0,       # EUR/h
+        "fuel_in_c": 3.5,     # EUR/GJ for input stream
+    }
+    execo.run(costs, Tamb=298.15)
+"""
+
+try:
+    from .turton import TurtonCostEstimator
+
+    __all__ = ["TurtonCostEstimator"]
+except ImportError:
+    __all__ = []
+
+    class TurtonCostEstimator:
+        """
+        Placeholder for TurtonCostEstimator when data files are not available.
+
+        The actual TurtonCostEstimator requires proprietary cost correlation data
+        files from Turton et al. (2008) which cannot be distributed with ExerPy.
+
+        To use cost estimation with Turton correlations, you need to:
+        1. Obtain the correlation data from the original source
+        2. Create the required JSON files in src/exerpy/data/cost_correlations/
+        3. Ensure turton.py is present in src/exerpy/cost_estimation/
+
+        Alternatively, provide component costs directly to ExergoeconomicAnalysis.run().
+        """
+
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "TurtonCostEstimator is not available. "
+                "The required cost correlation data files (Turton 2008, CEPCI) "
+                "are not included in this distribution due to copyright restrictions.\n\n"
+                "Options:\n"
+                "1. Provide your own cost data files in src/exerpy/data/cost_correlations/\n"
+                "2. Provide costs directly to ExergoeconomicAnalysis.run() method\n"
+                "3. Implement your own cost estimator\n\n"
+                "See ExergoeconomicAnalysis documentation for the required cost format."
+            )