Update utils/solar.py

utils/solar.py

@@ -106,148 +106,92 @@ class SolarCalculations:
 
     def get_surface_parameters(self, component: Any, building_info: Dict) -> Tuple[float, float, float, Optional[float], float]:
         """
-        Determine surface parameters (tilt, azimuth, h_o, emissivity, solar_absorption) for a component.
-        Uses MaterialLibrary to fetch properties from first layer for walls/roofs, DoorMaterial for doors,
-        and GlazingMaterial for windows/skylights. Handles orientation and tilt based on component type:
-        - Walls, Doors, Windows: Azimuth = facade base azimuth + component.rotation; Tilt = 90°.
-        - Roofs, Skylights: Azimuth = component.orientation; Tilt = component.tilt (default 180°).
+        Determine surface parameters (tilt, azimuth, h_o, emissivity, absorptivity) for a component.
+        Uses pre-calculated values stored in the component dictionary from components.py.
         
         Args:
-            component: Component object with component_type, facade, rotation, orientation, tilt,
-                      construction, glazing_material, or door_material.
-            building_info (Dict): Building information containing orientation_angle for facade mapping.
+            component: Component dictionary with surface_tilt, surface_azimuth, absorptivity/emissivity or shgc,
+                      component_type, and optionally fenestration.
+            building_info (Dict): Building information (not used since parameters are pre-calculated).
 
         Returns:
             Tuple[float, float, float, Optional[float], float]: Surface tilt (°), surface azimuth (°),
-            h_o (W/m²·K), emissivity, solar_absorption.
-
-        Raises:
-            ValueError: If facade is missing or invalid for walls, doors, or windows.
+            h_o (W/m²·K), emissivity, absorptivity.
         """
+        component_id = component.get('id', 'unknown_component')
+        component_type = component.get('component_type', ComponentType.WALL)
+
         # Default parameters
-        if component.component_type == ComponentType.ROOF:
-            surface_tilt = getattr(component, 'tilt', 180.0)  # Horizontal, downward if tilt absent
-            h_o = 23.0  # W/m²·K for roofs
-        elif component.component_type == ComponentType.SKYLIGHT:
-            surface_tilt = getattr(component, 'tilt', 180.0)  # Horizontal, downward if tilt absent
-            h_o = 23.0  # W/m²·K for skylights
-        elif component.component_type == ComponentType.FLOOR:
-            surface_tilt = 0.0  # Horizontal, upward
-            h_o = 17.0  # W/m²·K
+        if component_type == ComponentType.ROOF:
+            surface_tilt = component.get('surface_tilt', 0.0)
+            h_o = 23.0
+        elif component_type == ComponentType.SKYLIGHT:
+            surface_tilt = component.get('surface_tilt', 0.0)
+            h_o = 23.0
+        elif component_type == ComponentType.FLOOR:
+            surface_tilt = component.get('surface_tilt', 180.0)
+            h_o = 17.0
         else:  # WALL, DOOR, WINDOW
-            surface_tilt = 90.0  # Vertical
-            h_o = 17.0  # W/m²·K
+            surface_tilt = component.get('surface_tilt', 90.0)
+            h_o = 17.0
 
-        emissivity = 0.9  # Default for opaque components
-        solar_absorption = 0.6  # Default
-        shgc = None  # Only for windows/skylights
+        surface_azimuth = component.get('surface_azimuth', 0.0)
+        emissivity = component.get('emissivity', 0.9 if component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR] else None)
+        absorptivity = component.get('absorptivity', 0.6 if component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR] else 0.0)
 
         try:
-            # Determine surface azimuth
-            if component.component_type in [ComponentType.ROOF, ComponentType.SKYLIGHT]:
-                # Use component's orientation attribute directly, ignoring facade
-                surface_azimuth = getattr(component, 'orientation', 0.0)
-                logger.debug(f"Using component orientation for {component.id}: "
-                            f"azimuth={surface_azimuth}, tilt={surface_tilt}")
-            else:  # WALL, DOOR, WINDOW
-                # Check for facade attribute
-                facade = getattr(component, 'facade', None)
-                if not facade:
-                    component_id = getattr(component, 'id', 'unknown_component')
-                    raise ValueError(f"Component {component_id} is missing 'facade' field")
-
-                # Define facade azimuths based on building orientation_angle
-                base_azimuth = building_info.get("orientation_angle", 0.0)
-                facade_angles = {
-                    "A": base_azimuth,
-                    "B": (base_azimuth + 90.0) % 360,
-                    "C": (base_azimuth + 180.0) % 360,
-                    "D": (base_azimuth + 270.0) % 360
-                }
-
-                if facade not in facade_angles:
-                    component_id = getattr(component, 'id', 'unknown_component')
-                    raise ValueError(f"Invalid facade '{facade}' for component {component_id}. "
-                                    f"Expected one of {list(facade_angles.keys())}")
-
-                # Add component rotation to facade azimuth
-                surface_azimuth = (facade_angles[facade] + getattr(component, 'rotation', 0.0)) % 360
-                logger.debug(f"Component {component.id}: facade={facade}, "
-                            f"base_azimuth={facade_angles[facade]}, rotation={getattr(component, 'rotation', 0.0)}, "
-                            f"total_azimuth={surface_azimuth}, tilt={surface_tilt}")
-
-            # Fetch material properties
-            if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
-                construction = getattr(component, 'construction', None)
-                if not construction:
-                    logger.warning(f"No construction defined for {component.id}. "
-                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
-                else:
-                    # Get construction from library or project
-                    construction_obj = (self.project_constructions.get(construction.name) or
-                                        self.material_library.library_constructions.get(construction.name))
-                    if not construction_obj:
-                        logger.error(f"Construction '{construction.name}' not found for {component.id}.")
-                    elif not construction_obj.layers:
-                        logger.warning(f"No layers in construction '{construction.name}' for {component.id}.")
-                    else:
-                        # Use first (outermost) layer's properties
-                        first_layer = construction_obj.layers[0]
-                        material = first_layer["material"]
-                        solar_absorption = material.solar_absorption
-                        emissivity = material.emissivity
-                        logger.debug(f"Using first layer material '{material.name}' for {component.id}: "
-                                    f"solar_absorption={solar_absorption}, emissivity={emissivity}")
-
-            elif component.component_type == ComponentType.DOOR:
-                door_material = getattr(component, 'door_material', None)
-                if not door_material:
-                    logger.warning(f"No door material defined for {component.id}. "
-                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
-                else:
-                    # Get door material from library or project
-                    door_material_obj = (self.project_door_materials.get(door_material.name) or
-                                         self.material_library.library_door_materials.get(door_material.name))
-                    if not door_material_obj:
-                        logger.error(f"Door material '{door_material.name}' not found for {component.id}.")
-                    else:
-                        solar_absorption = door_material_obj.solar_absorption
-                        emissivity = door_material_obj.emissivity
-                        logger.debug(f"Using door material '{door_material_obj.name}' for {component.id}: "
-                                    f"solar_absorption={solar_absorption}, emissivity={emissivity}")
-
-            elif component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
-                glazing_material = getattr(component, 'glazing_material', None)
+            # For windows and skylights, use shgc instead of absorptivity and adjust h_o
+            if component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                glazing_material = component.get('fenestration', None)
                 if not glazing_material:
-                    logger.warning(f"No glazing material defined for {component.id}. "
-                                  f"Using default SHGC=0.7, h_o={h_o}.")
-                    shgc = 0.7
+                    logger.warning(f"No fenestration defined for {component_id}. Using default SHGC=0.7, h_o={h_o}.")
+                    absorptivity = component.get('shgc', 0.7)
                 else:
-                    # Get glazing material from library or project
-                    glazing_material_obj = (self.project_glazing_materials.get(glazing_material.name) or
-                                            self.material_library.library_glazing_materials.get(glazing_material.name))
+                    glazing_material_obj = (self.project_glazing_materials.get(glazing_material) or
+                                           self.material_library.library_glazing_materials.get(glazing_material))
                     if not glazing_material_obj:
-                        logger.error(f"Glazing material '{glazing_material.name}' not found for {component.id}.")
-                        shgc = 0.7
+                        logger.warning(f"Fenestration '{glazing_material}' not found for {component_id}. Using default SHGC=0.7, h_o={h_o}.")
+                        absorptivity = component.get('shgc', 0.7)
                     else:
-                        shgc = glazing_material_obj.shgc
-                        h_o = glazing_material_obj.h_o
-                        logger.debug(f"Using glazing material '{glazing_material_obj.name}' for {component.id}: "
-                                    f"shgc={shgc}, h_o={h_o}")
-                emissivity = None  # Not used for glazing
+                        absorptivity = glazing_material_obj.get('shgc', component.get('shgc', 0.7))
+                        h_o = glazing_material_obj.get('h_o', h_o)
+                        logger.debug(f"Using fenestration '{glazing_material}' for {component_id}: shgc={absorptivity}, h_o={h_o}")
+                emissivity = None
+
+            logger.debug(f"Surface parameters for {component_id}: tilt={surface_tilt:.2f}, azimuth={surface_azimuth:.2f}, "
+                        f"h_o={h_o:.2f}, emissivity={emissivity}, absorptivity={absorptivity}")
+
+            return surface_tilt, surface_azimuth, h_o, emissivity, absorptivity
 
         except Exception as e:
-            component_id = getattr(component, 'id', 'unknown_component')
             logger.error(f"Error retrieving surface parameters for {component_id}: {str(e)}")
             # Apply defaults
-            if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
-                solar_absorption = 0.6
+            if component_type == ComponentType.ROOF:
+                surface_tilt = 0.0
+                h_o = 23.0
+                surface_azimuth = 0.0
+            elif component_type == ComponentType.SKYLIGHT:
+                surface_tilt = 0.0
+                h_o = 23.0
+                surface_azimuth = 0.0
+            elif component_type == ComponentType.FLOOR:
+                surface_tilt = 180.0
+                h_o = 17.0
+                surface_azimuth = 0.0
+            else:  # WALL, DOOR, WINDOW
+                surface_tilt = 90.0
+                h_o = 17.0
+                surface_azimuth = 0.0
+
+            if component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
+                absorptivity = 0.6
                 emissivity = 0.9
             else:  # WINDOW, SKYLIGHT
-                shgc = 0.7
-                # h_o retains default from component type
+                absorptivity = 0.7
+                emissivity = None
 
-        return surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption
+            logger.info(f"Default surface parameters for {component_id}: tilt={surface_tilt:.1f}, azimuth={surface_azimuth:.1f}, h_o={h_o:.1f}")
+            return surface_tilt, surface_azimuth, h_o, emissivity, absorptivity
 
     @staticmethod
     def calculate_dynamic_shgc(glazing_type: str, cos_theta: float) -> float:
@@ -398,7 +342,7 @@ class SolarCalculations:
                 for comp in comp_list:
                     try:
                         # Get surface parameters
-                        surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption = \
+                        surface_tilt, surface_azimuth, h_o, emissivity, absorptivity = \
                             self.get_surface_parameters(comp, building_info)
                         
                         # For windows/skylights, get SHGC from material
@@ -432,14 +376,14 @@ class SolarCalculations:
                         comp_result = {
                             "component_id": getattr(comp, 'id', 'unknown_component'),
                             "total_incident_radiation": round(I_t, 2),
-                            "solar_absorption": round(solar_absorption, 2),
+                            "absorptivity": round(absorptivity, 2),
                             "emissivity": round(emissivity, 2) if emissivity is not None else None
                         }
 
                         # Calculate sol-air temperature for opaque surfaces
                         if comp.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
                             delta_R = 63.0 if comp.component_type == ComponentType.ROOF else 0.0
-                            sol_air_temp = outdoor_temp + (solar_absorption * I_t - (emissivity or 0.9) * 
+                            sol_air_temp = outdoor_temp + (absorptivity * I_t - (emissivity or 0.9) * 
                             delta_R) / h_o
                             comp_result["sol_air_temp"] = round(sol_air_temp, 2)
                             logger.info(f"Sol-air temp for {comp_result['component_id']} at {month}/{day}/{hour}: {sol_air_temp:.2f}°C")