Update app/hvac_loads.py

app/hvac_loads.py

@@ -8,43 +8,940 @@ modules to determine the building's thermal loads.
 Developed by: Dr Majed Abuseif, Deakin University
 © 2025
 """
+
 import streamlit as st
+import pandas as pd
+import numpy as np
+import json
+import logging
+import uuid
+import plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple, Union
+from datetime import datetime
+import math
+from collections import defaultdict
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-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")
+# Constants
+STEFAN_BOLTZMANN = 5.67e-8  # W/m²·K⁴
+ABSORPTIVITY_DEFAULT = 0.7  # Default surface absorptivity
+EMISSIVITY_DEFAULT = 0.9  # Default surface emissivity
+SKY_TEMP_FACTOR = 0.0552  # Factor for sky temperature calculation
+AIR_DENSITY = 1.2  # kg/m³
+AIR_SPECIFIC_HEAT = 1005  # J/kg·K
+LATENT_HEAT_VAPORIZATION = 2260000  # J/kg
 
+def display_hvac_loads_page():
+    """
+    Display the HVAC loads calculation page.
+    This is the main function called by main.py when the HVAC Loads page is selected.
+    """
+    st.title("HVAC Load Calculations")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_hvac_loads_help()
+    
+    # Check if necessary data is available
+    if not check_prerequisites():
+        st.warning("Please complete all previous steps (Building Info, Climate, Materials, Construction, Components, Internal Loads) before calculating HVAC loads.")
+        return
+    
+    # --- User Input for Simulation Parameters --- #
+    st.subheader("Simulation Parameters")
+    
     # 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":
+    with st.expander("Simulation Period"):
+        sim_period_type = st.selectbox(
+            "Simulation Period Type",
+            ["Full Year", "From-to", "HDD", "CDD"],
+            key="sim_period_type"
+        )
+        sim_period = {"type": sim_period_type}
+        
+        if sim_period_type == "From-to":
+            col1, col2 = st.columns(2)
+            with col1:
+                start_date = st.date_input("Start Date", value=datetime(2025, 1, 1))
+            with col2:
+                end_date = st.date_input("End Date", value=datetime(2025, 12, 31))
+            sim_period["start_date"] = start_date
+            sim_period["end_date"] = end_date
+        elif sim_period_type in ["HDD", "CDD"]:
+            base_temp = st.number_input(
+                f"Base Temperature (°C) for {sim_period_type}",
+                value=18.3 if sim_period_type == "HDD" else 23.9,
+                min_value=0.0,
+                max_value=40.0,
+                step=0.1
+            )
+            sim_period["base_temp"] = base_temp
+    
+    # Indoor Conditions
+    with st.expander("Indoor Conditions"):
+        indoor_cond_type = st.selectbox(
+            "Indoor Conditions Type",
+            ["Fixed", "Time-varying", "Adaptive"],
+            key="indoor_conditions_type"
+        )
+        indoor_conditions = {"type": indoor_cond_type}
+        
+        if indoor_cond_type == "Fixed":
             col1, col2 = st.columns(2)
             with col1:
-                st.date_input("Start Date", key="start_date")
+                cooling_temp = st.number_input(
+                    "Cooling Setpoint Temperature (°C)",
+                    value=24.0,
+                    min_value=15.0,
+                    max_value=30.0,
+                    step=0.5
+                )
+                cooling_rh = st.number_input(
+                    "Cooling Setpoint Relative Humidity (%)",
+                    value=50.0,
+                    min_value=30.0,
+                    max_value=70.0,
+                    step=5.0
+                )
             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")
+                heating_temp = st.number_input(
+                    "Heating Setpoint Temperature (°C)",
+                    value=22.0,
+                    min_value=15.0,
+                    max_value=30.0,
+                    step=0.5
+                )
+                heating_rh = st.number_input(
+                    "Heating Setpoint Relative Humidity (%)",
+                    value=50.0,
+                    min_value=30.0,
+                    max_value=70.0,
+                    step=5.0
+                )
+            indoor_conditions["cooling_setpoint"] = {"temperature": cooling_temp, "rh": cooling_rh}
+            indoor_conditions["heating_setpoint"] = {"temperature": heating_temp, "rh": heating_rh}
+        elif indoor_cond_type == "Time-varying":
+            st.write("Define Hourly Schedule")
+            schedule = []
+            for hour in range(24):
+                with st.container():
+                    col1, col2, col3 = st.columns([1, 2, 2])
+                    with col1:
+                        st.write(f"Hour {hour}:00")
+                    with col2:
+                        temp = st.number_input(
+                            "Temperature (°C)",
+                            value=24.0,
+                            min_value=15.0,
+                            max_value=30.0,
+                            step=0.5,
+                            key=f"schedule_temp_{hour}"
+                        )
+                    with col3:
+                        rh = st.number_input(
+                            "Relative Humidity (%)",
+                            value=50.0,
+                            min_value=30.0,
+                            max_value=70.0,
+                            step=5.0,
+                            key=f"schedule_rh_{hour}"
+                        )
+                    schedule.append({"hour": hour, "temperature": temp, "rh": rh})
+            indoor_conditions["schedule"] = schedule
+    
+    # Operating Hours
+    with st.expander("HVAC Operating Hours"):
+        num_periods = st.number_input(
+            "Number of Operating Periods",
+            value=1,
+            min_value=1,
+            max_value=5,
+            step=1
+        )
+        operating_periods = []
+        for i in range(int(num_periods)):
+            with st.container():
+                st.write(f"Operating Period {i+1}")
+                col1, col2 = st.columns(2)
+                with col1:
+                    start_hour = st.number_input(
+                        "Start Hour",
+                        value=8,
+                        min_value=0,
+                        max_value=23,
+                        step=1,
+                        key=f"start_hour_{i}"
+                    )
+                with col2:
+                    end_hour = st.number_input(
+                        "End Hour",
+                        value=18,
+                        min_value=0,
+                        max_value=23,
+                        step=1,
+                        key=f"end_hour_{i}"
+                    )
+                operating_periods.append({"start": start_hour, "end": end_hour})
+        hvac_settings = {"operating_hours": operating_periods}
+    
+    # Calculation trigger
+    if st.button("Calculate HVAC Loads", key="calculate_hvac_loads"):
+        try:
+            results = calculate_loads(
+                sim_period=sim_period,
+                indoor_conditions=indoor_conditions,
+                hvac_settings=hvac_settings
+            )
+            st.session_state.project_data["hvac_loads"] = results
+            st.success("HVAC loads calculated successfully.")
+            logger.info("HVAC loads calculated.")
+        except Exception as e:
+            st.error(f"Error calculating HVAC loads: {e}")
+            logger.error(f"Error calculating HVAC loads: {e}", exc_info=True)
+            st.session_state.project_data["hvac_loads"] = None
+    
+    # Display results if available
+    if "hvac_loads" in st.session_state.project_data and st.session_state.project_data["hvac_loads"]:
+        display_load_results(st.session_state.project_data["hvac_loads"])
+    else:
+        st.info("Click the button above to calculate HVAC loads.")
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Internal Loads", key="back_to_internal_loads"):
+            st.session_state.current_page = "Internal Loads"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Building Energy", key="continue_to_building_energy"):
+            st.session_state.current_page = "Building Energy"
+            st.rerun()
+
+def check_prerequisites() -> bool:
+    """Check if all prerequisite data is available in session state."""
+    required_keys = [
+        "building_info",
+        "climate_data",
+        "materials",
+        "constructions",
+        "components",
+        "internal_loads"
+    ]
+    
+    for key in required_keys:
+        if key not in st.session_state.project_data or not st.session_state.project_data[key]:
+            logger.warning(f"Prerequisite check failed: Missing data for '{key}'.")
+            return False
+            
+    # Specific checks within components
+    components = st.session_state.project_data["components"]
+    if not components.get("walls") and not components.get("roofs") and not components.get("floors"):
+        logger.warning("Prerequisite check failed: No opaque components defined.")
+        return False
+        
+    # Specific checks within climate data
+    climate = st.session_state.project_data["climate_data"]
+    if not climate.get("hourly_data") or not climate.get("design_conditions"):
+        logger.warning("Prerequisite check failed: Climate data not processed.")
+        return False
+        
+    return True
+
+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["type"] == "Full Year":
+        return hourly_data
+    filtered_data = []
+    if sim_period["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["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
+
+def get_indoor_conditions(indoor_conditions: Dict, hour: int, outdoor_temp: float) -> Dict:
+    """Determine indoor conditions based on user settings."""
+    if indoor_conditions["type"] == "Fixed":
+        mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
+        if mode == "cooling":
+            return {
+                "temperature": indoor_conditions.get("cooling_setpoint", {}).get("temperature", 24.0),
+                "rh": indoor_conditions.get("cooling_setpoint", {}).get("rh", 50.0)
+            }
+        elif mode == "heating":
+            return {
+                "temperature": indoor_conditions.get("heating_setpoint", {}).get("temperature", 22.0),
+                "rh": indoor_conditions.get("heating_setpoint", {}).get("rh", 50.0)
+            }
+        else:
+            return {"temperature": 24.0, "rh": 50.0}
+    elif indoor_conditions["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": 24.0, "rh": 50.0}
+    else:  # Adaptive
+        if 10 <= outdoor_temp <= 33.5:
+            return {"temperature": 0.31 * outdoor_temp + 17.8, "rh": 50.0}
+        return {"temperature": 24.0, "rh": 50.0}
 
-    # Action Buttons
+def calculate_loads(sim_period: Dict, indoor_conditions: Dict, hvac_settings: Dict) -> Dict[str, Any]:
+    """
+    Perform the main HVAC load calculations with user-defined filters and temperature threshold.
+    
+    Args:
+        sim_period: Simulation period settings.
+        indoor_conditions: Indoor conditions settings.
+        hvac_settings: HVAC operating hours settings.
+        
+    Returns:
+        Dictionary containing calculation results.
+    """
+    logger.info("Starting HVAC load calculations...")
+    
+    # Get data from session state
+    building_info = st.session_state.project_data["building_info"]
+    climate_data = st.session_state.project_data["climate_data"]
+    materials = get_available_materials()
+    constructions = get_available_constructions()
+    fenestrations = get_available_fenestrations()
+    components = st.session_state.project_data["components"]
+    internal_loads = st.session_state.project_data["internal_loads"]
+    
+    # Get design conditions
+    design_conditions = climate_data["design_conditions"]
+    hourly_data_list = climate_data["hourly_data"]
+    
+    # Filter hourly data based on simulation period
+    filtered_hourly_data = filter_hourly_data(hourly_data_list, sim_period, climate_data)
+    hourly_data_df = pd.DataFrame(filtered_hourly_data)
+    if hourly_data_df.empty:
+        logger.warning("No hourly data available after filtering.")
+        return {}
+    
+    # --- Solar Calculations --- #
+    logger.info("Calculating solar geometry...")
+    latitude = climate_data["location"]["latitude"]
+    longitude = climate_data["location"]["longitude"]
+    timezone = climate_data["location"]["timezone"]
+    building_orientation_angle = building_info["orientation_angle"]
+    
+    # Calculate solar angles for filtered hours
+    solar_angles = calculate_solar_angles(latitude, longitude, timezone, hourly_data_df.index)
+    hourly_data_df = pd.concat([hourly_data_df, solar_angles], axis=1)
+    
+    # Initialize load arrays
+    num_hours = len(filtered_hourly_data)
+    cooling_loads = {
+        "opaque_conduction": np.zeros(num_hours),
+        "fenestration_conduction": np.zeros(num_hours),
+        "fenestration_solar": np.zeros(num_hours),
+        "infiltration": np.zeros(num_hours),
+        "ventilation": np.zeros(num_hours),
+        "internal_sensible": np.zeros(num_hours),
+        "internal_latent": np.zeros(num_hours)
+    }
+    heating_loads = {
+        "opaque_conduction": np.zeros(num_hours),
+        "fenestration_conduction": np.zeros(num_hours),
+        "infiltration": np.zeros(num_hours),
+        "ventilation": np.zeros(num_hours)
+    }
+    
+    # --- Load Calculations --- #
+    operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
+    area = building_info["floor_area"]
+    
+    for idx, hour_data in enumerate(filtered_hourly_data):
+        hour = hour_data["hour"]
+        outdoor_temp = hour_data["dry_bulb"]
+        indoor_cond = get_indoor_conditions(indoor_conditions, hour, outdoor_temp)
+        indoor_temp = indoor_cond["temperature"]
+        
+        # Check if hour is within operating periods
+        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
+        
+        # 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 not is_operating:
+            continue
+        
+        # 1. Opaque Surfaces (Walls, Roofs, Floors)
+        for comp_type in ["walls", "roofs", "floors"]:
+            for comp in components.get(comp_type, []):
+                logger.debug(f"Calculating loads for {comp_type}: {comp['name']}")
+                construction = constructions[comp['construction']]
+                u_value = construction['u_value']
+                area = comp['area']
+                tilt = comp['tilt']
+                orientation = comp['orientation']
+                
+                # Calculate surface azimuth
+                surface_azimuth = calculate_surface_azimuth(orientation, building_orientation_angle)
+                
+                # Calculate sol-air temperature
+                sol_air_temp = calculate_sol_air_temperature(
+                    pd.Series([outdoor_temp], index=[idx]),
+                    pd.Series([hour_data.get("direct_normal_radiation", 0)], index=[idx]),
+                    pd.Series([hour_data.get("diffuse_horizontal_radiation", 0)], index=[idx]),
+                    pd.Series([hourly_data_df.loc[idx, "solar_altitude"]], index=[idx]),
+                    pd.Series([hourly_data_df.loc[idx, "solar_azimuth"]], index=[idx]),
+                    tilt,
+                    surface_azimuth,
+                    absorptivity=ABSORPTIVITY_DEFAULT,
+                    emissivity=EMISSIVITY_DEFAULT,
+                    h_o=20.0
+                )[0]
+                
+                # Calculate conduction heat gain/loss
+                if mode == "cooling":
+                    delta_t = sol_air_temp - indoor_temp
+                    if delta_t > 0:
+                        cooling_loads["opaque_conduction"][idx] += u_value * area * delta_t
+                elif mode == "heating":
+                    delta_t = indoor_temp - outdoor_temp
+                    if delta_t > 0:
+                        heating_loads["opaque_conduction"][idx] += u_value * area * delta_t
+        
+        # 2. Fenestration (Windows, Doors, Skylights)
+        for comp_type in ["windows", "doors", "skylights"]:
+            for comp in components.get(comp_type, []):
+                logger.debug(f"Calculating loads for {comp_type}: {comp['name']}")
+                fenestration = fenestrations[comp['fenestration']]
+                u_value = fenestration['u_value']
+                shgc = fenestration['shgc']
+                area = comp['area']
+                tilt = comp['tilt']
+                orientation = comp['orientation']
+                
+                # Calculate surface azimuth
+                surface_azimuth = calculate_surface_azimuth(orientation, building_orientation_angle)
+                
+                # Calculate incident solar radiation
+                incident_solar = calculate_incident_solar(
+                    pd.Series([hour_data.get("direct_normal_radiation", 0)], index=[idx]),
+                    pd.Series([hour_data.get("diffuse_horizontal_radiation", 0)], index=[idx]),
+                    pd.Series([hourly_data_df.loc[idx, "solar_altitude"]], index=[idx]),
+                    pd.Series([hourly_data_df.loc[idx, "solar_azimuth"]], index=[idx]),
+                    tilt,
+                    surface_azimuth
+                )[0]
+                
+                # Calculate conduction heat gain/loss
+                if mode == "cooling":
+                    delta_t = outdoor_temp - indoor_temp
+                    if delta_t > 0:
+                        cooling_loads["fenestration_conduction"][idx] += u_value * area * delta_t
+                elif mode == "heating":
+                    delta_t = indoor_temp - outdoor_temp
+                    if delta_t > 0:
+                        heating_loads["fenestration_conduction"][idx] += u_value * area * delta_t
+                
+                # Calculate solar heat gain
+                if mode == "cooling":
+                    solar_gain = shgc * area * incident_solar
+                    cooling_loads["fenestration_solar"][idx] += solar_gain
+        
+        # 3. Infiltration
+        if mode in ["cooling", "heating"]:
+            logger.info("Calculating infiltration loads...")
+            volume = building_info["floor_area"] * building_info["building_height"]
+            ach = 0.5
+            infiltration_rate_m3s = volume * ach / 3600.0
+            
+            delta_t = outdoor_temp - indoor_temp if mode == "cooling" else indoor_temp - outdoor_temp
+            if delta_t > 0:
+                infiltration_sensible = AIR_DENSITY * AIR_SPECIFIC_HEAT * infiltration_rate_m3s * delta_t
+                if mode == "cooling":
+                    cooling_loads["infiltration"][idx] += infiltration_sensible
+                else:
+                    heating_loads["infiltration"][idx] += infiltration_sensible
+        
+        # 4. Ventilation
+        if mode in ["cooling", "heating"]:
+            logger.info("Calculating ventilation loads...")
+            ventilation_rate_lps = building_info["ventilation_rate"]
+            ventilation_rate_m3s = ventilation_rate_lps * building_info["floor_area"] / 1000.0
+            
+            delta_t = outdoor_temp - indoor_temp if mode == "cooling" else indoor_temp - outdoor_temp
+            if delta_t > 0:
+                ventilation_sensible = AIR_DENSITY * AIR_SPECIFIC_HEAT * ventilation_rate_m3s * delta_t
+                if mode == "cooling":
+                    cooling_loads["ventilation"][idx] += ventilation_sensible
+                else:
+                    heating_loads["ventilation"][idx] += ventilation_sensible
+        
+        # 5. Internal Loads
+        if mode == "cooling":
+            logger.info("Calculating internal loads...")
+            internal_sensible, internal_latent = calculate_hourly_internal_loads(internal_loads)
+            cooling_loads["internal_sensible"][idx] = internal_sensible[idx % 8760]
+            cooling_loads["internal_latent"][idx] = internal_latent[idx % 8760]
+    
+    # --- Total Loads --- #
+    logger.info("Summing up loads...")
+    total_cooling_sensible = (
+        cooling_loads["opaque_conduction"] +
+        cooling_loads["fenestration_conduction"] +
+        cooling_loads["fenestration_solar"] +
+        cooling_loads["infiltration"] +
+        cooling_loads["ventilation"] +
+        cooling_loads["internal_sensible"]
+    )
+    total_cooling_latent = cooling_loads["internal_latent"]
+    total_cooling = total_cooling_sensible + total_cooling_latent
+    
+    total_heating_loss = (
+        heating_loads["opaque_conduction"] +
+        heating_loads["fenestration_conduction"] +
+        heating_loads["infiltration"] +
+        heating_loads["ventilation"]
+    )
+    total_heating_needed = np.maximum(0, total_heating_loss - cooling_loads["internal_sensible"])
+    
+    # --- Daily Control --- #
+    loads_by_day = defaultdict(list)
+    for idx, hour_data in enumerate(filtered_hourly_data):
+        day_key = (hour_data["month"], hour_data["day"])
+        loads_by_day[day_key].append({
+            "hour": hour_data["hour"],
+            "month": hour_data["month"],
+            "day": hour_data["day"],
+            "total_cooling": total_cooling[idx],
+            "total_heating": total_heating_needed[idx],
+            "cooling_components": {k: v[idx] for k, v in cooling_loads.items()},
+            "heating_components": {k: v[idx] for k, v in heating_loads.items()}
+        })
+    
+    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)
+    
+    # --- Peak Loads --- #
+    logger.info("Calculating peak loads...")
+    hourly_cooling_sensible = np.array([load["cooling_components"]["opaque_conduction"] +
+                                       load["cooling_components"]["fenestration_conduction"] +
+                                       load["cooling_components"]["fenestration_solar"] +
+                                       load["cooling_components"]["infiltration"] +
+                                       load["cooling_components"]["ventilation"] +
+                                       load["cooling_components"]["internal_sensible"]
+                                       for load in final_loads])
+    hourly_cooling_latent = np.array([load["cooling_components"]["internal_latent"] for load in final_loads])
+    hourly_cooling_total = hourly_cooling_sensible + hourly_cooling_latent
+    hourly_heating = np.array([load["total_heating"] for load in final_loads])
+    
+    peak_cooling_sensible = np.max(hourly_cooling_sensible) if len(hourly_cooling_sensible) > 0 else 0
+    peak_cooling_latent = np.max(hourly_cooling_latent) if len(hourly_cooling_latent) > 0 else 0
+    peak_cooling_total = np.max(hourly_cooling_total) if len(hourly_cooling_total) > 0 else 0
+    peak_heating = np.max(hourly_heating) if len(hourly_heating) > 0 else 0
+    
+    peak_cooling_sensible_hour = np.argmax(hourly_cooling_sensible) if len(hourly_cooling_sensible) > 0 else 0
+    peak_cooling_latent_hour = np.argmax(hourly_cooling_latent) if len(hourly_cooling_latent) > 0 else 0
+    peak_cooling_total_hour = np.argmax(hourly_cooling_total) if len(hourly_cooling_total) > 0 else 0
+    peak_heating_hour = np.argmax(hourly_heating) if len(hourly_heating) > 0 else 0
+    
+    results = {
+        "hourly_cooling_sensible": hourly_cooling_sensible.tolist(),
+        "hourly_cooling_latent": hourly_cooling_latent.tolist(),
+        "hourly_cooling_total": hourly_cooling_total.tolist(),
+        "hourly_heating": hourly_heating.tolist(),
+        "cooling_load_components": {k: [load["cooling_components"][k] for load in final_loads] for k in cooling_loads},
+        "heating_load_components": {k: [load["heating_components"][k] for load in final_loads] for k in heating_loads},
+        "peak_cooling_sensible": peak_cooling_sensible,
+        "peak_cooling_latent": peak_cooling_latent,
+        "peak_cooling_total": peak_cooling_total,
+        "peak_heating": peak_heating,
+        "peak_cooling_sensible_hour": int(peak_cooling_sensible_hour),
+        "peak_cooling_latent_hour": int(peak_cooling_latent_hour),
+        "peak_cooling_total_hour": int(peak_cooling_total_hour),
+        "peak_heating_hour": int(peak_heating_hour),
+        "filtered_hours": [{"month": load["month"], "day": load["day"], "hour": load["hour"]} for load in final_loads]
+    }
+    
+    logger.info("HVAC load calculations completed.")
+    return results
+
+def calculate_solar_angles(latitude: float, longitude: float, timezone: float, index: pd.Index) -> pd.DataFrame:
+    """
+    Calculate solar altitude and azimuth angles for given location and time.
+    Uses formulas from Duffie & Beckman, Solar Engineering of Thermal Processes.
+    
+    Args:
+        latitude: Latitude in degrees
+        longitude: Longitude in degrees (East positive)
+        timezone: Timezone offset from UTC in hours
+        index: Pandas Index for the hours
+        
+    Returns:
+        DataFrame with solar altitude and azimuth angles in degrees.
+    """
+    # Convert angles to radians
+    lat_rad = np.radians(latitude)
+    
+    # Day of year
+    day_of_year = pd.Series(index).apply(lambda x: pd.Timestamp(x).dayofyear)
+    
+    # Equation of time (simplified)
+    b = 2 * np.pi * (day_of_year - 81) / 364
+    eot = 9.87 * np.sin(2 * b) - 7.53 * np.cos(b) - 1.5 * np.sin(b)  # minutes
+    
+    # Local Standard Time Meridian (LSTM)
+    lstm = 15 * timezone
+    
+    # Time Correction Factor (TC)
+    tc = 4 * (longitude - lstm) + eot  # minutes
+    
+    # Local Solar Time (LST)
+    local_time_hour = pd.Series(index).apply(lambda x: pd.Timestamp(x).hour + pd.Timestamp(x).minute / 60.0)
+    lst = local_time_hour + tc / 60.0
+    
+    # Hour Angle (HRA)
+    hra = 15 * (lst - 12)  # degrees
+    hra_rad = np.radians(hra)
+    
+    # Declination Angle
+    declination_rad = np.radians(23.45 * np.sin(2 * np.pi * (284 + day_of_year) / 365))
+    
+    # Solar Altitude (alpha)
+    sin_alpha = np.sin(lat_rad) * np.sin(declination_rad) + \
+                np.cos(lat_rad) * np.cos(declination_rad) * np.cos(hra_rad)
+    solar_altitude_rad = np.arcsin(np.clip(sin_alpha, -1, 1))
+    solar_altitude_deg = np.degrees(solar_altitude_rad)
+    
+    # Solar Azimuth (gamma_s) - measured from South, positive West
+    cos_gamma_s = (np.sin(solar_altitude_rad) * np.sin(lat_rad) - np.sin(declination_rad)) / \
+                  (np.cos(solar_altitude_rad) * np.cos(lat_rad))
+    solar_azimuth_rad = np.arccos(np.clip(cos_gamma_s, -1, 1))
+    solar_azimuth_deg = np.degrees(solar_azimuth_rad)
+    # Adjust azimuth based on hour angle
+    solar_azimuth_deg = np.where(hra > 0, solar_azimuth_deg, 360 - solar_azimuth_deg)
+    # Convert to azimuth from North, positive East
+    solar_azimuth_deg = (solar_azimuth_deg + 180) % 360
+    
+    return pd.DataFrame({
+        "solar_altitude": solar_altitude_deg,
+        "solar_azimuth": solar_azimuth_deg
+    }, index=index)
+
+def calculate_surface_azimuth(orientation: str, building_orientation_angle: float) -> float:
+    """
+    Calculate the actual surface azimuth based on orientation label and building rotation.
+    Azimuth: 0=N, 90=E, 180=S, 270=W
+    
+    Args:
+        orientation: Orientation label (e.g., "A (North)", "B (South)")
+        building_orientation_angle: Building rotation angle from North (degrees, positive East)
+        
+    Returns:
+        Surface azimuth in degrees.
+    """
+    base_azimuth = {
+        "A (North)": 0.0,
+        "B (South)": 180.0,
+        "C (East)": 90.0,
+        "D (West)": 270.0,
+        "Horizontal": 0.0
+    }.get(orientation, 0.0)
+    
+    # Adjust for building rotation
+    surface_azimuth = (base_azimuth + building_orientation_angle) % 360
+    return surface_azimuth
+
+def calculate_incident_solar(dnr: pd.Series, dhr: pd.Series, solar_altitude: pd.Series, solar_azimuth: pd.Series, tilt: float, surface_azimuth: float) -> pd.Series:
+    """
+    Calculate total incident solar radiation on a tilted surface.
+    
+    Args:
+        dnr: Direct Normal Radiation (W/m²)
+        dhr: Diffuse Horizontal Radiation (W/m²)
+        solar_altitude: Solar altitude angle (degrees)
+        solar_azimuth: Solar azimuth angle (degrees, 0=N, positive E)
+        tilt: Surface tilt angle from horizontal (degrees)
+        surface_azimuth: Surface azimuth angle (degrees, 0=N, positive E)
+        
+    Returns:
+        Total incident solar radiation on the surface (W/m²).
+    """
+    # Convert angles to radians
+    alt_rad = np.radians(solar_altitude)
+    az_rad = np.radians(solar_azimuth)
+    tilt_rad = np.radians(tilt)
+    surf_az_rad = np.radians(surface_azimuth)
+    
+    # Angle of Incidence (theta)
+    cos_theta = np.cos(alt_rad) * np.sin(tilt_rad) * np.cos(az_rad - surf_az_rad) + \
+                np.sin(alt_rad) * np.cos(tilt_rad)
+    cos_theta = np.maximum(0, cos_theta)
+    
+    # Direct radiation component
+    direct_tilted = dnr * cos_theta
+    
+    # Diffuse radiation component (simplified isotropic sky model)
+    sky_diffuse_tilted = dhr * (1 + np.cos(tilt_rad)) / 2
+    
+    # Ground reflected component
+    albedo = 0.2
+    ground_reflected_tilted = (dnr * np.sin(alt_rad) + dhr) * albedo * (1 - np.cos(tilt_rad)) / 2
+    
+    # Total incident solar radiation
+    total_incident = direct_tilted + sky_diffuse_tilted + ground_reflected_tilted
+    return total_incident
+
+def calculate_sol_air_temperature(t_oa: pd.Series, dnr: pd.Series, dhr: pd.Series, solar_altitude: pd.Series, solar_azimuth: pd.Series, tilt: float, surface_azimuth: float, absorptivity: float, emissivity: float, h_o: float) -> pd.Series:
+    """
+    Calculate Sol-Air Temperature.
+    
+    Args:
+        t_oa: Outdoor air temperature (°C)
+        dnr, dhr, solar_altitude, solar_azimuth: Solar data
+        tilt, surface_azimuth: Surface orientation
+        absorptivity: Surface solar absorptivity
+        emissivity: Surface thermal emissivity
+        h_o: Outside surface heat transfer coefficient (W/m²·K)
+        
+    Returns:
+        Sol-air temperature (°C).
+    """
+    # Calculate incident solar radiation
+    i_total = calculate_incident_solar(dnr, dhr, solar_altitude, solar_azimuth, tilt, surface_azimuth)
+    
+    # Calculate sky temperature
+    t_sky = t_oa * (SKY_TEMP_FACTOR * t_oa**0.25)**0.25
+    
+    # Longwave radiation exchange term
+    delta_r = STEFAN_BOLTZMANN * emissivity * ((t_oa + 273.15)**4 - (t_sky + 273.15)**4) / h_o
+    
+    # Sol-air temperature
+    t_sol_air = t_oa + (absorptivity * i_total / h_o) - delta_r
+    return t_sol_air
+
+def calculate_hourly_internal_loads(internal_loads_data: Dict[str, List[Dict[str, Any]]]) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Calculate total hourly sensible and latent internal loads.
+    
+    Args:
+        internal_loads_data: Dictionary containing lists of loads for each type.
+        
+    Returns:
+        Tuple of (hourly_sensible_loads, hourly_latent_loads) as numpy arrays.
+    """
+    hourly_sensible = np.zeros(8760)
+    hourly_latent = np.zeros(8760)
+    
+    # Process each load type
+    for load_type, loads in internal_loads_data.items():
+        for load in loads:
+            total_load = load["total"]
+            schedule_type = load["schedule_type"]
+            
+            # Get schedule multipliers
+            schedule_multipliers = np.zeros(8760)
+            if schedule_type == "Custom" and "custom_schedule" in load:
+                weekday_schedule = load["custom_schedule"]["Weekday"]
+                weekend_schedule = load["custom_schedule"]["Weekend"]
+            elif schedule_type in DEFAULT_SCHEDULES:
+                weekday_schedule = DEFAULT_SCHEDULES[schedule_type]["Weekday"]
+                weekend_schedule = DEFAULT_SCHEDULES[schedule_type]["Weekend"]
+            else:
+                weekday_schedule = [1.0] * 24
+                weekend_schedule = [1.0] * 24
+                
+            for hour in range(8760):
+                day_of_week = (hour // 24) % 7
+                hour_of_day = hour % 24
+                if day_of_week < 5:
+                    schedule_multipliers[hour] = weekday_schedule[hour_of_day]
+                else:
+                    schedule_multipliers[hour] = weekend_schedule[hour_of_day]
+            
+            if load_type == "occupancy":
+                sensible_fraction = load["sensible_fraction"]
+                latent_fraction = load["latent_fraction"]
+                hourly_sensible += total_load * sensible_fraction * schedule_multipliers
+                hourly_latent += total_load * latent_fraction * schedule_multipliers
+            else:
+                hourly_sensible += total_load * schedule_multipliers
+                
+    return hourly_sensible, hourly_latent
+
+def display_load_results(results: Dict[str, Any]):
+    """
+    Display the calculated HVAC load results.
+    
+    Args:
+        results: Dictionary containing calculation results.
+    """
+    st.subheader("Peak Load Summary")
+    
     col1, col2, col3 = st.columns(3)
     with col1:
-        st.button("Calculate", key="calculate_button")
+        st.metric("Peak Cooling (Total)", f"{results['peak_cooling_total'] / 1000:.1f} kW", help=f"Occurred at hour {results['peak_cooling_total_hour']}")
+        st.metric("Peak Cooling (Sensible)", f"{results['peak_cooling_sensible'] / 1000:.1f} kW", help=f"Occurred at hour {results['peak_cooling_sensible_hour']}")
     with col2:
-        st.button("Save", key="save_button")
-    with col3:
-        st.button("Reset", key="reset_button")
+        st.metric("Peak Heating", f"{results['peak_heating'] / 1000:.1f} kW", help=f"Occurred at hour {results['peak_heating_hour']}")
+        st.metric("Peak Cooling (Latent)", f"{results['peak_cooling_latent'] / 1000:.1f} kW", help=f"Occurred at hour {results['peak_cooling_latent_hour']}")
+    
+    st.subheader("Hourly Load Profiles")
+    
+    # Create DataFrame for plotting
+    hourly_df = pd.DataFrame({
+        "Hour": range(len(results["hourly_cooling_total"])),
+        "Cooling (Sensible)": results["hourly_cooling_sensible"],
+        "Cooling (Latent)": results["hourly_cooling_latent"],
+        "Cooling (Total)": results["hourly_cooling_total"],
+        "Heating": results["hourly_heating"]
+    })
+    
+    # Plot cooling loads
+    fig_cooling = go.Figure()
+    fig_cooling.add_trace(go.Scatter(x=hourly_df["Hour"], y=hourly_df["Cooling (Sensible)"], name="Sensible Cooling", stackgroup='one'))
+    fig_cooling.add_trace(go.Scatter(x=hourly_df["Hour"], y=hourly_df["Cooling (Latent)"], name="Latent Cooling", stackgroup='one'))
+    fig_cooling.update_layout(title="Hourly Cooling Load Profile", xaxis_title="Hour Index", yaxis_title="Load (W)", height=400)
+    st.plotly_chart(fig_cooling, use_container_width=True)
+    
+    # Plot heating loads
+    fig_heating = go.Figure()
+    fig_heating.add_trace(go.Scatter(x=hourly_df["Hour"], y=hourly_df["Heating"], name="Heating Load", line=dict(color='red')))
+    fig_heating.update_layout(title="Hourly Heating Load Profile", xaxis_title="Hour Index", yaxis_title="Load (W)", height=400)
+    st.plotly_chart(fig_heating, use_container_width=True)
+    
+    st.subheader("Load Components at Peak Cooling Hour")
+    peak_hour = results["peak_cooling_total_hour"]
+    
+    cooling_components = results["cooling_load_components"]
+    peak_cooling_data = {
+        "Component": list(cooling_components.keys()),
+        "Load (W)": [cooling_components[k][peak_hour] for k in cooling_components]
+    }
+    peak_cooling_df = pd.DataFrame(peak_cooling_data)
+    peak_cooling_df = peak_cooling_df[peak_cooling_df["Load (W)"] > 0]
+    
+    fig_peak_cooling = px.pie(
+        peak_cooling_df,
+        values="Load (W)",
+        names="Component",
+        title=f"Cooling Load Breakdown at Peak Hour ({peak_hour})"
+    )
+    st.plotly_chart(fig_peak_cooling, use_container_width=True)
+    
+    st.subheader("Load Components at Peak Heating Hour")
+    peak_hour_heating = results["peak_heating_hour"]
+    
+    heating_components = results["heating_load_components"]
+    internal_gains_at_peak = results["cooling_load_components"]["internal_sensible"][peak_hour_heating]
+    
+    peak_heating_data = {
+        "Component": list(heating_components.keys()) + ["Internal Gains Offset"],
+        "Load (W)": [heating_components[k][peak_hour_heating] for k in heating_components] + [-internal_gains_at_peak]
+    }
+    peak_heating_df = pd.DataFrame(peak_heating_data)
+    peak_heating_df = peak_heating_df[peak_heating_df["Load (W)"] != 0]
+    
+    fig_peak_heating = px.pie(
+        peak_heating_df,
+        values="Load (W)",
+        names="Component",
+        title=f"Heating Load Breakdown at Peak Hour ({peak_hour_heating})"
+    )
+    st.plotly_chart(fig_peak_heating, use_container_width=True)
+
+def get_available_materials() -> Dict[str, Any]:
+    mats = {}
+    if "materials" in st.session_state.project_data:
+        mats.update(st.session_state.project_data["materials"].get("library", {}))
+        mats.update(st.session_state.project_data["materials"].get("project", {}))
+    return mats
+
+def get_available_constructions() -> Dict[str, Any]:
+    consts = {}
+    if "constructions" in st.session_state.project_data:
+        consts.update(st.session_state.project_data["constructions"].get("library", {}))
+        consts.update(st.session_state.project_data["constructions"].get("project", {}))
+    return consts
+
+def get_available_fenestrations() -> Dict[str, Any]:
+    fens = {}
+    if "fenestrations" in st.session_state.project_data:
+        fens.update(st.session_state.project_data["fenestrations"].get("library", {}))
+        fens.update(st.session_state.project_data["fenestrations"].get("project", {}))
+    return fens
 
-if __name__ == "__main__":
-    render_ui()
+def display_hvac_loads_help():
+    """
+    Display help information for the HVAC loads page.
+    """
+    st.markdown("""
+    ### HVAC Loads Help
+    
+    This section calculates the building's heating and cooling loads based on the information provided in the previous steps.
+    
+    **Calculation Process:**
+    
+    1.  **Heat Transfer**: Calculates heat gains and losses through the building envelope (walls, roofs, floors, windows, doors, skylights) considering conduction and solar radiation.
+    2.  **Infiltration & Ventilation**: Calculates loads due to air exchange with the outside.
+    3.  **Internal Loads**: Incorporates heat gains from occupants, lighting, and equipment.
+    4.  **Summation**: Combines all heat gains and losses to determine the net hourly cooling and heating loads.
+    
+    **Simulation Parameters:**
+    
+    *   **Simulation Period**: Choose 'Full Year', a specific date range ('From-to'), or degree-day methods ('HDD' or 'CDD').
+    *   **Indoor Conditions**: Set fixed setpoints, time-varying schedules, or adaptive comfort temperatures.
+    *   **Operating Hours**: Define when the HVAC system operates.
+    
+    **Results:**
+    
+    *   **Peak Loads**: Shows the maximum calculated cooling and heating loads.
+    *   **Hourly Profiles**: Displays graphs of loads for the selected period.
+    *   **Load Components**: Shows the breakdown of loads at peak hours.
+    
+    **Workflow:**
+    
+    1.  Complete all previous sections.
+    2.  Configure simulation parameters.
+    3.  Click "Calculate HVAC Loads".
+    4.  Review results.
+    5.  Proceed to Building Energy section.
+    
+    **Important:**
+    
+    *   Calculations follow ASHRAE methodology.
+    *   Input data quality affects accuracy.
+    *   Review results carefully.
+    """)