Update app/hvac_loads.py

app/hvac_loads.py

@@ -8,666 +8,43 @@ modules to determine the building's thermal loads.
 Developed by: Dr Majed Abuseif, Deakin University
 © 2025
 """
-
-import numpy as np
-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
-
-# Configure logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-class TFMCalculations:
-    # Solar calculation constants (from 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],
-        "Double Clear": [0.14, -0.0, 0.0, -0.0, 0.78, -0.0],
-        "Double Low-E": [0.2, -0.0, 0.0, 0.7, 0.0, -0.0],
-        "Double Tinted": [0.15, -0.0, 0.0, -0.0, 0.65, -0.0],
-        "Double Low-E with Argon": [0.18, -0.0, 0.0, 0.68, 0.0, -0.0],
-        "Single Low-E Reflective": [0.22, -0.0, 0.0, 0.6, 0.0, -0.0],
-        "Double Reflective": [0.24, -0.0, 0.0, 0.58, 0.0, -0.0],
-        "Electrochromic": [0.25, -0.0, 0.5, -0.0, 0.0, -0.0]
-    }
-
-    GLAZING_TYPE_MAPPING = {
-        "Single Clear 3mm": "Single Clear",
-        "Single Clear 6mm": "Single Clear",
-        "Single Tinted 6mm": "Single Tinted",
-        "Double Clear 6mm/13mm Air": "Double Clear",
-        "Double Low-E 6mm/13mm Air": "Double Low-E",
-        "Double Tinted 6mm/13mm Air": "Double Tinted",
-        "Double Low-E 6mm/13mm Argon": "Double Low-E with Argon",
-        "Single Low-E Reflective 6mm": "Single Low-E Reflective",
-        "Double Reflective 6mm/13mm Air": "Double Reflective",
-        "Electrochromic 6mm/13mm Air": "Electrochromic"
-    }
-
-    @staticmethod
-    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
-        delta_t = outdoor_temp - indoor_temp
-        if mode == "cooling" and delta_t <= 0:
-            return 0, 0
-        if mode == "heating" and delta_t >= 0:
-            return 0, 0
-
-        # Get CTF coefficients using CTFCalculator
-        ctf = CTFCalculator.calculate_ctf_coefficients(component)
-        
-        # Initialize history terms (simplified: assume steady-state history for demonstration)
-        load = component.u_value * component.area * delta_t
-        for i in range(len(ctf.Y)):
-            load += component.area * ctf.Y[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
-            load -= component.area * ctf.Z[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
-        cooling_load = load / 1000 if mode == "cooling" else 0
-        heating_load = -load / 1000 if mode == "heating" else 0
-        return cooling_load, heating_load
-
-    @staticmethod
-    def day_of_year(month: int, day: int, year: int) -> int:
-        """Calculate day of the year (n) from month, day, and year, accounting for leap years."""
-        days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-        if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
-            days_in_month[1] = 29
-        return sum(days_in_month[:month-1]) + day
-
-    @staticmethod
-    def equation_of_time(n: int) -> float:
-        """Calculate Equation of Time (EOT) in minutes using Spencer's formula."""
-        B = (n - 1) * 360 / 365
-        B_rad = math.radians(B)
-        EOT = 229.2 * (0.000075 + 0.001868 * math.cos(B_rad) - 0.032077 * math.sin(B_rad) -
-                       0.014615 * math.cos(2 * B_rad) - 0.04089 * math.sin(2 * B_rad))
-        return EOT
-
-    @staticmethod
-    def calculate_dynamic_shgc(glazing_type: str, cos_theta: float) -> float:
-        """Calculate dynamic SHGC based on incidence angle."""
-        if glazing_type not in TFMCalculations.SHGC_COEFFICIENTS:
-            logger.warning(f"Unknown glazing type '{glazing_type}'. Using default SHGC coefficients for Single Clear.")
-            glazing_type = "Single Clear"
-        
-        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 f_cos_theta
-
-    @staticmethod
-    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 (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')
-        
-        # 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
-        
-        try:
-            # 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
-                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:
-                    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:
-                        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:
-                    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(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 = 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:
-                    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(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
-                h_o = 23.0
-                surface_azimuth = 0.0
-            elif component.component_type == ComponentType.SKYLIGHT:
-                surface_tilt = 0.0
-                h_o = 23.0
-                surface_azimuth = 0.0
-            elif component.component_type == ComponentType.FLOOR:
-                surface_tilt = 180.0
-                h_o = 17.0
-                surface_azimuth = 0.0
-            else:
-                surface_tilt = 90.0
-                h_o = 17.0
-                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"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, hourly_data: Dict, hour: int, building_orientation: float, mode: str = "none") -> float:
-        """Calculate solar load in kW (cooling only) using ASHRAE-compliant solar calculations."""
-        if mode != "cooling":
-            return 0
-        if component.component_type == ComponentType.FLOOR:
-            return 0
-
-        component_name = getattr(component, 'name', 'unnamed_component')
-
-        try:
-            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("time_zone", 0.0)
-            ground_reflectivity = climate_data.get("ground_reflectivity", 0.2)
-
-            if not -90 <= latitude <= 90:
-                logger.warning(f"Invalid latitude {latitude} for {component_name}. Using default 0.0.")
-                latitude = 0.0
-            if not -180 <= longitude <= 180:
-                logger.warning(f"Invalid longitude {longitude} for {component_name}. Using default 0.0.")
-                longitude = 0.0
-            if not -12 <= timezone <= 14:
-                logger.warning(f"Invalid timezone {timezone} for {component_name}. Using default 0.0.")
-                timezone = 0.0
-            if not 0 <= ground_reflectivity <= 1:
-                logger.warning(f"Invalid ground_reflectivity {ground_reflectivity} for {component_name}. Using default 0.2.")
-                ground_reflectivity = 0.2
-
-            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
-
-            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}")
-                return 0
-
-            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)
-            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}")
-                raise ValueError(f"Negative radiation values for {month}/{day}/{hour}")
-
-            logger.info(f"Processing solar for {month}/{day}/{hour} with GHI={ghi}, DNI={dni}, DHI={dhi}, "
-                       f"dry_bulb={outdoor_temp} for {component_name}")
-
-            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 
-
-            delta = 23.45 * math.sin(math.radians(360 / 365 * (284 + n)))
-            hra = 15 * (LST - 12)
-            phi = math.radians(latitude)
-            delta_rad = math.radians(delta)
-            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
-            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:
-                    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}")
-
-            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_fenestrations
-                )
-
-            alpha_rad = math.radians(alpha)
-            surface_tilt_rad = math.radians(surface_tilt)
-            azimuth_rad = math.radians(azimuth)
-            surface_azimuth_rad = math.radians(surface_azimuth)
-            
-            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))
-            cos_theta = max(min(cos_theta, 1.0), 0.0)
-
-            logger.info(f"Component {component_name} at {month}/{day}/{hour}: "
-                        f"surface_tilt={surface_tilt:.2f}, surface_azimuth={surface_azimuth:.2f}, "
-                        f"cos_theta={cos_theta:.4f}")
-
-            view_factor = (1 - math.cos(surface_tilt_rad)) / 2
-            ground_reflected = ground_reflectivity * ghi * view_factor
-            
-            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 = getattr(component, 'fenestration', None)
-                shgc = 0.7
-                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.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:
-            logger.error(f"Error calculating solar load for {component_name} at hour {hour}: {str(e)}")
-            return 0
-
-    @staticmethod
-    def calculate_internal_load(internal_loads: Dict, hour: int, operation_hours: int, area: float) -> float:
-        """Calculate total internal load in kW."""
-        total_load = 0
-        for group in internal_loads.get("people", []):
-            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["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", []):
-            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]:
-        """Calculate ventilation load for heating and cooling in kW based on mode."""
-        if mode == "none":
-            return 0, 0
-        total_ventilation_flow = 0
-        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
-        if mode == "cooling" and delta_t <= 0:
-            return 0, 0
-        if mode == "heating" and delta_t >= 0:
-            return 0, 0
-        load = total_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
-
-    @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]:
-        """Calculate infiltration load for heating and cooling in kW based on mode."""
-        if mode == "none":
-            return 0, 0
-        total_infiltration_flow = 0
-        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
-        if mode == "cooling" and delta_t <= 0:
-            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
-        return cooling_load, heating_load
-
-    @staticmethod
-    def get_adaptive_comfort_temp(outdoor_temp: float) -> float:
-        """Calculate adaptive comfort temperature per ASHRAE 55."""
-        if 10 <= outdoor_temp <= 33.5:
-            return 0.31 * outdoor_temp + 17.8
-        return 24.0
-
-    @staticmethod
-    def filter_hourly_data(hourly_data: List[Dict], sim_period: Dict, climate_data: Dict) -> List[Dict]:
-        """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["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 \
-                   (month < end_month or (month == end_month and day <= end_day)):
-                    filtered_data.append(data)
-        elif sim_period.get("type") in ["HDD", "CDD"]:
-            base_temp = sim_period.get("base_temp", 18.3 if sim_period["type"] == "HDD" else 23.9)
-            for data in hourly_data:
-                temp = data["dry_bulb"]
-                if (sim_period["type"] == "HDD" and temp < base_temp) or (sim_period["type"] == "CDD" and temp > base_temp):
-                    filtered_data.append(data)
-        return filtered_data
-
-    @staticmethod
-    def get_indoor_conditions(indoor_conditions: Dict, hour: int, outdoor_temp: float, building_info: Dict) -> Dict:
-        """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 - winter_temp) < 0.01 else "cooling" if outdoor_temp > summer_temp else "heating"
-            if mode == "cooling":
-                return {"temperature": summer_temp, "rh": summer_rh}
-            elif mode == "heating":
-                return {"temperature": winter_temp, "rh": winter_rh}
-            else:
-                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:
-                hour_idx = hour % 24
-                for entry in schedule:
-                    if entry["hour"] == hour_idx:
-                        return {"temperature": entry["temperature"], "rh": entry["rh"]}
-            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": (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 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)
-        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")
-
-        for comp_list in components.values():
-            for comp in comp_list:
-                comp.ctf = CTFCalculator.calculate_ctf_coefficients(comp)
-
-        for hour_data in filtered_data:
-            hour = hour_data["hour"]
-            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 = 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")
-                        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":
-                for comp_list in components.values():
-                    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, 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
-            total_heating = max(conduction_heating + ventilation_heating + infiltration_heating - internal, 0)
-            if mode == "cooling":
-                total_heating = 0
-            elif mode == "heating":
-                total_cooling = 0
-            temp_loads.append({
-                "hour": hour,
-                "month": hour_data["month"],
-                "day": hour_data["day"],
-                "conduction_cooling": conduction_cooling,
-                "conduction_heating": conduction_heating,
-                "solar": solar,
-                "internal": internal,
-                "ventilation_cooling": ventilation_cooling,
-                "ventilation_heating": ventilation_heating,
-                "infiltration_cooling": infiltration_cooling,
-                "infiltration_heating": infiltration_heating,
-                "total_cooling": total_cooling,
-                "total_heating": total_heating
-            })
-        
-        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():
-            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)
-            for load in day_loads:
-                if cooling_hours > heating_hours:
-                    load["total_heating"] = 0
-                elif heating_hours > cooling_hours:
-                    load["total_cooling"] = 0
-                else:
-                    load["total_cooling"] = 0
-                    load["total_heating"] = 0
-                final_loads.append(load)
-        return final_loads
 
-def display_hvac_loads_page():
-    """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 (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"):
-        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")
+def render_ui():
+    """Render the Streamlit UI for location information, simulation periods, and action buttons."""
+    st.header("HVAC Load Calculator")
+
+    # Location Information
+    with st.expander("Location Information", expanded=True):
+        col1, col2 = st.columns(2)
+        with col1:
+            st.text_input("City", key="city")
+            st.number_input("Latitude (°)", min_value=-90.0, max_value=90.0, value=0.0, step=0.1, key="latitude")
+            st.number_input("Longitude (°)", min_value=-180.0, max_value=180.0, value=0.0, step=0.1, key="longitude")
+        with col2:
+            st.number_input("Time Zone", min_value=-12.0, max_value=14.0, value=0.0, step=0.5, key="time_zone")
+            st.number_input("Ground Reflectivity", min_value=0.0, max_value=1.0, value=0.2, step=0.01, key="ground_reflectivity")
+
+    # Simulation Period
+    with st.expander("Simulation Period", expanded=True):
+        sim_type = st.selectbox("Simulation Type", ["Full Year", "From-to", "HDD", "CDD"], key="sim_type")
+        if sim_type == "From-to":
+            col1, col2 = st.columns(2)
+            with col1:
+                st.date_input("Start Date", key="start_date")
+            with col2:
+                st.date_input("End Date", key="end_date")
+        elif sim_type in ["HDD", "CDD"]:
+            st.number_input("Base Temperature (°C)", value=18.3 if sim_type == "HDD" else 23.9, key="base_temp")
+
+    # Action Buttons
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        st.button("Calculate", key="calculate_button")
+    with col2:
+        st.button("Save", key="save_button")
+    with col3:
+        st.button("Reset", key="reset_button")
 
 if __name__ == "__main__":
-    display_hvac_loads_page()
+    render_ui()