Upload hvac_loads.py

app/hvac_loads.py

@@ -1,947 +1,838 @@
 """
-BuildSustain - HVAC Loads Module
-
-This module performs the core cooling and heating load calculations based on the
-ASHRAE methodology. It integrates data from climate, components, and internal loads
-modules to determine the building's thermal loads.
+HVAC Calculator Code Documentation
 
 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
+import pandas as pd
+from typing import Dict, List, Optional, NamedTuple, Any, Tuple
+from enum import Enum
+import streamlit as st
+from data.material_library import Construction, GlazingMaterial, DoorMaterial, Material, MaterialLibrary
+from data.internal_loads import PEOPLE_ACTIVITY_LEVELS, DIVERSITY_FACTORS, LIGHTING_FIXTURE_TYPES, EQUIPMENT_HEAT_GAINS, VENTILATION_RATES, INFILTRATION_SETTINGS
 from datetime import datetime
-import math
 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__)
 
-# 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"):
-        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:
-                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:
-                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}
-
-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)
+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]
     }
-    heating_loads = {
-        "opaque_conduction": np.zeros(num_hours),
-        "fenestration_conduction": np.zeros(num_hours),
-        "infiltration": np.zeros(num_hours),
-        "ventilation": np.zeros(num_hours)
+
+    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"
     }
-    
-    # --- 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"]
+
+    @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)
         
-        # 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
+        # Initialize history terms (simplified: assume steady-state history for demonstration)
+        # In practice, maintain temperature and flux histories
+        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)
+            # Note: F terms require flux history, omitted here for simplicity
+        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.
+
+        Args:
+            month (int): Month of the year (1-12).
+            day (int): Day of the month (1-31).
+            year (int): Year.
+
+        Returns:
+            int: Day of the year (1-365 or 366 for leap years).
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapter 18.
+        """
+        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.
+
+        Args:
+            n (int): Day of the year (1-365 or 366).
+
+        Returns:
+            float: Equation of Time in minutes.
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapter 18.
+        """
+        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.
+
+        Args:
+            glazing_type (str): Type of glazing (e.g., 'Single Clear').
+            cos_theta (float): Cosine of the angle of incidence.
+
+        Returns:
+            float: Dynamic SHGC value.
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapter 15, Table 13.
+        """
+        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"
         
-        # 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"
+        c = TFMCalculations.SHGC_COEFFICIENTS[glazing_type]
+        # Incidence angle modifier: f(cos(θ)) = c_0 + c_1·cos(θ) + c_2·cos²(θ) + c_3·cos³(θ) + c_4·cos⁴(θ) + c_5·cos⁵(θ)
+        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_glazing_materials: Dict, project_door_materials: Dict) -> Tuple[float, float, float, Optional[float], float]:
+        """
+        Determine surface parameters (tilt, azimuth, h_o, emissivity, solar_absorption) for a component.
+        Uses MaterialLibrary to fetch properties from first layer for walls/roofs, DoorMaterial for doors,
+        and GlazingMaterial for windows/skylights. Handles orientation and tilt based on component type:
+        - Walls, Doors, Windows: Azimuth = elevation base azimuth + component.rotation; Tilt = 90°.
+        - Roofs, Skylights: Azimuth = component.orientation; Tilt = component.tilt (default 180°).
         
-        if not is_operating:
-            continue
+        Args:
+            component: Component object with component_type, elevation, rotation, orientation, tilt,
+                      construction, glazing_material, or door_material.
+            building_info (Dict): Building information containing orientation_angle for elevation mapping.
+            material_library: MaterialLibrary instance for accessing library materials/constructions.
+            project_materials: Dict of project-specific Material objects.
+            project_constructions: Dict of project-specific Construction objects.
+            project_glazing_materials: Dict of project-specific GlazingMaterial objects.
+            project_door_materials: Dict of project-specific DoorMaterial objects.
+
+        Returns:
+            Tuple[float, float, float, Optional[float], float]: Surface tilt (°), surface azimuth (°),
+            h_o (W/m²·K), emissivity, solar_absorption.
+        """
+        # Default parameters
+        component_name = getattr(component, 'name', 'unnamed_component')
         
-        # 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
+        # Initialize default values
+        surface_tilt = 90.0  # Default vertical for walls, windows, doors
+        surface_azimuth = 0.0  # Default north-facing
+        h_o = 17.0  # Default exterior convection coefficient
+        emissivity = 0.9  # Default for opaque components
+        solar_absorption = 0.6  # Default
         
-        # 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']
+        try:
+            # Set component-specific defaults based on type
+            if component.component_type == ComponentType.ROOF:
+                surface_tilt = getattr(component, 'tilt', 0.0)  # Horizontal, upward if tilt absent
+                h_o = 23.0  # W/m²·K for roofs
+                # For roofs, use orientation directly
+                surface_azimuth = getattr(component, 'orientation', 0.0)
+                logger.debug(f"Roof component {component_name}: using orientation={surface_azimuth}, tilt={surface_tilt}")
                 
-                # Calculate surface azimuth
-                surface_azimuth = calculate_surface_azimuth(orientation, building_orientation_angle)
+            elif component.component_type == ComponentType.SKYLIGHT:
+                surface_tilt = getattr(component, 'tilt', 0.0)  # Horizontal, upward if tilt absent
+                h_o = 23.0  # W/m²·K for skylights
+                # For skylights, use orientation directly, not elevation
+                surface_azimuth = getattr(component, 'orientation', 0.0)
+                logger.debug(f"Skylight component {component_name}: using orientation={surface_azimuth}, tilt={surface_tilt}")
                 
-                # 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]
+            elif component.component_type == ComponentType.FLOOR:
+                surface_tilt = 180.0  # Horizontal, downward
+                h_o = 17.0  # W/m²·K
+                surface_azimuth = 0.0  # Default azimuth for floors
+                logger.debug(f"Floor component {component_name}: using default azimuth={surface_azimuth}, tilt={surface_tilt}")
                 
-                # 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
+            else:  # WALL, DOOR, WINDOW
+                surface_tilt = 90.0  # Vertical
+                h_o = 17.0  # W/m²·K
                 
-                # 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
+                # Check for elevation attribute
+                elevation = getattr(component, 'elevation', None)
+                if not elevation:
+                    logger.warning(f"Component {component_name} ({component.component_type.value}) is missing 'elevation' field. Using default azimuth=0.")
+                    surface_azimuth = 0.0  # Default to north-facing if elevation is missing
                 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
+                    # Define elevation azimuths based on building orientation_angle
+                    base_azimuth = building_info.get("orientation_angle", 0.0)
+                    elevation_angles = {
+                        "A": base_azimuth,
+                        "B": (base_azimuth + 90.0) % 360,
+                        "C": (base_azimuth + 180.0) % 360,
+                        "D": (base_azimuth + 270.0) % 360
+                    }
+
+                    if elevation not in elevation_angles:
+                        logger.warning(f"Invalid elevation '{elevation}' for component {component_name} ({component.component_type.value}). "
+                                      f"Expected one of {list(elevation_angles.keys())}. Using default azimuth=0.")
+                        surface_azimuth = 0.0  # Default to north-facing if elevation is invalid
+                    else:
+                        # Add component rotation to elevation azimuth
+                        surface_azimuth = (elevation_angles[elevation] + getattr(component, 'rotation', 0.0)) % 360
+                        logger.debug(f"Component {component_name} ({component.component_type.value}): elevation={elevation}, "
+                                    f"base_azimuth={elevation_angles[elevation]}, rotation={getattr(component, 'rotation', 0.0)}, "
+                                    f"total_azimuth={surface_azimuth}, tilt={surface_tilt}")
+
+            # Fetch material properties
+            if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
+                construction = getattr(component, 'construction', None)
+                if not construction:
+                    logger.warning(f"No construction defined for {component_name} ({component.component_type.value}). "
+                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
                 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.
+                    # Get construction from library or project
+                    construction_obj = None
+                    if hasattr(construction, 'name'):
+                        construction_obj = (project_constructions.get(construction.name) or
+                                           material_library.library_constructions.get(construction.name))
+                    
+                    if not construction_obj:
+                        logger.warning(f"Construction not found for {component_name} ({component.component_type.value}). "
+                                      f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                    elif not construction_obj.layers:
+                        logger.warning(f"No layers in construction for {component_name} ({component.component_type.value}). "
+                                      f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                    else:
+                        # Use first (outermost) layer's properties
+                        first_layer = construction_obj.layers[0]
+                        material = first_layer.get("material")
+                        if material:
+                            solar_absorption = getattr(material, 'solar_absorption', 0.6)
+                            emissivity = getattr(material, 'emissivity', 0.9)
+                            logger.debug(f"Using first layer material for {component_name} ({component.component_type.value}): "
+                                        f"solar_absorption={solar_absorption}, emissivity={emissivity}")
+
+            elif component.component_type == ComponentType.DOOR:
+                door_material = getattr(component, 'door_material', None)
+                if not door_material:
+                    logger.warning(f"No door material defined for {component_name} ({component.component_type.value}). "
+                                  f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                else:
+                    # Get door material from library or project
+                    door_material_obj = None
+                    if hasattr(door_material, 'name'):
+                        door_material_obj = (project_door_materials.get(door_material.name) or
+                                            material_library.library_door_materials.get(door_material.name))
+                    
+                    if not door_material_obj:
+                        logger.warning(f"Door material not found for {component_name} ({component.component_type.value}). "
+                                      f"Using defaults: solar_absorption=0.6, emissivity=0.9.")
+                    else:
+                        solar_absorption = getattr(door_material_obj, 'solar_absorption', 0.6)
+                        emissivity = getattr(door_material_obj, 'emissivity', 0.9)
+                        logger.debug(f"Using door material for {component_name} ({component.component_type.value}): "
+                                    f"solar_absorption={solar_absorption}, emissivity={emissivity}")
+
+            elif component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                glazing_material = getattr(component, 'glazing_material', None)
+                if not glazing_material:
+                    logger.warning(f"No glazing material defined for {component_name} ({component.component_type.value}). "
+                                  f"Using default SHGC=0.7, h_o={h_o}.")
+                    shgc = 0.7
+                else:
+                    # Get glazing material from library or project
+                    glazing_material_obj = None
+                    if hasattr(glazing_material, 'name'):
+                        glazing_material_obj = (project_glazing_materials.get(glazing_material.name) or
+                                               material_library.library_glazing_materials.get(glazing_material.name))
+                    
+                    if not glazing_material_obj:
+                        logger.warning(f"Glazing material not found for {component_name} ({component.component_type.value}). "
+                                      f"Using default SHGC=0.7, h_o={h_o}.")
+                        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} ({component.component_type.value}): "
+                                    f"shgc={shgc}, h_o={h_o}")
+                emissivity = None  # Not used for glazing
+
+        except Exception as e:
+            logger.error(f"Error retrieving surface parameters for {component_name} ({component.component_type.value}): {str(e)}")
+            # Apply defaults based on component type
+            if component.component_type == ComponentType.ROOF:
+                surface_tilt = 0.0  # Horizontal, upward
+                h_o = 23.0  # W/m²·K for roofs
+                surface_azimuth = 0.0  # Default north
+            elif component.component_type == ComponentType.SKYLIGHT:
+                surface_tilt = 0.0  # Horizontal, upward
+                h_o = 23.0  # W/m²·K for skylights
+                surface_azimuth = 0.0  # Default north
+            elif component.component_type == ComponentType.FLOOR:
+                surface_tilt = 180.0  # Horizontal, downward
+                h_o = 17.0  # W/m²·K
+                surface_azimuth = 0.0  # Default north
+            else:  # WALL, DOOR, WINDOW
+                surface_tilt = 90.0  # Vertical
+                h_o = 17.0  # W/m²·K
+                surface_azimuth = 0.0  # Default north
+            
+            # Apply material defaults
+            if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
+                solar_absorption = 0.6
+                emissivity = 0.9
+            else:  # WINDOW, SKYLIGHT
+                shgc = 0.7
+                emissivity = None
+
+        # Debug output for all components
+        logger.info(f"Final surface parameters for {component_name} ({component.component_type.value}): "
+                   f"tilt={surface_tilt:.1f}, azimuth={surface_azimuth:.1f}, h_o={h_o:.1f}")
+
+        return surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption
+
+    @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.
         
-    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"]
+        Args:
+            component: Component object with area, component_type, elevation, glazing_material, shgc, iac.
+            hourly_data (Dict): Hourly weather data including solar radiation.
+            hour (int): Current hour.
+            building_orientation (float): Building orientation angle in degrees.
+            mode (str): Operating mode ('cooling', 'heating', 'none').
+
+        Returns:
+            float: Solar cooling load in kW. Returns 0 for non-cooling modes or non-fenestration components.
+
+        References:
+            ASHRAE Handbook—Fundamentals, Chapters 15 and 18.
+        """
+        # Only calculate solar loads in cooling mode
+        if mode != "cooling":
+            return 0
+            
+        # Skip floors for solar calculation
+        if component.component_type == ComponentType.FLOOR:
+            return 0
+
+        component_name = getattr(component, 'name', 'unnamed_component')
+
+        try:
+            # Ensure MaterialLibrary is properly initialized and accessible
+            material_library = st.session_state.get("material_library")
+            if not material_library:
+                logger.error(f"MaterialLibrary not found in session_state for {component_name} ({component.component_type.value})")
+                # Instead of raising an error, initialize a new MaterialLibrary
+                from data.material_library import MaterialLibrary
+                material_library = MaterialLibrary()
+                st.session_state.material_library = material_library
+                logger.info(f"Created new MaterialLibrary for {component_name} ({component.component_type.value})")
             
-            # 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"]
+            project_materials = st.session_state.get("project_materials", {})
+            project_constructions = st.session_state.get("project_constructions", {})
+            project_glazing_materials = st.session_state.get("project_glazing_materials", {})
+            project_door_materials = st.session_state.get("project_door_materials", {})
+
+            # Get location parameters from climate_data
+            climate_data = st.session_state.get("climate_data", {})
+            latitude = climate_data.get("latitude", 0.0)
+            longitude = climate_data.get("longitude", 0.0)
+            timezone = climate_data.get("time_zone", 0.0)
+
+            # Get ground reflectivity (default 0.2)
+            ground_reflectivity = st.session_state.get("ground_reflectivity", 0.2)
+
+            # Validate input parameters
+            if not -90 <= latitude <= 90:
+                logger.warning(f"Invalid latitude {latitude} for {component_name} ({component.component_type.value}). Using default 0.0.")
+                latitude = 0.0
+            if not -180 <= longitude <= 180:
+                logger.warning(f"Invalid longitude {longitude} for {component_name} ({component.component_type.value}). Using default 0.0.")
+                longitude = 0.0
+            if not -12 <= timezone <= 14:
+                logger.warning(f"Invalid timezone {timezone} for {component_name} ({component.component_type.value}). Using default 0.0.")
+                timezone = 0.0
+            if not 0 <= ground_reflectivity <= 1:
+                logger.warning(f"Invalid ground_reflectivity {ground_reflectivity} for {component_name} ({component.component_type.value}). Using default 0.2.")
+                ground_reflectivity = 0.2
+
+            # Ensure hourly_data has required fields
+            required_fields = ["month", "day", "hour", "global_horizontal_radiation", "direct_normal_radiation", 
+                             "diffuse_horizontal_radiation", "dry_bulb"]
+            if not all(field in hourly_data for field in required_fields):
+                logger.warning(f"Missing required fields in hourly_data for hour {hour} for {component_name} ({component.component_type.value}): {hourly_data}")
+                return 0
+
+            # Skip if GHI <= 0
+            if hourly_data["global_horizontal_radiation"] <= 0:
+                logger.info(f"No solar load for hour {hour} due to GHI={hourly_data['global_horizontal_radiation']} for {component_name} ({component.component_type.value})")
+                return 0
+
+            # Extract weather data
+            month = hourly_data["month"]
+            day = hourly_data["day"]
+            hour = hourly_data["hour"]
+            ghi = hourly_data["global_horizontal_radiation"]
+            dni = hourly_data.get("direct_normal_radiation", ghi * 0.7)  # Fallback: estimate DNI
+            dhi = hourly_data.get("diffuse_horizontal_radiation", ghi * 0.3)  # Fallback: estimate DHI
+            outdoor_temp = hourly_data["dry_bulb"]
+
+            if ghi < 0 or dni < 0 or dhi < 0:
+                logger.error(f"Negative radiation values for {month}/{day}/{hour} for {component_name} ({component.component_type.value})")
+                raise ValueError(f"Negative radiation values for {month}/{day}/{hour}")
+
+            # Add detailed logging for solar calculation
+            logger.info(f"Processing solar for {month}/{day}/{hour} with GHI={ghi}, DNI={dni}, DHI={dhi}, "
+                       f"dry_bulb={outdoor_temp} for {component_name} ({component.component_type.value})")
+
+            # Step 1: Local Solar Time (LST) with Equation of Time
+            year = 2025  # Fixed year since not provided
+            n = TFMCalculations.day_of_year(month, day, year)
+            EOT = TFMCalculations.equation_of_time(n)
+            lambda_std = 15 * timezone  # Standard meridian longitude (°)
+            standard_time = hour - 1 + 0.5  # Convert to decimal, assume mid-hour
+            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)
+
+            sin_alpha = math.sin(phi) * math.sin(delta_rad) + math.cos(phi) * math.cos(delta_rad) * math.cos(hra_rad)
+            alpha = math.degrees(math.asin(sin_alpha))
+
+            if abs(math.cos(math.radians(alpha))) < 0.01:
+                azimuth = 0  # North at sunrise/sunset
             else:
-                weekday_schedule = [1.0] * 24
-                weekend_schedule = [1.0] * 24
+                sin_az = math.cos(delta_rad) * math.sin(hra_rad) / math.cos(math.radians(alpha))
+                cos_az = (sin_alpha * math.sin(phi) - math.sin(delta_rad)) / (math.cos(math.radians(alpha)) * math.cos(phi))
+                azimuth = math.degrees(math.atan2(sin_az, cos_az))
+                if hra > 0:  # Afternoon
+                    azimuth = 360 - azimuth if azimuth > 0 else -azimuth
+
+            logger.info(f"Solar angles for {month}/{day}/{hour}: declination={delta:.2f}, LST={LST:.2f}, "
+                       f"HRA={hra:.2f}, altitude={alpha:.2f}, azimuth={azimuth:.2f} for {component_name} ({component.component_type.value})")
+
+            # Step 5: Get surface parameters with robust error handling
+            building_info = {"orientation_angle": building_orientation}
+            try:
+                surface_tilt, surface_azimuth, h_o, emissivity, solar_absorption = \
+                    TFMCalculations.get_surface_parameters(
+                        component, building_info, material_library, project_materials,
+                        project_constructions, project_glazing_materials, project_door_materials
+                    )
+            except Exception as e:
+                logger.error(f"Error getting surface parameters for {component_name}: {str(e)}. Using defaults.")
+                # Apply defaults based on component type
+                if component.component_type == ComponentType.ROOF:
+                    surface_tilt = 0.0  # Horizontal, upward
+                    surface_azimuth = 0.0  # Default north
+                elif component.component_type == ComponentType.SKYLIGHT:
+                    surface_tilt = 0.0  # Horizontal, upward
+                    surface_azimuth = 0.0  # Default north
+                elif component.component_type == ComponentType.FLOOR:
+                    surface_tilt = 180.0  # Horizontal, downward
+                    surface_azimuth = 0.0  # Default north
+                else:  # WALL, DOOR, WINDOW
+                    surface_tilt = 90.0  # Vertical
+                    surface_azimuth = 0.0  # Default north
                 
-            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]
+                # Apply material defaults
+                if component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
+                    solar_absorption = 0.6
+                    h_o = 17.0 if component.component_type == ComponentType.WALL else 23.0
+                else:  # WINDOW, SKYLIGHT
+                    solar_absorption = 0.0  # Not used for glazing
+                    h_o = 17.0 if component.component_type == ComponentType.WINDOW else 23.0
+
+            # Step 6: Calculate angle of incidence (θ)
+            # Convert angles to radians for calculation
+            alpha_rad = math.radians(alpha)
+            surface_tilt_rad = math.radians(surface_tilt)
+            azimuth_rad = math.radians(azimuth)
+            surface_azimuth_rad = math.radians(surface_azimuth)
+            
+            # Calculate cos(θ) using the solar position and surface orientation
+            cos_theta = (math.sin(alpha_rad) * math.cos(surface_tilt_rad) +
+                         math.cos(alpha_rad) * math.sin(surface_tilt_rad) *
+                         math.cos(azimuth_rad - surface_azimuth_rad))
+            
+            # Clamp to [0, 1] to avoid numerical issues
+            cos_theta = max(min(cos_theta, 1.0), 0.0)
+            
+            # Log the calculated values
+            logger.info(f"  Component {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
+                        f"surface_tilt={surface_tilt:.2f}, surface_azimuth={surface_azimuth:.2f}, "
+                        f"cos_theta={cos_theta:.4f}")
+
+            # Step 7: Calculate total incident radiation (I_t)
+            # Calculate view factor for ground-reflected radiation
+            view_factor = (1 - math.cos(surface_tilt_rad)) / 2
+            
+            # Calculate ground-reflected radiation
+            ground_reflected = ground_reflectivity * ghi * view_factor
+            
+            # Calculate total incident radiation
+            if cos_theta > 0:  # Surface receives direct beam radiation
+                I_t = dni * cos_theta + dhi + ground_reflected
+            else:  # Surface in shade, only diffuse and reflected
+                I_t = dhi + ground_reflected
+            
+            # Step 8: Calculate solar heat gain based on component type
+            solar_heat_gain = 0.0
+            
+            if component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+                # For windows/skylights, get SHGC from material
+                shgc = 0.7  # Default
+                glazing_material = getattr(component, 'glazing_material', None)
+                if glazing_material:
+                    glazing_material_obj = None
+                    if hasattr(glazing_material, 'name'):
+                        glazing_material_obj = (project_glazing_materials.get(glazing_material.name) or
+                                               material_library.library_glazing_materials.get(glazing_material.name))
+                    
+                    if glazing_material_obj:
+                        shgc = getattr(glazing_material_obj, 'shgc', 0.7)
+                        h_o = getattr(glazing_material_obj, 'h_o', h_o)
+                    else:
+                        logger.warning(f"Glazing material not found for {component_name} ({component.component_type.value}). Using default SHGC=0.7.")
                 else:
-                    schedule_multipliers[hour] = weekend_schedule[hour_of_day]
+                    logger.warning(f"No glazing material defined for {component_name} ({component.component_type.value}). Using default SHGC=0.7.")
+                
+                # Get glazing type for dynamic SHGC calculation
+                glazing_type = "Single Clear"  # Default
+                if hasattr(component, 'name') and component.name in TFMCalculations.GLAZING_TYPE_MAPPING:
+                    glazing_type = TFMCalculations.GLAZING_TYPE_MAPPING[component.name]
+                
+                # Get internal shading coefficient
+                iac = getattr(component, 'iac', 1.0)  # Default internal shading
+                
+                # Calculate dynamic SHGC based on incidence angle
+                shgc_dynamic = shgc * TFMCalculations.calculate_dynamic_shgc(glazing_type, cos_theta)
+                
+                # Calculate solar heat gain for fenestration
+                solar_heat_gain = component.area * shgc_dynamic * I_t * iac / 1000  # kW
+                
+                logger.info(f"Fenestration solar heat gain for {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
+                            f"{solar_heat_gain:.4f} kW (area={component.area}, shgc_dynamic={shgc_dynamic:.4f}, "
+                            f"I_t={I_t:.2f}, iac={iac})")
+            
+            elif component.component_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.DOOR]:
+                # For opaque surfaces, use solar absorptivity and surface resistance
+                surface_resistance = 1/h_o  # m²·K/W
+                
+                # Calculate absorbed solar radiation
+                solar_heat_gain = component.area * solar_absorption * I_t * surface_resistance / 1000  # kW
+                
+                logger.info(f"Opaque surface solar heat gain for {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
+                            f"{solar_heat_gain:.4f} kW (area={component.area}, solar_absorption={solar_absorption:.2f}, "
+                            f"I_t={I_t:.2f}, surface_resistance={surface_resistance:.4f})")
             
-            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
+            return solar_heat_gain
+
+        except Exception as e:
+            logger.error(f"Error calculating solar load for {component_name} ({component.component_type.value}) 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["diversity_factor"]
+        for light in internal_loads.get("lighting", []):
+            lpd = light["lpd"]
+            lighting_operating_hours = light["operating_hours"]
+            fraction = min(lighting_operating_hours, operation_hours) / operation_hours if operation_hours > 0 else 0
+            lighting_load = lpd * area * fraction
+            total_load += lighting_load
+        equipment = internal_loads.get("equipment")
+        if equipment:
+            total_power_density = equipment.get("total_power_density", 0)
+            equipment_load = total_power_density * area
+            total_load += equipment_load
+        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
+        ventilation = internal_loads.get("ventilation")
+        if not ventilation:
+            return 0, 0
+        space_rate = ventilation.get("space_rate", 0.3)  # L/s/m²
+        people_rate = ventilation.get("people_rate", 2.5)  # L/s/person
+        num_people = sum(group["num_people"] for group in internal_loads.get("people", []))
+        ventilation_flow = (space_rate * area + people_rate * num_people) / 1000  # m³/s
+        air_density = 1.2  # kg/m³
+        specific_heat = 1000  # J/kg·K
+        delta_t = outdoor_temp - indoor_temp
+        if mode == "cooling" and delta_t <= 0:
+            return 0, 0
+        if mode == "heating" and delta_t >= 0:
+            return 0, 0
+        load = ventilation_flow * air_density * specific_heat * delta_t / 1000  # kW
+        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
+        infiltration = internal_loads.get("infiltration")
+        if not infiltration:
+            return 0, 0
+        method = infiltration.get("method", "ACH")
+        settings = infiltration.get("settings", {})
+        building_height = building_info.get("building_height", 3.0)
+        volume = area * building_height  # m³
+        air_density = 1.2  # kg/m³
+        specific_heat = 1000  # J/kg·K
+        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
+        if method == "ACH":
+            ach = settings.get("rate", 0.5)
+            infiltration_flow = ach * volume / 3600  # m³/s
+        elif method == "Crack Flow":
+            ela = settings.get("ela", 0.0001)  # m²/m²
+            wind_speed = 4.0  # m/s (assumed)
+            infiltration_flow = ela * area * wind_speed / 2  # m³/s
+        else:  # Empirical Equations
+            c = settings.get("c", 0.1)
+            n = settings.get("n", 0.65)
+            delta_t_abs = abs(delta_t)
+            infiltration_flow = c * (delta_t_abs ** n) * area / 3600  # m³/s
+        load = infiltration_flow * air_density * specific_heat * delta_t / 1000  # kW
+        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  # Default to standard setpoint if outside range
+
+    @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["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
+
+    @staticmethod
+    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:
-                hourly_sensible += total_load * schedule_multipliers
+                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
+            return {"temperature": TFMCalculations.get_adaptive_comfort_temp(outdoor_temp), "rh": 50.0}
+
+    @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)
+        operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
+        area = building_info.get("floor_area", 100.0)
+        
+        # Ensure MaterialLibrary is properly initialized
+        if "material_library" not in st.session_state:
+            from data.material_library import MaterialLibrary
+            st.session_state.material_library = MaterialLibrary()
+            logger.info("Initialized MaterialLibrary in session_state for solar calculations")
+        
+        # Pre-calculate CTF coefficients for all components using CTFCalculator
+        for comp_list in components.values():
+            for comp in comp_list:
+                comp.ctf = CTFCalculator.calculate_ctf_coefficients(comp)
+
+        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)
+            indoor_temp = indoor_cond["temperature"]
+            # Initialize all loads to 0
+            conduction_cooling = conduction_heating = solar = internal = ventilation_cooling = ventilation_heating = infiltration_cooling = infiltration_heating = 0
+            # Check if hour is within operating periods
+            is_operating = False
+            for period in operating_periods:
+                start_hour = period.get("start", 8)
+                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 is_operating and mode == "cooling":
+                # Calculate solar load for each component and accumulate
+                for comp_list in components.values():
+                    for comp in comp_list:
+                        cool_load, _ = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="cooling")
+                        conduction_cooling += cool_load
+                        
+                        # Calculate solar load for each component and accumulate
+                        component_solar_load = TFMCalculations.calculate_solar_load(comp, hour_data, hour, building_orientation, mode="cooling")
+                        solar += component_solar_load
+                        
+                        # Add detailed logging for solar load accumulation
+                        logger.info(f"Component {comp.name} ({comp.component_type.value}) solar load: {component_solar_load:.3f} kW, accumulated solar: {solar:.3f} kW")
                 
-    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.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.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
-
-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.
-    """)
+                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), 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, max([p["end"] - p["start"] for p in operating_periods]), area)
+                _, ventilation_heating = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
+                _, infiltration_heating = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
+            else:  # mode == "none" or not is_operating
+                internal = 0  # No internal loads when no heating or cooling is needed or outside operating hours
+            
+            # Add detailed logging for total loads
+            logger.info(f"Hour {hour} total loads - conduction: {conduction_cooling:.3f} kW, solar: {solar:.3f} kW, internal: {internal:.3f} kW")
+            
+            # Calculate total loads, subtracting internal load for heating
+            total_cooling = conduction_cooling + solar + internal + ventilation_cooling + infiltration_cooling
+            total_heating = max(conduction_heating + ventilation_heating + infiltration_heating - internal, 0)
+            # Enforce mutual exclusivity within hour
+            if mode == "cooling":
+                total_heating = 0
+            elif mode == "heating":
+                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
+            })
+        # Group loads by day and apply daily control
+        loads_by_day = defaultdict(list)
+        for load in temp_loads:
+            day_key = (load["month"], load["day"])
+            loads_by_day[day_key].append(load)
+        final_loads = []
+        for day_key, day_loads in loads_by_day.items():
+            # Count hours with non-zero cooling and heating loads
+            cooling_hours = sum(1 for load in day_loads if load["total_cooling"] > 0)
+            heating_hours = sum(1 for load in day_loads if load["total_heating"] > 0)
+            # Apply daily control
+            for load in day_loads:
+                if cooling_hours > heating_hours:
+                    load["total_heating"] = 0  # Keep cooling components, zero heating total
+                elif heating_hours > cooling_hours:
+                    load["total_cooling"] = 0  # Keep heating components, zero cooling total
+                else:  # Equal hours
+                    load["total_cooling"] = 0
+                    load["total_heating"] = 0  # Zero both totals, keep components
+                final_loads.append(load)
+        return final_loads