Update utils/ctf_calculations.py

utils/ctf_calculations.py

@@ -17,6 +17,7 @@ import threading
 from typing import List, Dict, Any, NamedTuple
 import streamlit as st
 from enum import Enum
+from utils.solar import SolarCalculations
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -310,4 +311,90 @@ 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])
+        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