Update app/hvac_loads.py

app/hvac_loads.py

@@ -50,27 +50,55 @@ class TFMCalculations:
     }
 
     @staticmethod
-    def calculate_conduction_load(component, outdoor_temp: float, indoor_temp: float, hour: int, mode: str = "none") -> tuple[float, float]:
+    def get_component_type(component: Dict[str, Any]) -> ComponentType:
+        """Map component dictionary 'type' to ComponentType enum."""
+        comp_type_map = {
+            'walls': ComponentType.WALL,
+            'roofs': ComponentType.ROOF,
+            'floors': ComponentType.FLOOR,
+            'windows': ComponentType.WINDOW,
+            'skylights': ComponentType.SKYLIGHT
+        }
+        comp_type_str = component.get('type', '').lower()
+        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')}'. Defaulting to WALL.")
+            return ComponentType.WALL
+        return component_type
+
+    @staticmethod
+    def calculate_conduction_load(component: Dict[str, Any], outdoor_temp: float, indoor_temp: float, hour: int, mode: str = "none") -> tuple[float, float]:
         """Calculate conduction load for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
+        component_name = component.get('name', 'unnamed_component')
         delta_t = outdoor_temp - indoor_temp
         if mode == "cooling" and delta_t <= 0:
             return 0, 0
         if mode == "heating" and delta_t >= 0:
             return 0, 0
 
-        # Get CTF coefficients using CTFCalculator
-        ctf = CTFCalculator.calculate_ctf_coefficients(component)
-        
-        # Initialize history terms (simplified: assume steady-state history for demonstration)
-        load = component.u_value * component.area * delta_t
-        for i in range(len(ctf.Y)):
-            load += component.area * ctf.Y[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
-            load -= component.area * ctf.Z[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
-        cooling_load = load / 1000 if mode == "cooling" else 0
-        heating_load = -load / 1000 if mode == "heating" else 0
-        return cooling_load, heating_load
+        try:
+            # Get CTF coefficients, preferring stored value
+            ctf = component.get('ctf')
+            if not ctf:
+                logger.debug(f"No CTF coefficients found for {component_name}. Calculating CTF coefficients.")
+                ctf = CTFCalculator.calculate_ctf_coefficients(component)
+                component['ctf'] = ctf  # Store in dictionary
+            
+            # Initialize history terms (simplified: assume steady-state history for demonstration)
+            load = component.get('u_value', 0.0) * component.get('area', 0.0) * delta_t
+            for i in range(len(ctf.Y)):
+                load += component.get('area', 0.0) * ctf.Y[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
+                load -= component.get('area', 0.0) * ctf.Z[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
+            cooling_load = load / 1000 if mode == "cooling" else 0
+            heating_load = -load / 1000 if mode == "heating" else 0
+            logger.info(f"Conduction load for {component_name} at hour {hour}: cooling={cooling_load:.3f} kW, heating={heating_load:.3f} kW")
+            return cooling_load, heating_load
+
+        except Exception as e:
+            logger.error(f"Error calculating conduction load for {component_name} at hour {hour}: {str(e)}")
+            return 0, 0
 
     @staticmethod
     def day_of_year(month: int, day: int, year: int) -> int:
@@ -102,11 +130,12 @@ class TFMCalculations:
         return f_cos_theta
 
     @staticmethod
-    def get_surface_parameters(component: Any, building_info: Dict, material_library: MaterialLibrary, 
+    def get_surface_parameters(component: Dict[str, Any], building_info: Dict, material_library: MaterialLibrary, 
                              project_materials: Dict, project_constructions: Dict, 
                              project_glazing_materials: Dict) -> Tuple[float, float, float, Optional[float], float]:
         """Determine surface parameters (tilt, azimuth, h_o, emissivity, absorptivity) for a component."""
-        component_name = getattr(component, 'name', 'unnamed_component')
+        component_name = component.get('name', 'unnamed_component')
+        component_type = TFMCalculations.get_component_type(component)
         
         surface_tilt = 90.0
         surface_azimuth = 0.0
@@ -115,19 +144,19 @@ class TFMCalculations:
         absorptivity = 0.6
         
         try:
-            if component.component_type == ComponentType.ROOF:
-                surface_tilt = getattr(component, 'tilt', 0.0)
+            if component_type == ComponentType.ROOF:
+                surface_tilt = component.get('tilt', 0.0)
                 h_o = 23.0
-                surface_azimuth = getattr(component, 'orientation', 0.0)
+                surface_azimuth = component.get('orientation', 0.0)
                 logger.debug(f"Roof component {component_name}: using orientation={surface_azimuth}, tilt={surface_tilt}")
                 
-            elif component.component_type == ComponentType.SKYLIGHT:
-                surface_tilt = getattr(component, 'tilt', 0.0)
+            elif component_type == ComponentType.SKYLIGHT:
+                surface_tilt = component.get('tilt', 0.0)
                 h_o = 23.0
-                surface_azimuth = getattr(component, 'orientation', 0.0)
+                surface_azimuth = component.get('orientation', 0.0)
                 logger.debug(f"Skylight component {component_name}: using orientation={surface_azimuth}, tilt={surface_tilt}")
                 
-            elif component.component_type == ComponentType.FLOOR:
+            elif component_type == ComponentType.FLOOR:
                 surface_tilt = 180.0
                 h_o = 17.0
                 surface_azimuth = 0.0
@@ -136,9 +165,9 @@ class TFMCalculations:
             else:  # WALL, WINDOW
                 surface_tilt = 90.0
                 h_o = 17.0
-                elevation = getattr(component, 'elevation', None)
+                elevation = component.get('elevation', None)
                 if not elevation:
-                    logger.warning(f"Component {component_name} ({component.component_type.value}) is missing 'elevation' field. Using default azimuth=0.")
+                    logger.warning(f"Component {component_name} ({component_type.value}) is missing 'elevation' field. Using default azimuth=0.")
                     surface_azimuth = 0.0
                 else:
                     base_azimuth = building_info.get("orientation_angle", 0.0)
@@ -149,65 +178,62 @@ class TFMCalculations:
                         "D": (base_azimuth + 270.0) % 360
                     }
                     if elevation not in elevation_angles:
-                        logger.warning(f"Invalid elevation '{elevation}' for component {component_name}. Using default azimuth=0.")
+                        logger.warning(f"Invalid elevation '{elevation}' for {component_name}. Using default azimuth=0.")
                         surface_azimuth = 0.0
                     else:
-                        surface_azimuth = (elevation_angles[elevation] + getattr(component, 'rotation', 0.0)) % 360
-                        logger.debug(f"Component {component_name}: elevation={elevation}, base_azimuth={elevation_angles[elevation]}, rotation={getattr(component, 'rotation', 0.0)}, total_azimuth={surface_azimuth}")
+                        surface_azimuth = (elevation_angles[elevation] + component.get('rotation', 0.0)) % 360
+                        logger.debug(f"Component {component_name}: elevation={elevation}, base_azimuth={elevation_angles[elevation]}, rotation={component.get('rotation', 0.0)}, total_azimuth={surface_azimuth}")
 
-            if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
-                construction = getattr(component, 'construction', None)
-                if not construction:
+            if component_type in [ComponentType.WALL, ComponentType.ROOF]:
+                construction_name = component.get('construction', None)
+                if not construction_name:
                     logger.warning(f"No construction defined for {component_name}. Using defaults: absorptivity=0.6, emissivity=0.9.")
                 else:
-                    construction_obj = None
-                    if hasattr(construction, 'name'):
-                        construction_obj = (project_constructions.get(construction.name) or
-                                           material_library.library_constructions.get(construction.name))
-                    
+                    construction_obj = (project_constructions.get(construction_name) or
+                                       material_library.library_constructions.get(construction_name))
                     if not construction_obj:
-                        logger.warning(f"Construction not found for {component_name}. Using defaults: absorptivity=0.6, emissivity=0.9.")
-                    elif not construction_obj.layers:
+                        logger.warning(f"Construction '{construction_name}' not found for {component_name}. Using defaults: absorptivity=0.6, emissivity=0.9.")
+                    elif not construction_obj.get('layers', []):
                         logger.warning(f"No layers in construction for {component_name}. Using defaults: absorptivity=0.6, emissivity=0.9.")
                     else:
-                        first_layer = construction_obj.layers[0]
-                        material = first_layer.get("material")
-                        if material:
-                            absorptivity = getattr(material, 'absorptivity', 0.6)
-                            emissivity = getattr(material, 'emissivity', 0.9)
-                            logger.debug(f"Using first layer material for {component_name}: absorptivity={absorptivity}, emissivity={emissivity}")
-
-            elif component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
-                glazing_material = getattr(component, 'glazing_material', None)
-                if not glazing_material:
+                        first_layer = construction_obj['layers'][0]
+                        material_name = first_layer.get("material")
+                        if material_name:
+                            material_obj = (project_materials.get(material_name) or
+                                           material_library.library_materials.get(material_name))
+                            if material_obj:
+                                absorptivity = material_obj.get('absorptivity', 0.6)
+                                emissivity = material_obj.get('emissivity', 0.9)
+                                logger.debug(f"Using first layer material '{material_name}' for {component_name}: absorptivity={absorptivity}, emissivity={emissivity}")
+
+            elif component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                glazing_material_name = component.get('glazing_material', None)
+                if not glazing_material_name:
                     logger.warning(f"No glazing material defined for {component_name}. Using default SHGC=0.7, h_o={h_o}.")
                     shgc = 0.7
                 else:
-                    glazing_material_obj = None
-                    if hasattr(glazing_material, 'name'):
-                        glazing_material_obj = (project_glazing_materials.get(glazing_material.name) or
-                                               material_library.library_glazing_materials.get(glazing_material.name))
-                    
+                    glazing_material_obj = (project_glazing_materials.get(glazing_material_name) or
+                                           material_library.library_glazing_materials.get(glazing_material_name))
                     if not glazing_material_obj:
-                        logger.warning(f"Glazing material not found for {component_name}. Using default SHGC=0.7, h_o={h_o}.")
+                        logger.warning(f"Glazing material '{glazing_material_name}' not found for {component_name}. Using default SHGC=0.7, h_o={h_o}.")
                         shgc = 0.7
                     else:
-                        shgc = getattr(glazing_material_obj, 'shgc', 0.7)
-                        h_o = getattr(glazing_material_obj, 'h_o', h_o)
-                        logger.debug(f"Using glazing material for {component_name}: shgc={shgc}, h_o={h_o}")
+                        shgc = glazing_material_obj.get('shgc', 0.7)
+                        h_o = glazing_material_obj.get('h_o', h_o)
+                        logger.debug(f"Using glazing material '{glazing_material_name}' for {component_name}: shgc={shgc}, h_o={h_o}")
                 emissivity = None
 
         except Exception as e:
             logger.error(f"Error retrieving surface parameters for {component_name}: {str(e)}")
-            if component.component_type == ComponentType.ROOF:
+            if component_type == ComponentType.ROOF:
                 surface_tilt = 0.0
                 h_o = 23.0
                 surface_azimuth = 0.0
-            elif component.component_type == ComponentType.SKYLIGHT:
+            elif component_type == ComponentType.SKYLIGHT:
                 surface_tilt = 0.0
                 h_o = 23.0
                 surface_azimuth = 0.0
-            elif component.component_type == ComponentType.FLOOR:
+            elif component_type == ComponentType.FLOOR:
                 surface_tilt = 180.0
                 h_o = 17.0
                 surface_azimuth = 0.0
@@ -216,7 +242,7 @@ class TFMCalculations:
                 h_o = 17.0
                 surface_azimuth = 0.0
             
-            if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+            if component_type in [ComponentType.WALL, ComponentType.ROOF]:
                 absorptivity = 0.6
                 emissivity = 0.9
             else:  # WINDOW, SKYLIGHT
@@ -227,15 +253,16 @@ class TFMCalculations:
         return surface_tilt, surface_azimuth, h_o, emissivity, absorptivity
 
     @staticmethod
-    def calculate_solar_load(component, hourly_data: Dict, hour: int, building_orientation: float, mode: str = "none") -> float:
+    def calculate_solar_load(component: Dict[str, Any], hourly_data: Dict, hour: int, building_orientation: float, mode: str = "none") -> float:
         """Calculate solar load in kW (cooling only) using ASHRAE-compliant solar calculations."""
         if mode != "cooling":
             return 0
             
-        if component.component_type == ComponentType.FLOOR:
+        component_type = TFMCalculations.get_component_type(component)
+        if component_type == ComponentType.FLOOR:
             return 0
 
-        component_name = getattr(component, 'name', 'unnamed_component')
+        component_name = component.get('name', 'unnamed_component')
 
         try:
             material_library = st.session_state.get("material_library")
@@ -281,7 +308,7 @@ class TFMCalculations:
             day = hourly_data["day"]
             hour = hourly_data["hour"]
             ghi = hourly_data["global_horizontal_radiation"]
-            dni = hourly_data.get("direct_normal_radiation", echi * 0.7)
+            dni = hourly_data.get("direct_normal_radiation", ghi * 0.7)
             dhi = hourly_data.get("diffuse_horizontal_radiation", ghi * 0.3)
             outdoor_temp = hourly_data["dry_bulb"]
 
@@ -329,25 +356,25 @@ class TFMCalculations:
                     )
             except Exception as e:
                 logger.error(f"Error getting surface parameters for {component_name}: {str(e)}. Using defaults.")
-                if component.component_type == ComponentType.ROOF:
+                if component_type == ComponentType.ROOF:
                     surface_tilt = 0.0
                     surface_azimuth = 0.0
-                elif component.component_type == ComponentType.SKYLIGHT:
+                elif component_type == ComponentType.SKYLIGHT:
                     surface_tilt = 0.0
                     surface_azimuth = 0.0
-                elif component.component_type == ComponentType.FLOOR:
+                elif component_type == ComponentType.FLOOR:
                     surface_tilt = 180.0
                     surface_azimuth = 0.0
                 else:  # WALL, WINDOW
                     surface_tilt = 90.0
                     surface_azimuth = 0.0
                 
-                if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+                if component_type in [ComponentType.WALL, ComponentType.ROOF]:
                     absorptivity = 0.6
-                    h_o = 17.0 if component.component_type == ComponentType.WALL else 23.0
+                    h_o = 17.0 if component_type == ComponentType.WALL else 23.0
                 else:  # WINDOW, SKYLIGHT
                     absorptivity = 0.0
-                    h_o = 17.0 if component.component_type == ComponentType.WINDOW else 23.0
+                    h_o = 17.0 if component_type == ComponentType.WINDOW else 23.0
 
             alpha_rad = math.radians(alpha)
             surface_tilt_rad = math.radians(surface_tilt)
@@ -374,42 +401,39 @@ class TFMCalculations:
             
             solar_heat_gain = 0.0
             
-            if component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+            if component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
                 shgc = 0.7
-                glazing_material = getattr(component, 'glazing_material', None)
-                if glazing_material:
-                    glazing_material_obj = None
-                    if hasattr(glazing_material, 'name'):
-                        glazing_material_obj = (project_glazing_materials.get(glazing_material.name) or
-                                               material_library.library_glazing_materials.get(glazing_material.name))
-                    
+                glazing_material_name = component.get('glazing_material', None)
+                if glazing_material_name:
+                    glazing_material_obj = (project_glazing_materials.get(glazing_material_name) or
+                                           material_library.library_glazing_materials.get(glazing_material_name))
                     if glazing_material_obj:
-                        shgc = getattr(glazing_material_obj, 'shgc', 0.7)
-                        h_o = getattr(glazing_material_obj, 'h_o', h_o)
+                        shgc = glazing_material_obj.get('shgc', 0.7)
+                        h_o = glazing_material_obj.get('h_o', h_o)
                     else:
-                        logger.warning(f"Glazing material not found for {component_name}. Using default SHGC=0.7.")
+                        logger.warning(f"Glazing material '{glazing_material_name}' not found for {component_name}. Using default SHGC=0.7.")
                 
                 glazing_type = "Single Clear"
-                if hasattr(component, 'name') and component.name in TFMCalculations.GLAZING_TYPE_MAPPING:
-                    glazing_type = TFMCalculations.GLAZING_TYPE_MAPPING[component.name]
+                if component.get('name') in TFMCalculations.GLAZING_TYPE_MAPPING:
+                    glazing_type = TFMCalculations.GLAZING_TYPE_MAPPING[component.get('name')]
                 
-                iac = getattr(component, 'iac', 1.0)
+                iac = component.get('iac', 1.0)
                 
                 shgc_dynamic = shgc * TFMCalculations.calculate_dynamic_shgc(glazing_type, cos_theta)
                 
-                solar_heat_gain = component.area * shgc_dynamic * I_t * iac / 1000
+                solar_heat_gain = component.get('area', 0.0) * shgc_dynamic * I_t * iac / 1000
                 
                 logger.info(f"Fenestration solar heat gain for {component_name} at {month}/{day}/{hour}: "
-                            f"{solar_heat_gain:.4f} kW (area={component.area}, shgc_dynamic={shgc_dynamic:.4f}, "
+                            f"{solar_heat_gain:.4f} kW (area={component.get('area', 0.0)}, shgc_dynamic={shgc_dynamic:.4f}, "
                             f"I_t={I_t:.2f}, iac={iac})")
             
-            elif component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+            elif component_type in [ComponentType.WALL, ComponentType.ROOF]:
                 surface_resistance = 1/h_o
                 
-                solar_heat_gain = component.area * absorptivity * I_t * surface_resistance / 1000
+                solar_heat_gain = component.get('area', 0.0) * absorptivity * I_t * surface_resistance / 1000
                 
                 logger.info(f"Opaque surface solar heat gain for {component_name} at {month}/{day}/{hour}: "
-                            f"{solar_heat_gain:.4f} kW (area={component.area}, absorptivity={absorptivity:.2f}, "
+                            f"{solar_heat_gain:.4f} kW (area={component.get('area', 0.0)}, absorptivity={absorptivity:.2f}, "
                             f"I_t={I_t:.2f}, surface_resistance={surface_resistance:.4f})")
             
             return solar_heat_gain
@@ -681,7 +705,8 @@ class TFMCalculations:
         
         for comp_list in components.values():
             for comp in comp_list:
-                comp.ctf = CTFCalculator.calculate_ctf_coefficients(comp)
+                comp['ctf'] = CTFCalculator.calculate_ctf_coefficients(comp)
+                logger.debug(f"Stored CTF coefficients for component {comp.get('name', 'Unknown')}")
 
         for hour_data in filtered_data:
             hour = hour_data["hour"]
@@ -704,7 +729,7 @@ class TFMCalculations:
                         conduction_cooling += cool_load
                         component_solar_load = TFMCalculations.calculate_solar_load(comp, hour_data, hour, building_orientation, mode="cooling")
                         solar += component_solar_load
-                        logger.info(f"Component {comp.name} ({comp.component_type.value}) solar load: {component_solar_load:.3f} kW, accumulated solar: {solar:.3f} kW")
+                        logger.info(f"Component {comp.get('name', 'Unknown')} ({TFMCalculations.get_component_type(comp).value}) solar load: {component_solar_load:.3f} kW, accumulated solar: {solar:.3f} kW")
                 
                 internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
                 ventilation_cooling, _ = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")