Update utils/ctf_calculations.py

utils/ctf_calculations.py

@@ -14,10 +14,9 @@ import scipy.sparse.linalg as sparse_linalg
 import hashlib
 import logging
 import threading
-from typing import List
-from data.material_library import Construction
+from typing import List, Dict, Any, NamedTuple
+import streamlit as st
 from enum import Enum
-from typing import Dict, List, Optional, NamedTuple
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -28,7 +27,6 @@ class ComponentType(Enum):
     ROOF = "Roof"
     FLOOR = "Floor"
     WINDOW = "Window"
-    DOOR = "Door"
     SKYLIGHT = "Skylight"
 
 class CTFCoefficients(NamedTuple):
@@ -45,66 +43,138 @@ class CTFCalculator:
     _cache_lock = threading.Lock()  # Thread-safe lock for cache access
 
     @staticmethod
-    def _hash_construction(construction: Construction) -> str:
+    def _hash_construction(construction: Dict[str, Any]) -> str:
         """Generate a unique hash for a construction based on its properties.
 
         Args:
-            construction: Construction object containing material layers.
+            construction: Dictionary containing construction properties (name, layers).
 
         Returns:
             str: SHA-256 hash of the construction properties.
         """
-        hash_input = f"{construction.name}"
-        for layer in construction.layers:
-            material = layer["material"]
-            hash_input += f"{material.name}{material.conductivity}{material.density}{material.specific_heat}{layer['thickness']}"
+        hash_input = f"{construction.get('name', '')}"
+        layers = construction.get('layers', [])
+        for layer in layers:
+            material_name = layer.get('material', '')
+            thickness = layer.get('thickness', 0.0)
+            hash_input += f"{material_name}{thickness}"
         return hashlib.sha256(hash_input.encode()).hexdigest()
 
     @classmethod
-    def calculate_ctf_coefficients(cls, component) -> CTFCoefficients:
+    def _get_material_properties(cls, material_name: str) -> Dict[str, float]:
+        """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.
+        """
+        try:
+            materials = st.session_state.project_data.get('materials', {})
+            material = materials.get('library', {}).get(material_name, materials.get('project', {}).get(material_name))
+            if not material:
+                logger.error(f"Material '{material_name}' not found in library or project materials.")
+                return {}
+            
+            # Extract required properties
+            thermal_props = material.get('thermal_properties', {})
+            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),
+                'absorptivity': material.get('absorptivity', 0.6),
+                'emissivity': material.get('emissivity', 0.9)
+            }
+        except Exception as e:
+            logger.error(f"Error retrieving material '{material_name}' properties: {str(e)}")
+            return {}
+
+    @classmethod
+    def calculate_ctf_coefficients(cls, component: Dict[str, Any]) -> CTFCoefficients:
         """Calculate CTF coefficients using implicit Finite Difference Method.
 
-        Note: Per ASHRAE, CTF calculations are skipped for WINDOW, DOOR, and SKYLIGHT components,
+        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: Building component with construction properties.
+            component: Dictionary containing component properties from st.session_state.project_data["components"].
 
         Returns:
             CTFCoefficients: Named tuple containing X, Y, Z, and F coefficients.
         """
-        # Skip CTF for WINDOW, DOOR, SKYLIGHT as per ASHRAE; return zero coefficients
-        if component.component_type in [ComponentType.WINDOW, ComponentType.DOOR, ComponentType.SKYLIGHT]:
-            logger.info(f"Skipping CTF calculation for {component.component_type.value} component '{component.name}'. Using zero coefficients until CTF tables are implemented.")
+        # Determine component type
+        comp_type_str = component.get('type', '').lower()  # Expected from component dictionary key (e.g., 'walls')
+        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 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])
 
-        # Check if construction exists and has layers
-        construction = component.construction
-        if not construction or not construction.layers:
-            logger.warning(f"No valid construction or layers for component '{component.name}' ({component.component_type.value}). Returning zero CTFs.")
+        # 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}")
+                logger.info(f"Using cached CTF coefficients for construction '{construction_name}'")
                 return cls._ctf_cache[construction_hash]
 
+        # Collect layer properties
+        thicknesses = []
+        material_props = []
+        for layer in construction.get('layers', []):
+            material_name = layer.get('material', '')
+            thickness = layer.get('thickness', 0.0)
+            if thickness <= 0.0:
+                logger.warning(f"Invalid thickness {thickness} for material '{material_name}' in construction '{construction_name}'. Skipping layer.")
+                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.")
+                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³
+        c = [m['specific_heat'] for m in material_props]  # J/kg·K
+        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)
+
         # Discretization parameters
         dt = 3600  # 1-hour time step (s)
         nodes_per_layer = 3  # 2–4 nodes per layer for balance
         R_out = 0.04  # Outdoor surface resistance (m²·K/W, ASHRAE)
         R_in = 0.12   # Indoor surface resistance (m²·K/W, ASHRAE)
 
-        # Collect layer properties
-        thicknesses = [layer["thickness"] for layer in construction.layers]
-        materials = [layer["material"] for layer in construction.layers]
-        k = [m.conductivity for m in materials]  # W/m·K
-        rho = [m.density for m in materials]    # kg/m³
-        c = [m.specific_heat for m in materials]  # J/kg·K
-        alpha = [k_i / (rho_i * c_i) for k_i, rho_i, c_i in zip(k, rho, c)]  # Thermal diffusivity (m²/s)
-
         # 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
@@ -117,9 +187,12 @@ class CTFCalculator:
 
         # Stability check: Fourier number
         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.33:
-                logger.warning(f"Fourier number {Fo:.3f} < 0.33 for layer {i} ({materials[i].name}). Adjusting node spacing.")
+                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
@@ -137,6 +210,10 @@ class CTFCalculator:
             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)
@@ -150,6 +227,9 @@ class CTFCalculator:
                 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))
@@ -158,6 +238,9 @@ class CTFCalculator:
                 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))
@@ -180,7 +263,7 @@ class CTFCalculator:
         for t in range(num_ctf):
             b_out = b.copy()
             if t == 0:
-                b_out[0] = dt / (rho[0] * c[0] * dx[0] * R_out)  # Unit outdoor temp impulse
+                b_out[0] = dt / (rho[0] * c[0] * dx[0] * R_out) if rho[0] * c[0] * dx[0] != 0 else 0.0  # Unit outdoor temp impulse
             T = sparse_linalg.spsolve(A, b_out + T_prev)
             q_in = (T[-1] - 0.0) / R_in  # Indoor heat flux (W/m²)
             Y[t] = q_in
@@ -193,7 +276,7 @@ class CTFCalculator:
         for t in range(num_ctf):
             b_in = b.copy()
             if t == 0:
-                b_in[-1] = dt / (rho[-1] * c[-1] * dx[-1] * R_in)  # Unit indoor temp impulse
+                b_in[-1] = dt / (rho[-1] * c[-1] * dx[-1] * R_in) if rho[-1] * c[-1] * dx[-1] != 0 else 0.0  # Unit indoor temp impulse
             T = sparse_linalg.spsolve(A, b_in + T_prev)
             q_in = (T[-1] - 0.0) / R_in
             Z[t] = q_in
@@ -204,7 +287,7 @@ class CTFCalculator:
         for t in range(num_ctf):
             b_flux = np.zeros(total_nodes)
             if t == 0:
-                b_flux[-1] = -1.0 / (rho[-1] * c[-1] * dx[-1])  # Unit flux impulse
+                b_flux[-1] = -1.0 / (rho[-1] * c[-1] * dx[-1]) if rho[-1] * c[-1] * dx[-1] != 0 else 0.0  # Unit flux impulse
             T = sparse_linalg.spsolve(A, b_flux + T_prev)
             q_in = (T[-1] - 0.0) / R_in
             F[t] = q_in
@@ -213,18 +296,18 @@ class CTFCalculator:
         ctf = CTFCoefficients(X=X, Y=Y, Z=Z, F=F)
         with cls._cache_lock:
             cls._ctf_cache[construction_hash] = ctf
-        logger.info(f"Calculated CTF coefficients for construction {construction.name}")
+        logger.info(f"Calculated CTF coefficients for construction '{construction_name}' in component '{component.get('name', 'Unknown')}'")
         return ctf
 
     @classmethod
-    def calculate_ctf_tables(cls, component) -> CTFCoefficients:
-        """Placeholder for future implementation of CTF table lookups for windows, doors, and skylights.
+    def calculate_ctf_tables(cls, component: Dict[str, Any]) -> CTFCoefficients:
+        """Placeholder for future implementation of CTF table lookups for windows and skylights.
 
         Args:
-            component: Building component with construction properties.
+            component: Dictionary containing component properties.
 
         Returns:
             CTFCoefficients: Placeholder zero coefficients until implementation.
         """
-        logger.info(f"CTF table calculation for {component.component_type.value} component '{component.name}' not yet implemented. Returning zero coefficients.")
+        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])