Update utils/ctf_calculations.py

utils/ctf_calculations.py

@@ -2,7 +2,9 @@
 CTF Calculations Module
 
 This module contains the CTFCalculator class for calculating Conduction Transfer Function (CTF)
-coefficients for HVAC load calculations using the implicit Finite Difference Method.
+coefficients for HVAC load calculations using the implicit Finite Difference Method, enhanced
+with sol-air temperature calculations accounting for solar radiation, longwave radiation, and
+dynamic outdoor heat transfer coefficient.
 
 Developed by: Dr Majed Abuseif, Deakin University
 © 2025
@@ -16,13 +18,19 @@ import logging
 import threading
 from typing import List, Dict, Any, NamedTuple
 import streamlit as st
-from utils.enums import ComponentType
-from utils.solar import SolarCalculations
+from enum import Enum
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+class ComponentType(Enum):
+    WALL = "Wall"
+    ROOF = "Roof"
+    FLOOR = "Floor"
+    WINDOW = "Window"
+    SKYLIGHT = "Skylight"
+
 class CTFCoefficients(NamedTuple):
     X: List[float]  # Exterior temperature coefficients
     Y: List[float]  # Cross coefficients
@@ -36,6 +44,74 @@ class CTFCalculator:
     _ctf_cache = {}
     _cache_lock = threading.Lock()  # Thread-safe lock for cache access
 
+    @staticmethod
+    def calculate_sky_temperature(T_out: float, dew_point: float, total_sky_cover: float = 0.5) -> float:
+        """Calculate sky temperature using cloud-cover-dependent model.
+
+        Args:
+            T_out (float): Outdoor dry-bulb temperature (°C).
+            dew_point (float): Dew point temperature (°C).
+            total_sky_cover (float): Sky cover fraction (0 to 1).
+
+        Returns:
+            float: Sky temperature (°C), bounded by dew point.
+
+        References:
+            ASHRAE Handbook—Fundamentals (2021), Chapter 26.
+        """
+        epsilon_sky = 0.9 + 0.04 * total_sky_cover
+        T_sky = (epsilon_sky * (T_out + 273.15)**4)**0.25 - 273.15
+        return T_sky if dew_point <= T_out else dew_point
+
+    @staticmethod
+    def calculate_h_o(wind_speed: float, surface_type: ComponentType) -> float:
+        """Calculate dynamic outdoor heat transfer coefficient based on wind speed and surface type.
+
+        Args:
+            wind_speed (float): Wind speed (m/s).
+            surface_type (ComponentType): Type of surface (WALL, ROOF, FLOOR, WINDOW, SKYLIGHT).
+
+        Returns:
+            float: Outdoor heat transfer coefficient (W/m²·K).
+
+        References:
+            ASHRAE Handbook—Fundamentals (2021), Chapter 26.
+        """
+        from app.m_c_data import DEFAULT_WINDOW_PROPERTIES  # Delayed import to avoid circular dependency
+        wind_speed = max(min(wind_speed, 20.0), 0.0)  # Bound for stability
+        if surface_type in [ComponentType.WALL, ComponentType.FLOOR]:
+            h_o = 8.3 + 4.0 * (wind_speed ** 0.6)  # ASHRAE Ch. 26
+        elif surface_type == ComponentType.ROOF:
+            h_o = 9.1 + 2.8 * wind_speed  # ASHRAE Ch. 26
+        else:  # WINDOW, SKYLIGHT
+            h_o = DEFAULT_WINDOW_PROPERTIES["h_o"]
+        return max(h_o, 5.0)  # Minimum for stability
+
+    @staticmethod
+    def calculate_sol_air_temperature(T_out: float, I_t: float, absorptivity: float, emissivity: float, 
+                                     h_o: float, dew_point: float, total_sky_cover: float = 0.5) -> float:
+        """Calculate sol-air temperature for a surface.
+
+        Args:
+            T_out (float): Outdoor dry-bulb temperature (°C).
+            I_t (float): Total incident solar radiation (W/m²).
+            absorptivity (float): Surface absorptivity.
+            emissivity (float): Surface emissivity.
+            h_o (float): Outdoor heat transfer coefficient (W/m²·K).
+            dew_point (float): Dew point temperature (°C).
+            total_sky_cover (float): Sky cover fraction (0 to 1).
+
+        Returns:
+            float: Sol-air temperature (°C).
+
+        References:
+            ASHRAE Handbook—Fundamentals (2021), Chapter 26.
+        """
+        sigma = 5.67e-8  # Stefan-Boltzmann constant (W/m²·K⁴)
+        T_sky = CTFCalculator.calculate_sky_temperature(T_out, dew_point, total_sky_cover)
+        T_sol_air = T_out + (absorptivity * I_t - emissivity * sigma * ((T_out + 273.15)**4 - (T_sky + 273.15)**4)) / h_o
+        return T_sol_air
+
     @staticmethod
     def _hash_construction(construction: Dict[str, Any]) -> str:
         """Generate a unique hash for a construction based on its properties.
@@ -87,14 +163,15 @@ class CTFCalculator:
             return {}
 
     @classmethod
-    def calculate_ctf_coefficients(cls, component: Dict[str, Any]) -> CTFCoefficients:
-        """Calculate CTF coefficients using implicit Finite Difference Method.
+    def calculate_ctf_coefficients(cls, component: Dict[str, Any], hourly_data: Dict[str, Any] = None) -> CTFCoefficients:
+        """Calculate CTF coefficients using implicit Finite Difference Method with sol-air temperature.
 
         Note: Per ASHRAE, CTF calculations are skipped for WINDOW and SKYLIGHT components,
         as they use typical material properties. CTF tables for these components will be added later.
 
         Args:
             component: Dictionary containing component properties from st.session_state.project_data["components"].
+            hourly_data: Dictionary containing hourly weather data (T_out, dew_point, wind_speed, total_sky_cover, I_t).
 
         Returns:
             CTFCoefficients: Named tuple containing X, Y, Z, and F coefficients.
@@ -162,13 +239,28 @@ class CTFCalculator:
         rho = [m['density'] for m in material_props]    # kg/m³
         c = [m['specific_heat'] for m in material_props]  # J/kg·K
         alpha = [k_i / (rho_i * c_i) if rho_i * c_i > 0 else 0.0 for k_i, rho_i, c_i in zip(k, rho, c)]  # Thermal diffusivity (m²/s)
+        absorptivity = material_props[0].get('absorptivity', 0.6)  # Use first layer's absorptivity
+        emissivity = material_props[0].get('emissivity', 0.9)      # Use first layer's emissivity
 
         # Discretization parameters
         dt = 3600  # 1-hour time step (s)
         nodes_per_layer = 3  # 2–4 nodes per layer for balance
-        R_out = 0.04  # Outdoor surface resistance (m²·K/W, ASHRAE)
         R_in = 0.12   # Indoor surface resistance (m²·K/W, ASHRAE)
 
+        # Get weather data for sol-air temperature
+        T_out = hourly_data.get('dry_bulb', 25.0) if hourly_data else 25.0
+        dew_point = hourly_data.get('dew_point', T_out - 5.0) if hourly_data else T_out - 5.0
+        wind_speed = hourly_data.get('wind_speed', 4.0) if hourly_data else 4.0
+        total_sky_cover = hourly_data.get('total_sky_cover', 0.5) if hourly_data else 0.5
+        I_t = hourly_data.get('total_incident_radiation', 0.0) if hourly_data else 0.0
+
+        # Calculate dynamic h_o and sol-air temperature
+        h_o = cls.calculate_h_o(wind_speed, component_type)
+        T_sol_air = cls.calculate_sol_air_temperature(T_out, I_t, absorptivity, emissivity, h_o, dew_point, total_sky_cover)
+        R_out = 1.0 / h_o  # Outdoor surface resistance based on dynamic h_o
+
+        logger.info(f"Calculated h_o={h_o:.2f} W/m²·K, T_sol_air={T_sol_air:.2f}°C for component '{component.get('name', 'Unknown')}'")
+
         # Calculate node spacing and check stability
         total_nodes = sum(nodes_per_layer for _ in thicknesses)
         dx = [t / nodes_per_layer for t in thicknesses]  # Node spacing per layer
@@ -211,7 +303,7 @@ class CTFCalculator:
             if node_j == 0 and layer_idx == 0:  # Outdoor surface node
                 A[idx, idx] = 1.0 + 2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) + dt / (rho_i * c_i * dx_i * R_out)
                 A[idx, idx + 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i)
-                b[idx] = dt / (rho_i * c_i * dx_i * R_out)  # Outdoor temp contribution
+                b[idx] = dt / (rho_i * c_i * dx_i * R_out) * T_sol_air  # Use sol-air temperature
             elif node_j == nodes_per_layer - 1 and layer_idx == len(thicknesses) - 1:  # Indoor surface node
                 A[idx, idx] = 1.0 + 2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) + dt / (rho_i * c_i * dx_i * R_in)
                 A[idx, idx - 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i)
@@ -257,7 +349,7 @@ class CTFCalculator:
         for t in range(num_ctf):
             b_out = b.copy()
             if t == 0:
-                b_out[0] = dt / (rho[0] * c[0] * dx[0] * R_out) if rho[0] * c[0] * dx[0] != 0 else 0.0  # Unit outdoor temp impulse
+                b_out[0] = dt / (rho[0] * c[0] * dx[0] * R_out) * T_sol_air if rho[0] * c[0] * dx[0] != 0 else 0.0  # Unit outdoor temp impulse with sol-air
             T = sparse_linalg.spsolve(A, b_out + T_prev)
             q_in = (T[-1] - 0.0) / R_in  # Indoor heat flux (W/m²)
             Y[t] = q_in
@@ -304,90 +396,4 @@ class CTFCalculator:
             CTFCoefficients: Placeholder zero coefficients until implementation.
         """
         logger.info(f"CTF table calculation for {component.get('type', 'Unknown')} component '{component.get('name', 'Unknown')}' not yet implemented. Returning zero coefficients.")
-        return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
-
-    @classmethod
-    def calculate_heat_flux(cls, component: Dict[str, Any], hourly_data: Dict[str, Any], 
-                           solar_calc: SolarCalculations, building_info: Dict[str, Any]) -> float:
-        """Calculate hourly heat flux using CTF coefficients and sol-air temperature.
-
-        Args:
-            component: Dictionary containing component properties.
-            hourly_data: Dictionary with month, day, hour, dry_bulb, dew_point, wind_speed, 
-                        total_sky_cover, global_horizontal_radiation, direct_normal_radiation, 
-                        diffuse_horizontal_radiation.
-            solar_calc: SolarCalculations instance for sol-air temperature.
-            building_info: Building information dictionary.
-
-        Returns:
-            float: Heat flux through the component (W/m²).
-
-        References:
-            ASHRAE Handbook—Fundamentals, Chapter 26.
-        """
-        # Get component type
-        comp_type_str = component.get('type', '').lower()
-        comp_type_map = {
-            'walls': ComponentType.WALL,
-            'roofs': ComponentType.ROOF,
-            'floors': ComponentType.FLOOR,
-            'windows': ComponentType.WINDOW,
-            'skylights': ComponentType.SKYLIGHT
-        }
-        component_type = comp_type_map.get(comp_type_str, None)
-        if not component_type:
-            logger.warning(f"Invalid component type '{comp_type_str}' for component '{component.get('name', 'Unknown')}'. Returning zero flux.")
-            return 0.0
-
-        # Skip for WINDOW, SKYLIGHT (handled via SHGC)
-        if component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
-            logger.info(f"Skipping heat flux calculation for {component_type.value} component '{component.get('name', 'Unknown')}'.")
-            return 0.0
-
-        # Get CTF coefficients
-        ctf = cls.calculate_ctf_coefficients(component)
-        if not any(ctf.X + ctf.Y + ctf.Z + ctf.F):
-            logger.warning(f"Zero CTF coefficients for component '{component.get('name', 'Unknown')}'. Returning zero flux.")
-            return 0.0
-
-        # Extract hourly data
-        T_out = hourly_data.get('dry_bulb', 25.0)
-        dew_point = hourly_data.get('dew_point', T_out - 5.0)
-        wind_speed = hourly_data.get('wind_speed', 4.0)
-        total_sky_cover = hourly_data.get('total_sky_cover', 0.5)
-        T_in = 24.0  # Assume constant indoor temperature (adjust as needed)
-
-        # Get surface parameters and total incident radiation
-        surface_tilt, surface_azimuth, h_o, emissivity, absorptivity = solar_calc.get_surface_parameters(
-            component, building_info, wind_speed)
-        
-        # Calculate total incident radiation (simplified, reuse solar_calc logic)
-        ghi = hourly_data.get('global_horizontal_radiation', 0.0)
-        dni = hourly_data.get('direct_normal_radiation', ghi * 0.7)
-        dhi = hourly_data.get('diffuse_horizontal_radiation', ghi * 0.3)
-        if ghi <= 0:
-            I_t = 0.0
-        else:
-            # Simplified radiation calculation (full calc in solar.py)
-            view_factor = (1 - math.cos(math.radians(surface_tilt))) / 2
-            ground_reflectivity = 0.2
-            cos_theta = max(math.cos(math.radians(surface_tilt)), 0.0)  # Simplified for CTF
-            I_t = dni * cos_theta + dhi + ground_reflectivity * ghi * view_factor
-
-        # Calculate sol-air temperature
-        T_sol_air = solar_calc.calculate_sol_air_temperature(
-            T_out, I_t, absorptivity, emissivity, h_o, dew_point, total_sky_cover)
-
-        # Calculate heat flux using CTF (q_t = Σ X_i * T_sol_air(t-i) + Σ Z_i * T_in(t-i) - Σ F_i * q(t-i))
-        num_ctf = len(ctf.X)
-        q_t = 0.0
-        for i in range(num_ctf):
-            # Assume T_sol_air and T_in are constant for history (simplified, extend with history buffer if needed)
-            q_t += ctf.X[i] * T_sol_air + ctf.Z[i] * T_in
-            # Flux history (F) requires previous q values; assume zero for first calculation
-            q_t -= ctf.F[i] * 0.0  # Placeholder, implement history buffer for accurate F terms
-
-        logger.info(f"Calculated heat flux for component '{component.get('name', 'Unknown')}' at "
-                   f"{hourly_data.get('month')}/{hourly_data.get('day')}/{hourly_data.get('hour')}: "
-                   f"{q_t:.2f} W/m² (T_sol_air={T_sol_air:.2f}°C)")
-        return q_t
+        return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])