Update app/hvac_loads.py

app/hvac_loads.py

@@ -14,12 +14,13 @@ import pandas as pd
 from typing import Dict, List, Optional, NamedTuple, Any, Tuple
 from enum import Enum
 import streamlit as st
+from app.materials_library import MaterialLibrary, Material, GlazingMaterial
+from app.construction import Construction
 from datetime import datetime
 from collections import defaultdict
 import logging
 import math
 from utils.ctf_calculations import CTFCalculator, ComponentType, CTFCoefficients
-from app.material_library import Construction, GlazingMaterial, DoorMaterial, Material, MaterialLibrary
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -53,7 +54,7 @@ class TFMCalculations:
     }
 
     @staticmethod
-    def calculate_conduction_load(component: Any, outdoor_temp: float, indoor_temp: float, hour: int, mode: str = "none") -> Tuple[float, float]:
+    def calculate_conduction_load(component, 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
@@ -64,14 +65,13 @@ class TFMCalculations:
             return 0, 0
 
         # Get CTF coefficients using CTFCalculator
-        if not hasattr(component, 'ctf'):
-            component.ctf = CTFCalculator.calculate_ctf_coefficients(component)
-
-        # Initialize history terms (simplified: assume steady-state history)
+        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(component.ctf.Y)):
-            load += component.area * component.ctf.Y[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
-            load -= component.area * component.ctf.Z[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
+        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
@@ -103,141 +103,142 @@ class TFMCalculations:
         c = TFMCalculations.SHGC_COEFFICIENTS[glazing_type]
         f_cos_theta = (c[0] + c[1] * cos_theta + c[2] * cos_theta**2 +
                        c[3] * cos_theta**3 + c[4] * cos_theta**4 + c[5] * cos_theta**5)
-        return max(min(f_cos_theta, 1.0), 0.0)
+        return f_cos_theta
 
     @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]:
+    def get_surface_parameters(component: Any, building_info: Dict, material_library: MaterialLibrary, 
+                             project_materials: Dict, project_constructions: Dict, 
+                             project_fenestrations: Dict) -> Tuple[float, float, float, Optional[float], float]:
         """
-        Determine surface parameters for a component using new component structure.
+        Determine surface parameters (tilt, azimuth, h_o, emissivity, absorptivity) for a component.
+        Uses MaterialLibrary for materials/fenestrations and Construction for walls/roofs/floors.
         """
         component_name = getattr(component, 'name', 'unnamed_component')
         
-        # Use component's pre-calculated surface properties
-        surface_tilt = getattr(component, 'tilt', 90.0)
-        surface_azimuth = getattr(component, 'surface_azimuth', 0.0)
-        h_o = 17.0  # Default for walls/windows/doors
+        # Initialize default values
+        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
-        absorptivity = 0.6  # Default for opaque components
-
+        absorptivity = 0.6  # Default
+        
         try:
-            # Adjust defaults based on component type
+            # Set component-specific defaults based on type
             if component.component_type == ComponentType.ROOF:
+                surface_tilt = getattr(component, 'tilt', 0.0)
                 h_o = 23.0
+                surface_azimuth = getattr(component, 'rotation', 0.0)
+                logger.debug(f"Roof component {component_name}: using rotation={surface_azimuth}, tilt={surface_tilt}")
+                
             elif component.component_type == ComponentType.SKYLIGHT:
+                surface_tilt = getattr(component, 'tilt', 0.0)
                 h_o = 23.0
+                surface_azimuth = getattr(component, 'rotation', 0.0)
+                logger.debug(f"Skylight component {component_name}: using rotation={surface_azimuth}, tilt={surface_tilt}")
+                
             elif component.component_type == ComponentType.FLOOR:
                 surface_tilt = 180.0
+                h_o = 17.0
                 surface_azimuth = 0.0
+                logger.debug(f"Floor component {component_name}: using default azimuth={surface_azimuth}, tilt={surface_tilt}")
+                
+            else:  # WALL, WINDOW
+                surface_tilt = 90.0
                 h_o = 17.0
-
-            # Fetch material properties
-            if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
-                construction_name = getattr(component, 'construction', None)
-                if not construction_name:
-                    logger.warning(f"No construction defined for {component_name} ({component.component_type.value}). Using defaults.")
+                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
                 else:
-                    construction_obj = (project_constructions.get(construction_name) or
-                                      material_library.library_constructions.get(construction_name))
-                    if not construction_obj:
-                        logger.warning(f"Construction {construction_name} not found for {component_name}. Using defaults.")
-                    elif not construction_obj.layers:
-                        logger.warning(f"No layers in construction {construction_name} for {component_name}. Using defaults.")
+                    elevation_angles = {
+                        "A": building_info.get("orientation_angle", 0.0),
+                        "B": (building_info.get("orientation_angle", 0.0) + 90.0) % 360,
+                        "C": (building_info.get("orientation_angle", 0.0) + 180.0) % 360,
+                        "D": (building_info.get("orientation_angle", 0.0) + 270.0) % 360
+                    }
+                    if elevation not in elevation_angles:
+                        logger.warning(f"Invalid elevation '{elevation}' for component {component_name}. Using default azimuth=0.")
+                        surface_azimuth = 0.0
                     else:
-                        first_layer = construction_obj.layers[0]
-                        material = (project_materials.get(first_layer['material']) or
-                                   material_library.library_materials.get(first_layer['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}: "
-                                        f"absorptivity={absorptivity}, emissivity={emissivity}")
-
-            elif component.component_type == ComponentType.DOOR:
-                door_material_name = getattr(component, 'door_material', None)
-                if not door_material_name:
-                    logger.warning(f"No door material defined for {component_name}. Using defaults.")
+                        surface_azimuth = (elevation_angles[elevation] + getattr(component, 'rotation', 0.0)) % 360
+                        logger.debug(f"Component {component_name}: elevation={elevation}, total_azimuth={surface_azimuth}, tilt={surface_tilt}")
+
+            # Fetch material properties
+            if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.FLOOR]:
+                construction = getattr(component, 'construction', None)
+                if not construction:
+                    logger.warning(f"No construction defined for {component_name} ({component.component_type.value}). Using defaults: absorptivity=0.6, emissivity=0.9.")
                 else:
-                    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 {door_material_name} not found for {component_name}. Using defaults.")
+                    construction_obj = project_constructions.get(construction) or material_library.library_constructions.get(construction)
+                    if not construction_obj or not construction_obj.layers:
+                        logger.warning(f"Construction not found or empty for {component_name}. Using defaults.")
                     else:
-                        absorptivity = getattr(door_material_obj, 'absorptivity', 0.6)
-                        emissivity = getattr(door_material_obj, 'emissivity', 0.9)
-                        logger.debug(f"Using door material for {component_name}: "
-                                    f"absorptivity={absorptivity}, emissivity={emissivity}")
+                        absorptivity = getattr(construction_obj, 'absorptivity', 0.6)
+                        emissivity = getattr(construction_obj, 'emissivity', 0.9)
+                        logger.debug(f"Using construction for {component_name}: absorptivity={absorptivity}, emissivity={emissivity}")
 
             elif component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
-                fenestration_name = getattr(component, 'fenestration', None)
-                if not fenestration_name:
-                    logger.warning(f"No fenestration defined for {component_name}. Using default SHGC=0.7.")
+                fenestration = getattr(component, 'fenestration', None)
+                if not fenestration:
+                    logger.warning(f"No fenestration defined for {component_name} ({component.component_type.value}). Using default SHGC=0.7, h_o={h_o}.")
                     shgc = 0.7
                 else:
-                    glazing_material_obj = (project_glazing_materials.get(fenestration_name) or
-                                          material_library.library_glazing_materials.get(fenestration_name))
-                    if not glazing_material_obj:
-                        logger.warning(f"Fenestration {fenestration_name} not found for {component_name}. Using default SHGC=0.7.")
+                    fenestration_obj = project_fenestrations.get(fenestration) or material_library.library_fenestrations.get(fenestration)
+                    if not fenestration_obj:
+                        logger.warning(f"Fenestration not found for {component_name}. Using default SHGC=0.7.")
                         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}")
-                emissivity = None
+                        shgc = getattr(fenestration_obj, 'shgc', 0.7)
+                        h_o = getattr(fenestration_obj, 'h_o', h_o)
+                        logger.debug(f"Using fenestration for {component_name}: shgc={shgc}, h_o={h_o}")
+                emissivity = None  # Not used for fenestration
 
         except Exception as e:
             logger.error(f"Error retrieving surface parameters for {component_name}: {str(e)}")
             if component.component_type == ComponentType.ROOF:
                 surface_tilt = 0.0
-                surface_azimuth = 0.0
                 h_o = 23.0
+                surface_azimuth = 0.0
             elif component.component_type == ComponentType.SKYLIGHT:
                 surface_tilt = 0.0
-                surface_azimuth = 0.0
                 h_o = 23.0
+                surface_azimuth = 0.0
             elif component.component_type == ComponentType.FLOOR:
                 surface_tilt = 180.0
-                surface_azimuth = 0.0
                 h_o = 17.0
+                surface_azimuth = 0.0
             else:
                 surface_tilt = 90.0
-                surface_azimuth = 0.0
                 h_o = 17.0
-            absorptivity = 0.6
-            emissivity = 0.9 if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR] else None
+                surface_azimuth = 0.0
+            absorptivity = 0.6 if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.FLOOR] else 0.0
+            emissivity = 0.9 if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.FLOOR] else None
 
-        logger.info(f"Surface parameters for {component_name}: tilt={surface_tilt:.1f}, azimuth={surface_azimuth:.1f}, h_o={h_o:.1f}")
+        logger.info(f"Final surface parameters for {component_name}: 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_solar_load(component: Any, hourly_data: Dict, hour: int, building_orientation: float, mode: str = "none") -> float:
+    def calculate_solar_load(component, 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" or component.component_type == ComponentType.FLOOR:
+        if mode != "cooling":
+            return 0
+        if component.component_type == ComponentType.FLOOR:
             return 0
 
         component_name = getattr(component, 'name', 'unnamed_component')
 
         try:
-            # Initialize MaterialLibrary if not present
-            if "material_library" not in st.session_state:
-                st.session_state.material_library = MaterialLibrary()
-                logger.info(f"Initialized MaterialLibrary for {component_name}")
-
-            material_library = st.session_state.material_library
-            project_materials = st.session_state.project_data["materials"]["project"]
-            project_constructions = st.session_state.project_data["constructions"]["project"]
-            project_glazing_materials = st.session_state.project_data["fenestrations"]["project"]
-            project_door_materials = st.session_state.project_data.get("door_materials", {})
-
-            # Get location parameters from climate_data
-            climate_data = st.session_state.project_data["climate_data"]
+            material_library = st.session_state.project_data.get("material_library", MaterialLibrary())
+            project_materials = st.session_state.project_data.get("materials", {}).get("project", {})
+            project_constructions = st.session_state.project_data.get("constructions", {}).get("project", {})
+            project_fenestrations = st.session_state.project_data.get("fenestrations", {}).get("project", {})
+
+            climate_data = st.session_state.project_data.get("climate_data", {})
             latitude = climate_data.get("latitude", 0.0)
             longitude = climate_data.get("longitude", 0.0)
-            timezone = climate_data.get("timezone", 0.0)
+            timezone = climate_data.get("time_zone", 0.0)
             ground_reflectivity = climate_data.get("ground_reflectivity", 0.2)
 
-            # Validate inputs
             if not -90 <= latitude <= 90:
                 logger.warning(f"Invalid latitude {latitude} for {component_name}. Using default 0.0.")
                 latitude = 0.0
@@ -251,9 +252,8 @@ class TFMCalculations:
                 logger.warning(f"Invalid ground_reflectivity {ground_reflectivity} for {component_name}. 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"]
+            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}: {hourly_data}")
                 return 0
@@ -277,21 +277,15 @@ class TFMCalculations:
             logger.info(f"Processing solar for {month}/{day}/{hour} with GHI={ghi}, DNI={dni}, DHI={dhi}, "
                        f"dry_bulb={outdoor_temp} for {component_name}")
 
-            # Step 1: Local Solar Time (LST)
             year = 2025
             n = TFMCalculations.day_of_year(month, day, year)
             EOT = TFMCalculations.equation_of_time(n)
             lambda_std = 15 * timezone
             standard_time = hour - 1 + 0.5
-            LST = standard_time + (4 * (lambda_std - longitude) + EOT) / 60
+            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_rad = math.radians(hra)
@@ -311,15 +305,13 @@ class TFMCalculations:
             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}")
 
-            # Step 5: Get surface parameters
-            building_info = st.session_state.project_data["building_info"]
+            building_info = {"orientation_angle": building_orientation}
             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_fenestrations
                 )
 
-            # Step 6: Calculate angle of incidence (θ)
             alpha_rad = math.radians(alpha)
             surface_tilt_rad = math.radians(surface_tilt)
             azimuth_rad = math.radians(azimuth)
@@ -334,41 +326,44 @@ class TFMCalculations:
                         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)
             view_factor = (1 - math.cos(surface_tilt_rad)) / 2
             ground_reflected = ground_reflectivity * ghi * view_factor
-            I_t = dni * cos_theta + dhi + ground_reflected if cos_theta > 0 else dhi + ground_reflected
-
-            # Step 8: Calculate solar heat gain
+            
+            if cos_theta > 0:
+                I_t = dni * cos_theta + dhi + ground_reflected
+            else:
+                I_t = dhi + ground_reflected
+            
             solar_heat_gain = 0.0
-
+            
             if component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
-                fenestration_name = getattr(component, 'fenestration', None)
+                fenestration = getattr(component, 'fenestration', None)
                 shgc = 0.7
-                if fenestration_name:
-                    glazing_material_obj = (project_glazing_materials.get(fenestration_name) or
-                                          material_library.library_glazing_materials.get(fenestration_name))
-                    if glazing_material_obj:
-                        shgc = getattr(glazing_material_obj, 'shgc', 0.7)
-                        h_o = getattr(glazing_material_obj, 'h_o', h_o)
-
-                glazing_type = TFMCalculations.GLAZING_TYPE_MAPPING.get(fenestration_name, "Single Clear")
+                if fenestration:
+                    fenestration_obj = project_fenestrations.get(fenestration) or material_library.library_fenestrations.get(fenestration)
+                    if fenestration_obj:
+                        shgc = getattr(fenestration_obj, 'shgc', 0.7)
+                        h_o = getattr(fenestration_obj, 'h_o', h_o)
+                    else:
+                        logger.warning(f"Fenestration not found for {component_name}. Using default SHGC=0.7.")
+                
+                glazing_type = TFMCalculations.GLAZING_TYPE_MAPPING.get(fenestration, "Single Clear")
                 iac = getattr(component, 'shading_coefficient', 1.0)
                 shgc_dynamic = shgc * TFMCalculations.calculate_dynamic_shgc(glazing_type, cos_theta)
                 solar_heat_gain = component.area * 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"I_t={I_t:.2f}, iac={iac})")
-
-            elif component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
-                surface_resistance = 1 / h_o
+            
+            elif component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.FLOOR]:
+                surface_resistance = 1/h_o
                 solar_heat_gain = component.area * 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"I_t={I_t:.2f}, surface_resistance={surface_resistance:.4f})")
-
+            
             return solar_heat_gain
 
         except Exception as e:
@@ -380,51 +375,34 @@ class TFMCalculations:
         """Calculate total internal load in kW."""
         total_load = 0
         for group in internal_loads.get("people", []):
-            activity_data = group.get("activity_data", {})
-            sensible = (activity_data.get("sensible_min_w", 0) + activity_data.get("sensible_max_w", 0)) / 2
-            latent = (activity_data.get("latent_min_w", 0) + activity_data.get("latent_max_w", 0)) / 2
-            schedule = internal_loads["schedules"].get(group.get("schedule", ""), {})
-            diversity_factor = schedule.get("weekday", [1.0]*24)[hour % 24] if schedule else 1.0
-            total_load += group.get("num_people", 0) * (sensible + latent) * diversity_factor
-
+            activity_data = group["activity_data"]
+            sensible = (activity_data["sensible_min_w"] + activity_data["sensible_max_w"]) / 2
+            latent = (activity_data["latent_min_w"] + activity_data["latent_max_w"]) / 2
+            load_per_person = sensible + latent
+            total_load += group["num_people"] * load_per_person * group.get("diversity_factor", 1.0)
         for light in internal_loads.get("lighting", []):
-            lpd = light.get("lpd", 0)
-            schedule = internal_loads["schedules"].get(light.get("schedule", ""), {})
-            fraction = schedule.get("weekday", [1.0]*24)[hour % 24] if schedule else 1.0
-            lighting_load = lpd * light.get("area", area) * fraction
+            lpd = light["lpd"]
+            lighting_operating_hours = light.get("operating_hours", operation_hours)
+            fraction = min(lighting_operating_hours, operation_hours) / operation_hours if operation_hours > 0 else 0
+            lighting_load = lpd * light["area"] * fraction
             total_load += lighting_load
-
         for equip in internal_loads.get("equipment", []):
-            sensible_gain = equip.get("sensible_gain", 0)
-            latent_gain = equip.get("latent_gain", 0)
-            schedule = internal_loads["schedules"].get(equip.get("schedule", ""), {})
-            fraction = schedule.get("weekday", [1.0]*24)[hour % 24] if schedule else 1.0
-            equipment_load = (sensible_gain + latent_gain) * equip.get("area", area) * fraction
+            equipment_load = equip["equipment_load"] * equip["area"]
             total_load += equipment_load
-
         return total_load / 1000
 
     @staticmethod
-    def calculate_ventilation_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> Tuple[float, float]:
+    def calculate_ventilation_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> tuple[float, float]:
         """Calculate ventilation load for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
-        ventilation = internal_loads.get("ventilation", [])
-        if not ventilation:
-            return 0, 0
         total_ventilation_flow = 0
-        for vent in ventilation:
-            if vent.get("system_type") == "AirChanges/Hour":
-                design_flow_rate = vent.get("design_flow_rate", 0.3)  # ACH
-                building_height = building_info.get("building_height", 3.0)
-                volume = area * building_height
-                flow = design_flow_rate * volume / 3600  # m³/s
-            else:
-                flow = vent.get("design_flow_rate", 0.0) / 1000  # L/s to m³/s
-            schedule = internal_loads["schedules"].get(vent.get("schedule", ""), {})
-            fraction = schedule.get("weekday", [1.0]*24)[hour % 24] if schedule else 1.0
-            total_ventilation_flow += flow * fraction
-
+        num_people = sum(group["num_people"] for group in internal_loads.get("people", []))
+        for ventilation in internal_loads.get("ventilation", []):
+            space_rate = ventilation.get("design_flow_rate", 0.3)  # L/s/m²
+            total_ventilation_flow += space_rate * ventilation["area"] / 1000  # m³/s
+        if not internal_loads.get("ventilation"):
+            total_ventilation_flow = 0.3 * area / 1000 + 2.5 * num_people / 1000  # Default rates
         air_density = 1.2
         specific_heat = 1000
         delta_t = outdoor_temp - indoor_temp
@@ -438,33 +416,13 @@ class TFMCalculations:
         return cooling_load, heating_load
 
     @staticmethod
-    def calculate_infiltration_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> Tuple[float, float]:
+    def calculate_infiltration_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> tuple[float, float]:
         """Calculate infiltration load for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
-        infiltration = internal_loads.get("infiltration", [])
-        if not infiltration:
-            return 0, 0
         total_infiltration_flow = 0
-        for inf in infiltration:
-            if inf.get("system_type") == "AirChanges/Hour":
-                design_flow_rate = inf.get("design_flow_rate", 0.5)  # ACH
-                building_height = building_info.get("building_height", 3.0)
-                volume = area * building_height
-                flow = design_flow_rate * volume / 3600  # m³/s
-            elif inf.get("system_type") == "Crack Flow":
-                ela = inf.get("effective_air_leakage_area", 0.0001) / 10000  # cm² to m²
-                wind_speed = 4.0
-                flow = ela * area * wind_speed / 2
-            else:  # Empirical Equations
-                c = inf.get("flow_coefficient", 0.0001)
-                n = inf.get("pressure_exponent", 0.65)
-                delta_t_abs = abs(outdoor_temp - indoor_temp)
-                flow = c * (delta_t_abs ** n) * area / 3600
-            schedule = internal_loads["schedules"].get(inf.get("schedule", ""), {})
-            fraction = schedule.get("weekday", [1.0]*24)[hour % 24] if schedule else 1.0
-            total_infiltration_flow += flow * fraction
-
+        building_height = building_info.get("building_height", 3.0)
+        volume = area * building_height
         air_density = 1.2
         specific_heat = 1000
         delta_t = outdoor_temp - indoor_temp
@@ -472,6 +430,22 @@ class TFMCalculations:
             return 0, 0
         if mode == "heating" and delta_t >= 0:
             return 0, 0
+        for infiltration in internal_loads.get("infiltration", []):
+            method = infiltration.get("system_type", "AirChanges/Hour")
+            if method == "AirChanges/Hour":
+                ach = infiltration.get("design_flow_rate", 0.5)
+                total_infiltration_flow += ach * volume / 3600
+            elif method == "Crack Flow":
+                ela = infiltration.get("effective_air_leakage_area", 0.0001) / 10000  # cm² to m²
+                wind_speed = 4.0
+                total_infiltration_flow += ela * infiltration["area"] * wind_speed / 2
+            else:  # Flow Equation
+                c = infiltration.get("flow_coefficient", 0.0001)
+                n = infiltration.get("pressure_exponent", 0.65)
+                delta_t_abs = abs(delta_t)
+                total_infiltration_flow += c * (delta_t_abs ** n) * infiltration["area"] / 3600
+        if not internal_loads.get("infiltration"):
+            total_infiltration_flow = 0.5 * volume / 3600  # Default ACH
         load = total_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
@@ -486,15 +460,15 @@ class TFMCalculations:
 
     @staticmethod
     def filter_hourly_data(hourly_data: List[Dict], sim_period: Dict, climate_data: Dict) -> List[Dict]:
-        """Filter hourly data based on simulation period."""
+        """Filter hourly data based on simulation period, ignoring year."""
         if sim_period.get("type") == "Full Year":
             return hourly_data
         filtered_data = []
         if sim_period.get("type") == "From-to":
-            start_month = sim_period.get("start_date", {}).get("month", 1)
-            start_day = sim_period.get("start_date", {}).get("day", 1)
-            end_month = sim_period.get("end_date", {}).get("month", 12)
-            end_day = sim_period.get("end_date", {}).get("day", 31)
+            start_month = sim_period["start_date"].month
+            start_day = sim_period["start_date"].day
+            end_month = sim_period["end_date"].month
+            end_day = sim_period["end_date"].day
             for data in hourly_data:
                 month, day = data["month"], data["day"]
                 if (month > start_month or (month == start_month and day >= start_day)) and \
@@ -510,21 +484,20 @@ class TFMCalculations:
 
     @staticmethod
     def get_indoor_conditions(indoor_conditions: Dict, hour: int, outdoor_temp: float, building_info: Dict) -> Dict:
-        """Determine indoor conditions based on user settings."""
+        """Determine indoor conditions based on user settings and building_info."""
+        winter_temp = building_info.get("winter_indoor_design_temp", 20.0)
+        summer_temp = building_info.get("summer_indoor_design_temp", 24.0)
+        winter_rh = building_info.get("winter_indoor_design_rh", 50.0)
+        summer_rh = building_info.get("summer_indoor_design_rh", 50.0)
+        
         if indoor_conditions.get("type") == "Fixed":
-            mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
+            mode = "none" if abs(outdoor_temp - winter_temp) < 0.01 else "cooling" if outdoor_temp > summer_temp else "heating"
             if mode == "cooling":
-                return {
-                    "temperature": building_info.get("summer_indoor_design_temp", 24.0),
-                    "rh": building_info.get("summer_indoor_design_rh", 50.0)
-                }
+                return {"temperature": summer_temp, "rh": summer_rh}
             elif mode == "heating":
-                return {
-                    "temperature": building_info.get("winter_indoor_design_temp", 22.0),
-                    "rh": building_info.get("winter_indoor_design_rh", 50.0)
-                }
+                return {"temperature": winter_temp, "rh": winter_rh}
             else:
-                return {"temperature": 24.0, "rh": 50.0}
+                return {"temperature": (winter_temp + summer_temp) / 2, "rh": (winter_rh + summer_rh) / 2}
         elif indoor_conditions.get("type") == "Time-varying":
             schedule = indoor_conditions.get("schedule", [])
             if schedule:
@@ -532,24 +505,24 @@ class TFMCalculations:
                 for entry in schedule:
                     if entry["hour"] == hour_idx:
                         return {"temperature": entry["temperature"], "rh": entry["rh"]}
-            return {"temperature": 24.0, "rh": 50.0}
+            return {"temperature": (winter_temp + summer_temp) / 2, "rh": (winter_rh + summer_rh) / 2}
         else:  # Adaptive
-            return {"temperature": TFMCalculations.get_adaptive_comfort_temp(outdoor_temp), "rh": 50.0}
+            return {"temperature": TFMCalculations.get_adaptive_comfort_temp(outdoor_temp), "rh": (winter_rh + summer_rh) / 2}
 
     @staticmethod
     def calculate_tfm_loads(components: Dict, hourly_data: List[Dict], indoor_conditions: Dict, internal_loads: Dict, building_info: Dict, sim_period: Dict, hvac_settings: Dict) -> List[Dict]:
-        """Calculate TFM loads for heating and cooling."""
+        """Calculate TFM loads for heating and cooling with user-defined filters and temperature threshold."""
         filtered_data = TFMCalculations.filter_hourly_data(hourly_data, sim_period, building_info)
         temp_loads = []
         building_orientation = building_info.get("orientation_angle", 0.0)
-        operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
+        operation_hours = building_info.get("operation_hours", 8)
+        operating_periods = [{"start": 8, "end": 8 + operation_hours}]  # Convert float to dict
         area = building_info.get("floor_area", 100.0)
+        
+        if "material_library" not in st.session_state.project_data:
+            st.session_state.project_data["material_library"] = MaterialLibrary()
+            logger.info("Initialized MaterialLibrary in session_state for solar calculations")
 
-        if "material_library" not in st.session_state:
-            st.session_state.material_library = MaterialLibrary()
-            logger.info("Initialized MaterialLibrary in session_state")
-
-        # Pre-calculate CTF coefficients
         for comp_list in components.values():
             for comp in comp_list:
                 comp.ctf = CTFCalculator.calculate_ctf_coefficients(comp)
@@ -559,18 +532,24 @@ class TFMCalculations:
             outdoor_temp = hour_data["dry_bulb"]
             indoor_cond = TFMCalculations.get_indoor_conditions(indoor_conditions, hour, outdoor_temp, building_info)
             indoor_temp = indoor_cond["temperature"]
-
             conduction_cooling = conduction_heating = solar = internal = ventilation_cooling = ventilation_heating = infiltration_cooling = infiltration_heating = 0
-            is_operating = any(period["start"] <= hour % 24 <= period["end"] for period in operating_periods)
-            mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
-
+            is_operating = False
+            for period in operating_periods:
+                start_hour = period.get("start", 8)
+                end_hour = period.get("end", 18)
+                if start_hour <= hour % 24 <= end_hour:
+                    is_operating = True
+                    break
+            mode = "none" if abs(outdoor_temp - building_info.get("winter_indoor_design_temp", 20.0)) < 0.01 else \
+                   "cooling" if outdoor_temp > building_info.get("summer_indoor_design_temp", 24.0) else "heating"
             if is_operating and mode == "cooling":
                 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
                         solar += TFMCalculations.calculate_solar_load(comp, hour_data, hour, building_orientation, mode="cooling")
-                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
+                        logger.info(f"Component {comp.name} solar load: {solar:.3f} kW")
+                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, operation_hours, area)
                 ventilation_cooling, _ = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
                 infiltration_cooling, _ = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
             elif is_operating and mode == "heating":
@@ -578,12 +557,12 @@ class TFMCalculations:
                     for comp in comp_list:
                         _, heat_load = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="heating")
                         conduction_heating += heat_load
-                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
+                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, operation_hours, 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:
                 internal = 0
-
+            
             logger.info(f"Hour {hour} total loads - conduction: {conduction_cooling:.3f} kW, solar: {solar:.3f} kW, internal: {internal:.3f} kW")
             
             total_cooling = conduction_cooling + solar + internal + ventilation_cooling + infiltration_cooling
@@ -592,7 +571,6 @@ class TFMCalculations:
                 total_heating = 0
             elif mode == "heating":
                 total_cooling = 0
-
             temp_loads.append({
                 "hour": hour,
                 "month": hour_data["month"],
@@ -608,7 +586,7 @@ class TFMCalculations:
                 "total_cooling": total_cooling,
                 "total_heating": total_heating
             })
-
+        
         loads_by_day = defaultdict(list)
         for load in temp_loads:
             day_key = (load["month"], load["day"])
@@ -629,59 +607,67 @@ class TFMCalculations:
         return final_loads
 
 def display_hvac_loads_page():
-    """Display the HVAC Loads page and manage calculations."""
-    st.title("HVAC Loads")
-    st.markdown("Calculate cooling and heating loads based on ASHRAE methodology.")
-
+    """Display the HVAC Loads page and perform calculations."""
+    st.header("HVAC Loads")
+    
+    # Access project data
     project_data = st.session_state.project_data
     components = project_data.get("components", {})
     climate_data = project_data.get("climate_data", {})
+    hourly_data = climate_data.get("hourly_data", [])
     internal_loads = project_data.get("internal_loads", {})
     building_info = project_data.get("building_info", {})
+    
+    # Simulation period (assumed to be in climate_data)
     sim_period = climate_data.get("typical_extreme_periods", {"type": "Full Year"})
-    indoor_conditions = {"type": "Fixed"}  # Default, can be extended with UI
-    hvac_settings = project_data.get("hvac_loads", {}).get("settings", {"operating_hours": [{"start": 8, "end": 18}]})
-
-    if not climate_data.get("hourly_data"):
-        st.warning("Please upload climate data in the Climate Data page.")
-        return
-
-    if not any(components.values()):
-        st.warning("Please define building components in the Building Components page.")
-        return
-
+    
+    # Indoor conditions (modify as needed based on UI inputs)
+    indoor_conditions = {
+        "type": "Fixed",  # Could be "Time-varying" or "Adaptive" based on UI
+        "cooling_setpoint": {"temperature": building_info.get("summer_indoor_design_temp", 24.0), "rh": building_info.get("summer_indoor_design_rh", 50.0)},
+        "heating_setpoint": {"temperature": building_info.get("winter_indoor_design_temp", 20.0), "rh": building_info.get("winter_indoor_design_rh", 50.0)}
+    }
+    
+    # HVAC settings
+    hvac_settings = {
+        "operating_hours": [{"start": 8, "end": 8 + building_info.get("operation_hours", 8)}]
+    }
+    
     if st.button("Calculate HVAC Loads"):
-        loads = TFMCalculations.calculate_tfm_loads(
-            components, climate_data["hourly_data"], indoor_conditions,
-            internal_loads, building_info, sim_period, hvac_settings
-        )
-        
-        # Update session state
-        project_data["hvac_loads"]["cooling"]["hourly"] = [load for load in loads if load["total_cooling"] > 0]
-        project_data["hvac_loads"]["heating"]["hourly"] = [load for load in loads if load["total_heating"] > 0]
-        project_data["hvac_loads"]["cooling"]["peak"] = max((load["total_cooling"] for load in loads), default=0)
-        project_data["hvac_loads"]["heating"]["peak"] = max((load["total_heating"] for load in loads), default=0)
-
-        # Generate summary tables and charts
-        cooling_df = pd.DataFrame(project_data["hvac_loads"]["cooling"]["hourly"])
-        heating_df = pd.DataFrame(project_data["hvac_loads"]["heating"]["hourly"])
-        
-        if not cooling_df.empty:
-            st.subheader("Cooling Loads")
-            st.dataframe(cooling_df[["month", "day", "hour", "total_cooling", "conduction_cooling", "solar", "internal", "ventilation_cooling", "infiltration_cooling"]])
-            project_data["hvac_loads"]["cooling"]["summary_tables"] = {"hourly_summary": cooling_df.to_dict()}
-        
-        if not heating_df.empty:
-            st.subheader("Heating Loads")
-            st.dataframe(heating_df[["month", "day", "hour", "total_heating", "conduction_heating", "internal", "ventilation_heating", "infiltration_heating"]])
-            project_data["hvac_loads"]["heating"]["summary_tables"] = {"hourly_summary": heating_df.to_dict()}
-
-        # Trigger rerun if needed
-        if "hvac_loads_rerun_pending" not in st.session_state:
-            st.session_state.hvac_loads_rerun_pending = False
-        if st.session_state.hvac_loads_rerun_pending:
-            st.session_state.hvac_loads_rerun_pending = False
-            st.rerun()
+        try:
+            loads = TFMCalculations.calculate_tfm_loads(
+                components=components,
+                hourly_data=hourly_data,
+                indoor_conditions=indoor_conditions,
+                internal_loads=internal_loads,
+                building_info=building_info,
+                sim_period=sim_period,
+                hvac_settings=hvac_settings
+            )
+            
+            # Update project_data
+            project_data["hvac_loads"]["cooling"]["hourly"] = [load for load in loads if load["total_cooling"] > 0]
+            project_data["hvac_loads"]["heating"]["hourly"] = [load for load in loads if load["total_heating"] > 0]
+            project_data["hvac_loads"]["cooling"]["peak"] = max((load["total_cooling"] for load in loads), default=0)
+            project_data["hvac_loads"]["heating"]["peak"] = max((load["total_heating"] for load in loads), default=0)
+            
+            # Display results
+            st.subheader("Cooling Loads (kW)")
+            cooling_df = pd.DataFrame(project_data["hvac_loads"]["cooling"]["hourly"])
+            if not cooling_df.empty:
+                st.dataframe(cooling_df[["month", "day", "hour", "total_cooling", "conduction_cooling", "solar", "internal", "ventilation_cooling", "infiltration_cooling"]])
+            
+            st.subheader("Heating Loads (kW)")
+            heating_df = pd.DataFrame(project_data["hvac_loads"]["heating"]["hourly"])
+            if not heating_df.empty:
+                st.dataframe(heating_df[["month", "day", "hour", "total_heating", "conduction_heating", "internal", "ventilation_heating", "infiltration_heating"]])
+            
+            st.write(f"Peak Cooling Load: {project_data['hvac_loads']['cooling']['peak']:.2f} kW")
+            st.write(f"Peak Heating vanguard: {project_data['hvac_loads']['heating']['peak']:.2f} kW")
+            
+        except Exception as e:
+            st.error(f"Error calculating HVAC loads: {str(e)}")
+            logger.exception("HVAC load calculation error")
 
 if __name__ == "__main__":
     display_hvac_loads_page()