Update utils/ctf_calculations.py

utils/ctf_calculations.py

@@ -113,17 +113,16 @@ class CTFCalculator:
         return T_sol_air
 
     @staticmethod
-    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.
+    def _hash_construction(construction: Dict[str, Any]) -> str:
+        """Generate a unique hash for a construction based on its properties.
     
         Args:
             construction: Dictionary containing construction properties (name, layers, adiabatic).
-            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.
+            str: SHA-256 hash of the construction properties.
         """
-        hash_input = f"{construction.get('name', '')}{construction.get('adiabatic', False)}{''.join(map(str, nodes_per_layer))}"
+        hash_input = f"{construction.get('name', '')}{construction.get('adiabatic', False)}"
         layers = construction.get('layers', [])
         for layer in layers:
             material_name = layer.get('material', '')
@@ -133,14 +132,14 @@ class CTFCalculator:
 
     @classmethod
     def _get_material_properties(cls, material_name: str) -> Dict[str, float]:
-        """Retrieve material properties from session state with validation.
+        """Retrieve material properties from session state.
 
         Args:
             material_name: Name of the material.
 
         Returns:
             Dict containing conductivity, density, specific_heat, absorptivity, emissivity.
-            Returns empty dict if material not found or properties are invalid.
+            Returns empty dict if material not found.
         """
         try:
             materials = st.session_state.project_data.get('materials', {})
@@ -151,26 +150,11 @@ 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': conductivity,
-                'density': density,
-                'specific_heat': specific_heat,
+                'conductivity': thermal_props.get('conductivity', 0.0),
+                'density': thermal_props.get('density', 0.0),
+                'specific_heat': thermal_props.get('specific_heat', 0.0),
                 'absorptivity': material.get('absorptivity', 0.6),
                 'emissivity': material.get('emissivity', 0.9)
             }
@@ -233,6 +217,13 @@ class CTFCalculator:
             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 = []
@@ -244,7 +235,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 or invalid properties.")
+                logger.warning(f"Skipping layer with material '{material_name}' in construction '{construction_name}' due to missing properties.")
                 continue
             thicknesses.append(thickness)
             material_props.append(material)
@@ -263,7 +254,7 @@ class CTFCalculator:
     
         # Discretization parameters
         dt = 3600  # 1-hour time step (s)
-        nodes_per_layer = [3] * len(thicknesses)  # Initial number of nodes per layer
+        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
@@ -280,52 +271,31 @@ class CTFCalculator:
     
         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')}'")
     
-        # Check cache with thread-safe access
-        construction_hash = cls._hash_construction(construction, nodes_per_layer)
-        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]
+        # 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
+        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
     
-        # Calculate node spacing
-        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, t) in enumerate(zip(alpha, dx, thicknesses)):
+        for i, (a, d) in enumerate(zip(alpha, dx)):
             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.")
-                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)
-        with cls._cache_lock:
-            if construction_hash in cls._ctf_cache:
-                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
+            if Fo < 0.33:
+                logger.warning(f"Fourier number {Fo:.3f} < 0.33 for layer {i} ({material_props[i]['name']}). Adjusting node spacing.")
+                dx[i] = np.sqrt(a * dt / 0.33)
+                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}")
     
         # Build system matrices
-        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]
@@ -335,7 +305,6 @@ 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.")
@@ -343,11 +312,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) if idx + 1 < total_nodes else 0.0
+                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) * T_sol_air  # Use sol-air temperature
-            elif node_j == npl_i - 1 and layer_idx == len(thicknesses) - 1:  # Indoor surface node
+            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) if idx - 1 >= 0 else 0.0
+                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
@@ -356,7 +325,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 == npl_i - 1 and layer_idx < len(thicknesses) - 1:  # Interface between layers
+            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]
                 rho_next = rho[layer_idx + 1]
@@ -365,8 +334,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)) 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
+                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))
             elif node_j == 0 and layer_idx > 0:  # Interface from previous layer
                 k_prev = k[layer_idx - 1]
                 dx_prev = dx[layer_idx - 1]
@@ -376,100 +345,15 @@ 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)) 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
+                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))
             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) 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[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
     
-        # Check matrix conditioning
-        try:
-            from scipy.sparse.linalg import norm
-            A_csc = A.tocsc()
-            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(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, 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)
-                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]
-                    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.")
-                        continue
-                    
-                    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) 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 == 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) 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:
-                            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 == 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]
-                        c_next = c[layer_idx + 1]
-                        if k_next == 0 or dx_next == 0 or rho_next == 0 or c_next == 0:
-                            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)) 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]
-                        rho_prev = rho[layer_idx - 1]
-                        c_prev = c[layer_idx - 1]
-                        if k_prev == 0 or dx_prev == 0 or rho_prev == 0 or c_prev == 0:
-                            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)) 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) 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)
-                with cls._cache_lock:
-                    if construction_hash in cls._ctf_cache:
-                        logger.info(f"Using cached CTF coefficients for construction '{construction_name}' after matrix conditioning adjustment")
-                        return cls._ctf_cache[construction_hash]
-        except Exception as e:
-            logger.warning(f"Failed to compute matrix condition number: {str(e)}. Proceeding with current discretization.")
-    
         # Calculate CTF coefficients (X, Y, Z, F)
         num_ctf = 12  # Standard number of coefficients
         X = [0.0] * num_ctf  # Exterior temp response