Upload 4 files

data/calculation.py

@@ -1,40 +1,295 @@
-import altair as alt
+"""
+HVAC Calculator Code Documentation
+
+Developed by: Dr Majed Abuseif, Deakin University
+© 2025
+"""
+
 import numpy as np
 import pandas as pd
-import streamlit as st
+from typing import Dict, List, Optional, NamedTuple
+from enum import Enum
+from data.material_library import Construction, GlazingMaterial, DoorMaterial
+from data.internal_loads import PEOPLE_ACTIVITY_LEVELS, DIVERSITY_FACTORS, LIGHTING_FIXTURE_TYPES, EQUIPMENT_HEAT_GAINS, VENTILATION_RATES, INFILTRATION_SETTINGS
+from datetime import datetime
+from collections import defaultdict
+import logging
+from utils.ctf_calculations import CTFCalculator, ComponentType, CTFCoefficients
 
-"""
-# Welcome to Streamlit!
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+class TFMCalculations:
+    @staticmethod
+    def calculate_conduction_load(component, outdoor_temp: float, indoor_temp: float, hour: int, mode: str = "none") -> tuple[float, float]:
+        """Calculate conduction load for heating and cooling in kW based on mode."""
+        if mode == "none":
+            return 0, 0
+        delta_t = outdoor_temp - indoor_temp
+        if mode == "cooling" and delta_t <= 0:
+            return 0, 0
+        if mode == "heating" and delta_t >= 0:
+            return 0, 0
 
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
+        # Get CTF coefficients using CTFCalculator
+        ctf = CTFCalculator.calculate_ctf_coefficients(component)
+        
+        # Initialize history terms (simplified: assume steady-state history for demonstration)
+        # In practice, maintain temperature and flux histories
+        load = component.u_value * component.area * delta_t
+        for i in range(len(ctf.Y)):
+            load += component.area * ctf.Y[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
+            load -= component.area * ctf.Z[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
+            # Note: F terms require flux history, omitted here for simplicity
+        cooling_load = load / 1000 if mode == "cooling" else 0
+        heating_load = -load / 1000 if mode == "heating" else 0
+        return cooling_load, heating_load
+
+    @staticmethod
+    def calculate_solar_load(component, hourly_data: Dict, hour: int, building_orientation: float, mode: str = "none") -> float:
+        """Calculate solar load in kW (cooling only) based on mode."""
+        if mode != "cooling" or component.component_type not in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
+            return 0
+        solar_radiation = hourly_data.get("global_horizontal_radiation", 800)
+        shgc = component.shgc or 0.7
+        absolute_angle = (building_orientation + component.orientation_angle) % 360
+        solar_incidence = np.cos(np.radians(absolute_angle - hour % 24 * 15))
+        return component.area * shgc * solar_radiation * max(solar_incidence, 0) * 0.8 / 1000
+
+    @staticmethod
+    def calculate_internal_load(internal_loads: Dict, hour: int, operation_hours: int, area: float) -> float:
+        """Calculate total internal load in kW."""
+        total_load = 0
+        for group in internal_loads.get("people", []):
+            activity_data = group["activity_data"]
+            sensible = (activity_data["sensible_min_w"] + activity_data["sensible_max_w"]) / 2
+            latent = (activity_data["latent_min_w"] + activity_data["latent_max_w"]) / 2
+            load_per_person = sensible + latent
+            total_load += group["num_people"] * load_per_person * group["diversity_factor"]
+        for light in internal_loads.get("lighting", []):
+            lpd = light["lpd"]
+            lighting_operating_hours = light["operating_hours"]
+            fraction = min(lighting_operating_hours, operation_hours) / operation_hours if operation_hours > 0 else 0
+            lighting_load = lpd * area * fraction
+            total_load += lighting_load
+        equipment = internal_loads.get("equipment")
+        if equipment:
+            total_power_density = equipment.get("total_power_density", 0)
+            equipment_load = total_power_density * area
+            total_load += equipment_load
+        return total_load / 1000
+
+    @staticmethod
+    def calculate_ventilation_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> tuple[float, float]:
+        """Calculate ventilation load for heating and cooling in kW based on mode."""
+        if mode == "none":
+            return 0, 0
+        ventilation = internal_loads.get("ventilation")
+        if not ventilation:
+            return 0, 0
+        space_rate = ventilation.get("space_rate", 0.3)  # L/s/m²
+        people_rate = ventilation.get("people_rate", 2.5)  # L/s/person
+        num_people = sum(group["num_people"] for group in internal_loads.get("people", []))
+        ventilation_flow = (space_rate * area + people_rate * num_people) / 1000  # m³/s
+        air_density = 1.2  # kg/m³
+        specific_heat = 1000  # J/kg·K
+        delta_t = outdoor_temp - indoor_temp
+        if mode == "cooling" and delta_t <= 0:
+            return 0, 0
+        if mode == "heating" and delta_t >= 0:
+            return 0, 0
+        load = ventilation_flow * air_density * specific_heat * delta_t / 1000  # kW
+        cooling_load = load if mode == "cooling" else 0
+        heating_load = -load if mode == "heating" else 0
+        return cooling_load, heating_load
+
+    @staticmethod
+    def calculate_infiltration_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> tuple[float, float]:
+        """Calculate infiltration load for heating and cooling in kW based on mode."""
+        if mode == "none":
+            return 0, 0
+        infiltration = internal_loads.get("infiltration")
+        if not infiltration:
+            return 0, 0
+        method = infiltration.get("method", "ACH")
+        settings = infiltration.get("settings", {})
+        building_height = building_info.get("building_height", 3.0)
+        volume = area * building_height  # m³
+        air_density = 1.2  # kg/m³
+        specific_heat = 1000  # J/kg·K
+        delta_t = outdoor_temp - indoor_temp
+        if mode == "cooling" and delta_t <= 0:
+            return 0, 0
+        if mode == "heating" and delta_t >= 0:
+            return 0, 0
+        if method == "ACH":
+            ach = settings.get("rate", 0.5)
+            infiltration_flow = ach * volume / 3600  # m³/s
+        elif method == "Crack Flow":
+            ela = settings.get("ela", 0.0001)  # m²/m²
+            wind_speed = 4.0  # m/s (assumed)
+            infiltration_flow = ela * area * wind_speed / 2  # m³/s
+        else:  # Empirical Equations
+            c = settings.get("c", 0.1)
+            n = settings.get("n", 0.65)
+            delta_t_abs = abs(delta_t)
+            infiltration_flow = c * (delta_t_abs ** n) * area / 3600  # m³/s
+        load = infiltration_flow * air_density * specific_heat * delta_t / 1000  # kW
+        cooling_load = load if mode == "cooling" else 0
+        heating_load = -load if mode == "heating" else 0
+        return cooling_load, heating_load
+
+    @staticmethod
+    def get_adaptive_comfort_temp(outdoor_temp: float) -> float:
+        """Calculate adaptive comfort temperature per ASHRAE 55."""
+        if 10 <= outdoor_temp <= 33.5:
+            return 0.31 * outdoor_temp + 17.8
+        return 24.0  # Default to standard setpoint if outside range
+
+    @staticmethod
+    def filter_hourly_data(hourly_data: List[Dict], sim_period: Dict, climate_data: Dict) -> List[Dict]:
+        """Filter hourly data based on simulation period, ignoring year."""
+        if sim_period["type"] == "Full Year":
+            return hourly_data
+        filtered_data = []
+        if sim_period["type"] == "From-to":
+            start_month = sim_period["start_date"].month
+            start_day = sim_period["start_date"].day
+            end_month = sim_period["end_date"].month
+            end_day = sim_period["end_date"].day
+            for data in hourly_data:
+                month, day = data["month"], data["day"]
+                if (month > start_month or (month == start_month and day >= start_day)) and \
+                   (month < end_month or (month == end_month and day <= end_day)):
+                    filtered_data.append(data)
+        elif sim_period["type"] in ["HDD", "CDD"]:
+            base_temp = sim_period.get("base_temp", 18.3 if sim_period["type"] == "HDD" else 23.9)
+            for data in hourly_data:
+                temp = data["dry_bulb"]
+                if (sim_period["type"] == "HDD" and temp < base_temp) or (sim_period["type"] == "CDD" and temp > base_temp):
+                    filtered_data.append(data)
+        return filtered_data
+
+    @staticmethod
+    def get_indoor_conditions(indoor_conditions: Dict, hour: int, outdoor_temp: float) -> Dict:
+        """Determine indoor conditions based on user settings."""
+        if indoor_conditions["type"] == "Fixed":
+            mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
+            if mode == "cooling":
+                return {
+                    "temperature": indoor_conditions.get("cooling_setpoint", {}).get("temperature", 24.0),
+                    "rh": indoor_conditions.get("cooling_setpoint", {}).get("rh", 50.0)
+                }
+            elif mode == "heating":
+                return {
+                    "temperature": indoor_conditions.get("heating_setpoint", {}).get("temperature", 22.0),
+                    "rh": indoor_conditions.get("heating_setpoint", {}).get("rh", 50.0)
+                }
+            else:
+                return {"temperature": 24.0, "rh": 50.0}
+        elif indoor_conditions["type"] == "Time-varying":
+            schedule = indoor_conditions.get("schedule", [])
+            if schedule:
+                hour_idx = hour % 24
+                for entry in schedule:
+                    if entry["hour"] == hour_idx:
+                        return {"temperature": entry["temperature"], "rh": entry["rh"]}
+            return {"temperature": 24.0, "rh": 50.0}
+        else:  # Adaptive
+            return {"temperature": TFMCalculations.get_adaptive_comfort_temp(outdoor_temp), "rh": 50.0}
+
+    @staticmethod
+    def calculate_tfm_loads(components: Dict, hourly_data: List[Dict], indoor_conditions: Dict, internal_loads: Dict, building_info: Dict, sim_period: Dict, hvac_settings: Dict) -> List[Dict]:
+        """Calculate TFM loads for heating and cooling with user-defined filters and temperature threshold."""
+        filtered_data = TFMCalculations.filter_hourly_data(hourly_data, sim_period, building_info)
+        temp_loads = []
+        building_orientation = building_info.get("orientation_angle", 0.0)
+        operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
+        area = building_info.get("floor_area", 100.0)
+        
+        # Pre-calculate CTF coefficients for all components using CTFCalculator
+        for comp_list in components.values():
+            for comp in comp_list:
+                comp.ctf = CTFCalculator.calculate_ctf_coefficients(comp)
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+        for hour_data in filtered_data:
+            hour = hour_data["hour"]
+            outdoor_temp = hour_data["dry_bulb"]
+            indoor_cond = TFMCalculations.get_indoor_conditions(indoor_conditions, hour, outdoor_temp)
+            indoor_temp = indoor_cond["temperature"]
+            # Initialize all loads to 0
+            conduction_cooling = conduction_heating = solar = internal = ventilation_cooling = ventilation_heating = infiltration_cooling = infiltration_heating = 0
+            # Check if hour is within operating periods
+            is_operating = False
+            for period in operating_periods:
+                start_hour = period.get("start", 8)
+                end_hour = period.get("end", 18)
+                if start_hour <= hour % 24 <= end_hour:
+                    is_operating = True
+                    break
+            # Determine mode based on temperature threshold (18°C)
+            mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
+            if is_operating and mode == "cooling":
+                for comp_list in components.values():
+                    for comp in comp_list:
+                        cool_load, _ = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="cooling")
+                        conduction_cooling += cool_load
+                        solar += TFMCalculations.calculate_solar_load(comp, hour_data, hour, building_orientation, mode="cooling")
+                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
+                ventilation_cooling, _ = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
+                infiltration_cooling, _ = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
+            elif is_operating and mode == "heating":
+                for comp_list in components.values():
+                    for comp in comp_list:
+                        _, heat_load = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="heating")
+                        conduction_heating += heat_load
+                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
+                _, ventilation_heating = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
+                _, infiltration_heating = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
+            else:  # mode == "none" or not is_operating
+                internal = 0  # No internal loads when no heating or cooling is needed or outside operating hours
+            # Calculate total loads, subtracting internal load for heating
+            total_cooling = conduction_cooling + solar + internal + ventilation_cooling + infiltration_cooling
+            total_heating = max(conduction_heating + ventilation_heating + infiltration_heating - internal, 0)
+            # Enforce mutual exclusivity within hour
+            if mode == "cooling":
+                total_heating = 0
+            elif mode == "heating":
+                total_cooling = 0
+            temp_loads.append({
+                "hour": hour,
+                "month": hour_data["month"],
+                "day": hour_data["day"],
+                "conduction_cooling": conduction_cooling,
+                "conduction_heating": conduction_heating,
+                "solar": solar,
+                "internal": internal,
+                "ventilation_cooling": ventilation_cooling,
+                "ventilation_heating": ventilation_heating,
+                "infiltration_cooling": infiltration_cooling,
+                "infiltration_heating": infiltration_heating,
+                "total_cooling": total_cooling,
+                "total_heating": total_heating
+            })
+        # Group loads by day and apply daily control
+        loads_by_day = defaultdict(list)
+        for load in temp_loads:
+            day_key = (load["month"], load["day"])
+            loads_by_day[day_key].append(load)
+        final_loads = []
+        for day_key, day_loads in loads_by_day.items():
+            # Count hours with non-zero cooling and heating loads
+            cooling_hours = sum(1 for load in day_loads if load["total_cooling"] > 0)
+            heating_hours = sum(1 for load in day_loads if load["total_heating"] > 0)
+            # Apply daily control
+            for load in day_loads:
+                if cooling_hours > heating_hours:
+                    load["total_heating"] = 0  # Keep cooling components, zero heating total
+                elif heating_hours > cooling_hours:
+                    load["total_cooling"] = 0  # Keep heating components, zero cooling total
+                else:  # Equal hours
+                    load["total_cooling"] = 0
+                    load["total_heating"] = 0  # Zero both totals, keep components
+                final_loads.append(load)
+        return final_loads

data/climate_data.py

@@ -0,0 +1,859 @@
+"""
+Extracts climate data from EPW files
+Includes Solar Analysis tab for solar angle and ground-reflected radiation calculations.
+
+Author: Dr Majed Abuseif
+Date: May 2025
+Version: 2.1.6
+"""
+
+from typing import Dict, List, Any, Optional
+import pandas as pd
+import numpy as np
+import os
+import json
+from dataclasses import dataclass
+import streamlit as st
+import plotly.graph_objects as go
+from io import StringIO
+import pvlib
+from datetime import datetime, timedelta
+import re
+import logging
+from data.solar_calculations import SolarCalculations  
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# CSS for consistent formatting
+STYLE = """
+<style>
+.markdown-text {
+    font-family: Roboto, sans-serif;
+    font-size: 14px;
+    line-height: 1.5;
+    margin-bottom: 20px;
+}
+.markdown-text h3 {
+    font-size: 18px;
+    font-weight: bold;
+    margin-top: 20px;
+    margin-bottom: 10px;
+}
+.markdown-text ul {
+    list-style-type: disc;
+    padding-left: 20px;
+    margin: 0;
+}
+.markdown-text li {
+    margin-bottom: 8px;
+}
+.markdown-text strong {
+    font-weight: bold;
+}
+.two-column {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 20px;
+}
+.column {
+    width: 100%;
+}
+</style>
+"""
+
+@dataclass
+class ClimateLocation:
+    """Class representing a climate location with ASHRAE 169 data derived from EPW files."""
+    
+    id: str
+    country: str
+    state_province: str
+    city: str
+    latitude: float
+    longitude: float
+    elevation: float  # meters
+    timezone: float  # hours from UTC
+    climate_zone: str
+    heating_degree_days: float  # base 18°C
+    cooling_degree_days: float  # base 18°C
+    winter_design_temp: float  # 99.6% heating design temperature (°C)
+    summer_design_temp_db: float  # 0.4% cooling design dry-bulb temperature (°C)
+    summer_design_temp_wb: float  # 0.4% cooling design wet-bulb temperature (°C)
+    summer_daily_range: float  # Mean daily temperature range in summer (°C)
+    wind_speed: float  # Mean wind speed (m/s)
+    pressure: float  # Mean atmospheric pressure (Pa)
+    hourly_data: List[Dict]  # Hourly data for integration with main.py
+    typical_extreme_periods: Dict[str, Dict]  # Typical/extreme periods (summer/winter)
+    ground_temperatures: Dict[str, List[float]]  # Monthly ground temperatures by depth
+    solar_calculations: List[Dict] = None  # Solar calculation results
+    
+    def __init__(self, epw_file: pd.DataFrame, typical_extreme_periods: Dict, ground_temperatures: Dict, **kwargs):
+        """Initialize ClimateLocation with EPW file data and header information."""
+        self.id = kwargs.get("id")
+        self.country = kwargs.get("country")
+        self.state_province = kwargs.get("state_province", "N/A")
+        self.city = kwargs.get("city")
+        self.latitude = kwargs.get("latitude")
+        self.longitude = kwargs.get("longitude")
+        self.elevation = kwargs.get("elevation")
+        self.timezone = kwargs.get("timezone")
+        self.typical_extreme_periods = typical_extreme_periods
+        self.ground_temperatures = ground_temperatures
+        self.solar_calculations = kwargs.get("solar_calculations", [])
+        
+        # Extract columns from EPW data
+        months = pd.to_numeric(epw_file[1], errors='coerce').values
+        days = pd.to_numeric(epw_file[2], errors='coerce').values
+        hours = pd.to_numeric(epw_file[3], errors='coerce').values
+        dry_bulb = pd.to_numeric(epw_file[6], errors='coerce').values
+        humidity = pd.to_numeric(epw_file[8], errors='coerce').values
+        pressure = pd.to_numeric(epw_file[9], errors='coerce').values
+        global_radiation = pd.to_numeric(epw_file[13], errors='coerce').values
+        direct_normal_radiation = pd.to_numeric(epw_file[14], errors='coerce').values
+        diffuse_horizontal_radiation = pd.to_numeric(epw_file[15], errors='coerce').values
+        wind_direction = pd.to_numeric(epw_file[20], errors='coerce').values
+        wind_speed = pd.to_numeric(epw_file[21], errors='coerce')
+        
+        # Filter wind speed outliers and log high values
+        wind_speed = wind_speed[wind_speed <= 50]  # Remove extreme outliers
+        if (wind_speed > 15).any():
+            logger.warning(f"High wind speeds detected: {wind_speed[wind_speed > 15].tolist()}")
+        
+        # Calculate wet-bulb temperature
+        wet_bulb = ClimateData.calculate_wet_bulb(dry_bulb, humidity)
+        
+        # Calculate design conditions
+        self.winter_design_temp = round(np.nanpercentile(dry_bulb, 0.4), 1)
+        self.summer_design_temp_db = round(np.nanpercentile(dry_bulb, 99.6), 1)
+        self.summer_design_temp_wb = round(np.nanpercentile(wet_bulb, 99.6), 1)
+        
+        # Calculate degree days using (T_max + T_min)/2
+        daily_temps = dry_bulb.reshape(-1, 24)
+        daily_max = np.nanmax(daily_temps, axis=1)
+        daily_min = np.nanmin(daily_temps, axis=1)
+        daily_avg = (daily_max + daily_min) / 2
+        self.heating_degree_days = round(np.nansum(np.where(daily_avg < 18, 18 - daily_avg, 0)))
+        self.cooling_degree_days = round(np.nansum(np.where(daily_avg > 18, daily_avg - 18, 0)))
+        
+        # Calculate summer daily temperature range (June–August, Southern Hemisphere)
+        summer_mask = (months >= 6) & (months <= 8)
+        summer_temps = dry_bulb[summer_mask].reshape(-1, 24)
+        self.summer_daily_range = round(np.nanmean(np.nanmax(summer_temps, axis=1) - np.nanmin(summer_temps, axis=1)), 1)
+        
+        # Calculate mean wind speed and pressure
+        self.wind_speed = round(np.nanmean(wind_speed), 1)
+        self.pressure = round(np.nanmean(pressure), 1)
+        
+        # Log wind speed diagnostics
+        logger.info(f"Wind speed stats: min={wind_speed.min():.1f}, max={wind_speed.max():.1f}, mean={self.wind_speed:.1f}")
+        
+        # Assign climate zone
+        self.climate_zone = ClimateData.assign_climate_zone(self.heating_degree_days, self.cooling_degree_days, np.nanmean(humidity))
+        
+        # Store hourly data with enhanced fields
+        self.hourly_data = []
+        for i in range(len(months)):
+            if np.isnan(months[i]) or np.isnan(days[i]) or np.isnan(hours[i]) or np.isnan(dry_bulb[i]):
+                continue  # Skip records with missing critical fields
+            record = {
+                "month": int(months[i]),
+                "day": int(days[i]),
+                "hour": int(hours[i]),
+                "dry_bulb": float(dry_bulb[i]),
+                "relative_humidity": float(humidity[i]) if not np.isnan(humidity[i]) else 0.0,
+                "atmospheric_pressure": float(pressure[i]) if not np.isnan(pressure[i]) else self.pressure,
+                "global_horizontal_radiation": float(global_radiation[i]) if not np.isnan(global_radiation[i]) else 0.0,
+                "direct_normal_radiation": float(direct_normal_radiation[i]) if not np.isnan(direct_normal_radiation[i]) else 0.0,
+                "diffuse_horizontal_radiation": float(diffuse_horizontal_radiation[i]) if not np.isnan(diffuse_horizontal_radiation[i]) else 0.0,
+                "wind_speed": float(wind_speed[i]) if not np.isnan(wind_speed[i]) else 0.0,
+                "wind_direction": float(wind_direction[i]) if not np.isnan(wind_direction[i]) else 0.0
+            }
+            self.hourly_data.append(record)
+        
+        if len(self.hourly_data) != 8760:
+            st.warning(f"Hourly data has {len(self.hourly_data)} records instead of 8760. Some records may have been excluded due to missing data.")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the climate location to a dictionary."""
+        return {
+            "id": self.id,
+            "country": self.country,
+            "state_province": self.state_province,
+            "city": self.city,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "elevation": self.elevation,
+            "timezone": self.timezone,
+            "climate_zone": self.climate_zone,
+            "heating_degree_days": self.heating_degree_days,
+            "cooling_degree_days": self.cooling_degree_days,
+            "winter_design_temp": self.winter_design_temp,
+            "summer_design_temp_db": self.summer_design_temp_db,
+            "summer_design_temp_wb": self.summer_design_temp_wb,
+            "summer_daily_range": self.summer_daily_range,
+            "wind_speed": self.wind_speed,
+            "pressure": self.pressure,
+            "hourly_data": self.hourly_data,
+            "typical_extreme_periods": self.typical_extreme_periods,
+            "ground_temperatures": self.ground_temperatures,
+            "solar_calculations": self.solar_calculations
+        }
+
+class ClimateData:
+    """Class for managing ASHRAE 169 climate data from EPW files."""
+    
+    def __init__(self):
+        """Initialize climate data."""
+        self.locations = {}
+        self.countries = []
+        self.country_states = {}
+    
+    def add_location(self, location: ClimateLocation):
+        """Add a new location to the dictionary."""
+        self.locations[location.id] = location
+        self.countries = sorted(list(set(loc.country for loc in self.locations.values())))
+        self.country_states = self._group_locations_by_country_state()
+    
+    def _group_locations_by_country_state(self) -> Dict[str, Dict[str, List[str]]]:
+        """Group locations by country and state/province."""
+        result = {}
+        for loc in self.locations.values():
+            if loc.country not in result:
+                result[loc.country] = {}
+            if loc.state_province not in result[loc.country]:
+                result[loc.country][loc.state_province] = []
+            result[loc.country][loc.state_province].append(loc.city)
+        for country in result:
+            for state in result[country]:
+                result[country][state] = sorted(result[country][state])
+        return result
+    
+    def get_location_by_id(self, location_id: str, session_state: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Retrieve climate data by ID from session state or locations."""
+        if "climate_data" in session_state and session_state["climate_data"].get("id") == location_id:
+            return session_state["climate_data"]
+        if location_id in self.locations:
+            return self.locations[location_id].to_dict()
+        return None
+
+    @staticmethod
+    def validate_climate_data(data: Dict[str, Any]) -> bool:
+        """Validate climate data for required fields and ranges."""
+        required_fields = [
+            "id", "country", "city", "latitude", "longitude", "elevation", "timezone",
+            "climate_zone", "heating_degree_days", "cooling_degree_days",
+            "winter_design_temp", "summer_design_temp_db", "summer_design_temp_wb",
+            "summer_daily_range", "wind_speed", "pressure", "hourly_data"
+        ]
+        
+        for field in required_fields:
+            if field not in data:
+                st.error(f"Validation failed: Missing required field '{field}'")
+                return False
+        
+        if not (-90 <= data["latitude"] <= 90 and -180 <= data["longitude"] <= 180):
+            st.error("Validation failed: Invalid latitude or longitude")
+            return False
+        if data["elevation"] < 0:
+            st.error("Validation failed: Negative elevation")
+            return False
+        if not (-24 <= data["timezone"] <= 24):
+            st.error(f"Validation failed: Timezone {data['timezone']} outside range")
+            return False
+        if data["climate_zone"] not in ["0A", "0B", "1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"]:
+            st.error(f"Validation failed: Invalid climate zone '{data['climate_zone']}'")
+            return False
+        if not (data["heating_degree_days"] >= 0 and data["cooling_degree_days"] >= 0):
+            st.error("Validation failed: Negative degree days")
+            return False
+        if not (-50 <= data["winter_design_temp"] <= 20):
+            st.error(f"Validation failed: Winter design temp {data['winter_design_temp']} outside range")
+            return False
+        if not (0 <= data["summer_design_temp_db"] <= 50 and 0 <= data["summer_design_temp_wb"] <= 40):
+            st.error("Validation failed: Invalid summer design temperatures")
+            return False
+        if data["summer_daily_range"] < 0:
+            st.error("Validation failed: Negative summer daily range")
+            return False
+        if not (0 <= data["wind_speed"] <= 30):
+            st.error(f"Validation failed: Wind speed {data['wind_speed']} outside range")
+            return False
+        if not (80000 <= data["pressure"] <= 110000):
+            st.error(f"Validation failed: Pressure {data['pressure']} outside range")
+            return False
+        
+        if not data["hourly_data"] or len(data["hourly_data"]) < 8700:
+            st.error(f"Validation failed: Hourly data has {len(data['hourly_data'])} records, expected ~8760")
+            return False
+        for record in data["hourly_data"]:
+            if not (1 <= record["month"] <= 12):
+                st.error(f"Validation failed: Invalid month {record['month']}")
+                return False
+            if not (1 <= record["day"] <= 31):
+                st.error(f"Validation failed: Invalid day {record['day']}")
+                return False
+            if not (1 <= record["hour"] <= 24):
+                st.error(f"Validation failed: Invalid hour {record['hour']}")
+                return False
+            if not (-50 <= record["dry_bulb"] <= 50):
+                st.error(f"Validation failed: Dry bulb {record['dry_bulb']} outside range")
+                return False
+            if not (0 <= record["relative_humidity"] <= 100):
+                st.error(f"Validation failed: Relative humidity {record['relative_humidity']} outside range")
+                return False
+            if not (80000 <= record["atmospheric_pressure"] <= 110000):
+                st.error(f"Validation failed: Atmospheric pressure {record['atmospheric_pressure']} outside range")
+                return False
+            if not (0 <= record["global_horizontal_radiation"] <= 1200):
+                st.error(f"Validation failed: Global radiation {record['global_horizontal_radiation']} outside range")
+                return False
+            if not (0 <= record["direct_normal_radiation"] <= 1200):
+                st.error(f"Validation failed: Direct normal radiation {record['direct_normal_radiation']} outside range")
+                return False
+            if not (0 <= record["diffuse_horizontal_radiation"] <= 1200):
+                st.error(f"Validation failed: Diffuse horizontal radiation {record['diffuse_horizontal_radiation']} outside range")
+                return False
+            if not (0 <= record["wind_speed"] <= 30):
+                st.error(f"Validation failed: Wind speed {record['wind_speed']} outside range")
+                return False
+            if not (0 <= record["wind_direction"] <= 360):
+                st.error(f"Validation failed: Wind direction {record['wind_direction']} outside range")
+                return False
+        
+        # Validate typical/extreme periods (optional)
+        if "typical_extreme_periods" in data and data["typical_extreme_periods"]:
+            expected_periods = ["summer_extreme", "summer_typical", "winter_extreme", "winter_typical"]
+            missing_periods = [p for p in expected_periods if p not in data["typical_extreme_periods"]]
+            if missing_periods:
+                st.warning(f"Validation warning: Missing typical/extreme periods: {', '.join(missing_periods)}")
+            for period in data["typical_extreme_periods"].values():
+                for date in ["start", "end"]:
+                    if not (1 <= period[date]["month"] <= 12 and 1 <= period[date]["day"] <= 31):
+                        st.error(f"Validation failed: Invalid date in typical/extreme periods: {period[date]}")
+                        return False
+        
+        # Validate ground temperatures (optional)
+        if "ground_temperatures" in data and data["ground_temperatures"]:
+            for depth, temps in data["ground_temperatures"].items():
+                if len(temps) != 12 or not all(0 <= t <= 50 for t in temps):
+                    st.error(f"Validation failed: Invalid ground temperatures for depth {depth}")
+                    return False
+        
+        # Validate solar calculations (optional)
+        if "solar_calculations" in data and data["solar_calculations"]:
+            for calc in data["solar_calculations"]:
+                if not (1 <= calc["month"] <= 12 and 1 <= calc["day"] <= 31 and 1 <= calc["hour"] <= 24):
+                    st.error(f"Validation failed: Invalid date/time in solar calculations: {calc}")
+                    return False
+                if not (-23.45 <= calc["declination"] <= 23.45):
+                    st.error(f"Validation failed: Declination {calc['declination']} outside range")
+                    return False
+                if not (0 <= calc["LST"] <= 24):
+                    st.error(f"Validation failed: LST {calc['LST']} outside range")
+                    return False
+                if not (-180 <= calc["HRA"] <= 180):
+                    st.error(f"Validation failed: HRA {calc['HRA']} outside range")
+                    return False
+                if not (0 <= calc["altitude"] <= 90):
+                    st.error(f"Validation failed: Altitude {calc['altitude']} outside range")
+                    return False
+                if not (0 <= calc["azimuth"] <= 360):
+                    st.error(f"Validation failed: Azimuth {calc['azimuth']} outside range")
+                    return False
+                if not (0 <= calc["ground_reflected"] <= 1200):
+                    st.error(f"Validation failed: Ground-reflected radiation {calc['ground_reflected']} outside range")
+                    return False
+        
+        return True
+
+    @staticmethod
+    def calculate_wet_bulb(dry_bulb: np.ndarray, relative_humidity: np.ndarray) -> np.ndarray:
+        """Calculate Wet Bulb Temperature using Stull (2011) approximation."""
+        db = np.array(dry_bulb, dtype=float)
+        rh = np.array(relative_humidity, dtype=float)
+        
+        term1 = db * np.arctan(0.151977 * (rh + 8.313659)**0.5)
+        term2 = np.arctan(db + rh)
+        term3 = np.arctan(rh - 1.676331)
+        term4 = 0.00391838 * rh**1.5 * np.arctan(0.023101 * rh)
+        term5 = -4.686035
+        
+        wet_bulb = term1 + term2 - term3 + term4 + term5
+        
+        invalid_mask = (rh < 5) | (rh > 99) | (db < -20) | (db > 50) | np.isnan(db) | np.isnan(rh)
+        wet_bulb[invalid_mask] = np.nan
+        
+        return wet_bulb
+
+    @staticmethod
+    def is_numeric(value: str) -> bool:
+        """Check if a string can be converted to a number."""
+        try:
+            float(value)
+            return True
+        except ValueError:
+            return False
+
+    def display_climate_input(self, session_state: Dict[str, Any]):
+        """Display Streamlit interface for EPW upload, visualizations, and solar analysis."""
+        st.title("Climate Data Analysis")
+        
+        # Apply consistent styling
+        st.markdown(STYLE, unsafe_allow_html=True)
+        
+        # Clear invalid session_state["climate_data"] without warning
+        if "climate_data" in session_state and not all(key in session_state["climate_data"] for key in ["id", "country", "city", "timezone"]):
+            del session_state["climate_data"]
+        
+        uploaded_file = st.file_uploader("Upload EPW File", type=["epw"])
+        
+        # Initialize location and epw_data for display
+        location = None
+        epw_data = None
+        
+        if uploaded_file:
+            try:
+                # Process new EPW file
+                epw_content = uploaded_file.read().decode("utf-8")
+                epw_lines = epw_content.splitlines()
+                
+                # Parse header
+                header = next(line for line in epw_lines if line.startswith("LOCATION"))
+                header_parts = header.split(",")
+                city = header_parts[1].strip() or "Unknown"
+                # Clean city name by removing suffixes like '.Racecourse'
+                city = re.sub(r'\..*', '', city)
+                state_province = header_parts[2].strip() or "Unknown"
+                country = header_parts[3].strip() or "Unknown"
+                
+                latitude = float(header_parts[6])
+                longitude = float(header_parts[7])
+                elevation = float(header_parts[9])
+                timezone = float(header_parts[8])  # Time zone from EPW header
+                
+                # Parse TYPICAL/EXTREME PERIODS
+                typical_extreme_periods = {}
+                date_pattern = r'^\d{1,2}\s*/\s*\d{1,2}$'
+                for line in epw_lines:
+                    if line.startswith("TYPICAL/EXTREME PERIODS"):
+                        parts = line.strip().split(',')
+                        try:
+                            num_periods = int(parts[1])
+                        except ValueError:
+                            st.warning("Invalid number of periods in TYPICAL/EXTREME PERIODS, skipping parsing.")
+                            break
+                        for i in range(num_periods):
+                            try:
+                                if len(parts) < 2 + i*4 + 4:
+                                    st.warning(f"Insufficient fields for period {i+1}, skipping.")
+                                    continue
+                                period_name = parts[2 + i*4]
+                                period_type = parts[3 + i*4]
+                                start_date = parts[4 + i*4].strip()
+                                end_date = parts[5 + i*4].strip()
+                                if period_name in [
+                                    "Summer - Week Nearest Max Temperature For Period",
+                                    "Summer - Week Nearest Average Temperature For Period",
+                                    "Winter - Week Nearest Min Temperature For Period",
+                                    "Winter - Week Nearest Average Temperature For Period"
+                                ]:
+                                    season = 'summer' if 'Summer' in period_name else 'winter'
+                                    period_type = ('extreme' if 'Max' in period_name or 'Min' in period_name else 'typical')
+                                    key = f"{season}_{period_type}"
+                                    # Clean dates to remove non-standard whitespace
+                                    start_date_clean = re.sub(r'\s+', '', start_date)
+                                    end_date_clean = re.sub(r'\s+', '', end_date)
+                                    if not re.match(date_pattern, start_date) or not re.match(date_pattern, end_date):
+                                        st.warning(f"Invalid date format for period {period_name}: {start_date} to {end_date}, skipping.")
+                                        continue
+                                    start_month, start_day = map(int, start_date_clean.split('/'))
+                                    end_month, end_day = map(int, end_date_clean.split('/'))
+                                    typical_extreme_periods[key] = {
+                                        "start": {"month": start_month, "day": start_day},
+                                        "end": {"month": end_month, "day": end_day}
+                                    }
+                            except (IndexError, ValueError) as e:
+                                st.warning(f"Error parsing period {i+1}: {str(e)}, skipping.")
+                                continue
+                        break
+                
+                # Parse GROUND TEMPERATURES
+                ground_temperatures = {}
+                for line in epw_lines:
+                    if line.startswith("GROUND TEMPERATURES"):
+                        parts = line.strip().split(',')
+                        try:
+                            num_depths = int(parts[1])
+                        except ValueError:
+                            st.warning("Invalid number of depths in GROUND TEMPERATURES, skipping parsing.")
+                            break
+                        for i in range(num_depths):
+                            try:
+                                if len(parts) < 2 + i*16 + 16:
+                                    st.warning(f"Insufficient fields for ground temperature depth {i+1}, skipping.")
+                                    continue
+                                depth = parts[2 + i*16]
+                                temps = [float(t) for t in parts[6 + i*16:18 + i*16] if t.strip()]
+                                if len(temps) != 12:
+                                    st.warning(f"Invalid number of temperatures for depth {depth}m, expected 12, got {len(temps)}, skipping.")
+                                    continue
+                                ground_temperatures[depth] = temps
+                            except (ValueError, IndexError) as e:
+                                st.warning(f"Error parsing ground temperatures for depth {i+1}: {str(e)}, skipping.")
+                                continue
+                        break
+                
+                # Read data section
+                data_start_idx = next(i for i, line in enumerate(epw_lines) if line.startswith("DATA PERIODS")) + 1
+                epw_data = pd.read_csv(StringIO("\n".join(epw_lines[data_start_idx:])), header=None, dtype=str)
+                
+                if len(epw_data) != 8760:
+                    raise ValueError(f"EPW file has {len(epw_data)} records, expected 8760.")
+                if len(epw_data.columns) != 35:
+                    raise ValueError(f"EPW file has {len(epw_data.columns)} columns, expected 35.")
+                
+                for col in [1, 2, 3, 6, 8, 9, 13, 14, 15, 20, 21]:
+                    epw_data[col] = pd.to_numeric(epw_data[col], errors='coerce')
+                    if epw_data[col].isna().all():
+                        raise ValueError(f"Column {col} contains only non-numeric or missing data.")
+                
+                # Create ClimateLocation
+                location = ClimateLocation(
+                    epw_file=epw_data,
+                    typical_extreme_periods=typical_extreme_periods,
+                    ground_temperatures=ground_temperatures,
+                    id=f"{country[:1].upper()}{city[:3].upper()}",
+                    country=country,
+                    state_province=state_province,
+                    city=city,
+                    latitude=latitude,
+                    longitude=longitude,
+                    elevation=elevation,
+                    timezone=timezone
+                )
+                self.add_location(location)
+                climate_data_dict = location.to_dict()
+                if not self.validate_climate_data(climate_data_dict):
+                    raise ValueError("Invalid climate data extracted from EPW file.")
+                session_state["climate_data"] = climate_data_dict
+                st.success("Climate data extracted from EPW file!")
+            
+            except Exception as e:
+                st.error(f"Error processing EPW file: {str(e)}. Ensure it has 8760 hourly records and correct format.")
+        
+        elif "climate_data" in session_state and self.validate_climate_data(session_state["climate_data"]):
+            # Reconstruct from session_state
+            climate_data_dict = session_state["climate_data"]
+            
+            # Rebuild epw_data from hourly_data
+            hourly_data = climate_data_dict["hourly_data"]
+            epw_data = pd.DataFrame({
+                1: [d["month"] for d in hourly_data],  # Month
+                2: [d["day"] for d in hourly_data],  # Day
+                3: [d["hour"] for d in hourly_data],  # Hour
+                6: [d["dry_bulb"] for d in hourly_data],  # Dry-bulb temperature
+                8: [d["relative_humidity"] for d in hourly_data],  # Relative humidity
+                9: [d["atmospheric_pressure"] for d in hourly_data],  # Pressure
+                13: [d["global_horizontal_radiation"] for d in hourly_data],  # Global horizontal radiation
+                14: [d["direct_normal_radiation"] for d in hourly_data],  # Direct normal radiation
+                15: [d["diffuse_horizontal_radiation"] for d in hourly_data],  # Diffuse horizontal radiation
+                20: [d["wind_direction"] for d in hourly_data],  # Wind direction
+                21: [d["wind_speed"] for d in hourly_data],  # Wind speed
+            })
+            
+            # Create ClimateLocation with reconstructed epw_data
+            location = ClimateLocation(
+                epw_file=epw_data,
+                typical_extreme_periods=climate_data_dict["typical_extreme_periods"],
+                ground_temperatures=climate_data_dict["ground_temperatures"],
+                id=climate_data_dict["id"],
+                country=climate_data_dict["country"],
+                state_province=climate_data_dict["state_province"],
+                city=climate_data_dict["city"],
+                latitude=climate_data_dict["latitude"],
+                longitude=climate_data_dict["longitude"],
+                elevation=climate_data_dict["elevation"],
+                timezone=climate_data_dict["timezone"],
+                solar_calculations=climate_data_dict.get("solar_calculations", [])
+            )
+            # Override hourly_data to ensure consistency
+            location.hourly_data = climate_data_dict["hourly_data"]
+            self.add_location(location)
+            st.info("Displaying previously extracted climate data.")
+        
+        # Display tabs if location and epw_data are available
+        if location and epw_data is not None:
+            tab1, tab2 = st.tabs(["General Information", "Solar Analysis"])
+            
+            with tab1:
+                self.display_design_conditions(location)
+            
+            with tab2:
+                self.display_solar_analysis(location, session_state)
+        
+        else:
+            st.info("No climate data available. Please upload an EPW file to proceed.")
+
+    def display_solar_analysis(self, location: ClimateLocation, session_state: Dict[str, Any]):
+        """Display solar analysis tab with input fields and calculation results."""
+        st.subheader("Solar Analysis")
+        
+        # Input fields with help text
+        col1, col2 = st.columns(2)
+        with col1:
+            ground_reflectivity = st.number_input(
+                "Ground Reflectivity (ρg)",
+                min_value=0.0,
+                max_value=1.0,
+                value=0.2,
+                step=0.01,
+                help="Enter the albedo of the ground surface (0 to 1). Common values: 0.2 (grass), 0.3 (concrete), 0.8 (snow). Default: 0.2."
+            )
+        with col2:
+            surface_tilt = st.number_input(
+                "Surface Tilt (β, degrees)",
+                min_value=0.0,
+                max_value=180.0,
+                value=0.0,
+                step=1.0,
+                help="Enter the tilt angle of the surface in degrees (0° for horizontal, 90° for vertical, up to 180° for downward-facing). Default: 0°."
+            )
+        
+        # Calculate button
+        if st.button("Calculate Solar Parameters"):
+            try:
+                solar_results = SolarCalculations.calculate_solar_parameters(
+                    hourly_data=location.hourly_data,
+                    latitude=location.latitude,
+                    longitude=location.longitude,
+                    timezone=session_state["climate_data"].get("timezone", 0),
+                    ground_reflectivity=ground_reflectivity,
+                    surface_tilt=surface_tilt
+                )
+                session_state["climate_data"]["solar_calculations"] = solar_results
+                location.solar_calculations = solar_results
+                st.success("Solar calculations completed!")
+            except Exception as e:
+                st.error(f"Error in solar calculations: {str(e)}")
+        
+        # Display results table
+        if "solar_calculations" in session_state["climate_data"] and session_state["climate_data"]["solar_calculations"]:
+            st.markdown('<div class="markdown-text"><h3>Solar Analysis Results</h3></div>', unsafe_allow_html=True)
+            table_data = []
+            solar_data = {f"{r['month']}-{r['day']}-{r['hour']}": r for r in session_state["climate_data"]["solar_calculations"]}
+            
+            for record in location.hourly_data:
+                key = f"{record['month']}-{record['day']}-{record['hour']}"
+                row = {
+                    "Month": record["month"],
+                    "Day": record["day"],
+                    "Hour": record["hour"],
+                    "Dry Bulb Temperature (°C)": f"{record['dry_bulb']:.1f}",
+                    "Relative Humidity (%)": f"{record['relative_humidity']:.1f}",
+                    "Wind Speed (m/s)": f"{record['wind_speed']:.1f}",
+                    "Wind Direction (°)": f"{record['wind_direction']:.1f}",
+                    "Global Horizontal Radiation (W/m²)": f"{record['global_horizontal_radiation']:.1f}",
+                    "Direct Normal Radiation (W/m²)": f"{record['direct_normal_radiation']:.1f}",
+                    "Diffuse Horizontal Radiation (W/m²)": f"{record['diffuse_horizontal_radiation']:.1f}",
+                    "Declination (°)": "",
+                    "Local Solar Time (h)": "",
+                    "Hour Angle (°)": "",
+                    "Solar Altitude (°)": "",
+                    "Solar Azimuth (°)": "",
+                    "Ground-Reflected Radiation (W/m²)": ""
+                }
+                if key in solar_data:
+                    solar = solar_data[key]
+                    row.update({
+                        "Declination (°)": f"{solar['declination']:.2f}",
+                        "Local Solar Time (h)": f"{solar['LST']:.2f}",
+                        "Hour Angle (°)": f"{solar['HRA']:.2f}",
+                        "Solar Altitude (°)": f"{solar['altitude']:.2f}",
+                        "Solar Azimuth (°)": f"{solar['azimuth']:.2f}",
+                        "Ground-Reflected Radiation (W/m²)": f"{solar['ground_reflected']:.2f}"
+                    })
+                table_data.append(row)
+            
+            df = pd.DataFrame(table_data)
+            st.dataframe(df, use_container_width=True)
+        else:
+            st.info("No solar calculation results available. Click 'Calculate Solar Parameters' to generate results.")
+
+    def display_design_conditions(self, location: ClimateLocation):
+        """Display design conditions for HVAC calculations using styled HTML."""
+        st.subheader("Design Conditions")
+        
+        col1, col2 = st.columns(2)
+        
+        # Location Details (First Column)
+        with col1:
+            st.markdown(f"""
+            <div class="column">
+                <div class="markdown-text">
+                    <h3>Location Details</h3>
+                    <ul>
+                        <li><strong>Country:</strong> {location.country}</li>
+                        <li><strong>City:</strong> {location.city}</li>
+                        <li><strong>State/Province:</strong> {location.state_province}</li>
+                        <li><strong>Latitude:</strong> {location.latitude}°</li>
+                        <li><strong>Longitude:</strong> {location.longitude}°</li>
+                        <li><strong>Elevation:</strong> {location.elevation} m</li>
+                        <li><strong>Timezone:</strong> {location.timezone:+.1f} hours</li>
+                    </ul>
+                </div>
+            </div>
+            """, unsafe_allow_html=True)
+        
+        # Typical/Extreme Periods (Second Column)
+        with col2:
+            if location.typical_extreme_periods:
+                period_items = [
+                    f"<li><strong>{key.replace('_', ' ').title()}:</strong> {period['start']['month']}/{period['start']['day']} to {period['end']['month']}/{period['end']['day']}</li>"
+                    for key, period in location.typical_extreme_periods.items()
+                ]
+                period_content = f"""
+                <div class="markdown-text">
+                    <h3>Typical/Extreme Periods</h3>
+                    <ul>
+                        {''.join(period_items)}
+                    </ul>
+                </div>
+                """
+            else:
+                period_content = """
+                <div class="markdown-text">
+                    <h3>Typical/Extreme Periods</h3>
+                    <p>No typical/extreme period data available.</p>
+                </div>
+                """
+            st.markdown(period_content, unsafe_allow_html=True)
+        
+        # Calculated Climate Parameters
+        st.markdown(f"""
+        <div class="markdown-text">
+            <h3>Calculated Climate Parameters</h3>
+            <ul>
+                <li><strong>Climate Zone:</strong> {location.climate_zone}</li>
+                <li><strong>Heating Degree Days (base 18°C):</strong> {location.heating_degree_days} HDD</li>
+                <li><strong>Cooling Degree Days (base 18°C):</strong> {location.cooling_degree_days} CDD</li>
+                <li><strong>Winter Design Temperature (99.6%):</strong> {location.winter_design_temp} °C</li>
+                <li><strong>Summer Design Dry-Bulb Temp (0.4%):</strong> {location.summer_design_temp_db} °C</li>
+                <li><strong>Summer Design Wet-Bulb Temp (0.4%):</strong> {location.summer_design_temp_wb} °C</li>
+                <li><strong>Summer Daily Temperature Range:</strong> {location.summer_daily_range} °C</li>
+                <li><strong>Mean Wind Speed:</strong> {location.wind_speed} m/s</li>
+                <li><strong>Mean Atmospheric Pressure:</strong> {location.pressure} Pa</li>
+            </ul>
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # Ground Temperatures (Table)
+        if location.ground_temperatures:
+            st.markdown('<div class="markdown-text"><h3>Ground Temperatures</h3></div>', unsafe_allow_html=True)
+            month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+            table_data = []
+            for depth, temps in location.ground_temperatures.items():
+                row = {"Depth (m)": float(depth)}
+                row.update({month: f"{temp:.2f}" for month, temp in zip(month_names, temps)})
+                table_data.append(row)
+            df = pd.DataFrame(table_data)
+            st.dataframe(df, use_container_width=True)
+        
+        # Hourly Climate Data (Table)
+        if location.hourly_data:
+            st.markdown('<div class="markdown-text"><h3>Hourly Climate Data</h3></div>', unsafe_allow_html=True)
+            hourly_table_data = []
+            for record in location.hourly_data:
+                row = {
+                    "Month": record["month"],
+                    "Day": record["day"],
+                    "Hour": record["hour"],
+                    "Dry Bulb Temperature (°C)": f"{record['dry_bulb']:.1f}",
+                    "Relative Humidity (%)": f"{record['relative_humidity']:.1f}",
+                    "Atmospheric Pressure (Pa)": f"{record['atmospheric_pressure']:.1f}",
+                    "Global Horizontal Radiation (W/m²)": f"{record['global_horizontal_radiation']:.1f}",
+                    "Direct Normal Radiation (W/m²)": f"{record['direct_normal_radiation']:.1f}",
+                    "Diffuse Horizontal Radiation (W/m²)": f"{record['diffuse_horizontal_radiation']:.1f}",
+                    "Wind Speed (m/s)": f"{record['wind_speed']:.1f}",
+                    "Wind Direction (°)": f"{record['wind_direction']:.1f}"
+                }
+                hourly_table_data.append(row)
+            hourly_df = pd.DataFrame(hourly_table_data)
+            st.dataframe(hourly_df, use_container_width=True)
+
+    @staticmethod
+    def assign_climate_zone(hdd: float, cdd: float, avg_humidity: float) -> str:
+        """Assign ASHRAE 169 climate zone based on HDD, CDD, and humidity."""
+        if cdd > 10000:
+            return "0A" if avg_humidity > 60 else "0B"
+        elif cdd > 5000:
+            return "1A" if avg_humidity > 60 else "1B"
+        elif cdd > 2500:
+            return "2A" if avg_humidity > 60 else "2B"
+        elif hdd < 2000 and cdd > 1000:
+            return "3A" if avg_humidity > 60 else "3B" if avg_humidity < 40 else "3C"
+        elif hdd < 3000:
+            return "4A" if avg_humidity > 60 else "4B" if avg_humidity < 40 else "4C"
+        elif hdd < 4000:
+            return "5A" if avg_humidity > 60 else "5B" if avg_humidity < 40 else "5C"
+        elif hdd < 5000:
+            return "6A" if avg_humidity > 60 else "6B"
+        elif hdd < 7000:
+            return "7"
+        else:
+            return "8"
+
+    def export_to_json(self, file_path: str) -> None:
+        """Export all climate data to a JSON file."""
+        data = {loc_id: loc.to_dict() for loc_id, loc in self.locations.items()}
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4)
+
+    @classmethod
+    def from_json(cls, file_path: str) -> 'ClimateData':
+        """Load climate data from a JSON file."""
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        climate_data = cls()
+        for loc_id, loc_dict in data.items():
+            # Rebuild epw_data from hourly_data
+            hourly_data = loc_dict["hourly_data"]
+            epw_data = pd.DataFrame({
+                1: [d["month"] for d in hourly_data],
+                2: [d["day"] for d in hourly_data],
+                3: [d["hour"] for d in hourly_data],
+                6: [d["dry_bulb"] for d in hourly_data],
+                8: [d["relative_humidity"] for d in hourly_data],
+                9: [d["atmospheric_pressure"] for d in hourly_data],
+                13: [d["global_horizontal_radiation"] for d in hourly_data],
+                14: [d["direct_normal_radiation"] for d in hourly_data],
+                15: [d["diffuse_horizontal_radiation"] for d in hourly_data],
+                20: [d["wind_direction"] for d in hourly_data],
+                21: [d["wind_speed"] for d in hourly_data],
+            })
+            location = ClimateLocation(
+                epw_file=epw_data,
+                typical_extreme_periods=loc_dict["typical_extreme_periods"],
+                ground_temperatures=loc_dict["ground_temperatures"],
+                id=loc_dict["id"],
+                country=loc_dict["country"],
+                state_province=loc_dict["state_province"],
+                city=loc_dict["city"],
+                latitude=loc_dict["latitude"],
+                longitude=loc_dict["longitude"],
+                elevation=loc_dict["elevation"],
+                timezone=loc_dict["timezone"],
+                solar_calculations=loc_dict.get("solar_calculations", [])
+            )
+            location.hourly_data = loc_dict["hourly_data"]  # Ensure consistency
+            climate_data.add_location(location)
+        return climate_data
+
+if __name__ == "__main__":
+    climate_data = ClimateData()
+    session_state = {"building_info": {"country": "Australia", "city": "Geelong"}, "page": "Climate Data"}
+    climate_data.display_climate_input(session_state)

data/internal_loads.py

@@ -0,0 +1,263 @@
+# internal_loads.py
+
+# People Activity Levels
+# Each activity level includes metabolic rate (met), metabolic rate in W/person,
+# and ranges for sensible and latent heat gains in W.
+PEOPLE_ACTIVITY_LEVELS = {
+    "Seated, at Rest (Quiet, Reading, Writing)": {
+        "metabolic_rate_met": 1.0,
+        "metabolic_rate_w": 110,
+        "sensible_min_w": 20,
+        "sensible_max_w": 24,
+        "latent_min_w": 9,
+        "latent_max_w": 12
+    },
+    "Seated, Light Office Work (Typing, Filing)": {
+        "metabolic_rate_met": 1.1,
+        "metabolic_rate_w": 125,
+        "sensible_min_w": 24,
+        "sensible_max_w": 27,
+        "latent_min_w": 12,
+        "latent_max_w": 15
+    },
+    "Standing, Light Work (Filing, Walking Slowly)": {
+        "metabolic_rate_met": 1.35,
+        "metabolic_rate_w": 155,
+        "sensible_min_w": 30,
+        "sensible_max_w": 35,
+        "latent_min_w": 18,
+        "latent_max_w": 24
+    },
+    "Walking, Moderate Pace (2–3 mph / 3.2–4.8 km/h)": {
+        "metabolic_rate_met": 2.0,
+        "metabolic_rate_w": 210,
+        "sensible_min_w": 41,
+        "sensible_max_w": 47,
+        "latent_min_w": 30,
+        "latent_max_w": 35
+    },
+    "Light Machine Work (Assembly, Small Tools)": {
+        "metabolic_rate_met": 2.35,
+        "metabolic_rate_w": 250,
+        "sensible_min_w": 47,
+        "sensible_max_w": 56,
+        "latent_min_w": 35,
+        "latent_max_w": 44
+    },
+    "Moderate Work (Walking with Loads, Lifting)": {
+        "metabolic_rate_met": 3.0,
+        "metabolic_rate_w": 310,
+        "sensible_min_w": 59,
+        "sensible_max_w": 68,
+        "latent_min_w": 50,
+        "latent_max_w": 59
+    },
+    "Heavy Work (Carrying Heavy Loads, Shoveling)": {
+        "metabolic_rate_met": 4.0,
+        "metabolic_rate_w": 425,
+        "sensible_min_w": 73,
+        "sensible_max_w": 88,
+        "latent_min_w": 73,
+        "latent_max_w": 88
+    },
+    "Dancing (Moderate to Vigorous)": {
+        "metabolic_rate_met": 3.5,
+        "metabolic_rate_w": 400,
+        "sensible_min_w": 59,
+        "sensible_max_w": 88,
+        "latent_min_w": 59,
+        "latent_max_w": 73
+    },
+    "Athletics/Exercise (Vigorous)": {
+        "metabolic_rate_met": 6.0,
+        "metabolic_rate_w": 600,
+        "sensible_min_w": 88,
+        "sensible_max_w": 117,
+        "latent_min_w": 88,
+        "latent_max_w": 117
+    }
+}
+
+# Diversity Factors by Building Type
+DIVERSITY_FACTORS = {
+    "Office": 0.80,
+    "Classroom": 1.00,
+    "Retail": 0.80,
+    "Restaurant Dining": 1.00,
+    "Restaurant Kitchen": 1.00,
+    "Hotel Guest Room": 0.50,
+    "Hotel Lobby": 0.75,
+    "Hospital Patient Room": 0.60,
+    "Hospital Operating Room": 1.00,
+    "Library": 0.75,
+    "Museum": 0.75,
+    "Courthouse": 1.00,
+    "Gymnasium": 1.00,
+    "Warehouse": 0.50,
+    "Residential Single-Family": 0.50,
+    "Residential Multi-Family": 0.60,
+    "Auditorium": 1.00,
+    "Place of Worship": 1.00,
+    "Laboratory": 0.80,
+    "Data Center": 0.10,
+    "Manufacturing Facility": 0.75,
+    "School Cafeteria": 1.00,
+    "Dormitory": 0.60,
+    "Conference Room": 1.00,
+    "Bank": 0.80,
+    "Post Office": 0.75,
+    "Supermarket": 0.70
+}
+
+# Lighting Power Density (LPD) by Building Type (W/m²)
+LPD_VALUES = {
+    "Office": 8.82,
+    "Classroom": 13.34,
+    "Retail": 13.56,
+    "Restaurant Dining": 9.58,
+    "Restaurant Kitchen": 11.42,
+    "Hotel Guest Room": 9.47,
+    "Hotel Lobby": 13.57,
+    "Hospital Patient Room": 11.30,
+    "Hospital Operating Room": 17.11,
+    "Library": 12.70,
+    "Museum": 11.41,
+    "Courthouse": 11.30,
+    "Gymnasium": 10.76,
+    "Warehouse": 4.84,
+    "Residential Single-Family": 5.38,
+    "Residential Multi-Family": 6.46,
+    "Auditorium": 14.96,
+    "Place of Worship": 11.30,
+    "Laboratory": 15.61,
+    "Data Center": 8.61,
+    "Manufacturing Facility": 11.95,
+    "School Cafeteria": 9.69,
+    "Dormitory": 6.57,
+    "Conference Room": 13.24,
+    "Bank": 10.76,
+    "Post Office": 9.37,
+    "Supermarket": 13.35
+}
+
+# Lighting Fixture Types and Heat Gain Splits
+LIGHTING_FIXTURE_TYPES = {
+    "Incandescent": {"radiative": 80, "convective": 20},
+    "Fluorescent": {"radiative": 60, "convective": 40},
+    "Compact Fluorescent (CFL)": {"radiative": 60, "convective": 40},
+    "LED (Light Emitting Diode)": {"radiative": 50, "convective": 50},
+    "High-Intensity Discharge (HID)": {"radiative": 70, "convective": 30},
+    "Halogen": {"radiative": 80, "convective": 20}
+}
+
+# Equipment Heat Gains by Building Type
+# Includes sensible, latent, convective, and radiant splits (all in %)
+EQUIPMENT_HEAT_GAINS = {
+    "Office": {"sensible": 75, "latent": 25, "convective": 50, "radiant": 50},
+    "Classroom": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Retail": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Restaurant Dining": {"sensible": 60, "latent": 40, "convective": 60, "radiant": 40},
+    "Restaurant Kitchen": {"sensible": 50, "latent": 50, "convective": 70, "radiant": 30},
+    "Hotel Guest Room": {"sensible": 65, "latent": 35, "convective": 60, "radiant": 40},
+    "Hotel Lobby": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Hospital Patient Room": {"sensible": 65, "latent": 35, "convective": 60, "radiant": 40},
+    "Hospital Operating Room": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Library": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Museum": {"sensible": 75, "latent": 25, "convective": 40, "radiant": 60},
+    "Courthouse": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Gymnasium": {"sensible": 60, "latent": 40, "convective": 60, "radiant": 40},
+    "Warehouse": {"sensible": 80, "latent": 20, "convective": 70, "radiant": 30},
+    "Residential Single-Family": {"sensible": 60, "latent": 40, "convective": 60, "radiant": 40},
+    "Residential Multi-Family": {"sensible": 60, "latent": 40, "convective": 60, "radiant": 40},
+    "Auditorium": {"sensible": 65, "latent": 35, "convective": 50, "radiant": 50},
+    "Place of Worship": {"sensible": 65, "latent": 35, "convective": 50, "radiant": 50},
+    "Laboratory": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Data Center": {"sensible": 90, "latent": 10, "convective": 80, "radiant": 20},
+    "Manufacturing Facility": {"sensible": 75, "latent": 25, "convective": 60, "radiant": 40},
+    "School Cafeteria": {"sensible": 65, "latent": 35, "convective": 60, "radiant": 40},
+    "Dormitory": {"sensible": 60, "latent": 40, "convective": 60, "radiant": 40},
+    "Conference Room": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Bank": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Post Office": {"sensible": 70, "latent": 30, "convective": 50, "radiant": 50},
+    "Supermarket": {"sensible": 75, "latent": 25, "convective": 60, "radiant": 40}
+}
+
+# Ventilation Rates by Building Type
+# Includes people_rate (L/s/person) and area_rate (L/s/m²)
+VENTILATION_RATES = {
+    "Office": {"people_rate": 2.5, "area_rate": 0.3},
+    "Classroom": {"people_rate": 5.0, "area_rate": 0.9},
+    "Retail": {"people_rate": 3.8, "area_rate": 0.9},
+    "Restaurant Dining": {"people_rate": 5.0, "area_rate": 1.8},
+    "Restaurant Kitchen": {"people_rate": 3.8, "area_rate": 1.0},
+    "Hotel Guest Room": {"people_rate": 2.5, "area_rate": 0.3},
+    "Hotel Lobby": {"people_rate": 3.8, "area_rate": 0.3},
+    "Hospital Patient Room": {"people_rate": 5.0, "area_rate": 0.6},
+    "Hospital Operating Room": {"people_rate": 10.0, "area_rate": 0.6},
+    "Library": {"people_rate": 2.5, "area_rate": 0.6},
+    "Museum": {"people_rate": 3.8, "area_rate": 0.6},
+    "Courthouse": {"people_rate": 2.5, "area_rate": 0.3},
+    "Gymnasium": {"people_rate": 10.0, "area_rate": 0.9},
+    "Warehouse": {"people_rate": 5.0, "area_rate": 0.3},
+    "Residential Single-Family": {"people_rate": 2.5, "area_rate": 0.3},
+    "Residential Multi-Family": {"people_rate": 2.5, "area_rate": 0.3},
+    "Auditorium": {"people_rate": 2.5, "area_rate": 0.3},
+    "Place of Worship": {"people_rate": 2.5, "area_rate": 0.3},
+    "Laboratory": {"people_rate": 5.0, "area_rate": 0.9},
+    "Data Center": {"people_rate": 5.0, "area_rate": 0.6},
+    "Manufacturing Facility": {"people_rate": 5.0, "area_rate": 0.9},
+    "School Cafeteria": {"people_rate": 5.0, "area_rate": 0.9},
+    "Dormitory": {"people_rate": 2.5, "area_rate": 0.3},
+    "Conference Room": {"people_rate": 2.5, "area_rate": 0.3},
+    "Bank": {"people_rate": 2.5, "area_rate": 0.3},
+    "Post Office": {"people_rate": 2.5, "area_rate": 0.3},
+    "Supermarket": {"people_rate": 3.8, "area_rate": 0.6},
+    "Custom": {"people_rate": 0.0, "area_rate": 0.0}
+}
+
+BUILDING_TYPES = list(VENTILATION_RATES.keys())
+
+# Infiltration Settings by Building Type and Method
+# Methods: ACH, Crack Flow, Empirical Equations
+# Each method has specific parameters for each building type
+INFILTRATION_SETTINGS = {
+    "ACH": {
+        "Office": {"rate": 0.5},
+        "Classroom": {"rate": 0.3},
+        "Retail": {"rate": 0.4},
+        "Restaurant Dining": {"rate": 0.6},
+        "Restaurant Kitchen": {"rate": 0.8},
+        "Hotel Guest Room": {"rate": 0.2},
+        "Hotel Lobby": {"rate": 0.5},
+        "Hospital Patient Room": {"rate": 0.1},
+        "Hospital Operating Room": {"rate": 0.05},
+        "Library": {"rate": 0.3},
+        "Museum": {"rate": 0.2},
+        "Courthouse": {"rate": 0.4},
+        "Gymnasium": {"rate": 0.6},
+        "Warehouse": {"rate": 1.0},
+        "Residential Single-Family": {"rate": 0.5},
+        "Residential Multi-Family": {"rate": 0.4},
+        "Auditorium": {"rate": 0.3},
+        "Place of Worship": {"rate": 0.4},
+        "Laboratory": {"rate": 0.2},
+        "Data Center": {"rate": 0.1},
+        "Manufacturing Facility": {"rate": 0.7},
+        "School Cafeteria": {"rate": 0.5},
+        "Dormitory": {"rate": 0.4},
+        "Conference Room": {"rate": 0.3},
+        "Bank": {"rate": 0.4},
+        "Post Office": {"rate": 0.5},
+        "Supermarket": {"rate": 0.6}
+    },
+    "Crack Flow": {
+        "Office": {"ela": 0.0001},  # Effective Leakage Area (m²/m² of wall)
+        "Classroom": {"ela": 0.00008},
+        # Additional building types can be added as needed
+    },
+    "Empirical Equations": {
+        "Office": {"c": 0.1, "n": 0.65},  # Example coefficients for Sherman-Grimsrud model
+        "Classroom": {"c": 0.08, "n": 0.65},
+        # Additional building types can be added as needed
+    }
+}

data/material_library.py

@@ -0,0 +1,505 @@
+"""
+Material Library for HVAC Load Calculator
+Updated 2025-05-17: Removed original materials and constructions, deleted ASHRAE materials starting with 'R' followed by number (e.g., R01, R25), verified constructions use valid materials.
+Updated 2025-05-17: Added all materials and constructions from ASHRAE_2005_HOF_Materials.idf with Australian-specific embodied carbon and prices.
+Updated 2025-05-17: Added GlazingMaterial and DoorMaterial classes, included library_glazing_materials and library_door_materials with comprehensive data.
+Updated 2025-05-16: Removed mass_per_meter, added thermal_mass method, updated CSV handling.
+Updated 2025-05-16: Fixed U-value calculation in Material.get_u_value.
+Updated 2025-05-16: Updated MaterialCategory to Finishing Materials, Structural Materials, Sub-Structural Materials, Insulation.
+Updated 2025-05-16: Fixed Construction.get_thermal_mass to use avg_specific_heat.
+
+Developed by: Dr Majed Abuseif, Deakin University
+© 2025
+"""
+
+from typing import Dict, List, Optional, Tuple
+from enum import Enum
+import pandas as pd
+
+class MaterialCategory(Enum):
+    FINISHING_MATERIALS = "Finishing Materials"
+    STRUCTURAL_MATERIALS = "Structural Materials"
+    SUB_STRUCTURAL_MATERIALS = "Sub-Structural Materials"
+    INSULATION = "Insulation"
+
+class ThermalMass(Enum):
+    HIGH = "High"
+    MEDIUM = "Medium"
+    LOW = "Low"
+    NO_MASS = "No Mass"
+
+class Material:
+    def __init__(self, name: str, category: MaterialCategory, conductivity: float, density: float,
+                 specific_heat: float, default_thickness: float, embodied_carbon: float,
+                 solar_absorption: float, price: float, is_library: bool = True):
+        self.name = name
+        self.category = category
+        self.conductivity = max(0.01, conductivity)  # W/m·K
+        self.density = max(1.0, density)  # kg/m³
+        self.specific_heat = max(100.0, specific_heat)  # J/kg·K
+        self.default_thickness = max(0.01, default_thickness)  # m
+        self.embodied_carbon = max(0.0, embodied_carbon)  # kgCO₂e/kg
+        self.solar_absorption = min(max(0.0, solar_absorption), 1.0)
+        self.price = max(0.0, price)  # USD/m²
+        self.is_library = is_library
+
+    def get_thermal_mass(self) -> ThermalMass:
+        if self.density < 100.0 or self.specific_heat < 800.0:
+            return ThermalMass.NO_MASS
+        elif self.density > 2000.0 and self.specific_heat > 800.0:
+            return ThermalMass.HIGH
+        elif 1000.0 <= self.density <= 2000.0 and 800.0 <= self.specific_heat <= 1200.0:
+            return ThermalMass.MEDIUM
+        else:
+            return ThermalMass.LOW
+
+    def get_u_value(self) -> float:
+        return self.conductivity / self.default_thickness if self.default_thickness > 0 else 0.1
+
+class GlazingMaterial:
+    def __init__(self, name: str, u_value: float, shgc: float, embodied_carbon: float, price: float, is_library: bool = True):
+        self.name = name
+        self.u_value = max(0.1, u_value)  # W/m²·K
+        self.shgc = min(max(0.0, shgc), 1.0)  # Solar Heat Gain Coefficient
+        self.embodied_carbon = max(0.0, embodied_carbon)  # kgCO₂e/m²
+        self.price = max(0.0, price)  # USD/m²
+        self.is_library = is_library
+
+class DoorMaterial:
+    def __init__(self, name: str, u_value: float, solar_absorption: float, embodied_carbon: float, price: float, is_library: bool = True):
+        self.name = name
+        self.u_value = max(0.1, u_value)  # W/m²·K
+        self.solar_absorption = min(max(0.0, solar_absorption), 1.0)
+        self.embodied_carbon = max(0.0, embodied_carbon)  # kgCO₂e/m²
+        self.price = max(0.0, price)  # USD/m²
+        self.is_library = is_library
+
+class Construction:
+    def __init__(self, name: str, component_type: str, layers: List[Dict], is_library: bool = True):
+        self.name = name
+        self.component_type = component_type
+        self.layers = layers or []
+        self.is_library = is_library
+        self.u_value = self.calculate_u_value()
+        self.total_thickness = sum(layer["thickness"] for layer in self.layers)
+        self.embodied_carbon = sum(layer["material"].embodied_carbon * layer["material"].density * layer["thickness"]
+                                  for layer in self.layers)
+        self.solar_absorption = max(layer["material"].solar_absorption for layer in self.layers) if self.layers else 0.6
+        self.price = sum(layer["material"].price * layer["thickness"] / layer["material"].default_thickness
+                         for layer in self.layers)
+
+    def calculate_u_value(self) -> float:
+        if not self.layers:
+            return 0.1
+        r_total = sum(layer["thickness"] / layer["material"].conductivity for layer in self.layers)
+        return 1 / r_total if r_total > 0 else 0.1
+
+    def get_thermal_mass(self) -> ThermalMass:
+        if not self.layers:
+            return ThermalMass.NO_MASS
+        total_thickness = self.total_thickness
+        if total_thickness == 0:
+            return ThermalMass.NO_MASS
+        avg_density = sum(layer["material"].density * layer["thickness"] for layer in self.layers) / total_thickness
+        avg_specific_heat = sum(layer["material"].specific_heat * layer["thickness"] for layer in self.layers) / total_thickness
+        if avg_density < 100.0 or avg_specific_heat < 800.0:
+            return ThermalMass.NO_MASS
+        elif avg_density > 2000.0 and avg_specific_heat > 800.0:
+            return ThermalMass.HIGH
+        elif 1000.0 <= avg_density <= 2000.0 and 800.0 <= avg_specific_heat <= 1200.0:
+            return ThermalMass.MEDIUM
+        else:
+            return ThermalMass.LOW
+
+class MaterialLibrary:
+    def __init__(self):
+        self.library_materials = self.initialize_materials()
+        self.library_constructions = self.initialize_constructions()
+        self.library_glazing_materials = self.initialize_glazing_materials()
+        self.library_door_materials = self.initialize_door_materials()
+
+    def initialize_materials(self) -> Dict[str, Material]:
+        materials = [
+            # ASHRAE 2005 HOF Materials (excluding 'R'-prefixed materials)
+            Material("F04 Wall air space resistance", MaterialCategory.INSULATION, 0.01, 1.0, 1000.0, 0.01, 0.01, 0.5, 0.5),
+            Material("F05 Ceiling air space resistance", MaterialCategory.INSULATION, 0.01, 1.0, 1000.0, 0.01, 0.01, 0.5, 0.5),
+            Material("F06 EIFS finish", MaterialCategory.FINISHING_MATERIALS, 0.72, 1856.0, 840.0, 0.0095, 0.3, 0.5, 17.6),
+            Material("F07 25mm stucco", MaterialCategory.FINISHING_MATERIALS, 0.72, 1856.0, 840.0, 0.0254, 0.2, 0.6, 14.1),
+            Material("F08 Metal surface", MaterialCategory.SUB_STRUCTURAL_MATERIALS, 45.28, 7824.0, 500.0, 0.001, 2.2, 0.7, 25.0),
+            Material("F09 25mm cement plaster", MaterialCategory.FINISHING_MATERIALS, 0.72, 1856.0, 840.0, 0.0254, 0.2, 0.6, 14.1),
+            Material("F10 13mm gypsum board", MaterialCategory.FINISHING_MATERIALS, 0.16, 800.0, 1090.0, 0.0127, 0.25, 0.4, 5.1),
+            Material("F11 16mm gypsum board", MaterialCategory.FINISHING_MATERIALS, 0.16, 800.0, 1090.0, 0.0159, 0.25, 0.4, 6.4),
+            Material("F12 19mm gypsum board", MaterialCategory.FINISHING_MATERIALS, 0.16, 800.0, 1090.0, 0.0191, 0.25, 0.4, 7.6),
+            Material("F13 13mm cement plaster", MaterialCategory.FINISHING_MATERIALS, 0.72, 1856.0, 840.0, 0.0127, 0.2, 0.6, 7.1),
+            Material("F14 13mm lime plaster", MaterialCategory.FINISHING_MATERIALS, 0.72, 1600.0, 840.0, 0.0127, 0.2, 0.5, 6.1),
+            Material("F15 22mm cement plaster", MaterialCategory.FINISHING_MATERIALS, 0.72, 1856.0, 840.0, 0.0222, 0.2, 0.6, 12.4),
+            Material("F16 Acoustic tile", MaterialCategory.FINISHING_MATERIALS, 0.06, 368.0, 590.0, 0.0191, 1.0, 0.4, 14.0),
+            Material("F17 13mm slag", MaterialCategory.FINISHING_MATERIALS, 0.16, 960.0, 1090.0, 0.0127, 0.2, 0.5, 1.0),
+            Material("F18 25mm slag", MaterialCategory.FINISHING_MATERIALS, 0.16, 960.0, 1090.0, 0.0254, 0.2, 0.5, 1.9),
+            Material("G01 13mm gypsum board", MaterialCategory.FINISHING_MATERIALS, 0.16, 800.0, 1090.0, 0.0127, 0.25, 0.4, 5.1),
+            Material("G01a 19mm gypsum board", MaterialCategory.FINISHING_MATERIALS, 0.16, 800.0, 1090.0, 0.0191, 0.25, 0.4, 7.6),
+            Material("G02 25mm cement plaster", MaterialCategory.FINISHING_MATERIALS, 0.72, 1856.0, 840.0, 0.0254, 0.2, 0.6, 14.1),
+            Material("G03 13mm lime plaster", MaterialCategory.FINISHING_MATERIALS, 0.72, 1600.0, 840.0, 0.0127, 0.25, 0.5, 6.1),
+            Material("G04 13mm cement plaster", MaterialCategory.FINISHING_MATERIALS, 0.72, 1856.0, 840.0, 0.0127, 0.2, 0.6, 7.1),
+            Material("G05 25mm wood", MaterialCategory.SUB_STRUCTURAL_MATERIALS, 0.15, 608.0, 1630.0, 0.0254, 0.3, 0.5, 15.4),
+            Material("G06 19mm wood", MaterialCategory.SUB_STRUCTURAL_MATERIALS, 0.15, 608.0, 1630.0, 0.0191, 0.3, 0.5, 11.6),
+            Material("I01 25mm insulation board", MaterialCategory.INSULATION, 0.03, 43.0, 1210.0, 0.0254, 2.5, 0.5, 1.1),
+            Material("I02 50mm insulation board", MaterialCategory.INSULATION, 0.03, 43.0, 1210.0, 0.0508, 2.5, 0.5, 2.2),
+            Material("I03 75mm insulation board", MaterialCategory.INSULATION, 0.03, 43.0, 1210.0, 0.0762, 2.5, 0.5, 3.3),
+            Material("M01 100mm brick", MaterialCategory.STRUCTURAL_MATERIALS, 0.89, 1920.0, 790.0, 0.1016, 0.3, 0.7, 19.5),
+            Material("M02 100mm face brick", MaterialCategory.STRUCTURAL_MATERIALS, 1.33, 2000.0, 790.0, 0.1016, 0.3, 0.7, 20.3),
+            Material("M03 150mm brick", MaterialCategory.STRUCTURAL_MATERIALS, 0.89, 1920.0, 790.0, 0.1524, 0.3, 0.7, 29.3),
+            Material("M04 200mm concrete block", MaterialCategory.STRUCTURAL_MATERIALS, 0.51, 800.0, 920.0, 0.2032, 0.2, 0.65, 13.0),
+            Material("M05 200mm concrete block", MaterialCategory.STRUCTURAL_MATERIALS, 1.11, 1280.0, 920.0, 0.2032, 0.2, 0.65, 20.8),
+            Material("M06 150mm concrete block", MaterialCategory.STRUCTURAL_MATERIALS, 0.51, 800.0, 920.0, 0.1524, 0.2, 0.65, 9.8),
+            Material("M07 100mm concrete block", MaterialCategory.STRUCTURAL_MATERIALS, 0.51, 800.0, 920.0, 0.1016, 0.2, 0.65, 6.5),
+            Material("M08 150mm concrete block", MaterialCategory.STRUCTURAL_MATERIALS, 1.11, 1280.0, 920.0, 0.1524, 0.2, 0.65, 15.6),
+            Material("M09 100mm concrete block", MaterialCategory.STRUCTURAL_MATERIALS, 1.11, 1280.0, 920.0, 0.1016, 0.2, 0.65, 10.4),
+            Material("M10 100mm lightweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 0.53, 1280.0, 840.0, 0.1016, 0.15, 0.65, 7.8),
+            Material("M11 100mm lightweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 0.53, 1280.0, 840.0, 0.1016, 0.15, 0.65, 7.8),
+            Material("M12 150mm lightweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 0.53, 1280.0, 840.0, 0.1524, 0.15, 0.65, 11.7),
+            Material("M13 200mm lightweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 0.53, 1280.0, 840.0, 0.2032, 0.15, 0.65, 15.6),
+            Material("M14 100mm heavyweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 1.95, 2240.0, 900.0, 0.1016, 0.2, 0.65, 18.2),
+            Material("M14a 100mm heavyweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 1.95, 2240.0, 900.0, 0.1016, 0.2, 0.65, 18.2),
+            Material("M15 200mm heavyweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 1.95, 2240.0, 900.0, 0.2032, 0.2, 0.65, 36.4),
+            Material("M16 300mm heavyweight concrete", MaterialCategory.STRUCTURAL_MATERIALS, 1.95, 2240.0, 900.0, 0.3048, 0.2, 0.65, 54.6),
+            Material("M17 100mm stone", MaterialCategory.STRUCTURAL_MATERIALS, 2.10, 2240.0, 880.0, 0.1016, 0.2, 0.7, 22.8),
+            Material("M18 150mm stone", MaterialCategory.STRUCTURAL_MATERIALS, 2.10, 2240.0, 880.0, 0.1524, 0.2, 0.7, 34.1),
+            Material("M19 100mm limestone", MaterialCategory.STRUCTURAL_MATERIALS, 1.80, 2320.0, 880.0, 0.1016, 0.2, 0.6, 23.6),
+            Material("M20 150mm limestone", MaterialCategory.STRUCTURAL_MATERIALS, 1.80, 2320.0, 880.0, 0.1524, 0.2, 0.6, 35.4),
+            Material("M21 200mm limestone", MaterialCategory.STRUCTURAL_MATERIALS, 1.80, 2320.0, 880.0, 0.2032, 0.2, 0.6, 47.1),
+            Material("M22 100mm granite", MaterialCategory.STRUCTURAL_MATERIALS, 2.80, 2640.0, 880.0, 0.1016, 0.2, 0.7, 26.8),
+            Material("M23 150mm granite", MaterialCategory.STRUCTURAL_MATERIALS, 2.80, 2640.0, 880.0, 0.1524, 0.2, 0.7, 40.2),
+            Material("M24 200mm granite", MaterialCategory.STRUCTURAL_MATERIALS, 2.80, 2640.0, 880.0, 0.2032, 0.2, 0.7, 53.6),
+            Material("M25 100mm marble", MaterialCategory.STRUCTURAL_MATERIALS, 2.50, 2720.0, 880.0, 0.1016, 0.2, 0.6, 27.6),
+            Material("M26 150mm marble", MaterialCategory.STRUCTURAL_MATERIALS, 2.50, 2720.0, 880.0, 0.1524, 0.2, 0.6, 41.4),
+            Material("M27 200mm marble", MaterialCategory.STRUCTURAL_MATERIALS, 2.50, 2720.0, 880.0, 0.2032, 0.2, 0.6, 55.3),
+        ]
+        return {mat.name: mat for mat in materials}
+
+    def initialize_glazing_materials(self) -> Dict[str, GlazingMaterial]:
+        glazing_materials = [
+            # ASHRAE-based glazing materials with Australian pricing
+            GlazingMaterial("Single Clear 3mm", 5.8, 0.81, 25.0, 50.0),  # High U-value, high SHGC
+            GlazingMaterial("Single Clear 6mm", 5.7, 0.78, 28.0, 60.0),  # Slightly lower SHGC
+            GlazingMaterial("Single Tinted 6mm", 5.7, 0.55, 30.0, 70.0),  # Reduced SHGC for solar control
+            GlazingMaterial("Double Clear 6mm/13mm Air", 2.7, 0.70, 40.0, 100.0),  # Improved insulation
+            GlazingMaterial("Double Low-E 6mm/13mm Air", 1.8, 0.60, 45.0, 120.0),  # Low-E coating
+            GlazingMaterial("Double Tinted 6mm/13mm Air", 2.7, 0.45, 42.0, 110.0),  # Tinted for solar control
+            GlazingMaterial("Double Low-E 6mm/13mm Argon", 1.5, 0.55, 48.0, 130.0),  # Argon-filled, better U-value
+            GlazingMaterial("Triple Clear 4mm/12mm Air", 1.8, 0.62, 55.0, 150.0),  # Triple glazing
+            GlazingMaterial("Triple Low-E 4mm/12mm Argon", 0.9, 0.50, 60.0, 180.0),  # High-performance
+            GlazingMaterial("Single Low-E Reflective 6mm", 5.6, 0.35, 35.0, 90.0),  # Reflective coating
+            GlazingMaterial("Double Reflective 6mm/13mm Air", 2.5, 0.30, 50.0, 140.0),  # Low SHGC
+            GlazingMaterial("Electrochromic 6mm/13mm Air", 2.0, 0.40, 70.0, 200.0),  # Dynamic glazing
+        ]
+        return {mat.name: mat for mat in glazing_materials}
+
+    def initialize_door_materials(self) -> Dict[str, DoorMaterial]:
+        door_materials = [
+            # Door materials with ASHRAE-based properties and Australian pricing
+            DoorMaterial("Solid Wood 45mm", 2.5, 0.50, 15.0, 200.0),  # Standard wooden door
+            DoorMaterial("Insulated Wood 50mm", 1.8, 0.45, 18.0, 250.0),  # Better insulation
+            DoorMaterial("Hollow Core Wood 40mm", 3.5, 0.50, 12.0, 150.0),  # Less insulation
+            DoorMaterial("Steel Uninsulated 45mm", 5.0, 0.70, 20.0, 180.0),  # High U-value
+            DoorMaterial("Steel Insulated 50mm", 2.0, 0.65, 25.0, 220.0),  # Foam-insulated
+            DoorMaterial("Aluminum Uninsulated 45mm", 6.0, 0.75, 22.0, 200.0),  # Poor insulation
+            DoorMaterial("Aluminum Insulated 50mm", 2.5, 0.70, 28.0, 240.0),  # Thermal break
+            DoorMaterial("Glass Single 6mm", 5.7, 0.78, 28.0, 100.0),  # Same as single glazing
+            DoorMaterial("Glass Double 6mm/13mm Air", 2.7, 0.70, 40.0, 150.0),  # Double-glazed door
+            DoorMaterial("Fiberglass Insulated 50mm", 1.5, 0.60, 20.0, 230.0),  # High performance
+            DoorMaterial("PVC Insulated 50mm", 1.7, 0.55, 18.0, 210.0),  # Durable, insulated
+            DoorMaterial("Wood with Glass Insert", 3.0, 0.65, 16.0, 190.0),  # Mixed properties
+        ]
+        return {mat.name: mat for mat in door_materials}
+
+    def initialize_constructions(self) -> Dict[str, Construction]:
+        constructions = [
+            Construction("Light Exterior Wall", "Wall", [
+                {"material": self.library_materials["F08 Metal surface"], "thickness": 0.001},
+                {"material": self.library_materials["I02 50mm insulation board"], "thickness": 0.0508},
+                {"material": self.library_materials["F04 Wall air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["G01a 19mm gypsum board"], "thickness": 0.0191}
+            ]),
+            Construction("Light Roof/Ceiling", "Roof", [
+                {"material": self.library_materials["M11 100mm lightweight concrete"], "thickness": 0.1016},
+                {"material": self.library_materials["F05 Ceiling air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["F16 Acoustic tile"], "thickness": 0.0191}
+            ]),
+            Construction("Light Floor", "Floor", [
+                {"material": self.library_materials["F16 Acoustic tile"], "thickness": 0.0191},
+                {"material": self.library_materials["F05 Ceiling air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["M11 100mm lightweight concrete"], "thickness": 0.1016}
+            ]),
+            Construction("Medium Exterior Wall", "Wall", [
+                {"material": self.library_materials["M01 100mm brick"], "thickness": 0.1016},
+                {"material": self.library_materials["I02 50mm insulation board"], "thickness": 0.0508},
+                {"material": self.library_materials["F04 Wall air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["G01a 19mm gypsum board"], "thickness": 0.0191}
+            ]),
+            Construction("Medium Roof/Ceiling", "Roof", [
+                {"material": self.library_materials["M14a 100mm heavyweight concrete"], "thickness": 0.1016},
+                {"material": self.library_materials["F05 Ceiling air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["F16 Acoustic tile"], "thickness": 0.0191}
+            ]),
+            Construction("Medium Floor", "Floor", [
+                {"material": self.library_materials["F16 Acoustic tile"], "thickness": 0.0191},
+                {"material": self.library_materials["F05 Ceiling air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["M14a 100mm heavyweight concrete"], "thickness": 0.1016}
+            ]),
+            Construction("Heavy Exterior Wall", "Wall", [
+                {"material": self.library_materials["M01 100mm brick"], "thickness": 0.1016},
+                {"material": self.library_materials["M15 200mm heavyweight concrete"], "thickness": 0.2032},
+                {"material": self.library_materials["I02 50mm insulation board"], "thickness": 0.0508},
+                {"material": self.library_materials["F04 Wall air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["G01a 19mm gypsum board"], "thickness": 0.0191}
+            ]),
+            Construction("Heavy Roof/Ceiling", "Roof", [
+                {"material": self.library_materials["M15 200mm heavyweight concrete"], "thickness": 0.2032},
+                {"material": self.library_materials["F05 Ceiling air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["F16 Acoustic tile"], "thickness": 0.0191}
+            ]),
+            Construction("Heavy Floor", "Floor", [
+                {"material": self.library_materials["F16 Acoustic tile"], "thickness": 0.0191},
+                {"material": self.library_materials["F05 Ceiling air space resistance"], "thickness": 0.01},
+                {"material": self.library_materials["M15 200mm heavyweight concrete"], "thickness": 0.2032}
+            ]),
+        ]
+        return {cons.name: cons for cons in constructions}
+
+    def get_all_materials(self, project_materials: Optional[Dict[str, Material]] = None) -> List[Material]:
+        materials = list(self.library_materials.values())
+        if project_materials:
+            materials.extend(list(project_materials.values()))
+        return materials
+
+    def get_all_glazing_materials(self, project_glazing_materials: Optional[Dict[str, GlazingMaterial]] = None) -> List[GlazingMaterial]:
+        materials = list(self.library_glazing_materials.values())
+        if project_glazing_materials:
+            materials.extend(list(project_glazing_materials.values()))
+        return materials
+
+    def get_all_door_materials(self, project_door_materials: Optional[Dict[str, DoorMaterial]] = None) -> List[DoorMaterial]:
+        materials = list(self.library_door_materials.values())
+        if project_door_materials:
+            materials.extend(list(project_door_materials.values()))
+        return materials
+
+    def add_project_material(self, material: Material, project_materials: Dict[str, Material]) -> Tuple[bool, str]:
+        if len(project_materials) >= 20:
+            return False, "Maximum 20 project materials allowed."
+        if material.name in project_materials or material.name in self.library_materials:
+            return False, f"Material name '{material.name}' already exists."
+        project_materials[material.name] = material
+        return True, f"Material '{material.name}' added to project materials."
+
+    def add_project_glazing_material(self, material: GlazingMaterial, project_glazing_materials: Dict[str, GlazingMaterial]) -> Tuple[bool, str]:
+        if len(project_glazing_materials) >= 20:
+            return False, "Maximum 20 project glazing materials allowed."
+        if material.name in project_glazing_materials or material.name in self.library_glazing_materials:
+            return False, f"Glazing material name '{material.name}' already exists."
+        project_glazing_materials[material.name] = material
+        return True, f"Glazing material '{material.name}' added to project glazing materials."
+
+    def add_project_door_material(self, material: DoorMaterial, project_door_materials: Dict[str, DoorMaterial]) -> Tuple[bool, str]:
+        if len(project_door_materials) >= 20:
+            return False, "Maximum 20 project door materials allowed."
+        if material.name in project_door_materials or material.name in self.library_door_materials:
+            return False, f"Door material name '{material.name}' already exists."
+        project_door_materials[material.name] = material
+        return True, f"Door material '{material.name}' added to project door materials."
+
+    def edit_project_material(self, old_name: str, new_material: Material, project_materials: Dict[str, Material],
+                             components: Dict[str, List]) -> Tuple[bool, str]:
+        if old_name not in project_materials:
+            return False, f"Material '{old_name}' not found in project materials."
+        if new_material.name != old_name and (new_material.name in project_materials or new_material.name in self.library_materials):
+            return False, f"Material name '{new_material.name}' already exists."
+        for comp_list in components.values():
+            for comp in comp_list:
+                if comp.construction and any(layer["material"].name == old_name for layer in comp.layers):
+                    comp.layers = [{"material": new_material if layer["material"].name == old_name else layer["material"],
+                                    "thickness": layer["thickness"]} for layer in comp.layers]
+                    comp.construction = Construction(
+                        name=comp.construction.name,
+                        component_type=comp.construction.component_type,
+                        layers=comp.layers,
+                        is_library=comp.construction.is_library
+                    )
+        project_materials.pop(old_name)
+        project_materials[new_material.name] = new_material
+        return True, f"Material '{old_name}' updated to '{new_material.name}'."
+
+    def edit_project_glazing_material(self, old_name: str, new_material: GlazingMaterial,
+                                     project_glazing_materials: Dict[str, GlazingMaterial],
+                                     components: Dict[str, List]) -> Tuple[bool, str]:
+        if old_name not in project_glazing_materials:
+            return False, f"Glazing material '{old_name}' not found in project glazing materials."
+        if new_material.name != old_name and (new_material.name in project_glazing_materials or new_material.name in self.library_glazing_materials):
+            return False, f"Glazing material name '{new_material.name}' already exists."
+        for comp_list in components.values():
+            for comp in comp_list:
+                if comp.glazing_material and comp.glazing_material.name == old_name:
+                    comp.glazing_material = new_material
+                    comp.u_value = new_material.u_value
+                    comp.shgc = new_material.shgc
+        project_glazing_materials.pop(old_name)
+        project_glazing_materials[new_material.name] = new_material
+        return True, f"Glazing material '{old_name}' updated to '{new_material.name}'."
+
+    def edit_project_door_material(self, old_name: str, new_material: DoorMaterial,
+                                  project_door_materials: Dict[str, DoorMaterial],
+                                  components: Dict[str, List]) -> Tuple[bool, str]:
+        if old_name not in project_door_materials:
+            return False, f"Door material '{old_name}' not found in project door materials."
+        if new_material.name != old_name and (new_material.name in project_door_materials or new_material.name in self.library_door_materials):
+            return False, f"Door material name '{new_material.name}' already exists."
+        for comp_list in components.values():
+            for comp in comp_list:
+                if comp.door_material and comp.door_material.name == old_name:
+                    comp.door_material = new_material
+                    comp.u_value = new_material.u_value
+                    comp.solar_absorptivity = new_material.solar_absorption
+        project_door_materials.pop(old_name)
+        project_door_materials[new_material.name] = new_material
+        return True, f"Door material '{old_name}' updated to '{new_material.name}'."
+
+    def delete_project_material(self, name: str, project_materials: Dict[str, Material], components: Dict[str, List]) -> Tuple[bool, str]:
+        if name not in project_materials:
+            return False, f"Material '{name}' not found in project materials."
+        for cons in self.library_constructions.values():
+            if any(layer["material"].name == name for layer in cons.layers):
+                return False, f"Cannot delete '{name}' as it is used in library construction '{cons.name}'."
+        for comp_type, comp_list in components.items():
+            for comp in comp_list:
+                if 'layers' in comp and any(layer["material"].name == name for layer in comp["layers"]):
+                    return False, f"Cannot delete '{name}' as it is used in component '{comp['name']}' ({comp_type})."
+        del project_materials[name]
+        return True, f"Material '{name}' deleted successfully."
+
+    def delete_project_glazing_material(self, name: str, project_glazing_materials: Dict[str, GlazingMaterial],
+                                       components: Dict[str, List]) -> Tuple[bool, str]:
+        if name not in project_glazing_materials:
+            return False, f"Glazing material '{name}' not found in project glazing materials."
+        for comp_list in components.values():
+            for comp in comp_list:
+                if comp.glazing_material and comp.glazing_material.name == name:
+                    return False, f"Cannot delete '{name}' as it is used in component '{comp.name}'."
+        del project_glazing_materials[name]
+        return True, f"Glazing material '{name}' deleted successfully."
+
+    def delete_project_door_material(self, name: str, project_door_materials: Dict[str, DoorMaterial],
+                                    components: Dict[str, List]) -> Tuple[bool, str]:
+        if name not in project_door_materials:
+            return False, f"Door material '{name}' not found in project door materials."
+        for comp_list in components.values():
+            for comp in comp_list:
+                if comp.door_material and comp.door_material.name == name:
+                    return False, f"Cannot delete '{name}' as it is used in component '{comp.name}'."
+        del project_door_materials[name]
+        return True, f"Door material '{name}' deleted successfully."
+
+    def add_project_construction(self, construction: Construction, project_constructions: Dict[str, Construction]) -> Tuple[bool, str]:
+        if len(project_constructions) >= 20:
+            return False, "Maximum 20 project constructions allowed."
+        if construction.name in project_constructions or construction.name in self.library_constructions:
+            return False, f"Construction name '{construction.name}' already exists."
+        project_constructions[construction.name] = construction
+        return True, f"Construction '{construction.name}' added to project constructions."
+
+    def edit_project_construction(self, old_name: str, new_construction: Construction,
+                                 project_constructions: Dict[str, Construction],
+                                 components: Dict[str, List]) -> Tuple[bool, str]:
+        if old_name not in project_constructions:
+            return False, f"Construction '{old_name}' not found in project constructions."
+        if new_construction.name != old_name and (new_construction.name in project_constructions or new_construction.name in self.library_constructions):
+            return False, f"Construction name '{new_construction.name}' already exists."
+        for comp_list in components.values():
+            for comp in comp_list:
+                if comp.construction and comp.construction.name == old_name:
+                    comp.construction = new_construction
+                    comp.layers = new_construction.layers
+                    comp.u_value = new_construction.u_value
+        project_constructions.pop(old_name)
+        project_constructions[new_construction.name] = new_construction
+        return True, f"Construction '{old_name}' updated to '{new_construction.name}'."
+
+    def delete_project_construction(self, name: str, project_constructions: Dict[str, Construction],
+                                   components: Dict[str, List]) -> Tuple[bool, str]:
+        if name not in project_constructions:
+            return False, f"Construction '{name}' not found in project constructions."
+        for comp_list in components.values():
+            for comp in comp_list:
+                if comp.construction and comp.construction.name == name:
+                    return False, f"Construction '{name}' is used in component '{comp.name}'."
+        project_constructions.pop(name)
+        return True, f"Construction '{name}' deleted."
+
+    def to_dataframe(self, data_type: str, project_materials: Optional[Dict[str, Material]] = None,
+                     project_constructions: Optional[Dict[str, Construction]] = None,
+                     project_glazing_materials: Optional[Dict[str, GlazingMaterial]] = None,
+                     project_door_materials: Optional[Dict[str, DoorMaterial]] = None,
+                     only_project: bool = False) -> pd.DataFrame:
+        if data_type == "materials":
+            data = []
+            materials = project_materials.values() if only_project else self.get_all_materials(project_materials)
+            for mat in materials:
+                data.append({
+                    "Name": mat.name,
+                    "Category": mat.category.value,
+                    "Conductivity (W/m·K)": mat.conductivity,
+                    "Density (kg/m³)": mat.density,
+                    "Specific Heat (J/kg·K)": mat.specific_heat,
+                    "Default Thickness (m)": mat.default_thickness,
+                    "Embodied Carbon (kgCO₂e/kg)": mat.embodied_carbon,
+                    "Solar Absorption": mat.solar_absorption,
+                    "Price (USD/m²)": mat.price,
+                    "Source": "Project" if not mat.is_library else "Library"
+                })
+            return pd.DataFrame(data)
+        elif data_type == "constructions":
+            data = []
+            constructions = project_constructions.values() if only_project else list(self.library_constructions.values())
+            if not only_project and project_constructions:
+                constructions.extend(list(project_constructions.values()))
+            for cons in constructions:
+                layers_str = "; ".join(f"{layer['material'].name} ({layer['thickness']}m)" for layer in cons.layers)
+                data.append({
+                    "Name": cons.name,
+                    "Component Type": cons.component_type,
+                    "U-Value (W/m²·K)": cons.u_value,
+                    "Total Thickness (m)": cons.total_thickness,
+                    "Embodied Carbon (kgCO₂e/m²)": cons.embodied_carbon,
+                    "Solar Absorption": cons.solar_absorption,
+                    "Price (USD/m²)": cons.price,
+                    "Layers": layers_str,
+                    "Source": "Project" if not cons.is_library else "Library"
+                })
+            return pd.DataFrame(data)
+        elif data_type == "glazing_materials":
+            data = []
+            glazing_materials = project_glazing_materials.values() if only_project else self.get_all_glazing_materials(project_glazing_materials)
+            for mat in glazing_materials:
+                data.append({
+                    "Name": mat.name,
+                    "U-Value (W/m²·K)": mat.u_value,
+                    "SHGC": mat.shgc,
+                    "Embodied Carbon (kgCO₂e/m²)": mat.embodied_carbon,
+                    "Price (USD/m²)": mat.price,
+                    "Source": "Project" if not mat.is_library else "Library"
+                })
+            return pd.DataFrame(data)
+        elif data_type == "door_materials":
+            data = []
+            door_materials = project_door_materials.values() if only_project else self.get_all_door_materials(project_door_materials)
+            for mat in door_materials:
+                data.append({
+                    "Name": mat.name,
+                    "U-Value (W/m²·K)": mat.u_value,
+                    "Solar Absorption": mat.solar_absorption,
+                    "Embodied Carbon (kgCO₂e/m²)": mat.embodied_carbon,
+                    "Price (USD/m²)": mat.price,
+                    "Source": "Project" if not mat.is_library else "Library"
+                })
+            return pd.DataFrame(data)
+        return pd.DataFrame()