Update utils/ctf_calculations.py

utils/ctf_calculations.py

@@ -165,14 +165,14 @@ class CTFCalculator:
     @classmethod
     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.
         """
@@ -189,31 +189,31 @@ class CTFCalculator:
         if not component_type:
             logger.warning(f"Invalid component type '{comp_type_str}' for component '{component.get('name', 'Unknown')}'. Returning zero CTFs.")
             return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
-
+    
         # Skip CTF for WINDOW, SKYLIGHT as per ASHRAE; return zero coefficients
         if component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
             logger.info(f"Skipping CTF calculation for {component_type.value} component '{component.get('name', 'Unknown')}'. Using zero coefficients until CTF tables are implemented.")
             return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
-
+    
         # Retrieve construction
         construction_name = component.get('construction', '')
         if not construction_name:
             logger.warning(f"No construction specified for component '{component.get('name', 'Unknown')}' ({component_type.value}). Returning zero CTFs.")
             return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
-
+    
         constructions = st.session_state.project_data.get('constructions', {})
         construction = constructions.get('library', {}).get(construction_name, constructions.get('project', {}).get(construction_name))
         if not construction or not construction.get('layers'):
             logger.warning(f"No valid construction or layers found for construction '{construction_name}' in component '{component.get('name', 'Unknown')}' ({component_type.value}). Returning zero CTFs.")
             return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
-
+    
         # Check cache with thread-safe access
         construction_hash = cls._hash_construction(construction)
         with cls._cache_lock:
             if construction_hash in cls._ctf_cache:
                 logger.info(f"Using cached CTF coefficients for construction '{construction_name}'")
                 return cls._ctf_cache[construction_hash]
-
+    
         # Collect layer properties
         thicknesses = []
         material_props = []
@@ -229,11 +229,11 @@ class CTFCalculator:
                 continue
             thicknesses.append(thickness)
             material_props.append(material)
-
+    
         if not thicknesses or not material_props:
             logger.warning(f"No valid layers with material properties for construction '{construction_name}' in component '{component.get('name', 'Unknown')}'. Returning zero CTFs.")
             return CTFCoefficients(X=[0.0], Y=[0.0], Z=[0.0], F=[0.0])
-
+    
         # Extract material properties
         k = [m['conductivity'] for m in material_props]  # W/m·K
         rho = [m['density'] for m in material_props]    # kg/m³
@@ -241,26 +241,26 @@ class CTFCalculator:
         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_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
+        total_sky_cover = hourly_data.get('total_sky_cover', 0.5) if hourly_data else 0.0
         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
@@ -270,7 +270,7 @@ class CTFCalculator:
             for j in range(nodes_per_layer):
                 node_positions.append((i, j, node_idx))  # (layer_idx, node_in_layer, global_node_idx)
                 node_idx += 1
-
+    
         # Stability check: Fourier number
         for i, (a, d) in enumerate(zip(alpha, dx)):
             if a == 0 or d == 0:
@@ -284,22 +284,22 @@ class CTFCalculator:
                 dx[i] = thicknesses[i] / nodes_per_layer
                 Fo = a * dt / (dx[i] ** 2)
                 logger.info(f"Adjusted node spacing for layer {i}: dx={dx[i]:.4f} m, Fo={Fo:.3f}")
-
+    
         # Build system matrices
         A = sparse.lil_matrix((total_nodes, total_nodes))
         b = np.zeros(total_nodes)
         node_to_layer = [i for i, _, _ in node_positions]
-
+    
         for idx, (layer_idx, node_j, global_idx) in enumerate(node_positions):
             k_i = k[layer_idx]
             rho_i = rho[layer_idx]
             c_i = c[layer_idx]
             dx_i = dx[layer_idx]
-
+    
             if k_i == 0 or rho_i == 0 or c_i == 0 or dx_i == 0:
                 logger.warning(f"Invalid material properties for layer {layer_idx} ({material_props[layer_idx]['name']}) in construction '{construction_name}'. Using default values.")
                 continue
-
+    
             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)
@@ -308,6 +308,13 @@ class CTFCalculator:
                 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)
                 b[idx] = dt / (rho_i * c_i * dx_i * R_in)  # Indoor temp contribution
+                # Add radiant load to indoor surface node (convert kW to W)
+                radiant_load = component.get("radiant_load", 0.0) * 1000  # kW to W
+                if radiant_load != 0 and rho_i * c_i * dx_i != 0:
+                    b[idx] += dt / (rho_i * c_i * dx_i) * radiant_load
+                    logger.debug(f"Added radiant load {radiant_load:.2f} W to indoor node for component '{component.get('name', 'Unknown')}'")
+                elif radiant_load != 0:
+                    logger.warning(f"Invalid material properties (rho={rho_i}, c={c_i}, dx={dx_i}) for radiant load in component '{component.get('name', 'Unknown')}'. Skipping.")
             elif node_j == nodes_per_layer - 1 and layer_idx < len(thicknesses) - 1:  # Interface between layers
                 k_next = k[layer_idx + 1]
                 dx_next = dx[layer_idx + 1]
@@ -334,9 +341,9 @@ class CTFCalculator:
                 A[idx, idx] = 1.0 + 2 * dt * k_i / (dx_i * rho_i * c_i * dx_i)
                 A[idx, idx - 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i)
                 A[idx, idx + 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i)
-
+    
         A = A.tocsr()  # Convert to CSR for efficient solving
-
+    
         # Calculate CTF coefficients (X, Y, Z, F)
         num_ctf = 12  # Standard number of coefficients
         X = [0.0] * num_ctf  # Exterior temp response
@@ -344,7 +351,7 @@ class CTFCalculator:
         Z = [0.0] * num_ctf  # Interior temp response
         F = [0.0] * num_ctf  # Flux history
         T_prev = np.zeros(total_nodes)  # Previous temperatures
-
+    
         # Impulse response for exterior temperature (X, Y)
         for t in range(num_ctf):
             b_out = b.copy()
@@ -356,7 +363,7 @@ class CTFCalculator:
             q_out = (0.0 - T[0]) / R_out  # Outdoor heat flux
             X[t] = q_out
             T_prev = T.copy()
-
+    
         # Reset for interior temperature (Z)
         T_prev = np.zeros(total_nodes)
         for t in range(num_ctf):
@@ -367,7 +374,7 @@ class CTFCalculator:
             q_in = (T[-1] - 0.0) / R_in
             Z[t] = q_in
             T_prev = T.copy()
-
+    
         # Flux history coefficients (F)
         T_prev = np.zeros(total_nodes)
         for t in range(num_ctf):
@@ -378,7 +385,7 @@ class CTFCalculator:
             q_in = (T[-1] - 0.0) / R_in
             F[t] = q_in
             T_prev = T.copy()
-
+    
         ctf = CTFCoefficients(X=X, Y=Y, Z=Z, F=F)
         with cls._cache_lock:
             cls._ctf_cache[construction_hash] = ctf