Update app/hvac_loads.py

app/hvac_loads.py

@@ -10,7 +10,7 @@ import pandas as pd
 from typing import Dict, List, Optional, NamedTuple, Any, Tuple
 from enum import Enum
 import streamlit as st
-from app.material_library import Construction, GlazingMaterial, DoorMaterial, Material, MaterialLibrary
+from app.material_library import Construction, GlazingMaterial, Material, MaterialLibrary
 from app.internal_loads import PEOPLE_ACTIVITY_LEVELS, DIVERSITY_FACTORS, LIGHTING_FIXTURE_TYPES, EQUIPMENT_HEAT_GAINS, VENTILATION_RATES, INFILTRATION_SETTINGS
 from datetime import datetime
 from collections import defaultdict
@@ -23,7 +23,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 logger = logging.getLogger(__name__)
 
 class TFMCalculations:
-    # Solar calculation constants (from solar.py)
+    # Solar calculation constants (from utils/solar.py)
     SHGC_COEFFICIENTS = {
         "Single Clear": [0.1, -0.0, 0.0, -0.0, 0.0, 0.87],
         "Single Tinted": [0.12, -0.0, 0.0, -0.0, 0.8, -0.0],
@@ -140,51 +140,49 @@ class TFMCalculations:
     @staticmethod
     def get_surface_parameters(component: Any, building_info: Dict, material_library: MaterialLibrary, 
                              project_materials: Dict, project_constructions: Dict, 
-                             project_glazing_materials: Dict, project_door_materials: Dict) -> Tuple[float, float, float, Optional[float], float]:
+                             project_glazing_materials: 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 = elevation 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 MaterialLibrary to fetch properties from first layer for walls/roofs, and GlazingMaterial for windows/skylights.
+        Handles orientation and tilt based on component type:
+        - Walls, Windows: Azimuth = elevation base azimuth + component.rotation; Tilt = 90°.
+        - Roofs, Skylights: Azimuth = component.orientation; Tilt = component.tilt (default 0°).
+        - Floors: Tilt = 180°; Azimuth = 0°.
         
         Args:
             component: Component object with component_type, elevation, rotation, orientation, tilt,
-                      construction, glazing_material, or door_material.
+                      construction, or glazing_material.
             building_info (Dict): Building information containing orientation_angle for elevation mapping.
             material_library: MaterialLibrary instance for accessing library materials/constructions.
             project_materials: Dict of project-specific Material objects.
             project_constructions: Dict of project-specific Construction objects.
             project_glazing_materials: Dict of project-specific GlazingMaterial objects.
-            project_door_materials: Dict of project-specific DoorMaterial objects.
 
         Returns:
             Tuple[float, float, float, Optional[float], float]: Surface tilt (°), surface azimuth (°),
-            h_o (W/m²·K), emissivity, solar_absorption.
+            h_o (W/m²·K), emissivity, absorptivity.
         """
         # Default parameters
         component_name = getattr(component, 'name', 'unnamed_component')
         
         # Initialize default values
-        surface_tilt = 90.0  # Default vertical for walls, windows, doors
+        surface_tilt = 90.0  # Default vertical for walls, windows
         surface_azimuth = 0.0  # Default north-facing
         h_o = 17.0  # Default exterior convection coefficient
         emissivity = 0.9  # Default for opaque components
-        solar_absorption = 0.6  # Default
+        absorptivity = 0.6  # Default
         
         try:
             # Set component-specific defaults based on type
             if component.component_type == ComponentType.ROOF:
                 surface_tilt = getattr(component, 'tilt', 0.0)  # Horizontal, upward if tilt absent
                 h_o = 23.0  # W/m²·K for roofs
-                # For roofs, use orientation directly
                 surface_azimuth = getattr(component, '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)  # Horizontal, upward if tilt absent
                 h_o = 23.0  # W/m²·K for skylights
-                # For skylights, use orientation directly, not elevation
                 surface_azimuth = getattr(component, 'orientation', 0.0)
                 logger.debug(f"Skylight component {component_name}: using orientation={surface_azimuth}, tilt={surface_tilt}")
                 
@@ -194,17 +192,14 @@ class TFMCalculations:
                 surface_azimuth = 0.0  # Default azimuth for floors
                 logger.debug(f"Floor component {component_name}: using default azimuth={surface_azimuth}, tilt={surface_tilt}")
                 
-            else:  # WALL, DOOR, WINDOW
+            else:  # WALL, WINDOW
                 surface_tilt = 90.0  # Vertical
                 h_o = 17.0  # W/m²·K
-                
-                # Check for elevation attribute
                 elevation = getattr(component, 'elevation', None)
                 if not elevation:
                     logger.warning(f"Component {component_name} ({component.component_type.value}) is missing 'elevation' field. Using default azimuth=0.")
-                    surface_azimuth = 0.0  # Default to north-facing if elevation is missing
+                    surface_azimuth = 0.0
                 else:
-                    # Define elevation azimuths based on building orientation_angle
                     base_azimuth = building_info.get("orientation_angle", 0.0)
                     elevation_angles = {
                         "A": base_azimuth,
@@ -216,9 +211,8 @@ class TFMCalculations:
                     if elevation not in elevation_angles:
                         logger.warning(f"Invalid elevation '{elevation}' for component {component_name} ({component.component_type.value}). "
                                       f"Expected one of {list(elevation_angles.keys())}. Using default azimuth=0.")
-                        surface_azimuth = 0.0  # Default to north-facing if elevation is invalid
+                        surface_azimuth = 0.0
                     else:
-                        # Add component rotation to elevation azimuth
                         surface_azimuth = (elevation_angles[elevation] + getattr(component, 'rotation', 0.0)) % 360
                         logger.debug(f"Component {component_name} ({component.component_type.value}): elevation={elevation}, "
                                     f"base_azimuth={elevation_angles[elevation]}, rotation={getattr(component, 'rotation', 0.0)}, "
@@ -229,9 +223,8 @@ class TFMCalculations:
                 construction = getattr(component, 'construction', None)
                 if not construction:
                     logger.warning(f"No construction defined for {component_name} ({component.component_type.value}). "
-                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                                  f"Using defaults: absorptivity=0.6, emissivity=0.9.")
                 else:
-                    # Get construction from library or project
                     construction_obj = None
                     if hasattr(construction, 'name'):
                         construction_obj = (project_constructions.get(construction.name) or
@@ -239,40 +232,18 @@ class TFMCalculations:
                     
                     if not construction_obj:
                         logger.warning(f"Construction not found for {component_name} ({component.component_type.value}). "
-                                      f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                                      f"Using defaults: absorptivity=0.6, emissivity=0.9.")
                     elif not construction_obj.layers:
                         logger.warning(f"No layers in construction for {component_name} ({component.component_type.value}). "
-                                      f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                                      f"Using defaults: absorptivity=0.6, emissivity=0.9.")
                     else:
-                        # Use first (outermost) layer's properties
                         first_layer = construction_obj.layers[0]
                         material = first_layer.get("material")
                         if material:
-                            solar_absorption = getattr(material, 'solar_absorption', 0.6)
+                            absorptivity = getattr(material, 'absorptivity', 0.6)
                             emissivity = getattr(material, 'emissivity', 0.9)
                             logger.debug(f"Using first layer material for {component_name} ({component.component_type.value}): "
-                                        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_name} ({component.component_type.value}). "
-                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
-                else:
-                    # Get door material from library or project
-                    door_material_obj = None
-                    if hasattr(door_material, 'name'):
-                        door_material_obj = (project_door_materials.get(door_material.name) or
-                                            material_library.library_door_materials.get(door_material.name))
-                    
-                    if not door_material_obj:
-                        logger.warning(f"Door material not found for {component_name} ({component.component_type.value}). "
-                                      f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
-                    else:
-                        solar_absorption = getattr(door_material_obj, 'solar_absorption', 0.6)
-                        emissivity = getattr(door_material_obj, 'emissivity', 0.9)
-                        logger.debug(f"Using door material for {component_name} ({component.component_type.value}): "
-                                    f"solar_absorption={solar_absorption}, emissivity={emissivity}")
+                                        f"absorptivity={absorptivity}, emissivity={emissivity}")
 
             elif component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
                 glazing_material = getattr(component, 'glazing_material', None)
@@ -281,7 +252,6 @@ class TFMCalculations:
                                   f"Using default SHGC=0.7, h_o={h_o}.")
                     shgc = 0.7
                 else:
-                    # Get glazing material from library or project
                     glazing_material_obj = None
                     if hasattr(glazing_material, 'name'):
                         glazing_material_obj = (project_glazing_materials.get(glazing_material.name) or
@@ -296,41 +266,37 @@ class TFMCalculations:
                         h_o = getattr(glazing_material_obj, 'h_o', h_o)
                         logger.debug(f"Using glazing material for {component_name} ({component.component_type.value}): "
                                     f"shgc={shgc}, h_o={h_o}")
-                emissivity = None  # Not used for glazing
+                emissivity = None
 
         except Exception as e:
             logger.error(f"Error retrieving surface parameters for {component_name} ({component.component_type.value}): {str(e)}")
-            # Apply defaults based on component type
             if component.component_type == ComponentType.ROOF:
-                surface_tilt = 0.0  # Horizontal, upward
-                h_o = 23.0  # W/m²·K for roofs
-                surface_azimuth = 0.0  # Default north
+                surface_tilt = 0.0
+                h_o = 23.0
+                surface_azimuth = 0.0
             elif component.component_type == ComponentType.SKYLIGHT:
-                surface_tilt = 0.0  # Horizontal, upward
-                h_o = 23.0  # W/m²·K for skylights
-                surface_azimuth = 0.0  # Default north
+                surface_tilt = 0.0
+                h_o = 23.0
+                surface_azimuth = 0.0
             elif component.component_type == ComponentType.FLOOR:
-                surface_tilt = 180.0  # Horizontal, downward
-                h_o = 17.0  # W/m²·K
-                surface_azimuth = 0.0  # Default north
-            else:  # WALL, DOOR, WINDOW
-                surface_tilt = 90.0  # Vertical
-                h_o = 17.0  # W/m²·K
-                surface_azimuth = 0.0  # Default north
+                surface_tilt = 180.0
+                h_o = 17.0
+                surface_azimuth = 0.0
+            else:  # WALL, WINDOW
+                surface_tilt = 90.0
+                h_o = 17.0
+                surface_azimuth = 0.0
             
-            # Apply material defaults
-            if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
-                solar_absorption = 0.6
+            if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+                absorptivity = 0.6
                 emissivity = 0.9
             else:  # WINDOW, SKYLIGHT
                 shgc = 0.7
                 emissivity = None
 
-        # Debug output for all components
         logger.info(f"Final surface parameters for {component_name} ({component.component_type.value}): "
                    f"tilt={surface_tilt:.1f}, azimuth={surface_azimuth:.1f}, h_o={h_o:.1f}")
-
-        return surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption
+        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:
@@ -349,42 +315,31 @@ class TFMCalculations:
         References:
             ASHRAE Handbook—Fundamentals, Chapters 15 and 18.
         """
-        # Only calculate solar loads in cooling mode
         if mode != "cooling":
             return 0
             
-        # Skip floors for solar calculation
         if component.component_type == ComponentType.FLOOR:
             return 0
 
         component_name = getattr(component, 'name', 'unnamed_component')
 
         try:
-            # Ensure MaterialLibrary is properly initialized and accessible
             material_library = st.session_state.get("material_library")
             if not material_library:
-                logger.error(f"MaterialLibrary not found in session_state for {component_name} ({component.component_type.value})")
-                # Instead of raising an error, initialize a new MaterialLibrary
-                from data.material_library import MaterialLibrary
+                from app.material_library import MaterialLibrary
                 material_library = MaterialLibrary()
                 st.session_state.material_library = material_library
                 logger.info(f"Created new MaterialLibrary for {component_name} ({component.component_type.value})")
             
-            project_materials = st.session_state.get("project_materials", {})
-            project_constructions = st.session_state.get("project_constructions", {})
-            project_glazing_materials = st.session_state.get("project_glazing_materials", {})
-            project_door_materials = st.session_state.get("project_door_materials", {})
-
-            # Get location parameters from climate_data
-            climate_data = st.session_state.get("climate_data", {})
+            project_materials = st.session_state.get("project_data", {}).get("materials", {}).get("project", {})
+            project_constructions = st.session_state.get("project_data", {}).get("constructions", {}).get("project", {})
+            project_glazing_materials = st.session_state.get("project_data", {}).get("fenestrations", {}).get("project", {})
+            climate_data = st.session_state.get("project_data", {}).get("climate_data", {})
             latitude = climate_data.get("latitude", 0.0)
             longitude = climate_data.get("longitude", 0.0)
             timezone = climate_data.get("time_zone", 0.0)
+            ground_reflectivity = st.session_state.get("project_data", {}).get("climate_data", {}).get("ground_reflectivity", 0.2)
 
-            # Get ground reflectivity (default 0.2)
-            ground_reflectivity = st.session_state.get("ground_reflectivity", 0.2)
-
-            # Validate input parameters
             if not -90 <= latitude <= 90:
                 logger.warning(f"Invalid latitude {latitude} for {component_name} ({component.component_type.value}). Using default 0.0.")
                 latitude = 0.0
@@ -398,140 +353,115 @@ class TFMCalculations:
                 logger.warning(f"Invalid ground_reflectivity {ground_reflectivity} for {component_name} ({component.component_type.value}). Using default 0.2.")
                 ground_reflectivity = 0.2
 
-            # Ensure hourly_data has required fields
             required_fields = ["month", "day", "hour", "global_horizontal_radiation", "direct_normal_radiation", 
                              "diffuse_horizontal_radiation", "dry_bulb"]
             if not all(field in hourly_data for field in required_fields):
                 logger.warning(f"Missing required fields in hourly_data for hour {hour} for {component_name} ({component.component_type.value}): {hourly_data}")
                 return 0
 
-            # Skip if GHI <= 0
             if hourly_data["global_horizontal_radiation"] <= 0:
                 logger.info(f"No solar load for hour {hour} due to GHI={hourly_data['global_horizontal_radiation']} for {component_name} ({component.component_type.value})")
                 return 0
 
-            # Extract weather data
             month = hourly_data["month"]
             day = hourly_data["day"]
             hour = hourly_data["hour"]
             ghi = hourly_data["global_horizontal_radiation"]
-            dni = hourly_data.get("direct_normal_radiation", ghi * 0.7)  # Fallback: estimate DNI
-            dhi = hourly_data.get("diffuse_horizontal_radiation", ghi * 0.3)  # Fallback: estimate DHI
+            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"]
 
             if ghi < 0 or dni < 0 or dhi < 0:
                 logger.error(f"Negative radiation values for {month}/{day}/{hour} for {component_name} ({component.component_type.value})")
                 raise ValueError(f"Negative radiation values for {month}/{day}/{hour}")
 
-            # Add detailed logging for solar calculation
             logger.info(f"Processing solar for {month}/{day}/{hour} with GHI={ghi}, DNI={dni}, DHI={dhi}, "
                        f"dry_bulb={outdoor_temp} for {component_name} ({component.component_type.value})")
 
-            # Step 1: Local Solar Time (LST) with Equation of Time
-            year = 2025  # Fixed year since not provided
+            year = 2025
             n = TFMCalculations.day_of_year(month, day, year)
             EOT = TFMCalculations.equation_of_time(n)
-            lambda_std = 15 * timezone  # Standard meridian longitude (°)
-            standard_time = hour - 1 + 0.5  # Convert to decimal, assume mid-hour
+            lambda_std = 15 * timezone
+            standard_time = hour - 1 + 0.5
             LST = standard_time + (4 * (lambda_std - longitude) + EOT) / 60 
 
-            # Step 2: Solar Declination (δ)
             delta = 23.45 * math.sin(math.radians(360 / 365 * (284 + n)))
-
-            # Step 3: Hour Angle (HRA)
-            hra = 15 * (LST - 12)
-
-            # Step 4: Solar Altitude (α) and Azimuth (ψ)
             phi = math.radians(latitude)
             delta_rad = math.radians(delta)
+            hra = 15 * (LST - 12)
             hra_rad = math.radians(hra)
 
             sin_alpha = math.sin(phi) * math.sin(delta_rad) + math.cos(phi) * math.cos(delta_rad) * math.cos(hra_rad)
             alpha = math.degrees(math.asin(sin_alpha))
 
             if abs(math.cos(math.radians(alpha))) < 0.01:
-                azimuth = 0  # North at sunrise/sunset
+                azimuth = 0
             else:
                 sin_az = math.cos(delta_rad) * math.sin(hra_rad) / math.cos(math.radians(alpha))
                 cos_az = (sin_alpha * math.sin(phi) - math.sin(delta_rad)) / (math.cos(math.radians(alpha)) * math.cos(phi))
                 azimuth = math.degrees(math.atan2(sin_az, cos_az))
-                if hra > 0:  # Afternoon
+                if hra > 0:
                     azimuth = 360 - azimuth if azimuth > 0 else -azimuth
 
             logger.info(f"Solar angles for {month}/{day}/{hour}: declination={delta:.2f}, LST={LST:.2f}, "
                        f"HRA={hra:.2f}, altitude={alpha:.2f}, azimuth={azimuth:.2f} for {component_name} ({component.component_type.value})")
 
-            # Step 5: Get surface parameters with robust error handling
             building_info = {"orientation_angle": building_orientation}
             try:
-                surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption = \
+                surface_tilt, surface_azimuth, h_o, emissivity, absorptivity = \
                     TFMCalculations.get_surface_parameters(
                         component, building_info, material_library, project_materials,
-                        project_constructions, project_glazing_materials, project_door_materials
+                        project_constructions, project_glazing_materials
                     )
             except Exception as e:
                 logger.error(f"Error getting surface parameters for {component_name}: {str(e)}. Using defaults.")
-                # Apply defaults based on component type
                 if component.component_type == ComponentType.ROOF:
-                    surface_tilt = 0.0  # Horizontal, upward
-                    surface_azimuth = 0.0  # Default north
+                    surface_tilt = 0.0
+                    surface_azimuth = 0.0
                 elif component.component_type == ComponentType.SKYLIGHT:
-                    surface_tilt = 0.0  # Horizontal, upward
-                    surface_azimuth = 0.0  # Default north
+                    surface_tilt = 0.0
+                    surface_azimuth = 0.0
                 elif component.component_type == ComponentType.FLOOR:
-                    surface_tilt = 180.0  # Horizontal, downward
-                    surface_azimuth = 0.0  # Default north
-                else:  # WALL, DOOR, WINDOW
-                    surface_tilt = 90.0  # Vertical
-                    surface_azimuth = 0.0  # Default north
+                    surface_tilt = 180.0
+                    surface_azimuth = 0.0
+                else:  # WALL, WINDOW
+                    surface_tilt = 90.0
+                    surface_azimuth = 0.0
                 
-                # Apply material defaults
-                if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
-                    solar_absorption = 0.6
+                if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+                    absorptivity = 0.6
                     h_o = 17.0 if component.component_type == ComponentType.WALL else 23.0
                 else:  # WINDOW, SKYLIGHT
-                    solar_absorption = 0.0  # Not used for glazing
+                    absorptivity = 0.0
                     h_o = 17.0 if component.component_type == ComponentType.WINDOW else 23.0
 
-            # Step 6: Calculate angle of incidence (θ)
-            # Convert angles to radians for calculation
             alpha_rad = math.radians(alpha)
             surface_tilt_rad = math.radians(surface_tilt)
             azimuth_rad = math.radians(azimuth)
             surface_azimuth_rad = math.radians(surface_azimuth)
             
-            # Calculate cos(θ) using the solar position and surface orientation
             cos_theta = (math.sin(alpha_rad) * math.cos(surface_tilt_rad) +
                          math.cos(alpha_rad) * math.sin(surface_tilt_rad) *
                          math.cos(azimuth_rad - surface_azimuth_rad))
             
-            # Clamp to [0, 1] to avoid numerical issues
             cos_theta = max(min(cos_theta, 1.0), 0.0)
             
-            # Log the calculated values
             logger.info(f"  Component {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
                         f"surface_tilt={surface_tilt:.2f}, surface_azimuth={surface_azimuth:.2f}, "
                         f"cos_theta={cos_theta:.4f}")
 
-            # Step 7: Calculate total incident radiation (I_t)
-            # Calculate view factor for ground-reflected radiation
             view_factor = (1 - math.cos(surface_tilt_rad)) / 2
-            
-            # Calculate ground-reflected radiation
             ground_reflected = ground_reflectivity * ghi * view_factor
             
-            # Calculate total incident radiation
-            if cos_theta > 0:  # Surface receives direct beam radiation
+            if cos_theta > 0:
                 I_t = dni * cos_theta + dhi + ground_reflected
-            else:  # Surface in shade, only diffuse and reflected
+            else:
                 I_t = dhi + ground_reflected
             
-            # Step 8: Calculate solar heat gain based on component type
             solar_heat_gain = 0.0
             
             if component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
-                # For windows/skylights, get SHGC from material
-                shgc = 0.7  # Default
+                shgc = 0.7
                 glazing_material = getattr(component, 'glazing_material', None)
                 if glazing_material:
                     glazing_material_obj = None
@@ -544,36 +474,28 @@ class TFMCalculations:
                         h_o = getattr(glazing_material_obj, 'h_o', h_o)
                     else:
                         logger.warning(f"Glazing material not found for {component_name} ({component.component_type.value}). Using default SHGC=0.7.")
-                else:
-                    logger.warning(f"No glazing material defined for {component_name} ({component.component_type.value}). Using default SHGC=0.7.")
                 
-                # Get glazing type for dynamic SHGC calculation
-                glazing_type = "Single Clear"  # Default
+                glazing_type = "Single Clear"
                 if hasattr(component, 'name') and component.name in TFMCalculations.GLAZING_TYPE_MAPPING:
                     glazing_type = TFMCalculations.GLAZING_TYPE_MAPPING[component.name]
                 
-                # Get internal shading coefficient
-                iac = getattr(component, 'iac', 1.0)  # Default internal shading
+                iac = getattr(component, 'iac', 1.0)
                 
-                # Calculate dynamic SHGC based on incidence angle
                 shgc_dynamic = shgc * TFMCalculations.calculate_dynamic_shgc(glazing_type, cos_theta)
                 
-                # Calculate solar heat gain for fenestration
-                solar_heat_gain = component.area * shgc_dynamic * I_t * iac / 1000  # kW
+                solar_heat_gain = component.area * shgc_dynamic * I_t * iac / 1000
                 
                 logger.info(f"Fenestration solar heat gain for {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
                             f"{solar_heat_gain:.4f} kW (area={component.area}, shgc_dynamic={shgc_dynamic:.4f}, "
                             f"I_t={I_t:.2f}, iac={iac})")
             
-            elif component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
-                # For opaque surfaces, use solar absorptivity and surface resistance
-                surface_resistance = 1/h_o  # m²·K/W
+            elif component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+                surface_resistance = 1/h_o
                 
-                # Calculate absorbed solar radiation
-                solar_heat_gain = component.area * solar_absorption * I_t * surface_resistance / 1000  # kW
+                solar_heat_gain = component.area * absorptivity * I_t * surface_resistance / 1000
                 
                 logger.info(f"Opaque surface solar heat gain for {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
-                            f"{solar_heat_gain:.4f} kW (area={component.area}, solar_absorption={solar_absorption:.2f}, "
+                            f"{solar_heat_gain:.4f} kW (area={component.area}, absorptivity={absorptivity:.2f}, "
                             f"I_t={I_t:.2f}, surface_resistance={surface_resistance:.4f})")
             
             return solar_heat_gain
@@ -598,11 +520,10 @@ class TFMCalculations:
             fraction = min(lighting_operating_hours, operation_hours) / operation_hours if operation_hours > 0 else 0
             lighting_load = lpd * area * fraction
             total_load += lighting_load
-        equipment = internal_loads.get("equipment")
-        if equipment:
-            total_power_density = equipment.get("total_power_density", 0)
-            equipment_load = total_power_density * area
-            total_load += equipment_load
+        equipment = internal_loads.get("equipment", {})
+        total_power_density = equipment.get("total_power_density", 0)
+        equipment_load = total_power_density * area
+        total_load += equipment_load
         return total_load / 1000
 
     @staticmethod
@@ -610,21 +531,21 @@ class TFMCalculations:
         """Calculate ventilation load for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
-        ventilation = internal_loads.get("ventilation")
+        ventilation = internal_loads.get("ventilation", {})
         if not ventilation:
             return 0, 0
-        space_rate = ventilation.get("space_rate", 0.3)  # L/s/m²
-        people_rate = ventilation.get("people_rate", 2.5)  # L/s/person
+        space_rate = ventilation.get("space_rate", 0.3)
+        people_rate = ventilation.get("people_rate", 2.5)
         num_people = sum(group["num_people"] for group in internal_loads.get("people", []))
-        ventilation_flow = (space_rate * area + people_rate * num_people) / 1000  # m³/s
-        air_density = 1.2  # kg/m³
-        specific_heat = 1000  # J/kg·K
+        ventilation_flow = (space_rate * area + people_rate * num_people) / 1000
+        air_density = 1.2
+        specific_heat = 1000
         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
-        load = ventilation_flow * air_density * specific_heat * delta_t / 1000  # kW
+        load = ventilation_flow * air_density * specific_heat * delta_t / 1000
         cooling_load = load if mode == "cooling" else 0
         heating_load = -load if mode == "heating" else 0
         return cooling_load, heating_load
@@ -634,15 +555,15 @@ class TFMCalculations:
         """Calculate infiltration load for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
-        infiltration = internal_loads.get("infiltration")
+        infiltration = internal_loads.get("infiltration", {})
         if not infiltration:
             return 0, 0
         method = infiltration.get("method", "ACH")
         settings = infiltration.get("settings", {})
         building_height = building_info.get("building_height", 3.0)
-        volume = area * building_height  # m³
-        air_density = 1.2  # kg/m³
-        specific_heat = 1000  # J/kg·K
+        volume = area * building_height
+        air_density = 1.2
+        specific_heat = 1000
         delta_t = outdoor_temp - indoor_temp
         if mode == "cooling" and delta_t <= 0:
             return 0, 0
@@ -650,17 +571,17 @@ class TFMCalculations:
             return 0, 0
         if method == "ACH":
             ach = settings.get("rate", 0.5)
-            infiltration_flow = ach * volume / 3600  # m³/s
+            infiltration_flow = ach * volume / 3600
         elif method == "Crack Flow":
-            ela = settings.get("ela", 0.0001)  # m²/m²
-            wind_speed = 4.0  # m/s (assumed)
-            infiltration_flow = ela * area * wind_speed / 2  # m³/s
+            ela = settings.get("ela", 0.0001)
+            wind_speed = 4.0
+            infiltration_flow = ela * area * wind_speed / 2
         else:  # Empirical Equations
             c = settings.get("c", 0.1)
             n = settings.get("n", 0.65)
             delta_t_abs = abs(delta_t)
-            infiltration_flow = c * (delta_t_abs ** n) * area / 3600  # m³/s
-        load = infiltration_flow * air_density * specific_heat * delta_t / 1000  # kW
+            infiltration_flow = c * (delta_t_abs ** n) * area / 3600
+        load = infiltration_flow * air_density * specific_heat * delta_t / 1000
         cooling_load = load if mode == "cooling" else 0
         heating_load = -load if mode == "heating" else 0
         return cooling_load, heating_load
@@ -670,7 +591,7 @@ class TFMCalculations:
         """Calculate adaptive comfort temperature per ASHRAE 55."""
         if 10 <= outdoor_temp <= 33.5:
             return 0.31 * outdoor_temp + 17.8
-        return 24.0  # Default to standard setpoint if outside range
+        return 24.0
 
     @staticmethod
     def filter_hourly_data(hourly_data: List[Dict], sim_period: Dict, climate_data: Dict) -> List[Dict]:
@@ -708,7 +629,7 @@ class TFMCalculations:
                 }
             elif mode == "heating":
                 return {
-                    "temperature": indoor_conditions.get("heating_setpoint", {}).get("temperature", 22.0),
+                    "temperature": indoor_conditions.get("heating_setpoint", {}).get("temperature", 20.0),
                     "rh": indoor_conditions.get("heating_setpoint", {}).get("rh", 50.0)
                 }
             else:
@@ -733,13 +654,11 @@ class TFMCalculations:
         operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
         area = building_info.get("floor_area", 100.0)
         
-        # Ensure MaterialLibrary is properly initialized
         if "material_library" not in st.session_state:
-            from data.material_library import MaterialLibrary
+            from app.material_library import MaterialLibrary
             st.session_state.material_library = MaterialLibrary()
             logger.info("Initialized MaterialLibrary in session_state for solar calculations")
         
-        # Pre-calculate CTF coefficients for all components using CTFCalculator
         for comp_list in components.values():
             for comp in comp_list:
                 comp.ctf = CTFCalculator.calculate_ctf_coefficients(comp)
@@ -749,9 +668,7 @@ class TFMCalculations:
             outdoor_temp = hour_data["dry_bulb"]
             indoor_cond = TFMCalculations.get_indoor_conditions(indoor_conditions, hour, outdoor_temp)
             indoor_temp = indoor_cond["temperature"]
-            # Initialize all loads to 0
             conduction_cooling = conduction_heating = solar = internal = ventilation_cooling = ventilation_heating = infiltration_cooling = infiltration_heating = 0
-            # Check if hour is within operating periods
             is_operating = False
             for period in operating_periods:
                 start_hour = period.get("start", 8)
@@ -759,20 +676,14 @@ class TFMCalculations:
                 if start_hour <= hour % 24 <= end_hour:
                     is_operating = True
                     break
-            # Determine mode based on temperature threshold (18°C)
             mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
             if is_operating and mode == "cooling":
-                # Calculate solar load for each component and accumulate
                 for comp_list in components.values():
                     for comp in comp_list:
                         cool_load, _ = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="cooling")
                         conduction_cooling += cool_load
-                        
-                        # Calculate solar load for each component and accumulate
                         component_solar_load = TFMCalculations.calculate_solar_load(comp, hour_data, hour, building_orientation, mode="cooling")
                         solar += component_solar_load
-                        
-                        # Add detailed logging for solar load accumulation
                         logger.info(f"Component {comp.name} ({comp.component_type.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)
@@ -786,16 +697,13 @@ class TFMCalculations:
                 internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
                 _, ventilation_heating = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
                 _, infiltration_heating = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
-            else:  # mode == "none" or not is_operating
-                internal = 0  # No internal loads when no heating or cooling is needed or outside operating hours
+            else:
+                internal = 0
             
-            # Add detailed logging for total loads
             logger.info(f"Hour {hour} total loads - conduction: {conduction_cooling:.3f} kW, solar: {solar:.3f} kW, internal: {internal:.3f} kW")
             
-            # Calculate total loads, subtracting internal load for heating
             total_cooling = conduction_cooling + solar + internal + ventilation_cooling + infiltration_cooling
             total_heating = max(conduction_heating + ventilation_heating + infiltration_heating - internal, 0)
-            # Enforce mutual exclusivity within hour
             if mode == "cooling":
                 total_heating = 0
             elif mode == "heating":
@@ -815,24 +723,21 @@ class TFMCalculations:
                 "total_cooling": total_cooling,
                 "total_heating": total_heating
             })
-        # Group loads by day and apply daily control
         loads_by_day = defaultdict(list)
         for load in temp_loads:
             day_key = (load["month"], load["day"])
             loads_by_day[day_key].append(load)
         final_loads = []
         for day_key, day_loads in loads_by_day.items():
-            # Count hours with non-zero cooling and heating loads
             cooling_hours = sum(1 for load in day_loads if load["total_cooling"] > 0)
             heating_hours = sum(1 for load in day_loads if load["total_heating"] > 0)
-            # Apply daily control
             for load in day_loads:
                 if cooling_hours > heating_hours:
-                    load["total_heating"] = 0  # Keep cooling components, zero heating total
+                    load["total_heating"] = 0
                 elif heating_hours > cooling_hours:
-                    load["total_cooling"] = 0  # Keep heating components, zero cooling total
-                else:  # Equal hours
                     load["total_cooling"] = 0
-                    load["total_heating"] = 0  # Zero both totals, keep components
+                else:
+                    load["total_cooling"] = 0
+                    load["total_heating"] = 0
                 final_loads.append(load)
         return final_loads