Upload 11 files

app/building_energy.py

@@ -0,0 +1,1136 @@
+"""
+HVAC Load Calculator - Building Energy Module
+
+This module handles the building energy consumption calculations based on the HVAC loads,
+system efficiencies, and operational parameters. It provides energy use estimates,
+cost analysis, and carbon emissions calculations.
+
+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 plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple, Union
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Constants
+MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]  # Non-leap year
+HOURS_IN_YEAR = 8760
+
+# Default HVAC system parameters
+DEFAULT_HVAC_SYSTEMS = {
+    "Split System Heat Pump": {
+        "cooling_cop": 3.5,
+        "heating_cop": 4.0,
+        "fan_power_ratio": 0.1,  # Fan power as fraction of total capacity
+        "pump_power_ratio": 0.05,  # Pump power as fraction of total capacity
+        "part_load_performance": "Good",  # Qualitative assessment
+        "cost_per_kw": 500,  # Installation cost per kW of capacity
+        "lifespan_years": 15,
+        "maintenance_cost_ratio": 0.02  # Annual maintenance as fraction of installation cost
+    },
+    "VRF System": {
+        "cooling_cop": 4.2,
+        "heating_cop": 4.5,
+        "fan_power_ratio": 0.08,
+        "pump_power_ratio": 0.04,
+        "part_load_performance": "Excellent",
+        "cost_per_kw": 800,
+        "lifespan_years": 20,
+        "maintenance_cost_ratio": 0.015
+    },
+    "Chiller with Gas Boiler": {
+        "cooling_cop": 5.0,
+        "heating_cop": 0.85,  # Gas boiler efficiency
+        "fan_power_ratio": 0.12,
+        "pump_power_ratio": 0.08,
+        "part_load_performance": "Good",
+        "cost_per_kw": 1000,
+        "lifespan_years": 25,
+        "maintenance_cost_ratio": 0.025
+    },
+    "Air-Cooled Packaged Unit": {
+        "cooling_cop": 3.2,
+        "heating_cop": 3.8,
+        "fan_power_ratio": 0.15,
+        "pump_power_ratio": 0.03,
+        "part_load_performance": "Fair",
+        "cost_per_kw": 400,
+        "lifespan_years": 12,
+        "maintenance_cost_ratio": 0.03
+    },
+    "Water-Source Heat Pump": {
+        "cooling_cop": 4.8,
+        "heating_cop": 5.2,
+        "fan_power_ratio": 0.07,
+        "pump_power_ratio": 0.1,
+        "part_load_performance": "Excellent",
+        "cost_per_kw": 900,
+        "lifespan_years": 20,
+        "maintenance_cost_ratio": 0.02
+    },
+    "Custom System": {
+        "cooling_cop": 4.0,
+        "heating_cop": 4.0,
+        "fan_power_ratio": 0.1,
+        "pump_power_ratio": 0.05,
+        "part_load_performance": "Good",
+        "cost_per_kw": 600,
+        "lifespan_years": 15,
+        "maintenance_cost_ratio": 0.02
+    }
+}
+
+# Default energy rates
+DEFAULT_ENERGY_RATES = {
+    "electricity": {
+        "rate": 0.25,  # $/kWh
+        "demand_charge": 15.0,  # $/kW-month
+        "carbon_intensity": 0.5  # kg CO2e/kWh
+    },
+    "natural_gas": {
+        "rate": 0.08,  # $/kWh
+        "demand_charge": 0.0,  # $/kW-month
+        "carbon_intensity": 0.2  # kg CO2e/kWh
+    }
+}
+
+def display_building_energy_page():
+    """
+    Display the building energy page.
+    This is the main function called by main.py when the Building Energy page is selected.
+    """
+    st.title("Building Energy Consumption")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_building_energy_help()
+    
+    # Check if HVAC loads have been calculated
+    if "hvac_loads" not in st.session_state.project_data or not st.session_state.project_data["hvac_loads"]:
+        st.warning("Please complete the HVAC Loads calculations before proceeding to Building Energy analysis.")
+        
+        # Navigation buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Back to HVAC Loads", key="back_to_hvac_loads"):
+                st.session_state.current_page = "HVAC Loads"
+                st.rerun()
+        return
+    
+    # Initialize building energy data if not present
+    initialize_building_energy_data()
+    
+    # Create tabs for different aspects of energy analysis
+    tabs = st.tabs(["HVAC System", "Energy Consumption", "Energy Costs", "Carbon Emissions"])
+    
+    with tabs[0]:
+        display_hvac_system_tab()
+    
+    with tabs[1]:
+        display_energy_consumption_tab()
+    
+    with tabs[2]:
+        display_energy_costs_tab()
+    
+    with tabs[3]:
+        display_carbon_emissions_tab()
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to HVAC Loads", key="back_to_hvac_loads"):
+            st.session_state.current_page = "HVAC Loads"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Renewable Energy", key="continue_to_renewable_energy"):
+            st.session_state.current_page = "Renewable Energy"
+            st.rerun()
+
+def initialize_building_energy_data():
+    """Initialize building energy data in session state if not present."""
+    if "building_energy" not in st.session_state.project_data:
+        st.session_state.project_data["building_energy"] = {
+            "hvac_system": {
+                "system_type": "Split System Heat Pump",
+                "cooling_cop": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["cooling_cop"],
+                "heating_cop": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["heating_cop"],
+                "fan_power_ratio": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["fan_power_ratio"],
+                "pump_power_ratio": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["pump_power_ratio"],
+                "part_load_performance": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["part_load_performance"],
+                "cost_per_kw": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["cost_per_kw"],
+                "lifespan_years": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["lifespan_years"],
+                "maintenance_cost_ratio": DEFAULT_HVAC_SYSTEMS["Split System Heat Pump"]["maintenance_cost_ratio"]
+            },
+            "energy_rates": {
+                "electricity": DEFAULT_ENERGY_RATES["electricity"].copy(),
+                "natural_gas": DEFAULT_ENERGY_RATES["natural_gas"].copy()
+            },
+            "results": None
+        }
+
+def display_hvac_system_tab():
+    """Display the HVAC system selection and configuration tab."""
+    st.header("HVAC System Configuration")
+    
+    # Get current HVAC system data
+    hvac_system = st.session_state.project_data["building_energy"]["hvac_system"]
+    
+    # System type selection
+    system_type = st.selectbox(
+        "HVAC System Type",
+        list(DEFAULT_HVAC_SYSTEMS.keys()),
+        index=list(DEFAULT_HVAC_SYSTEMS.keys()).index(hvac_system["system_type"]),
+        help="Select the type of HVAC system for the building."
+    )
+    
+    # If system type changed, update default values
+    if system_type != hvac_system["system_type"] and system_type != "Custom System":
+        hvac_system.update({
+            "system_type": system_type,
+            "cooling_cop": DEFAULT_HVAC_SYSTEMS[system_type]["cooling_cop"],
+            "heating_cop": DEFAULT_HVAC_SYSTEMS[system_type]["heating_cop"],
+            "fan_power_ratio": DEFAULT_HVAC_SYSTEMS[system_type]["fan_power_ratio"],
+            "pump_power_ratio": DEFAULT_HVAC_SYSTEMS[system_type]["pump_power_ratio"],
+            "part_load_performance": DEFAULT_HVAC_SYSTEMS[system_type]["part_load_performance"],
+            "cost_per_kw": DEFAULT_HVAC_SYSTEMS[system_type]["cost_per_kw"],
+            "lifespan_years": DEFAULT_HVAC_SYSTEMS[system_type]["lifespan_years"],
+            "maintenance_cost_ratio": DEFAULT_HVAC_SYSTEMS[system_type]["maintenance_cost_ratio"]
+        })
+    elif system_type != hvac_system["system_type"] and system_type == "Custom System":
+        hvac_system["system_type"] = system_type
+    
+    # System parameters
+    st.subheader("System Performance Parameters")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        cooling_cop = st.number_input(
+            "Cooling COP",
+            min_value=1.0,
+            max_value=10.0,
+            value=float(hvac_system["cooling_cop"]),
+            step=0.1,
+            format="%.1f",
+            help="Coefficient of Performance for cooling (higher is more efficient)."
+        )
+        
+        fan_power_ratio = st.number_input(
+            "Fan Power Ratio",
+            min_value=0.01,
+            max_value=0.5,
+            value=float(hvac_system["fan_power_ratio"]),
+            step=0.01,
+            format="%.2f",
+            help="Fan power as a fraction of total system capacity."
+        )
+    
+    with col2:
+        heating_cop = st.number_input(
+            "Heating COP/Efficiency",
+            min_value=0.5,
+            max_value=10.0,
+            value=float(hvac_system["heating_cop"]),
+            step=0.1,
+            format="%.1f",
+            help="Coefficient of Performance for heating (for heat pumps) or efficiency (for boilers)."
+        )
+        
+        pump_power_ratio = st.number_input(
+            "Pump Power Ratio",
+            min_value=0.0,
+            max_value=0.5,
+            value=float(hvac_system["pump_power_ratio"]),
+            step=0.01,
+            format="%.2f",
+            help="Pump power as a fraction of total system capacity."
+        )
+    
+    # System cost parameters
+    st.subheader("System Cost Parameters")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        cost_per_kw = st.number_input(
+            "Installation Cost ($/kW)",
+            min_value=100.0,
+            max_value=2000.0,
+            value=float(hvac_system["cost_per_kw"]),
+            step=50.0,
+            format="%.0f",
+            help="Installation cost per kW of system capacity."
+        )
+    
+    with col2:
+        lifespan_years = st.number_input(
+            "System Lifespan (years)",
+            min_value=5,
+            max_value=30,
+            value=int(hvac_system["lifespan_years"]),
+            step=1,
+            help="Expected lifespan of the HVAC system in years."
+        )
+    
+    with col3:
+        maintenance_cost_ratio = st.number_input(
+            "Annual Maintenance Cost Ratio",
+            min_value=0.005,
+            max_value=0.1,
+            value=float(hvac_system["maintenance_cost_ratio"]),
+            step=0.005,
+            format="%.3f",
+            help="Annual maintenance cost as a fraction of installation cost."
+        )
+    
+    # Energy rates
+    st.subheader("Energy Rates")
+    
+    energy_rates = st.session_state.project_data["building_energy"]["energy_rates"]
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.write("Electricity")
+        electricity_rate = st.number_input(
+            "Electricity Rate ($/kWh)",
+            min_value=0.05,
+            max_value=1.0,
+            value=float(energy_rates["electricity"]["rate"]),
+            step=0.01,
+            format="%.2f",
+            help="Cost of electricity per kWh."
+        )
+        
+        electricity_demand_charge = st.number_input(
+            "Electricity Demand Charge ($/kW-month)",
+            min_value=0.0,
+            max_value=50.0,
+            value=float(energy_rates["electricity"]["demand_charge"]),
+            step=1.0,
+            format="%.1f",
+            help="Monthly demand charge for peak electricity usage."
+        )
+        
+        electricity_carbon = st.number_input(
+            "Electricity Carbon Intensity (kg CO2e/kWh)",
+            min_value=0.0,
+            max_value=2.0,
+            value=float(energy_rates["electricity"]["carbon_intensity"]),
+            step=0.05,
+            format="%.2f",
+            help="Carbon emissions per kWh of electricity."
+        )
+    
+    with col2:
+        st.write("Natural Gas")
+        gas_rate = st.number_input(
+            "Natural Gas Rate ($/kWh)",
+            min_value=0.01,
+            max_value=0.5,
+            value=float(energy_rates["natural_gas"]["rate"]),
+            step=0.01,
+            format="%.2f",
+            help="Cost of natural gas per kWh equivalent."
+        )
+        
+        gas_demand_charge = st.number_input(
+            "Natural Gas Demand Charge ($/kW-month)",
+            min_value=0.0,
+            max_value=20.0,
+            value=float(energy_rates["natural_gas"]["demand_charge"]),
+            step=1.0,
+            format="%.1f",
+            help="Monthly demand charge for peak natural gas usage."
+        )
+        
+        gas_carbon = st.number_input(
+            "Natural Gas Carbon Intensity (kg CO2e/kWh)",
+            min_value=0.1,
+            max_value=1.0,
+            value=float(energy_rates["natural_gas"]["carbon_intensity"]),
+            step=0.05,
+            format="%.2f",
+            help="Carbon emissions per kWh equivalent of natural gas."
+        )
+    
+    # Update HVAC system data
+    hvac_system.update({
+        "cooling_cop": cooling_cop,
+        "heating_cop": heating_cop,
+        "fan_power_ratio": fan_power_ratio,
+        "pump_power_ratio": pump_power_ratio,
+        "cost_per_kw": cost_per_kw,
+        "lifespan_years": lifespan_years,
+        "maintenance_cost_ratio": maintenance_cost_ratio
+    })
+    
+    # Update energy rates
+    energy_rates["electricity"].update({
+        "rate": electricity_rate,
+        "demand_charge": electricity_demand_charge,
+        "carbon_intensity": electricity_carbon
+    })
+    
+    energy_rates["natural_gas"].update({
+        "rate": gas_rate,
+        "demand_charge": gas_demand_charge,
+        "carbon_intensity": gas_carbon
+    })
+    
+    # Calculate energy consumption button
+    if st.button("Calculate Energy Consumption", key="calculate_energy"):
+        try:
+            results = calculate_energy_consumption()
+            st.session_state.project_data["building_energy"]["results"] = results
+            st.success("Energy consumption calculated successfully.")
+            logger.info("Energy consumption calculated.")
+            st.rerun()  # Refresh to show results
+        except Exception as e:
+            st.error(f"Error calculating energy consumption: {e}")
+            logger.error(f"Error calculating energy consumption: {e}", exc_info=True)
+            st.session_state.project_data["building_energy"]["results"] = None
+
+def display_energy_consumption_tab():
+    """Display the energy consumption analysis tab."""
+    st.header("Energy Consumption Analysis")
+    
+    # Check if results are available
+    results = st.session_state.project_data["building_energy"].get("results")
+    if not results:
+        st.info("Please calculate energy consumption using the HVAC System tab.")
+        return
+    
+    # Display annual energy summary
+    st.subheader("Annual Energy Summary")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric(
+            "Total Annual Energy",
+            f"{results['annual_total_energy'] / 1000:.1f} MWh",
+            help="Total annual energy consumption for heating, cooling, and auxiliary systems."
+        )
+    
+    with col2:
+        st.metric(
+            "Energy Use Intensity",
+            f"{results['energy_use_intensity']:.1f} kWh/m²",
+            help="Annual energy consumption per square meter of floor area."
+        )
+    
+    with col3:
+        st.metric(
+            "Peak Demand",
+            f"{results['peak_demand'] / 1000:.2f} kW",
+            help="Maximum power demand throughout the year."
+        )
+    
+    # Display energy breakdown
+    st.subheader("Energy Consumption Breakdown")
+    
+    # Create pie chart of energy components
+    energy_components = {
+        "Cooling": results["annual_cooling_energy"],
+        "Heating": results["annual_heating_energy"],
+        "Fans": results["annual_fan_energy"],
+        "Pumps": results["annual_pump_energy"]
+    }
+    
+    fig_pie = px.pie(
+        values=list(energy_components.values()),
+        names=list(energy_components.keys()),
+        title="Annual Energy Consumption by Component"
+    )
+    st.plotly_chart(fig_pie, use_container_width=True)
+    
+    # Display monthly energy consumption
+    st.subheader("Monthly Energy Consumption")
+    
+    # Create bar chart of monthly energy
+    monthly_data = {
+        "Month": MONTHS,
+        "Cooling (kWh)": results["monthly_cooling_energy"],
+        "Heating (kWh)": results["monthly_heating_energy"],
+        "Fans (kWh)": results["monthly_fan_energy"],
+        "Pumps (kWh)": results["monthly_pump_energy"]
+    }
+    
+    monthly_df = pd.DataFrame(monthly_data)
+    
+    fig_monthly = px.bar(
+        monthly_df,
+        x="Month",
+        y=["Cooling (kWh)", "Heating (kWh)", "Fans (kWh)", "Pumps (kWh)"],
+        title="Monthly Energy Consumption by Component",
+        barmode="stack"
+    )
+    st.plotly_chart(fig_monthly, use_container_width=True)
+    
+    # Display hourly energy profile for a typical day
+    st.subheader("Hourly Energy Profile")
+    
+    # Allow user to select month for hourly profile
+    selected_month = st.selectbox(
+        "Select Month for Hourly Profile",
+        MONTHS,
+        index=6,  # Default to July
+        help="Select a month to view the typical daily energy profile."
+    )
+    
+    month_index = MONTHS.index(selected_month)
+    
+    # Get hourly data for the selected month
+    month_start_hour = sum(DAYS_IN_MONTH[:month_index]) * 24
+    month_hours = DAYS_IN_MONTH[month_index] * 24
+    
+    # Calculate average hourly profile for the month
+    hourly_profile = calculate_average_daily_profile(
+        results["hourly_total_energy"][month_start_hour:month_start_hour + month_hours],
+        DAYS_IN_MONTH[month_index]
+    )
+    
+    # Create hourly profile chart
+    fig_hourly = px.line(
+        x=list(range(24)),
+        y=hourly_profile,
+        title=f"Average Daily Energy Profile for {selected_month}",
+        labels={"x": "Hour of Day", "y": "Energy (kWh)"}
+    )
+    st.plotly_chart(fig_hourly, use_container_width=True)
+    
+    # Display load duration curve
+    st.subheader("Load Duration Curve")
+    
+    # Sort hourly energy from highest to lowest
+    load_duration = sorted(results["hourly_total_energy"], reverse=True)
+    
+    fig_duration = px.line(
+        x=list(range(1, HOURS_IN_YEAR + 1)),
+        y=load_duration,
+        title="Load Duration Curve",
+        labels={"x": "Hours", "y": "Energy (kWh)"}
+    )
+    fig_duration.update_xaxes(type="log")
+    st.plotly_chart(fig_duration, use_container_width=True)
+
+def display_energy_costs_tab():
+    """Display the energy costs analysis tab."""
+    st.header("Energy Cost Analysis")
+    
+    # Check if results are available
+    results = st.session_state.project_data["building_energy"].get("results")
+    if not results:
+        st.info("Please calculate energy consumption using the HVAC System tab.")
+        return
+    
+    # Display annual cost summary
+    st.subheader("Annual Cost Summary")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric(
+            "Total Annual Energy Cost",
+            f"${results['annual_energy_cost']:.0f}",
+            help="Total annual cost for all energy consumption."
+        )
+    
+    with col2:
+        st.metric(
+            "Energy Cost per Area",
+            f"${results['energy_cost_per_area']:.2f}/m²",
+            help="Annual energy cost per square meter of floor area."
+        )
+    
+    with col3:
+        st.metric(
+            "Average Energy Rate",
+            f"${results['average_energy_rate']:.3f}/kWh",
+            help="Average cost per kWh of energy consumed."
+        )
+    
+    # Display cost breakdown
+    st.subheader("Cost Breakdown")
+    
+    # Create pie chart of cost components
+    cost_components = {
+        "Electricity Consumption": results["annual_electricity_consumption_cost"],
+        "Electricity Demand": results["annual_electricity_demand_cost"],
+        "Natural Gas Consumption": results["annual_gas_consumption_cost"],
+        "Natural Gas Demand": results["annual_gas_demand_cost"]
+    }
+    
+    fig_cost_pie = px.pie(
+        values=list(cost_components.values()),
+        names=list(cost_components.keys()),
+        title="Annual Energy Cost Breakdown"
+    )
+    st.plotly_chart(fig_cost_pie, use_container_width=True)
+    
+    # Display monthly energy costs
+    st.subheader("Monthly Energy Costs")
+    
+    # Create bar chart of monthly costs
+    monthly_cost_data = {
+        "Month": MONTHS,
+        "Electricity Consumption": results["monthly_electricity_consumption_cost"],
+        "Electricity Demand": results["monthly_electricity_demand_cost"],
+        "Natural Gas Consumption": results["monthly_gas_consumption_cost"],
+        "Natural Gas Demand": results["monthly_gas_demand_cost"]
+    }
+    
+    monthly_cost_df = pd.DataFrame(monthly_cost_data)
+    
+    fig_monthly_cost = px.bar(
+        monthly_cost_df,
+        x="Month",
+        y=["Electricity Consumption", "Electricity Demand", "Natural Gas Consumption", "Natural Gas Demand"],
+        title="Monthly Energy Costs by Component",
+        barmode="stack"
+    )
+    st.plotly_chart(fig_monthly_cost, use_container_width=True)
+    
+    # Display lifecycle cost analysis
+    st.subheader("Lifecycle Cost Analysis")
+    
+    # Get HVAC system data
+    hvac_system = st.session_state.project_data["building_energy"]["hvac_system"]
+    
+    # Calculate lifecycle costs
+    lifecycle_years = 30  # Standard lifecycle analysis period
+    
+    # Initial cost
+    peak_load = max(
+        results["peak_cooling_load"],
+        results["peak_heating_load"]
+    )
+    initial_cost = peak_load * hvac_system["cost_per_kw"]
+    
+    # Replacement costs
+    num_replacements = lifecycle_years // hvac_system["lifespan_years"]
+    replacement_cost = initial_cost * num_replacements
+    
+    # Maintenance costs
+    annual_maintenance = initial_cost * hvac_system["maintenance_cost_ratio"]
+    total_maintenance = annual_maintenance * lifecycle_years
+    
+    # Energy costs
+    total_energy_cost = results["annual_energy_cost"] * lifecycle_years
+    
+    # Total lifecycle cost
+    total_lifecycle_cost = initial_cost + replacement_cost + total_maintenance + total_energy_cost
+    
+    # Create lifecycle cost breakdown
+    lifecycle_components = {
+        "Initial Installation": initial_cost,
+        "Replacement": replacement_cost,
+        "Maintenance": total_maintenance,
+        "Energy": total_energy_cost
+    }
+    
+    fig_lifecycle = px.pie(
+        values=list(lifecycle_components.values()),
+        names=list(lifecycle_components.keys()),
+        title=f"{lifecycle_years}-Year Lifecycle Cost Breakdown"
+    )
+    st.plotly_chart(fig_lifecycle, use_container_width=True)
+    
+    # Display lifecycle cost summary
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Total Lifecycle Cost",
+            f"${total_lifecycle_cost:.0f}",
+            help=f"Total cost over {lifecycle_years} years including installation, replacement, maintenance, and energy."
+        )
+    
+    with col2:
+        st.metric(
+            "Annualized Cost",
+            f"${total_lifecycle_cost / lifecycle_years:.0f}/year",
+            help=f"Average annual cost over {lifecycle_years} years."
+        )
+
+def display_carbon_emissions_tab():
+    """Display the carbon emissions analysis tab."""
+    st.header("Carbon Emissions Analysis")
+    
+    # Check if results are available
+    results = st.session_state.project_data["building_energy"].get("results")
+    if not results:
+        st.info("Please calculate energy consumption using the HVAC System tab.")
+        return
+    
+    # Display annual emissions summary
+    st.subheader("Annual Emissions Summary")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Total Annual Emissions",
+            f"{results['annual_carbon_emissions']:.1f} tonnes CO2e",
+            help="Total annual carbon emissions from all energy consumption."
+        )
+    
+    with col2:
+        st.metric(
+            "Emissions Intensity",
+            f"{results['carbon_emissions_intensity']:.1f} kg CO2e/m²",
+            help="Annual carbon emissions per square meter of floor area."
+        )
+    
+    # Display emissions breakdown
+    st.subheader("Emissions Breakdown")
+    
+    # Create pie chart of emissions sources
+    emissions_components = {
+        "Electricity": results["annual_electricity_emissions"],
+        "Natural Gas": results["annual_gas_emissions"]
+    }
+    
+    fig_emissions_pie = px.pie(
+        values=list(emissions_components.values()),
+        names=list(emissions_components.keys()),
+        title="Annual Carbon Emissions by Source"
+    )
+    st.plotly_chart(fig_emissions_pie, use_container_width=True)
+    
+    # Display monthly emissions
+    st.subheader("Monthly Carbon Emissions")
+    
+    # Create bar chart of monthly emissions
+    monthly_emissions_data = {
+        "Month": MONTHS,
+        "Electricity Emissions": results["monthly_electricity_emissions"],
+        "Natural Gas Emissions": results["monthly_gas_emissions"]
+    }
+    
+    monthly_emissions_df = pd.DataFrame(monthly_emissions_data)
+    
+    fig_monthly_emissions = px.bar(
+        monthly_emissions_df,
+        x="Month",
+        y=["Electricity Emissions", "Natural Gas Emissions"],
+        title="Monthly Carbon Emissions by Source",
+        barmode="stack"
+    )
+    st.plotly_chart(fig_monthly_emissions, use_container_width=True)
+    
+    # Display emissions benchmark comparison
+    st.subheader("Emissions Benchmark Comparison")
+    
+    # Define benchmark emissions intensities (kg CO2e/m²/year)
+    benchmarks = {
+        "This Building": results["carbon_emissions_intensity"],
+        "Low Energy Building": 15.0,
+        "Average Building": 50.0,
+        "High Energy Building": 100.0
+    }
+    
+    # Create benchmark comparison chart
+    fig_benchmark = px.bar(
+        x=list(benchmarks.keys()),
+        y=list(benchmarks.values()),
+        title="Carbon Emissions Intensity Comparison",
+        labels={"x": "Building Type", "y": "Emissions Intensity (kg CO2e/m²/year)"}
+    )
+    st.plotly_chart(fig_benchmark, use_container_width=True)
+    
+    # Display emissions reduction potential
+    st.subheader("Emissions Reduction Potential")
+    
+    # Calculate potential reductions
+    potential_reductions = {
+        "Current Emissions": results["annual_carbon_emissions"],
+        "With 25% More Efficient HVAC": results["annual_carbon_emissions"] * 0.75,
+        "With 50% Renewable Electricity": results["annual_carbon_emissions"] - (results["annual_electricity_emissions"] * 0.5),
+        "With Both Measures": results["annual_carbon_emissions"] * 0.75 - (results["annual_electricity_emissions"] * 0.5 * 0.75)
+    }
+    
+    # Create reduction potential chart
+    fig_reduction = px.bar(
+        x=list(potential_reductions.keys()),
+        y=list(potential_reductions.values()),
+        title="Carbon Emissions Reduction Potential",
+        labels={"x": "Scenario", "y": "Annual Emissions (tonnes CO2e)"}
+    )
+    st.plotly_chart(fig_reduction, use_container_width=True)
+
+def calculate_energy_consumption() -> Dict[str, Any]:
+    """
+    Calculate building energy consumption based on HVAC loads and system parameters.
+    
+    Returns:
+        Dictionary containing energy consumption results.
+    """
+    logger.info("Starting energy consumption calculations...")
+    
+    # Get required data
+    hvac_loads = st.session_state.project_data["hvac_loads"]
+    building_info = st.session_state.project_data["building_info"]
+    hvac_system = st.session_state.project_data["building_energy"]["hvac_system"]
+    energy_rates = st.session_state.project_data["building_energy"]["energy_rates"]
+    
+    # Get hourly load data
+    hourly_cooling_sensible = np.array(hvac_loads["hourly_cooling_sensible"])
+    hourly_cooling_latent = np.array(hvac_loads["hourly_cooling_latent"])
+    hourly_cooling_total = np.array(hvac_loads["hourly_cooling_total"])
+    hourly_heating = np.array(hvac_loads["hourly_heating"])
+    
+    # Get system parameters
+    cooling_cop = hvac_system["cooling_cop"]
+    heating_cop = hvac_system["heating_cop"]
+    fan_power_ratio = hvac_system["fan_power_ratio"]
+    pump_power_ratio = hvac_system["pump_power_ratio"]
+    
+    # Calculate peak loads (W)
+    peak_cooling_load = hvac_loads["peak_cooling_total"]
+    peak_heating_load = hvac_loads["peak_heating"]
+    
+    # Calculate hourly energy consumption (kWh)
+    # Convert from W to kWh by dividing by 1000
+    hourly_cooling_energy = hourly_cooling_total / cooling_cop / 1000
+    hourly_heating_energy = hourly_heating / heating_cop / 1000
+    
+    # Calculate fan and pump energy
+    # Fans run whenever there's heating or cooling
+    hourly_fan_energy = (
+        (hourly_cooling_total + hourly_heating) * fan_power_ratio / 1000
+    )
+    
+    # Pumps run primarily for cooling, but also for some heating systems
+    hourly_pump_energy = (
+        hourly_cooling_total * pump_power_ratio / 1000 +
+        hourly_heating * pump_power_ratio * 0.5 / 1000  # Assume 50% pump usage for heating
+    )
+    
+    # Calculate total hourly energy
+    hourly_total_energy = (
+        hourly_cooling_energy +
+        hourly_heating_energy +
+        hourly_fan_energy +
+        hourly_pump_energy
+    )
+    
+    # Calculate monthly energy consumption
+    monthly_cooling_energy = calculate_monthly_totals(hourly_cooling_energy)
+    monthly_heating_energy = calculate_monthly_totals(hourly_heating_energy)
+    monthly_fan_energy = calculate_monthly_totals(hourly_fan_energy)
+    monthly_pump_energy = calculate_monthly_totals(hourly_pump_energy)
+    monthly_total_energy = calculate_monthly_totals(hourly_total_energy)
+    
+    # Calculate annual energy consumption
+    annual_cooling_energy = sum(monthly_cooling_energy)
+    annual_heating_energy = sum(monthly_heating_energy)
+    annual_fan_energy = sum(monthly_fan_energy)
+    annual_pump_energy = sum(monthly_pump_energy)
+    annual_total_energy = sum(monthly_total_energy)
+    
+    # Calculate energy use intensity (kWh/m²)
+    floor_area = building_info["floor_area"]
+    energy_use_intensity = annual_total_energy / floor_area
+    
+    # Calculate peak demand (kW)
+    peak_demand = max(hourly_total_energy)
+    
+    # Calculate energy costs
+    # Determine energy source for heating (electricity or gas)
+    is_electric_heating = hvac_system["system_type"] not in ["Chiller with Gas Boiler"]
+    
+    # Calculate electricity and gas consumption
+    if is_electric_heating:
+        # All electric system
+        hourly_electricity = hourly_total_energy
+        hourly_gas = np.zeros(HOURS_IN_YEAR)
+    else:
+        # Gas heating, electric cooling
+        hourly_electricity = (
+            hourly_cooling_energy +
+            hourly_fan_energy +
+            hourly_pump_energy
+        )
+        hourly_gas = hourly_heating_energy
+    
+    # Calculate monthly electricity and gas consumption
+    monthly_electricity = calculate_monthly_totals(hourly_electricity)
+    monthly_gas = calculate_monthly_totals(hourly_gas)
+    
+    # Calculate annual electricity and gas consumption
+    annual_electricity = sum(monthly_electricity)
+    annual_gas = sum(monthly_gas)
+    
+    # Calculate monthly peak demand
+    monthly_electricity_peak = calculate_monthly_peaks(hourly_electricity)
+    monthly_gas_peak = calculate_monthly_peaks(hourly_gas)
+    
+    # Calculate energy costs
+    # Consumption costs
+    monthly_electricity_consumption_cost = [
+        monthly_electricity[i] * energy_rates["electricity"]["rate"]
+        for i in range(12)
+    ]
+    
+    monthly_gas_consumption_cost = [
+        monthly_gas[i] * energy_rates["natural_gas"]["rate"]
+        for i in range(12)
+    ]
+    
+    # Demand costs
+    monthly_electricity_demand_cost = [
+        monthly_electricity_peak[i] * energy_rates["electricity"]["demand_charge"]
+        for i in range(12)
+    ]
+    
+    monthly_gas_demand_cost = [
+        monthly_gas_peak[i] * energy_rates["natural_gas"]["demand_charge"]
+        for i in range(12)
+    ]
+    
+    # Total monthly costs
+    monthly_total_cost = [
+        monthly_electricity_consumption_cost[i] +
+        monthly_electricity_demand_cost[i] +
+        monthly_gas_consumption_cost[i] +
+        monthly_gas_demand_cost[i]
+        for i in range(12)
+    ]
+    
+    # Annual costs
+    annual_electricity_consumption_cost = sum(monthly_electricity_consumption_cost)
+    annual_electricity_demand_cost = sum(monthly_electricity_demand_cost)
+    annual_gas_consumption_cost = sum(monthly_gas_consumption_cost)
+    annual_gas_demand_cost = sum(monthly_gas_demand_cost)
+    annual_energy_cost = sum(monthly_total_cost)
+    
+    # Calculate cost metrics
+    energy_cost_per_area = annual_energy_cost / floor_area
+    average_energy_rate = annual_energy_cost / annual_total_energy if annual_total_energy > 0 else 0
+    
+    # Calculate carbon emissions
+    # Monthly emissions
+    monthly_electricity_emissions = [
+        monthly_electricity[i] * energy_rates["electricity"]["carbon_intensity"]
+        for i in range(12)
+    ]
+    
+    monthly_gas_emissions = [
+        monthly_gas[i] * energy_rates["natural_gas"]["carbon_intensity"]
+        for i in range(12)
+    ]
+    
+    monthly_total_emissions = [
+        monthly_electricity_emissions[i] + monthly_gas_emissions[i]
+        for i in range(12)
+    ]
+    
+    # Annual emissions
+    annual_electricity_emissions = sum(monthly_electricity_emissions)
+    annual_gas_emissions = sum(monthly_gas_emissions)
+    annual_carbon_emissions = annual_electricity_emissions + annual_gas_emissions
+    
+    # Convert from kg to tonnes
+    annual_carbon_emissions /= 1000
+    annual_electricity_emissions /= 1000
+    annual_gas_emissions /= 1000
+    
+    # Calculate emissions intensity
+    carbon_emissions_intensity = annual_carbon_emissions * 1000 / floor_area  # kg CO2e/m²
+    
+    # Compile results
+    results = {
+        # Energy consumption
+        "hourly_cooling_energy": hourly_cooling_energy.tolist(),
+        "hourly_heating_energy": hourly_heating_energy.tolist(),
+        "hourly_fan_energy": hourly_fan_energy.tolist(),
+        "hourly_pump_energy": hourly_pump_energy.tolist(),
+        "hourly_total_energy": hourly_total_energy.tolist(),
+        "hourly_electricity": hourly_electricity.tolist(),
+        "hourly_gas": hourly_gas.tolist(),
+        
+        "monthly_cooling_energy": monthly_cooling_energy,
+        "monthly_heating_energy": monthly_heating_energy,
+        "monthly_fan_energy": monthly_fan_energy,
+        "monthly_pump_energy": monthly_pump_energy,
+        "monthly_total_energy": monthly_total_energy,
+        "monthly_electricity": monthly_electricity,
+        "monthly_gas": monthly_gas,
+        "monthly_electricity_peak": monthly_electricity_peak,
+        "monthly_gas_peak": monthly_gas_peak,
+        
+        "annual_cooling_energy": annual_cooling_energy,
+        "annual_heating_energy": annual_heating_energy,
+        "annual_fan_energy": annual_fan_energy,
+        "annual_pump_energy": annual_pump_energy,
+        "annual_total_energy": annual_total_energy,
+        "annual_electricity": annual_electricity,
+        "annual_gas": annual_gas,
+        
+        "energy_use_intensity": energy_use_intensity,
+        "peak_demand": peak_demand,
+        "peak_cooling_load": peak_cooling_load,
+        "peak_heating_load": peak_heating_load,
+        
+        # Energy costs
+        "monthly_electricity_consumption_cost": monthly_electricity_consumption_cost,
+        "monthly_electricity_demand_cost": monthly_electricity_demand_cost,
+        "monthly_gas_consumption_cost": monthly_gas_consumption_cost,
+        "monthly_gas_demand_cost": monthly_gas_demand_cost,
+        "monthly_total_cost": monthly_total_cost,
+        
+        "annual_electricity_consumption_cost": annual_electricity_consumption_cost,
+        "annual_electricity_demand_cost": annual_electricity_demand_cost,
+        "annual_gas_consumption_cost": annual_gas_consumption_cost,
+        "annual_gas_demand_cost": annual_gas_demand_cost,
+        "annual_energy_cost": annual_energy_cost,
+        
+        "energy_cost_per_area": energy_cost_per_area,
+        "average_energy_rate": average_energy_rate,
+        
+        # Carbon emissions
+        "monthly_electricity_emissions": monthly_electricity_emissions,
+        "monthly_gas_emissions": monthly_gas_emissions,
+        "monthly_total_emissions": monthly_total_emissions,
+        
+        "annual_electricity_emissions": annual_electricity_emissions,
+        "annual_gas_emissions": annual_gas_emissions,
+        "annual_carbon_emissions": annual_carbon_emissions,
+        
+        "carbon_emissions_intensity": carbon_emissions_intensity,
+        
+        # Calculation timestamp
+        "calculation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    logger.info("Energy consumption calculations completed.")
+    return results
+
+def calculate_monthly_totals(hourly_data: np.ndarray) -> List[float]:
+    """
+    Calculate monthly totals from hourly data.
+    
+    Args:
+        hourly_data: Numpy array of hourly values
+        
+    Returns:
+        List of monthly totals
+    """
+    monthly_totals = []
+    hour_index = 0
+    
+    for days in DAYS_IN_MONTH:
+        hours_in_month = days * 24
+        month_total = sum(hourly_data[hour_index:hour_index + hours_in_month])
+        monthly_totals.append(month_total)
+        hour_index += hours_in_month
+    
+    return monthly_totals
+
+def calculate_monthly_peaks(hourly_data: np.ndarray) -> List[float]:
+    """
+    Calculate monthly peak values from hourly data.
+    
+    Args:
+        hourly_data: Numpy array of hourly values
+        
+    Returns:
+        List of monthly peak values
+    """
+    monthly_peaks = []
+    hour_index = 0
+    
+    for days in DAYS_IN_MONTH:
+        hours_in_month = days * 24
+        month_data = hourly_data[hour_index:hour_index + hours_in_month]
+        monthly_peaks.append(max(month_data) if len(month_data) > 0 else 0)
+        hour_index += hours_in_month
+    
+    return monthly_peaks
+
+def calculate_average_daily_profile(hourly_data: np.ndarray, days: int) -> List[float]:
+    """
+    Calculate average daily profile from hourly data for a month.
+    
+    Args:
+        hourly_data: Numpy array of hourly values for the month
+        days: Number of days in the month
+        
+    Returns:
+        List of 24 hourly average values
+    """
+    daily_profile = [0.0] * 24
+    
+    for hour in range(len(hourly_data)):
+        hour_of_day = hour % 24
+        daily_profile[hour_of_day] += hourly_data[hour]
+    
+    # Calculate averages
+    for i in range(24):
+        daily_profile[i] /= days
+    
+    return daily_profile
+
+def display_building_energy_help():
+    """
+    Display help information for the building energy page.
+    """
+    st.markdown("""
+    ### Building Energy Consumption Help
+    
+    This section calculates the building's energy consumption, costs, and carbon emissions based on the HVAC loads and system parameters.
+    
+    **Key Concepts:**
+    
+    * **COP (Coefficient of Performance)**: Ratio of useful heating or cooling provided to energy input. Higher values indicate better efficiency.
+    * **Energy Use Intensity (EUI)**: Annual energy consumption per unit floor area (kWh/m²).
+    * **Peak Demand**: Maximum power required at any point during the year.
+    * **Demand Charges**: Utility charges based on peak power demand, typically monthly.
+    * **Carbon Emissions**: Greenhouse gas emissions associated with energy consumption.
+    
+    **Workflow:**
+    
+    1. **HVAC System Tab**:
+        * Select the type of HVAC system for your building.
+        * Adjust system performance parameters (COP, fan power, etc.).
+        * Set energy rates and carbon intensities.
+        * Click "Calculate Energy Consumption" to perform the analysis.
+    
+    2. **Energy Consumption Tab**:
+        * Review annual and monthly energy consumption.
+        * Examine energy breakdown by component.
+        * Analyze hourly energy profiles and load duration curve.
+    
+    3. **Energy Costs Tab**:
+        * Review annual and monthly energy costs.
+        * Examine cost breakdown by component.
+        * Analyze lifecycle cost including installation, maintenance, and energy.
+    
+    4. **Carbon Emissions Tab**:
+        * Review annual and monthly carbon emissions.
+        * Compare emissions to benchmarks.
+        * Explore emissions reduction potential.
+    
+    **Important:**
+    
+    * Energy calculations are based on the HVAC loads calculated in the previous section.
+    * System efficiency has a major impact on energy consumption and costs.
+    * Consider both initial costs and lifecycle costs when evaluating systems.
+    * Carbon emissions vary significantly based on the energy source and local grid mix.
+    """)

app/building_information.py

@@ -0,0 +1,328 @@
+"""
+HVAC Load Calculator - Building Information Module
+
+This module handles the building information input page of the HVAC Load Calculator application,
+allowing users to define basic building parameters such as project name, floor area, building height,
+indoor design conditions, orientation, and building type.
+
+Developed by: Dr Majed Abuseif, Deakin University
+© 2025
+"""
+
+import streamlit as st
+import logging
+import math
+from typing import Dict, Any, Optional, List, Tuple
+from data.internal_loads import BUILDING_TYPES
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+def display_building_info_page():
+    """
+    Display the building information input page.
+    This is the main function called by main.py when the Building Information page is selected.
+    """
+    st.title("Building Information")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_building_info_help()
+    
+    # Create the main form for building information input
+    with st.form("building_info_form"):
+        # Get current values from session state or use defaults
+        current_values = st.session_state.project_data["building_info"]
+        
+        # Project Name
+        project_name = st.text_input(
+            "Project Name",
+            value=current_values["project_name"],
+            help="Enter a unique identifier for your project."
+        )
+        
+        # Create two columns for layout
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Floor Area
+            floor_area = st.number_input(
+                "Floor Area (square meters)",
+                min_value=1.0,
+                max_value=100000.0,
+                value=float(current_values["floor_area"]),
+                step=10.0,
+                format="%.1f",
+                help="Total conditioned floor area of the building in square meters."
+            )
+            
+            # Building Height
+            building_height = st.number_input(
+                "Building Height (meters)",
+                min_value=2.0,
+                max_value=100.0,
+                value=float(current_values["building_height"]),
+                step=0.1,
+                format="%.1f",
+                help="Average ceiling height of the building in meters."
+            )
+            
+            # Building Type
+            building_type = st.selectbox(
+                "Building Type",
+                options=BUILDING_TYPES,
+                index=BUILDING_TYPES.index(current_values["building_type"]) if current_values["building_type"] in BUILDING_TYPES else 0,
+                help="Primary use of the building, which affects default internal loads and ventilation rates."
+            )
+        
+        with col2:
+            # Indoor Design Temperature
+            indoor_design_temp = st.number_input(
+                "Indoor Design Temperature (°C)",
+                min_value=15.0,
+                max_value=30.0,
+                value=float(current_values["indoor_design_temp"]),
+                step=0.5,
+                format="%.1f",
+                help="Target indoor temperature for cooling season comfort (15–30°C)."
+            )
+            
+            # Indoor Design Relative Humidity
+            indoor_design_rh = st.number_input(
+                "Indoor Design Relative Humidity (%)",
+                min_value=20.0,
+                max_value=80.0,
+                value=float(current_values["indoor_design_rh"]),
+                step=5.0,
+                format="%.1f",
+                help="Target indoor relative humidity for comfort (20–80%)."
+            )
+            
+            # Ventilation Rate
+            ventilation_rate = st.number_input(
+                "Ventilation Rate (L/s/m²)",
+                min_value=0.0,
+                max_value=10.0,
+                value=float(current_values["ventilation_rate"]),
+                step=0.1,
+                format="%.2f",
+                help="Fresh air ventilation rate in liters per second per square meter."
+            )
+        
+        # Building Orientation
+        st.subheader("Building Orientation")
+        
+        # Display orientation diagram
+        display_orientation_diagram()
+        
+        orientation_angle = st.slider(
+            "Orientation Angle (°)",
+            min_value=-180,
+            max_value=180,
+            value=int(current_values["orientation_angle"]),
+            step=5,
+            help="Sets the building's rotation angle relative to north (0°). Component orientations are defined as A (North), B (South), C (East), D (West) at 0°. Adjusting this angle rotates all component orientations accordingly."
+        )
+        
+        # Operation Hours
+        operation_hours = st.slider(
+            "Operation Hours (hours/day)",
+            min_value=0,
+            max_value=24,
+            value=int(current_values["operation_hours"]),
+            step=1,
+            help="Daily hours the building is occupied or operational, affecting internal loads (0–24 hours)."
+        )
+        
+        # Form submission button
+        submit_button = st.form_submit_button("Save Building Information")
+        
+        if submit_button:
+            # Validate inputs
+            validation_errors = validate_building_info(
+                project_name, floor_area, building_height, building_type,
+                indoor_design_temp, indoor_design_rh, ventilation_rate,
+                orientation_angle, operation_hours
+            )
+            
+            if validation_errors:
+                # Display validation errors
+                for error in validation_errors:
+                    st.error(error)
+            else:
+                # Update session state with validated inputs
+                st.session_state.project_data["project_name"] = project_name
+                st.session_state.project_data["building_info"].update({
+                    "project_name": project_name,
+                    "floor_area": floor_area,
+                    "building_height": building_height,
+                    "building_type": building_type,
+                    "indoor_design_temp": indoor_design_temp,
+                    "indoor_design_rh": indoor_design_rh,
+                    "ventilation_rate": ventilation_rate,
+                    "orientation_angle": float(orientation_angle),
+                    "operation_hours": operation_hours
+                })
+                
+                # Log the update
+                logger.info(f"Building information updated for project: {project_name}")
+                
+                # Show success message
+                st.success("Building information saved successfully!")
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Intro", key="back_to_intro"):
+            st.session_state.current_page = "Intro"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Climate Data", key="continue_to_climate"):
+            # Check if required fields are filled before proceeding
+            if not st.session_state.project_data["building_info"]["project_name"]:
+                st.error("Please enter a project name before continuing.")
+            else:
+                st.session_state.current_page = "Climate Data"
+                st.rerun()
+
+def validate_building_info(
+    project_name: str, 
+    floor_area: float, 
+    building_height: float, 
+    building_type: str,
+    indoor_design_temp: float, 
+    indoor_design_rh: float, 
+    ventilation_rate: float,
+    orientation_angle: int, 
+    operation_hours: int
+) -> List[str]:
+    """
+    Validate building information inputs.
+    
+    Args:
+        project_name: Project name
+        floor_area: Floor area in square meters
+        building_height: Building height in meters
+        building_type: Building type
+        indoor_design_temp: Indoor design temperature in °C
+        indoor_design_rh: Indoor design relative humidity in %
+        ventilation_rate: Ventilation rate in L/s/m²
+        orientation_angle: Building orientation angle in degrees
+        operation_hours: Building operation hours per day
+        
+    Returns:
+        List of validation error messages, empty if all inputs are valid
+    """
+    errors = []
+    
+    # Validate project name
+    if not project_name or project_name.strip() == "":
+        errors.append("Project name is required.")
+    
+    # Validate floor area
+    if floor_area <= 0:
+        errors.append("Floor area must be greater than zero.")
+    elif floor_area > 100000:
+        errors.append("Floor area exceeds maximum value (100,000 m²).")
+    
+    # Validate building height
+    if building_height < 2.0:
+        errors.append("Building height must be at least 2.0 meters.")
+    elif building_height > 100.0:
+        errors.append("Building height exceeds maximum value (100 meters).")
+    
+    # Validate building type
+    if building_type not in BUILDING_TYPES:
+        errors.append("Please select a valid building type.")
+    
+    # Validate indoor design temperature
+    if indoor_design_temp < 15.0 or indoor_design_temp > 30.0:
+        errors.append("Indoor design temperature must be between 15°C and 30°C.")
+    
+    # Validate indoor design relative humidity
+    if indoor_design_rh < 20.0 or indoor_design_rh > 80.0:
+        errors.append("Indoor design relative humidity must be between 20% and 80%.")
+    
+    # Validate ventilation rate
+    if ventilation_rate < 0.0:
+        errors.append("Ventilation rate cannot be negative.")
+    elif ventilation_rate > 10.0:
+        errors.append("Ventilation rate exceeds maximum value (10 L/s/m²).")
+    
+    # Validate orientation angle
+    if orientation_angle < -180 or orientation_angle > 180:
+        errors.append("Orientation angle must be between -180° and 180°.")
+    
+    # Validate operation hours
+    if operation_hours < 0 or operation_hours > 24:
+        errors.append("Operation hours must be between 0 and 24.")
+    
+    return errors
+
+def display_building_info_help():
+    """Display help information for the building information page."""
+    st.markdown("""
+    ### Building Information Help
+    
+    This section collects basic information about your building project. The inputs provided here will be used throughout the calculation process.
+    
+    **Key Parameters:**
+    
+    * **Project Name**: A unique identifier for your project.
+    * **Floor Area**: The total conditioned floor area of the building in square meters.
+    * **Building Height**: The average ceiling height of the building in meters.
+    * **Building Type**: The primary use of the building, which affects default internal loads and ventilation rates.
+    * **Indoor Design Temperature**: The target indoor temperature for cooling season comfort (typically 22-26°C).
+    * **Indoor Design Relative Humidity**: The target indoor relative humidity for comfort (typically 40-60%).
+    * **Ventilation Rate**: The fresh air ventilation rate in liters per second per square meter.
+    * **Orientation Angle**: The building's rotation angle relative to north (0°).
+    * **Operation Hours**: Daily hours the building is occupied or operational, affecting internal loads.
+    
+    **Building Orientation:**
+    
+    The orientation angle rotates the entire building relative to true north. At 0°, the building facades are aligned with the cardinal directions:
+    * Facade A: North (0°)
+    * Facade B: South (180°)
+    * Facade C: East (90°)
+    * Facade D: West (270°)
+    
+    Adjusting the orientation angle will rotate all facades accordingly.
+    """)
+
+def display_orientation_diagram():
+    """Display a simple ASCII diagram showing building orientation."""
+    orientation_diagram = """
+                North (0°)
+                    ^
+                    |
+                    |
+    West (270°) <---+---> East (90°)
+                    |
+                    |
+                    v
+                South (180°)
+    
+    Facades at 0° orientation:
+    - Facade A: North (0°)
+    - Facade B: South (180°)
+    - Facade C: East (90°)
+    - Facade D: West (270°)
+    """
+    
+    st.text(orientation_diagram)
+
+def calculate_volume(floor_area: float, height: float) -> float:
+    """
+    Calculate the building volume.
+    
+    Args:
+        floor_area: Floor area in square meters
+        height: Building height in meters
+        
+    Returns:
+        Building volume in cubic meters
+    """
+    return floor_area * height

app/climate_data.py

@@ -0,0 +1,548 @@
+"""
+HVAC Load Calculator - Climate Data Module
+
+This module handles the climate data selection, EPW file processing, and display of climate information
+for the HVAC Load Calculator application. It allows users to upload EPW weather files and extracts
+relevant climate data for use in load calculations.
+
+Developed by: Dr Majed Abuseif, Deakin University
+© 2025
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import os
+import json
+import io
+import logging
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Tuple, Union
+import math
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Define constants
+MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+CLIMATE_ZONES = ["0A", "0B", "1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"]
+
+class ClimateDataManager:
+    """Class for managing climate data from EPW files."""
+    
+    def __init__(self):
+        """Initialize climate data manager."""
+        pass
+    
+    def load_epw(self, uploaded_file) -> Dict[str, Any]:
+        """
+        Parse an EPW file and extract climate data.
+        
+        Args:
+            uploaded_file: The uploaded EPW file object
+            
+        Returns:
+            Dict containing parsed climate data
+        """
+        try:
+            # Read the EPW file
+            content = uploaded_file.getvalue().decode('utf-8')
+            lines = content.split('\n')
+            
+            # Extract header information (first 8 lines)
+            header_lines = lines[:8]
+            
+            # Parse location data from line 1
+            location_data = header_lines[0].split(',')
+            
+            # Extract location information
+            location = {
+                "city": location_data[1].strip(),
+                "state_province": location_data[2].strip(),
+                "country": location_data[3].strip(),
+                "source": location_data[4].strip(),
+                "wmo": location_data[5].strip(),
+                "latitude": float(location_data[6]),
+                "longitude": float(location_data[7]),
+                "timezone": float(location_data[8]),
+                "elevation": float(location_data[9])
+            }
+            
+            # Parse data rows (starting from line 9)
+            data_lines = lines[8:]
+            
+            # Create a DataFrame from the data rows
+            data = []
+            for line in data_lines:
+                if line.strip():  # Skip empty lines
+                    data.append(line.split(','))
+            
+            # Create DataFrame
+            columns = [
+                "year", "month", "day", "hour", "minute", "data_source", "dry_bulb_temp",
+                "dew_point_temp", "relative_humidity", "atmospheric_pressure", "extraterrestrial_radiation",
+                "extraterrestrial_radiation_normal", "horizontal_infrared_radiation", "global_horizontal_radiation",
+                "direct_normal_radiation", "diffuse_horizontal_radiation", "global_horizontal_illuminance",
+                "direct_normal_illuminance", "diffuse_horizontal_illuminance", "zenith_luminance",
+                "wind_direction", "wind_speed", "total_sky_cover", "opaque_sky_cover", "visibility",
+                "ceiling_height", "present_weather_observation", "present_weather_codes",
+                "precipitable_water", "aerosol_optical_depth", "snow_depth", "days_since_last_snowfall",
+                "albedo", "liquid_precipitation_depth", "liquid_precipitation_quantity"
+            ]
+            
+            df = pd.DataFrame(data, columns=columns)
+            
+            # Convert numeric columns
+            numeric_columns = [
+                "dry_bulb_temp", "dew_point_temp", "relative_humidity", "atmospheric_pressure",
+                "global_horizontal_radiation", "direct_normal_radiation", "diffuse_horizontal_radiation",
+                "wind_direction", "wind_speed"
+            ]
+            
+            for col in numeric_columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+            
+            # Calculate design conditions
+            design_conditions = self._calculate_design_conditions(df)
+            
+            # Process hourly data
+            hourly_data = self._process_hourly_data(df)
+            
+            # Determine climate zone based on HDD and CDD
+            climate_zone = self._determine_climate_zone(
+                design_conditions["heating_degree_days"],
+                design_conditions["cooling_degree_days"]
+            )
+            
+            # Create climate data dictionary
+            climate_data = {
+                "id": f"{location['city']}_{location['country']}".replace(" ", "_"),
+                "location": location,
+                "design_conditions": design_conditions,
+                "climate_zone": climate_zone,
+                "hourly_data": hourly_data,
+                "epw_filename": uploaded_file.name
+            }
+            
+            logger.info(f"EPW file processed successfully: {uploaded_file.name}")
+            return climate_data
+            
+        except Exception as e:
+            logger.error(f"Error processing EPW file: {str(e)}")
+            raise ValueError(f"Error processing EPW file: {str(e)}")
+    
+    def _calculate_design_conditions(self, df: pd.DataFrame) -> Dict[str, Any]:
+        """
+        Calculate design conditions from EPW data.
+        
+        Args:
+            df: DataFrame containing EPW data
+            
+        Returns:
+            Dict containing design conditions
+        """
+        try:
+            # Convert temperatures from C to K if needed
+            temp_col = df["dry_bulb_temp"].astype(float)
+            
+            # Calculate design temperatures
+            winter_design_temp = np.percentile(temp_col, 0.4)  # 99.6% heating design temperature
+            summer_design_temp_db = np.percentile(temp_col, 99.6)  # 0.4% cooling design temperature
+            
+            # Calculate wet-bulb temperature (simplified)
+            rh_col = df["relative_humidity"].astype(float)
+            wet_bulb_temp = self._calculate_wet_bulb(temp_col, rh_col)
+            summer_design_temp_wb = np.percentile(wet_bulb_temp, 99.6)  # 0.4% cooling wet-bulb temperature
+            
+            # Calculate degree days
+            df["month"] = df["month"].astype(int)
+            df["day"] = df["day"].astype(int)
+            df["hour"] = df["hour"].astype(int)
+            
+            # Group by day and calculate average temperature
+            df["date"] = pd.to_datetime(df[["year", "month", "day"]].astype(int))
+            daily_temps = df.groupby("date")["dry_bulb_temp"].mean()
+            
+            # Calculate heating and cooling degree days (base 18°C)
+            heating_degree_days = sum(max(0, 18 - temp) for temp in daily_temps)
+            cooling_degree_days = sum(max(0, temp - 18) for temp in daily_temps)
+            
+            # Calculate monthly average temperatures
+            monthly_temps = df.groupby(df["month"])["dry_bulb_temp"].mean().tolist()
+            
+            # Calculate monthly average radiation
+            monthly_radiation = df.groupby(df["month"])["global_horizontal_radiation"].mean().tolist()
+            
+            # Calculate summer daily temperature range
+            # Summer months: 6-8 for Northern Hemisphere, 12-2 for Southern Hemisphere
+            # Determine hemisphere based on latitude
+            latitude = df["latitude"].iloc[0] if "latitude" in df.columns else 0
+            
+            if latitude >= 0:  # Northern Hemisphere
+                summer_months = [6, 7, 8]
+            else:  # Southern Hemisphere
+                summer_months = [12, 1, 2]
+            
+            summer_data = df[df["month"].isin(summer_months)]
+            summer_daily_range = 0
+            
+            if not summer_data.empty:
+                summer_daily_max = summer_data.groupby(["month", "day"])["dry_bulb_temp"].max()
+                summer_daily_min = summer_data.groupby(["month", "day"])["dry_bulb_temp"].min()
+                summer_daily_range = (summer_daily_max - summer_daily_min).mean()
+            
+            # Calculate mean wind speed and pressure
+            wind_speed = df["wind_speed"].mean()
+            pressure = df["atmospheric_pressure"].mean()
+            
+            return {
+                "winter_design_temp": round(winter_design_temp, 1),
+                "summer_design_temp_db": round(summer_design_temp_db, 1),
+                "summer_design_temp_wb": round(summer_design_temp_wb, 1),
+                "heating_degree_days": round(heating_degree_days),
+                "cooling_degree_days": round(cooling_degree_days),
+                "monthly_average_temps": [round(t, 1) for t in monthly_temps],
+                "monthly_average_radiation": [round(r, 1) for r in monthly_radiation],
+                "summer_daily_range": round(summer_daily_range, 1),
+                "wind_speed": round(wind_speed, 1),
+                "pressure": round(pressure)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error calculating design conditions: {str(e)}")
+            # Return default values if calculation fails
+            return {
+                "winter_design_temp": 0.0,
+                "summer_design_temp_db": 30.0,
+                "summer_design_temp_wb": 25.0,
+                "heating_degree_days": 0,
+                "cooling_degree_days": 0,
+                "monthly_average_temps": [20.0] * 12,
+                "monthly_average_radiation": [150.0] * 12,
+                "summer_daily_range": 8.0,
+                "wind_speed": 3.0,
+                "pressure": 101325.0
+            }
+    
+    def _process_hourly_data(self, df: pd.DataFrame) -> List[Dict[str, Any]]:
+        """
+        Process hourly data from EPW DataFrame.
+        
+        Args:
+            df: DataFrame containing EPW data
+            
+        Returns:
+            List of hourly data records
+        """
+        hourly_data = []
+        
+        try:
+            # Ensure numeric columns
+            df["dry_bulb_temp"] = pd.to_numeric(df["dry_bulb_temp"], errors='coerce')
+            df["relative_humidity"] = pd.to_numeric(df["relative_humidity"], errors='coerce')
+            df["atmospheric_pressure"] = pd.to_numeric(df["atmospheric_pressure"], errors='coerce')
+            df["global_horizontal_radiation"] = pd.to_numeric(df["global_horizontal_radiation"], errors='coerce')
+            df["direct_normal_radiation"] = pd.to_numeric(df["direct_normal_radiation"], errors='coerce')
+            df["diffuse_horizontal_radiation"] = pd.to_numeric(df["diffuse_horizontal_radiation"], errors='coerce')
+            df["wind_speed"] = pd.to_numeric(df["wind_speed"], errors='coerce')
+            df["wind_direction"] = pd.to_numeric(df["wind_direction"], errors='coerce')
+            
+            # Convert to integers for month, day, hour
+            df["month"] = pd.to_numeric(df["month"], errors='coerce').astype('Int64')
+            df["day"] = pd.to_numeric(df["day"], errors='coerce').astype('Int64')
+            df["hour"] = pd.to_numeric(df["hour"], errors='coerce').astype('Int64')
+            
+            # Process each row
+            for _, row in df.iterrows():
+                if pd.isna(row["month"]) or pd.isna(row["day"]) or pd.isna(row["hour"]) or pd.isna(row["dry_bulb_temp"]):
+                    continue  # Skip rows with missing critical data
+                
+                record = {
+                    "month": int(row["month"]),
+                    "day": int(row["day"]),
+                    "hour": int(row["hour"]),
+                    "dry_bulb": float(row["dry_bulb_temp"]) if not pd.isna(row["dry_bulb_temp"]) else 20.0,
+                    "relative_humidity": float(row["relative_humidity"]) if not pd.isna(row["relative_humidity"]) else 50.0,
+                    "atmospheric_pressure": float(row["atmospheric_pressure"]) if not pd.isna(row["atmospheric_pressure"]) else 101325.0,
+                    "global_horizontal_radiation": float(row["global_horizontal_radiation"]) if not pd.isna(row["global_horizontal_radiation"]) else 0.0,
+                    "direct_normal_radiation": float(row["direct_normal_radiation"]) if not pd.isna(row["direct_normal_radiation"]) else 0.0,
+                    "diffuse_horizontal_radiation": float(row["diffuse_horizontal_radiation"]) if not pd.isna(row["diffuse_horizontal_radiation"]) else 0.0,
+                    "wind_speed": float(row["wind_speed"]) if not pd.isna(row["wind_speed"]) else 0.0,
+                    "wind_direction": float(row["wind_direction"]) if not pd.isna(row["wind_direction"]) else 0.0
+                }
+                hourly_data.append(record)
+            
+            # Check if we have the expected number of records (8760 hours in a year)
+            if len(hourly_data) < 8700:  # Allow for some missing data
+                logger.warning(f"Hourly data has {len(hourly_data)} records instead of 8760. Some records may be missing.")
+            
+            return hourly_data
+            
+        except Exception as e:
+            logger.error(f"Error processing hourly data: {str(e)}")
+            return []
+    
+    def _determine_climate_zone(self, hdd: float, cdd: float) -> str:
+        """
+        Determine ASHRAE climate zone based on heating and cooling degree days.
+        
+        Args:
+            hdd: Heating degree days (base 18°C)
+            cdd: Cooling degree days (base 18°C)
+            
+        Returns:
+            ASHRAE climate zone designation
+        """
+        # Simplified climate zone determination based on ASHRAE 169
+        if hdd >= 7000:
+            return "8"
+        elif hdd >= 5400:
+            return "7"
+        elif hdd >= 3900:
+            return "6A" if cdd <= 450 else "6B"
+        elif hdd >= 2700:
+            return "5A" if cdd <= 900 else ("5B" if cdd <= 1800 else "5C")
+        elif hdd >= 1800:
+            return "4A" if cdd <= 1800 else ("4B" if cdd <= 2700 else "4C")
+        elif hdd >= 900:
+            return "3A" if cdd <= 2700 else ("3B" if cdd <= 3600 else "3C")
+        elif hdd >= 0:
+            return "2A" if cdd <= 3600 else "2B"
+        else:
+            return "1A" if cdd <= 4500 else "1B"
+    
+    @staticmethod
+    def _calculate_wet_bulb(dry_bulb: np.ndarray, relative_humidity: np.ndarray) -> np.ndarray:
+        """
+        Calculate wet-bulb temperature using a simplified formula.
+        
+        Args:
+            dry_bulb: Dry-bulb temperature in °C
+            relative_humidity: Relative humidity in %
+            
+        Returns:
+            Wet-bulb temperature in °C
+        """
+        # Simplified formula for wet-bulb temperature
+        wet_bulb = dry_bulb * np.arctan(0.151977 * np.sqrt(relative_humidity + 8.313659)) + \
+                   np.arctan(dry_bulb + relative_humidity) - np.arctan(relative_humidity - 1.676331) + \
+                   0.00391838 * (relative_humidity)**(3/2) * np.arctan(0.023101 * relative_humidity) - 4.686035
+        
+        # Ensure wet-bulb is not higher than dry-bulb
+        wet_bulb = np.minimum(wet_bulb, dry_bulb)
+        
+        return wet_bulb
+
+def display_climate_page():
+    """
+    Display the climate data page.
+    This is the main function called by main.py when the Climate Data page is selected.
+    """
+    st.title("Climate Data and Design Requirements")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_climate_help()
+    
+    # Initialize climate data manager
+    climate_manager = ClimateDataManager()
+    
+    # Create tabs for different sections
+    tab1, tab2 = st.tabs(["EPW Data Input", "Climate Summary"])
+    
+    # EPW Data Input tab
+    with tab1:
+        st.subheader("Upload EPW Weather File")
+        
+        # File uploader for EPW files
+        uploaded_file = st.file_uploader(
+            "Upload EPW File",
+            type=["epw"],
+            help="Upload an EnergyPlus Weather (EPW) file for your location."
+        )
+        
+        if uploaded_file is not None:
+            try:
+                # Process the uploaded EPW file
+                with st.spinner("Processing EPW file..."):
+                    climate_data = climate_manager.load_epw(uploaded_file)
+                
+                # Store climate data in session state
+                st.session_state.project_data["climate_data"] = climate_data
+                
+                # Show success message
+                st.success(f"EPW file processed successfully: {uploaded_file.name}")
+                
+                # Display basic location information
+                location = climate_data["location"]
+                st.subheader("Location Information")
+                
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.write(f"**City:** {location['city']}")
+                    st.write(f"**State/Province:** {location['state_province']}")
+                    st.write(f"**Country:** {location['country']}")
+                
+                with col2:
+                    st.write(f"**Latitude:** {location['latitude']}°")
+                    st.write(f"**Longitude:** {location['longitude']}°")
+                    st.write(f"**Elevation:** {location['elevation']} m")
+                
+                # Automatically switch to Climate Summary tab
+                st.button("View Climate Summary", on_click=lambda: st.session_state.update({"climate_tab": "Climate Summary"}))
+                
+            except Exception as e:
+                st.error(f"Error processing EPW file: {str(e)}")
+                logger.error(f"Error processing EPW file: {str(e)}")
+    
+    # Climate Summary tab
+    with tab2:
+        if "climate_data" in st.session_state.project_data and st.session_state.project_data["climate_data"]:
+            display_climate_summary(st.session_state.project_data["climate_data"])
+        else:
+            st.info("Please upload an EPW file in the 'EPW Data Input' tab to view climate summary.")
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Building Information", key="back_to_building"):
+            st.session_state.current_page = "Building Information"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Material Library", key="continue_to_material"):
+            # Check if climate data is available before proceeding
+            if "climate_data" not in st.session_state.project_data or not st.session_state.project_data["climate_data"]:
+                st.warning("Please upload an EPW file before continuing.")
+            else:
+                st.session_state.current_page = "Material Library"
+                st.rerun()
+
+def display_climate_summary(climate_data: Dict[str, Any]):
+    """
+    Display climate summary information.
+    
+    Args:
+        climate_data: Dictionary containing climate data
+    """
+    st.subheader("Climate Summary")
+    
+    # Extract design conditions
+    design = climate_data["design_conditions"]
+    location = climate_data["location"]
+    
+    # Display climate zone
+    st.markdown(f"### ASHRAE Climate Zone: {climate_data['climate_zone']}")
+    
+    # Create columns for layout
+    col1, col2 = st.columns(2)
+    
+    # Design temperatures
+    with col1:
+        st.subheader("Design Temperatures")
+        st.write(f"**Winter Design Temperature:** {design['winter_design_temp']}°C")
+        st.write(f"**Summer Design Temperature (DB):** {design['summer_design_temp_db']}°C")
+        st.write(f"**Summer Design Temperature (WB):** {design['summer_design_temp_wb']}°C")
+        st.write(f"**Summer Daily Temperature Range:** {design['summer_daily_range']}°C")
+    
+    # Degree days
+    with col2:
+        st.subheader("Degree Days")
+        st.write(f"**Heating Degree Days (Base 18°C):** {design['heating_degree_days']}")
+        st.write(f"**Cooling Degree Days (Base 18°C):** {design['cooling_degree_days']}")
+        st.write(f"**Average Wind Speed:** {design['wind_speed']} m/s")
+        st.write(f"**Average Atmospheric Pressure:** {design['pressure']} Pa")
+    
+    # Monthly temperature chart
+    st.subheader("Monthly Average Temperatures")
+    
+    fig_temp = go.Figure()
+    fig_temp.add_trace(go.Scatter(
+        x=MONTHS,
+        y=design["monthly_average_temps"],
+        mode='lines+markers',
+        name='Temperature',
+        line=dict(color='firebrick', width=2),
+        marker=dict(size=8)
+    ))
+    
+    fig_temp.update_layout(
+        xaxis_title="Month",
+        yaxis_title="Temperature (°C)",
+        height=400,
+        margin=dict(l=20, r=20, t=30, b=20),
+    )
+    
+    st.plotly_chart(fig_temp, use_container_width=True)
+    
+    # Monthly radiation chart
+    st.subheader("Monthly Average Solar Radiation")
+    
+    fig_rad = go.Figure()
+    fig_rad.add_trace(go.Bar(
+        x=MONTHS,
+        y=design["monthly_average_radiation"],
+        name='Global Horizontal Radiation',
+        marker_color='gold'
+    ))
+    
+    fig_rad.update_layout(
+        xaxis_title="Month",
+        yaxis_title="Radiation (W/m²)",
+        height=400,
+        margin=dict(l=20, r=20, t=30, b=20),
+    )
+    
+    st.plotly_chart(fig_rad, use_container_width=True)
+    
+    # Display hourly data statistics
+    st.subheader("Hourly Data Statistics")
+    
+    if "hourly_data" in climate_data and climate_data["hourly_data"]:
+        hourly_count = len(climate_data["hourly_data"])
+        st.write(f"**Number of Hourly Records:** {hourly_count}")
+        
+        if hourly_count < 8760:
+            st.warning(f"Expected 8760 hourly records for a full year, but found {hourly_count}. Some data may be missing.")
+    else:
+        st.warning("No hourly data available.")
+
+def display_climate_help():
+    """Display help information for the climate data page."""
+    st.markdown("""
+    ### Climate Data Help
+    
+    This section allows you to upload and process weather data for your location, which is essential for accurate HVAC load calculations.
+    
+    **EPW Files:**
+    
+    EPW (EnergyPlus Weather) files contain hourly weather data for a specific location, including:
+    
+    * Dry-bulb temperature
+    * Relative humidity
+    * Solar radiation (direct and diffuse)
+    * Wind speed and direction
+    * Atmospheric pressure
+    
+    **Where to Find EPW Files:**
+    
+    * [EnergyPlus Weather Data](https://energyplus.net/weather)
+    * [Climate.OneBuilding.Org](https://climate.onebuilding.org/)
+    * [ASHRAE International Weather for Energy Calculations (IWEC)](https://www.ashrae.org/technical-resources/bookstore/ashrae-international-weather-files-for-energy-calculations-2-0-iwec2)
+    
+    **Climate Summary:**
+    
+    After uploading an EPW file, the Climate Summary tab will display:
+    
+    * ASHRAE Climate Zone
+    * Design temperatures for heating and cooling
+    * Heating and cooling degree days
+    * Monthly average temperatures and solar radiation
+    * Hourly data statistics
+    
+    This information will be used throughout the HVAC load calculation process.
+    """)

app/components.py

@@ -0,0 +1,504 @@
+"""
+HVAC Load Calculator - Building Components Module
+
+This module handles the definition of building envelope components (walls, roofs, floors,
+windows, doors, skylights) for the HVAC Load Calculator application. It allows users to
+assign constructions and fenestrations to specific components, define their areas,
+orientations, and other relevant properties.
+
+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
+from typing import Dict, List, Any, Optional, Tuple, Union
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Define constants
+COMPONENT_TYPES = ["Wall", "Roof", "Floor", "Window", "Door", "Skylight"]
+ORIENTATION_OPTIONS = ["A (North)", "B (South)", "C (East)", "D (West)", "Horizontal"]
+
+def display_components_page():
+    """
+    Display the building components page.
+    This is the main function called by main.py when the Building Components page is selected.
+    """
+    st.title("Building Components")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_components_help()
+    
+    # Initialize components in session state if not present
+    initialize_components()
+    
+    # Create tabs for different component types
+    tabs = st.tabs(COMPONENT_TYPES)
+    
+    for i, component_type in enumerate(COMPONENT_TYPES):
+        with tabs[i]:
+            display_component_tab(component_type)
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Construction", key="back_to_construction"):
+            st.session_state.current_page = "Construction"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Internal Loads", key="continue_to_internal_loads"):
+            st.session_state.current_page = "Internal Loads"
+            st.rerun()
+
+def initialize_components():
+    """Initialize components in session state if not present."""
+    if "components" not in st.session_state.project_data:
+        st.session_state.project_data["components"] = {
+            "walls": [],
+            "roofs": [],
+            "floors": [],
+            "windows": [],
+            "doors": [],
+            "skylights": []
+        }
+    
+    # Initialize component editor state
+    if "component_editor" not in st.session_state:
+        st.session_state.component_editor = {
+            "type": COMPONENT_TYPES[0],
+            "name": "",
+            "construction": "",
+            "fenestration": "",
+            "area": 10.0,
+            "orientation": ORIENTATION_OPTIONS[0],
+            "tilt": 90.0,
+            "parent_component": "",
+            "edit_mode": False,
+            "original_id": ""
+        }
+
+def display_component_tab(component_type: str):
+    """
+    Display the content for a specific component type tab.
+    
+    Args:
+        component_type: The type of component (e.g., "Wall", "Window")
+    """
+    st.subheader(f"{component_type}s")
+    
+    # Get components of this type
+    component_key = component_type.lower() + "s"
+    components = st.session_state.project_data["components"].get(component_key, [])
+    
+    # Display existing components
+    if components:
+        display_component_list(component_type, components)
+    else:
+        st.info(f"No {component_type.lower()}s added yet. Use the editor below to add components.")
+    
+    # Component Editor
+    st.markdown("---")
+    st.subheader(f"{component_type} Editor")
+    display_component_editor(component_type)
+
+def display_component_list(component_type: str, components: List[Dict[str, Any]]):
+    """
+    Display the list of existing components for a given type.
+    
+    Args:
+        component_type: The type of component
+        components: List of component dictionaries
+    """
+    # Create a DataFrame for display
+    data = []
+    for i, comp in enumerate(components):
+        record = {
+            "#": i + 1,
+            "Name": comp["name"],
+            "Area (m²)": comp["area"],
+            "Orientation": comp["orientation"],
+            "Tilt (°) ": comp["tilt"]
+        }
+        
+        if component_type in ["Wall", "Roof", "Floor"]:
+            record["Construction"] = comp["construction"]
+        else:
+            record["Fenestration"] = comp["fenestration"]
+            record["Parent Component"] = comp.get("parent_component", "N/A")
+        
+        data.append(record)
+    
+    df = pd.DataFrame(data)
+    st.dataframe(df, use_container_width=True, hide_index=True)
+    
+    # Edit and delete options
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        selected_index = st.selectbox(
+            f"Select {component_type} # to Edit",
+            range(1, len(components) + 1),
+            key=f"edit_{component_type}_selector"
+        )
+        
+        if st.button(f"Edit {component_type}", key=f"edit_{component_type}_button"):
+            # Load component data into editor
+            component_data = components[selected_index - 1]
+            st.session_state.component_editor = {
+                "type": component_type,
+                "name": component_data["name"],
+                "construction": component_data.get("construction", ""),
+                "fenestration": component_data.get("fenestration", ""),
+                "area": component_data["area"],
+                "orientation": component_data["orientation"],
+                "tilt": component_data["tilt"],
+                "parent_component": component_data.get("parent_component", ""),
+                "edit_mode": True,
+                "original_id": component_data["id"]
+            }
+            st.success(f"{component_type} 	\'{component_data['name']}\' loaded for editing.")
+            st.rerun()
+    
+    with col2:
+        selected_index_delete = st.selectbox(
+            f"Select {component_type} # to Delete",
+            range(1, len(components) + 1),
+            key=f"delete_{component_type}_selector"
+        )
+        
+        if st.button(f"Delete {component_type}", key=f"delete_{component_type}_button"):
+            # Delete component
+            component_key = component_type.lower() + "s"
+            deleted_component = st.session_state.project_data["components"][component_key].pop(selected_index_delete - 1)
+            st.success(f"{component_type} 	\'{deleted_component['name']}\' deleted.")
+            logger.info(f"Deleted {component_type} 	\'{deleted_component['name']}\'")
+            st.rerun()
+
+def display_component_editor(component_type: str):
+    """
+    Display the editor form for a specific component type.
+    
+    Args:
+        component_type: The type of component
+    """
+    # Get available constructions and fenestrations
+    available_constructions = get_available_constructions()
+    available_fenestrations = get_available_fenestrations()
+    available_walls = get_available_walls()
+    
+    # Check if the editor is currently set to this component type
+    if st.session_state.component_editor["type"] != component_type and not st.session_state.component_editor["edit_mode"]:
+        reset_component_editor(component_type)
+    
+    with st.form(f"{component_type}_editor_form"):
+        # Component name
+        name = st.text_input(
+            "Component Name",
+            value=st.session_state.component_editor["name"],
+            help="Enter a unique name for this component."
+        )
+        
+        # Create two columns for layout
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Construction or Fenestration selection
+            if component_type in ["Wall", "Roof", "Floor"]:
+                construction = st.selectbox(
+                    "Construction",
+                    list(available_constructions.keys()),
+                    index=list(available_constructions.keys()).index(st.session_state.component_editor["construction"]) if st.session_state.component_editor["construction"] in available_constructions else 0,
+                    help="Select the construction assembly for this component."
+                )
+                fenestration = ""
+            else:
+                fenestration = st.selectbox(
+                    "Fenestration",
+                    list(available_fenestrations.keys()),
+                    index=list(available_fenestrations.keys()).index(st.session_state.component_editor["fenestration"]) if st.session_state.component_editor["fenestration"] in available_fenestrations else 0,
+                    help="Select the fenestration type for this component."
+                )
+                construction = ""
+            
+            # Area
+            area = st.number_input(
+                "Area (m²)",
+                min_value=0.1,
+                max_value=10000.0,
+                value=float(st.session_state.component_editor["area"]),
+                format="%.2f",
+                help="Surface area of the component in square meters."
+            )
+        
+        with col2:
+            # Orientation
+            orientation = st.selectbox(
+                "Orientation",
+                ORIENTATION_OPTIONS,
+                index=ORIENTATION_OPTIONS.index(st.session_state.component_editor["orientation"]) if st.session_state.component_editor["orientation"] in ORIENTATION_OPTIONS else 0,
+                help="Orientation of the component relative to the building orientation angle."
+            )
+            
+            # Tilt
+            tilt = st.number_input(
+                "Tilt (°) ",
+                min_value=0.0,
+                max_value=180.0,
+                value=float(st.session_state.component_editor["tilt"]),
+                format="%.1f",
+                help="Tilt angle of the component relative to horizontal (0° = horizontal, 90° = vertical)."
+            )
+        
+        # Parent component (for windows, doors, skylights)
+        parent_component = ""
+        if component_type in ["Window", "Door", "Skylight"]:
+            parent_component = st.selectbox(
+                "Parent Component (Wall/Roof)",
+                list(available_walls.keys()),
+                index=list(available_walls.keys()).index(st.session_state.component_editor["parent_component"]) if st.session_state.component_editor["parent_component"] in available_walls else 0,
+                help="Select the wall or roof component this fenestration belongs to."
+            )
+        
+        # Form submission buttons
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            submit_button = st.form_submit_button("Save Component")
+        
+        with col2:
+            clear_button = st.form_submit_button("Clear Form")
+    
+    # Handle form submission
+    if submit_button:
+        # Validate inputs
+        validation_errors = validate_component(
+            component_type, name, construction, fenestration, area, orientation, tilt,
+            parent_component, st.session_state.component_editor["edit_mode"],
+            st.session_state.component_editor["original_id"]
+        )
+        
+        if validation_errors:
+            # Display validation errors
+            for error in validation_errors:
+                st.error(error)
+        else:
+            # Create component data
+            component_data = {
+                "id": st.session_state.component_editor["original_id"] if st.session_state.component_editor["edit_mode"] else str(uuid.uuid4()),
+                "name": name,
+                "type": component_type,
+                "area": area,
+                "orientation": orientation,
+                "tilt": tilt
+            }
+            
+            if component_type in ["Wall", "Roof", "Floor"]:
+                component_data["construction"] = construction
+            else:
+                component_data["fenestration"] = fenestration
+                component_data["parent_component"] = parent_component
+            
+            # Handle edit mode
+            component_key = component_type.lower() + "s"
+            if st.session_state.component_editor["edit_mode"]:
+                # Find and update the component
+                components = st.session_state.project_data["components"][component_key]
+                for i, comp in enumerate(components):
+                    if comp["id"] == st.session_state.component_editor["original_id"]:
+                        components[i] = component_data
+                        break
+                st.success(f"{component_type} 	\'{name}\' updated successfully.")
+                logger.info(f"Updated {component_type} 	\'{name}\'")
+            else:
+                # Add new component
+                st.session_state.project_data["components"][component_key].append(component_data)
+                st.success(f"{component_type} 	\'{name}\' added successfully.")
+                logger.info(f"Added new {component_type} 	\'{name}\'")
+            
+            # Reset editor
+            reset_component_editor(component_type)
+            st.rerun()
+    
+    # Handle clear button
+    if clear_button:
+        reset_component_editor(component_type)
+        st.rerun()
+
+def get_available_constructions() -> Dict[str, Any]:
+    """
+    Get all available constructions from both library and project.
+    
+    Returns:
+        Dict of construction name to construction properties
+    """
+    available_constructions = {}
+    
+    # Add library constructions
+    if "constructions" in st.session_state.project_data and "library" in st.session_state.project_data["constructions"]:
+        available_constructions.update(st.session_state.project_data["constructions"]["library"])
+    
+    # Add project constructions
+    if "constructions" in st.session_state.project_data and "project" in st.session_state.project_data["constructions"]:
+        available_constructions.update(st.session_state.project_data["constructions"]["project"])
+    
+    return available_constructions
+
+def get_available_fenestrations() -> Dict[str, Any]:
+    """
+    Get all available fenestrations from both library and project.
+    
+    Returns:
+        Dict of fenestration name to fenestration properties
+    """
+    available_fenestrations = {}
+    
+    # Add library fenestrations
+    if "fenestrations" in st.session_state.project_data and "library" in st.session_state.project_data["fenestrations"]:
+        available_fenestrations.update(st.session_state.project_data["fenestrations"]["library"])
+    
+    # Add project fenestrations
+    if "fenestrations" in st.session_state.project_data and "project" in st.session_state.project_data["fenestrations"]:
+        available_fenestrations.update(st.session_state.project_data["fenestrations"]["project"])
+    
+    return available_fenestrations
+
+def get_available_walls() -> Dict[str, Any]:
+    """
+    Get all available wall components.
+    
+    Returns:
+        Dict of wall name to wall properties
+    """
+    available_walls = {}
+    if "components" in st.session_state.project_data and "walls" in st.session_state.project_data["components"]:
+        for wall in st.session_state.project_data["components"]["walls"]:
+            available_walls[wall["name"]] = wall
+    return available_walls
+
+def validate_component(
+    component_type: str, name: str, construction: str, fenestration: str, area: float,
+    orientation: str, tilt: float, parent_component: str, edit_mode: bool, original_id: str
+) -> List[str]:
+    """
+    Validate component inputs.
+    
+    Args:
+        component_type: Type of component
+        name: Component name
+        construction: Selected construction name
+        fenestration: Selected fenestration name
+        area: Component area
+        orientation: Component orientation
+        tilt: Component tilt angle
+        parent_component: Parent component name (for fenestrations)
+        edit_mode: Whether in edit mode
+        original_id: Original ID if in edit mode
+        
+    Returns:
+        List of validation error messages, empty if all inputs are valid
+    """
+    errors = []
+    
+    # Validate name
+    if not name or name.strip() == "":
+        errors.append("Component name is required.")
+    
+    # Check for name uniqueness within the same component type
+    component_key = component_type.lower() + "s"
+    components = st.session_state.project_data["components"].get(component_key, [])
+    
+    for comp in components:
+        if comp["name"] == name and (not edit_mode or comp["id"] != original_id):
+            errors.append(f"{component_type} name 	\'{name}\' already exists.")
+            break
+    
+    # Validate construction or fenestration selection
+    if component_type in ["Wall", "Roof", "Floor"] and not construction:
+        errors.append("Construction selection is required.")
+    elif component_type in ["Window", "Door", "Skylight"] and not fenestration:
+        errors.append("Fenestration selection is required.")
+    
+    # Validate area
+    if area <= 0:
+        errors.append("Area must be greater than zero.")
+    
+    # Validate orientation
+    if orientation not in ORIENTATION_OPTIONS:
+        errors.append("Please select a valid orientation.")
+    
+    # Validate tilt
+    if tilt < 0 or tilt > 180:
+        errors.append("Tilt angle must be between 0° and 180°.")
+    
+    # Validate parent component for fenestrations
+    if component_type in ["Window", "Door", "Skylight"] and not parent_component:
+        errors.append("Parent component selection is required for fenestrations.")
+    
+    return errors
+
+def reset_component_editor(component_type: str):
+    """
+    Reset the component editor to default values for the given type.
+    
+    Args:
+        component_type: The type of component
+    """
+    st.session_state.component_editor = {
+        "type": component_type,
+        "name": "",
+        "construction": "",
+        "fenestration": "",
+        "area": 10.0,
+        "orientation": ORIENTATION_OPTIONS[0],
+        "tilt": 90.0 if component_type == "Wall" else 0.0,
+        "parent_component": "",
+        "edit_mode": False,
+        "original_id": ""
+    }
+
+def display_components_help():
+    """
+    Display help information for the building components page.
+    """
+    st.markdown("""
+    ### Building Components Help
+    
+    This section allows you to define the individual components of your building envelope, such as walls, roofs, floors, windows, doors, and skylights.
+    
+    **Key Concepts:**
+    
+    * **Component**: A specific part of the building envelope (e.g., "North Wall", "Living Room Window").
+    * **Construction**: The multi-layer assembly assigned to opaque components (walls, roofs, floors).
+    * **Fenestration**: The glazing or door system assigned to transparent or operable components (windows, doors, skylights).
+    * **Area**: The surface area of the component in square meters.
+    * **Orientation**: The direction the component faces relative to the building orientation angle (A=North, B=South, C=East, D=West, Horizontal).
+    * **Tilt**: The angle of the component relative to horizontal (0° = horizontal, 90° = vertical).
+    * **Parent Component**: For fenestrations, the wall or roof component they are part of.
+    
+    **Workflow:**
+    
+    1. Select the tab for the component type you want to define (e.g., "Walls").
+    2. Use the editor to add new components:
+        * Give the component a unique name.
+        * Select the appropriate construction (for walls, roofs, floors) or fenestration (for windows, doors, skylights) from your project library.
+        * Enter the area, orientation, and tilt.
+        * For fenestrations, select the parent wall or roof component.
+    3. Save the component.
+    4. Repeat for all building envelope components.
+    5. Edit or delete components as needed using the controls above the editor.
+    
+    **Important:**
+    
+    * Ensure all constructions and fenestrations you need are defined in the Material Library and Construction pages before defining components.
+    * The accuracy of your load calculations depends heavily on the correct definition of these components.
+    """)

app/construction.py

@@ -0,0 +1,823 @@
+"""
+HVAC Load Calculator - Construction Module
+
+This module handles the construction assembly functionality of the HVAC Load Calculator application,
+allowing users to create and manage multi-layer constructions for walls, roofs, and floors.
+It integrates with the material library to select materials for each layer and calculates
+overall thermal properties.
+
+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
+from typing import Dict, List, Any, Optional, Tuple, Union
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Define constants
+CONSTRUCTION_TYPES = ["Wall", "Roof", "Floor"]
+
+# Default library constructions
+DEFAULT_CONSTRUCTIONS = {
+    "Brick Cavity Wall": {
+        "type": "Wall",
+        "layers": [
+            {"material": "Brick", "thickness": 0.1},
+            {"material": "Air Gap", "thickness": 0.05},
+            {"material": "Mineral Wool", "thickness": 0.1},
+            {"material": "Concrete Block", "thickness": 0.1},
+            {"material": "Gypsum Board", "thickness": 0.0125}
+        ],
+        "u_value": 0.35,  # W/m²·K
+        "r_value": 2.86,  # m²·K/W
+        "thermal_mass": 220.0,  # kJ/m²·K
+        "embodied_carbon": 120.0,  # kg CO2e/m²
+        "cost": 180.0  # USD/m²
+    },
+    "Insulated Concrete Wall": {
+        "type": "Wall",
+        "layers": [
+            {"material": "Concrete", "thickness": 0.15},
+            {"material": "EPS Insulation", "thickness": 0.1},
+            {"material": "Gypsum Board", "thickness": 0.0125}
+        ],
+        "u_value": 0.32,
+        "r_value": 3.13,
+        "thermal_mass": 360.0,
+        "embodied_carbon": 95.0,
+        "cost": 150.0
+    },
+    "Timber Frame Wall": {
+        "type": "Wall",
+        "layers": [
+            {"material": "Wood (Pine)", "thickness": 0.02},
+            {"material": "Glass Fiber Insulation", "thickness": 0.15},
+            {"material": "Plywood", "thickness": 0.012},
+            {"material": "Gypsum Board", "thickness": 0.0125}
+        ],
+        "u_value": 0.25,
+        "r_value": 4.0,
+        "thermal_mass": 45.0,
+        "embodied_carbon": 35.0,
+        "cost": 120.0
+    },
+    "Concrete Flat Roof": {
+        "type": "Roof",
+        "layers": [
+            {"material": "Concrete", "thickness": 0.15},
+            {"material": "Polyurethane Insulation", "thickness": 0.15},
+            {"material": "Waterproofing Membrane", "thickness": 0.005}
+        ],
+        "u_value": 0.18,
+        "r_value": 5.56,
+        "thermal_mass": 360.0,
+        "embodied_carbon": 110.0,
+        "cost": 200.0
+    },
+    "Timber Pitched Roof": {
+        "type": "Roof",
+        "layers": [
+            {"material": "Roof Tiles", "thickness": 0.02},
+            {"material": "Waterproofing Membrane", "thickness": 0.002},
+            {"material": "Wood (Pine)", "thickness": 0.025},
+            {"material": "Glass Fiber Insulation", "thickness": 0.2},
+            {"material": "Gypsum Board", "thickness": 0.0125}
+        ],
+        "u_value": 0.16,
+        "r_value": 6.25,
+        "thermal_mass": 40.0,
+        "embodied_carbon": 45.0,
+        "cost": 160.0
+    },
+    "Concrete Floor Slab": {
+        "type": "Floor",
+        "layers": [
+            {"material": "Ceramic Tile", "thickness": 0.01},
+            {"material": "Concrete", "thickness": 0.1},
+            {"material": "EPS Insulation", "thickness": 0.1},
+            {"material": "Damp Proof Membrane", "thickness": 0.002},
+            {"material": "Gravel", "thickness": 0.15}
+        ],
+        "u_value": 0.25,
+        "r_value": 4.0,
+        "thermal_mass": 240.0,
+        "embodied_carbon": 85.0,
+        "cost": 140.0
+    },
+    "Timber Floor": {
+        "type": "Floor",
+        "layers": [
+            {"material": "Wood (Pine)", "thickness": 0.02},
+            {"material": "Air Gap", "thickness": 0.05},
+            {"material": "Glass Fiber Insulation", "thickness": 0.15},
+            {"material": "Plywood", "thickness": 0.018}
+        ],
+        "u_value": 0.22,
+        "r_value": 4.55,
+        "thermal_mass": 30.0,
+        "embodied_carbon": 25.0,
+        "cost": 110.0
+    }
+}
+
+# Additional materials needed for constructions but not in material library
+ADDITIONAL_MATERIALS = {
+    "Air Gap": {
+        "category": "Sub-Structural Materials",
+        "thermal_conductivity": 0.026,
+        "density": 1.2,
+        "specific_heat": 1000.0,
+        "thickness_range": [0.01, 0.1],
+        "default_thickness": 0.05,
+        "embodied_carbon": 0.0,
+        "cost": 0.0
+    },
+    "Waterproofing Membrane": {
+        "category": "Finishing Materials",
+        "thermal_conductivity": 0.17,
+        "density": 1100.0,
+        "specific_heat": 1000.0,
+        "thickness_range": [0.001, 0.01],
+        "default_thickness": 0.002,
+        "embodied_carbon": 4.2,
+        "cost": 15.0
+    },
+    "Damp Proof Membrane": {
+        "category": "Sub-Structural Materials",
+        "thermal_conductivity": 0.17,
+        "density": 1100.0,
+        "specific_heat": 1000.0,
+        "thickness_range": [0.001, 0.005],
+        "default_thickness": 0.002,
+        "embodied_carbon": 4.0,
+        "cost": 12.0
+    },
+    "Roof Tiles": {
+        "category": "Finishing Materials",
+        "thermal_conductivity": 1.0,
+        "density": 1900.0,
+        "specific_heat": 800.0,
+        "thickness_range": [0.01, 0.03],
+        "default_thickness": 0.02,
+        "embodied_carbon": 110.0,
+        "cost": 75.0
+    },
+    "Gravel": {
+        "category": "Sub-Structural Materials",
+        "thermal_conductivity": 0.7,
+        "density": 1800.0,
+        "specific_heat": 840.0,
+        "thickness_range": [0.05, 0.3],
+        "default_thickness": 0.15,
+        "embodied_carbon": 1.5,
+        "cost": 30.0
+    }
+}
+
+def display_construction_page():
+    """
+    Display the construction page.
+    This is the main function called by main.py when the Construction page is selected.
+    """
+    st.title("Construction Library")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_construction_help()
+    
+    # Initialize constructions in session state if not present
+    initialize_constructions()
+    
+    # Create columns for library and project constructions
+    col1, col2 = st.columns(2)
+    
+    # Library Constructions
+    with col1:
+        st.subheader("Library Constructions")
+        display_library_constructions()
+    
+    # Project Constructions
+    with col2:
+        st.subheader("Project Constructions")
+        display_project_constructions()
+    
+    # Construction Editor
+    st.markdown("---")
+    st.subheader("Construction Editor")
+    display_construction_editor()
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Material Library", key="back_to_materials"):
+            st.session_state.current_page = "Material Library"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Building Components", key="continue_to_components"):
+            st.session_state.current_page = "Building Components"
+            st.rerun()
+
+def initialize_constructions():
+    """Initialize constructions in session state if not present."""
+    if "constructions" not in st.session_state.project_data:
+        st.session_state.project_data["constructions"] = {
+            "library": {},
+            "project": {}
+        }
+    
+    # Initialize library constructions if empty
+    if not st.session_state.project_data["constructions"]["library"]:
+        st.session_state.project_data["constructions"]["library"] = DEFAULT_CONSTRUCTIONS.copy()
+    
+    # Add additional materials to library if not present
+    for material_name, material_data in ADDITIONAL_MATERIALS.items():
+        if material_name not in st.session_state.project_data["materials"]["library"]:
+            st.session_state.project_data["materials"]["library"][material_name] = material_data
+    
+    # Initialize construction editor state
+    if "construction_editor" not in st.session_state:
+        st.session_state.construction_editor = {
+            "name": "",
+            "type": CONSTRUCTION_TYPES[0],
+            "layers": [],
+            "edit_mode": False,
+            "original_name": ""
+        }
+
+def display_library_constructions():
+    """Display the library constructions section."""
+    # Filter options
+    type_filter = st.selectbox(
+        "Filter by Type",
+        ["All"] + CONSTRUCTION_TYPES,
+        key="library_construction_type_filter"
+    )
+    
+    # Get library constructions
+    library_constructions = st.session_state.project_data["constructions"]["library"]
+    
+    # Apply filter
+    if type_filter != "All":
+        filtered_constructions = {
+            name: props for name, props in library_constructions.items()
+            if props["type"] == type_filter
+        }
+    else:
+        filtered_constructions = library_constructions
+    
+    # Display constructions in a table
+    if filtered_constructions:
+        # Create a DataFrame for display
+        data = []
+        for name, props in filtered_constructions.items():
+            data.append({
+                "Name": name,
+                "Type": props["type"],
+                "U-Value (W/m²·K)": props["u_value"],
+                "R-Value (m²·K/W)": props["r_value"],
+                "Thermal Mass (kJ/m²·K)": props["thermal_mass"],
+                "Layers": len(props["layers"])
+            })
+        
+        df = pd.DataFrame(data)
+        st.dataframe(df, use_container_width=True, hide_index=True)
+        
+        # Add to project button
+        selected_construction = st.selectbox(
+            "Select Construction to Add to Project",
+            list(filtered_constructions.keys()),
+            key="library_construction_selector"
+        )
+        
+        # Display selected construction details
+        if selected_construction:
+            st.subheader(f"Details: {selected_construction}")
+            display_construction_details(filtered_constructions[selected_construction])
+        
+        if st.button("Add to Project", key="add_library_construction_to_project"):
+            # Check if construction already exists in project
+            if selected_construction in st.session_state.project_data["constructions"]["project"]:
+                st.warning(f"Construction '{selected_construction}' already exists in your project.")
+            else:
+                # Add to project constructions
+                st.session_state.project_data["constructions"]["project"][selected_construction] = \
+                    st.session_state.project_data["constructions"]["library"][selected_construction].copy()
+                st.success(f"Construction '{selected_construction}' added to your project.")
+                logger.info(f"Added library construction '{selected_construction}' to project")
+    else:
+        st.info("No constructions found in the selected type.")
+
+def display_project_constructions():
+    """Display the project constructions section."""
+    # Get project constructions
+    project_constructions = st.session_state.project_data["constructions"]["project"]
+    
+    if project_constructions:
+        # Create a DataFrame for display
+        data = []
+        for name, props in project_constructions.items():
+            data.append({
+                "Name": name,
+                "Type": props["type"],
+                "U-Value (W/m²·K)": props["u_value"],
+                "R-Value (m²·K/W)": props["r_value"],
+                "Thermal Mass (kJ/m²·K)": props["thermal_mass"],
+                "Layers": len(props["layers"])
+            })
+        
+        df = pd.DataFrame(data)
+        st.dataframe(df, use_container_width=True, hide_index=True)
+        
+        # Select construction to view details
+        selected_construction = st.selectbox(
+            "Select Construction to View Details",
+            list(project_constructions.keys()),
+            key="project_construction_selector"
+        )
+        
+        # Display selected construction details
+        if selected_construction:
+            st.subheader(f"Details: {selected_construction}")
+            display_construction_details(project_constructions[selected_construction])
+        
+        # Edit and delete options
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            selected_construction_edit = st.selectbox(
+                "Select Construction to Edit",
+                list(project_constructions.keys()),
+                key="project_construction_edit_selector"
+            )
+            
+            if st.button("Edit Construction", key="edit_project_construction"):
+                # Load construction data into editor
+                construction_data = project_constructions[selected_construction_edit]
+                st.session_state.construction_editor = {
+                    "name": selected_construction_edit,
+                    "type": construction_data["type"],
+                    "layers": construction_data["layers"].copy(),
+                    "edit_mode": True,
+                    "original_name": selected_construction_edit
+                }
+                st.success(f"Construction '{selected_construction_edit}' loaded for editing.")
+                st.rerun()
+        
+        with col2:
+            selected_construction_delete = st.selectbox(
+                "Select Construction to Delete",
+                list(project_constructions.keys()),
+                key="project_construction_delete_selector"
+            )
+            
+            if st.button("Delete Construction", key="delete_project_construction"):
+                # Check if construction is in use
+                is_in_use = check_construction_in_use(selected_construction_delete)
+                
+                if is_in_use:
+                    st.error(f"Cannot delete construction '{selected_construction_delete}' because it is in use in building components.")
+                else:
+                    # Delete construction
+                    del st.session_state.project_data["constructions"]["project"][selected_construction_delete]
+                    st.success(f"Construction '{selected_construction_delete}' deleted from your project.")
+                    logger.info(f"Deleted construction '{selected_construction_delete}' from project")
+    else:
+        st.info("No constructions in your project. Add constructions from the library or create custom constructions.")
+
+def display_construction_details(construction: Dict[str, Any]):
+    """
+    Display detailed information about a construction.
+    
+    Args:
+        construction: Construction data dictionary
+    """
+    # Display basic properties
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.write(f"**Type:** {construction['type']}")
+        st.write(f"**U-Value:** {construction['u_value']} W/m²·K")
+    
+    with col2:
+        st.write(f"**R-Value:** {construction['r_value']} m²·K/W")
+        st.write(f"**Thermal Mass:** {construction['thermal_mass']} kJ/m²·K")
+    
+    with col3:
+        st.write(f"**Embodied Carbon:** {construction['embodied_carbon']} kg CO₂e/m²")
+        st.write(f"**Cost:** ${construction['cost']}/m²")
+    
+    # Display layers
+    st.write("**Layers (from outside to inside):**")
+    
+    # Create a DataFrame for layers
+    layers_data = []
+    for i, layer in enumerate(construction["layers"]):
+        layers_data.append({
+            "Layer": i + 1,
+            "Material": layer["material"],
+            "Thickness (m)": layer["thickness"]
+        })
+    
+    layers_df = pd.DataFrame(layers_data)
+    st.dataframe(layers_df, use_container_width=True, hide_index=True)
+
+def display_construction_editor():
+    """Display the construction editor form."""
+    # Get available materials
+    available_materials = get_available_materials()
+    
+    with st.form("construction_editor_form"):
+        # Construction name
+        name = st.text_input(
+            "Construction Name",
+            value=st.session_state.construction_editor["name"],
+            help="Enter a unique name for the construction."
+        )
+        
+        # Construction type
+        construction_type = st.selectbox(
+            "Construction Type",
+            CONSTRUCTION_TYPES,
+            index=CONSTRUCTION_TYPES.index(st.session_state.construction_editor["type"]) if st.session_state.construction_editor["type"] in CONSTRUCTION_TYPES else 0,
+            help="Select the construction type."
+        )
+        
+        # Layers section
+        st.subheader("Layers (from outside to inside)")
+        
+        # Display current layers
+        if st.session_state.construction_editor["layers"]:
+            layers_data = []
+            for i, layer in enumerate(st.session_state.construction_editor["layers"]):
+                layers_data.append({
+                    "Layer": i + 1,
+                    "Material": layer["material"],
+                    "Thickness (m)": layer["thickness"]
+                })
+            
+            layers_df = pd.DataFrame(layers_data)
+            st.dataframe(layers_df, use_container_width=True, hide_index=True)
+        else:
+            st.info("No layers added yet. Use the controls below to add layers.")
+        
+        # Layer controls
+        st.subheader("Add/Edit Layer")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            layer_material = st.selectbox(
+                "Material",
+                list(available_materials.keys()),
+                key="layer_material_selector",
+                help="Select a material for this layer."
+            )
+            
+            # Get material properties
+            if layer_material in available_materials:
+                material_props = available_materials[layer_material]
+                min_thickness = material_props["thickness_range"][0]
+                max_thickness = material_props["thickness_range"][1]
+                default_thickness = material_props["default_thickness"]
+            else:
+                min_thickness = 0.001
+                max_thickness = 0.5
+                default_thickness = 0.05
+        
+        with col2:
+            layer_thickness = st.number_input(
+                "Thickness (m)",
+                min_value=float(min_thickness),
+                max_value=float(max_thickness),
+                value=float(default_thickness),
+                format="%.3f",
+                help=f"Enter the thickness for this layer (range: {min_thickness}-{max_thickness} m)."
+            )
+        
+        # Layer action buttons
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            add_layer = st.form_submit_button("Add Layer")
+        
+        with col2:
+            layer_index_to_remove = st.number_input(
+                "Layer # to Remove",
+                min_value=1,
+                max_value=max(1, len(st.session_state.construction_editor["layers"])),
+                value=len(st.session_state.construction_editor["layers"]) if st.session_state.construction_editor["layers"] else 1,
+                step=1,
+                help="Enter the layer number to remove."
+            )
+        
+        with col3:
+            remove_layer = st.form_submit_button("Remove Layer")
+        
+        # Calculate button and results
+        st.subheader("Thermal Properties")
+        calculate = st.form_submit_button("Calculate Properties")
+        
+        # Form submission buttons
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            save_button = st.form_submit_button("Save Construction")
+        
+        with col2:
+            clear_button = st.form_submit_button("Clear Form")
+        
+        with col3:
+            cancel_button = st.form_submit_button("Cancel Edit")
+    
+    # Handle form actions outside the form
+    if add_layer:
+        # Add new layer
+        new_layer = {
+            "material": layer_material,
+            "thickness": layer_thickness
+        }
+        st.session_state.construction_editor["layers"].append(new_layer)
+        st.success(f"Layer added: {layer_material} ({layer_thickness} m)")
+        st.rerun()
+    
+    if remove_layer and st.session_state.construction_editor["layers"]:
+        # Remove layer
+        if 1 <= layer_index_to_remove <= len(st.session_state.construction_editor["layers"]):
+            removed_layer = st.session_state.construction_editor["layers"].pop(layer_index_to_remove - 1)
+            st.success(f"Layer {layer_index_to_remove} removed: {removed_layer['material']} ({removed_layer['thickness']} m)")
+            st.rerun()
+        else:
+            st.error("Invalid layer index.")
+    
+    if calculate:
+        # Calculate thermal properties
+        if st.session_state.construction_editor["layers"]:
+            u_value, r_value, thermal_mass, embodied_carbon, cost = calculate_construction_properties(
+                st.session_state.construction_editor["layers"],
+                available_materials
+            )
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                st.metric("U-Value", f"{u_value:.3f} W/m²·K")
+                st.metric("R-Value", f"{r_value:.3f} m²·K/W")
+            
+            with col2:
+                st.metric("Thermal Mass", f"{thermal_mass:.1f} kJ/m²·K")
+                st.metric("Total Thickness", f"{sum(layer['thickness'] for layer in st.session_state.construction_editor['layers']):.3f} m")
+            
+            with col3:
+                st.metric("Embodied Carbon", f"{embodied_carbon:.1f} kg CO₂e/m²")
+                st.metric("Cost", f"${cost:.2f}/m²")
+        else:
+            st.warning("Add layers to calculate thermal properties.")
+    
+    if save_button:
+        # Validate inputs
+        validation_errors = validate_construction(
+            name, construction_type, st.session_state.construction_editor["layers"],
+            st.session_state.construction_editor["edit_mode"], st.session_state.construction_editor["original_name"]
+        )
+        
+        if validation_errors:
+            # Display validation errors
+            for error in validation_errors:
+                st.error(error)
+        else:
+            # Calculate properties
+            u_value, r_value, thermal_mass, embodied_carbon, cost = calculate_construction_properties(
+                st.session_state.construction_editor["layers"],
+                available_materials
+            )
+            
+            # Create construction data
+            construction_data = {
+                "type": construction_type,
+                "layers": st.session_state.construction_editor["layers"].copy(),
+                "u_value": u_value,
+                "r_value": r_value,
+                "thermal_mass": thermal_mass,
+                "embodied_carbon": embodied_carbon,
+                "cost": cost
+            }
+            
+            # Handle edit mode
+            if st.session_state.construction_editor["edit_mode"]:
+                original_name = st.session_state.construction_editor["original_name"]
+                
+                # If name changed, delete old entry and create new one
+                if original_name != name:
+                    del st.session_state.project_data["constructions"]["project"][original_name]
+                
+                # Update construction
+                st.session_state.project_data["constructions"]["project"][name] = construction_data
+                st.success(f"Construction '{name}' updated successfully.")
+                logger.info(f"Updated construction '{name}' in project")
+            else:
+                # Add new construction
+                st.session_state.project_data["constructions"]["project"][name] = construction_data
+                st.success(f"Construction '{name}' added to your project.")
+                logger.info(f"Added new construction '{name}' to project")
+            
+            # Reset editor
+            reset_construction_editor()
+            st.rerun()
+    
+    if clear_button:
+        reset_construction_editor()
+        st.rerun()
+    
+    if cancel_button and st.session_state.construction_editor["edit_mode"]:
+        reset_construction_editor()
+        st.success("Edit cancelled.")
+        st.rerun()
+
+def get_available_materials() -> Dict[str, Any]:
+    """
+    Get all available materials from both library and project.
+    
+    Returns:
+        Dict of material name to material properties
+    """
+    available_materials = {}
+    
+    # Add library materials
+    if "materials" in st.session_state.project_data and "library" in st.session_state.project_data["materials"]:
+        available_materials.update(st.session_state.project_data["materials"]["library"])
+    
+    # Add project materials
+    if "materials" in st.session_state.project_data and "project" in st.session_state.project_data["materials"]:
+        available_materials.update(st.session_state.project_data["materials"]["project"])
+    
+    return available_materials
+
+def calculate_construction_properties(
+    layers: List[Dict[str, Any]],
+    available_materials: Dict[str, Any]
+) -> Tuple[float, float, float, float, float]:
+    """
+    Calculate thermal properties of a construction.
+    
+    Args:
+        layers: List of layer dictionaries with material and thickness
+        available_materials: Dictionary of available materials
+        
+    Returns:
+        Tuple of (u_value, r_value, thermal_mass, embodied_carbon, cost)
+    """
+    # Initialize values
+    r_value_total = 0.0  # m²·K/W
+    thermal_mass_total = 0.0  # kJ/m²·K
+    embodied_carbon_total = 0.0  # kg CO₂e/m²
+    cost_total = 0.0  # USD/m²
+    
+    # Add standard surface resistances
+    r_value_total += 0.13  # Interior surface resistance
+    r_value_total += 0.04  # Exterior surface resistance
+    
+    # Calculate properties for each layer
+    for layer in layers:
+        material_name = layer["material"]
+        thickness = layer["thickness"]
+        
+        if material_name in available_materials:
+            material = available_materials[material_name]
+            
+            # Calculate R-value for this layer
+            r_value_layer = thickness / material["thermal_conductivity"]
+            r_value_total += r_value_layer
+            
+            # Calculate thermal mass for this layer
+            thermal_mass_layer = material["density"] * material["specific_heat"] * thickness / 1000  # Convert J to kJ
+            thermal_mass_total += thermal_mass_layer
+            
+            # Calculate embodied carbon for this layer
+            embodied_carbon_layer = material["embodied_carbon"] * thickness
+            embodied_carbon_total += embodied_carbon_layer
+            
+            # Calculate cost for this layer
+            cost_layer = material["cost"] * thickness
+            cost_total += cost_layer
+    
+    # Calculate U-value from R-value
+    u_value = 1.0 / r_value_total if r_value_total > 0 else float('inf')
+    
+    return u_value, r_value_total, thermal_mass_total, embodied_carbon_total, cost_total
+
+def validate_construction(
+    name: str, construction_type: str, layers: List[Dict[str, Any]],
+    edit_mode: bool, original_name: str
+) -> List[str]:
+    """
+    Validate construction inputs.
+    
+    Args:
+        name: Construction name
+        construction_type: Construction type
+        layers: List of layer dictionaries
+        edit_mode: Whether in edit mode
+        original_name: Original name if in edit mode
+        
+    Returns:
+        List of validation error messages, empty if all inputs are valid
+    """
+    errors = []
+    
+    # Validate name
+    if not name or name.strip() == "":
+        errors.append("Construction name is required.")
+    
+    # Check for name uniqueness if not in edit mode or if name changed
+    if not edit_mode or (edit_mode and name != original_name):
+        if name in st.session_state.project_data["constructions"]["project"]:
+            errors.append(f"Construction name '{name}' already exists in your project.")
+    
+    # Validate construction type
+    if construction_type not in CONSTRUCTION_TYPES:
+        errors.append("Please select a valid construction type.")
+    
+    # Validate layers
+    if not layers:
+        errors.append("At least one layer is required.")
+    
+    return errors
+
+def reset_construction_editor():
+    """Reset the construction editor to default values."""
+    st.session_state.construction_editor = {
+        "name": "",
+        "type": CONSTRUCTION_TYPES[0],
+        "layers": [],
+        "edit_mode": False,
+        "original_name": ""
+    }
+
+def check_construction_in_use(construction_name: str) -> bool:
+    """
+    Check if a construction is in use in any building components.
+    
+    Args:
+        construction_name: Name of the construction to check
+        
+    Returns:
+        True if the construction is in use, False otherwise
+    """
+    # This is a placeholder function that will be implemented when components are added
+    # For now, we'll assume constructions are not in use
+    return False
+
+def display_construction_help():
+    """Display help information for the construction page."""
+    st.markdown("""
+    ### Construction Library Help
+    
+    This section allows you to create and manage multi-layer constructions for your building envelope.
+    
+    **Key Concepts:**
+    
+    * **Construction**: A multi-layer assembly of materials used for walls, roofs, or floors.
+    * **Layers**: Individual material layers that make up a construction, defined from outside to inside.
+    * **U-Value**: Overall heat transfer coefficient (W/m²·K). Lower values indicate better insulation.
+    * **R-Value**: Thermal resistance (m²·K/W). Higher values indicate better insulation.
+    * **Thermal Mass**: Ability to store heat (kJ/m²·K). Higher values indicate better heat storage capacity.
+    
+    **Library Constructions:**
+    
+    The library contains pre-defined constructions with standard thermal properties. You can:
+    * Browse constructions by type (Wall, Roof, Floor)
+    * View detailed information about each construction
+    * Add library constructions to your project
+    
+    **Project Constructions:**
+    
+    These are constructions you've added to your project from the library or created custom. You can:
+    * View detailed information about each construction
+    * Edit existing constructions
+    * Delete constructions (if not in use)
+    
+    **Construction Editor:**
+    
+    The editor allows you to create new constructions or modify existing ones:
+    * Add layers from outside to inside
+    * Select materials from your material library
+    * Specify thickness for each layer
+    * Calculate overall thermal properties
+    
+    **Workflow:**
+    
+    1. Browse the library constructions
+    2. Add constructions to your project or create custom ones
+    3. Edit properties as needed for your specific project
+    4. Continue to the Building Components page to use these constructions
+    """)

app/embodied_energy.py

@@ -0,0 +1,997 @@
+"""
+HVAC Load Calculator - Embodied Energy Module
+
+This module handles the embodied carbon calculations for building materials,
+life cycle assessment integration, carbon payback period analysis,
+and embodied vs. operational carbon visualization.
+
+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 plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple, Union
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Constants
+YEARS_FOR_ANALYSIS = 60  # Standard building lifecycle for embodied carbon analysis
+REPLACEMENT_CYCLES = {
+    "Structure": 60,  # Years before replacement (typically building lifetime)
+    "Envelope": 30,
+    "Finishes": 15,
+    "MEP Systems": 20,
+    "Furniture": 10
+}
+
+# Default embodied carbon factors (kg CO2e/kg)
+DEFAULT_EMBODIED_CARBON = {
+    "Concrete": 0.12,
+    "Steel": 1.46,
+    "Timber": 0.42,
+    "Brick": 0.24,
+    "Glass": 0.86,
+    "Aluminum": 8.24,
+    "Insulation (mineral wool)": 1.28,
+    "Insulation (EPS)": 3.29,
+    "Gypsum board": 0.39,
+    "Carpet": 3.89,
+    "Ceramic tile": 0.78,
+    "PVC": 3.10,
+    "Paint": 2.54,
+    "HVAC equipment": 3.62,
+    "Electrical equipment": 4.26,
+    "Plumbing fixtures": 2.11
+}
+
+def display_embodied_energy_page():
+    """
+    Display the embodied energy page.
+    This is the main function called by main.py when the Embodied Energy page is selected.
+    """
+    st.title("Embodied Energy Analysis")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_embodied_energy_help()
+    
+    # Check if building components have been defined
+    if "components" not in st.session_state.project_data or not st.session_state.project_data["components"]:
+        st.warning("Please define building components before proceeding to Embodied Energy analysis.")
+        
+        # Navigation buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Back to Building Components", key="back_to_components_ee"):
+                st.session_state.current_page = "Building Components"
+                st.rerun()
+        return
+    
+    # Initialize embodied energy data if not present
+    initialize_embodied_energy_data()
+    
+    # Create tabs for different aspects of embodied energy analysis
+    tabs = st.tabs(["Material Inventory", "Embodied Carbon", "Carbon Payback"])
+    
+    with tabs[0]:
+        display_material_inventory_tab()
+    
+    with tabs[1]:
+        display_embodied_carbon_tab()
+    
+    with tabs[2]:
+        display_carbon_payback_tab()
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Renewable Energy", key="back_to_renewable_energy"):
+            st.session_state.current_page = "Renewable Energy"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Materials Cost", key="continue_to_materials_cost"):
+            st.session_state.current_page = "Materials Cost"
+            st.rerun()
+
+def initialize_embodied_energy_data():
+    """Initialize embodied energy data in session state if not present."""
+    if "embodied_energy" not in st.session_state.project_data:
+        st.session_state.project_data["embodied_energy"] = {
+            "material_inventory": [],
+            "embodied_carbon_factors": DEFAULT_EMBODIED_CARBON.copy(),
+            "results": None
+        }
+    
+    # Initialize material inventory if empty
+    if not st.session_state.project_data["embodied_energy"]["material_inventory"]:
+        # Generate initial material inventory from building components
+        material_inventory = generate_material_inventory_from_components()
+        st.session_state.project_data["embodied_energy"]["material_inventory"] = material_inventory
+
+def generate_material_inventory_from_components() -> List[Dict[str, Any]]:
+    """
+    Generate material inventory from building components.
+    
+    Returns:
+        List of material items with quantities and properties.
+    """
+    logger.info("Generating material inventory from building components...")
+    
+    material_inventory = []
+    
+    # Get building components
+    components = st.session_state.project_data["components"]
+    
+    # Get constructions
+    constructions = st.session_state.project_data["constructions"]
+    
+    # Get materials
+    materials = st.session_state.project_data["materials"]
+    
+    # Process opaque components (walls, roofs, floors)
+    for comp_type in ["walls", "roofs", "floors"]:
+        for comp in components.get(comp_type, []):
+            # Get construction details
+            construction_id = comp.get("construction_id")
+            if not construction_id:
+                continue
+                
+            construction = next((c for c in constructions if c["id"] == construction_id), None)
+            if not construction:
+                continue
+                
+            # Calculate component area
+            area = comp.get("area", 0)
+            
+            # Process each layer in the construction
+            for layer in construction.get("layers", []):
+                material_id = layer.get("material_id")
+                if not material_id:
+                    continue
+                    
+                material = next((m for m in materials if m["id"] == material_id), None)
+                if not material:
+                    continue
+                
+                # Calculate material quantity
+                thickness = layer.get("thickness", 0)  # m
+                density = material.get("density", 0)  # kg/m³
+                volume = area * thickness  # m³
+                mass = volume * density  # kg
+                
+                # Get material category
+                category = get_material_category(material.get("name", ""))
+                
+                # Create material inventory item
+                item = {
+                    "component_type": comp_type,
+                    "component_name": comp.get("name", ""),
+                    "material_name": material.get("name", ""),
+                    "material_category": category,
+                    "quantity": mass,  # kg
+                    "unit": "kg",
+                    "volume": volume,  # m³
+                    "area": area,  # m²
+                    "thickness": thickness,  # m
+                    "density": density,  # kg/m³
+                    "replacement_cycle": REPLACEMENT_CYCLES.get(category, YEARS_FOR_ANALYSIS)
+                }
+                
+                material_inventory.append(item)
+    
+    # Process fenestration components (windows, doors, skylights)
+    for comp_type in ["windows", "doors", "skylights"]:
+        for comp in components.get(comp_type, []):
+            # Get fenestration details
+            fenestration_id = comp.get("fenestration_id")
+            if not fenestration_id:
+                continue
+                
+            fenestration = next((f for f in materials if f["id"] == fenestration_id), None)
+            if not fenestration:
+                continue
+                
+            # Calculate component area
+            area = comp.get("area", 0)
+            
+            # Estimate material quantities based on fenestration type
+            if comp_type == "windows":
+                # Typical window composition
+                glass_mass = area * 2.5 * 2500  # 2.5 cm thick glass at 2500 kg/m³
+                frame_mass = area * 0.1 * 2700  # 10% frame area, aluminum at 2700 kg/m³
+                
+                # Add glass
+                material_inventory.append({
+                    "component_type": comp_type,
+                    "component_name": comp.get("name", ""),
+                    "material_name": "Glass",
+                    "material_category": "Envelope",
+                    "quantity": glass_mass,
+                    "unit": "kg",
+                    "volume": area * 0.025,
+                    "area": area,
+                    "thickness": 0.025,
+                    "density": 2500,
+                    "replacement_cycle": REPLACEMENT_CYCLES.get("Envelope", YEARS_FOR_ANALYSIS)
+                })
+                
+                # Add frame
+                material_inventory.append({
+                    "component_type": comp_type,
+                    "component_name": comp.get("name", ""),
+                    "material_name": "Aluminum",
+                    "material_category": "Envelope",
+                    "quantity": frame_mass,
+                    "unit": "kg",
+                    "volume": area * 0.1 * 0.05,
+                    "area": area * 0.1,
+                    "thickness": 0.05,
+                    "density": 2700,
+                    "replacement_cycle": REPLACEMENT_CYCLES.get("Envelope", YEARS_FOR_ANALYSIS)
+                })
+            
+            elif comp_type == "doors":
+                # Typical door composition
+                if "glass" in fenestration.get("name", "").lower():
+                    # Glass door
+                    glass_mass = area * 1.2 * 2500  # 1.2 cm thick glass at 2500 kg/m³
+                    frame_mass = area * 0.15 * 2700  # 15% frame area, aluminum at 2700 kg/m³
+                    
+                    material_inventory.append({
+                        "component_type": comp_type,
+                        "component_name": comp.get("name", ""),
+                        "material_name": "Glass",
+                        "material_category": "Envelope",
+                        "quantity": glass_mass,
+                        "unit": "kg",
+                        "volume": area * 0.012,
+                        "area": area,
+                        "thickness": 0.012,
+                        "density": 2500,
+                        "replacement_cycle": REPLACEMENT_CYCLES.get("Envelope", YEARS_FOR_ANALYSIS)
+                    })
+                    
+                    material_inventory.append({
+                        "component_type": comp_type,
+                        "component_name": comp.get("name", ""),
+                        "material_name": "Aluminum",
+                        "material_category": "Envelope",
+                        "quantity": frame_mass,
+                        "unit": "kg",
+                        "volume": area * 0.15 * 0.05,
+                        "area": area * 0.15,
+                        "thickness": 0.05,
+                        "density": 2700,
+                        "replacement_cycle": REPLACEMENT_CYCLES.get("Envelope", YEARS_FOR_ANALYSIS)
+                    })
+                else:
+                    # Solid door
+                    door_mass = area * 0.04 * 700  # 4 cm thick wood at 700 kg/m³
+                    
+                    material_inventory.append({
+                        "component_type": comp_type,
+                        "component_name": comp.get("name", ""),
+                        "material_name": "Timber",
+                        "material_category": "Envelope",
+                        "quantity": door_mass,
+                        "unit": "kg",
+                        "volume": area * 0.04,
+                        "area": area,
+                        "thickness": 0.04,
+                        "density": 700,
+                        "replacement_cycle": REPLACEMENT_CYCLES.get("Envelope", YEARS_FOR_ANALYSIS)
+                    })
+            
+            elif comp_type == "skylights":
+                # Typical skylight composition
+                glass_mass = area * 2.0 * 2500  # 2.0 cm thick glass at 2500 kg/m³
+                frame_mass = area * 0.12 * 2700  # 12% frame area, aluminum at 2700 kg/m³
+                
+                material_inventory.append({
+                    "component_type": comp_type,
+                    "component_name": comp.get("name", ""),
+                    "material_name": "Glass",
+                    "material_category": "Envelope",
+                    "quantity": glass_mass,
+                    "unit": "kg",
+                    "volume": area * 0.02,
+                    "area": area,
+                    "thickness": 0.02,
+                    "density": 2500,
+                    "replacement_cycle": REPLACEMENT_CYCLES.get("Envelope", YEARS_FOR_ANALYSIS)
+                })
+                
+                material_inventory.append({
+                    "component_type": comp_type,
+                    "component_name": comp.get("name", ""),
+                    "material_name": "Aluminum",
+                    "material_category": "Envelope",
+                    "quantity": frame_mass,
+                    "unit": "kg",
+                    "volume": area * 0.12 * 0.05,
+                    "area": area * 0.12,
+                    "thickness": 0.05,
+                    "density": 2700,
+                    "replacement_cycle": REPLACEMENT_CYCLES.get("Envelope", YEARS_FOR_ANALYSIS)
+                })
+    
+    # Add HVAC equipment (estimated based on building size)
+    building_info = st.session_state.project_data["building_info"]
+    floor_area = building_info.get("floor_area", 0)
+    
+    # HVAC equipment (estimated at 15 kg/m²)
+    hvac_mass = floor_area * 15
+    
+    material_inventory.append({
+        "component_type": "systems",
+        "component_name": "HVAC System",
+        "material_name": "HVAC equipment",
+        "material_category": "MEP Systems",
+        "quantity": hvac_mass,
+        "unit": "kg",
+        "volume": 0,
+        "area": 0,
+        "thickness": 0,
+        "density": 0,
+        "replacement_cycle": REPLACEMENT_CYCLES.get("MEP Systems", YEARS_FOR_ANALYSIS)
+    })
+    
+    # Electrical equipment (estimated at 5 kg/m²)
+    electrical_mass = floor_area * 5
+    
+    material_inventory.append({
+        "component_type": "systems",
+        "component_name": "Electrical System",
+        "material_name": "Electrical equipment",
+        "material_category": "MEP Systems",
+        "quantity": electrical_mass,
+        "unit": "kg",
+        "volume": 0,
+        "area": 0,
+        "thickness": 0,
+        "density": 0,
+        "replacement_cycle": REPLACEMENT_CYCLES.get("MEP Systems", YEARS_FOR_ANALYSIS)
+    })
+    
+    # Plumbing fixtures (estimated at 3 kg/m²)
+    plumbing_mass = floor_area * 3
+    
+    material_inventory.append({
+        "component_type": "systems",
+        "component_name": "Plumbing System",
+        "material_name": "Plumbing fixtures",
+        "material_category": "MEP Systems",
+        "quantity": plumbing_mass,
+        "unit": "kg",
+        "volume": 0,
+        "area": 0,
+        "thickness": 0,
+        "density": 0,
+        "replacement_cycle": REPLACEMENT_CYCLES.get("MEP Systems", YEARS_FOR_ANALYSIS)
+    })
+    
+    logger.info(f"Generated material inventory with {len(material_inventory)} items.")
+    return material_inventory
+
+def get_material_category(material_name: str) -> str:
+    """
+    Determine the material category based on the material name.
+    
+    Args:
+        material_name: Name of the material
+        
+    Returns:
+        Category of the material
+    """
+    material_name_lower = material_name.lower()
+    
+    if any(term in material_name_lower for term in ["concrete", "steel", "timber", "wood", "brick", "stone", "structural"]):
+        return "Structure"
+    
+    elif any(term in material_name_lower for term in ["insulation", "cladding", "siding", "roofing", "glass", "window", "door"]):
+        return "Envelope"
+    
+    elif any(term in material_name_lower for term in ["paint", "carpet", "tile", "flooring", "ceiling", "gypsum", "drywall"]):
+        return "Finishes"
+    
+    elif any(term in material_name_lower for term in ["hvac", "electrical", "plumbing", "mechanical", "pipe", "duct", "wire"]):
+        return "MEP Systems"
+    
+    elif any(term in material_name_lower for term in ["furniture", "fixture", "equipment", "appliance"]):
+        return "Furniture"
+    
+    else:
+        return "Other"
+
+def display_material_inventory_tab():
+    """Display the material inventory tab."""
+    st.header("Material Inventory")
+    
+    # Get material inventory
+    material_inventory = st.session_state.project_data["embodied_energy"]["material_inventory"]
+    
+    # Allow user to edit material inventory
+    st.subheader("Edit Material Inventory")
+    
+    # Create a DataFrame for display and editing
+    if material_inventory:
+        df = pd.DataFrame(material_inventory)
+        
+        # Select columns for display
+        display_columns = ["component_type", "component_name", "material_name", "material_category", "quantity", "unit", "replacement_cycle"]
+        display_df = df[display_columns].copy()
+        
+        # Format column names for display
+        display_df.columns = [col.replace("_", " ").title() for col in display_columns]
+        
+        # Display the inventory table
+        st.dataframe(display_df)
+        
+        # Allow adding new materials
+        st.subheader("Add New Material")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            new_component_type = st.selectbox(
+                "Component Type",
+                ["walls", "roofs", "floors", "windows", "doors", "skylights", "systems", "other"],
+                key="new_material_component_type"
+            )
+            
+            new_component_name = st.text_input(
+                "Component Name",
+                key="new_material_component_name"
+            )
+            
+            new_material_name = st.selectbox(
+                "Material Name",
+                list(DEFAULT_EMBODIED_CARBON.keys()),
+                key="new_material_name"
+            )
+        
+        with col2:
+            new_material_category = st.selectbox(
+                "Material Category",
+                list(REPLACEMENT_CYCLES.keys()),
+                key="new_material_category"
+            )
+            
+            new_quantity = st.number_input(
+                "Quantity (kg)",
+                min_value=0.0,
+                value=100.0,
+                step=10.0,
+                key="new_material_quantity"
+            )
+            
+            new_replacement_cycle = st.number_input(
+                "Replacement Cycle (years)",
+                min_value=1,
+                max_value=100,
+                value=REPLACEMENT_CYCLES.get(new_material_category, YEARS_FOR_ANALYSIS),
+                step=1,
+                key="new_material_replacement_cycle"
+            )
+        
+        if st.button("Add Material", key="add_material_button"):
+            # Create new material inventory item
+            new_item = {
+                "component_type": new_component_type,
+                "component_name": new_component_name,
+                "material_name": new_material_name,
+                "material_category": new_material_category,
+                "quantity": new_quantity,
+                "unit": "kg",
+                "volume": 0,
+                "area": 0,
+                "thickness": 0,
+                "density": 0,
+                "replacement_cycle": new_replacement_cycle
+            }
+            
+            # Add to inventory
+            material_inventory.append(new_item)
+            st.success(f"Added {new_material_name} to inventory.")
+            st.rerun()
+    else:
+        st.info("No materials in inventory. Generate inventory from building components.")
+    
+    # Button to regenerate inventory
+    if st.button("Regenerate Inventory from Components", key="regenerate_inventory"):
+        material_inventory = generate_material_inventory_from_components()
+        st.session_state.project_data["embodied_energy"]["material_inventory"] = material_inventory
+        st.success("Material inventory regenerated from building components.")
+        st.rerun()
+    
+    # Display material inventory summary
+    if material_inventory:
+        st.subheader("Material Inventory Summary")
+        
+        # Create summary by material category
+        category_summary = {}
+        for item in material_inventory:
+            category = item["material_category"]
+            quantity = item["quantity"]
+            
+            if category in category_summary:
+                category_summary[category] += quantity
+            else:
+                category_summary[category] = quantity
+        
+        # Create summary chart
+        fig = px.pie(
+            values=list(category_summary.values()),
+            names=list(category_summary.keys()),
+            title="Material Quantity by Category (kg)"
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Display total material quantity
+        total_quantity = sum(category_summary.values())
+        st.metric("Total Material Quantity", f"{total_quantity:.0f} kg")
+
+def display_embodied_carbon_tab():
+    """Display the embodied carbon analysis tab."""
+    st.header("Embodied Carbon Analysis")
+    
+    # Get material inventory and embodied carbon factors
+    material_inventory = st.session_state.project_data["embodied_energy"]["material_inventory"]
+    embodied_carbon_factors = st.session_state.project_data["embodied_energy"]["embodied_carbon_factors"]
+    
+    if not material_inventory:
+        st.info("Please define material inventory in the Material Inventory tab.")
+        return
+    
+    # Allow user to edit embodied carbon factors
+    st.subheader("Embodied Carbon Factors")
+    
+    # Create a DataFrame for display and editing
+    factor_df = pd.DataFrame({
+        "Material": list(embodied_carbon_factors.keys()),
+        "Embodied Carbon (kg CO2e/kg)": list(embodied_carbon_factors.values())
+    })
+    
+    # Display the factors table
+    edited_factor_df = st.data_editor(
+        factor_df,
+        column_config={
+            "Material": st.column_config.TextColumn("Material"),
+            "Embodied Carbon (kg CO2e/kg)": st.column_config.NumberColumn(
+                "Embodied Carbon (kg CO2e/kg)",
+                min_value=0.0,
+                max_value=20.0,
+                step=0.01,
+                format="%.2f"
+            )
+        },
+        use_container_width=True,
+        key="embodied_carbon_factors_editor"
+    )
+    
+    # Update embodied carbon factors if edited
+    if not factor_df.equals(edited_factor_df):
+        updated_factors = dict(zip(edited_factor_df["Material"], edited_factor_df["Embodied Carbon (kg CO2e/kg)"]))
+        st.session_state.project_data["embodied_energy"]["embodied_carbon_factors"] = updated_factors
+        embodied_carbon_factors = updated_factors
+    
+    # Calculate embodied carbon button
+    if st.button("Calculate Embodied Carbon", key="calculate_embodied_carbon"):
+        try:
+            results = calculate_embodied_carbon(material_inventory, embodied_carbon_factors)
+            st.session_state.project_data["embodied_energy"]["results"] = results
+            st.success("Embodied carbon calculated successfully.")
+            logger.info("Embodied carbon calculated.")
+            st.rerun()  # Refresh to show results
+        except Exception as e:
+            st.error(f"Error calculating embodied carbon: {e}")
+            logger.error(f"Error calculating embodied carbon: {e}", exc_info=True)
+            st.session_state.project_data["embodied_energy"]["results"] = None
+    
+    # Display embodied carbon results if available
+    results = st.session_state.project_data["embodied_energy"].get("results")
+    if results:
+        display_embodied_carbon_results(results)
+
+def display_embodied_carbon_results(results: Dict[str, Any]):
+    """Display the embodied carbon calculation results."""
+    st.subheader("Embodied Carbon Summary")
+    
+    # Get building info for normalization
+    building_info = st.session_state.project_data["building_info"]
+    floor_area = building_info.get("floor_area", 0)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Total Initial Embodied Carbon",
+            f"{results['total_initial_embodied_carbon']:.1f} tonnes CO2e",
+            help="Total embodied carbon from initial construction."
+        )
+    
+    with col2:
+        st.metric(
+            "Total Lifecycle Embodied Carbon",
+            f"{results['total_lifecycle_embodied_carbon']:.1f} tonnes CO2e",
+            help=f"Total embodied carbon over {YEARS_FOR_ANALYSIS} years including replacements."
+        )
+    
+    # Display normalized metrics
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Initial Embodied Carbon Intensity",
+            f"{results['initial_embodied_carbon_intensity']:.1f} kg CO2e/m²",
+            help="Initial embodied carbon per square meter of floor area."
+        )
+    
+    with col2:
+        st.metric(
+            "Lifecycle Embodied Carbon Intensity",
+            f"{results['lifecycle_embodied_carbon_intensity']:.1f} kg CO2e/m²",
+            help=f"Lifecycle embodied carbon per square meter of floor area over {YEARS_FOR_ANALYSIS} years."
+        )
+    
+    # Display embodied carbon breakdown by category
+    st.subheader("Embodied Carbon by Category")
+    
+    # Create pie chart of initial embodied carbon by category
+    fig_initial = px.pie(
+        values=list(results["initial_embodied_carbon_by_category"].values()),
+        names=list(results["initial_embodied_carbon_by_category"].keys()),
+        title="Initial Embodied Carbon by Category"
+    )
+    st.plotly_chart(fig_initial, use_container_width=True)
+    
+    # Create pie chart of lifecycle embodied carbon by category
+    fig_lifecycle = px.pie(
+        values=list(results["lifecycle_embodied_carbon_by_category"].values()),
+        names=list(results["lifecycle_embodied_carbon_by_category"].keys()),
+        title=f"Lifecycle Embodied Carbon by Category ({YEARS_FOR_ANALYSIS} years)"
+    )
+    st.plotly_chart(fig_lifecycle, use_container_width=True)
+    
+    # Display embodied carbon breakdown by material
+    st.subheader("Top 10 Materials by Embodied Carbon")
+    
+    # Create bar chart of top 10 materials by initial embodied carbon
+    top_materials_df = pd.DataFrame({
+        "Material": list(results["initial_embodied_carbon_by_material"].keys()),
+        "Initial Embodied Carbon (tonnes CO2e)": list(results["initial_embodied_carbon_by_material"].values())
+    })
+    
+    top_materials_df = top_materials_df.sort_values(
+        by="Initial Embodied Carbon (tonnes CO2e)",
+        ascending=False
+    ).head(10)
+    
+    fig_top_materials = px.bar(
+        top_materials_df,
+        x="Material",
+        y="Initial Embodied Carbon (tonnes CO2e)",
+        title="Top 10 Materials by Initial Embodied Carbon"
+    )
+    st.plotly_chart(fig_top_materials, use_container_width=True)
+    
+    # Display embodied carbon over time
+    st.subheader("Embodied Carbon Over Time")
+    
+    # Create line chart of cumulative embodied carbon over time
+    years = list(range(0, YEARS_FOR_ANALYSIS + 1, 5))
+    cumulative_carbon = [results["cumulative_embodied_carbon"].get(str(year), 0) for year in years]
+    
+    fig_over_time = px.line(
+        x=years,
+        y=cumulative_carbon,
+        title="Cumulative Embodied Carbon Over Time",
+        labels={"x": "Year", "y": "Cumulative Embodied Carbon (tonnes CO2e)"}
+    )
+    st.plotly_chart(fig_over_time, use_container_width=True)
+
+def display_carbon_payback_tab():
+    """Display the carbon payback analysis tab."""
+    st.header("Carbon Payback Analysis")
+    
+    # Check if embodied carbon results are available
+    embodied_results = st.session_state.project_data["embodied_energy"].get("results")
+    if not embodied_results:
+        st.info("Please calculate embodied carbon in the Embodied Carbon tab.")
+        return
+    
+    # Check if operational carbon results are available
+    if "building_energy" not in st.session_state.project_data or not st.session_state.project_data["building_energy"].get("results"):
+        st.info("Please complete the Building Energy analysis to calculate operational carbon.")
+        return
+    
+    # Check if renewable energy results are available
+    renewable_results = None
+    if "renewable_energy" in st.session_state.project_data and st.session_state.project_data["renewable_energy"].get("results"):
+        renewable_results = st.session_state.project_data["renewable_energy"]["results"]
+    
+    # Get operational carbon from building energy results
+    building_energy_results = st.session_state.project_data["building_energy"]["results"]
+    annual_operational_carbon = building_energy_results["annual_carbon_emissions"]  # tonnes CO2e/year
+    
+    # Calculate carbon payback
+    lifecycle_embodied_carbon = embodied_results["total_lifecycle_embodied_carbon"]  # tonnes CO2e
+    
+    # Display carbon comparison
+    st.subheader("Embodied vs. Operational Carbon")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Lifecycle Embodied Carbon",
+            f"{lifecycle_embodied_carbon:.1f} tonnes CO2e",
+            help=f"Total embodied carbon over {YEARS_FOR_ANALYSIS} years including replacements."
+        )
+    
+    with col2:
+        st.metric(
+            "Annual Operational Carbon",
+            f"{annual_operational_carbon:.1f} tonnes CO2e/year",
+            help="Annual carbon emissions from building operation."
+        )
+    
+    # Calculate total operational carbon over building lifecycle
+    total_operational_carbon = annual_operational_carbon * YEARS_FOR_ANALYSIS
+    
+    # Calculate total lifecycle carbon
+    total_lifecycle_carbon = lifecycle_embodied_carbon + total_operational_carbon
+    
+    # Display total lifecycle carbon
+    st.metric(
+        f"Total Lifecycle Carbon ({YEARS_FOR_ANALYSIS} years)",
+        f"{total_lifecycle_carbon:.1f} tonnes CO2e",
+        help=f"Total carbon emissions over {YEARS_FOR_ANALYSIS} years (embodied + operational)."
+    )
+    
+    # Create pie chart of embodied vs. operational carbon
+    carbon_breakdown = {
+        "Embodied Carbon": lifecycle_embodied_carbon,
+        "Operational Carbon": total_operational_carbon
+    }
+    
+    fig_breakdown = px.pie(
+        values=list(carbon_breakdown.values()),
+        names=list(carbon_breakdown.keys()),
+        title=f"Lifecycle Carbon Breakdown ({YEARS_FOR_ANALYSIS} years)"
+    )
+    st.plotly_chart(fig_breakdown, use_container_width=True)
+    
+    # Calculate carbon payback period
+    st.subheader("Carbon Payback Analysis")
+    
+    # If renewable energy results are available, calculate carbon savings
+    if renewable_results:
+        # Get annual PV generation
+        annual_pv_generation = renewable_results["annual_pv_generation"]  # kWh
+        
+        # Calculate carbon savings from PV
+        electricity_carbon_intensity = building_energy_results["energy_rates"]["electricity"]["carbon_intensity"]  # kg CO2e/kWh
+        annual_carbon_savings = (annual_pv_generation * electricity_carbon_intensity) / 1000  # tonnes CO2e/year
+        
+        # Calculate carbon payback period
+        initial_embodied_carbon = embodied_results["total_initial_embodied_carbon"]  # tonnes CO2e
+        
+        if annual_carbon_savings > 0:
+            carbon_payback_period = initial_embodied_carbon / annual_carbon_savings
+            
+            st.metric(
+                "Carbon Payback Period",
+                f"{carbon_payback_period:.1f} years",
+                help="Years required for operational carbon savings to offset initial embodied carbon."
+            )
+            
+            # Create carbon payback chart
+            years = list(range(0, min(int(carbon_payback_period * 2), YEARS_FOR_ANALYSIS) + 1))
+            embodied_carbon = [initial_embodied_carbon] * len(years)
+            carbon_savings = [year * annual_carbon_savings for year in years]
+            
+            fig_payback = go.Figure()
+            
+            fig_payback.add_trace(go.Scatter(
+                x=years,
+                y=embodied_carbon,
+                mode="lines",
+                name="Initial Embodied Carbon"
+            ))
+            
+            fig_payback.add_trace(go.Scatter(
+                x=years,
+                y=carbon_savings,
+                mode="lines",
+                name="Cumulative Carbon Savings"
+            ))
+            
+            fig_payback.update_layout(
+                title="Carbon Payback Analysis",
+                xaxis_title="Year",
+                yaxis_title="Carbon (tonnes CO2e)"
+            )
+            
+            st.plotly_chart(fig_payback, use_container_width=True)
+        else:
+            st.warning("No carbon savings from renewable energy. Carbon payback period is infinite.")
+    else:
+        st.info("Please calculate PV generation in the Renewable Energy section for carbon payback analysis.")
+    
+    # Display carbon reduction strategies
+    st.subheader("Carbon Reduction Strategies")
+    
+    # Create a DataFrame of potential strategies
+    strategies_data = {
+        "Strategy": [
+            "Use low-carbon materials",
+            "Optimize structural design",
+            "Increase renewable energy capacity",
+            "Improve building envelope",
+            "Extend material lifespans"
+        ],
+        "Potential Reduction": [
+            "20-30% embodied carbon",
+            "15-25% embodied carbon",
+            "50-100% operational carbon",
+            "20-40% operational carbon",
+            "10-20% lifecycle embodied carbon"
+        ],
+        "Implementation Difficulty": [
+            "Medium",
+            "High",
+            "Medium",
+            "Medium",
+            "Low"
+        ]
+    }
+    
+    strategies_df = pd.DataFrame(strategies_data)
+    st.table(strategies_df)
+
+def calculate_embodied_carbon(material_inventory: List[Dict[str, Any]], embodied_carbon_factors: Dict[str, float]) -> Dict[str, Any]:
+    """
+    Calculate embodied carbon based on material inventory and carbon factors.
+    
+    Args:
+        material_inventory: List of material items with quantities
+        embodied_carbon_factors: Dictionary of embodied carbon factors by material
+        
+    Returns:
+        Dictionary containing embodied carbon results
+    """
+    logger.info("Starting embodied carbon calculations...")
+    
+    # Initialize results
+    initial_embodied_carbon_by_material = {}
+    initial_embodied_carbon_by_category = {}
+    lifecycle_embodied_carbon_by_category = {}
+    cumulative_embodied_carbon = {"0": 0}
+    
+    # Calculate embodied carbon for each material
+    for item in material_inventory:
+        material_name = item["material_name"]
+        category = item["material_category"]
+        quantity = item["quantity"]  # kg
+        replacement_cycle = item["replacement_cycle"]  # years
+        
+        # Get embodied carbon factor
+        carbon_factor = embodied_carbon_factors.get(material_name, 0)  # kg CO2e/kg
+        
+        # Calculate initial embodied carbon (tonnes CO2e)
+        initial_carbon = (quantity * carbon_factor) / 1000
+        
+        # Add to material totals
+        if material_name in initial_embodied_carbon_by_material:
+            initial_embodied_carbon_by_material[material_name] += initial_carbon
+        else:
+            initial_embodied_carbon_by_material[material_name] = initial_carbon
+        
+        # Add to category totals
+        if category in initial_embodied_carbon_by_category:
+            initial_embodied_carbon_by_category[category] += initial_carbon
+        else:
+            initial_embodied_carbon_by_category[category] = initial_carbon
+        
+        # Calculate lifecycle embodied carbon with replacements
+        num_replacements = YEARS_FOR_ANALYSIS // replacement_cycle
+        lifecycle_carbon = initial_carbon * (num_replacements + 1)  # +1 for initial installation
+        
+        # Add to lifecycle category totals
+        if category in lifecycle_embodied_carbon_by_category:
+            lifecycle_embodied_carbon_by_category[category] += lifecycle_carbon
+        else:
+            lifecycle_embodied_carbon_by_category[category] = lifecycle_carbon
+        
+        # Add to cumulative carbon over time
+        cumulative_embodied_carbon["0"] += initial_carbon
+        
+        for year in range(replacement_cycle, YEARS_FOR_ANALYSIS + 1, replacement_cycle):
+            year_str = str(year)
+            if year_str not in cumulative_embodied_carbon:
+                cumulative_embodied_carbon[year_str] = cumulative_embodied_carbon[str(year - replacement_cycle)]
+            
+            cumulative_embodied_carbon[year_str] += initial_carbon
+    
+    # Calculate totals
+    total_initial_embodied_carbon = sum(initial_embodied_carbon_by_material.values())
+    total_lifecycle_embodied_carbon = sum(lifecycle_embodied_carbon_by_category.values())
+    
+    # Get building info for normalization
+    building_info = st.session_state.project_data["building_info"]
+    floor_area = building_info.get("floor_area", 0)
+    
+    # Calculate normalized metrics
+    initial_embodied_carbon_intensity = (total_initial_embodied_carbon * 1000) / floor_area if floor_area > 0 else 0
+    lifecycle_embodied_carbon_intensity = (total_lifecycle_embodied_carbon * 1000) / floor_area if floor_area > 0 else 0
+    
+    # Compile results
+    results = {
+        "initial_embodied_carbon_by_material": initial_embodied_carbon_by_material,
+        "initial_embodied_carbon_by_category": initial_embodied_carbon_by_category,
+        "lifecycle_embodied_carbon_by_category": lifecycle_embodied_carbon_by_category,
+        "cumulative_embodied_carbon": cumulative_embodied_carbon,
+        "total_initial_embodied_carbon": total_initial_embodied_carbon,
+        "total_lifecycle_embodied_carbon": total_lifecycle_embodied_carbon,
+        "initial_embodied_carbon_intensity": initial_embodied_carbon_intensity,
+        "lifecycle_embodied_carbon_intensity": lifecycle_embodied_carbon_intensity,
+        "calculation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    logger.info("Embodied carbon calculations completed.")
+    return results
+
+def display_embodied_energy_help():
+    """
+    Display help information for the embodied energy page.
+    """
+    st.markdown("""
+    ### Embodied Energy Analysis Help
+    
+    This section calculates the embodied carbon of building materials, analyzes lifecycle carbon emissions, and evaluates carbon payback periods.
+    
+    **Key Concepts:**
+    
+    * **Embodied Carbon**: Greenhouse gas emissions associated with materials throughout their lifecycle (extraction, manufacturing, transportation, installation, replacement, and disposal).
+    * **Initial Embodied Carbon**: Carbon emissions from the initial construction of the building.
+    * **Lifecycle Embodied Carbon**: Total carbon emissions over the building's lifespan, including initial construction and material replacements.
+    * **Carbon Intensity**: Embodied carbon per unit area (kg CO2e/m²).
+    * **Carbon Payback Period**: Time required for operational carbon savings (e.g., from renewable energy) to offset the embodied carbon.
+    
+    **Workflow:**
+    
+    1. **Material Inventory Tab**:
+        * Review the automatically generated material inventory based on building components.
+        * Add or modify materials as needed.
+        * View material quantity summary by category.
+    
+    2. **Embodied Carbon Tab**:
+        * Adjust embodied carbon factors for different materials if needed.
+        * Calculate embodied carbon based on the material inventory.
+        * Analyze embodied carbon breakdown by category and material.
+        * View embodied carbon accumulation over the building's lifespan.
+    
+    3. **Carbon Payback Tab**:
+        * Compare embodied carbon with operational carbon.
+        * Analyze the carbon payback period if renewable energy is implemented.
+        * Explore carbon reduction strategies.
+    
+    **Important:**
+    
+    * Accurate material quantities are crucial for embodied carbon calculations.
+    * Embodied carbon factors vary by region and manufacturing process.
+    * The standard analysis period is 60 years, but different materials have different replacement cycles.
+    * Carbon payback analysis requires both embodied carbon and operational carbon data.
+    """)

app/hvac_loads.py

@@ -0,0 +1,683 @@
+"""
+HVAC Load Calculator - 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.
+
+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
+
+# 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
+    
+    # Calculation trigger
+    if st.button("Calculate HVAC Loads", key="calculate_hvac_loads"):
+        try:
+            results = calculate_loads()
+            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 calculate_loads() -> Dict[str, Any]:
+    """
+    Perform the main HVAC load calculations.
+    
+    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 = pd.DataFrame(climate_data["hourly_data"])
+    
+    # --- 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 every hour of the year
+    solar_angles = calculate_solar_angles(latitude, longitude, timezone, hourly_data.index)
+    hourly_data = pd.concat([hourly_data, solar_angles], axis=1)
+    
+    # --- Heat Transfer Calculations --- #
+    logger.info("Calculating heat transfer through components...")
+    cooling_loads = {
+        "opaque_conduction": np.zeros(8760),
+        "fenestration_conduction": np.zeros(8760),
+        "fenestration_solar": np.zeros(8760),
+        "infiltration": np.zeros(8760),
+        "ventilation": np.zeros(8760),
+        "internal_sensible": np.zeros(8760),
+        "internal_latent": np.zeros(8760)
+    }
+    heating_loads = {
+        "opaque_conduction": np.zeros(8760),
+        "fenestration_conduction": np.zeros(8760),
+        "infiltration": np.zeros(8760),
+        "ventilation": np.zeros(8760)
+    }
+    
+    # 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(
+                hourly_data["Dry Bulb Temperature"],
+                hourly_data["Direct Normal Radiation"],
+                hourly_data["Diffuse Horizontal Radiation"],
+                hourly_data["solar_altitude"],
+                hourly_data["solar_azimuth"],
+                tilt,
+                surface_azimuth,
+                absorptivity=ABSORPTIVITY_DEFAULT,  # TODO: Get from material/construction
+                emissivity=EMISSIVITY_DEFAULT,  # TODO: Get from material/construction
+                h_o=20.0  # TODO: Calculate based on wind speed
+            )
+            
+            # Calculate conduction heat gain/loss
+            delta_t_cooling = sol_air_temp - design_conditions["cooling_indoor_temp"]
+            delta_t_heating = design_conditions["heating_indoor_temp"] - hourly_data["Dry Bulb Temperature"] # Use outdoor air temp for heating loss
+            
+            conduction_gain = u_value * area * delta_t_cooling
+            conduction_loss = u_value * area * delta_t_heating
+            
+            cooling_loads["opaque_conduction"] += np.maximum(0, conduction_gain) # Only gain for cooling
+            heating_loads["opaque_conduction"] += np.maximum(0, conduction_loss) # Only loss for heating
+
+    # 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 on the surface
+            incident_solar = calculate_incident_solar(
+                hourly_data["Direct Normal Radiation"],
+                hourly_data["Diffuse Horizontal Radiation"],
+                hourly_data["solar_altitude"],
+                hourly_data["solar_azimuth"],
+                tilt,
+                surface_azimuth
+            )
+            
+            # Calculate conduction heat gain/loss
+            delta_t_cooling = hourly_data["Dry Bulb Temperature"] - design_conditions["cooling_indoor_temp"]
+            delta_t_heating = design_conditions["heating_indoor_temp"] - hourly_data["Dry Bulb Temperature"]
+            
+            conduction_gain = u_value * area * delta_t_cooling
+            conduction_loss = u_value * area * delta_t_heating
+            
+            cooling_loads["fenestration_conduction"] += np.maximum(0, conduction_gain)
+            heating_loads["fenestration_conduction"] += np.maximum(0, conduction_loss)
+            
+            # Calculate solar heat gain
+            solar_gain = shgc * area * incident_solar
+            cooling_loads["fenestration_solar"] += solar_gain
+
+    # 3. Infiltration
+    logger.info("Calculating infiltration loads...")
+    # Simple ACH method for now - TODO: Implement more detailed method (e.g., LBL model)
+    volume = building_info["floor_area"] * building_info["building_height"]
+    ach = 0.5  # Air changes per hour (typical value, needs refinement)
+    infiltration_rate_m3s = volume * ach / 3600.0
+    
+    delta_t_cooling_infil = hourly_data["Dry Bulb Temperature"] - design_conditions["cooling_indoor_temp"]
+    delta_t_heating_infil = design_conditions["heating_indoor_temp"] - hourly_data["Dry Bulb Temperature"]
+    
+    infiltration_sensible_gain = AIR_DENSITY * AIR_SPECIFIC_HEAT * infiltration_rate_m3s * delta_t_cooling_infil
+    infiltration_sensible_loss = AIR_DENSITY * AIR_SPECIFIC_HEAT * infiltration_rate_m3s * delta_t_heating_infil
+    
+    cooling_loads["infiltration"] += np.maximum(0, infiltration_sensible_gain)
+    heating_loads["infiltration"] += np.maximum(0, infiltration_sensible_loss)
+    
+    # TODO: Add latent infiltration load calculation
+
+    # 4. Ventilation
+    logger.info("Calculating ventilation loads...")
+    ventilation_rate_lps = building_info["ventilation_rate"] # L/s per person or L/s per m² - needs clarification
+    # Assuming L/s per m² for now
+    ventilation_rate_m3s = ventilation_rate_lps * building_info["floor_area"] / 1000.0
+    
+    delta_t_cooling_vent = hourly_data["Dry Bulb Temperature"] - design_conditions["cooling_indoor_temp"]
+    delta_t_heating_vent = design_conditions["heating_indoor_temp"] - hourly_data["Dry Bulb Temperature"]
+    
+    ventilation_sensible_gain = AIR_DENSITY * AIR_SPECIFIC_HEAT * ventilation_rate_m3s * delta_t_cooling_vent
+    ventilation_sensible_loss = AIR_DENSITY * AIR_SPECIFIC_HEAT * ventilation_rate_m3s * delta_t_heating_vent
+    
+    cooling_loads["ventilation"] += np.maximum(0, ventilation_sensible_gain)
+    heating_loads["ventilation"] += np.maximum(0, ventilation_sensible_loss)
+    
+    # TODO: Add latent ventilation load calculation
+
+    # 5. Internal Loads
+    logger.info("Calculating internal loads...")
+    internal_sensible, internal_latent = calculate_hourly_internal_loads(internal_loads)
+    cooling_loads["internal_sensible"] = internal_sensible
+    cooling_loads["internal_latent"] = internal_latent
+    
+    # --- 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"] # Add infiltration/ventilation latent later
+    total_cooling = total_cooling_sensible + total_cooling_latent
+    
+    # Heating loads are losses, internal gains reduce heating need
+    total_heating_loss = (
+        heating_loads["opaque_conduction"] +
+        heating_loads["fenestration_conduction"] +
+        heating_loads["infiltration"] +
+        heating_loads["ventilation"]
+    )
+    # Consider internal sensible gains as reducing heating load
+    total_heating_needed = np.maximum(0, total_heating_loss - cooling_loads["internal_sensible"])
+    
+    # --- Peak Loads --- #
+    logger.info("Calculating peak loads...")
+    peak_cooling_sensible = np.max(total_cooling_sensible)
+    peak_cooling_latent = np.max(total_cooling_latent)
+    peak_cooling_total = np.max(total_cooling)
+    peak_heating = np.max(total_heating_needed)
+    
+    peak_cooling_sensible_hour = np.argmax(total_cooling_sensible)
+    peak_cooling_latent_hour = np.argmax(total_cooling_latent)
+    peak_cooling_total_hour = np.argmax(total_cooling)
+    peak_heating_hour = np.argmax(total_heating_needed)
+    
+    results = {
+        "hourly_cooling_sensible": total_cooling_sensible.tolist(),
+        "hourly_cooling_latent": total_cooling_latent.tolist(),
+        "hourly_cooling_total": total_cooling.tolist(),
+        "hourly_heating": total_heating_needed.tolist(),
+        "cooling_load_components": {k: v.tolist() for k, v in cooling_loads.items()},
+        "heating_load_components": {k: v.tolist() for k, v in heating_loads.items()},
+        "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)
+    }
+    
+    logger.info("HVAC load calculations completed.")
+    return results
+
+def calculate_solar_angles(latitude: float, longitude: float, timezone: float, index: pd.DatetimeIndex) -> 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 DatetimeIndex for the hours of the year
+        
+    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 = index.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 = index.hour + index.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 (common convention)
+    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 # Azimuth doesn't matter for horizontal
+    }.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.
+    Uses Perez model for diffuse radiation is simplified here.
+    
+    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) # Radiation only incident if cos_theta > 0
+    
+    # Direct radiation component on tilted surface
+    direct_tilted = dnr * cos_theta
+    
+    # Diffuse radiation component (simplified isotropic sky model)
+    # TODO: Implement Perez model or Hay-Davies model for better accuracy
+    sky_diffuse_tilted = dhr * (1 + np.cos(tilt_rad)) / 2
+    
+    # Ground reflected component (simplified)
+    albedo = 0.2 # Typical ground reflectance
+    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 (simplified from Berdahl & Martin)
+    t_sky = t_oa * (SKY_TEMP_FACTOR * hourly_data["Dew Point Temperature"]**0.25)**0.25 # Approximation
+    
+    # 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 (assuming 365 days, repeating weekly pattern)
+            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: # Continuous
+                weekday_schedule = [1.0] * 24
+                weekend_schedule = [1.0] * 24
+                
+            # Apply schedule to 8760 hours (assuming standard year)
+            # TODO: Use actual date index for proper weekday/weekend assignment
+            for hour in range(8760):
+                day_of_week = (hour // 24) % 7 # Simple approximation (0=Mon, 6=Sun)
+                hour_of_day = hour % 24
+                if day_of_week < 5: # Weekday
+                    schedule_multipliers[hour] = weekday_schedule[hour_of_day]
+                else: # Weekend
+                    schedule_multipliers[hour] = weekend_schedule[hour_of_day]
+            
+            # Calculate hourly load components
+            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: # Lighting, Equipment, Other (assumed fully sensible)
+                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.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(8760),
+        "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 of Year", 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 of Year", 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] # Show only positive contributions
+    
+    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] # Show gains as negative
+    }
+    peak_heating_df = pd.DataFrame(peak_heating_data)
+    peak_heating_df = peak_heating_df[peak_heating_df["Load (W)"] != 0] # Show only non-zero contributions
+    
+    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)
+
+# Helper functions to get data (assuming they exist in other modules or session state)
+def get_available_materials() -> Dict[str, Any]:
+    # Placeholder - should retrieve from materials_library state
+    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]:
+    # Placeholder - should retrieve from construction state
+    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]:
+    # Placeholder - should retrieve from materials_library state
+    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.
+    
+    **Results:**
+    
+    *   **Peak Loads**: Shows the maximum calculated cooling and heating loads required to size HVAC equipment.
+    *   **Hourly Profiles**: Displays graphs of the calculated loads for every hour of the year.
+    *   **Load Components**: Shows the breakdown of loads by source (e.g., conduction, solar, internal) at the peak hours.
+    
+    **Workflow:**
+    
+    1.  Ensure all previous sections (Building Info, Climate, Materials, Construction, Components, Internal Loads) are complete and accurate.
+    2.  Click the "Calculate HVAC Loads" button.
+    3.  Review the peak load summary and hourly profiles.
+    4.  Analyze the load component breakdowns to understand the main drivers of heating and cooling needs.
+    5.  Continue to the Building Energy section to simulate energy consumption based on these loads.
+    
+    **Important:**
+    
+    *   The accuracy of these calculations depends heavily on the quality of the input data.
+    *   Calculations are based on the ASHRAE methodology.
+    *   Review the results carefully before proceeding.
+    """)

app/internal_loads.py

@@ -0,0 +1,883 @@
+"""
+HVAC Load Calculator - Internal Loads Module
+
+This module handles the internal loads functionality of the HVAC Load Calculator application,
+allowing users to define occupancy, lighting, equipment, and other internal heat gains.
+It provides schedule-based load profiles and integrates with building information.
+
+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
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Define constants
+LOAD_TYPES = ["Occupancy", "Lighting", "Equipment", "Other"]
+SCHEDULE_TYPES = ["Continuous", "Day/Night", "Custom"]
+DAYS_OF_WEEK = ["Weekday", "Weekend"]
+
+# Default occupancy densities by building type (m² per person)
+DEFAULT_OCCUPANCY_DENSITIES = {
+    "Office": 10.0,
+    "Retail": 5.0,
+    "Residential": 20.0,
+    "Educational": 4.0,
+    "Healthcare": 8.0,
+    "Industrial": 15.0,
+    "Hospitality": 3.0,
+    "Other": 10.0
+}
+
+# Default lighting power densities by building type (W/m²)
+DEFAULT_LIGHTING_DENSITIES = {
+    "Office": 12.0,
+    "Retail": 18.0,
+    "Residential": 8.0,
+    "Educational": 15.0,
+    "Healthcare": 15.0,
+    "Industrial": 13.0,
+    "Hospitality": 14.0,
+    "Other": 12.0
+}
+
+# Default equipment power densities by building type (W/m²)
+DEFAULT_EQUIPMENT_DENSITIES = {
+    "Office": 15.0,
+    "Retail": 10.0,
+    "Residential": 5.0,
+    "Educational": 8.0,
+    "Healthcare": 20.0,
+    "Industrial": 25.0,
+    "Hospitality": 10.0,
+    "Other": 12.0
+}
+
+# Default schedules
+DEFAULT_SCHEDULES = {
+    "Continuous": {
+        "Weekday": [1.0] * 24,
+        "Weekend": [1.0] * 24
+    },
+    "Day/Night": {
+        "Weekday": [0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.5, 0.8, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.8, 0.6, 0.5, 0.5, 0.4, 0.4, 0.3, 0.3],
+        "Weekend": [0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.3, 0.4, 0.5, 0.6, 0.7, 0.7, 0.7, 0.7, 0.6, 0.5, 0.5, 0.4, 0.4, 0.4, 0.3, 0.3, 0.3, 0.3]
+    }
+}
+
+def display_internal_loads_page():
+    """
+    Display the internal loads page.
+    This is the main function called by main.py when the Internal Loads page is selected.
+    """
+    st.title("Internal Loads")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_internal_loads_help()
+    
+    # Initialize internal loads in session state if not present
+    initialize_internal_loads()
+    
+    # Create tabs for different load types
+    tabs = st.tabs(LOAD_TYPES)
+    
+    for i, load_type in enumerate(LOAD_TYPES):
+        with tabs[i]:
+            display_load_tab(load_type)
+    
+    # Summary tab
+    st.markdown("---")
+    st.subheader("Internal Loads Summary")
+    display_loads_summary()
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Building Components", key="back_to_components"):
+            st.session_state.current_page = "Building Components"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to HVAC Loads", key="continue_to_hvac_loads"):
+            st.session_state.current_page = "HVAC Loads"
+            st.rerun()
+
+def initialize_internal_loads():
+    """Initialize internal loads in session state if not present."""
+    if "internal_loads" not in st.session_state.project_data:
+        st.session_state.project_data["internal_loads"] = {
+            "occupancy": [],
+            "lighting": [],
+            "equipment": [],
+            "other": []
+        }
+    
+    # Initialize load editor state
+    if "load_editor" not in st.session_state:
+        st.session_state.load_editor = {
+            "type": LOAD_TYPES[0],
+            "name": "",
+            "zone": "Whole Building",
+            "area": get_building_area(),
+            "density": 0.0,
+            "total": 0.0,
+            "sensible_fraction": 0.7,
+            "latent_fraction": 0.3,
+            "radiative_fraction": 0.4,
+            "convective_fraction": 0.6,
+            "schedule_type": SCHEDULE_TYPES[0],
+            "custom_schedule": {
+                "Weekday": [0.0] * 24,
+                "Weekend": [0.0] * 24
+            },
+            "edit_mode": False,
+            "original_id": ""
+        }
+    
+    # Initialize custom zones if not present
+    if "custom_zones" not in st.session_state.project_data:
+        st.session_state.project_data["custom_zones"] = ["Whole Building"]
+
+def display_load_tab(load_type: str):
+    """
+    Display the content for a specific load type tab.
+    
+    Args:
+        load_type: The type of load (e.g., "Occupancy", "Lighting")
+    """
+    st.subheader(f"{load_type} Loads")
+    
+    # Get loads of this type
+    load_key = load_type.lower()
+    loads = st.session_state.project_data["internal_loads"].get(load_key, [])
+    
+    # Display existing loads
+    if loads:
+        display_load_list(load_type, loads)
+    else:
+        st.info(f"No {load_type.lower()} loads added yet. Use the editor below to add loads.")
+    
+    # Load Editor
+    st.markdown("---")
+    st.subheader(f"{load_type} Load Editor")
+    display_load_editor(load_type)
+
+def display_load_list(load_type: str, loads: List[Dict[str, Any]]):
+    """
+    Display the list of existing loads for a given type.
+    
+    Args:
+        load_type: The type of load
+        loads: List of load dictionaries
+    """
+    # Create a DataFrame for display
+    data = []
+    for i, load in enumerate(loads):
+        record = {
+            "#": i + 1,
+            "Name": load["name"],
+            "Zone": load["zone"],
+            "Area (m²)": load["area"],
+            "Total (W)": load["total"],
+            "Density (W/m²)": load["density"],
+            "Schedule": load["schedule_type"]
+        }
+        
+        if load_type == "Occupancy":
+            record["Sensible (W)"] = load["total"] * load["sensible_fraction"]
+            record["Latent (W)"] = load["total"] * load["latent_fraction"]
+        else:
+            record["Radiative (W)"] = load["total"] * load["radiative_fraction"]
+            record["Convective (W)"] = load["total"] * load["convective_fraction"]
+        
+        data.append(record)
+    
+    df = pd.DataFrame(data)
+    st.dataframe(df, use_container_width=True, hide_index=True)
+    
+    # Edit and delete options
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        selected_index = st.selectbox(
+            f"Select {load_type} Load # to Edit",
+            range(1, len(loads) + 1),
+            key=f"edit_{load_type}_selector"
+        )
+        
+        if st.button(f"Edit {load_type} Load", key=f"edit_{load_type}_button"):
+            # Load data into editor
+            load_data = loads[selected_index - 1]
+            st.session_state.load_editor = {
+                "type": load_type,
+                "name": load_data["name"],
+                "zone": load_data["zone"],
+                "area": load_data["area"],
+                "density": load_data["density"],
+                "total": load_data["total"],
+                "sensible_fraction": load_data.get("sensible_fraction", 0.7),
+                "latent_fraction": load_data.get("latent_fraction", 0.3),
+                "radiative_fraction": load_data.get("radiative_fraction", 0.4),
+                "convective_fraction": load_data.get("convective_fraction", 0.6),
+                "schedule_type": load_data["schedule_type"],
+                "custom_schedule": load_data.get("custom_schedule", {
+                    "Weekday": [0.0] * 24,
+                    "Weekend": [0.0] * 24
+                }),
+                "edit_mode": True,
+                "original_id": load_data["id"]
+            }
+            st.success(f"{load_type} Load '{load_data['name']}' loaded for editing.")
+            st.rerun()
+    
+    with col2:
+        selected_index_delete = st.selectbox(
+            f"Select {load_type} Load # to Delete",
+            range(1, len(loads) + 1),
+            key=f"delete_{load_type}_selector"
+        )
+        
+        if st.button(f"Delete {load_type} Load", key=f"delete_{load_type}_button"):
+            # Delete load
+            load_key = load_type.lower()
+            deleted_load = st.session_state.project_data["internal_loads"][load_key].pop(selected_index_delete - 1)
+            st.success(f"{load_type} Load '{deleted_load['name']}' deleted.")
+            logger.info(f"Deleted {load_type} Load '{deleted_load['name']}'")
+            st.rerun()
+
+def display_load_editor(load_type: str):
+    """
+    Display the editor form for a specific load type.
+    
+    Args:
+        load_type: The type of load
+    """
+    # Check if the editor is currently set to this load type
+    if st.session_state.load_editor["type"] != load_type and not st.session_state.load_editor["edit_mode"]:
+        reset_load_editor(load_type)
+    
+    # Get building information
+    building_area = get_building_area()
+    building_type = get_building_type()
+    
+    with st.form(f"{load_type}_editor_form"):
+        # Load name
+        name = st.text_input(
+            "Load Name",
+            value=st.session_state.load_editor["name"],
+            help="Enter a unique name for this load."
+        )
+        
+        # Create columns for layout
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Zone selection
+            zones = st.session_state.project_data["custom_zones"]
+            zone = st.selectbox(
+                "Zone",
+                zones,
+                index=zones.index(st.session_state.load_editor["zone"]) if st.session_state.load_editor["zone"] in zones else 0,
+                help="Select the zone for this load."
+            )
+            
+            # Area
+            area = st.number_input(
+                "Area (m²)",
+                min_value=0.1,
+                max_value=float(building_area),
+                value=min(float(st.session_state.load_editor["area"]), float(building_area)),
+                format="%.2f",
+                help="Floor area affected by this load."
+            )
+        
+        with col2:
+            # Density or total selection
+            input_mode = st.radio(
+                "Input Mode",
+                ["Density (W/m²)", "Total Load (W)"],
+                horizontal=True,
+                help="Choose whether to input load density or total load."
+            )
+            
+            if input_mode == "Density (W/m²)":
+                # Set default density based on building type if not in edit mode
+                default_density = 0.0
+                if not st.session_state.load_editor["edit_mode"]:
+                    if load_type == "Occupancy":
+                        # For occupancy, we need to convert from m²/person to W/m²
+                        people_density = 1.0 / DEFAULT_OCCUPANCY_DENSITIES.get(building_type, 10.0)
+                        default_density = people_density * 115.0  # 115W per person (sensible + latent)
+                    elif load_type == "Lighting":
+                        default_density = DEFAULT_LIGHTING_DENSITIES.get(building_type, 12.0)
+                    elif load_type == "Equipment":
+                        default_density = DEFAULT_EQUIPMENT_DENSITIES.get(building_type, 15.0)
+                    else:  # Other
+                        default_density = 5.0
+                else:
+                    default_density = st.session_state.load_editor["density"]
+                
+                density = st.number_input(
+                    f"{load_type} Density (W/m²)",
+                    min_value=0.0,
+                    max_value=1000.0,
+                    value=default_density,
+                    format="%.2f",
+                    help=f"Power density for {load_type.lower()}."
+                )
+                total = density * area
+            else:
+                # Total load input
+                default_total = st.session_state.load_editor["total"] if st.session_state.load_editor["edit_mode"] else 0.0
+                total = st.number_input(
+                    f"Total {load_type} Load (W)",
+                    min_value=0.0,
+                    max_value=1000000.0,
+                    value=default_total,
+                    format="%.1f",
+                    help=f"Total power for {load_type.lower()}."
+                )
+                density = total / area if area > 0 else 0.0
+        
+        # Load-specific properties
+        st.subheader("Load Properties")
+        
+        if load_type == "Occupancy":
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                sensible_fraction = st.slider(
+                    "Sensible Heat Fraction",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(st.session_state.load_editor["sensible_fraction"]),
+                    format="%.2f",
+                    help="Fraction of heat that is sensible (affects air temperature)."
+                )
+            
+            with col2:
+                latent_fraction = st.slider(
+                    "Latent Heat Fraction",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(st.session_state.load_editor["latent_fraction"]),
+                    format="%.2f",
+                    help="Fraction of heat that is latent (affects humidity)."
+                )
+            
+            # Ensure fractions sum to 1.0
+            if abs(sensible_fraction + latent_fraction - 1.0) > 0.01:
+                st.warning("Sensible and latent fractions should sum to 1.0. Values will be normalized.")
+                total_fraction = sensible_fraction + latent_fraction
+                if total_fraction > 0:
+                    sensible_fraction = sensible_fraction / total_fraction
+                    latent_fraction = latent_fraction / total_fraction
+                else:
+                    sensible_fraction = 0.7
+                    latent_fraction = 0.3
+            
+            radiative_fraction = 0.0
+            convective_fraction = 0.0
+        else:
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                radiative_fraction = st.slider(
+                    "Radiative Heat Fraction",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(st.session_state.load_editor["radiative_fraction"]),
+                    format="%.2f",
+                    help="Fraction of heat that is radiative (affects surface temperatures)."
+                )
+            
+            with col2:
+                convective_fraction = st.slider(
+                    "Convective Heat Fraction",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=float(st.session_state.load_editor["convective_fraction"]),
+                    format="%.2f",
+                    help="Fraction of heat that is convective (affects air temperature)."
+                )
+            
+            # Ensure fractions sum to 1.0
+            if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
+                st.warning("Radiative and convective fractions should sum to 1.0. Values will be normalized.")
+                total_fraction = radiative_fraction + convective_fraction
+                if total_fraction > 0:
+                    radiative_fraction = radiative_fraction / total_fraction
+                    convective_fraction = convective_fraction / total_fraction
+                else:
+                    radiative_fraction = 0.4
+                    convective_fraction = 0.6
+            
+            sensible_fraction = 1.0
+            latent_fraction = 0.0
+        
+        # Schedule
+        st.subheader("Schedule")
+        
+        schedule_type = st.selectbox(
+            "Schedule Type",
+            SCHEDULE_TYPES,
+            index=SCHEDULE_TYPES.index(st.session_state.load_editor["schedule_type"]) if st.session_state.load_editor["schedule_type"] in SCHEDULE_TYPES else 0,
+            help="Select the schedule type for this load."
+        )
+        
+        if schedule_type == "Custom":
+            st.write("Define custom schedule for each day type:")
+            
+            # Initialize custom schedule if not present
+            if "custom_schedule" not in st.session_state.load_editor or not st.session_state.load_editor["custom_schedule"]:
+                st.session_state.load_editor["custom_schedule"] = {
+                    "Weekday": [0.0] * 24,
+                    "Weekend": [0.0] * 24
+                }
+            
+            # Create tabs for day types
+            day_tabs = st.tabs(DAYS_OF_WEEK)
+            
+            for i, day_type in enumerate(DAYS_OF_WEEK):
+                with day_tabs[i]:
+                    # Get current schedule values
+                    current_values = st.session_state.load_editor["custom_schedule"].get(day_type, [0.0] * 24)
+                    
+                    # Create sliders for each hour
+                    for hour in range(0, 24, 3):
+                        cols = st.columns(3)
+                        for j in range(3):
+                            if hour + j < 24:
+                                with cols[j]:
+                                    hour_label = f"{hour + j:02d}:00 - {hour + j + 1:02d}:00"
+                                    current_values[hour + j] = st.slider(
+                                        hour_label,
+                                        min_value=0.0,
+                                        max_value=1.0,
+                                        value=float(current_values[hour + j]),
+                                        format="%.2f",
+                                        key=f"schedule_{day_type}_{hour + j}"
+                                    )
+                    
+                    # Update custom schedule
+                    st.session_state.load_editor["custom_schedule"][day_type] = current_values
+                    
+                    # Display schedule as a chart
+                    fig = px.bar(
+                        x=list(range(24)),
+                        y=current_values,
+                        labels={"x": "Hour", "y": "Load Factor"},
+                        title=f"{day_type} Schedule"
+                    )
+                    fig.update_layout(height=300)
+                    st.plotly_chart(fig, use_container_width=True)
+        else:
+            # Display predefined schedule
+            if schedule_type in DEFAULT_SCHEDULES:
+                schedule_data = DEFAULT_SCHEDULES[schedule_type]
+                
+                # Create tabs for day types
+                day_tabs = st.tabs(DAYS_OF_WEEK)
+                
+                for i, day_type in enumerate(DAYS_OF_WEEK):
+                    with day_tabs[i]:
+                        # Display schedule as a chart
+                        fig = px.bar(
+                            x=list(range(24)),
+                            y=schedule_data[day_type],
+                            labels={"x": "Hour", "y": "Load Factor"},
+                            title=f"{day_type} Schedule"
+                        )
+                        fig.update_layout(height=300)
+                        st.plotly_chart(fig, use_container_width=True)
+        
+        # Form submission buttons
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            submit_button = st.form_submit_button("Save Load")
+        
+        with col2:
+            clear_button = st.form_submit_button("Clear Form")
+    
+    # Handle form submission
+    if submit_button:
+        # Validate inputs
+        validation_errors = validate_load(
+            load_type, name, zone, area, density, total,
+            sensible_fraction, latent_fraction, radiative_fraction, convective_fraction,
+            schedule_type, st.session_state.load_editor["custom_schedule"] if schedule_type == "Custom" else None,
+            st.session_state.load_editor["edit_mode"], st.session_state.load_editor["original_id"]
+        )
+        
+        if validation_errors:
+            # Display validation errors
+            for error in validation_errors:
+                st.error(error)
+        else:
+            # Create load data
+            load_data = {
+                "id": st.session_state.load_editor["original_id"] if st.session_state.load_editor["edit_mode"] else str(uuid.uuid4()),
+                "name": name,
+                "type": load_type,
+                "zone": zone,
+                "area": area,
+                "density": density,
+                "total": total,
+                "schedule_type": schedule_type
+            }
+            
+            # Add load-specific properties
+            if load_type == "Occupancy":
+                load_data["sensible_fraction"] = sensible_fraction
+                load_data["latent_fraction"] = latent_fraction
+            else:
+                load_data["radiative_fraction"] = radiative_fraction
+                load_data["convective_fraction"] = convective_fraction
+            
+            # Add custom schedule if applicable
+            if schedule_type == "Custom":
+                load_data["custom_schedule"] = st.session_state.load_editor["custom_schedule"]
+            
+            # Handle edit mode
+            load_key = load_type.lower()
+            if st.session_state.load_editor["edit_mode"]:
+                # Find and update the load
+                loads = st.session_state.project_data["internal_loads"][load_key]
+                for i, load in enumerate(loads):
+                    if load["id"] == st.session_state.load_editor["original_id"]:
+                        loads[i] = load_data
+                        break
+                st.success(f"{load_type} Load '{name}' updated successfully.")
+                logger.info(f"Updated {load_type} Load '{name}'")
+            else:
+                # Add new load
+                st.session_state.project_data["internal_loads"][load_key].append(load_data)
+                st.success(f"{load_type} Load '{name}' added successfully.")
+                logger.info(f"Added new {load_type} Load '{name}'")
+            
+            # Reset editor
+            reset_load_editor(load_type)
+            st.rerun()
+    
+    # Handle clear button
+    if clear_button:
+        reset_load_editor(load_type)
+        st.rerun()
+
+def display_loads_summary():
+    """Display a summary of all internal loads."""
+    # Get all loads
+    all_loads = []
+    for load_type in LOAD_TYPES:
+        load_key = load_type.lower()
+        loads = st.session_state.project_data["internal_loads"].get(load_key, [])
+        for load in loads:
+            all_loads.append({
+                "Type": load_type,
+                "Name": load["name"],
+                "Zone": load["zone"],
+                "Total (W)": load["total"]
+            })
+    
+    if all_loads:
+        # Create a DataFrame for display
+        df = pd.DataFrame(all_loads)
+        
+        # Calculate totals by type
+        totals_by_type = df.groupby("Type")["Total (W)"].sum().reset_index()
+        
+        # Display summary table
+        st.subheader("Total Internal Loads by Type")
+        st.dataframe(totals_by_type, use_container_width=True, hide_index=True)
+        
+        # Display pie chart
+        fig = px.pie(
+            totals_by_type,
+            values="Total (W)",
+            names="Type",
+            title="Internal Loads Distribution"
+        )
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Calculate peak load profiles
+        st.subheader("Peak Load Profiles")
+        
+        # Create tabs for day types
+        day_tabs = st.tabs(DAYS_OF_WEEK)
+        
+        for i, day_type in enumerate(DAYS_OF_WEEK):
+            with day_tabs[i]:
+                # Calculate hourly profiles for each load type
+                hourly_data = calculate_hourly_profiles(day_type)
+                
+                if hourly_data:
+                    # Create a stacked area chart
+                    fig = go.Figure()
+                    
+                    for load_type in LOAD_TYPES:
+                        if load_type in hourly_data:
+                            fig.add_trace(go.Scatter(
+                                x=list(range(24)),
+                                y=hourly_data[load_type],
+                                mode='lines',
+                                name=load_type,
+                                stackgroup='one',
+                                line=dict(width=0.5)
+                            ))
+                    
+                    fig.update_layout(
+                        title=f"{day_type} Hourly Load Profile",
+                        xaxis_title="Hour",
+                        yaxis_title="Load (W)",
+                        legend_title="Load Type",
+                        height=400
+                    )
+                    
+                    st.plotly_chart(fig, use_container_width=True)
+                else:
+                    st.info("No load profiles available. Add loads to see hourly profiles.")
+    else:
+        st.info("No internal loads defined yet. Add loads in the tabs above to see a summary.")
+
+def calculate_hourly_profiles(day_type: str) -> Dict[str, List[float]]:
+    """
+    Calculate hourly load profiles for each load type.
+    
+    Args:
+        day_type: Day type ("Weekday" or "Weekend")
+        
+    Returns:
+        Dictionary of load type to hourly values
+    """
+    hourly_data = {}
+    
+    for load_type in LOAD_TYPES:
+        load_key = load_type.lower()
+        loads = st.session_state.project_data["internal_loads"].get(load_key, [])
+        
+        if loads:
+            hourly_values = [0.0] * 24
+            
+            for load in loads:
+                # Get schedule values
+                schedule_values = []
+                
+                if load["schedule_type"] == "Custom" and "custom_schedule" in load:
+                    schedule_values = load["custom_schedule"].get(day_type, [0.0] * 24)
+                elif load["schedule_type"] in DEFAULT_SCHEDULES:
+                    schedule_values = DEFAULT_SCHEDULES[load["schedule_type"]].get(day_type, [0.0] * 24)
+                else:
+                    schedule_values = [1.0] * 24
+                
+                # Apply schedule to load
+                for hour in range(24):
+                    hourly_values[hour] += load["total"] * schedule_values[hour]
+            
+            hourly_data[load_type] = hourly_values
+    
+    return hourly_data
+
+def get_building_area() -> float:
+    """
+    Get the total floor area from building information.
+    
+    Returns:
+        Total floor area in m²
+    """
+    if "building_info" in st.session_state.project_data and "floor_area" in st.session_state.project_data["building_info"]:
+        return st.session_state.project_data["building_info"]["floor_area"]
+    return 100.0  # Default value
+
+def get_building_type() -> str:
+    """
+    Get the building type from building information.
+    
+    Returns:
+        Building type
+    """
+    if "building_info" in st.session_state.project_data and "building_type" in st.session_state.project_data["building_info"]:
+        return st.session_state.project_data["building_info"]["building_type"]
+    return "Other"  # Default value
+
+def validate_load(
+    load_type: str, name: str, zone: str, area: float, density: float, total: float,
+    sensible_fraction: float, latent_fraction: float, radiative_fraction: float, convective_fraction: float,
+    schedule_type: str, custom_schedule: Optional[Dict[str, List[float]]], edit_mode: bool, original_id: str
+) -> List[str]:
+    """
+    Validate load inputs.
+    
+    Args:
+        load_type: Type of load
+        name: Load name
+        zone: Zone name
+        area: Floor area
+        density: Power density
+        total: Total power
+        sensible_fraction: Sensible heat fraction
+        latent_fraction: Latent heat fraction
+        radiative_fraction: Radiative heat fraction
+        convective_fraction: Convective heat fraction
+        schedule_type: Schedule type
+        custom_schedule: Custom schedule data
+        edit_mode: Whether in edit mode
+        original_id: Original ID if in edit mode
+        
+    Returns:
+        List of validation error messages, empty if all inputs are valid
+    """
+    errors = []
+    
+    # Validate name
+    if not name or name.strip() == "":
+        errors.append("Load name is required.")
+    
+    # Check for name uniqueness within the same load type
+    load_key = load_type.lower()
+    loads = st.session_state.project_data["internal_loads"].get(load_key, [])
+    
+    for load in loads:
+        if load["name"] == name and (not edit_mode or load["id"] != original_id):
+            errors.append(f"{load_type} Load name '{name}' already exists.")
+            break
+    
+    # Validate zone
+    if not zone:
+        errors.append("Zone selection is required.")
+    
+    # Validate area
+    if area <= 0:
+        errors.append("Area must be greater than zero.")
+    
+    # Validate density and total
+    if density <= 0 and total <= 0:
+        errors.append("Either density or total load must be greater than zero.")
+    
+    # Validate fractions
+    if load_type == "Occupancy":
+        if abs(sensible_fraction + latent_fraction - 1.0) > 0.01:
+            errors.append("Sensible and latent fractions should sum to 1.0.")
+    else:
+        if abs(radiative_fraction + convective_fraction - 1.0) > 0.01:
+            errors.append("Radiative and convective fractions should sum to 1.0.")
+    
+    # Validate schedule
+    if schedule_type == "Custom":
+        if not custom_schedule:
+            errors.append("Custom schedule data is missing.")
+        else:
+            for day_type in DAYS_OF_WEEK:
+                if day_type not in custom_schedule or len(custom_schedule[day_type]) != 24:
+                    errors.append(f"Custom schedule for {day_type} must have 24 hourly values.")
+    
+    return errors
+
+def reset_load_editor(load_type: str):
+    """
+    Reset the load editor to default values for the given type.
+    
+    Args:
+        load_type: The type of load
+    """
+    # Get building information
+    building_area = get_building_area()
+    building_type = get_building_type()
+    
+    # Set default density based on building type
+    default_density = 0.0
+    if load_type == "Occupancy":
+        # For occupancy, we need to convert from m²/person to W/m²
+        people_density = 1.0 / DEFAULT_OCCUPANCY_DENSITIES.get(building_type, 10.0)
+        default_density = people_density * 115.0  # 115W per person (sensible + latent)
+    elif load_type == "Lighting":
+        default_density = DEFAULT_LIGHTING_DENSITIES.get(building_type, 12.0)
+    elif load_type == "Equipment":
+        default_density = DEFAULT_EQUIPMENT_DENSITIES.get(building_type, 15.0)
+    else:  # Other
+        default_density = 5.0
+    
+    st.session_state.load_editor = {
+        "type": load_type,
+        "name": "",
+        "zone": "Whole Building",
+        "area": building_area,
+        "density": default_density,
+        "total": default_density * building_area,
+        "sensible_fraction": 0.7,
+        "latent_fraction": 0.3,
+        "radiative_fraction": 0.4,
+        "convective_fraction": 0.6,
+        "schedule_type": SCHEDULE_TYPES[0],
+        "custom_schedule": {
+            "Weekday": [0.0] * 24,
+            "Weekend": [0.0] * 24
+        },
+        "edit_mode": False,
+        "original_id": ""
+    }
+
+def display_internal_loads_help():
+    """
+    Display help information for the internal loads page.
+    """
+    st.markdown("""
+    ### Internal Loads Help
+    
+    This section allows you to define the internal heat gains in your building from occupants, lighting, equipment, and other sources.
+    
+    **Key Concepts:**
+    
+    * **Internal Loads**: Heat gains inside the building that contribute to cooling loads and reduce heating loads.
+    * **Occupancy Loads**: Heat generated by people, including both sensible heat (affects air temperature) and latent heat (affects humidity).
+    * **Lighting Loads**: Heat generated by lighting fixtures, primarily as a combination of radiative and convective heat.
+    * **Equipment Loads**: Heat generated by appliances, computers, and other electrical equipment.
+    * **Schedules**: Time-based patterns that define when loads are active throughout the day.
+    
+    **Load Properties:**
+    
+    * **Density**: Power per unit area (W/m²).
+    * **Total**: Total power for the load (W).
+    * **Sensible Heat**: Heat that directly affects air temperature.
+    * **Latent Heat**: Heat that affects humidity (moisture in the air).
+    * **Radiative Heat**: Heat transferred by radiation to surfaces.
+    * **Convective Heat**: Heat transferred directly to the air.
+    
+    **Schedules:**
+    
+    * **Continuous**: Load is constant throughout the day.
+    * **Day/Night**: Load varies between day and night hours.
+    * **Custom**: Define your own hourly schedule for weekdays and weekends.
+    
+    **Workflow:**
+    
+    1. Select the tab for the load type you want to define (e.g., "Occupancy").
+    2. Use the editor to add new loads:
+        * Give the load a unique name.
+        * Select the zone it applies to.
+        * Enter the area and either the density or total load.
+        * Set the appropriate heat fractions.
+        * Choose or define a schedule.
+    3. Save the load.
+    4. Repeat for all internal load sources.
+    5. Review the summary to see the total internal loads and hourly profiles.
+    
+    **Important:**
+    
+    * Internal loads are a significant factor in cooling load calculations.
+    * Accurate schedules are essential for proper load calculations.
+    * The summary section shows the combined effect of all internal loads.
+    """)

app/materials_cost.py

@@ -0,0 +1,889 @@
+"""
+HVAC Load Calculator - Materials Cost Module
+
+This module handles the cost calculations for building materials,
+lifecycle cost analysis including initial, replacement, and maintenance costs,
+cost optimization recommendations, and economic payback period analysis.
+
+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 plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple, Union
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Constants
+YEARS_FOR_ANALYSIS = 60  # Standard building lifecycle for cost analysis
+DISCOUNT_RATE = 0.03  # Default discount rate for NPV calculations (3%)
+INFLATION_RATE = 0.025  # Default inflation rate (2.5%)
+
+# Default material costs ($/kg)
+DEFAULT_MATERIAL_COSTS = {
+    "Concrete": 0.12,
+    "Steel": 2.50,
+    "Timber": 1.80,
+    "Brick": 0.45,
+    "Glass": 3.20,
+    "Aluminum": 4.50,
+    "Insulation (mineral wool)": 2.80,
+    "Insulation (EPS)": 3.50,
+    "Gypsum board": 1.20,
+    "Carpet": 15.00,
+    "Ceramic tile": 8.50,
+    "PVC": 3.80,
+    "Paint": 12.00,
+    "HVAC equipment": 25.00,
+    "Electrical equipment": 35.00,
+    "Plumbing fixtures": 18.00
+}
+
+# Default labor costs ($/kg for installation)
+DEFAULT_LABOR_COSTS = {
+    "Concrete": 0.08,
+    "Steel": 1.20,
+    "Timber": 0.90,
+    "Brick": 0.35,
+    "Glass": 2.50,
+    "Aluminum": 1.80,
+    "Insulation (mineral wool)": 1.50,
+    "Insulation (EPS)": 1.20,
+    "Gypsum board": 2.00,
+    "Carpet": 8.00,
+    "Ceramic tile": 12.00,
+    "PVC": 2.50,
+    "Paint": 8.00,
+    "HVAC equipment": 15.00,
+    "Electrical equipment": 20.00,
+    "Plumbing fixtures": 12.00
+}
+
+def display_materials_cost_page():
+    """
+    Display the materials cost page.
+    This is the main function called by main.py when the Materials Cost page is selected.
+    """
+    st.title("Materials Cost Analysis")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_materials_cost_help()
+    
+    # Check if embodied energy has been calculated (for material inventory)
+    if "embodied_energy" not in st.session_state.project_data or not st.session_state.project_data["embodied_energy"].get("material_inventory"):
+        st.warning("Please complete the Embodied Energy analysis to generate material inventory before proceeding to Materials Cost analysis.")
+        
+        # Navigation buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Back to Embodied Energy", key="back_to_embodied_energy_mc"):
+                st.session_state.current_page = "Embodied Energy"
+                st.rerun()
+        return
+    
+    # Initialize materials cost data if not present
+    initialize_materials_cost_data()
+    
+    # Create tabs for different aspects of materials cost analysis
+    tabs = st.tabs(["Cost Parameters", "Cost Analysis", "Lifecycle Costs", "Cost Optimization"])
+    
+    with tabs[0]:
+        display_cost_parameters_tab()
+    
+    with tabs[1]:
+        display_cost_analysis_tab()
+    
+    with tabs[2]:
+        display_lifecycle_costs_tab()
+    
+    with tabs[3]:
+        display_cost_optimization_tab()
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Embodied Energy", key="back_to_embodied_energy"):
+            st.session_state.current_page = "Embodied Energy"
+            st.rerun()
+    
+    with col2:
+        st.info("This is the final module in the HVAC Load Calculator.")
+
+def initialize_materials_cost_data():
+    """Initialize materials cost data in session state if not present."""
+    if "materials_cost" not in st.session_state.project_data:
+        st.session_state.project_data["materials_cost"] = {
+            "material_costs": DEFAULT_MATERIAL_COSTS.copy(),
+            "labor_costs": DEFAULT_LABOR_COSTS.copy(),
+            "economic_parameters": {
+                "discount_rate": DISCOUNT_RATE,
+                "inflation_rate": INFLATION_RATE,
+                "maintenance_rate": 0.02,  # 2% of initial cost annually
+                "energy_cost_escalation": 0.03  # 3% annual energy cost increase
+            },
+            "results": None
+        }
+
+def display_cost_parameters_tab():
+    """Display the cost parameters configuration tab."""
+    st.header("Cost Parameters Configuration")
+    
+    # Get current cost data
+    material_costs = st.session_state.project_data["materials_cost"]["material_costs"]
+    labor_costs = st.session_state.project_data["materials_cost"]["labor_costs"]
+    economic_params = st.session_state.project_data["materials_cost"]["economic_parameters"]
+    
+    # Economic parameters
+    st.subheader("Economic Parameters")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        discount_rate = st.number_input(
+            "Discount Rate",
+            min_value=0.01,
+            max_value=0.15,
+            value=float(economic_params["discount_rate"]),
+            step=0.005,
+            format="%.3f",
+            help="Annual discount rate for net present value calculations."
+        )
+        
+        maintenance_rate = st.number_input(
+            "Annual Maintenance Rate",
+            min_value=0.005,
+            max_value=0.1,
+            value=float(economic_params["maintenance_rate"]),
+            step=0.005,
+            format="%.3f",
+            help="Annual maintenance cost as a fraction of initial cost."
+        )
+    
+    with col2:
+        inflation_rate = st.number_input(
+            "Inflation Rate",
+            min_value=0.01,
+            max_value=0.1,
+            value=float(economic_params["inflation_rate"]),
+            step=0.005,
+            format="%.3f",
+            help="Annual inflation rate for cost escalation."
+        )
+        
+        energy_cost_escalation = st.number_input(
+            "Energy Cost Escalation Rate",
+            min_value=0.01,
+            max_value=0.1,
+            value=float(economic_params["energy_cost_escalation"]),
+            step=0.005,
+            format="%.3f",
+            help="Annual energy cost escalation rate."
+        )
+    
+    # Update economic parameters
+    economic_params.update({
+        "discount_rate": discount_rate,
+        "inflation_rate": inflation_rate,
+        "maintenance_rate": maintenance_rate,
+        "energy_cost_escalation": energy_cost_escalation
+    })
+    
+    # Material costs
+    st.subheader("Material Costs")
+    
+    # Create a DataFrame for display and editing
+    cost_df = pd.DataFrame({
+        "Material": list(material_costs.keys()),
+        "Material Cost ($/kg)": list(material_costs.values()),
+        "Labor Cost ($/kg)": [labor_costs.get(material, 0) for material in material_costs.keys()]
+    })
+    
+    # Display the costs table
+    edited_cost_df = st.data_editor(
+        cost_df,
+        column_config={
+            "Material": st.column_config.TextColumn("Material"),
+            "Material Cost ($/kg)": st.column_config.NumberColumn(
+                "Material Cost ($/kg)",
+                min_value=0.0,
+                max_value=100.0,
+                step=0.01,
+                format="%.2f"
+            ),
+            "Labor Cost ($/kg)": st.column_config.NumberColumn(
+                "Labor Cost ($/kg)",
+                min_value=0.0,
+                max_value=50.0,
+                step=0.01,
+                format="%.2f"
+            )
+        },
+        use_container_width=True,
+        key="material_costs_editor"
+    )
+    
+    # Update material and labor costs if edited
+    if not cost_df.equals(edited_cost_df):
+        updated_material_costs = dict(zip(edited_cost_df["Material"], edited_cost_df["Material Cost ($/kg)"]))
+        updated_labor_costs = dict(zip(edited_cost_df["Material"], edited_cost_df["Labor Cost ($/kg)"]))
+        
+        st.session_state.project_data["materials_cost"]["material_costs"] = updated_material_costs
+        st.session_state.project_data["materials_cost"]["labor_costs"] = updated_labor_costs
+        
+        material_costs = updated_material_costs
+        labor_costs = updated_labor_costs
+    
+    # Calculate costs button
+    if st.button("Calculate Material Costs", key="calculate_material_costs"):
+        try:
+            results = calculate_material_costs()
+            st.session_state.project_data["materials_cost"]["results"] = results
+            st.success("Material costs calculated successfully.")
+            logger.info("Material costs calculated.")
+            st.rerun()  # Refresh to show results
+        except Exception as e:
+            st.error(f"Error calculating material costs: {e}")
+            logger.error(f"Error calculating material costs: {e}", exc_info=True)
+            st.session_state.project_data["materials_cost"]["results"] = None
+
+def display_cost_analysis_tab():
+    """Display the cost analysis tab."""
+    st.header("Cost Analysis")
+    
+    # Check if results are available
+    results = st.session_state.project_data["materials_cost"].get("results")
+    if not results:
+        st.info("Please calculate material costs using the Cost Parameters tab.")
+        return
+    
+    # Display cost summary
+    st.subheader("Cost Summary")
+    
+    # Get building info for normalization
+    building_info = st.session_state.project_data["building_info"]
+    floor_area = building_info.get("floor_area", 0)
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Total Initial Material Cost",
+            f"${results['total_initial_material_cost']:,.0f}",
+            help="Total cost of materials for initial construction."
+        )
+    
+    with col2:
+        st.metric(
+            "Total Initial Labor Cost",
+            f"${results['total_initial_labor_cost']:,.0f}",
+            help="Total labor cost for initial construction."
+        )
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Total Initial Construction Cost",
+            f"${results['total_initial_construction_cost']:,.0f}",
+            help="Total initial construction cost (materials + labor)."
+        )
+    
+    with col2:
+        st.metric(
+            "Construction Cost per Area",
+            f"${results['construction_cost_per_area']:,.0f}/m²",
+            help="Initial construction cost per square meter of floor area."
+        )
+    
+    # Display cost breakdown by category
+    st.subheader("Cost Breakdown by Category")
+    
+    # Create pie chart of initial costs by category
+    fig_material_category = px.pie(
+        values=list(results["initial_material_cost_by_category"].values()),
+        names=list(results["initial_material_cost_by_category"].keys()),
+        title="Initial Material Cost by Category"
+    )
+    st.plotly_chart(fig_material_category, use_container_width=True)
+    
+    # Create pie chart of initial labor costs by category
+    fig_labor_category = px.pie(
+        values=list(results["initial_labor_cost_by_category"].values()),
+        names=list(results["initial_labor_cost_by_category"].keys()),
+        title="Initial Labor Cost by Category"
+    )
+    st.plotly_chart(fig_labor_category, use_container_width=True)
+    
+    # Display cost breakdown by material
+    st.subheader("Top 10 Materials by Cost")
+    
+    # Create bar chart of top 10 materials by total initial cost
+    material_total_costs = {}
+    for material, material_cost in results["initial_material_cost_by_material"].items():
+        labor_cost = results["initial_labor_cost_by_material"].get(material, 0)
+        material_total_costs[material] = material_cost + labor_cost
+    
+    top_materials_df = pd.DataFrame({
+        "Material": list(material_total_costs.keys()),
+        "Total Initial Cost ($)": list(material_total_costs.values())
+    })
+    
+    top_materials_df = top_materials_df.sort_values(
+        by="Total Initial Cost ($)",
+        ascending=False
+    ).head(10)
+    
+    fig_top_materials = px.bar(
+        top_materials_df,
+        x="Material",
+        y="Total Initial Cost ($)",
+        title="Top 10 Materials by Total Initial Cost"
+    )
+    st.plotly_chart(fig_top_materials, use_container_width=True)
+
+def display_lifecycle_costs_tab():
+    """Display the lifecycle costs analysis tab."""
+    st.header("Lifecycle Cost Analysis")
+    
+    # Check if results are available
+    results = st.session_state.project_data["materials_cost"].get("results")
+    if not results:
+        st.info("Please calculate material costs using the Cost Parameters tab.")
+        return
+    
+    # Display lifecycle cost summary
+    st.subheader("Lifecycle Cost Summary")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            f"Total Lifecycle Material Cost ({YEARS_FOR_ANALYSIS} years)",
+            f"${results['total_lifecycle_material_cost']:,.0f}",
+            help=f"Total material cost over {YEARS_FOR_ANALYSIS} years including replacements."
+        )
+    
+    with col2:
+        st.metric(
+            f"Total Lifecycle Construction Cost ({YEARS_FOR_ANALYSIS} years)",
+            f"${results['total_lifecycle_construction_cost']:,.0f}",
+            help=f"Total construction cost over {YEARS_FOR_ANALYSIS} years including materials, labor, and maintenance."
+        )
+    
+    # Display net present value
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Net Present Value (NPV)",
+            f"${results['net_present_value']:,.0f}",
+            help="Net present value of all lifecycle costs."
+        )
+    
+    with col2:
+        st.metric(
+            "Annualized Cost",
+            f"${results['annualized_cost']:,.0f}/year",
+            help=f"Average annual cost over {YEARS_FOR_ANALYSIS} years."
+        )
+    
+    # Display lifecycle cost breakdown
+    st.subheader("Lifecycle Cost Breakdown")
+    
+    # Create pie chart of lifecycle costs
+    lifecycle_components = {
+        "Initial Materials": results["total_initial_material_cost"],
+        "Initial Labor": results["total_initial_labor_cost"],
+        "Replacement Materials": results["total_lifecycle_material_cost"] - results["total_initial_material_cost"],
+        "Replacement Labor": results["total_lifecycle_labor_cost"] - results["total_initial_labor_cost"],
+        "Maintenance": results["total_maintenance_cost"]
+    }
+    
+    fig_lifecycle = px.pie(
+        values=list(lifecycle_components.values()),
+        names=list(lifecycle_components.keys()),
+        title=f"Lifecycle Cost Breakdown ({YEARS_FOR_ANALYSIS} years)"
+    )
+    st.plotly_chart(fig_lifecycle, use_container_width=True)
+    
+    # Display cost over time
+    st.subheader("Cost Accumulation Over Time")
+    
+    # Create line chart of cumulative costs over time
+    years = list(range(0, YEARS_FOR_ANALYSIS + 1, 5))
+    cumulative_costs = [results["cumulative_costs"].get(str(year), 0) for year in years]
+    
+    fig_over_time = px.line(
+        x=years,
+        y=cumulative_costs,
+        title="Cumulative Costs Over Time",
+        labels={"x": "Year", "y": "Cumulative Cost ($)"}
+    )
+    st.plotly_chart(fig_over_time, use_container_width=True)
+    
+    # Compare with energy costs if available
+    if "building_energy" in st.session_state.project_data and st.session_state.project_data["building_energy"].get("results"):
+        st.subheader("Construction vs. Energy Costs")
+        
+        building_energy_results = st.session_state.project_data["building_energy"]["results"]
+        annual_energy_cost = building_energy_results["annual_energy_cost"]
+        
+        # Calculate total energy cost over lifecycle
+        economic_params = st.session_state.project_data["materials_cost"]["economic_parameters"]
+        energy_escalation = economic_params["energy_cost_escalation"]
+        discount_rate = economic_params["discount_rate"]
+        
+        total_energy_cost = 0
+        for year in range(1, YEARS_FOR_ANALYSIS + 1):
+            escalated_cost = annual_energy_cost * ((1 + energy_escalation) ** year)
+            discounted_cost = escalated_cost / ((1 + discount_rate) ** year)
+            total_energy_cost += discounted_cost
+        
+        # Create comparison chart
+        cost_comparison = {
+            "Construction (Lifecycle)": results["net_present_value"],
+            "Energy (Lifecycle)": total_energy_cost
+        }
+        
+        fig_comparison = px.bar(
+            x=list(cost_comparison.keys()),
+            y=list(cost_comparison.values()),
+            title=f"Lifecycle Cost Comparison ({YEARS_FOR_ANALYSIS} years, NPV)",
+            labels={"x": "Cost Category", "y": "Net Present Value ($)"}
+        )
+        st.plotly_chart(fig_comparison, use_container_width=True)
+        
+        # Display comparison metrics
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.metric(
+                "Construction NPV",
+                f"${results['net_present_value']:,.0f}",
+                help="Net present value of construction costs."
+            )
+        
+        with col2:
+            st.metric(
+                "Energy NPV",
+                f"${total_energy_cost:,.0f}",
+                help="Net present value of energy costs."
+            )
+
+def display_cost_optimization_tab():
+    """Display the cost optimization recommendations tab."""
+    st.header("Cost Optimization")
+    
+    # Check if results are available
+    results = st.session_state.project_data["materials_cost"].get("results")
+    if not results:
+        st.info("Please calculate material costs using the Cost Parameters tab.")
+        return
+    
+    # Display cost optimization opportunities
+    st.subheader("Cost Optimization Opportunities")
+    
+    # Identify high-cost materials
+    material_total_costs = {}
+    for material, material_cost in results["initial_material_cost_by_material"].items():
+        labor_cost = results["initial_labor_cost_by_material"].get(material, 0)
+        material_total_costs[material] = material_cost + labor_cost
+    
+    # Sort materials by cost
+    sorted_materials = sorted(material_total_costs.items(), key=lambda x: x[1], reverse=True)
+    
+    # Create optimization recommendations
+    optimization_data = []
+    
+    for i, (material, cost) in enumerate(sorted_materials[:10]):  # Top 10 materials
+        # Calculate potential savings
+        potential_savings_low = cost * 0.1  # 10% savings
+        potential_savings_high = cost * 0.3  # 30% savings
+        
+        # Determine optimization strategy
+        if "Concrete" in material:
+            strategy = "Use high-performance concrete, optimize mix design"
+            difficulty = "Medium"
+        elif "Steel" in material:
+            strategy = "Optimize structural design, use high-strength steel"
+            difficulty = "High"
+        elif "Timber" in material:
+            strategy = "Use engineered wood products, optimize sizing"
+            difficulty = "Medium"
+        elif "Glass" in material:
+            strategy = "Optimize window sizing, use high-performance glazing"
+            difficulty = "Medium"
+        elif "Aluminum" in material:
+            strategy = "Optimize frame design, consider alternative materials"
+            difficulty = "Medium"
+        elif "Insulation" in material:
+            strategy = "Optimize insulation thickness, use cost-effective materials"
+            difficulty = "Low"
+        elif "equipment" in material:
+            strategy = "Right-size equipment, consider high-efficiency options"
+            difficulty = "Medium"
+        else:
+            strategy = "Value engineering, alternative materials"
+            difficulty = "Medium"
+        
+        optimization_data.append({
+            "Rank": i + 1,
+            "Material": material,
+            "Current Cost": f"${cost:,.0f}",
+            "Potential Savings (10-30%)": f"${potential_savings_low:,.0f} - ${potential_savings_high:,.0f}",
+            "Optimization Strategy": strategy,
+            "Implementation Difficulty": difficulty
+        })
+    
+    # Display optimization table
+    optimization_df = pd.DataFrame(optimization_data)
+    st.table(optimization_df)
+    
+    # Display cost reduction scenarios
+    st.subheader("Cost Reduction Scenarios")
+    
+    # Calculate different scenarios
+    current_cost = results["total_initial_construction_cost"]
+    
+    scenarios = {
+        "Current Design": current_cost,
+        "5% Cost Reduction": current_cost * 0.95,
+        "10% Cost Reduction": current_cost * 0.90,
+        "15% Cost Reduction": current_cost * 0.85,
+        "20% Cost Reduction": current_cost * 0.80
+    }
+    
+    # Create scenario comparison chart
+    fig_scenarios = px.bar(
+        x=list(scenarios.keys()),
+        y=list(scenarios.values()),
+        title="Cost Reduction Scenarios",
+        labels={"x": "Scenario", "y": "Initial Construction Cost ($)"}
+    )
+    st.plotly_chart(fig_scenarios, use_container_width=True)
+    
+    # Display payback analysis if renewable energy is available
+    if "renewable_energy" in st.session_state.project_data and st.session_state.project_data["renewable_energy"].get("results"):
+        st.subheader("Economic Payback Analysis")
+        
+        # Get renewable energy results
+        renewable_results = st.session_state.project_data["renewable_energy"]["results"]
+        building_energy_results = st.session_state.project_data["building_energy"]["results"]
+        
+        # Calculate PV system cost
+        pv_system = st.session_state.project_data["renewable_energy"]["pv_system"]
+        pv_capacity = pv_system["system_capacity_kw"]
+        pv_cost_per_kw = pv_system["cost_per_kw"]
+        pv_system_cost = pv_capacity * pv_cost_per_kw
+        
+        # Calculate annual energy savings
+        annual_pv_generation = renewable_results["annual_pv_generation"]  # kWh
+        electricity_rate = building_energy_results["energy_rates"]["electricity"]["rate"]  # $/kWh
+        annual_energy_savings = annual_pv_generation * electricity_rate
+        
+        # Calculate simple payback period
+        if annual_energy_savings > 0:
+            simple_payback = pv_system_cost / annual_energy_savings
+            
+            st.metric(
+                "PV System Simple Payback Period",
+                f"{simple_payback:.1f} years",
+                help="Years required for energy savings to offset PV system cost."
+            )
+            
+            # Create payback chart
+            years = list(range(0, min(int(simple_payback * 2), 30) + 1))
+            pv_cost = [pv_system_cost] * len(years)
+            energy_savings = [year * annual_energy_savings for year in years]
+            
+            fig_payback = go.Figure()
+            
+            fig_payback.add_trace(go.Scatter(
+                x=years,
+                y=pv_cost,
+                mode="lines",
+                name="PV System Cost"
+            ))
+            
+            fig_payback.add_trace(go.Scatter(
+                x=years,
+                y=energy_savings,
+                mode="lines",
+                name="Cumulative Energy Savings"
+            ))
+            
+            fig_payback.update_layout(
+                title="Economic Payback Analysis",
+                xaxis_title="Year",
+                yaxis_title="Cost/Savings ($)"
+            )
+            
+            st.plotly_chart(fig_payback, use_container_width=True)
+        else:
+            st.warning("No energy savings calculated. Cannot determine payback period.")
+    
+    # Display general cost optimization strategies
+    st.subheader("General Cost Optimization Strategies")
+    
+    strategies_data = {
+        "Strategy": [
+            "Value Engineering",
+            "Design Optimization",
+            "Material Substitution",
+            "Bulk Purchasing",
+            "Construction Sequencing",
+            "Energy Efficiency Measures",
+            "Lifecycle Cost Analysis",
+            "Standardization"
+        ],
+        "Potential Savings": [
+            "10-20%",
+            "5-15%",
+            "5-25%",
+            "2-8%",
+            "3-10%",
+            "Long-term savings",
+            "Optimize total cost",
+            "5-15%"
+        ],
+        "Implementation Phase": [
+            "Design",
+            "Design",
+            "Design/Procurement",
+            "Procurement",
+            "Construction",
+            "Design",
+            "Design",
+            "Design"
+        ]
+    }
+    
+    strategies_df = pd.DataFrame(strategies_data)
+    st.table(strategies_df)
+
+def calculate_material_costs() -> Dict[str, Any]:
+    """
+    Calculate material costs based on material inventory and cost parameters.
+    
+    Returns:
+        Dictionary containing material cost results.
+    """
+    logger.info("Starting material cost calculations...")
+    
+    # Get required data
+    material_inventory = st.session_state.project_data["embodied_energy"]["material_inventory"]
+    material_costs = st.session_state.project_data["materials_cost"]["material_costs"]
+    labor_costs = st.session_state.project_data["materials_cost"]["labor_costs"]
+    economic_params = st.session_state.project_data["materials_cost"]["economic_parameters"]
+    
+    # Get economic parameters
+    discount_rate = economic_params["discount_rate"]
+    inflation_rate = economic_params["inflation_rate"]
+    maintenance_rate = economic_params["maintenance_rate"]
+    
+    # Initialize results
+    initial_material_cost_by_material = {}
+    initial_labor_cost_by_material = {}
+    initial_material_cost_by_category = {}
+    initial_labor_cost_by_category = {}
+    lifecycle_material_cost_by_category = {}
+    lifecycle_labor_cost_by_category = {}
+    cumulative_costs = {"0": 0}
+    
+    # Calculate costs for each material
+    for item in material_inventory:
+        material_name = item["material_name"]
+        category = item["material_category"]
+        quantity = item["quantity"]  # kg
+        replacement_cycle = item["replacement_cycle"]  # years
+        
+        # Get cost factors
+        material_cost_per_kg = material_costs.get(material_name, 0)  # $/kg
+        labor_cost_per_kg = labor_costs.get(material_name, 0)  # $/kg
+        
+        # Calculate initial costs
+        initial_material_cost = quantity * material_cost_per_kg
+        initial_labor_cost = quantity * labor_cost_per_kg
+        
+        # Add to material totals
+        if material_name in initial_material_cost_by_material:
+            initial_material_cost_by_material[material_name] += initial_material_cost
+            initial_labor_cost_by_material[material_name] += initial_labor_cost
+        else:
+            initial_material_cost_by_material[material_name] = initial_material_cost
+            initial_labor_cost_by_material[material_name] = initial_labor_cost
+        
+        # Add to category totals
+        if category in initial_material_cost_by_category:
+            initial_material_cost_by_category[category] += initial_material_cost
+            initial_labor_cost_by_category[category] += initial_labor_cost
+        else:
+            initial_material_cost_by_category[category] = initial_material_cost
+            initial_labor_cost_by_category[category] = initial_labor_cost
+        
+        # Calculate lifecycle costs with replacements and inflation
+        num_replacements = YEARS_FOR_ANALYSIS // replacement_cycle
+        
+        # Initial cost
+        lifecycle_material_cost = initial_material_cost
+        lifecycle_labor_cost = initial_labor_cost
+        
+        # Replacement costs
+        for replacement in range(1, num_replacements + 1):
+            replacement_year = replacement * replacement_cycle
+            
+            # Apply inflation to replacement costs
+            inflated_material_cost = initial_material_cost * ((1 + inflation_rate) ** replacement_year)
+            inflated_labor_cost = initial_labor_cost * ((1 + inflation_rate) ** replacement_year)
+            
+            # Discount to present value
+            discounted_material_cost = inflated_material_cost / ((1 + discount_rate) ** replacement_year)
+            discounted_labor_cost = inflated_labor_cost / ((1 + discount_rate) ** replacement_year)
+            
+            lifecycle_material_cost += discounted_material_cost
+            lifecycle_labor_cost += discounted_labor_cost
+        
+        # Add to lifecycle category totals
+        if category in lifecycle_material_cost_by_category:
+            lifecycle_material_cost_by_category[category] += lifecycle_material_cost
+            lifecycle_labor_cost_by_category[category] += lifecycle_labor_cost
+        else:
+            lifecycle_material_cost_by_category[category] = lifecycle_material_cost
+            lifecycle_labor_cost_by_category[category] = lifecycle_labor_cost
+        
+        # Add to cumulative costs over time
+        cumulative_costs["0"] += initial_material_cost + initial_labor_cost
+        
+        for replacement in range(1, num_replacements + 1):
+            replacement_year = replacement * replacement_cycle
+            year_str = str(replacement_year)
+            
+            if year_str not in cumulative_costs:
+                # Find the previous year's cumulative cost
+                prev_year = replacement_year - replacement_cycle
+                cumulative_costs[year_str] = cumulative_costs[str(prev_year)]
+            
+            # Add replacement cost (not discounted for cumulative display)
+            inflated_material_cost = initial_material_cost * ((1 + inflation_rate) ** replacement_year)
+            inflated_labor_cost = initial_labor_cost * ((1 + inflation_rate) ** replacement_year)
+            
+            cumulative_costs[year_str] += inflated_material_cost + inflated_labor_cost
+    
+    # Calculate totals
+    total_initial_material_cost = sum(initial_material_cost_by_material.values())
+    total_initial_labor_cost = sum(initial_labor_cost_by_material.values())
+    total_initial_construction_cost = total_initial_material_cost + total_initial_labor_cost
+    
+    total_lifecycle_material_cost = sum(lifecycle_material_cost_by_category.values())
+    total_lifecycle_labor_cost = sum(lifecycle_labor_cost_by_category.values())
+    
+    # Calculate maintenance costs
+    total_maintenance_cost = 0
+    for year in range(1, YEARS_FOR_ANALYSIS + 1):
+        annual_maintenance = total_initial_construction_cost * maintenance_rate
+        inflated_maintenance = annual_maintenance * ((1 + inflation_rate) ** year)
+        discounted_maintenance = inflated_maintenance / ((1 + discount_rate) ** year)
+        total_maintenance_cost += discounted_maintenance
+    
+    total_lifecycle_construction_cost = total_lifecycle_material_cost + total_lifecycle_labor_cost + total_maintenance_cost
+    
+    # Calculate net present value
+    net_present_value = total_lifecycle_construction_cost
+    
+    # Calculate annualized cost
+    # Using capital recovery factor
+    capital_recovery_factor = (discount_rate * ((1 + discount_rate) ** YEARS_FOR_ANALYSIS)) / (((1 + discount_rate) ** YEARS_FOR_ANALYSIS) - 1)
+    annualized_cost = net_present_value * capital_recovery_factor
+    
+    # Get building info for normalization
+    building_info = st.session_state.project_data["building_info"]
+    floor_area = building_info.get("floor_area", 0)
+    
+    # Calculate normalized metrics
+    construction_cost_per_area = total_initial_construction_cost / floor_area if floor_area > 0 else 0
+    
+    # Compile results
+    results = {
+        "initial_material_cost_by_material": initial_material_cost_by_material,
+        "initial_labor_cost_by_material": initial_labor_cost_by_material,
+        "initial_material_cost_by_category": initial_material_cost_by_category,
+        "initial_labor_cost_by_category": initial_labor_cost_by_category,
+        "lifecycle_material_cost_by_category": lifecycle_material_cost_by_category,
+        "lifecycle_labor_cost_by_category": lifecycle_labor_cost_by_category,
+        "cumulative_costs": cumulative_costs,
+        "total_initial_material_cost": total_initial_material_cost,
+        "total_initial_labor_cost": total_initial_labor_cost,
+        "total_initial_construction_cost": total_initial_construction_cost,
+        "total_lifecycle_material_cost": total_lifecycle_material_cost,
+        "total_lifecycle_labor_cost": total_lifecycle_labor_cost,
+        "total_maintenance_cost": total_maintenance_cost,
+        "total_lifecycle_construction_cost": total_lifecycle_construction_cost,
+        "net_present_value": net_present_value,
+        "annualized_cost": annualized_cost,
+        "construction_cost_per_area": construction_cost_per_area,
+        "calculation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    logger.info("Material cost calculations completed.")
+    return results
+
+def display_materials_cost_help():
+    """
+    Display help information for the materials cost page.
+    """
+    st.markdown("""
+    ### Materials Cost Analysis Help
+    
+    This section calculates the costs associated with building materials, including initial construction costs, lifecycle costs, and economic optimization opportunities.
+    
+    **Key Concepts:**
+    
+    * **Material Costs**: Direct costs of materials ($/kg).
+    * **Labor Costs**: Installation labor costs ($/kg).
+    * **Lifecycle Costs**: Total costs over the building's lifespan including initial construction, replacements, and maintenance.
+    * **Net Present Value (NPV)**: Present value of all future costs, accounting for discount rate.
+    * **Discount Rate**: Interest rate used to calculate present value of future costs.
+    * **Inflation Rate**: Annual rate of cost increase.
+    * **Payback Period**: Time required for savings to offset initial investment.
+    
+    **Workflow:**
+    
+    1. **Cost Parameters Tab**:
+        * Configure economic parameters (discount rate, inflation rate, maintenance rate).
+        * Adjust material and labor costs for different materials.
+        * Click "Calculate Material Costs" to perform the analysis.
+    
+    2. **Cost Analysis Tab**:
+        * Review initial construction costs and cost breakdown.
+        * Analyze costs by material category and individual materials.
+        * Identify the most expensive materials.
+    
+    3. **Lifecycle Costs Tab**:
+        * Review total lifecycle costs including replacements and maintenance.
+        * Analyze cost accumulation over time.
+        * Compare construction costs with energy costs.
+    
+    4. **Cost Optimization Tab**:
+        * Identify cost optimization opportunities.
+        * Review cost reduction scenarios.
+        * Analyze economic payback of renewable energy systems.
+        * Explore general cost optimization strategies.
+    
+    **Important:**
+    
+    * Accurate material quantities from the Embodied Energy module are essential.
+    * Cost data should reflect local market conditions.
+    * Lifecycle cost analysis helps identify the most cost-effective solutions.
+    * Consider both initial costs and long-term operational costs in decision-making.
+    """)

app/materials_library.py

@@ -0,0 +1,1215 @@
+"""
+HVAC Load Calculator - Material Library Module
+
+This module handles the material library functionality of the HVAC Load Calculator application,
+allowing users to manage building materials and fenestrations (windows, doors, skylights).
+It provides both predefined library materials and the ability to create custom materials.
+
+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
+from typing import Dict, List, Any, Optional, Tuple, Union
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Define constants
+MATERIAL_CATEGORIES = [
+    "Finishing Materials",
+    "Structural Materials",
+    "Sub-Structural Materials",
+    "Insulation",
+    "Custom"
+]
+
+FENESTRATION_TYPES = [
+    "Window",
+    "Door",
+    "Skylight",
+    "Custom"
+]
+
+# Default library materials
+DEFAULT_MATERIALS = {
+    "Brick": {
+        "category": "Structural Materials",
+        "thermal_conductivity": 0.72,
+        "density": 1920.0,
+        "specific_heat": 840.0,
+        "thickness_range": [0.05, 0.3],
+        "default_thickness": 0.1,
+        "embodied_carbon": 240.0,  # kg CO2e/m³
+        "cost": 180.0  # USD/m³
+    },
+    "Concrete": {
+        "category": "Structural Materials",
+        "thermal_conductivity": 1.4,
+        "density": 2300.0,
+        "specific_heat": 880.0,
+        "thickness_range": [0.05, 0.5],
+        "default_thickness": 0.15,
+        "embodied_carbon": 320.0,
+        "cost": 120.0
+    },
+    "Gypsum Board": {
+        "category": "Finishing Materials",
+        "thermal_conductivity": 0.25,
+        "density": 900.0,
+        "specific_heat": 1000.0,
+        "thickness_range": [0.01, 0.05],
+        "default_thickness": 0.0125,
+        "embodied_carbon": 120.0,
+        "cost": 90.0
+    },
+    "Mineral Wool": {
+        "category": "Insulation",
+        "thermal_conductivity": 0.04,
+        "density": 30.0,
+        "specific_heat": 840.0,
+        "thickness_range": [0.025, 0.3],
+        "default_thickness": 0.1,
+        "embodied_carbon": 45.0,
+        "cost": 70.0
+    },
+    "EPS Insulation": {
+        "category": "Insulation",
+        "thermal_conductivity": 0.035,
+        "density": 25.0,
+        "specific_heat": 1400.0,
+        "thickness_range": [0.025, 0.3],
+        "default_thickness": 0.1,
+        "embodied_carbon": 88.0,
+        "cost": 65.0
+    },
+    "Wood (Pine)": {
+        "category": "Structural Materials",
+        "thermal_conductivity": 0.14,
+        "density": 550.0,
+        "specific_heat": 1600.0,
+        "thickness_range": [0.01, 0.3],
+        "default_thickness": 0.05,
+        "embodied_carbon": 110.0,
+        "cost": 250.0
+    },
+    "Steel": {
+        "category": "Structural Materials",
+        "thermal_conductivity": 50.0,
+        "density": 7800.0,
+        "specific_heat": 450.0,
+        "thickness_range": [0.001, 0.05],
+        "default_thickness": 0.005,
+        "embodied_carbon": 1750.0,
+        "cost": 800.0
+    },
+    "Aluminum": {
+        "category": "Structural Materials",
+        "thermal_conductivity": 230.0,
+        "density": 2700.0,
+        "specific_heat": 880.0,
+        "thickness_range": [0.001, 0.05],
+        "default_thickness": 0.003,
+        "embodied_carbon": 8500.0,
+        "cost": 1200.0
+    },
+    "Glass Fiber Insulation": {
+        "category": "Insulation",
+        "thermal_conductivity": 0.035,
+        "density": 12.0,
+        "specific_heat": 840.0,
+        "thickness_range": [0.025, 0.3],
+        "default_thickness": 0.1,
+        "embodied_carbon": 28.0,
+        "cost": 45.0
+    },
+    "Ceramic Tile": {
+        "category": "Finishing Materials",
+        "thermal_conductivity": 1.3,
+        "density": 2300.0,
+        "specific_heat": 840.0,
+        "thickness_range": [0.005, 0.025],
+        "default_thickness": 0.01,
+        "embodied_carbon": 650.0,
+        "cost": 280.0
+    },
+    "Carpet": {
+        "category": "Finishing Materials",
+        "thermal_conductivity": 0.06,
+        "density": 200.0,
+        "specific_heat": 1300.0,
+        "thickness_range": [0.005, 0.02],
+        "default_thickness": 0.01,
+        "embodied_carbon": 40.0,
+        "cost": 150.0
+    },
+    "Plywood": {
+        "category": "Sub-Structural Materials",
+        "thermal_conductivity": 0.13,
+        "density": 560.0,
+        "specific_heat": 1400.0,
+        "thickness_range": [0.006, 0.025],
+        "default_thickness": 0.012,
+        "embodied_carbon": 350.0,
+        "cost": 180.0
+    },
+    "Concrete Block": {
+        "category": "Structural Materials",
+        "thermal_conductivity": 0.51,
+        "density": 1400.0,
+        "specific_heat": 1000.0,
+        "thickness_range": [0.1, 0.3],
+        "default_thickness": 0.2,
+        "embodied_carbon": 260.0,
+        "cost": 140.0
+    },
+    "Stone (Granite)": {
+        "category": "Finishing Materials",
+        "thermal_conductivity": 2.8,
+        "density": 2600.0,
+        "specific_heat": 790.0,
+        "thickness_range": [0.01, 0.1],
+        "default_thickness": 0.03,
+        "embodied_carbon": 170.0,
+        "cost": 450.0
+    },
+    "Polyurethane Insulation": {
+        "category": "Insulation",
+        "thermal_conductivity": 0.025,
+        "density": 30.0,
+        "specific_heat": 1400.0,
+        "thickness_range": [0.025, 0.2],
+        "default_thickness": 0.075,
+        "embodied_carbon": 102.0,
+        "cost": 95.0
+    }
+}
+
+# Default library fenestrations
+DEFAULT_FENESTRATIONS = {
+    "Single Glazing": {
+        "type": "Window",
+        "u_value": 5.8,
+        "shgc": 0.86,
+        "visible_transmittance": 0.9,
+        "thickness": 0.006,
+        "embodied_carbon": 800.0,  # kg CO2e/m²
+        "cost": 120.0  # USD/m²
+    },
+    "Double Glazing (Air)": {
+        "type": "Window",
+        "u_value": 2.8,
+        "shgc": 0.72,
+        "visible_transmittance": 0.78,
+        "thickness": 0.024,
+        "embodied_carbon": 950.0,
+        "cost": 180.0
+    },
+    "Double Glazing (Argon)": {
+        "type": "Window",
+        "u_value": 1.4,
+        "shgc": 0.7,
+        "visible_transmittance": 0.76,
+        "thickness": 0.024,
+        "embodied_carbon": 980.0,
+        "cost": 220.0
+    },
+    "Triple Glazing": {
+        "type": "Window",
+        "u_value": 0.8,
+        "shgc": 0.5,
+        "visible_transmittance": 0.68,
+        "thickness": 0.036,
+        "embodied_carbon": 1100.0,
+        "cost": 320.0
+    },
+    "Low-E Double Glazing": {
+        "type": "Window",
+        "u_value": 1.8,
+        "shgc": 0.4,
+        "visible_transmittance": 0.74,
+        "thickness": 0.024,
+        "embodied_carbon": 1050.0,
+        "cost": 250.0
+    },
+    "Wooden Door": {
+        "type": "Door",
+        "u_value": 2.2,
+        "shgc": 0.0,
+        "visible_transmittance": 0.0,
+        "thickness": 0.04,
+        "embodied_carbon": 400.0,
+        "cost": 280.0
+    },
+    "Steel Door": {
+        "type": "Door",
+        "u_value": 3.1,
+        "shgc": 0.0,
+        "visible_transmittance": 0.0,
+        "thickness": 0.035,
+        "embodied_carbon": 1200.0,
+        "cost": 350.0
+    },
+    "Glass Door": {
+        "type": "Door",
+        "u_value": 3.8,
+        "shgc": 0.6,
+        "visible_transmittance": 0.7,
+        "thickness": 0.01,
+        "embodied_carbon": 900.0,
+        "cost": 420.0
+    },
+    "Skylight (Double Glazed)": {
+        "type": "Skylight",
+        "u_value": 3.0,
+        "shgc": 0.65,
+        "visible_transmittance": 0.75,
+        "thickness": 0.024,
+        "embodied_carbon": 1050.0,
+        "cost": 380.0
+    },
+    "Skylight (Low-E)": {
+        "type": "Skylight",
+        "u_value": 2.0,
+        "shgc": 0.35,
+        "visible_transmittance": 0.7,
+        "thickness": 0.024,
+        "embodied_carbon": 1150.0,
+        "cost": 450.0
+    }
+}
+
+def display_materials_page():
+    """
+    Display the material library page.
+    This is the main function called by main.py when the Material Library page is selected.
+    """
+    st.title("Material Library")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_materials_help()
+    
+    # Create tabs for materials and fenestrations
+    tab1, tab2 = st.tabs(["Materials", "Fenestrations"])
+    
+    # Materials tab
+    with tab1:
+        display_materials_tab()
+    
+    # Fenestrations tab
+    with tab2:
+        display_fenestrations_tab()
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Climate Data", key="back_to_climate"):
+            st.session_state.current_page = "Climate Data"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Construction", key="continue_to_construction"):
+            st.session_state.current_page = "Construction"
+            st.rerun()
+
+def display_materials_tab():
+    """Display the materials tab content."""
+    # Initialize materials in session state if not present
+    initialize_materials()
+    
+    # Create columns for library and project materials
+    col1, col2 = st.columns(2)
+    
+    # Library Materials
+    with col1:
+        st.subheader("Library Materials")
+        display_library_materials()
+    
+    # Project Materials
+    with col2:
+        st.subheader("Project Materials")
+        display_project_materials()
+    
+    # Material Editor
+    st.markdown("---")
+    st.subheader("Material Editor")
+    display_material_editor()
+
+def display_fenestrations_tab():
+    """Display the fenestrations tab content."""
+    # Initialize fenestrations in session state if not present
+    initialize_fenestrations()
+    
+    # Create columns for library and project fenestrations
+    col1, col2 = st.columns(2)
+    
+    # Library Fenestrations
+    with col1:
+        st.subheader("Library Fenestrations")
+        display_library_fenestrations()
+    
+    # Project Fenestrations
+    with col2:
+        st.subheader("Project Fenestrations")
+        display_project_fenestrations()
+    
+    # Fenestration Editor
+    st.markdown("---")
+    st.subheader("Fenestration Editor")
+    display_fenestration_editor()
+
+def initialize_materials():
+    """Initialize materials in session state if not present."""
+    if "materials" not in st.session_state.project_data:
+        st.session_state.project_data["materials"] = {
+            "library": {},
+            "project": {}
+        }
+    
+    # Initialize library materials if empty
+    if not st.session_state.project_data["materials"]["library"]:
+        st.session_state.project_data["materials"]["library"] = DEFAULT_MATERIALS.copy()
+    
+    # Initialize material editor state
+    if "material_editor" not in st.session_state:
+        st.session_state.material_editor = {
+            "name": "",
+            "category": MATERIAL_CATEGORIES[0],
+            "thermal_conductivity": 0.5,
+            "density": 1000.0,
+            "specific_heat": 1000.0,
+            "thickness_range": [0.01, 0.2],
+            "default_thickness": 0.05,
+            "embodied_carbon": 100.0,
+            "cost": 100.0,
+            "edit_mode": False,
+            "original_name": ""
+        }
+
+def initialize_fenestrations():
+    """Initialize fenestrations in session state if not present."""
+    if "fenestrations" not in st.session_state.project_data:
+        st.session_state.project_data["fenestrations"] = {
+            "library": {},
+            "project": {}
+        }
+    
+    # Initialize library fenestrations if empty
+    if not st.session_state.project_data["fenestrations"]["library"]:
+        st.session_state.project_data["fenestrations"]["library"] = DEFAULT_FENESTRATIONS.copy()
+    
+    # Initialize fenestration editor state
+    if "fenestration_editor" not in st.session_state:
+        st.session_state.fenestration_editor = {
+            "name": "",
+            "type": FENESTRATION_TYPES[0],
+            "u_value": 2.8,
+            "shgc": 0.7,
+            "visible_transmittance": 0.8,
+            "thickness": 0.024,
+            "embodied_carbon": 900.0,
+            "cost": 200.0,
+            "edit_mode": False,
+            "original_name": ""
+        }
+
+def display_library_materials():
+    """Display the library materials section."""
+    # Filter options
+    category_filter = st.selectbox(
+        "Filter by Category",
+        ["All"] + MATERIAL_CATEGORIES,
+        key="library_material_category_filter"
+    )
+    
+    # Get library materials
+    library_materials = st.session_state.project_data["materials"]["library"]
+    
+    # Apply filter
+    if category_filter != "All":
+        filtered_materials = {
+            name: props for name, props in library_materials.items()
+            if props["category"] == category_filter
+        }
+    else:
+        filtered_materials = library_materials
+    
+    # Display materials in a table
+    if filtered_materials:
+        # Create a DataFrame for display
+        data = []
+        for name, props in filtered_materials.items():
+            data.append({
+                "Name": name,
+                "Category": props["category"],
+                "Thermal Conductivity (W/m·K)": props["thermal_conductivity"],
+                "Density (kg/m³)": props["density"],
+                "Specific Heat (J/kg·K)": props["specific_heat"]
+            })
+        
+        df = pd.DataFrame(data)
+        st.dataframe(df, use_container_width=True, hide_index=True)
+        
+        # Add to project button
+        selected_material = st.selectbox(
+            "Select Material to Add to Project",
+            list(filtered_materials.keys()),
+            key="library_material_selector"
+        )
+        
+        if st.button("Add to Project", key="add_library_material_to_project"):
+            # Check if material already exists in project
+            if selected_material in st.session_state.project_data["materials"]["project"]:
+                st.warning(f"Material '{selected_material}' already exists in your project.")
+            else:
+                # Add to project materials
+                st.session_state.project_data["materials"]["project"][selected_material] = \
+                    st.session_state.project_data["materials"]["library"][selected_material].copy()
+                st.success(f"Material '{selected_material}' added to your project.")
+                logger.info(f"Added library material '{selected_material}' to project")
+    else:
+        st.info("No materials found in the selected category.")
+
+def display_project_materials():
+    """Display the project materials section."""
+    # Get project materials
+    project_materials = st.session_state.project_data["materials"]["project"]
+    
+    if project_materials:
+        # Create a DataFrame for display
+        data = []
+        for name, props in project_materials.items():
+            data.append({
+                "Name": name,
+                "Category": props["category"],
+                "Thermal Conductivity (W/m·K)": props["thermal_conductivity"],
+                "Density (kg/m³)": props["density"],
+                "Specific Heat (J/kg·K)": props["specific_heat"]
+            })
+        
+        df = pd.DataFrame(data)
+        st.dataframe(df, use_container_width=True, hide_index=True)
+        
+        # Edit and delete options
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            selected_material = st.selectbox(
+                "Select Material to Edit",
+                list(project_materials.keys()),
+                key="project_material_edit_selector"
+            )
+            
+            if st.button("Edit Material", key="edit_project_material"):
+                # Load material data into editor
+                material_data = project_materials[selected_material]
+                st.session_state.material_editor = {
+                    "name": selected_material,
+                    "category": material_data["category"],
+                    "thermal_conductivity": material_data["thermal_conductivity"],
+                    "density": material_data["density"],
+                    "specific_heat": material_data["specific_heat"],
+                    "thickness_range": material_data["thickness_range"],
+                    "default_thickness": material_data["default_thickness"],
+                    "embodied_carbon": material_data["embodied_carbon"],
+                    "cost": material_data["cost"],
+                    "edit_mode": True,
+                    "original_name": selected_material
+                }
+                st.success(f"Material '{selected_material}' loaded for editing.")
+        
+        with col2:
+            selected_material_delete = st.selectbox(
+                "Select Material to Delete",
+                list(project_materials.keys()),
+                key="project_material_delete_selector"
+            )
+            
+            if st.button("Delete Material", key="delete_project_material"):
+                # Check if material is in use
+                is_in_use = check_material_in_use(selected_material_delete)
+                
+                if is_in_use:
+                    st.error(f"Cannot delete material '{selected_material_delete}' because it is in use in constructions.")
+                else:
+                    # Delete material
+                    del st.session_state.project_data["materials"]["project"][selected_material_delete]
+                    st.success(f"Material '{selected_material_delete}' deleted from your project.")
+                    logger.info(f"Deleted material '{selected_material_delete}' from project")
+    else:
+        st.info("No materials in your project. Add materials from the library or create custom materials.")
+
+def display_material_editor():
+    """Display the material editor form."""
+    with st.form("material_editor_form"):
+        # Material name
+        name = st.text_input(
+            "Material Name",
+            value=st.session_state.material_editor["name"],
+            help="Enter a unique name for the material."
+        )
+        
+        # Create two columns for layout
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Category
+            category = st.selectbox(
+                "Category",
+                MATERIAL_CATEGORIES,
+                index=MATERIAL_CATEGORIES.index(st.session_state.material_editor["category"]) if st.session_state.material_editor["category"] in MATERIAL_CATEGORIES else 0,
+                help="Select the material category."
+            )
+            
+            # Thermal conductivity
+            thermal_conductivity = st.number_input(
+                "Thermal Conductivity (W/m·K)",
+                min_value=0.001,
+                max_value=1000.0,
+                value=float(st.session_state.material_editor["thermal_conductivity"]),
+                format="%.3f",
+                help="Thermal conductivity in W/m·K. Lower values indicate better insulation."
+            )
+            
+            # Density
+            density = st.number_input(
+                "Density (kg/m³)",
+                min_value=1.0,
+                max_value=20000.0,
+                value=float(st.session_state.material_editor["density"]),
+                format="%.1f",
+                help="Material density in kg/m³."
+            )
+        
+        with col2:
+            # Specific heat
+            specific_heat = st.number_input(
+                "Specific Heat (J/kg·K)",
+                min_value=100.0,
+                max_value=10000.0,
+                value=float(st.session_state.material_editor["specific_heat"]),
+                format="%.1f",
+                help="Specific heat capacity in J/kg·K. Higher values indicate better thermal mass."
+            )
+            
+            # Thickness range
+            min_thickness, max_thickness = st.session_state.material_editor["thickness_range"]
+            thickness_range = st.slider(
+                "Thickness Range (m)",
+                min_value=0.001,
+                max_value=0.5,
+                value=(float(min_thickness), float(max_thickness)),
+                format="%.3f",
+                help="Minimum and maximum thickness range for this material in meters."
+            )
+            
+            # Default thickness
+            default_thickness = st.number_input(
+                "Default Thickness (m)",
+                min_value=float(thickness_range[0]),
+                max_value=float(thickness_range[1]),
+                value=min(max(float(st.session_state.material_editor["default_thickness"]), float(thickness_range[0])), float(thickness_range[1])),
+                format="%.3f",
+                help="Default thickness for this material in meters."
+            )
+        
+        # Additional properties for embodied carbon and cost
+        st.subheader("Additional Properties")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Embodied carbon
+            embodied_carbon = st.number_input(
+                "Embodied Carbon (kg CO₂e/m³)",
+                min_value=0.0,
+                max_value=10000.0,
+                value=float(st.session_state.material_editor["embodied_carbon"]),
+                format="%.1f",
+                help="Embodied carbon in kg CO₂e per cubic meter."
+            )
+        
+        with col2:
+            # Cost
+            cost = st.number_input(
+                "Cost (USD/m³)",
+                min_value=0.0,
+                max_value=10000.0,
+                value=float(st.session_state.material_editor["cost"]),
+                format="%.1f",
+                help="Material cost in USD per cubic meter."
+            )
+        
+        # Form submission buttons
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            submit_button = st.form_submit_button("Save Material")
+        
+        with col2:
+            clear_button = st.form_submit_button("Clear Form")
+    
+    # Handle form submission
+    if submit_button:
+        # Validate inputs
+        validation_errors = validate_material(
+            name, category, thermal_conductivity, density, specific_heat,
+            thickness_range, default_thickness, embodied_carbon, cost,
+            st.session_state.material_editor["edit_mode"], st.session_state.material_editor["original_name"]
+        )
+        
+        if validation_errors:
+            # Display validation errors
+            for error in validation_errors:
+                st.error(error)
+        else:
+            # Create material data
+            material_data = {
+                "category": category,
+                "thermal_conductivity": thermal_conductivity,
+                "density": density,
+                "specific_heat": specific_heat,
+                "thickness_range": list(thickness_range),
+                "default_thickness": default_thickness,
+                "embodied_carbon": embodied_carbon,
+                "cost": cost
+            }
+            
+            # Handle edit mode
+            if st.session_state.material_editor["edit_mode"]:
+                original_name = st.session_state.material_editor["original_name"]
+                
+                # If name changed, delete old entry and create new one
+                if original_name != name:
+                    del st.session_state.project_data["materials"]["project"][original_name]
+                
+                # Update material
+                st.session_state.project_data["materials"]["project"][name] = material_data
+                st.success(f"Material '{name}' updated successfully.")
+                logger.info(f"Updated material '{name}' in project")
+            else:
+                # Add new material
+                st.session_state.project_data["materials"]["project"][name] = material_data
+                st.success(f"Material '{name}' added to your project.")
+                logger.info(f"Added new material '{name}' to project")
+            
+            # Reset editor
+            reset_material_editor()
+    
+    # Handle clear button
+    if clear_button:
+        reset_material_editor()
+        st.rerun()
+
+def display_library_fenestrations():
+    """Display the library fenestrations section."""
+    # Filter options
+    type_filter = st.selectbox(
+        "Filter by Type",
+        ["All"] + FENESTRATION_TYPES,
+        key="library_fenestration_type_filter"
+    )
+    
+    # Get library fenestrations
+    library_fenestrations = st.session_state.project_data["fenestrations"]["library"]
+    
+    # Apply filter
+    if type_filter != "All":
+        filtered_fenestrations = {
+            name: props for name, props in library_fenestrations.items()
+            if props["type"] == type_filter
+        }
+    else:
+        filtered_fenestrations = library_fenestrations
+    
+    # Display fenestrations in a table
+    if filtered_fenestrations:
+        # Create a DataFrame for display
+        data = []
+        for name, props in filtered_fenestrations.items():
+            data.append({
+                "Name": name,
+                "Type": props["type"],
+                "U-Value (W/m²·K)": props["u_value"],
+                "SHGC": props["shgc"],
+                "Visible Transmittance": props["visible_transmittance"]
+            })
+        
+        df = pd.DataFrame(data)
+        st.dataframe(df, use_container_width=True, hide_index=True)
+        
+        # Add to project button
+        selected_fenestration = st.selectbox(
+            "Select Fenestration to Add to Project",
+            list(filtered_fenestrations.keys()),
+            key="library_fenestration_selector"
+        )
+        
+        if st.button("Add to Project", key="add_library_fenestration_to_project"):
+            # Check if fenestration already exists in project
+            if selected_fenestration in st.session_state.project_data["fenestrations"]["project"]:
+                st.warning(f"Fenestration '{selected_fenestration}' already exists in your project.")
+            else:
+                # Add to project fenestrations
+                st.session_state.project_data["fenestrations"]["project"][selected_fenestration] = \
+                    st.session_state.project_data["fenestrations"]["library"][selected_fenestration].copy()
+                st.success(f"Fenestration '{selected_fenestration}' added to your project.")
+                logger.info(f"Added library fenestration '{selected_fenestration}' to project")
+    else:
+        st.info("No fenestrations found in the selected type.")
+
+def display_project_fenestrations():
+    """Display the project fenestrations section."""
+    # Get project fenestrations
+    project_fenestrations = st.session_state.project_data["fenestrations"]["project"]
+    
+    if project_fenestrations:
+        # Create a DataFrame for display
+        data = []
+        for name, props in project_fenestrations.items():
+            data.append({
+                "Name": name,
+                "Type": props["type"],
+                "U-Value (W/m²·K)": props["u_value"],
+                "SHGC": props["shgc"],
+                "Visible Transmittance": props["visible_transmittance"]
+            })
+        
+        df = pd.DataFrame(data)
+        st.dataframe(df, use_container_width=True, hide_index=True)
+        
+        # Edit and delete options
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            selected_fenestration = st.selectbox(
+                "Select Fenestration to Edit",
+                list(project_fenestrations.keys()),
+                key="project_fenestration_edit_selector"
+            )
+            
+            if st.button("Edit Fenestration", key="edit_project_fenestration"):
+                # Load fenestration data into editor
+                fenestration_data = project_fenestrations[selected_fenestration]
+                st.session_state.fenestration_editor = {
+                    "name": selected_fenestration,
+                    "type": fenestration_data["type"],
+                    "u_value": fenestration_data["u_value"],
+                    "shgc": fenestration_data["shgc"],
+                    "visible_transmittance": fenestration_data["visible_transmittance"],
+                    "thickness": fenestration_data["thickness"],
+                    "embodied_carbon": fenestration_data["embodied_carbon"],
+                    "cost": fenestration_data["cost"],
+                    "edit_mode": True,
+                    "original_name": selected_fenestration
+                }
+                st.success(f"Fenestration '{selected_fenestration}' loaded for editing.")
+        
+        with col2:
+            selected_fenestration_delete = st.selectbox(
+                "Select Fenestration to Delete",
+                list(project_fenestrations.keys()),
+                key="project_fenestration_delete_selector"
+            )
+            
+            if st.button("Delete Fenestration", key="delete_project_fenestration"):
+                # Check if fenestration is in use
+                is_in_use = check_fenestration_in_use(selected_fenestration_delete)
+                
+                if is_in_use:
+                    st.error(f"Cannot delete fenestration '{selected_fenestration_delete}' because it is in use in components.")
+                else:
+                    # Delete fenestration
+                    del st.session_state.project_data["fenestrations"]["project"][selected_fenestration_delete]
+                    st.success(f"Fenestration '{selected_fenestration_delete}' deleted from your project.")
+                    logger.info(f"Deleted fenestration '{selected_fenestration_delete}' from project")
+    else:
+        st.info("No fenestrations in your project. Add fenestrations from the library or create custom fenestrations.")
+
+def display_fenestration_editor():
+    """Display the fenestration editor form."""
+    with st.form("fenestration_editor_form"):
+        # Fenestration name
+        name = st.text_input(
+            "Fenestration Name",
+            value=st.session_state.fenestration_editor["name"],
+            help="Enter a unique name for the fenestration."
+        )
+        
+        # Create two columns for layout
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Type
+            fenestration_type = st.selectbox(
+                "Type",
+                FENESTRATION_TYPES,
+                index=FENESTRATION_TYPES.index(st.session_state.fenestration_editor["type"]) if st.session_state.fenestration_editor["type"] in FENESTRATION_TYPES else 0,
+                help="Select the fenestration type."
+            )
+            
+            # U-value
+            u_value = st.number_input(
+                "U-Value (W/m²·K)",
+                min_value=0.1,
+                max_value=10.0,
+                value=float(st.session_state.fenestration_editor["u_value"]),
+                format="%.2f",
+                help="U-value in W/m²·K. Lower values indicate better insulation."
+            )
+            
+            # SHGC
+            shgc = st.number_input(
+                "Solar Heat Gain Coefficient (SHGC)",
+                min_value=0.0,
+                max_value=1.0,
+                value=float(st.session_state.fenestration_editor["shgc"]),
+                format="%.2f",
+                help="Solar Heat Gain Coefficient (0-1). Lower values indicate less solar heat transmission."
+            )
+        
+        with col2:
+            # Visible transmittance
+            visible_transmittance = st.number_input(
+                "Visible Transmittance",
+                min_value=0.0,
+                max_value=1.0,
+                value=float(st.session_state.fenestration_editor["visible_transmittance"]),
+                format="%.2f",
+                help="Visible Transmittance (0-1). Higher values indicate more visible light transmission."
+            )
+            
+            # Thickness
+            thickness = st.number_input(
+                "Thickness (m)",
+                min_value=0.001,
+                max_value=0.1,
+                value=float(st.session_state.fenestration_editor["thickness"]),
+                format="%.3f",
+                help="Thickness in meters."
+            )
+        
+        # Additional properties for embodied carbon and cost
+        st.subheader("Additional Properties")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Embodied carbon
+            embodied_carbon = st.number_input(
+                "Embodied Carbon (kg CO₂e/m²)",
+                min_value=0.0,
+                max_value=5000.0,
+                value=float(st.session_state.fenestration_editor["embodied_carbon"]),
+                format="%.1f",
+                help="Embodied carbon in kg CO₂e per square meter."
+            )
+        
+        with col2:
+            # Cost
+            cost = st.number_input(
+                "Cost (USD/m²)",
+                min_value=0.0,
+                max_value=5000.0,
+                value=float(st.session_state.fenestration_editor["cost"]),
+                format="%.1f",
+                help="Fenestration cost in USD per square meter."
+            )
+        
+        # Form submission buttons
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            submit_button = st.form_submit_button("Save Fenestration")
+        
+        with col2:
+            clear_button = st.form_submit_button("Clear Form")
+    
+    # Handle form submission
+    if submit_button:
+        # Validate inputs
+        validation_errors = validate_fenestration(
+            name, fenestration_type, u_value, shgc, visible_transmittance, thickness,
+            embodied_carbon, cost, st.session_state.fenestration_editor["edit_mode"],
+            st.session_state.fenestration_editor["original_name"]
+        )
+        
+        if validation_errors:
+            # Display validation errors
+            for error in validation_errors:
+                st.error(error)
+        else:
+            # Create fenestration data
+            fenestration_data = {
+                "type": fenestration_type,
+                "u_value": u_value,
+                "shgc": shgc,
+                "visible_transmittance": visible_transmittance,
+                "thickness": thickness,
+                "embodied_carbon": embodied_carbon,
+                "cost": cost
+            }
+            
+            # Handle edit mode
+            if st.session_state.fenestration_editor["edit_mode"]:
+                original_name = st.session_state.fenestration_editor["original_name"]
+                
+                # If name changed, delete old entry and create new one
+                if original_name != name:
+                    del st.session_state.project_data["fenestrations"]["project"][original_name]
+                
+                # Update fenestration
+                st.session_state.project_data["fenestrations"]["project"][name] = fenestration_data
+                st.success(f"Fenestration '{name}' updated successfully.")
+                logger.info(f"Updated fenestration '{name}' in project")
+            else:
+                # Add new fenestration
+                st.session_state.project_data["fenestrations"]["project"][name] = fenestration_data
+                st.success(f"Fenestration '{name}' added to your project.")
+                logger.info(f"Added new fenestration '{name}' to project")
+            
+            # Reset editor
+            reset_fenestration_editor()
+    
+    # Handle clear button
+    if clear_button:
+        reset_fenestration_editor()
+        st.rerun()
+
+def validate_material(
+    name: str, category: str, thermal_conductivity: float, density: float,
+    specific_heat: float, thickness_range: Tuple[float, float], default_thickness: float,
+    embodied_carbon: float, cost: float, edit_mode: bool, original_name: str
+) -> List[str]:
+    """
+    Validate material inputs.
+    
+    Args:
+        name: Material name
+        category: Material category
+        thermal_conductivity: Thermal conductivity in W/m·K
+        density: Density in kg/m³
+        specific_heat: Specific heat in J/kg·K
+        thickness_range: Tuple of (min_thickness, max_thickness) in meters
+        default_thickness: Default thickness in meters
+        embodied_carbon: Embodied carbon in kg CO₂e/m³
+        cost: Cost in USD/m³
+        edit_mode: Whether in edit mode
+        original_name: Original name if in edit mode
+        
+    Returns:
+        List of validation error messages, empty if all inputs are valid
+    """
+    errors = []
+    
+    # Validate name
+    if not name or name.strip() == "":
+        errors.append("Material name is required.")
+    
+    # Check for name uniqueness if not in edit mode or if name changed
+    if not edit_mode or (edit_mode and name != original_name):
+        if name in st.session_state.project_data["materials"]["project"]:
+            errors.append(f"Material name '{name}' already exists in your project.")
+    
+    # Validate category
+    if category not in MATERIAL_CATEGORIES:
+        errors.append("Please select a valid material category.")
+    
+    # Validate thermal conductivity
+    if thermal_conductivity <= 0:
+        errors.append("Thermal conductivity must be greater than zero.")
+    
+    # Validate density
+    if density <= 0:
+        errors.append("Density must be greater than zero.")
+    
+    # Validate specific heat
+    if specific_heat <= 0:
+        errors.append("Specific heat must be greater than zero.")
+    
+    # Validate thickness range
+    if thickness_range[0] <= 0:
+        errors.append("Minimum thickness must be greater than zero.")
+    if thickness_range[0] >= thickness_range[1]:
+        errors.append("Maximum thickness must be greater than minimum thickness.")
+    
+    # Validate default thickness
+    if default_thickness < thickness_range[0] or default_thickness > thickness_range[1]:
+        errors.append("Default thickness must be within the thickness range.")
+    
+    # Validate embodied carbon
+    if embodied_carbon < 0:
+        errors.append("Embodied carbon cannot be negative.")
+    
+    # Validate cost
+    if cost < 0:
+        errors.append("Cost cannot be negative.")
+    
+    return errors
+
+def validate_fenestration(
+    name: str, fenestration_type: str, u_value: float, shgc: float,
+    visible_transmittance: float, thickness: float, embodied_carbon: float,
+    cost: float, edit_mode: bool, original_name: str
+) -> List[str]:
+    """
+    Validate fenestration inputs.
+    
+    Args:
+        name: Fenestration name
+        fenestration_type: Fenestration type
+        u_value: U-value in W/m²·K
+        shgc: Solar Heat Gain Coefficient (0-1)
+        visible_transmittance: Visible Transmittance (0-1)
+        thickness: Thickness in meters
+        embodied_carbon: Embodied carbon in kg CO₂e/m²
+        cost: Cost in USD/m²
+        edit_mode: Whether in edit mode
+        original_name: Original name if in edit mode
+        
+    Returns:
+        List of validation error messages, empty if all inputs are valid
+    """
+    errors = []
+    
+    # Validate name
+    if not name or name.strip() == "":
+        errors.append("Fenestration name is required.")
+    
+    # Check for name uniqueness if not in edit mode or if name changed
+    if not edit_mode or (edit_mode and name != original_name):
+        if name in st.session_state.project_data["fenestrations"]["project"]:
+            errors.append(f"Fenestration name '{name}' already exists in your project.")
+    
+    # Validate type
+    if fenestration_type not in FENESTRATION_TYPES:
+        errors.append("Please select a valid fenestration type.")
+    
+    # Validate u_value
+    if u_value <= 0:
+        errors.append("U-value must be greater than zero.")
+    
+    # Validate shgc
+    if shgc < 0 or shgc > 1:
+        errors.append("SHGC must be between 0 and 1.")
+    
+    # Validate visible transmittance
+    if visible_transmittance < 0 or visible_transmittance > 1:
+        errors.append("Visible transmittance must be between 0 and 1.")
+    
+    # Validate thickness
+    if thickness <= 0:
+        errors.append("Thickness must be greater than zero.")
+    
+    # Validate embodied carbon
+    if embodied_carbon < 0:
+        errors.append("Embodied carbon cannot be negative.")
+    
+    # Validate cost
+    if cost < 0:
+        errors.append("Cost cannot be negative.")
+    
+    return errors
+
+def reset_material_editor():
+    """Reset the material editor to default values."""
+    st.session_state.material_editor = {
+        "name": "",
+        "category": MATERIAL_CATEGORIES[0],
+        "thermal_conductivity": 0.5,
+        "density": 1000.0,
+        "specific_heat": 1000.0,
+        "thickness_range": [0.01, 0.2],
+        "default_thickness": 0.05,
+        "embodied_carbon": 100.0,
+        "cost": 100.0,
+        "edit_mode": False,
+        "original_name": ""
+    }
+
+def reset_fenestration_editor():
+    """Reset the fenestration editor to default values."""
+    st.session_state.fenestration_editor = {
+        "name": "",
+        "type": FENESTRATION_TYPES[0],
+        "u_value": 2.8,
+        "shgc": 0.7,
+        "visible_transmittance": 0.8,
+        "thickness": 0.024,
+        "embodied_carbon": 900.0,
+        "cost": 200.0,
+        "edit_mode": False,
+        "original_name": ""
+    }
+
+def check_material_in_use(material_name: str) -> bool:
+    """
+    Check if a material is in use in any constructions.
+    
+    Args:
+        material_name: Name of the material to check
+        
+    Returns:
+        True if the material is in use, False otherwise
+    """
+    # This is a placeholder function that will be implemented when constructions are added
+    # For now, we'll assume materials are not in use
+    return False
+
+def check_fenestration_in_use(fenestration_name: str) -> bool:
+    """
+    Check if a fenestration is in use in any components.
+    
+    Args:
+        fenestration_name: Name of the fenestration to check
+        
+    Returns:
+        True if the fenestration is in use, False otherwise
+    """
+    # This is a placeholder function that will be implemented when components are added
+    # For now, we'll assume fenestrations are not in use
+    return False
+
+def display_materials_help():
+    """Display help information for the material library page."""
+    st.markdown("""
+    ### Material Library Help
+    
+    This section allows you to manage building materials and fenestrations for your project.
+    
+    **Materials Tab:**
+    
+    * **Library Materials**: Pre-defined materials with standard thermal properties.
+    * **Project Materials**: Materials you've added to your project from the library or created custom.
+    * **Material Editor**: Create new materials or edit existing ones in your project.
+    
+    **Fenestrations Tab:**
+    
+    * **Library Fenestrations**: Pre-defined windows, doors, and skylights with standard thermal properties.
+    * **Project Fenestrations**: Fenestrations you've added to your project from the library or created custom.
+    * **Fenestration Editor**: Create new fenestrations or edit existing ones in your project.
+    
+    **Key Properties:**
+    
+    * **Thermal Conductivity (W/m·K)**: Rate of heat transfer through a material. Lower values indicate better insulation.
+    * **Density (kg/m³)**: Mass per unit volume.
+    * **Specific Heat (J/kg·K)**: Energy required to raise the temperature of 1 kg by 1 K. Higher values indicate better thermal mass.
+    * **U-Value (W/m²·K)**: Overall heat transfer coefficient for fenestrations. Lower values indicate better insulation.
+    * **SHGC**: Solar Heat Gain Coefficient (0-1). Fraction of incident solar radiation that enters through a fenestration.
+    * **Visible Transmittance**: Fraction of visible light that passes through a fenestration.
+    * **Embodied Carbon**: Carbon emissions associated with material production, measured in kg CO₂e per unit volume or area.
+    * **Cost**: Material cost in USD per unit volume or area.
+    
+    **Workflow:**
+    
+    1. Browse the library materials and fenestrations
+    2. Add items to your project or create custom ones
+    3. Edit properties as needed for your specific project
+    4. Continue to the Construction page to create assemblies using these materials
+    """)

app/renewable_energy.py

@@ -0,0 +1,626 @@
+"""
+HVAC Load Calculator - Renewable Energy Module
+
+This module handles the renewable energy system sizing and simulation, focusing on
+solar PV performance modeling, energy offset calculations, and zero energy building analysis.
+
+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 plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple, Union
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Constants
+MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]  # Non-leap year
+HOURS_IN_YEAR = 8760
+
+# Default PV system parameters
+DEFAULT_PV_SYSTEM = {
+    "system_capacity_kw": 5.0,  # kWp
+    "module_efficiency": 0.20,  # 20%
+    "inverter_efficiency": 0.96,  # 96%
+    "system_losses": 0.14,  # 14% (wiring, soiling, temperature, etc.)
+    "tilt_angle": 20.0,  # degrees
+    "azimuth_angle": 180.0,  # degrees (0=N, 180=S)
+    "cost_per_kw": 1500,  # $/kWp
+    "lifespan_years": 25,
+    "maintenance_cost_ratio": 0.01  # Annual maintenance as fraction of installation cost
+}
+
+def display_renewable_energy_page():
+    """
+    Display the renewable energy page.
+    This is the main function called by main.py when the Renewable Energy page is selected.
+    """
+    st.title("Renewable Energy Systems")
+    
+    # Display help information in an expandable section
+    with st.expander("Help & Information"):
+        display_renewable_energy_help()
+    
+    # Check if building energy has been calculated
+    if "building_energy" not in st.session_state.project_data or not st.session_state.project_data["building_energy"].get("results"):
+        st.warning("Please complete the Building Energy analysis before proceeding to Renewable Energy systems.")
+        
+        # Navigation buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Back to Building Energy", key="back_to_building_energy_re"):
+                st.session_state.current_page = "Building Energy"
+                st.rerun()
+        return
+    
+    # Initialize renewable energy data if not present
+    initialize_renewable_energy_data()
+    
+    # Create tabs for different aspects of renewable energy analysis
+    tabs = st.tabs(["Solar PV System", "Energy Offset & Net Zero"])
+    
+    with tabs[0]:
+        display_solar_pv_system_tab()
+    
+    with tabs[1]:
+        display_energy_offset_tab()
+    
+    # Navigation buttons
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Back to Building Energy", key="back_to_building_energy_re"):
+            st.session_state.current_page = "Building Energy"
+            st.rerun()
+    
+    with col2:
+        if st.button("Continue to Embodied Energy", key="continue_to_embodied_energy"):
+            st.session_state.current_page = "Embodied Energy"
+            st.rerun()
+
+def initialize_renewable_energy_data():
+    """Initialize renewable energy data in session state if not present."""
+    if "renewable_energy" not in st.session_state.project_data:
+        st.session_state.project_data["renewable_energy"] = {
+            "pv_system": DEFAULT_PV_SYSTEM.copy(),
+            "results": None
+        }
+
+def display_solar_pv_system_tab():
+    """
+    Display the Solar PV system configuration and analysis tab.
+    """
+    st.header("Solar Photovoltaic (PV) System")
+    
+    # Get current PV system data
+    pv_system = st.session_state.project_data["renewable_energy"]["pv_system"]
+    
+    # System parameters
+    st.subheader("PV System Parameters")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        system_capacity_kw = st.number_input(
+            "System Capacity (kWp)",
+            min_value=0.1,
+            max_value=1000.0,
+            value=float(pv_system["system_capacity_kw"]),
+            step=0.1,
+            format="%.1f",
+            help="Peak DC power output of the PV array."
+        )
+        
+        module_efficiency = st.number_input(
+            "Module Efficiency",
+            min_value=0.10,
+            max_value=0.30,
+            value=float(pv_system["module_efficiency"]),
+            step=0.01,
+            format="%.2f",
+            help="Efficiency of the PV modules (e.g., 0.20 for 20%)."
+        )
+        
+        tilt_angle = st.number_input(
+            "Tilt Angle (degrees)",
+            min_value=0.0,
+            max_value=90.0,
+            value=float(pv_system["tilt_angle"]),
+            step=1.0,
+            format="%.1f",
+            help="Angle of the PV panels relative to horizontal."
+        )
+    
+    with col2:
+        inverter_efficiency = st.number_input(
+            "Inverter Efficiency",
+            min_value=0.80,
+            max_value=0.99,
+            value=float(pv_system["inverter_efficiency"]),
+            step=0.01,
+            format="%.2f",
+            help="Efficiency of the PV inverter."
+        )
+        
+        system_losses = st.number_input(
+            "System Losses",
+            min_value=0.05,
+            max_value=0.30,
+            value=float(pv_system["system_losses"]),
+            step=0.01,
+            format="%.2f",
+            help="Overall system losses (wiring, soiling, temperature, etc.)."
+        )
+        
+        azimuth_angle = st.number_input(
+            "Azimuth Angle (degrees)",
+            min_value=0.0,
+            max_value=359.9,
+            value=float(pv_system["azimuth_angle"]),
+            step=1.0,
+            format="%.1f",
+            help="Orientation of the PV panels (0=North, 90=East, 180=South, 270=West)."
+        )
+    
+    # System cost parameters
+    st.subheader("PV System Cost Parameters")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        cost_per_kw = st.number_input(
+            "Installation Cost ($/kWp)",
+            min_value=500.0,
+            max_value=5000.0,
+            value=float(pv_system["cost_per_kw"]),
+            step=50.0,
+            format="%.0f",
+            help="Installation cost per kWp of PV system capacity."
+        )
+    
+    with col2:
+        lifespan_years = st.number_input(
+            "System Lifespan (years)",
+            min_value=10,
+            max_value=40,
+            value=int(pv_system["lifespan_years"]),
+            step=1,
+            help="Expected lifespan of the PV system in years."
+        )
+    
+    with col3:
+        maintenance_cost_ratio = st.number_input(
+            "Annual Maintenance Cost Ratio",
+            min_value=0.001,
+            max_value=0.05,
+            value=float(pv_system["maintenance_cost_ratio"]),
+            step=0.001,
+            format="%.3f",
+            help="Annual maintenance cost as a fraction of installation cost."
+        )
+    
+    # Update PV system data
+    pv_system.update({
+        "system_capacity_kw": system_capacity_kw,
+        "module_efficiency": module_efficiency,
+        "inverter_efficiency": inverter_efficiency,
+        "system_losses": system_losses,
+        "tilt_angle": tilt_angle,
+        "azimuth_angle": azimuth_angle,
+        "cost_per_kw": cost_per_kw,
+        "lifespan_years": lifespan_years,
+        "maintenance_cost_ratio": maintenance_cost_ratio
+    })
+    
+    # Calculate PV generation button
+    if st.button("Calculate PV Generation", key="calculate_pv_generation"):
+        try:
+            results = calculate_pv_generation()
+            st.session_state.project_data["renewable_energy"]["results"] = results
+            st.success("PV generation calculated successfully.")
+            logger.info("PV generation calculated.")
+            st.rerun()  # Refresh to show results
+        except Exception as e:
+            st.error(f"Error calculating PV generation: {e}")
+            logger.error(f"Error calculating PV generation: {e}", exc_info=True)
+            st.session_state.project_data["renewable_energy"]["results"] = None
+    
+    # Display PV generation results if available
+    results = st.session_state.project_data["renewable_energy"].get("results")
+    if results:
+        display_pv_generation_results(results)
+
+def display_pv_generation_results(results: Dict[str, Any]):
+    """Display the PV generation calculation results."""
+    st.subheader("PV Generation Summary")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Annual PV Generation",
+            f"{results['annual_pv_generation'] / 1000:.1f} MWh",
+            help="Total annual electricity generated by the PV system."
+        )
+    
+    with col2:
+        st.metric(
+            "Capacity Factor",
+            f"{results['capacity_factor'] * 100:.1f}%",
+            help="Ratio of actual energy generated to maximum possible generation."
+        )
+    
+    # Display monthly PV generation
+    st.subheader("Monthly PV Generation")
+    
+    # Create bar chart of monthly generation
+    monthly_data = {
+        "Month": MONTHS,
+        "PV Generation (kWh)": results["monthly_pv_generation"]
+    }
+    
+    monthly_df = pd.DataFrame(monthly_data)
+    
+    fig_monthly = px.bar(
+        monthly_df,
+        x="Month",
+        y="PV Generation (kWh)",
+        title="Monthly PV Generation"
+    )
+    st.plotly_chart(fig_monthly, use_container_width=True)
+    
+    # Display hourly PV generation profile for a typical day
+    st.subheader("Hourly PV Generation Profile")
+    
+    # Allow user to select month for hourly profile
+    selected_month = st.selectbox(
+        "Select Month for Hourly Profile",
+        MONTHS,
+        index=6,  # Default to July
+        key="pv_hourly_month_selector",
+        help="Select a month to view the typical daily PV generation profile."
+    )
+    
+    month_index = MONTHS.index(selected_month)
+    
+    # Get hourly data for the selected month
+    month_start_hour = sum(DAYS_IN_MONTH[:month_index]) * 24
+    month_hours = DAYS_IN_MONTH[month_index] * 24
+    
+    # Calculate average hourly profile for the month
+    hourly_profile = calculate_average_daily_profile(
+        results["hourly_pv_generation"][month_start_hour:month_start_hour + month_hours],
+        DAYS_IN_MONTH[month_index]
+    )
+    
+    # Create hourly profile chart
+    fig_hourly = px.line(
+        x=list(range(24)),
+        y=hourly_profile,
+        title=f"Average Daily PV Generation Profile for {selected_month}",
+        labels={"x": "Hour of Day", "y": "PV Generation (kWh)"}
+    )
+    st.plotly_chart(fig_hourly, use_container_width=True)
+
+def display_energy_offset_tab():
+    """Display the energy offset and net-zero analysis tab."""
+    st.header("Energy Offset & Net-Zero Analysis")
+    
+    # Check if PV results are available
+    pv_results = st.session_state.project_data["renewable_energy"].get("results")
+    if not pv_results:
+        st.info("Please calculate PV generation using the Solar PV System tab.")
+        return
+    
+    # Get building energy consumption data
+    building_energy_results = st.session_state.project_data["building_energy"]["results"]
+    
+    # Calculate energy offset
+    annual_consumption = building_energy_results["annual_total_energy"]
+    annual_generation = pv_results["annual_pv_generation"]
+    energy_offset_percentage = (annual_generation / annual_consumption) * 100 if annual_consumption > 0 else 0
+    
+    # Display offset summary
+    st.subheader("Energy Offset Summary")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric(
+            "Annual Energy Consumption",
+            f"{annual_consumption / 1000:.1f} MWh",
+            help="Total annual energy consumed by the building."
+        )
+    
+    with col2:
+        st.metric(
+            "Annual PV Generation",
+            f"{annual_generation / 1000:.1f} MWh",
+            help="Total annual electricity generated by the PV system."
+        )
+    
+    st.metric(
+        "Energy Offset Percentage",
+        f"{energy_offset_percentage:.1f}%",
+        help="Percentage of building energy consumption offset by PV generation."
+    )
+    
+    # Display net energy balance
+    st.subheader("Net Energy Balance")
+    
+    # Calculate hourly net energy
+    hourly_consumption = np.array(building_energy_results["hourly_total_energy"])
+    hourly_generation = np.array(pv_results["hourly_pv_generation"])
+    hourly_net_energy = hourly_generation - hourly_consumption  # Positive = export, Negative = import
+    
+    # Calculate monthly net energy
+    monthly_net_energy = calculate_monthly_totals(hourly_net_energy)
+    
+    # Create bar chart of monthly net energy
+    monthly_net_df = pd.DataFrame({
+        "Month": MONTHS,
+        "Net Energy (kWh)": monthly_net_energy
+    })
+    
+    fig_monthly_net = px.bar(
+        monthly_net_df,
+        x="Month",
+        y="Net Energy (kWh)",
+        title="Monthly Net Energy Balance (PV Generation - Consumption)",
+        color="Net Energy (kWh)",
+        color_continuous_scale=px.colors.diverging.RdBu
+    )
+    st.plotly_chart(fig_monthly_net, use_container_width=True)
+    
+    # Display net-zero analysis
+    st.subheader("Net-Zero Energy Analysis")
+    
+    if energy_offset_percentage >= 100:
+        st.success("Congratulations! This building achieves Net-Zero Energy based on annual generation vs. consumption.")
+    else:
+        st.warning("This building does not achieve Net-Zero Energy based on annual generation vs. consumption.")
+        
+        # Calculate additional PV capacity needed for net-zero
+        shortfall_kwh = annual_consumption - annual_generation
+        if shortfall_kwh > 0:
+            # Estimate additional capacity based on current system performance
+            current_capacity_kw = st.session_state.project_data["renewable_energy"]["pv_system"]["system_capacity_kw"]
+            kwh_per_kw = annual_generation / current_capacity_kw if current_capacity_kw > 0 else 0
+            additional_capacity_kw = shortfall_kwh / kwh_per_kw if kwh_per_kw > 0 else float("inf")
+            
+            st.info(f"Estimated additional PV capacity needed for Net-Zero: {additional_capacity_kw:.1f} kWp")
+    
+    # Display self-consumption and grid interaction
+    st.subheader("Self-Consumption & Grid Interaction")
+    
+    # Calculate self-consumption and grid export/import
+    hourly_self_consumption = np.minimum(hourly_consumption, hourly_generation)
+    hourly_grid_export = np.maximum(0, hourly_generation - hourly_consumption)
+    hourly_grid_import = np.maximum(0, hourly_consumption - hourly_generation)
+    
+    # Calculate annual totals
+    annual_self_consumption = sum(hourly_self_consumption)
+    annual_grid_export = sum(hourly_grid_export)
+    annual_grid_import = sum(hourly_grid_import)
+    
+    # Calculate self-consumption rate and self-sufficiency rate
+    self_consumption_rate = (annual_self_consumption / annual_generation) * 100 if annual_generation > 0 else 0
+    self_sufficiency_rate = (annual_self_consumption / annual_consumption) * 100 if annual_consumption > 0 else 0
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric("Self-Consumption Rate", f"{self_consumption_rate:.1f}%", help="Percentage of PV generation consumed on-site.")
+    with col2:
+        st.metric("Self-Sufficiency Rate", f"{self_sufficiency_rate:.1f}%", help="Percentage of building energy demand met by on-site PV.")
+    
+    # Create pie chart of energy flows
+    energy_flows = {
+        "Self-Consumed PV": annual_self_consumption,
+        "Exported to Grid": annual_grid_export,
+        "Imported from Grid": annual_grid_import
+    }
+    
+    fig_flows = px.pie(
+        values=list(energy_flows.values()),
+        names=list(energy_flows.keys()),
+        title="Annual Energy Flows"
+    )
+    st.plotly_chart(fig_flows, use_container_width=True)
+
+def calculate_pv_generation() -> Dict[str, Any]:
+    """
+    Calculate PV system energy generation.
+    
+    Returns:
+        Dictionary containing PV generation results.
+    """
+    logger.info("Starting PV generation calculations...")
+    
+    # Get required data
+    climate_data = st.session_state.project_data["climate_data"]
+    pv_system = st.session_state.project_data["renewable_energy"]["pv_system"]
+    
+    # Get hourly solar radiation data
+    hourly_weather = pd.DataFrame(climate_data["hourly_data"])
+    hourly_solar_angles = pd.DataFrame(climate_data["solar_angles"]) # Assuming this is stored from HVAC loads
+    
+    # Combine weather and solar angles
+    hourly_data = pd.concat([hourly_weather, hourly_solar_angles], axis=1)
+    
+    # Get PV system parameters
+    capacity_kw = pv_system["system_capacity_kw"]
+    module_efficiency = pv_system["module_efficiency"]
+    inverter_efficiency = pv_system["inverter_efficiency"]
+    system_losses = pv_system["system_losses"]
+    tilt_angle = pv_system["tilt_angle"]
+    azimuth_angle = pv_system["azimuth_angle"]
+    
+    # Calculate incident solar radiation on PV panels (W/m²)
+    # Using the same function from hvac_loads.py (ensure it is accessible or duplicated)
+    incident_solar_pv = calculate_incident_solar_on_surface(
+        hourly_data["Direct Normal Radiation"],
+        hourly_data["Diffuse Horizontal Radiation"],
+        hourly_data["solar_altitude"],
+        hourly_data["solar_azimuth"],
+        tilt_angle,
+        azimuth_angle
+    )
+    
+    # Calculate PV array area (m²)
+    # Assuming standard test conditions (STC) irradiance of 1000 W/m²
+    array_area = (capacity_kw * 1000) / (1000 * module_efficiency)
+    
+    # Calculate DC power output from PV array (W)
+    dc_power = incident_solar_pv * array_area * module_efficiency
+    
+    # Calculate AC power output after inverter and system losses (W)
+    ac_power = dc_power * inverter_efficiency * (1 - system_losses)
+    
+    # Ensure AC power does not exceed system capacity (kW -> W)
+    ac_power = np.minimum(ac_power, capacity_kw * 1000)
+    
+    # Convert hourly AC power from W to kWh
+    hourly_pv_generation = ac_power / 1000
+    
+    # Calculate monthly PV generation
+    monthly_pv_generation = calculate_monthly_totals(hourly_pv_generation)
+    
+    # Calculate annual PV generation
+    annual_pv_generation = sum(monthly_pv_generation)
+    
+    # Calculate capacity factor
+    max_possible_generation = capacity_kw * HOURS_IN_YEAR
+    capacity_factor = annual_pv_generation / max_possible_generation if max_possible_generation > 0 else 0
+    
+    # Compile results
+    results = {
+        "hourly_pv_generation": hourly_pv_generation.tolist(),
+        "monthly_pv_generation": monthly_pv_generation,
+        "annual_pv_generation": annual_pv_generation,
+        "capacity_factor": capacity_factor,
+        "calculation_timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    logger.info("PV generation calculations completed.")
+    return results
+
+# Helper function (can be moved to a utility module later)
+def calculate_incident_solar_on_surface(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.
+    (Copied from hvac_loads.py for now, consider refactoring to a shared utility)
+    """
+    # 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) # Radiation only incident if cos_theta > 0
+    
+    # Direct radiation component on tilted surface
+    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 (simplified)
+    albedo = 0.2 # Typical ground reflectance
+    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
+
+# Helper function (can be moved to a utility module later)
+def calculate_average_daily_profile(hourly_data: List[float], days: int) -> List[float]:
+    """
+    Calculate average daily profile from hourly data for a month.
+    (Copied from building_energy.py for now, consider refactoring to a shared utility)
+    """
+    daily_profile = [0.0] * 24
+    hourly_data_np = np.array(hourly_data)
+    
+    for hour in range(len(hourly_data_np)):
+        hour_of_day = hour % 24
+        daily_profile[hour_of_day] += hourly_data_np[hour]
+    
+    # Calculate averages
+    for i in range(24):
+        daily_profile[i] /= days
+    
+    return daily_profile
+
+# Helper function (can be moved to a utility module later)
+def calculate_monthly_totals(hourly_data: np.ndarray) -> List[float]:
+    """
+    Calculate monthly totals from hourly data.
+    (Copied from building_energy.py for now, consider refactoring to a shared utility)
+    """
+    monthly_totals = []
+    hour_index = 0
+    
+    for days_in_month_count in DAYS_IN_MONTH:
+        hours_in_month = days_in_month_count * 24
+        month_total = sum(hourly_data[hour_index:hour_index + hours_in_month])
+        monthly_totals.append(month_total)
+        hour_index += hours_in_month
+    
+    return monthly_totals
+
+def display_renewable_energy_help():
+    """
+    Display help information for the renewable energy page.
+    """
+    st.markdown("""
+    ### Renewable Energy Systems Help
+    
+    This section allows you to model renewable energy systems, primarily Solar Photovoltaics (PV), and analyze their impact on the building\s energy balance.
+    
+    **Key Concepts:**
+    
+    * **Solar PV System**: Converts sunlight into electricity.
+    * **System Capacity (kWp)**: Peak power output of the PV array under standard test conditions.
+    * **Module Efficiency**: Percentage of sunlight converted to DC electricity by the PV modules.
+    * **Inverter Efficiency**: Percentage of DC power converted to AC power by the inverter.
+    * **System Losses**: Reductions in PV output due to factors like wiring, soiling, temperature, and shading.
+    * **Tilt & Azimuth Angles**: Orientation of the PV panels, affecting solar energy capture.
+    * **Energy Offset**: Percentage of the building\s energy consumption met by on-site renewable generation.
+    * **Net-Zero Energy**: A building that produces as much energy as it consumes over a year.
+    * **Self-Consumption**: Portion of PV-generated electricity used directly by the building.
+    * **Grid Interaction**: Exchange of electricity with the utility grid (import and export).
+    
+    **Workflow:**
+    
+    1. **Solar PV System Tab**:
+        * Configure the parameters of your PV system (capacity, efficiency, orientation, costs).
+        * Click "Calculate PV Generation" to simulate the system\s output based on climate data.
+        * Review the PV generation summary, monthly profiles, and typical daily output.
+    
+    2. **Energy Offset & Net Zero Tab**:
+        * Analyze how the PV generation offsets the building\s energy consumption (calculated in the Building Energy section).
+        * View the net energy balance (generation vs. consumption) on a monthly basis.
+        * Assess if the building achieves Net-Zero Energy status.
+        * Examine self-consumption rates and grid interaction patterns.
+    
+    **Important:**
+    
+    * Accurate climate data (especially solar radiation) is crucial for PV modeling.
+    * System losses can significantly impact actual PV generation.
+    * Net-Zero calculations here are based on annual energy balance; consider hourly dynamics for more detailed analysis.
+    * This module focuses on PV; other renewable technologies may require different modeling approaches.
+    """)