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

exerpy/cost_estimation/turton.py

@@ -0,0 +1,1260 @@
+"""
+Turton 2008 cost estimation module.
+
+This module provides equipment cost estimation using correlations from:
+Turton, R., Bailie, R. C., Whiting, W. B., & Shaeiwitz, J. A. (2008).
+Analysis, Synthesis, and Design of Chemical Processes (3rd ed.). Prentice Hall.
+
+Note: This module requires proprietary data files that are not distributed
+with ExerPy due to copyright restrictions.
+"""
+
+import json
+import logging
+import os
+
+import numpy as np
+from tabulate import tabulate
+
+from ..components.helpers.cycle_closer import CycleCloser
+from ..components.helpers.power_bus import PowerBus
+
+
+class TurtonCostEstimator:
+    """
+    Cost estimator using Turton 2008 correlations.
+
+    This class estimates equipment costs using correlations from Turton et al. (2008)
+    with CEPCI (Chemical Engineering Plant Cost Index) adjustment for inflation.
+
+    Parameters
+    ----------
+    exergoeconomic_analysis : ExergoeconomicAnalysis
+        Instance of ExergoeconomicAnalysis to estimate costs for.
+
+    Attributes
+    ----------
+    execo : ExergoeconomicAnalysis
+        Reference to the exergoeconomic analysis instance.
+    connections : dict
+        Dictionary of all energy/material connections in the system.
+    components : dict
+        Dictionary of all components in the system.
+    currency : str
+        Currency symbol used in cost reporting.
+
+    Notes
+    -----
+    Requires the following data files in src/exerpy/data/cost_correlations/:
+    - turton2008.json: Equipment cost correlations (K1, K2, K3, B1, B2 coefficients)
+    - material_factors.json: Material factors (Fm) for different materials
+    - pressure_factors.json: Pressure factor coefficients (C1, C2, C3)
+    - cepci_index.json: Chemical Engineering Plant Cost Index values
+    - component_mapping.json: Mapping between ExerPy components and Turton equipment
+    """
+
+    def __init__(self, exergoeconomic_analysis):
+        """
+        Initialize the Turton cost estimator.
+
+        Parameters
+        ----------
+        exergoeconomic_analysis : ExergoeconomicAnalysis
+            Instance of ExergoeconomicAnalysis that has been initialized.
+        """
+        self.execo = exergoeconomic_analysis
+        self.connections = exergoeconomic_analysis.connections
+        self.components = exergoeconomic_analysis.components
+        self.currency = exergoeconomic_analysis.currency
+        self._cost_data = None  # Lazy-loaded cost correlation data
+
+    def _load_cost_data(self):
+        """
+        Load cost correlation data from JSON files.
+
+        Loads the following data files from the data/cost_correlations directory:
+        - turton2008.json: Equipment cost correlations (K1, K2, K3, B1, B2 coefficients)
+        - material_factors.json: Material factors (Fm) for different materials
+        - pressure_factors.json: Pressure factor coefficients (C1, C2, C3)
+        - cepci_index.json: Chemical Engineering Plant Cost Index values
+        - component_mapping.json: Mapping between ExerPy components and Turton equipment
+
+        Returns
+        -------
+        dict
+            Dictionary containing all loaded cost data.
+
+        Notes
+        -----
+        Data is lazy-loaded and cached in self._cost_data for subsequent calls.
+        """
+        if self._cost_data is not None:
+            return self._cost_data
+
+        # Navigate from cost_estimation module to data directory
+        data_dir = os.path.join(os.path.dirname(__file__), "..", "data", "cost_correlations")
+
+        self._cost_data = {}
+
+        files = {
+            "turton2008": "turton2008.json",
+            "material_factors": "material_factors.json",
+            "pressure_factors": "pressure_factors.json",
+            "cepci_index": "cepci_index.json",
+            "component_mapping": "component_mapping.json",
+        }
+
+        for key, filename in files.items():
+            filepath = os.path.join(data_dir, filename)
+            if os.path.exists(filepath):
+                with open(filepath, "r") as f:
+                    self._cost_data[key] = json.load(f)
+            else:
+                logging.warning(f"Cost data file not found: {filepath}")
+                self._cost_data[key] = {}
+
+        return self._cost_data
+
+    def _get_equipment_correlation(self, equipment_type):
+        """
+        Get cost correlation data for a specific equipment type.
+
+        Parameters
+        ----------
+        equipment_type : str
+            Equipment type in format "category.type" (e.g., "pumps.centrifugal_single_stage").
+
+        Returns
+        -------
+        dict or None
+            Cost correlation data dictionary containing K1, K2, K3, B1, B2, etc.
+            Returns None if equipment type is not found.
+        """
+        data = self._load_cost_data()
+        turton = data.get("turton2008", {})
+
+        # Parse equipment type (e.g., "pumps.centrifugal_single_stage")
+        parts = equipment_type.split(".")
+        if len(parts) != 2:
+            logging.warning(f"Invalid equipment type format: {equipment_type}")
+            return None
+
+        category, eq_type = parts
+        if category in turton and eq_type in turton[category]:
+            return turton[category][eq_type]
+        else:
+            logging.warning(f"Equipment type not found: {equipment_type}")
+            return None
+
+    def calculate_Cp0(self, equipment_type, size, component_name=None, component_type=None):
+        """
+        Calculate purchased equipment cost at base conditions (Cp0).
+
+        Uses the Turton 2008 correlation:
+        log10(Cp0) = K1 + K2*log10(A) + K3*(log10(A))^2
+
+        Parameters
+        ----------
+        equipment_type : str
+            Equipment type in format "category.type" (e.g., "pumps.centrifugal_single_stage").
+        size : float
+            Size/capacity parameter in the unit specified for the equipment type.
+            - Heat exchangers: area [m2]
+            - Pumps/Compressors/Turbines: power [kW]
+            - Vessels: volume [m3]
+        component_name : str, optional
+            Name/label of the component (for warning messages).
+        component_type : str, optional
+            Type/class of the component (for warning messages).
+
+        Returns
+        -------
+        float
+            Purchased equipment cost in USD at base conditions (CEPCI = 397, year 2001).
+
+        Raises
+        ------
+        ValueError
+            If equipment type is not found or size is not positive.
+
+        Notes
+        -----
+        If size is outside the valid range for the equipment type, a warning is logged
+        but the calculation proceeds. Extrapolation outside the valid range may be inaccurate.
+        """
+        corr = self._get_equipment_correlation(equipment_type)
+        if corr is None:
+            raise ValueError(f"Equipment correlation not found for: {equipment_type}")
+
+        # Check size limits
+        A_min = corr.get("capacity_min", 0)
+        A_max = corr.get("capacity_max", float("inf"))
+        capacity_unit = corr.get("capacity_unit", "")
+
+        if size < A_min or size > A_max:
+            # Build component identifier for warning message
+            comp_id = ""
+            if component_name and component_type:
+                comp_id = f"Component '{component_name}' ({component_type}): "
+            elif component_name:
+                comp_id = f"Component '{component_name}': "
+            elif component_type:
+                comp_id = f"Component type '{component_type}': "
+
+            logging.warning(
+                f"{comp_id}Size {size:.4g} {capacity_unit} is outside the valid range "
+                f"[{A_min}, {A_max}] {capacity_unit} for '{equipment_type}'. "
+                f"Cost extrapolation may be inaccurate."
+            )
+
+        # Ensure size > 0 for logarithm
+        if size <= 0:
+            raise ValueError(f"Size must be positive, got {size}")
+
+        K1 = corr["K1"]
+        K2 = corr["K2"]
+        K3 = corr["K3"]
+
+        log_A = np.log10(size)
+        log_Cp = K1 + K2 * log_A + K3 * log_A**2
+
+        return 10**log_Cp
+
+    def calculate_Fp(self, pressure_factor_type, pressure, diameter=None):
+        """
+        Calculate pressure factor (Fp) for equipment cost correction.
+
+        For most equipment: log10(Fp) = C1 + C2*log10(P) + C3*(log10(P))^2
+        For vessels: Fp = [(P+1)*D / (2*S*E - 1.2*(P+1)) + CA] / t_min
+
+        Parameters
+        ----------
+        pressure_factor_type : str
+            Type of pressure factor calculation. Options:
+            - "heat_exchanger": Shell-and-tube heat exchangers
+            - "pump": Pumps
+            - "fired_heater": Fired heaters
+            - "air_cooler": Air-cooled heat exchangers
+            - "vessel": Process vessels (requires diameter)
+            - "none": No pressure correction (returns 1.0)
+        pressure : float
+            Operating pressure in barg (gauge pressure).
+        diameter : float, optional
+            Vessel diameter in meters (required for vessel pressure factor).
+
+        Returns
+        -------
+        float
+            Pressure factor Fp (dimensionless, >= 1.0).
+
+        Notes
+        -----
+        For low pressures (typically < 5-10 barg), Fp = 1.0.
+        For vacuum operation (P < -0.5 barg), vessels use Fp = 1.25.
+        """
+        data = self._load_cost_data()
+        pf_data = data.get("pressure_factors", {})
+
+        if pressure_factor_type == "none":
+            return 1.0
+
+        if pressure_factor_type not in pf_data:
+            logging.warning(f"Pressure factor type not found: {pressure_factor_type}. Using Fp = 1.0")
+            return 1.0
+
+        pf_info = pf_data[pressure_factor_type]
+
+        # Special handling for vessels
+        if pressure_factor_type == "vessel":
+            if diameter is None:
+                logging.warning("Vessel diameter not provided. Using Fp = 1.0")
+                return 1.0
+
+            # Check for vacuum operation
+            vacuum_data = pf_info.get("vacuum_factor", {})
+            if pressure < vacuum_data.get("P_threshold", -0.5):
+                return vacuum_data.get("Fp", 1.25)
+
+            # Vessel pressure factor calculation
+            params = pf_info.get("parameters", {})
+            S = params.get("S_carbon_steel", {}).get("value", 944)  # bar
+            E = params.get("E", {}).get("value", 0.9)
+            CA = params.get("CA", {}).get("value", 0.00315)  # m
+            t_min = params.get("t_min", {}).get("value", 0.0063)  # m
+
+            # Calculate wall thickness
+            P_abs = pressure + 1  # Absolute pressure in barg -> approximately bar gauge
+            denominator = 2 * S * E - 1.2 * P_abs
+            if denominator <= 0:
+                logging.warning(f"Vessel wall thickness calculation invalid for P={pressure} barg. Using Fp = 1.0")
+                return 1.0
+
+            t_calc = (P_abs * diameter) / denominator + CA
+            Fp = t_calc / t_min
+
+            return max(1.0, Fp)
+
+        # Standard pressure factor calculation using polynomial
+        ranges = pf_info.get("ranges", [])
+
+        for rng in ranges:
+            P_min = rng.get("P_min", float("-inf"))
+            P_max = rng.get("P_max", float("inf"))
+
+            if P_min <= pressure <= P_max:
+                # Check for fixed Fp value
+                if "Fp_fixed" in rng:
+                    return rng["Fp_fixed"]
+
+                C1 = rng.get("C1", 0)
+                C2 = rng.get("C2", 0)
+                C3 = rng.get("C3", 0)
+
+                # For very low pressures (C1=C2=C3=0), Fp = 1.0
+                if C1 == 0 and C2 == 0 and C3 == 0:
+                    return 1.0
+
+                # Avoid log of zero or negative
+                if pressure <= 0:
+                    return 1.0
+
+                log_P = np.log10(pressure)
+                log_Fp = C1 + C2 * log_P + C3 * log_P**2
+                return max(1.0, 10**log_Fp)
+
+        # If pressure outside all ranges
+        logging.warning(f"Pressure {pressure} barg outside valid range for {pressure_factor_type}. Using Fp = 1.0")
+        return 1.0
+
+    def calculate_Fm(self, equipment_category, material):
+        """
+        Get material factor (Fm) for equipment cost correction.
+
+        Parameters
+        ----------
+        equipment_category : str
+            Equipment category for material factor lookup. Options:
+            - "heat_exchangers": Shell/tube material combinations (e.g., "CS/CS", "CS/SS")
+            - "process_vessels": Vessel materials (e.g., "CS", "SS304", "SS316")
+            - "pumps": Pump materials
+            - "compressors": Compressor materials
+            - "trays": Distillation tray materials
+            - "packing": Tower packing materials
+            - "plate_heat_exchangers": Plate HX materials
+            - "reactors": Reactor materials
+            - "fired_heaters": Fired heater tube materials
+        material : str
+            Material specification (e.g., "CS", "SS304", "CS/SS").
+
+        Returns
+        -------
+        float
+            Material factor Fm (dimensionless, >= 1.0).
+
+        Notes
+        -----
+        Carbon steel (CS) is the base material with Fm = 1.0 for most equipment.
+        For heat exchangers, the format is "shell_material/tube_material".
+        """
+        data = self._load_cost_data()
+        mf_data = data.get("material_factors", {})
+
+        if equipment_category not in mf_data:
+            logging.warning(f"Material factor category not found: {equipment_category}. Using Fm = 1.0")
+            return 1.0
+
+        category_data = mf_data[equipment_category]
+
+        # Skip metadata keys
+        if material.startswith("_"):
+            return 1.0
+
+        if material in category_data:
+            mat_info = category_data[material]
+            if isinstance(mat_info, dict):
+                return mat_info.get("Fm", 1.0)
+            else:
+                return mat_info
+        else:
+            logging.warning(f"Material '{material}' not found in category '{equipment_category}'. Using Fm = 1.0")
+            return 1.0
+
+    def calculate_CBM(
+        self,
+        equipment_type,
+        size,
+        pressure=0,
+        material="CS",
+        diameter=None,
+        cepci_year=2024,
+        regional_factor=1.0,
+        component_name=None,
+        component_type=None,
+    ):
+        """
+        Calculate bare module cost (CBM) for equipment.
+
+        CBM = Cp0 * (B1 + B2*Fp*Fm) * (CEPCI_year / CEPCI_base) * regional_factor
+        or
+        CBM = Cp0 * FBM * (CEPCI_year / CEPCI_base) * regional_factor  (for fixed FBM)
+
+        Parameters
+        ----------
+        equipment_type : str
+            Equipment type in format "category.type" (e.g., "pumps.centrifugal_single_stage").
+        size : float
+            Size/capacity parameter in the appropriate unit for the equipment.
+        pressure : float, optional
+            Operating pressure in barg (default: 0, atmospheric).
+        material : str, optional
+            Material of construction (default: "CS" for carbon steel).
+        diameter : float, optional
+            Vessel diameter in meters (required for vessel pressure factor).
+        cepci_year : int, optional
+            Year for CEPCI cost adjustment (default: 2024).
+        regional_factor : float, optional
+            Regional location factor relative to US Gulf Coast (default: 1.0).
+        component_name : str, optional
+            Name/label of the component (for warning messages).
+        component_type : str, optional
+            Type/class of the component (for warning messages).
+
+        Returns
+        -------
+        float
+            Bare module cost in USD at the specified year and location.
+
+        Notes
+        -----
+        The base costs from Turton 2008 are at CEPCI = 397 (year 2001).
+        """
+        corr = self._get_equipment_correlation(equipment_type)
+        if corr is None:
+            raise ValueError(f"Equipment correlation not found for: {equipment_type}")
+
+        # Calculate base purchased cost
+        Cp0 = self.calculate_Cp0(equipment_type, size, component_name, component_type)
+
+        # Get CEPCI values
+        data = self._load_cost_data()
+        cepci_data = data.get("cepci_index", {})
+        cepci_base = cepci_data.get("_metadata", {}).get("base_cepci_for_turton", 397)
+        cepci_values = cepci_data.get("annual_values", {})
+        cepci_current = cepci_values.get(str(cepci_year), cepci_values.get("2024", 800))
+
+        cepci_factor = cepci_current / cepci_base
+
+        # Check for fixed FBM
+        if "FBM" in corr:
+            FBM = corr["FBM"]
+            CBM = Cp0 * FBM * cepci_factor * regional_factor
+        else:
+            # Calculate pressure and material factors
+            pf_type = corr.get("pressure_factor_type", "none")
+            Fp = self.calculate_Fp(pf_type, pressure, diameter)
+
+            # Determine material factor category from equipment type
+            category = equipment_type.split(".")[0]
+            mf_category_map = {
+                "heat_exchangers": "heat_exchangers",
+                "pumps": "pumps",
+                "compressors": "compressors",
+                "vessels": "process_vessels",
+                "towers": "process_vessels",
+                "reactors": "reactors",
+                "fired_heaters": "fired_heaters",
+                "evaporators": "heat_exchangers",
+            }
+            mf_category = mf_category_map.get(category, "process_vessels")
+
+            # For shell-and-tube heat exchangers, convert material format
+            # "CS" -> "CS/CS" (shell/tube format)
+            mat_for_lookup = material
+            if mf_category == "heat_exchangers" and "/" not in material:
+                mat_for_lookup = f"{material}/{material}"
+
+            Fm = self.calculate_Fm(mf_category, mat_for_lookup)
+
+            B1 = corr.get("B1", 0)
+            B2 = corr.get("B2", 0)
+
+            CBM = Cp0 * (B1 + B2 * Fp * Fm) * cepci_factor * regional_factor
+
+        return CBM
+
+    def _get_component_size(self, component, mapping_info):
+        """
+        Extract size parameter from component based on mapping configuration.
+
+        Parameters
+        ----------
+        component : Component
+            ExerPy component object.
+        mapping_info : dict
+            Component mapping information from component_mapping.json.
+
+        Returns
+        -------
+        float or None
+            Size parameter value, or None if not available.
+        """
+        params = mapping_info.get("parameters", {})
+        size_info = params.get("size", {})
+        size_info.get("unit", "")
+
+        # Try to get the attribute from component
+        attr_name = size_info.get("attribute")
+        if attr_name and hasattr(component, attr_name):
+            value = getattr(component, attr_name)
+            if value is not None:
+                return abs(value)
+
+        # Fallback: try to calculate from exergy values or other component data
+        comp_class = component.__class__.__name__
+        category = mapping_info.get("category", "")
+
+        # For turbomachinery and power machines, use E_F or E_P
+        if category in ["turbomachinery", "power_machines"]:
+            # Power output components (turbines, generators)
+            if "Turbine" in comp_class or "Generator" in comp_class:
+                if hasattr(component, "E_P") and component.E_P is not None:
+                    # E_P is in W, convert to kW for cost correlations
+                    return abs(component.E_P) / 1000
+            # Power input components (pumps, compressors, motors)
+            elif "Pump" in comp_class or "Compressor" in comp_class or "Motor" in comp_class:
+                if hasattr(component, "E_F") and component.E_F is not None:
+                    # E_F is in W, convert to kW for cost correlations
+                    return abs(component.E_F) / 1000
+
+        # For heat exchangers, estimate area from heat duty
+        if category == "heat_exchanger":
+            # Try to calculate heat duty from connection data
+            Q = self._calculate_heat_duty(component)
+            if Q is not None and Q > 0:
+                # Estimate area from heat duty: A = Q / (U x LMTD)
+                # Use typical U values based on heat exchanger type
+                U = self._get_typical_U_value(component)  # W/(m2-K)
+                LMTD = self._estimate_LMTD(component)  # K
+                if U > 0 and LMTD > 0:
+                    # Q is in kW, U in W/(m2-K), LMTD in K
+                    # A = Q [kW] x 1000 / (U x LMTD) = m2
+                    area = (Q * 1000) / (U * LMTD)
+                    return area
+                else:
+                    logging.warning(
+                        f"Could not estimate area for {component.name}. "
+                        f"Heat duty Q={Q:.1f} kW. Please provide area via custom_sizes."
+                    )
+            return None
+
+        # For fired equipment (combustion chambers), use heat duty
+        if category == "fired_equipment" and hasattr(component, "E_F") and component.E_F is not None:
+            # E_F is in W, convert to kW
+            return abs(component.E_F) / 1000
+
+        # For vessels (Drum, Deaerator, FlashTank, Storage), estimate volume from flow data
+        if category == "vessels":
+            volume = self._estimate_vessel_volume(component)
+            if volume is not None:
+                return volume
+
+        return None
+
+    def _calculate_heat_duty(self, component):
+        """
+        Calculate heat duty for a heat exchanger from connection data.
+
+        Parameters
+        ----------
+        component : Component
+            Heat exchanger component.
+
+        Returns
+        -------
+        float or None
+            Heat duty in kW, or None if cannot be calculated.
+
+        Notes
+        -----
+        ExerPy stores enthalpies in J/kg, so Q = m x dh gives W.
+        This method converts to kW for consistency with cost correlations.
+        """
+        try:
+            # Heat exchangers have 2 inlets and 2 outlets
+            # Calculate Q from the hot side: Q = m x (h_in - h_out)
+            if hasattr(component, "inl") and hasattr(component, "outl"):
+                inl = component.inl
+                outl = component.outl
+
+                # Try hot side (index 0)
+                if 0 in inl and 0 in outl:
+                    m_hot = inl[0].get("m", 0)
+                    h_in_hot = inl[0].get("h", 0)  # J/kg in ExerPy
+                    h_out_hot = outl[0].get("h", 0)  # J/kg
+                    # Q = m [kg/s] x dh [J/kg] = W, convert to kW
+                    Q_hot_kW = abs(m_hot * (h_in_hot - h_out_hot)) / 1000
+                    if Q_hot_kW > 0:
+                        return Q_hot_kW
+
+                # Try cold side (index 1)
+                if 1 in inl and 1 in outl:
+                    m_cold = inl[1].get("m", 0)
+                    h_in_cold = inl[1].get("h", 0)  # J/kg
+                    h_out_cold = outl[1].get("h", 0)  # J/kg
+                    # Q = m [kg/s] x dh [J/kg] = W, convert to kW
+                    Q_cold_kW = abs(m_cold * (h_out_cold - h_in_cold)) / 1000
+                    if Q_cold_kW > 0:
+                        return Q_cold_kW
+        except Exception as e:
+            logging.debug(f"Could not calculate heat duty for {component.name}: {e}")
+
+        return None
+
+    def _estimate_vessel_volume(self, component):
+        """
+        Estimate vessel volume from flow data for Drum, Deaerator, FlashTank, etc.
+
+        Uses the volumetric flow rate and typical residence time to estimate volume.
+        For steam drums and similar vessels, the residence time is based on typical
+        industrial practice for liquid holdup.
+
+        Parameters
+        ----------
+        component : Component
+            Vessel component (Drum, Deaerator, FlashTank, Storage).
+
+        Returns
+        -------
+        float or None
+            Estimated volume in m3, or None if cannot be calculated.
+
+        Notes
+        -----
+        The estimation uses:
+        - V = Q_vol * t_residence
+        - Q_vol is calculated from mass flow rate and density
+        - Density is estimated from pressure and temperature using water properties
+        - Typical residence times: 60s for drums, 300s for deaerators/storage
+        """
+        try:
+            comp_class = component.__class__.__name__
+
+            # Get inlet/outlet data
+            if not hasattr(component, "inl") or not hasattr(component, "outl"):
+                return None
+
+            # Find the liquid outlet (saturated liquid for drums)
+            # For Drum: outlet 0 is typically saturated liquid, outlet 1 is saturated vapor
+            m_liquid = 0
+            rho_liquid = None
+
+            # Try to get liquid flow from outlets
+            for idx in component.outl:
+                outlet = component.outl[idx]
+                m = outlet.get("m", 0)
+                T = outlet.get("T")  # K
+                p = outlet.get("p")  # Pa
+
+                if m > 0 and T is not None and p is not None:
+                    # Estimate density using CoolProp if available, else use approximation
+                    try:
+                        from CoolProp.CoolProp import PropsSI
+
+                        # Check if this is liquid (quality x < 0.5) or use saturated liquid density
+                        x = outlet.get("x")
+                        if x is not None and x < 0.5:
+                            # This is the liquid outlet
+                            rho = PropsSI("D", "T", T, "P", p, "Water")
+                            m_liquid = max(m_liquid, m)
+                            rho_liquid = rho
+                        elif x is None:
+                            # No quality info, check if subcooled (T < T_sat)
+                            T_sat = PropsSI("T", "P", p, "Q", 0, "Water")
+                            if T <= T_sat:
+                                rho = PropsSI("D", "T", T, "P", p, "Water")
+                                m_liquid = max(m_liquid, m)
+                                rho_liquid = rho
+                    except Exception:
+                        # Fallback: use approximate water density at saturation
+                        # Rough estimate: rho ≈ 1000 - 0.1*(T-273) for liquid water
+                        if T < 500:  # Likely liquid
+                            rho_liquid = 900  # Approximate density kg/m3
+                            m_liquid = max(m_liquid, m)
+
+            if m_liquid <= 0 or rho_liquid is None:
+                # Try inlets as fallback
+                for idx in component.inl:
+                    inlet = component.inl[idx]
+                    m = inlet.get("m", 0)
+                    T = inlet.get("T")
+                    p = inlet.get("p")
+
+                    if m > 0 and T is not None and p is not None:
+                        try:
+                            from CoolProp.CoolProp import PropsSI
+
+                            rho = PropsSI("D", "T", T, "P", p, "Water")
+                            m_liquid = max(m_liquid, m)
+                            rho_liquid = rho
+                        except Exception:
+                            if T < 500:
+                                rho_liquid = 900
+                                m_liquid = max(m_liquid, m)
+
+            if m_liquid <= 0 or rho_liquid is None:
+                logging.warning(
+                    f"Could not estimate volume for vessel {component.name}. "
+                    f"Please provide volume via custom_sizes parameter."
+                )
+                return None
+
+            # Volumetric flow rate [m3/s]
+            Q_vol = m_liquid / rho_liquid
+
+            # Typical residence times based on vessel type
+            if "Drum" in comp_class:
+                t_residence = 60  # seconds - typical for steam drums
+            elif "Deaerator" in comp_class:
+                t_residence = 300  # seconds - longer for deaeration
+            elif "FlashTank" in comp_class:
+                t_residence = 120  # seconds
+            elif "Storage" in comp_class:
+                t_residence = 600  # seconds - storage tanks need more volume
+            else:
+                t_residence = 120  # default
+
+            # Volume estimate
+            volume = Q_vol * t_residence
+
+            # Apply a minimum practical volume (0.1 m3) and add margin factor
+            margin_factor = 1.5  # Safety margin for sizing
+            volume = max(0.1, volume * margin_factor)
+
+            logging.info(
+                f"Estimated volume for {component.name}: {volume:.2f} m3 "
+                f"(m={m_liquid:.2f} kg/s, rho={rho_liquid:.0f} kg/m3, t_res={t_residence}s)"
+            )
+
+            return volume
+
+        except Exception as e:
+            logging.debug(f"Could not estimate vessel volume for {component.name}: {e}")
+            return None
+
+    def _get_typical_U_value(self, component):
+        """
+        Get overall heat transfer coefficient (U) for heat exchanger sizing.
+
+        Checks in order:
+        1. Custom U value provided by user via custom_U_values parameter
+        2. U value parsed from simulation data (if available)
+        3. Default typical U value based on heat exchanger type (with warning)
+
+        Parameters
+        ----------
+        component : Component
+            Heat exchanger component.
+
+        Returns
+        -------
+        float
+            U value in W/(m2-K).
+        """
+        comp_name = component.name
+        comp_class = component.__class__.__name__
+
+        # 1. Check for user-provided custom U value
+        if hasattr(self, "_custom_U_values") and comp_name in self._custom_U_values:
+            return self._custom_U_values[comp_name]
+
+        # 2. Check if U value is available in simulation data (e.g., from TESPy UA)
+        # Look for UA or U attribute in component or connection data
+        if hasattr(component, "UA") and component.UA is not None and component.UA > 0:
+            # If we have UA, we'd need area to get U, but we're trying to find area
+            # So this is circular - skip for now
+            pass
+
+        # 3. Use default typical U value and track for warning
+        default_U = self._get_default_U_value(component)
+
+        # Track that this component is using a default U value
+        if hasattr(self, "_hx_using_default_U"):
+            self._hx_using_default_U.append((comp_name, comp_class, default_U))
+
+        return default_U
+
+    def _get_default_U_value(self, component):
+        """
+        Get default typical U value based on heat exchanger type and operating conditions.
+
+        Parameters
+        ----------
+        component : Component
+            Heat exchanger component.
+
+        Returns
+        -------
+        float
+            Default U value in W/(m2-K).
+        """
+        comp_class = component.__class__.__name__
+
+        # Check temperatures to determine service type
+        try:
+            if hasattr(component, "inl") and hasattr(component, "outl"):
+                component.inl.get(0, {}).get("T", 300)
+                T_cold_in = component.inl.get(1, {}).get("T", 300)
+
+                # Condenser (refrigerant condensing): higher U
+                if "Condenser" in comp_class:
+                    return 1500  # W/(m2-K) - refrigerant condensing to water/air
+
+                # Evaporator: lower U due to boiling
+                if T_cold_in < 273.15:  # Below 0 deg C, likely refrigeration
+                    return 300  # W/(m2-K) - evaporator with refrigerant
+
+                # Steam generator / boiler
+                if "SteamGenerator" in comp_class:
+                    return 1000  # W/(m2-K)
+
+                # General liquid-liquid
+                return 500  # W/(m2-K) - default shell-and-tube
+        except Exception:
+            pass
+
+        return 500  # Default value
+
+    def _estimate_LMTD(self, component):
+        """
+        Estimate Log Mean Temperature Difference (LMTD) for heat exchanger.
+
+        Parameters
+        ----------
+        component : Component
+            Heat exchanger component.
+
+        Returns
+        -------
+        float
+            Estimated LMTD in K.
+        """
+        try:
+            if hasattr(component, "inl") and hasattr(component, "outl"):
+                inl = component.inl
+                outl = component.outl
+
+                if 0 in inl and 0 in outl and 1 in inl and 1 in outl:
+                    T_hot_in = inl[0].get("T", 0)
+                    T_hot_out = outl[0].get("T", 0)
+                    T_cold_in = inl[1].get("T", 0)
+                    T_cold_out = outl[1].get("T", 0)
+
+                    # Assume counter-current flow
+                    dT1 = T_hot_in - T_cold_out
+                    dT2 = T_hot_out - T_cold_in
+
+                    # Avoid division by zero or log of negative
+                    if dT1 > 0 and dT2 > 0 and abs(dT1 - dT2) > 0.01:
+                        LMTD = (dT1 - dT2) / np.log(dT1 / dT2)
+                        return max(LMTD, 1.0)  # Minimum 1 K
+                    elif dT1 > 0 and dT2 > 0:
+                        return (dT1 + dT2) / 2  # Arithmetic mean if nearly equal
+        except Exception:
+            pass
+
+        return 10.0  # Default LMTD of 10 K
+
+    def _get_component_pressure(self, component, mapping_info):
+        """
+        Extract pressure parameter from component based on mapping configuration.
+
+        Parameters
+        ----------
+        component : Component
+            ExerPy component object.
+        mapping_info : dict
+            Component mapping information from component_mapping.json.
+
+        Returns
+        -------
+        float
+            Pressure in barg, or 0 if not available.
+        """
+        params = mapping_info.get("parameters", {})
+        pressure_info = params.get("pressure")
+
+        if pressure_info is None:
+            return 0
+
+        attr_name = pressure_info.get("attribute")
+        if attr_name and hasattr(component, attr_name):
+            p_pa = getattr(component, attr_name)
+            # Convert Pa to barg (assuming Pa input)
+            return (p_pa - 101325) / 100000  # Pa to barg
+
+        # Try to get pressure from inlet/outlet connections
+        if hasattr(component, "inlets") and component.inlets:
+            for conn_name in component.inlets:
+                conn = self.connections.get(conn_name, {})
+                if "p" in conn:
+                    # Assume pressure is in Pa
+                    return (conn["p"] - 101325) / 100000
+
+        # Fallback: try to get pressure from inl dictionary (ExerPy component structure)
+        if hasattr(component, "inl") and component.inl:
+            for idx in component.inl:
+                inlet = component.inl[idx]
+                if "p" in inlet and inlet["p"] is not None:
+                    # Assume pressure is in Pa
+                    return (inlet["p"] - 101325) / 100000
+
+        return 0
+
+    def _detect_turbine_type(self, component, mapping_info):
+        """
+        Automatically detect turbine equipment type based on working fluid and size.
+
+        Parameters
+        ----------
+        component : Component
+            Turbine component object.
+        mapping_info : dict
+            Component mapping information from component_mapping.json.
+
+        Returns
+        -------
+        str
+            Equipment type string (e.g., 'drives.steam_turbine', 'turbines.axial_gas').
+        """
+        auto_detect = mapping_info.get("auto_detect", {})
+        steam_fluids = auto_detect.get("steam_fluids", ["water", "Water", "HEOS::Water", "IF97::Water"])
+        steam_equipment = auto_detect.get("steam_equipment", "drives.steam_turbine")
+        gas_equipment = auto_detect.get("gas_equipment", "turbines.axial_gas")
+        large_gas_turbine_equipment = auto_detect.get("large_gas_turbine_equipment", "drives.gas_turbine")
+        large_gas_turbine_threshold = auto_detect.get("large_gas_turbine_threshold_kW", 4000)
+        liquid_expander_equipment = auto_detect.get("liquid_expander_equipment", "turbines.radial_gas_liquid_expander")
+
+        # Try to get fluid from inlet connection
+        fluid = None
+        inlet_phase = None
+
+        if hasattr(component, "inl") and component.inl:
+            inlet = component.inl.get(0, {})
+            fluid = inlet.get("fluid")
+
+            # Check if fluid info is in connection data from self.connections
+            if fluid is None and hasattr(component, "inlets") and component.inlets:
+                for conn_name in component.inlets:
+                    conn = self.connections.get(conn_name, {})
+                    fluid = conn.get("fluid")
+                    # Also check for phase information
+                    inlet_phase = conn.get("x")  # vapor quality
+                    if fluid:
+                        break
+
+        # Get turbine power for size-based selection
+        power_kW = None
+        if hasattr(component, "E_P") and component.E_P is not None:
+            power_kW = abs(component.E_P) / 1000  # Convert W to kW
+
+        # Determine equipment type based on fluid
+        if fluid:
+            # Check if it's a steam/water fluid
+            is_steam = any(sf.lower() in str(fluid).lower() for sf in steam_fluids)
+
+            if is_steam:
+                logging.info(f"Turbine {component.name}: detected steam/water fluid '{fluid}' -> using {steam_equipment}")
+                return steam_equipment
+            else:
+                # Check if it's a liquid (x close to 0) or gas/two-phase
+                if inlet_phase is not None and inlet_phase < 0.1:
+                    # Liquid expander
+                    logging.info(
+                        f"Turbine {component.name}: detected liquid phase (x={inlet_phase:.2f}) "
+                        f"with fluid '{fluid}' -> using {liquid_expander_equipment}"
+                    )
+                    return liquid_expander_equipment
+                else:
+                    # Gas turbine / expander - check size for large gas turbines
+                    if power_kW is not None and power_kW > large_gas_turbine_threshold:
+                        logging.info(
+                            f"Turbine {component.name}: detected large gas turbine "
+                            f"(P={power_kW:.0f} kW > {large_gas_turbine_threshold} kW) "
+                            f"with fluid '{fluid}' -> using {large_gas_turbine_equipment}"
+                        )
+                        return large_gas_turbine_equipment
+                    else:
+                        logging.info(
+                            f"Turbine {component.name}: detected gas/refrigerant fluid '{fluid}' "
+                            f"-> using {gas_equipment}"
+                        )
+                        return gas_equipment
+
+        # Default to steam turbine if fluid cannot be determined
+        logging.warning(
+            f"Turbine {component.name}: could not detect working fluid, defaulting to {steam_equipment}. "
+            f"Use custom_mappings to specify equipment type if this is incorrect."
+        )
+        return mapping_info.get("default", steam_equipment)
+
+    def estimate_costs(
+        self,
+        cepci_year=2024,
+        regional_factor=1.0,
+        operating_hours=8000,
+        equipment_lifetime=20,
+        maintenance_factor=0.06,
+        interest_rate=0.10,
+        escalation_rate=0.03,
+        default_material="CS",
+        custom_mappings=None,
+        custom_sizes=None,
+        custom_U_values=None,
+    ):
+        """
+        Estimate purchased equipment costs for all components in the system.
+
+        Uses Turton 2008 correlations to estimate bare module costs based on
+        component parameters extracted from the exergy analysis.
+
+        Parameters
+        ----------
+        cepci_year : int, optional
+            Year for CEPCI cost adjustment (default: 2024).
+        regional_factor : float, optional
+            Regional location factor relative to US Gulf Coast (default: 1.0).
+        operating_hours : float, optional
+            Annual operating hours for converting capital to hourly cost (default: 8000).
+        equipment_lifetime : float, optional
+            Equipment lifetime in years for annualization (default: 20).
+        maintenance_factor : float, optional
+            Annual maintenance cost as fraction of capital cost (default: 0.06).
+        interest_rate : float, optional
+            Effective interest rate for capital recovery factor (default: 0.10 = 10%).
+        escalation_rate : float, optional
+            Nominal cost escalation rate for O&M costs (default: 0.03 = 3%).
+        default_material : str, optional
+            Default material of construction (default: "CS" for carbon steel).
+        custom_mappings : dict, optional
+            Custom equipment type mappings for specific components.
+            Format: {"component_name": "category.equipment_type"}
+        custom_sizes : dict, optional
+            Custom size parameters for specific components.
+            Format: {"component_name": size_value}
+        custom_U_values : dict, optional
+            Custom heat transfer coefficients (U values) for heat exchangers in W/(m2-K).
+            Format: {"component_name": U_value}
+            If not provided, default values are used and a warning is issued.
+
+        Returns
+        -------
+        dict
+            Dictionary with component costs in the format required by run():
+            {"component_name_Z": cost_in_currency_per_hour, ...}
+
+        Notes
+        -----
+        The returned costs are annualized capital costs plus levelized O&M,
+        expressed in currency/hour for direct use with run().
+
+        The annualization formula used is:
+        Z [currency/h] = (CBM * CRF + OMC_first_year * CELF) / operating_hours
+
+        Where:
+        - CRF (Capital Recovery Factor) = i * (1+i)^n / ((1+i)^n - 1)
+        - CELF (Cost Escalation Levelization Factor) = ((1 - k^n) / (1 - k)) * CRF
+        - k = (1 + r_n) / (1 + i)
+        - OMC_first_year = CBM * maintenance_factor
+        """
+        data = self._load_cost_data()
+        mapping_data = data.get("component_mapping", {}).get("components", {})
+
+        custom_mappings = custom_mappings or {}
+        custom_sizes = custom_sizes or {}
+        custom_U_values = custom_U_values or {}
+
+        # Store custom U values for use in _get_typical_U_value
+        self._custom_U_values = custom_U_values
+        self._hx_using_default_U = []  # Track heat exchangers using default U values
+
+        # Economic factors
+        i = interest_rate
+        r_n = escalation_rate
+        n = equipment_lifetime
+
+        # Capital Recovery Factor (CRF)
+        CRF = (i * (1 + i) ** n) / ((1 + i) ** n - 1)
+
+        # Cost Escalation Levelization Factor (CELF) for O&M costs
+        k = (1 + r_n) / (1 + i)
+        if abs(k - 1.0) < 1e-10:
+            # Special case when escalation rate equals interest rate
+            CELF = n * CRF
+        else:
+            CELF = ((1 - k**n) / (1 - k)) * CRF
+
+        estimated_costs = {}
+        cost_details = {}  # Store detailed cost breakdown for reporting
+
+        for comp_name, component in self.components.items():
+            # Skip helper components
+            if isinstance(component, CycleCloser | PowerBus):
+                continue
+
+            comp_class = component.__class__.__name__
+
+            # Check if component has a cost correlation
+            if comp_class not in mapping_data:
+                logging.warning(f"No cost mapping for component type: {comp_class}")
+                continue
+
+            mapping_info = mapping_data[comp_class]
+
+            # Handle components without cost correlations (e.g., Valve, Mixer, Splitter)
+            # Set default cost of 0 for these components
+            if not mapping_info.get("has_cost_correlation", False):
+                logging.info(f"Component {comp_name} ({comp_class}) has no cost correlation - setting Z=0")
+                estimated_costs[f"{comp_name}_Z"] = 0.0
+                cost_details[comp_name] = {
+                    "equipment_type": "N/A (no correlation)",
+                    "size": 0,
+                    "size_unit": "-",
+                    "pressure_barg": 0,
+                    "material": "-",
+                    "CBM_USD": 0,
+                    "Z_hourly": 0,
+                }
+                continue
+
+            # Get equipment type (custom or default, with auto-detection for turbines)
+            if comp_name in custom_mappings:
+                equipment_type = custom_mappings[comp_name]
+            elif comp_class == "Turbine" and "auto_detect" in mapping_info:
+                # Auto-detect turbine type based on working fluid
+                equipment_type = self._detect_turbine_type(component, mapping_info)
+            else:
+                default_type = mapping_info.get("default")
+                if default_type is None:
+                    logging.warning(f"No default equipment type for {comp_class}")
+                    continue
+                equipment_type = default_type
+
+            # Get size parameter
+            if comp_name in custom_sizes:
+                size = custom_sizes[comp_name]
+            else:
+                size = self._get_component_size(component, mapping_info)
+
+            if size is None or size <= 0:
+                logging.warning(
+                    f"Could not determine size for component {comp_name} ({comp_class}). "
+                    f"Please provide size via custom_sizes parameter."
+                )
+                continue
+
+            # Get pressure
+            pressure = self._get_component_pressure(component, mapping_info)
+
+            # Get diameter for vessels (approximate from volume if not available)
+            diameter = None
+            if mapping_info.get("category") == "vessels":
+                if hasattr(component, "diameter"):
+                    diameter = component.diameter
+                elif hasattr(component, "volume") and component.volume:
+                    # Approximate: assume L/D = 3 for horizontal, L/D = 4 for vertical
+                    V = component.volume
+                    diameter = (4 * V / (3 * np.pi)) ** (1 / 3)  # Rough estimate
+
+            try:
+                # Calculate bare module cost
+                CBM = self.calculate_CBM(
+                    equipment_type=equipment_type,
+                    size=size,
+                    pressure=pressure,
+                    material=default_material,
+                    diameter=diameter,
+                    cepci_year=cepci_year,
+                    regional_factor=regional_factor,
+                    component_name=comp_name,
+                    component_type=comp_class,
+                )
+
+                # Annualize and convert to hourly cost
+                # Z = (CBM * CRF + OMC_first_year * CELF) / tau
+                # where OMC_first_year = CBM * maintenance_factor
+                OMC_first_year = CBM * maintenance_factor
+                annual_cost = CBM * CRF + OMC_first_year * CELF
+                hourly_cost = annual_cost / operating_hours
+
+                estimated_costs[f"{comp_name}_Z"] = hourly_cost
+
+                # Store details for reporting
+                cost_details[comp_name] = {
+                    "equipment_type": equipment_type,
+                    "size": size,
+                    "size_unit": mapping_info.get("parameters", {}).get("size", {}).get("unit", ""),
+                    "pressure_barg": pressure,
+                    "material": default_material,
+                    "CBM_USD": CBM,
+                    "Z_hourly": hourly_cost,
+                }
+
+            except Exception as e:
+                logging.warning(f"Failed to estimate cost for {comp_name}: {e}")
+                continue
+
+        # Store cost details for later access
+        self._estimated_cost_details = cost_details
+
+        # Warn about heat exchangers using default U values
+        if hasattr(self, "_hx_using_default_U") and self._hx_using_default_U:
+            logging.warning(
+                "The following heat exchangers are using DEFAULT U values for area estimation. "
+                "Provide custom_U_values parameter for accurate sizing:"
+            )
+            for comp_name, comp_class, default_U in self._hx_using_default_U:
+                logging.warning(f"  - {comp_name} ({comp_class}): U = {default_U} W/(m2-K)")
+
+        return estimated_costs
+
+    def print_estimated_costs(self):
+        """
+        Print a summary table of estimated component costs.
+
+        Requires estimate_costs() to have been called first.
+        """
+        if not hasattr(self, "_estimated_cost_details") or not self._estimated_cost_details:
+            print("No estimated costs available. Run estimate_costs() first.")
+            return
+
+        headers = [
+            "Component",
+            "Equipment Type",
+            "Size",
+            "Unit",
+            "P [barg]",
+            "Material",
+            "CBM [USD]",
+            f"Z [{self.currency}/h]",
+        ]
+        rows = []
+
+        for comp_name, details in self._estimated_cost_details.items():
+            rows.append(
+                [
+                    comp_name,
+                    details["equipment_type"],
+                    f"{details['size']:.2f}",
+                    details["size_unit"],
+                    f"{details['pressure_barg']:.1f}",
+                    details["material"],
+                    f"{details['CBM_USD']:,.0f}",
+                    f"{details['Z_hourly']:.2f}",
+                ]
+            )
+
+        print("\n" + "=" * 100)
+        print("ESTIMATED COMPONENT COSTS (Turton 2008 Correlations)")
+        print("=" * 100)
+        print(tabulate(rows, headers=headers, tablefmt="grid"))
+        print()