Update utils/ctf_calculations.py

utils/ctf_calculations.py

@@ -113,16 +113,17 @@ class CTFCalculator:
         return T_sol_air
 
     @staticmethod
-    def _hash_construction(construction: Dict[str, Any]) -> str:
-        """Generate a unique hash for a construction based on its properties.
+    def _hash_construction(construction: Dict[str, Any], nodes_per_layer: 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.
     
         Returns:
-            str: SHA-256 hash of the construction properties.
+            str: SHA-256 hash of the construction properties and nodes_per_layer.
         """
-        hash_input = f"{construction.get('name', '')}{construction.get('adiabatic', False)}"
+        hash_input = f"{construction.get('name', '')}{construction.get('adiabatic', False)}{nodes_per_layer}"
         layers = construction.get('layers', [])
         for layer in layers:
             material_name = layer.get('material', '')
@@ -217,13 +218,6 @@ 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 = []
@@ -254,7 +248,7 @@ class CTFCalculator:
     
         # Discretization parameters
         dt = 3600  # 1-hour time step (s)
-        nodes_per_layer = 3  # 2–4 nodes per layer for balance
+        nodes_per_layer = 3  # Initial number of nodes per layer
         R_in = 0.12   # Indoor surface resistance (m²·K/W, ASHRAE)
     
         # Get weather data for sol-air temperature
@@ -271,9 +265,15 @@ 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')}'")
     
-        # 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
+        # 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
+        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):
@@ -287,15 +287,23 @@ class CTFCalculator:
                 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.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)
+            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}")
     
+        # 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 system matrices
+        total_nodes = sum(nodes_per_layer for _ in thicknesses)
         A = sparse.lil_matrix((total_nodes, total_nodes))
         b = np.zeros(total_nodes)
         node_to_layer = [i for i, _, _ in node_positions]
@@ -354,6 +362,90 @@ class CTFCalculator:
     
         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(nodes_per_layer + 1, 6)
+                dx = [t / nodes_per_layer for t in thicknesses]
+                
+                # Recalculate node positions
+                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))
+                        node_idx += 1
+                
+                # Rebuild system matrices
+                total_nodes = sum(nodes_per_layer for _ in thicknesses)
+                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:
+                        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) * T_sol_air
+                    elif node_j == nodes_per_layer - 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)
+                        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 == nodes_per_layer - 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))
+                        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:
+                        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))
+                        A[idx, idx + 1] = -dt * k_i / (dx_i * 0.5 * (rho_prev * c_prev * dx_prev + rho_i * c_i * dx_i))
+                    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 = 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