Update utils/ctf_calculations.py

utils/ctf_calculations.py

@@ -113,17 +113,17 @@ class CTFCalculator:
         return T_sol_air
 
     @staticmethod
-    def _hash_construction(construction: Dict[str, Any], nodes_per_layer: int) -> str:
+    def _hash_construction(construction: Dict[str, Any], nodes_per_layer: List[int]) -> str:
         """Generate a unique hash for a construction based on its properties and node discretization.
     
         Args:
             construction: Dictionary containing construction properties (name, layers, adiabatic).
-            nodes_per_layer: Number of nodes per layer used in discretization.
+            nodes_per_layer: List of number of nodes per layer used in discretization.
     
         Returns:
             str: SHA-256 hash of the construction properties and nodes_per_layer.
         """
-        hash_input = f"{construction.get('name', '')}{construction.get('adiabatic', False)}{nodes_per_layer}"
+        hash_input = f"{construction.get('name', '')}{construction.get('adiabatic', False)}{''.join(map(str, nodes_per_layer))}"
         layers = construction.get('layers', [])
         for layer in layers:
             material_name = layer.get('material', '')
@@ -133,14 +133,14 @@ class CTFCalculator:
 
     @classmethod
     def _get_material_properties(cls, material_name: str) -> Dict[str, float]:
-        """Retrieve material properties from session state.
+        """Retrieve material properties from session state with validation.
 
         Args:
             material_name: Name of the material.
 
         Returns:
             Dict containing conductivity, density, specific_heat, absorptivity, emissivity.
-            Returns empty dict if material not found.
+            Returns empty dict if material not found or properties are invalid.
         """
         try:
             materials = st.session_state.project_data.get('materials', {})
@@ -151,11 +151,26 @@ class CTFCalculator:
             
             # Extract required properties
             thermal_props = material.get('thermal_properties', {})
+            conductivity = thermal_props.get('conductivity', 0.0)
+            density = thermal_props.get('density', 0.0)
+            specific_heat = thermal_props.get('specific_heat', 0.0)
+            
+            # Validate properties
+            if conductivity <= 0 or conductivity > 1000:  # Reasonable bounds for conductivity (W/m·K)
+                logger.error(f"Invalid conductivity {conductivity} for material '{material_name}'. Must be between 0 and 1000 W/m·K.")
+                return {}
+            if density <= 0 or density > 10000:  # Reasonable bounds for density (kg/m³)
+                logger.error(f"Invalid density {density} for material '{material_name}'. Must be between 0 and 10000 kg/m³.")
+                return {}
+            if specific_heat <= 0 or specific_heat > 5000:  # Reasonable bounds for specific heat (J/kg·K)
+                logger.error(f"Invalid specific heat {specific_heat} for material '{material_name}'. Must be between 0 and 5000 J/kg·K.")
+                return {}
+            
             return {
                 'name': material_name,
-                'conductivity': thermal_props.get('conductivity', 0.0),
-                'density': thermal_props.get('density', 0.0),
-                'specific_heat': thermal_props.get('specific_heat', 0.0),
+                'conductivity': conductivity,
+                'density': density,
+                'specific_heat': specific_heat,
                 'absorptivity': material.get('absorptivity', 0.6),
                 'emissivity': material.get('emissivity', 0.9)
             }
@@ -229,7 +244,7 @@ class CTFCalculator:
                 continue
             material = cls._get_material_properties(material_name)
             if not material:
-                logger.warning(f"Skipping layer with material '{material_name}' in construction '{construction_name}' due to missing properties.")
+                logger.warning(f"Skipping layer with material '{material_name}' in construction '{construction_name}' due to missing or invalid properties.")
                 continue
             thicknesses.append(thickness)
             material_props.append(material)
@@ -248,7 +263,7 @@ class CTFCalculator:
     
         # Discretization parameters
         dt = 3600  # 1-hour time step (s)
-        nodes_per_layer = 3  # Initial number of nodes per layer
+        nodes_per_layer = [3] * len(thicknesses)  # Initial number of nodes per layer
         R_in = 0.12   # Indoor surface resistance (m²·K/W, ASHRAE)
     
         # Get weather data for sol-air temperature
@@ -273,27 +288,26 @@ class CTFCalculator:
                 return cls._ctf_cache[construction_hash]
     
         # Calculate node spacing
-        dx = [t / nodes_per_layer for t in thicknesses]  # Initial node spacing per layer
-        node_positions = []
-        node_idx = 0
-        for i, t in enumerate(thicknesses):
-            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
-    
+        dx = [t / n for t, n in zip(thicknesses, nodes_per_layer)]  # Initial node spacing per layer
+        
         # Stability check: Fourier number
-        for i, (a, d) in enumerate(zip(alpha, dx)):
+        for i, (a, d, t) in enumerate(zip(alpha, dx, thicknesses)):
             if a == 0 or d == 0:
                 logger.warning(f"Invalid thermal diffusivity or node spacing for layer {i} in construction '{construction_name}'. Skipping stability adjustment.")
                 continue
             Fo = a * dt / (d ** 2)
             if Fo > 0.5 or Fo < 0.33:
                 logger.warning(f"Fourier number {Fo:.3f} out of stable range (0.33 ≤ Fo ≤ 0.5) for layer {i} ({material_props[i]['name']}). Adjusting dx.")
-                dx[i] = np.sqrt(a * dt / 0.4)  # Target Fo = 0.4
-                nodes_per_layer = max(2, int(np.ceil(thicknesses[i] / dx[i])))
-                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}")
+                if Fo > 1000:  # Handle extreme cases (e.g., air spaces, thin metal layers)
+                    logger.warning(f"Extreme Fourier number {Fo:.3f} detected. Using minimum dx for layer {i}.")
+                    dx[i] = t / 2  # Minimum 2 nodes per layer
+                    nodes_per_layer[i] = 2
+                else:
+                    dx[i] = np.sqrt(a * dt / 0.4)  # Target Fo = 0.4
+                    nodes_per_layer[i] = max(2, int(np.ceil(t / dx[i])))
+                    dx[i] = t / nodes_per_layer[i]
+                Fo = a * dt / (dx[i] ** 2) if dx[i] != 0 else 0.0
+                logger.info(f"Adjusted node spacing for layer {i}: dx={dx[i]:.4f} m, Fo={Fo:.3f}, nodes={nodes_per_layer[i]}")
     
         # Update construction hash if nodes_per_layer changed
         construction_hash = cls._hash_construction(construction, nodes_per_layer)
@@ -302,8 +316,16 @@ class CTFCalculator:
                 logger.info(f"Using cached CTF coefficients for construction '{construction_name}' after node adjustment")
                 return cls._ctf_cache[construction_hash]
     
+        # Build node positions
+        node_positions = []
+        node_idx = 0
+        for i, n in enumerate(nodes_per_layer):
+            for j in range(n):
+                node_positions.append((i, j, node_idx))  # (layer_idx, node_in_layer, global_node_idx)
+                node_idx += 1
+    
         # Build system matrices
-        total_nodes = sum(nodes_per_layer for _ in thicknesses)
+        total_nodes = sum(nodes_per_layer)
         A = sparse.lil_matrix((total_nodes, total_nodes))
         b = np.zeros(total_nodes)
         node_to_layer = [i for i, _, _ in node_positions]
@@ -313,6 +335,7 @@ class CTFCalculator:
             rho_i = rho[layer_idx]
             c_i = c[layer_idx]
             dx_i = dx[layer_idx]
+            npl_i = nodes_per_layer[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.")
@@ -320,11 +343,11 @@ 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)
+                A[idx, idx + 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx + 1 < total_nodes else 0.0
                 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
+            elif node_j == npl_i - 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)
+                A[idx, idx - 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx - 1 >= 0 else 0.0
                 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
@@ -333,7 +356,7 @@ class CTFCalculator:
                     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
+            elif node_j == npl_i - 1 and layer_idx < len(thicknesses) - 1:  # Interface between layers
                 k_next = k[layer_idx + 1]
                 dx_next = dx[layer_idx + 1]
                 rho_next = rho[layer_idx + 1]
@@ -342,8 +365,8 @@ class CTFCalculator:
                     logger.warning(f"Invalid material properties for layer {layer_idx + 1} ({material_props[layer_idx + 1]['name']}) in construction '{construction_name}'. Skipping interface.")
                     continue
                 A[idx, idx] = 1.0 + dt * (k_i / dx_i + k_next / dx_next) / (0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
-                A[idx, idx - 1] = -dt * k_i / (dx_i * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
-                A[idx, idx + 1] = -dt * k_next / (dx_next * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
+                A[idx, idx - 1] = -dt * k_i / (dx_i * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next)) if idx - 1 >= 0 else 0.0
+                A[idx, idx + 1] = -dt * k_next / (dx_next * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next)) if idx + 1 < total_nodes else 0.0
             elif node_j == 0 and layer_idx > 0:  # Interface from previous layer
                 k_prev = k[layer_idx - 1]
                 dx_prev = dx[layer_idx - 1]
@@ -353,12 +376,12 @@ class CTFCalculator:
                     logger.warning(f"Invalid material properties for layer {layer_idx - 1} ({material_props[layer_idx - 1]['name']}) in construction '{construction_name}'. Skipping interface.")
                     continue
                 A[idx, idx] = 1.0 + dt * (k_prev / dx_prev + k_i / dx_i) / (0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
-                A[idx, idx - 1] = -dt * k_prev / (dx_prev * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
-                A[idx, idx + 1] = -dt * k_i / (dx_i * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
+                A[idx, idx - 1] = -dt * k_prev / (dx_prev * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i)) if idx - 1 >= 0 else 0.0
+                A[idx, idx + 1] = -dt * k_i / (dx_i * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i)) if idx + 1 < total_nodes else 0.0
             else:  # Internal node
                 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[idx, idx - 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx - 1 >= 0 else 0.0
+                A[idx, idx + 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx + 1 < total_nodes else 0.0
     
         A = A.tocsr()  # Convert to CSR for efficient solving
     
@@ -369,19 +392,19 @@ class CTFCalculator:
             cond_number = norm(A, ord=2) * norm(sparse_linalg.inv(A_csc), ord=2)
             if cond_number > 1e6:
                 logger.warning(f"Matrix A is ill-conditioned (condition number: {cond_number:.2e}). Adjusting node spacing.")
-                nodes_per_layer = min(nodes_per_layer + 1, 6)
-                dx = [t / nodes_per_layer for t in thicknesses]
+                nodes_per_layer = [min(n + 1, 6) for n in nodes_per_layer]  # Increase nodes, cap at 6
+                dx = [t / n for t, n in zip(thicknesses, nodes_per_layer)]
                 
                 # Recalculate node positions
                 node_positions = []
                 node_idx = 0
-                for i, t in enumerate(thicknesses):
-                    for j in range(nodes_per_layer):
+                for i, n in enumerate(nodes_per_layer):
+                    for j in range(n):
                         node_positions.append((i, j, node_idx))
                         node_idx += 1
                 
                 # Rebuild system matrices
-                total_nodes = sum(nodes_per_layer for _ in thicknesses)
+                total_nodes = sum(nodes_per_layer)
                 A = sparse.lil_matrix((total_nodes, total_nodes))
                 b = np.zeros(total_nodes)
                 node_to_layer = [i for i, _, _ in node_positions]
@@ -391,6 +414,7 @@ class CTFCalculator:
                     rho_i = rho[layer_idx]
                     c_i = c[layer_idx]
                     dx_i = dx[layer_idx]
+                    npl_i = nodes_per_layer[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.")
@@ -398,11 +422,11 @@ class CTFCalculator:
                     
                     if node_j == 0 and layer_idx == 0:
                         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)
+                        A[idx, idx + 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx + 1 < total_nodes else 0.0
                         b[idx] = dt / (rho_i * c_i * dx_i * R_out) * T_sol_air
-                    elif node_j == nodes_per_layer - 1 and layer_idx == len(thicknesses) - 1:
+                    elif node_j == npl_i - 1 and layer_idx == len(thicknesses) - 1:
                         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)
+                        A[idx, idx - 1] = -2 * dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx - 1 >= 0 else 0.0
                         b[idx] = dt / (rho_i * c_i * dx_i * R_in)
                         radiant_load = component.get("radiant_load", 0.0) * 1000
                         if radiant_load != 0 and rho_i * c_i * dx_i != 0:
@@ -410,7 +434,7 @@ class CTFCalculator:
                             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:
+                    elif node_j == npl_i - 1 and layer_idx < len(thicknesses) - 1:
                         k_next = k[layer_idx + 1]
                         dx_next = dx[layer_idx + 1]
                         rho_next = rho[layer_idx + 1]
@@ -419,8 +443,8 @@ class CTFCalculator:
                             logger.warning(f"Invalid material properties for layer {layer_idx + 1} ({material_props[layer_idx + 1]['name']}) in construction '{construction_name}'. Skipping interface.")
                             continue
                         A[idx, idx] = 1.0 + dt * (k_i / dx_i + k_next / dx_next) / (0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
-                        A[idx, idx - 1] = -dt * k_i / (dx_i * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
-                        A[idx, idx + 1] = -dt * k_next / (dx_next * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next))
+                        A[idx, idx - 1] = -dt * k_i / (dx_i * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next)) if idx - 1 >= 0 else 0.0
+                        A[idx, idx + 1] = -dt * k_next / (dx_next * 0.5 * (rho_i * c_i * dx_i + rho_next * c_next * dx_next)) if idx + 1 < total_nodes else 0.0
                     elif node_j == 0 and layer_idx > 0:
                         k_prev = k[layer_idx - 1]
                         dx_prev = dx[layer_idx - 1]
@@ -430,12 +454,12 @@ class CTFCalculator:
                             logger.warning(f"Invalid material properties for layer {layer_idx - 1} ({material_props[layer_idx - 1]['name']}) in construction '{construction_name}'. Skipping interface.")
                             continue
                         A[idx, idx] = 1.0 + dt * (k_prev / dx_prev + k_i / dx_i) / (0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
-                        A[idx, idx - 1] = -dt * k_prev / (dx_prev * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
-                        A[idx, idx + 1] = -dt * k_i / (dx_i * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
+                        A[idx, idx - 1] = -dt * k_prev / (dx_prev * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i)) if idx - 1 >= 0 else 0.0
+                        A[idx, idx + 1] = -dt * k_i / (dx_i * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i)) if idx + 1 < total_nodes else 0.0
                     else:
                         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[idx, idx - 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx - 1 >= 0 else 0.0
+                        A[idx, idx + 1] = -dt * k_i / (dx_i * rho_i * c_i * dx_i) if idx + 1 < total_nodes else 0.0
                 
                 A = A.tocsr()
                 construction_hash = cls._hash_construction(construction, nodes_per_layer)