Upload 27 files

README.md

@@ -1,19 +1,13 @@
 ---
-title: HVAC 03
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
+name: hvac-calculator
+title: HVAC Load Calculator
+emoji: 🌡️
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.28.0
+app_file: app/main.py
 pinned: false
-short_description: Streamlit template space
 ---
 
-# Welcome to Streamlit!
-
-Edit `/src/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).
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app/building_info_form.py

@@ -0,0 +1,232 @@
+"""
+Building information input form for HVAC Load Calculator.
+This module provides the UI components for entering building information.
+
+Author: Dr Majed Abuseif
+Date: March 2025
+Version: 1.0.0
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import pycountry
+from typing import Dict, List, Any, Optional, Tuple
+import os
+
+# Import data models
+from data.building_components import Orientation, ComponentType
+
+
+class BuildingInfoForm:
+    """Class for building information input form."""
+    
+    def __init__(self):
+        """Initialize the building information form."""
+        self.countries = sorted([country.name for country in pycountry.countries])
+    
+    def display(self):
+        """Display the building information form."""
+        self.display_building_info_form(st.session_state)
+    
+    def display_building_info_form(self, session_state: Dict[str, Any]) -> None:
+        """Display building information input form in Streamlit."""
+        st.header("Building Information")
+        
+        if "building_info" not in session_state:
+            session_state["building_info"] = {
+                "project_name": "",
+                "building_name": "",
+                "country": "",
+                "city": "",
+                "building_type": "",
+                "floor_area": 0.0,
+                "width": 0.0,
+                "depth": 0.0,
+                "building_height": 3.0,
+                "orientation": "NORTH",
+                "operating_hours": "8:00-18:00"
+            }
+        
+        default_values = {
+            "project_name": "",
+            "building_name": "",
+            "country": "",
+            "city": "",
+            "building_type": "",
+            "floor_area": 0.0,
+            "width": 0.0,
+            "depth": 0.0,
+            "building_height": 3.0,
+            "orientation": "NORTH",
+            "operating_hours": "8:00-18:00"
+        }
+        
+        for key, default_value in default_values.items():
+            if key not in session_state["building_info"]:
+                session_state["building_info"][key] = default_value
+        
+        if "data_saved" not in session_state:
+            session_state["data_saved"] = False
+        
+        with st.form(key="building_info_form"):
+            st.subheader("Project Information")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                session_state["building_info"]["project_name"] = st.text_input(
+                    "Project Name",
+                    value=session_state["building_info"]["project_name"],
+                    help="Enter the project's identification name"
+                )
+                session_state["building_info"]["building_name"] = st.text_input(
+                    "Building Name",
+                    value=session_state["building_info"]["building_name"],
+                    help="Enter the building's identification name"
+                )
+            
+            with col2:
+                session_state["building_info"]["country"] = st.selectbox(
+                    "Country",
+                    options=[""] + self.countries,
+                    index=0 if not session_state["building_info"]["country"] else 
+                          self.countries.index(session_state["building_info"]["country"]) + 1,
+                    help="Select the building's country location"
+                )
+                session_state["building_info"]["city"] = st.text_input(
+                    "City",
+                    value=session_state["building_info"]["city"],
+                    help="Enter the building's city location"
+                )
+            
+            st.subheader("Building Characteristics")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                session_state["building_info"]["building_type"] = st.selectbox(
+                    "Building Type",
+                    ["Residential", "Office", "Retail", "Educational", "Healthcare", "Industrial", "Other"],
+                    index=1 if session_state["building_info"]["building_type"] == "" else 
+                          ["Residential", "Office", "Retail", "Educational", "Healthcare", "Industrial", "Other"].index(session_state["building_info"]["building_type"]),
+                    help="Select the building's purpose or usage type"
+                )
+            
+            with col2:
+                session_state["building_info"]["building_height"] = st.number_input(
+                    "Building Height (m)",
+                    min_value=2.0,
+                    max_value=1000.0,
+                    value=float(session_state["building_info"]["building_height"]),
+                    step=0.1,
+                    help="Enter the total height of the building in meters"
+                )
+            
+            st.subheader("Building Dimensions")
+            session_state["building_info"]["floor_area"] = st.number_input(
+                "Total Floor Area (m²)",
+                min_value=0.0,
+                value=float(session_state["building_info"]["floor_area"]),
+                step=10.0,
+                help="Enter the total floor area of the building in square meters (optional if width and depth provided)"
+            )
+            
+            # Center the OR using columns
+            col1, col2, col3 = st.columns([2, 1, 2])
+            with col2:
+                st.markdown("Enter the total floor area above OR the building width and depth below")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                session_state["building_info"]["width"] = st.number_input(
+                    "Width (m)",
+                    min_value=0.0,
+                    value=float(session_state["building_info"]["width"]),
+                    step=1.0,
+                    help="Enter the building's width in meters (optional if area provided)"
+                )
+            with col2:
+                session_state["building_info"]["depth"] = st.number_input(
+                    "Depth (m)",
+                    min_value=0.0,
+                    value=float(session_state["building_info"]["depth"]),
+                    step=1.0,
+                    help="Enter the building's depth in meters (optional if area provided)"
+                )
+            
+            st.subheader("Building Orientation")
+            session_state["building_info"]["orientation"] = st.selectbox(
+                "Building Orientation",
+                ["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"],
+                index=["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"].index(session_state["building_info"]["orientation"]),
+                help="Select the direction of the building's main facade"
+            )
+            
+            st.subheader("Operating Hours")
+            session_state["building_info"]["operating_hours"] = st.text_input(
+                "Operating Hours",
+                value=session_state["building_info"]["operating_hours"],
+                help="Enter the building's daily operating hours (e.g., 8:00-18:00)"
+            )
+            
+            submitted = st.form_submit_button("Save Building Information")
+            
+            if submitted:
+                valid, errors = self.validate_building_info(session_state["building_info"])
+                if not valid:
+                    for error in errors:
+                        st.error(error)
+                else:
+                    if session_state["building_info"]["width"] > 0 and session_state["building_info"]["depth"] > 0:
+                        calculated_area = session_state["building_info"]["width"] * session_state["building_info"]["depth"]
+                        if session_state["building_info"]["floor_area"] == 0:
+                            session_state["building_info"]["floor_area"] = calculated_area
+                    
+                    total_volume = session_state["building_info"]["floor_area"] * session_state["building_info"]["building_height"]
+                    
+                    session_state["save_results"] = {
+                        "success": "Building information saved successfully!",
+                        "area": f"Total Floor Area: {session_state['building_info']['floor_area']:.1f} m²",
+                        "volume": f"Total Building Volume: {total_volume:.1f} m³"
+                    }
+                    session_state["data_saved"] = True
+        
+        # Display results if they exist
+        if "save_results" in session_state and session_state["data_saved"]:
+            st.success(session_state["save_results"]["success"])
+            st.info(session_state["save_results"]["area"])
+            st.info(session_state["save_results"]["volume"])
+        
+        # Proceed button with immediate navigation
+        if session_state["data_saved"]:
+            if st.button("Proceed to Climate Data"):
+                session_state["page"] = "Climate Data"
+                session_state["data_saved"] = False
+                if "save_results" in session_state:
+                    del session_state["save_results"]
+    
+    @staticmethod
+    def validate_building_info(building_info: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        """Validate building information."""
+        valid = True
+        errors = []
+        
+        required_fields = ["project_name", "building_name", "country", "city", "building_type"]
+        for field in required_fields:
+            if field not in building_info or not building_info[field]:
+                valid = False
+                errors.append(f"Missing required field: {field}")
+        
+        if building_info.get("floor_area", 0) <= 0 and (building_info.get("width", 0) <= 0 or building_info.get("depth", 0) <= 0):
+            valid = False
+            errors.append("Must provide either floor area or both width and depth dimensions")
+        
+        if building_info.get("building_height", 0) <= 0:
+            valid = False
+            errors.append("Building height must be greater than zero")
+        
+        return valid, errors
+
+
+if __name__ == "__main__":
+    form = BuildingInfoForm()
+    form.display()

app/component_selection.py

@@ -0,0 +1,801 @@
+"""
+HVAC Component Selection Module
+Provides UI for selecting building components in the HVAC Load Calculator.
+All dependencies are included within this file for standalone operation.
+Updated 2025-04-28: Added perimeter field to Floor class for F-factor calculations.
+Updated 2025-04-29: Fixed Floors table headings, added insulated field for dynamic F-factor.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import json
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List, Any, Optional
+import io
+
+# --- Enums ---
+class Orientation(Enum):
+    NORTH = "North"
+    NORTHEAST = "Northeast"
+    EAST = "East"
+    SOUTHEAST = "Southeast"
+    SOUTH = "South"
+    SOUTHWEST = "Southwest"
+    WEST = "West"
+    NORTHWEST = "Northwest"
+    HORIZONTAL = "Horizontal"
+    NOT_APPLICABLE = "N/A"
+
+class ComponentType(Enum):
+    WALL = "Wall"
+    ROOF = "Roof"
+    FLOOR = "Floor"
+    WINDOW = "Window"
+    DOOR = "Door"
+
+# --- Data Models ---
+@dataclass
+class MaterialLayer:
+    name: str
+    thickness: float  # in mm
+    conductivity: float  # W/(m·K)
+
+@dataclass
+class BuildingComponent:
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    name: str = "Unnamed Component"
+    component_type: ComponentType = ComponentType.WALL
+    u_value: float = 0.0  # W/(m²·K)
+    area: float = 0.0  # m²
+    orientation: Orientation = Orientation.NOT_APPLICABLE
+
+    def __post_init__(self):
+        if self.area <= 0:
+            raise ValueError("Area must be greater than zero")
+        if self.u_value <= 0:
+            raise ValueError("U-value must be greater than zero")
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id, "name": self.name, "component_type": self.component_type.value,
+            "u_value": self.u_value, "area": self.area, "orientation": self.orientation.value
+        }
+
+@dataclass
+class Wall(BuildingComponent):
+    wall_type: str = "Brick"
+    wall_group: str = "A"  # ASHRAE group
+    absorptivity: float = 0.6
+    shading_coefficient: float = 1.0
+    infiltration_rate_cfm: float = 0.0
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.WALL
+        if not 0 <= self.absorptivity <= 1:
+            raise ValueError("Absorptivity must be between 0 and 1")
+        if not 0 <= self.shading_coefficient <= 1:
+            raise ValueError("Shading coefficient must be between 0 and 1")
+        if self.infiltration_rate_cfm < 0:
+            raise ValueError("Infiltration rate cannot be negative")
+        VALID_WALL_GROUPS = {"A", "B", "C", "D", "E", "F", "G", "H"}
+        if self.wall_group not in VALID_WALL_GROUPS:
+            st.warning(f"Invalid wall_group '{self.wall_group}' for wall '{self.name}'. Defaulting to 'A'.")
+            self.wall_group = "A"
+
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({
+            "wall_type": self.wall_type, "wall_group": self.wall_group, "absorptivity": self.absorptivity,
+            "shading_coefficient": self.shading_coefficient, "infiltration_rate_cfm": self.infiltration_rate_cfm
+        })
+        return base_dict
+
+@dataclass
+class Roof(BuildingComponent):
+    roof_type: str = "Concrete"
+    roof_group: str = "A"  # ASHRAE group
+    slope: str = "Flat"
+    absorptivity: float = 0.6
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.ROOF
+        if not self.orientation == Orientation.HORIZONTAL:
+            self.orientation = Orientation.HORIZONTAL
+        if not 0 <= self.absorptivity <= 1:
+            raise ValueError("Absorptivity must be between 0 and 1")
+        VALID_ROOF_GROUPS = {"A", "B", "C", "D", "E", "F", "G"}
+        if self.roof_group not in VALID_ROOF_GROUPS:
+            st.warning(f"Invalid roof_group '{self.roof_group}' for roof '{self.name}'. Defaulting to 'A'.")
+            self.roof_group = "A"
+
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({
+            "roof_type": self.roof_type, "roof_group": self.roof_group, "slope": self.slope, "absorptivity": self.absorptivity
+        })
+        return base_dict
+
+@dataclass
+class Floor(BuildingComponent):
+    floor_type: str = "Concrete"
+    ground_contact: bool = True
+    ground_temperature_c: float = 25.0
+    perimeter: float = 0.0
+    insulated: bool = False  # NEW: For dynamic F-factor
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.FLOOR
+        self.orientation = Orientation.NOT_APPLICABLE
+        if self.perimeter < 0:
+            raise ValueError("Perimeter cannot be negative")
+        if self.ground_contact and not (-10 <= self.ground_temperature_c <= 40):
+            raise ValueError("Ground temperature must be between -10°C and 40°C for ground-contact floors")
+
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({
+            "floor_type": self.floor_type, "ground_contact": self.ground_contact,
+            "ground_temperature_c": self.ground_temperature_c, "perimeter": self.perimeter,
+            "insulated": self.insulated
+        })
+        return base_dict
+
+@dataclass
+class Window(BuildingComponent):
+    shgc: float = 0.7
+    shading_device: str = "None"
+    shading_coefficient: float = 1.0
+    frame_type: str = "Aluminum"
+    frame_percentage: float = 20.0
+    infiltration_rate_cfm: float = 0.0
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.WINDOW
+        if not 0 <= self.shgc <= 1:
+            raise ValueError("SHGC must be between 0 and 1")
+        if not 0 <= self.shading_coefficient <= 1:
+            raise ValueError("Shading coefficient must be between 0 and 1")
+        if not 0 <= self.frame_percentage <= 30:
+            raise ValueError("Frame percentage must be between 0 and 30")
+        if self.infiltration_rate_cfm < 0:
+            raise ValueError("Infiltration rate cannot be negative")
+
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({
+            "shgc": self.shgc, "shading_device": self.shading_device, "shading_coefficient": self.shading_coefficient,
+            "frame_type": self.frame_type, "frame_percentage": self.frame_percentage, "infiltration_rate_cfm": self.infiltration_rate_cfm
+        })
+        return base_dict
+
+@dataclass
+class Door(BuildingComponent):
+    door_type: str = "Solid Wood"
+    infiltration_rate_cfm: float = 0.0
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.DOOR
+        if self.infiltration_rate_cfm < 0:
+            raise ValueError("Infiltration rate cannot be negative")
+
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({"door_type": self.door_type, "infiltration_rate_cfm": self.infiltration_rate_cfm})
+        return base_dict
+
+# --- Reference Data ---
+class ReferenceData:
+    def __init__(self):
+        self.data = {
+            "materials": {
+                "Concrete": {"conductivity": 1.4},
+                "Insulation": {"conductivity": 0.04},
+                "Brick": {"conductivity": 0.8},
+                "Glass": {"conductivity": 1.0},
+                "Wood": {"conductivity": 0.15}
+            },
+            "wall_types": {
+                "Brick Wall": {"u_value": 2.0, "absorptivity": 0.6, "wall_group": "A"},
+                "Insulated Brick": {"u_value": 0.5, "absorptivity": 0.6, "wall_group": "B"},
+                "Concrete Block": {"u_value": 1.8, "absorptivity": 0.6, "wall_group": "C"},
+                "Insulated Concrete": {"u_value": 0.4, "absorptivity": 0.6, "wall_group": "D"},
+                "Timber Frame": {"u_value": 0.3, "absorptivity": 0.6, "wall_group": "E"},
+                "Cavity Brick": {"u_value": 0.6, "absorptivity": 0.6, "wall_group": "F"},
+                "Lightweight Panel": {"u_value": 1.0, "absorptivity": 0.6, "wall_group": "G"},
+                "Reinforced Concrete": {"u_value": 1.5, "absorptivity": 0.6, "wall_group": "H"},
+                "SIP": {"u_value": 0.25, "absorptivity": 0.6, "wall_group": "A"},
+                "Custom": {"u_value": 0.5, "absorptivity": 0.6, "wall_group": "A"}
+            },
+            "roof_types": {
+                "Concrete Roof": {"u_value": 0.3, "absorptivity": 0.6, "group": "A"},
+                "Metal Roof": {"u_value": 1.0, "absorptivity": 0.75, "group": "B"}
+            },
+            "roof_ventilation_methods": {
+                "No Ventilation": 0.0,
+                "Natural Low": 0.1,
+                "Natural High": 0.5,
+                "Mechanical": 1.0
+            },
+            "floor_types": {
+                "Concrete Slab": {"u_value": 0.4, "ground_contact": True},
+                "Wood Floor": {"u_value": 0.8, "ground_contact": False}
+            },
+            "window_types": {
+                "Double Glazed": {"u_value": 2.8, "shgc": 0.7, "frame_type": "Aluminum"},
+                "Single Glazed": {"u_value": 5.0, "shgc": 0.9, "frame_type": "Wood"}
+            },
+            "shading_devices": {
+                "None": 1.0,
+                "Venetian Blinds": 0.6,
+                "Overhang": 0.4,
+                "Roller Shades": 0.5,
+                "Drapes": 0.7
+            },
+            "door_types": {
+                "Solid Wood": {"u_value": 2.0},
+                "Glass Door": {"u_value": 3.5}
+            }
+        }
+
+    def get_materials(self) -> List[Dict[str, Any]]:
+        return [{"name": k, "conductivity": v["conductivity"]} for k, v in self.data["materials"].items()]
+
+reference_data = ReferenceData()
+
+# --- Component Library ---
+class ComponentLibrary:
+    def __init__(self):
+        self.components = {}
+
+    def add_component(self, component: BuildingComponent):
+        self.components[component.id] = component
+
+    def remove_component(self, component_id: str):
+        if not component_id.startswith("preset_") and component_id in self.components:
+            del self.components[component_id]
+
+component_library = ComponentLibrary()
+
+# --- U-Value Calculator ---
+class UValueCalculator:
+    def __init__(self):
+        self.materials = reference_data.get_materials()
+
+    def calculate_u_value(self, layers: List[Dict[str, float]], outside_resistance: float, inside_resistance: float) -> float:
+        r_layers = sum(layer["thickness"] / 1000 / layer["conductivity"] for layer in layers)
+        r_total = outside_resistance + r_layers + inside_resistance
+        return 1 / r_total if r_total > 0 else 0
+
+u_value_calculator = UValueCalculator()
+
+# --- Component Selection Interface ---
+class ComponentSelectionInterface:
+    def __init__(self):
+        self.component_library = component_library
+        self.u_value_calculator = u_value_calculator
+        self.reference_data = reference_data
+
+    def display_component_selection(self, session_state: Any) -> None:
+        st.title("Building Components")
+        
+        if 'components' not in session_state:
+            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
+        if 'roof_air_volume_m3' not in session_state:
+            session_state.roof_air_volume_m3 = 0.0
+        if 'roof_ventilation_ach' not in session_state:
+            session_state.roof_ventilation_ach = 0.0
+
+        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
+        
+        with tabs[0]:
+            self._display_component_tab(session_state, ComponentType.WALL)
+        with tabs[1]:
+            self._display_component_tab(session_state, ComponentType.ROOF)
+        with tabs[2]:
+            self._display_component_tab(session_state, ComponentType.FLOOR)
+        with tabs[3]:
+            self._display_component_tab(session_state, ComponentType.WINDOW)
+        with tabs[4]:
+            self._display_component_tab(session_state, ComponentType.DOOR)
+        with tabs[5]:
+            self._display_u_value_calculator_tab(session_state)
+        
+        if st.button("Save Components"):
+            self._save_components(session_state)
+
+    def _display_component_tab(self, session_state: Any, component_type: ComponentType) -> None:
+        type_name = component_type.value.lower()
+        st.subheader(f"{type_name.capitalize()} Components")
+        
+        with st.expander(f"Add {type_name.capitalize()}", expanded=True):
+            if component_type == ComponentType.WALL:
+                self._display_add_wall_form(session_state)
+            elif component_type == ComponentType.ROOF:
+                self._display_add_roof_form(session_state)
+            elif component_type == ComponentType.FLOOR:
+                self._display_add_floor_form(session_state)
+            elif component_type == ComponentType.WINDOW:
+                self._display_add_window_form(session_state)
+            elif component_type == ComponentType.DOOR:
+                self._display_add_door_form(session_state)
+        
+        components = session_state.components.get(type_name + 's', [])
+        if components or component_type == ComponentType.ROOF:
+            st.subheader(f"Existing {type_name.capitalize()} Components")
+            self._display_components_table(session_state, component_type, components)
+
+    def _display_add_wall_form(self, session_state: Any) -> None:
+        st.write("Add walls manually or upload a file.")
+        method = st.radio("Add Wall Method", ["Manual Entry", "File Upload"])
+        if "add_wall_submitted" not in session_state:
+            session_state.add_wall_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_wall_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    name = st.text_input("Name", "New Wall")
+                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
+                with col2:
+                    wall_options = self.reference_data.data["wall_types"]
+                    selected_wall = st.selectbox("Wall Type", options=list(wall_options.keys()))
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(wall_options[selected_wall]["u_value"]), step=0.01)
+                    wall_group = st.selectbox("Wall Group (ASHRAE)", ["A", "B", "C", "D", "E", "F", "G", "H"], index=0)
+                    absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=2)
+                    shading_coefficient = st.number_input("Shading Coefficient", min_value=0.0, max_value=1.0, value=1.0, step=0.05)
+                    infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)
+
+                submitted = st.form_submit_button("Add Wall")
+                if submitted and not session_state.add_wall_submitted:
+                    try:
+                        absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
+                        new_wall = Wall(
+                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                            wall_type=selected_wall, wall_group=wall_group, absorptivity=absorptivity_value,
+                            shading_coefficient=shading_coefficient, infiltration_rate_cfm=infiltration_rate
+                        )
+                        self.component_library.add_component(new_wall)
+                        session_state.components['walls'].append(new_wall)
+                        st.success(f"Added {new_wall.name}")
+                        session_state.add_wall_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_wall_submitted:
+                session_state.add_wall_submitted = False
+
+        elif method == "File Upload":
+            uploaded_file = st.file_uploader("Upload Walls File", type=["csv", "xlsx"], key="wall_upload")
+            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Absorptivity", "Shading Coefficient", "Infiltration Rate (CFM)"]
+            template_data = pd.DataFrame(columns=required_cols)
+            template_data.loc[0] = ["Example Wall", 10.0, 2.0, "North", "Brick Wall", "A", 0.6, 1.0, 0.0]
+            st.download_button(label="Download Wall Template", data=template_data.to_csv(index=False), file_name="wall_template.csv", mime="text/csv")
+            if uploaded_file:
+                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
+                if all(col in df.columns for col in required_cols):
+                    valid_wall_groups = {"A", "B", "C", "D", "E", "F", "G", "H"}
+                    for _, row in df.iterrows():
+                        try:
+                            wall_group = str(row["Wall Group"])
+                            if wall_group not in valid_wall_groups:
+                                st.warning(f"Invalid Wall Group '{wall_group}' in row '{row['Name']}'. Defaulting to 'A'.")
+                                wall_group = "A"
+                            new_wall = Wall(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                orientation=Orientation(row["Orientation"]), wall_type=str(row["Wall Type"]),
+                                wall_group=wall_group, absorptivity=float(row["Absorptivity"]),
+                                shading_coefficient=float(row["Shading Coefficient"]), infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
+                            )
+                            self.component_library.add_component(new_wall)
+                            session_state.components['walls'].append(new_wall)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Walls uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_roof_form(self, session_state: Any) -> None:
+        st.write("Add roofs manually or upload a file.")
+        method = st.radio("Add Roof Method", ["Manual Entry", "File Upload"])
+        if "add_roof_submitted" not in session_state:
+            session_state.add_roof_submitted = False
+
+        st.subheader("Roof System Ventilation")
+        air_volume = st.number_input("Air Volume (m³)", min_value=0.0, value=session_state.roof_air_volume_m3, step=1.0, help="Total volume between roof and ceiling")
+        vent_options = {f"{k} (ACH={v})": v for k, v in self.reference_data.data["roof_ventilation_methods"].items()}
+        vent_options["Custom"] = None
+        ventilation_method = st.selectbox("Ventilation Method", options=list(vent_options.keys()), index=0, help="Applies to entire roof system")
+        ventilation_ach = st.number_input("Custom Ventilation Rate (ACH)", min_value=0.0, max_value=10.0, value=0.0, step=0.1) if ventilation_method == "Custom" else vent_options[ventilation_method]
+        session_state.roof_air_volume_m3 = air_volume
+        session_state.roof_ventilation_ach = ventilation_ach
+
+        if method == "Manual Entry":
+            with st.form("add_roof_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    name = st.text_input("Name", "New Roof")
+                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                    orientation = Orientation.HORIZONTAL.value
+                with col2:
+                    roof_options = self.reference_data.data["roof_types"]
+                    selected_roof = st.selectbox("Roof Type", options=list(roof_options.keys()))
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(roof_options[selected_roof]["u_value"]), step=0.01)
+                    roof_group = st.selectbox("Roof Group (ASHRAE)", ["A", "B", "C", "D", "E", "F", "G"], index=0)
+                    slope = st.selectbox("Slope", ["Flat", "Pitched"], index=0)
+                    absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=2)
+
+                submitted = st.form_submit_button("Add Roof")
+                if submitted and not session_state.add_roof_submitted:
+                    try:
+                        absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
+                        new_roof = Roof(
+                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                            roof_type=selected_roof, roof_group=roof_group, slope=slope, absorptivity=absorptivity_value
+                        )
+                        self.component_library.add_component(new_roof)
+                        session_state.components['roofs'].append(new_roof)
+                        st.success(f"Added {new_roof.name}")
+                        session_state.add_roof_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_roof_submitted:
+                session_state.add_roof_submitted = False
+
+        elif method == "File Upload":
+            uploaded_file = st.file_uploader("Upload Roofs File", type=["csv", "xlsx"], key="roof_upload")
+            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Roof Type", "Roof Group", "Slope", "Absorptivity"]
+            template_data = pd.DataFrame(columns=required_cols)
+            template_data.loc[0] = ["Example Roof", 10.0, 0.3, "Horizontal", "Concrete Roof", "A", "Flat", 0.6]
+            st.download_button(label="Download Roof Template", data=template_data.to_csv(index=False), file_name="roof_template.csv", mime="text/csv")
+            if uploaded_file:
+                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
+                if all(col in df.columns for col in required_cols):
+                    valid_roof_groups = {"A", "B", "C", "D", "E", "F", "G"}
+                    for _, row in df.iterrows():
+                        try:
+                            roof_group = str(row["Roof Group"])
+                            if roof_group not in valid_roof_groups:
+                                st.warning(f"Invalid Roof Group '{roof_group}' in row '{row['Name']}'. Defaulting to 'A'.")
+                                roof_group = "A"
+                            new_roof = Roof(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                orientation=Orientation(row["Orientation"]), roof_type=str(row["Roof Type"]),
+                                roof_group=roof_group, slope=str(row["Slope"]), absorptivity=float(row["Absorptivity"])
+                            )
+                            self.component_library.add_component(new_roof)
+                            session_state.components['roofs'].append(new_roof)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Roofs uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_floor_form(self, session_state: Any) -> None:
+        st.write("Add floors manually or upload a file.")
+        method = st.radio("Add Floor Method", ["Manual Entry", "File Upload"])
+        if "add_floor_submitted" not in session_state:
+            session_state.add_floor_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_floor_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    name = st.text_input("Name", "New Floor")
+                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                    perimeter = st.number_input("Perimeter (m)", min_value=0.0, value=0.0, step=0.1)
+                with col2:
+                    floor_options = self.reference_data.data["floor_types"]
+                    selected_floor = st.selectbox("Floor Type", options=list(floor_options.keys()))
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(floor_options[selected_floor]["u_value"]), step=0.01)
+                    ground_contact = st.selectbox("Ground Contact", ["Yes", "No"], index=0 if floor_options[selected_floor]["ground_contact"] else 1)
+                    ground_temp = st.number_input("Ground Temperature (°C)", min_value=-10.0, max_value=40.0, value=25.0, step=0.1) if ground_contact == "Yes" else 25.0
+                    insulated = st.checkbox("Insulated Floor (e.g., R-10)", value=False)  # NEW: Insulation option
+
+                submitted = st.form_submit_button("Add Floor")
+                if submitted and not session_state.add_floor_submitted:
+                    try:
+                        new_floor = Floor(
+                            name=name, u_value=u_value, area=area, floor_type=selected_floor,
+                            ground_contact=(ground_contact == "Yes"), ground_temperature_c=ground_temp,
+                            perimeter=perimeter, insulated=insulated
+                        )
+                        self.component_library.add_component(new_floor)
+                        session_state.components['floors'].append(new_floor)
+                        st.success(f"Added {new_floor.name}")
+                        session_state.add_floor_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_floor_submitted:
+                session_state.add_floor_submitted = False
+
+        elif method == "File Upload":
+            uploaded_file = st.file_uploader("Upload Floors File", type=["csv", "xlsx"], key="floor_upload")
+            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact", "Ground Temperature (°C)", "Perimeter (m)", "Insulated"]  # NEW: Added Insulated
+            template_data = pd.DataFrame(columns=required_cols)
+            template_data.loc[0] = ["Example Floor", 10.0, 0.4, "Concrete Slab", "Yes", 25.0, 12.0, "No"]
+            st.download_button(label="Download Floor Template", data=template_data.to_csv(index=False), file_name="floor_template.csv", mime="text/csv")
+            if uploaded_file:
+                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
+                if all(col in df.columns for col in required_cols):
+                    for _, row in df.iterrows():
+                        try:
+                            insulated = str(row["Insulated"]).lower() in ["yes", "true", "1"]
+                            new_floor = Floor(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                floor_type=str(row["Floor Type"]), ground_contact=(str(row["Ground Contact"]).lower() == "yes"),
+                                ground_temperature_c=float(row["Ground Temperature (°C)"]), perimeter=float(row["Perimeter (m)"]),
+                                insulated=insulated
+                            )
+                            self.component_library.add_component(new_floor)
+                            session_state.components['floors'].append(new_floor)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Floors uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_window_form(self, session_state: Any) -> None:
+        st.write("Add windows manually or upload a file.")
+        method = st.radio("Add Window Method", ["Manual Entry", "File Upload"])
+        if "add_window_submitted" not in session_state:
+            session_state.add_window_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_window_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    name = st.text_input("Name", "New Window")
+                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
+                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
+                with col2:
+                    window_options = self.reference_data.data["window_types"]
+                    selected_window = st.selectbox("Window Type", options=list(window_options.keys()))
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(window_options[selected_window]["u_value"]), step=0.01)
+                    shading_options = {f"{k} (SC={v})": k for k, v in self.reference_data.data["shading_devices"].items()}
+                    shading_options["Custom"] = "Custom"
+                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
+                    shading_coefficient = st.number_input("Custom Shading Coefficient", min_value=0.0, max_value=1.0, value=1.0, step=0.05) if shading_device == "Custom" else self.reference_data.data["shading_devices"][shading_options[shading_device]]
+                    frame_type = st.selectbox("Frame Type", ["Aluminum", "Wood", "Vinyl"], index=0)
+                    frame_percentage = st.slider("Frame Percentage (%)", min_value=0.0, max_value=30.0, value=20.0)
+                    infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)
+
+                submitted = st.form_submit_button("Add Window")
+                if submitted and not session_state.add_window_submitted:
+                    try:
+                        new_window = Window(
+                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                            shgc=shgc, shading_device=shading_options[shading_device], shading_coefficient=shading_coefficient,
+                            frame_type=frame_type, frame_percentage=frame_percentage, infiltration_rate_cfm=infiltration_rate
+                        )
+                        self.component_library.add_component(new_window)
+                        session_state.components['windows'].append(new_window)
+                        st.success(f"Added {new_window.name}")
+                        session_state.add_window_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_window_submitted:
+                session_state.add_window_submitted = False
+
+        elif method == "File Upload":
+            uploaded_file = st.file_uploader("Upload Windows File", type=["csv", "xlsx"], key="window_upload")
+            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "SHGC", "Shading Device", "Shading Coefficient", "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)"]
+            st.download_button(label="Download Window Template", data=pd.DataFrame(columns=required_cols).to_csv(index=False), file_name="window_template.csv", mime="text/csv")
+            if uploaded_file:
+                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
+                if all(col in df.columns for col in required_cols):
+                    for _, row in df.iterrows():
+                        try:
+                            new_window = Window(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                orientation=Orientation(row["Orientation"]), shgc=float(row["SHGC"]),
+                                shading_device=str(row["Shading Device"]), shading_coefficient=float(row["Shading Coefficient"]),
+                                frame_type=str(row["Frame Type"]), frame_percentage=float(row["Frame Percentage"]),
+                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
+                            )
+                            self.component_library.add_component(new_window)
+                            session_state.components['windows'].append(new_window)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Windows uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_door_form(self, session_state: Any) -> None:
+        st.write("Add doors manually or upload a file.")
+        method = st.radio("Add Door Method", ["Manual Entry", "File Upload"])
+        if "add_door_submitted" not in session_state:
+            session_state.add_door_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_door_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    name = st.text_input("Name", "New Door")
+                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
+                with col2:
+                    door_options = self.reference_data.data["door_types"]
+                    selected_door = st.selectbox("Door Type", options=list(door_options.keys()))
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(door_options[selected_door]["u_value"]), step=0.01)
+                    infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)
+
+                submitted = st.form_submit_button("Add Door")
+                if submitted and not session_state.add_door_submitted:
+                    try:
+                        new_door = Door(
+                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                            door_type=selected_door, infiltration_rate_cfm=infiltration_rate
+                        )
+                        self.component_library.add_component(new_door)
+                        session_state.components['doors'].append(new_door)
+                        st.success(f"Added {new_door.name}")
+                        session_state.add_door_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_door_submitted:
+                session_state.add_door_submitted = False
+
+        elif method == "File Upload":
+            uploaded_file = st.file_uploader("Upload Doors File", type=["csv", "xlsx"], key="door_upload")
+            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type", "Infiltration Rate (CFM)"]
+            st.download_button(label="Download Door Template", data=pd.DataFrame(columns=required_cols).to_csv(index=False), file_name="door_template.csv", mime="text/csv")
+            if uploaded_file:
+                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
+                if all(col in df.columns for col in required_cols):
+                    for _, row in df.iterrows():
+                        try:
+                            new_door = Door(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                orientation=Orientation(row["Orientation"]), door_type=str(row["Door Type"]),
+                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
+                            )
+                            self.component_library.add_component(new_door)
+                            session_state.components['doors'].append(new_door)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Doors uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[BuildingComponent]) -> None:
+        type_name = component_type.value.lower()
+        if component_type == ComponentType.ROOF:
+            st.write(f"Roof Air Volume: {session_state.roof_air_volume_m3} m³, Ventilation Rate: {session_state.roof_ventilation_ach} ACH")
+
+        if components:
+            headers = {
+                ComponentType.WALL: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Absorptivity", "Shading Coefficient", "Infiltration Rate (CFM)", "Delete"],
+                ComponentType.ROOF: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Roof Type", "Roof Group", "Slope", "Absorptivity", "Delete"],
+                ComponentType.FLOOR: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact", "Ground Temperature (°C)", "Perimeter (m)", "Insulated", "Delete"],  # NEW: Added Insulated
+                ComponentType.WINDOW: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "SHGC", "Shading Device", "Shading Coefficient", "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)", "Delete"],
+                ComponentType.DOOR: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type", "Infiltration Rate (CFM)", "Delete"]
+            }[component_type]
+            cols = st.columns([1] * len(headers))
+            for i, header in enumerate(headers):
+                cols[i].write(f"**{header}**")
+
+            for comp in components:
+                cols = st.columns([1] * len(headers))
+                cols[0].write(comp.name)
+                cols[1].write(comp.area)
+                cols[2].write(comp.u_value)
+                cols[3].write(comp.orientation.value)
+                if component_type == ComponentType.WALL:
+                    cols[4].write(comp.wall_type)
+                    cols[5].write(comp.wall_group)
+                    cols[6].write(comp.absorptivity)
+                    cols[7].write(comp.shading_coefficient)
+                    cols[8].write(comp.infiltration_rate_cfm)
+                elif component_type == ComponentType.ROOF:
+                    cols[4].write(comp.roof_type)
+                    cols[5].write(comp.roof_group)
+                    cols[6].write(comp.slope)
+                    cols[7].write(comp.absorptivity)
+                elif component_type == ComponentType.FLOOR:
+                    cols[4].write(comp.floor_type)
+                    cols[5].write("Yes" if comp.ground_contact else "No")
+                    cols[6].write(comp.ground_temperature_c if comp.ground_contact else "N/A")
+                    cols[7].write(comp.perimeter)
+                    cols[8].write("Yes" if comp.insulated else "No")  # NEW: Display insulated
+                elif component_type == ComponentType.WINDOW:
+                    cols[4].write(comp.shgc)
+                    cols[5].write(comp.shading_device)
+                    cols[6].write(comp.shading_coefficient)
+                    cols[7].write(comp.frame_type)
+                    cols[8].write(comp.frame_percentage)
+                    cols[9].write(comp.infiltration_rate_cfm)
+                elif component_type == ComponentType.DOOR:
+                    cols[4].write(comp.door_type)
+                    cols[5].write(comp.infiltration_rate_cfm)
+                if cols[-1].button("Delete", key=f"delete_{comp.id}"):
+                    self.component_library.remove_component(comp.id)
+                    session_state.components[type_name + 's'] = [c for c in components if c.id != comp.id]
+                    st.success(f"Deleted {comp.name}")
+                    st.rerun()
+
+    def _display_u_value_calculator_tab(self, session_state: Any) -> None:
+        st.subheader("U-Value Calculator (Standalone)")
+        if "u_value_layers" not in session_state:
+            session_state.u_value_layers = []
+
+        if session_state.u_value_layers:
+            st.write("Material Layers (Outside to Inside):")
+            layer_data = [{"Layer": i+1, "Material": l["name"], "Thickness (mm)": l["thickness"], 
+                           "Conductivity (W/m·K)": l["conductivity"], "R-Value (m²·K/W)": l["thickness"] / 1000 / l["conductivity"]} 
+                          for i, l in enumerate(session_state.u_value_layers)]
+            st.dataframe(pd.DataFrame(layer_data))
+            outside_resistance = st.selectbox("Outside Resistance (m²·K/W)", ["Summer (0.04)", "Winter (0.03)", "Custom"], index=0)
+            outside_r = float(st.number_input("Custom Outside Resistance", min_value=0.0, value=0.04, step=0.01)) if outside_resistance == "Custom" else (0.04 if outside_resistance.startswith("Summer") else 0.03)
+            inside_r = st.number_input("Inside Resistance (m²·K/W)", min_value=0.0, value=0.13, step=0.01)
+            u_value = self.u_value_calculator.calculate_u_value(session_state.u_value_layers, outside_r, inside_r)
+            st.metric("U-Value", f"{u_value:.3f} W/m²·K")
+
+        with st.form("u_value_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                material_options = {m["name"]: m["conductivity"] for m in self.u_value_calculator.materials}
+                material_name = st.selectbox("Material", options=list(material_options.keys()))
+                conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=material_options[material_name], step=0.01)
+            with col2:
+                thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
+            submitted = st.form_submit_button("Add Layer")
+            if submitted:
+                session_state.u_value_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
+                st.rerun()
+
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Remove Last Layer"):
+                if session_state.u_value_layers:
+                    session_state.u_value_layers.pop()
+                    st.rerun()
+        with col2:
+            if st.button("Reset"):
+                session_state.u_value_layers = []
+                st.rerun()
+
+    def _save_components(self, session_state: Any) -> None:
+        components_dict = {
+            "walls": [c.to_dict() for c in session_state.components["walls"]],
+            "roofs": [c.to_dict() for c in session_state.components["roofs"]],
+            "floors": [c.to_dict() for c in session_state.components["floors"]],
+            "windows": [c.to_dict() for c in session_state.components["windows"]],
+            "doors": [c.to_dict() for c in session_state.components["doors"]],
+            "roof_air_volume_m3": session_state.roof_air_volume_m3,
+            "roof_ventilation_ach": session_state.roof_ventilation_ach
+        }
+        file_path = "components_export.json"
+        with open(file_path, 'w') as f:
+            json.dump(components_dict, f, indent=4)
+        with open(file_path, 'r') as f:
+            st.download_button(label="Download Components", data=f, file_name="components.json", mime="application/json")
+        st.success("Components saved successfully.")
+
+# --- Main Execution ---
+if __name__ == "__main__":
+    interface = ComponentSelectionInterface()
+    interface.display_component_selection(st.session_state)

app/data_export.py

@@ -0,0 +1,870 @@
+"""
+Data export module for HVAC Load Calculator.
+This module provides functionality for exporting calculation results.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Any, Optional, Tuple
+import json
+import os
+import base64
+import io
+from datetime import datetime
+import xlsxwriter
+
+
+class DataExport:
+    """Class for data export functionality."""
+    
+    @staticmethod
+    def export_to_csv(data: Dict[str, Any], file_path: str = None) -> Optional[str]:
+        """
+        Export data to CSV format.
+        
+        Args:
+            data: Dictionary with data to export
+            file_path: Optional path to save the CSV file
+            
+        Returns:
+            CSV string if file_path is None, otherwise None
+        """
+        try:
+            # Create DataFrame from data
+            df = pd.DataFrame(data)
+            
+            # Convert to CSV
+            csv_data = df.to_csv(index=False)
+            
+            # Save to file if path provided
+            if file_path:
+                df.to_csv(file_path, index=False)
+                return None
+            
+            # Return CSV string if no path provided
+            return csv_data
+        
+        except Exception as e:
+            st.error(f"Error exporting to CSV: {e}")
+            return None
+    
+    @staticmethod
+    def export_to_excel(data_dict: Dict[str, pd.DataFrame], file_path: str = None) -> Optional[bytes]:
+        """
+        Export data to Excel format.
+        
+        Args:
+            data_dict: Dictionary with sheet names and DataFrames
+            file_path: Optional path to save the Excel file
+            
+        Returns:
+            Excel bytes if file_path is None, otherwise None
+        """
+        try:
+            # Create Excel file in memory or on disk
+            if file_path:
+                writer = pd.ExcelWriter(file_path, engine='xlsxwriter')
+            else:
+                output = io.BytesIO()
+                writer = pd.ExcelWriter(output, engine='xlsxwriter')
+            
+            # Write each DataFrame to a different sheet
+            for sheet_name, df in data_dict.items():
+                df.to_excel(writer, sheet_name=sheet_name, index=False)
+                
+                # Auto-adjust column widths
+                worksheet = writer.sheets[sheet_name]
+                for i, col in enumerate(df.columns):
+                    max_width = max(
+                        df[col].astype(str).map(len).max(),
+                        len(col)
+                    ) + 2
+                    worksheet.set_column(i, i, max_width)
+            
+            # Save the Excel file
+            writer.close()
+            
+            # Return Excel bytes if no path provided
+            if not file_path:
+                output.seek(0)
+                return output.getvalue()
+            
+            return None
+        
+        except Exception as e:
+            st.error(f"Error exporting to Excel: {e}")
+            return None
+    
+    @staticmethod
+    def export_scenario_to_json(scenario: Dict[str, Any], file_path: str = None) -> Optional[str]:
+        """
+        Export scenario data to JSON format.
+        
+        Args:
+            scenario: Dictionary with scenario data
+            file_path: Optional path to save the JSON file
+            
+        Returns:
+            JSON string if file_path is None, otherwise None
+        """
+        try:
+            # Convert to JSON
+            json_data = json.dumps(scenario, indent=4)
+            
+            # Save to file if path provided
+            if file_path:
+                with open(file_path, "w") as f:
+                    f.write(json_data)
+                return None
+            
+            # Return JSON string if no path provided
+            return json_data
+        
+        except Exception as e:
+            st.error(f"Error exporting scenario to JSON: {e}")
+            return None
+    
+    @staticmethod
+    def get_download_link(data: Any, filename: str, text: str, mime_type: str = "text/csv") -> str:
+        """
+        Generate a download link for data.
+        
+        Args:
+            data: Data to download
+            filename: Name of the file to download
+            text: Text to display for the download link
+            mime_type: MIME type of the file
+            
+        Returns:
+            HTML string with download link
+        """
+        if isinstance(data, str):
+            b64 = base64.b64encode(data.encode()).decode()
+        else:
+            b64 = base64.b64encode(data).decode()
+        
+        href = f'<a href="data:{mime_type};base64,{b64}" download="{filename}">{text}</a>'
+        return href
+    
+    @staticmethod
+    def create_cooling_load_dataframes(results: Dict[str, Any]) -> Dict[str, pd.DataFrame]:
+        """
+        Create DataFrames for cooling load results.
+        
+        Args:
+            results: Dictionary with calculation results
+            
+        Returns:
+            Dictionary with DataFrames for Excel export
+        """
+        dataframes = {}
+        
+        # Create summary DataFrame
+        summary_data = {
+            "Metric": [
+                "Total Cooling Load",
+                "Sensible Cooling Load",
+                "Latent Cooling Load",
+                "Cooling Load per Area"
+            ],
+            "Value": [
+                results["cooling"]["total_load"],
+                results["cooling"]["sensible_load"],
+                results["cooling"]["latent_load"],
+                results["cooling"]["load_per_area"]
+            ],
+            "Unit": [
+                "kW",
+                "kW",
+                "kW",
+                "W/m²"
+            ]
+        }
+        
+        dataframes["Cooling Summary"] = pd.DataFrame(summary_data)
+        
+        # Create component breakdown DataFrame
+        component_data = {
+            "Component": [
+                "Walls",
+                "Roof",
+                "Windows",
+                "Doors",
+                "People",
+                "Lighting",
+                "Equipment",
+                "Infiltration",
+                "Ventilation"
+            ],
+            "Load (kW)": [
+                results["cooling"]["component_loads"]["walls"],
+                results["cooling"]["component_loads"]["roof"],
+                results["cooling"]["component_loads"]["windows"],
+                results["cooling"]["component_loads"]["doors"],
+                results["cooling"]["component_loads"]["people"],
+                results["cooling"]["component_loads"]["lighting"],
+                results["cooling"]["component_loads"]["equipment"],
+                results["cooling"]["component_loads"]["infiltration"],
+                results["cooling"]["component_loads"]["ventilation"]
+            ],
+            "Percentage (%)": [
+                results["cooling"]["component_loads"]["walls"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["roof"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["windows"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["doors"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["people"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["lighting"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["equipment"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["infiltration"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["ventilation"] / results["cooling"]["total_load"] * 100
+            ]
+        }
+        
+        dataframes["Cooling Components"] = pd.DataFrame(component_data)
+        
+        # Create detailed loads DataFrames
+        
+        # Walls
+        wall_data = []
+        for wall in results["cooling"]["detailed_loads"]["walls"]:
+            wall_data.append({
+                "Name": wall["name"],
+                "Orientation": wall["orientation"],
+                "Area (m²)": wall["area"],
+                "U-Value (W/m²·K)": wall["u_value"],
+                "CLTD (°C)": wall["cltd"],
+                "Load (kW)": wall["load"]
+            })
+        
+        if wall_data:
+            dataframes["Cooling Walls"] = pd.DataFrame(wall_data)
+        
+        # Roofs
+        roof_data = []
+        for roof in results["cooling"]["detailed_loads"]["roofs"]:
+            roof_data.append({
+                "Name": roof["name"],
+                "Orientation": roof["orientation"],
+                "Area (m²)": roof["area"],
+                "U-Value (W/m²·K)": roof["u_value"],
+                "CLTD (°C)": roof["cltd"],
+                "Load (kW)": roof["load"]
+            })
+        
+        if roof_data:
+            dataframes["Cooling Roofs"] = pd.DataFrame(roof_data)
+        
+        # Windows
+        window_data = []
+        for window in results["cooling"]["detailed_loads"]["windows"]:
+            window_data.append({
+                "Name": window["name"],
+                "Orientation": window["orientation"],
+                "Area (m²)": window["area"],
+                "U-Value (W/m²·K)": window["u_value"],
+                "SHGC": window["shgc"],
+                "SCL (W/m²)": window["scl"],
+                "Load (kW)": window["load"]
+            })
+        
+        if window_data:
+            dataframes["Cooling Windows"] = pd.DataFrame(window_data)
+        
+        # Doors
+        door_data = []
+        for door in results["cooling"]["detailed_loads"]["doors"]:
+            door_data.append({
+                "Name": door["name"],
+                "Orientation": door["orientation"],
+                "Area (m²)": door["area"],
+                "U-Value (W/m²·K)": door["u_value"],
+                "CLTD (°C)": door["cltd"],
+                "Load (kW)": door["load"]
+            })
+        
+        if door_data:
+            dataframes["Cooling Doors"] = pd.DataFrame(door_data)
+        
+        # Internal loads
+        internal_data = []
+        for internal_load in results["cooling"]["detailed_loads"]["internal"]:
+            internal_data.append({
+                "Type": internal_load["type"],
+                "Name": internal_load["name"],
+                "Quantity": internal_load["quantity"],
+                "Heat Gain (W)": internal_load["heat_gain"],
+                "CLF": internal_load["clf"],
+                "Load (kW)": internal_load["load"]
+            })
+        
+        if internal_data:
+            dataframes["Cooling Internal Loads"] = pd.DataFrame(internal_data)
+        
+        # Infiltration and ventilation
+        air_data = [
+            {
+                "Type": "Infiltration",
+                "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["infiltration"]["air_flow"],
+                "Sensible Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["sensible_load"],
+                "Latent Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["latent_load"],
+                "Total Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["total_load"]
+            },
+            {
+                "Type": "Ventilation",
+                "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["ventilation"]["air_flow"],
+                "Sensible Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["sensible_load"],
+                "Latent Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["latent_load"],
+                "Total Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["total_load"]
+            }
+        ]
+        
+        dataframes["Cooling Air Exchange"] = pd.DataFrame(air_data)
+        
+        return dataframes
+    
+    @staticmethod
+    def create_heating_load_dataframes(results: Dict[str, Any]) -> Dict[str, pd.DataFrame]:
+        """
+        Create DataFrames for heating load results.
+        
+        Args:
+            results: Dictionary with calculation results
+            
+        Returns:
+            Dictionary with DataFrames for Excel export
+        """
+        dataframes = {}
+        
+        # Create summary DataFrame
+        summary_data = {
+            "Metric": [
+                "Total Heating Load",
+                "Heating Load per Area",
+                "Design Heat Loss",
+                "Safety Factor"
+            ],
+            "Value": [
+                results["heating"]["total_load"],
+                results["heating"]["load_per_area"],
+                results["heating"]["design_heat_loss"],
+                results["heating"]["safety_factor"]
+            ],
+            "Unit": [
+                "kW",
+                "W/m²",
+                "kW",
+                "%"
+            ]
+        }
+        
+        dataframes["Heating Summary"] = pd.DataFrame(summary_data)
+        
+        # Create component breakdown DataFrame
+        component_data = {
+            "Component": [
+                "Walls",
+                "Roof",
+                "Floor",
+                "Windows",
+                "Doors",
+                "Infiltration",
+                "Ventilation"
+            ],
+            "Load (kW)": [
+                results["heating"]["component_loads"]["walls"],
+                results["heating"]["component_loads"]["roof"],
+                results["heating"]["component_loads"]["floor"],
+                results["heating"]["component_loads"]["windows"],
+                results["heating"]["component_loads"]["doors"],
+                results["heating"]["component_loads"]["infiltration"],
+                results["heating"]["component_loads"]["ventilation"]
+            ],
+            "Percentage (%)": [
+                results["heating"]["component_loads"]["walls"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["roof"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["floor"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["windows"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["doors"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["infiltration"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["ventilation"] / results["heating"]["total_load"] * 100
+            ]
+        }
+        
+        dataframes["Heating Components"] = pd.DataFrame(component_data)
+        
+        # Create detailed loads DataFrames
+        
+        # Walls
+        wall_data = []
+        for wall in results["heating"]["detailed_loads"]["walls"]:
+            wall_data.append({
+                "Name": wall["name"],
+                "Orientation": wall["orientation"],
+                "Area (m²)": wall["area"],
+                "U-Value (W/m²·K)": wall["u_value"],
+                "Temperature Difference (°C)": wall["delta_t"],
+                "Load (kW)": wall["load"]
+            })
+        
+        if wall_data:
+            dataframes["Heating Walls"] = pd.DataFrame(wall_data)
+        
+        # Roofs
+        roof_data = []
+        for roof in results["heating"]["detailed_loads"]["roofs"]:
+            roof_data.append({
+                "Name": roof["name"],
+                "Orientation": roof["orientation"],
+                "Area (m²)": roof["area"],
+                "U-Value (W/m²·K)": roof["u_value"],
+                "Temperature Difference (°C)": roof["delta_t"],
+                "Load (kW)": roof["load"]
+            })
+        
+        if roof_data:
+            dataframes["Heating Roofs"] = pd.DataFrame(roof_data)
+        
+        # Floors
+        floor_data = []
+        for floor in results["heating"]["detailed_loads"]["floors"]:
+            floor_data.append({
+                "Name": floor["name"],
+                "Area (m²)": floor["area"],
+                "U-Value (W/m²·K)": floor["u_value"],
+                "Temperature Difference (°C)": floor["delta_t"],
+                "Load (kW)": floor["load"]
+            })
+        
+        if floor_data:
+            dataframes["Heating Floors"] = pd.DataFrame(floor_data)
+        
+        # Windows
+        window_data = []
+        for window in results["heating"]["detailed_loads"]["windows"]:
+            window_data.append({
+                "Name": window["name"],
+                "Orientation": window["orientation"],
+                "Area (m²)": window["area"],
+                "U-Value (W/m²·K)": window["u_value"],
+                "Temperature Difference (°C)": window["delta_t"],
+                "Load (kW)": window["load"]
+            })
+        
+        if window_data:
+            dataframes["Heating Windows"] = pd.DataFrame(window_data)
+        
+        # Doors
+        door_data = []
+        for door in results["heating"]["detailed_loads"]["doors"]:
+            door_data.append({
+                "Name": door["name"],
+                "Orientation": door["orientation"],
+                "Area (m²)": door["area"],
+                "U-Value (W/m²·K)": door["u_value"],
+                "Temperature Difference (°C)": door["delta_t"],
+                "Load (kW)": door["load"]
+            })
+        
+        if door_data:
+            dataframes["Heating Doors"] = pd.DataFrame(door_data)
+        
+        # Infiltration and ventilation
+        air_data = [
+            {
+                "Type": "Infiltration",
+                "Air Flow (m³/s)": results["heating"]["detailed_loads"]["infiltration"]["air_flow"],
+                "Temperature Difference (°C)": results["heating"]["detailed_loads"]["infiltration"]["delta_t"],
+                "Load (kW)": results["heating"]["detailed_loads"]["infiltration"]["load"]
+            },
+            {
+                "Type": "Ventilation",
+                "Air Flow (m³/s)": results["heating"]["detailed_loads"]["ventilation"]["air_flow"],
+                "Temperature Difference (°C)": results["heating"]["detailed_loads"]["ventilation"]["delta_t"],
+                "Load (kW)": results["heating"]["detailed_loads"]["ventilation"]["load"]
+            }
+        ]
+        
+        dataframes["Heating Air Exchange"] = pd.DataFrame(air_data)
+        
+        return dataframes
+    
+    @staticmethod
+    def display_export_interface(session_state: Dict[str, Any]) -> None:
+        """
+        Display export interface in Streamlit.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.header("Export Results")
+        
+        # Check if calculations have been performed
+        if "calculation_results" not in session_state or not session_state["calculation_results"]:
+            st.warning("No calculation results available. Please run calculations first.")
+            return
+        
+        # Create tabs for different export options
+        tab1, tab2, tab3 = st.tabs(["CSV Export", "Excel Export", "Scenario Export"])
+        
+        with tab1:
+            DataExport._display_csv_export(session_state)
+        
+        with tab2:
+            DataExport._display_excel_export(session_state)
+        
+        with tab3:
+            DataExport._display_scenario_export(session_state)
+    
+    @staticmethod
+    def _display_csv_export(session_state: Dict[str, Any]) -> None:
+        """
+        Display CSV export interface.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("CSV Export")
+        
+        # Get results
+        results = session_state["calculation_results"]
+        
+        # Create tabs for cooling and heating loads
+        tab1, tab2 = st.tabs(["Cooling Load CSV", "Heating Load CSV"])
+        
+        with tab1:
+            # Create cooling load DataFrames
+            cooling_dfs = DataExport.create_cooling_load_dataframes(results)
+            
+            # Display and export each DataFrame
+            for sheet_name, df in cooling_dfs.items():
+                st.write(f"### {sheet_name}")
+                st.dataframe(df)
+                
+                # Add download button
+                csv_data = DataExport.export_to_csv(df)
+                if csv_data:
+                    filename = f"{sheet_name.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+                    download_link = DataExport.get_download_link(csv_data, filename, f"Download {sheet_name} CSV")
+                    st.markdown(download_link, unsafe_allow_html=True)
+        
+        with tab2:
+            # Create heating load DataFrames
+            heating_dfs = DataExport.create_heating_load_dataframes(results)
+            
+            # Display and export each DataFrame
+            for sheet_name, df in heating_dfs.items():
+                st.write(f"### {sheet_name}")
+                st.dataframe(df)
+                
+                # Add download button
+                csv_data = DataExport.export_to_csv(df)
+                if csv_data:
+                    filename = f"{sheet_name.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+                    download_link = DataExport.get_download_link(csv_data, filename, f"Download {sheet_name} CSV")
+                    st.markdown(download_link, unsafe_allow_html=True)
+    
+    @staticmethod
+    def _display_excel_export(session_state: Dict[str, Any]) -> None:
+        """
+        Display Excel export interface.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("Excel Export")
+        
+        # Get results
+        results = session_state["calculation_results"]
+        
+        # Create tabs for cooling, heating, and combined loads
+        tab1, tab2, tab3 = st.tabs(["Cooling Load Excel", "Heating Load Excel", "Combined Excel"])
+        
+        with tab1:
+            # Create cooling load DataFrames
+            cooling_dfs = DataExport.create_cooling_load_dataframes(results)
+            
+            # Add download button
+            excel_data = DataExport.export_to_excel(cooling_dfs)
+            if excel_data:
+                filename = f"cooling_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+                download_link = DataExport.get_download_link(
+                    excel_data,
+                    filename,
+                    "Download Cooling Load Excel",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+            
+            # Display preview
+            st.write("### Excel Preview")
+            st.write("The Excel file will contain the following sheets:")
+            for sheet_name in cooling_dfs.keys():
+                st.write(f"- {sheet_name}")
+        
+        with tab2:
+            # Create heating load DataFrames
+            heating_dfs = DataExport.create_heating_load_dataframes(results)
+            
+            # Add download button
+            excel_data = DataExport.export_to_excel(heating_dfs)
+            if excel_data:
+                filename = f"heating_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+                download_link = DataExport.get_download_link(
+                    excel_data,
+                    filename,
+                    "Download Heating Load Excel",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+            
+            # Display preview
+            st.write("### Excel Preview")
+            st.write("The Excel file will contain the following sheets:")
+            for sheet_name in heating_dfs.keys():
+                st.write(f"- {sheet_name}")
+        
+        with tab3:
+            # Create combined DataFrames
+            combined_dfs = {}
+            
+            # Add project information
+            if "building_info" in session_state:
+                project_info = [
+                    {"Parameter": "Project Name", "Value": session_state["building_info"].get("project_name", "")},
+                    {"Parameter": "Building Name", "Value": session_state["building_info"].get("building_name", "")},
+                    {"Parameter": "Location", "Value": session_state["building_info"].get("location", "")},
+                    {"Parameter": "Climate Zone", "Value": session_state["building_info"].get("climate_zone", "")},
+                    {"Parameter": "Building Type", "Value": session_state["building_info"].get("building_type", "")},
+                    {"Parameter": "Floor Area", "Value": session_state["building_info"].get("floor_area", "")},
+                    {"Parameter": "Number of Floors", "Value": session_state["building_info"].get("num_floors", "")},
+                    {"Parameter": "Floor Height", "Value": session_state["building_info"].get("floor_height", "")},
+                    {"Parameter": "Orientation", "Value": session_state["building_info"].get("orientation", "")},
+                    {"Parameter": "Occupancy", "Value": session_state["building_info"].get("occupancy", "")},
+                    {"Parameter": "Operating Hours", "Value": session_state["building_info"].get("operating_hours", "")},
+                    {"Parameter": "Date", "Value": datetime.now().strftime("%Y-%m-%d")},
+                    {"Parameter": "Time", "Value": datetime.now().strftime("%H:%M:%S")}
+                ]
+                
+                combined_dfs["Project Information"] = pd.DataFrame(project_info)
+            
+            # Add cooling load DataFrames
+            cooling_dfs = DataExport.create_cooling_load_dataframes(results)
+            for sheet_name, df in cooling_dfs.items():
+                combined_dfs[sheet_name] = df
+            
+            # Add heating load DataFrames
+            heating_dfs = DataExport.create_heating_load_dataframes(results)
+            for sheet_name, df in heating_dfs.items():
+                combined_dfs[sheet_name] = df
+            
+            # Add download button
+            excel_data = DataExport.export_to_excel(combined_dfs)
+            if excel_data:
+                filename = f"hvac_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+                download_link = DataExport.get_download_link(
+                    excel_data,
+                    filename,
+                    "Download Combined Excel Report",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+            
+            # Display preview
+            st.write("### Excel Preview")
+            st.write("The Excel file will contain the following sheets:")
+            for sheet_name in combined_dfs.keys():
+                st.write(f"- {sheet_name}")
+    
+    @staticmethod
+    def _display_scenario_export(session_state: Dict[str, Any]) -> None:
+        """
+        Display scenario export interface.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("Scenario Export")
+        
+        # Check if there are saved scenarios
+        if "saved_scenarios" not in session_state or not session_state["saved_scenarios"]:
+            st.info("No saved scenarios available for export. Save the current results as a scenario to enable export.")
+            
+            # Add button to save current results as a scenario
+            scenario_name = st.text_input("Scenario Name", value="Baseline")
+            
+            if st.button("Save Current Results as Scenario"):
+                if "saved_scenarios" not in session_state:
+                    session_state["saved_scenarios"] = {}
+                
+                # Save current results as a scenario
+                session_state["saved_scenarios"][scenario_name] = {
+                    "results": session_state["calculation_results"],
+                    "building_info": session_state["building_info"],
+                    "components": session_state["components"],
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                }
+                
+                st.success(f"Scenario '{scenario_name}' saved successfully!")
+                st.experimental_rerun()
+        else:
+            # Display saved scenarios
+            st.write("### Saved Scenarios")
+            
+            # Create selectbox for scenarios
+            scenario_names = list(session_state["saved_scenarios"].keys())
+            selected_scenario = st.selectbox("Select Scenario to Export", scenario_names)
+            
+            if selected_scenario:
+                # Get selected scenario
+                scenario = session_state["saved_scenarios"][selected_scenario]
+                
+                # Display scenario information
+                st.write(f"**Scenario:** {selected_scenario}")
+                st.write(f"**Timestamp:** {scenario['timestamp']}")
+                
+                # Add download button
+                json_data = DataExport.export_scenario_to_json(scenario)
+                if json_data:
+                    filename = f"{selected_scenario.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+                    download_link = DataExport.get_download_link(
+                        json_data,
+                        filename,
+                        "Download Scenario JSON",
+                        "application/json"
+                    )
+                    st.markdown(download_link, unsafe_allow_html=True)
+            
+            # Add button to export all scenarios
+            if st.button("Export All Scenarios"):
+                # Create a zip file in memory
+                import zipfile
+                from io import BytesIO
+                
+                zip_buffer = BytesIO()
+                with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+                    for scenario_name, scenario in session_state["saved_scenarios"].items():
+                        # Export scenario to JSON
+                        json_data = DataExport.export_scenario_to_json(scenario)
+                        if json_data:
+                            filename = f"{scenario_name.replace(' ', '_').lower()}.json"
+                            zip_file.writestr(filename, json_data)
+                
+                # Add download button for zip file
+                zip_buffer.seek(0)
+                zip_data = zip_buffer.getvalue()
+                
+                filename = f"all_scenarios_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+                download_link = DataExport.get_download_link(
+                    zip_data,
+                    filename,
+                    "Download All Scenarios (ZIP)",
+                    "application/zip"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+
+
+# Create a singleton instance
+data_export = DataExport()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Initialize session state with dummy data for testing
+    if "calculation_results" not in st.session_state:
+        st.session_state["calculation_results"] = {
+            "cooling": {
+                "total_load": 25.5,
+                "sensible_load": 20.0,
+                "latent_load": 5.5,
+                "load_per_area": 85.0,
+                "component_loads": {
+                    "walls": 5.0,
+                    "roof": 3.0,
+                    "windows": 8.0,
+                    "doors": 1.0,
+                    "people": 2.5,
+                    "lighting": 2.0,
+                    "equipment": 1.5,
+                    "infiltration": 1.0,
+                    "ventilation": 1.5
+                },
+                "detailed_loads": {
+                    "walls": [
+                        {"name": "North Wall", "orientation": "NORTH", "area": 20.0, "u_value": 0.5, "cltd": 10.0, "load": 1.0}
+                    ],
+                    "roofs": [
+                        {"name": "Main Roof", "orientation": "HORIZONTAL", "area": 100.0, "u_value": 0.3, "cltd": 15.0, "load": 3.0}
+                    ],
+                    "windows": [
+                        {"name": "South Window", "orientation": "SOUTH", "area": 10.0, "u_value": 2.8, "shgc": 0.7, "scl": 800.0, "load": 8.0}
+                    ],
+                    "doors": [
+                        {"name": "Main Door", "orientation": "NORTH", "area": 2.0, "u_value": 2.0, "cltd": 10.0, "load": 1.0}
+                    ],
+                    "internal": [
+                        {"type": "People", "name": "Occupants", "quantity": 10, "heat_gain": 250, "clf": 1.0, "load": 2.5},
+                        {"type": "Lighting", "name": "General Lighting", "quantity": 1000, "heat_gain": 2000, "clf": 1.0, "load": 2.0},
+                        {"type": "Equipment", "name": "Office Equipment", "quantity": 5, "heat_gain": 300, "clf": 1.0, "load": 1.5}
+                    ],
+                    "infiltration": {
+                        "air_flow": 0.05,
+                        "sensible_load": 0.8,
+                        "latent_load": 0.2,
+                        "total_load": 1.0
+                    },
+                    "ventilation": {
+                        "air_flow": 0.1,
+                        "sensible_load": 1.0,
+                        "latent_load": 0.5,
+                        "total_load": 1.5
+                    }
+                }
+            },
+            "heating": {
+                "total_load": 30.0,
+                "load_per_area": 100.0,
+                "design_heat_loss": 27.0,
+                "safety_factor": 10.0,
+                "component_loads": {
+                    "walls": 8.0,
+                    "roof": 5.0,
+                    "floor": 4.0,
+                    "windows": 7.0,
+                    "doors": 1.0,
+                    "infiltration": 2.0,
+                    "ventilation": 3.0
+                },
+                "detailed_loads": {
+                    "walls": [
+                        {"name": "North Wall", "orientation": "NORTH", "area": 20.0, "u_value": 0.5, "delta_t": 25.0, "load": 8.0}
+                    ],
+                    "roofs": [
+                        {"name": "Main Roof", "orientation": "HORIZONTAL", "area": 100.0, "u_value": 0.3, "delta_t": 25.0, "load": 5.0}
+                    ],
+                    "floors": [
+                        {"name": "Ground Floor", "area": 100.0, "u_value": 0.4, "delta_t": 10.0, "load": 4.0}
+                    ],
+                    "windows": [
+                        {"name": "South Window", "orientation": "SOUTH", "area": 10.0, "u_value": 2.8, "delta_t": 25.0, "load": 7.0}
+                    ],
+                    "doors": [
+                        {"name": "Main Door", "orientation": "NORTH", "area": 2.0, "u_value": 2.0, "delta_t": 25.0, "load": 1.0}
+                    ],
+                    "infiltration": {
+                        "air_flow": 0.05,
+                        "delta_t": 25.0,
+                        "load": 2.0
+                    },
+                    "ventilation": {
+                        "air_flow": 0.1,
+                        "delta_t": 25.0,
+                        "load": 3.0
+                    }
+                }
+            }
+        }
+    
+    # Display export interface
+    data_export.display_export_interface(st.session_state)

app/data_persistence.py

@@ -0,0 +1,540 @@
+"""
+Data persistence module for HVAC Load Calculator.
+This module provides functionality for saving and loading project data.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Any, Optional, Tuple
+import json
+import os
+import base64
+import io
+import pickle
+from datetime import datetime
+
+# Import data models
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+
+
+class DataPersistence:
+    """Class for data persistence functionality."""
+    
+    @staticmethod
+    def save_project_to_json(session_state: Dict[str, Any], file_path: str = None) -> Optional[str]:
+        """
+        Save project data to a JSON file.
+        
+        Args:
+            session_state: Streamlit session state containing project data
+            file_path: Optional path to save the JSON file
+            
+        Returns:
+            JSON string if file_path is None, otherwise None
+        """
+        try:
+            # Create project data dictionary
+            project_data = {
+                "building_info": session_state.get("building_info", {}),
+                "components": DataPersistence._serialize_components(session_state.get("components", {})),
+                "internal_loads": session_state.get("internal_loads", {}),
+                "calculation_settings": session_state.get("calculation_settings", {}),
+                "saved_scenarios": DataPersistence._serialize_scenarios(session_state.get("saved_scenarios", {})),
+                "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            }
+            
+            # Convert to JSON
+            json_data = json.dumps(project_data, indent=4)
+            
+            # Save to file if path provided
+            if file_path:
+                with open(file_path, "w") as f:
+                    f.write(json_data)
+                return None
+            
+            # Return JSON string if no path provided
+            return json_data
+        
+        except Exception as e:
+            st.error(f"Error saving project data: {e}")
+            return None
+    
+    @staticmethod
+    def load_project_from_json(json_data: str = None, file_path: str = None) -> Optional[Dict[str, Any]]:
+        """
+        Load project data from a JSON file or string.
+        
+        Args:
+            json_data: Optional JSON string containing project data
+            file_path: Optional path to the JSON file
+            
+        Returns:
+            Dictionary with project data if successful, None otherwise
+        """
+        try:
+            # Load from file if path provided
+            if file_path and not json_data:
+                with open(file_path, "r") as f:
+                    json_data = f.read()
+            
+            # Parse JSON data
+            if json_data:
+                project_data = json.loads(json_data)
+                
+                # Deserialize components
+                if "components" in project_data:
+                    project_data["components"] = DataPersistence._deserialize_components(project_data["components"])
+                
+                # Deserialize scenarios
+                if "saved_scenarios" in project_data:
+                    project_data["saved_scenarios"] = DataPersistence._deserialize_scenarios(project_data["saved_scenarios"])
+                
+                return project_data
+            
+            return None
+        
+        except Exception as e:
+            st.error(f"Error loading project data: {e}")
+            return None
+    
+    @staticmethod
+    def _serialize_components(components: Dict[str, List[Any]]) -> Dict[str, List[Dict[str, Any]]]:
+        """
+        Serialize components for JSON storage.
+        
+        Args:
+            components: Dictionary with building components
+            
+        Returns:
+            Dictionary with serialized components
+        """
+        serialized_components = {
+            "walls": [],
+            "roofs": [],
+            "floors": [],
+            "windows": [],
+            "doors": []
+        }
+        
+        # Serialize walls
+        for wall in components.get("walls", []):
+            serialized_wall = wall.__dict__.copy()
+            
+            # Convert enums to strings
+            if hasattr(serialized_wall["orientation"], "name"):
+                serialized_wall["orientation"] = serialized_wall["orientation"].name
+            
+            if hasattr(serialized_wall["component_type"], "name"):
+                serialized_wall["component_type"] = serialized_wall["component_type"].name
+            
+            serialized_components["walls"].append(serialized_wall)
+        
+        # Serialize roofs
+        for roof in components.get("roofs", []):
+            serialized_roof = roof.__dict__.copy()
+            
+            # Convert enums to strings
+            if hasattr(serialized_roof["orientation"], "name"):
+                serialized_roof["orientation"] = serialized_roof["orientation"].name
+            
+            if hasattr(serialized_roof["component_type"], "name"):
+                serialized_roof["component_type"] = serialized_roof["component_type"].name
+            
+            serialized_components["roofs"].append(serialized_roof)
+        
+        # Serialize floors
+        for floor in components.get("floors", []):
+            serialized_floor = floor.__dict__.copy()
+            
+            # Convert enums to strings
+            if hasattr(serialized_floor["component_type"], "name"):
+                serialized_floor["component_type"] = serialized_floor["component_type"].name
+            
+            serialized_components["floors"].append(serialized_floor)
+        
+        # Serialize windows
+        for window in components.get("windows", []):
+            serialized_window = window.__dict__.copy()
+            
+            # Convert enums to strings
+            if hasattr(serialized_window["orientation"], "name"):
+                serialized_window["orientation"] = serialized_window["orientation"].name
+            
+            if hasattr(serialized_window["component_type"], "name"):
+                serialized_window["component_type"] = serialized_window["component_type"].name
+            
+            serialized_components["windows"].append(serialized_window)
+        
+        # Serialize doors
+        for door in components.get("doors", []):
+            serialized_door = door.__dict__.copy()
+            
+            # Convert enums to strings
+            if hasattr(serialized_door["orientation"], "name"):
+                serialized_door["orientation"] = serialized_door["orientation"].name
+            
+            if hasattr(serialized_door["component_type"], "name"):
+                serialized_door["component_type"] = serialized_door["component_type"].name
+            
+            serialized_components["doors"].append(serialized_door)
+        
+        return serialized_components
+    
+    @staticmethod
+    def _deserialize_components(serialized_components: Dict[str, List[Dict[str, Any]]]) -> Dict[str, List[Any]]:
+        """
+        Deserialize components from JSON storage.
+        
+        Args:
+            serialized_components: Dictionary with serialized components
+            
+        Returns:
+            Dictionary with deserialized components
+        """
+        components = {
+            "walls": [],
+            "roofs": [],
+            "floors": [],
+            "windows": [],
+            "doors": []
+        }
+        
+        # Deserialize walls
+        for wall_dict in serialized_components.get("walls", []):
+            wall = Wall(
+                id=wall_dict.get("id", ""),
+                name=wall_dict.get("name", ""),
+                component_type=ComponentType[wall_dict.get("component_type", "WALL")],
+                u_value=wall_dict.get("u_value", 0.0),
+                area=wall_dict.get("area", 0.0),
+                orientation=Orientation[wall_dict.get("orientation", "NORTH")],
+                wall_type=wall_dict.get("wall_type", ""),
+                wall_group=wall_dict.get("wall_group", "")
+            )
+            components["walls"].append(wall)
+        
+        # Deserialize roofs
+        for roof_dict in serialized_components.get("roofs", []):
+            roof = Roof(
+                id=roof_dict.get("id", ""),
+                name=roof_dict.get("name", ""),
+                component_type=ComponentType[roof_dict.get("component_type", "ROOF")],
+                u_value=roof_dict.get("u_value", 0.0),
+                area=roof_dict.get("area", 0.0),
+                orientation=Orientation[roof_dict.get("orientation", "HORIZONTAL")],
+                roof_type=roof_dict.get("roof_type", ""),
+                roof_group=roof_dict.get("roof_group", "")
+            )
+            components["roofs"].append(roof)
+        
+        # Deserialize floors
+        for floor_dict in serialized_components.get("floors", []):
+            floor = Floor(
+                id=floor_dict.get("id", ""),
+                name=floor_dict.get("name", ""),
+                component_type=ComponentType[floor_dict.get("component_type", "FLOOR")],
+                u_value=floor_dict.get("u_value", 0.0),
+                area=floor_dict.get("area", 0.0),
+                floor_type=floor_dict.get("floor_type", "")
+            )
+            components["floors"].append(floor)
+        
+        # Deserialize windows
+        for window_dict in serialized_components.get("windows", []):
+            window = Window(
+                id=window_dict.get("id", ""),
+                name=window_dict.get("name", ""),
+                component_type=ComponentType[window_dict.get("component_type", "WINDOW")],
+                u_value=window_dict.get("u_value", 0.0),
+                area=window_dict.get("area", 0.0),
+                orientation=Orientation[window_dict.get("orientation", "NORTH")],
+                shgc=window_dict.get("shgc", 0.0),
+                vt=window_dict.get("vt", 0.0),
+                window_type=window_dict.get("window_type", ""),
+                glazing_layers=window_dict.get("glazing_layers", 1),
+                gas_fill=window_dict.get("gas_fill", ""),
+                low_e_coating=window_dict.get("low_e_coating", False)
+            )
+            components["windows"].append(window)
+        
+        # Deserialize doors
+        for door_dict in serialized_components.get("doors", []):
+            door = Door(
+                id=door_dict.get("id", ""),
+                name=door_dict.get("name", ""),
+                component_type=ComponentType[door_dict.get("component_type", "DOOR")],
+                u_value=door_dict.get("u_value", 0.0),
+                area=door_dict.get("area", 0.0),
+                orientation=Orientation[door_dict.get("orientation", "NORTH")],
+                door_type=door_dict.get("door_type", "")
+            )
+            components["doors"].append(door)
+        
+        return components
+    
+    @staticmethod
+    def _serialize_scenarios(scenarios: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+        """
+        Serialize scenarios for JSON storage.
+        
+        Args:
+            scenarios: Dictionary with saved scenarios
+            
+        Returns:
+            Dictionary with serialized scenarios
+        """
+        serialized_scenarios = {}
+        
+        for scenario_name, scenario_data in scenarios.items():
+            serialized_scenario = {
+                "results": scenario_data.get("results", {}),
+                "building_info": scenario_data.get("building_info", {}),
+                "components": DataPersistence._serialize_components(scenario_data.get("components", {})),
+                "timestamp": scenario_data.get("timestamp", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+            }
+            
+            serialized_scenarios[scenario_name] = serialized_scenario
+        
+        return serialized_scenarios
+    
+    @staticmethod
+    def _deserialize_scenarios(serialized_scenarios: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+        """
+        Deserialize scenarios from JSON storage.
+        
+        Args:
+            serialized_scenarios: Dictionary with serialized scenarios
+            
+        Returns:
+            Dictionary with deserialized scenarios
+        """
+        scenarios = {}
+        
+        for scenario_name, serialized_scenario in serialized_scenarios.items():
+            scenario = {
+                "results": serialized_scenario.get("results", {}),
+                "building_info": serialized_scenario.get("building_info", {}),
+                "components": DataPersistence._deserialize_components(serialized_scenario.get("components", {})),
+                "timestamp": serialized_scenario.get("timestamp", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+            }
+            
+            scenarios[scenario_name] = scenario
+        
+        return scenarios
+    
+    @staticmethod
+    def get_download_link(data: str, filename: str, text: str) -> str:
+        """
+        Generate a download link for data.
+        
+        Args:
+            data: Data to download
+            filename: Name of the file to download
+            text: Text to display for the download link
+            
+        Returns:
+            HTML string with download link
+        """
+        b64 = base64.b64encode(data.encode()).decode()
+        href = f'<a href="data:file/txt;base64,{b64}" download="{filename}">{text}</a>'
+        return href
+    
+    @staticmethod
+    def display_project_management(session_state: Dict[str, Any]) -> None:
+        """
+        Display project management interface in Streamlit.
+        
+        Args:
+            session_state: Streamlit session state containing project data
+        """
+        st.header("Project Management")
+        
+        # Create tabs for different project management functions
+        tab1, tab2, tab3 = st.tabs(["Save Project", "Load Project", "Project History"])
+        
+        with tab1:
+            DataPersistence._display_save_project(session_state)
+        
+        with tab2:
+            DataPersistence._display_load_project(session_state)
+        
+        with tab3:
+            DataPersistence._display_project_history(session_state)
+    
+    @staticmethod
+    def _display_save_project(session_state: Dict[str, Any]) -> None:
+        """
+        Display save project interface.
+        
+        Args:
+            session_state: Streamlit session state containing project data
+        """
+        st.subheader("Save Project")
+        
+        # Get project name
+        project_name = st.text_input(
+            "Project Name",
+            value=session_state.get("building_info", {}).get("project_name", "HVAC_Project"),
+            key="save_project_name"
+        )
+        
+        # Add description
+        project_description = st.text_area(
+            "Project Description",
+            value=session_state.get("project_description", ""),
+            key="save_project_description"
+        )
+        
+        # Save project description
+        session_state["project_description"] = project_description
+        
+        # Add save button
+        if st.button("Save Project"):
+            # Validate project data
+            if "building_info" not in session_state or not session_state["building_info"]:
+                st.error("No building information found. Please enter building information before saving.")
+                return
+            
+            if "components" not in session_state or not any(session_state["components"].values()):
+                st.warning("No building components found. It's recommended to add components before saving.")
+            
+            # Save project data to JSON
+            json_data = DataPersistence.save_project_to_json(session_state)
+            
+            if json_data:
+                # Generate download link
+                filename = f"{project_name.replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.hvac"
+                download_link = DataPersistence.get_download_link(json_data, filename, "Download Project File")
+                
+                # Display download link
+                st.success("Project saved successfully!")
+                st.markdown(download_link, unsafe_allow_html=True)
+                
+                # Save to project history
+                if "project_history" not in session_state:
+                    session_state["project_history"] = []
+                
+                session_state["project_history"].append({
+                    "name": project_name,
+                    "description": project_description,
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    "data": json_data
+                })
+            else:
+                st.error("Error saving project data.")
+    
+    @staticmethod
+    def _display_load_project(session_state: Dict[str, Any]) -> None:
+        """
+        Display load project interface.
+        
+        Args:
+            session_state: Streamlit session state containing project data
+        """
+        st.subheader("Load Project")
+        
+        # Add file uploader
+        uploaded_file = st.file_uploader("Upload Project File", type=["hvac", "json"])
+        
+        if uploaded_file is not None:
+            # Read file content
+            json_data = uploaded_file.read().decode("utf-8")
+            
+            # Load project data
+            project_data = DataPersistence.load_project_from_json(json_data)
+            
+            if project_data:
+                # Add load button
+                if st.button("Load Project Data"):
+                    # Update session state with project data
+                    for key, value in project_data.items():
+                        session_state[key] = value
+                    
+                    st.success("Project loaded successfully!")
+                    st.experimental_rerun()
+            else:
+                st.error("Error loading project data. Invalid file format.")
+    
+    @staticmethod
+    def _display_project_history(session_state: Dict[str, Any]) -> None:
+        """
+        Display project history interface.
+        
+        Args:
+            session_state: Streamlit session state containing project data
+        """
+        st.subheader("Project History")
+        
+        # Check if project history exists
+        if "project_history" not in session_state or not session_state["project_history"]:
+            st.info("No project history found. Save a project to see it in the history.")
+            return
+        
+        # Display project history
+        for i, project in enumerate(reversed(session_state["project_history"])):
+            with st.expander(f"{project['name']} - {project['timestamp']}"):
+                st.write(f"**Description:** {project['description']}")
+                
+                # Add load button
+                if st.button(f"Load Project", key=f"load_history_{i}"):
+                    # Load project data
+                    project_data = DataPersistence.load_project_from_json(project["data"])
+                    
+                    if project_data:
+                        # Update session state with project data
+                        for key, value in project_data.items():
+                            session_state[key] = value
+                        
+                        st.success("Project loaded successfully!")
+                        st.experimental_rerun()
+                
+                # Add download button
+                filename = f"{project['name'].replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.hvac"
+                download_link = DataPersistence.get_download_link(project["data"], filename, "Download Project File")
+                st.markdown(download_link, unsafe_allow_html=True)
+                
+                # Add delete button
+                if st.button(f"Delete from History", key=f"delete_history_{i}"):
+                    # Remove project from history
+                    session_state["project_history"].remove(project)
+                    
+                    st.success("Project removed from history.")
+                    st.experimental_rerun()
+
+
+# Create a singleton instance
+data_persistence = DataPersistence()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Initialize session state with dummy data for testing
+    if "building_info" not in st.session_state:
+        st.session_state["building_info"] = {
+            "project_name": "Test Project",
+            "building_name": "Test Building",
+            "location": "New York",
+            "climate_zone": "4A",
+            "building_type": "Office",
+            "floor_area": 1000.0,
+            "num_floors": 2,
+            "floor_height": 3.0,
+            "orientation": "NORTH",
+            "occupancy": 50,
+            "operating_hours": "8:00-18:00",
+            "design_conditions": {
+                "summer_outdoor_db": 35.0,
+                "summer_outdoor_wb": 25.0,
+                "summer_indoor_db": 24.0,
+                "summer_indoor_rh": 50.0,
+                "winter_outdoor_db": -5.0,
+                "winter_outdoor_rh": 80.0,
+                "winter_indoor_db": 21.0,
+                "winter_indoor_rh": 40.0
+            }
+        }
+    
+    # Display project management interface
+    data_persistence.display_project_management(st.session_state)

app/data_validation.py

@@ -0,0 +1,494 @@
+"""
+Data validation module for HVAC Load Calculator.
+This module provides validation functions for user inputs.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Any, Optional, Tuple, Callable
+import json
+import os
+
+
+class DataValidation:
+    """Class for data validation functionality."""
+    
+    @staticmethod
+    def validate_building_info(building_info: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        """
+        Validate building information inputs.
+        
+        Args:
+            building_info: Dictionary with building information
+            
+        Returns:
+            Tuple containing validation result (True if valid) and list of validation messages
+        """
+        is_valid = True
+        messages = []
+        
+        # Check required fields
+        required_fields = [
+            ("project_name", "Project Name"),
+            ("building_name", "Building Name"),
+            ("location", "Location"),
+            ("climate_zone", "Climate Zone"),
+            ("building_type", "Building Type")
+        ]
+        
+        for field, display_name in required_fields:
+            if field not in building_info or not building_info[field]:
+                is_valid = False
+                messages.append(f"{display_name} is required.")
+        
+        # Check numeric fields
+        numeric_fields = [
+            ("floor_area", "Floor Area", 0, None),
+            ("num_floors", "Number of Floors", 1, None),
+            ("floor_height", "Floor Height", 2.0, 10.0),
+            ("occupancy", "Occupancy", 0, None)
+        ]
+        
+        for field, display_name, min_val, max_val in numeric_fields:
+            if field in building_info:
+                try:
+                    value = float(building_info[field])
+                    if min_val is not None and value < min_val:
+                        is_valid = False
+                        messages.append(f"{display_name} must be at least {min_val}.")
+                    if max_val is not None and value > max_val:
+                        is_valid = False
+                        messages.append(f"{display_name} must be at most {max_val}.")
+                except (ValueError, TypeError):
+                    is_valid = False
+                    messages.append(f"{display_name} must be a number.")
+        
+        # Check design conditions
+        if "design_conditions" in building_info:
+            design_conditions = building_info["design_conditions"]
+            
+            # Check summer conditions
+            summer_fields = [
+                ("summer_outdoor_db", "Summer Outdoor Dry-Bulb", -10.0, 50.0),
+                ("summer_outdoor_wb", "Summer Outdoor Wet-Bulb", -10.0, 40.0),
+                ("summer_indoor_db", "Summer Indoor Dry-Bulb", 18.0, 30.0),
+                ("summer_indoor_rh", "Summer Indoor RH", 30.0, 70.0)
+            ]
+            
+            for field, display_name, min_val, max_val in summer_fields:
+                if field in design_conditions:
+                    try:
+                        value = float(design_conditions[field])
+                        if min_val is not None and value < min_val:
+                            is_valid = False
+                            messages.append(f"{display_name} must be at least {min_val}.")
+                        if max_val is not None and value > max_val:
+                            is_valid = False
+                            messages.append(f"{display_name} must be at most {max_val}.")
+                    except (ValueError, TypeError):
+                        is_valid = False
+                        messages.append(f"{display_name} must be a number.")
+            
+            # Check winter conditions
+            winter_fields = [
+                ("winter_outdoor_db", "Winter Outdoor Dry-Bulb", -40.0, 20.0),
+                ("winter_outdoor_rh", "Winter Outdoor RH", 0.0, 100.0),
+                ("winter_indoor_db", "Winter Indoor Dry-Bulb", 18.0, 25.0),
+                ("winter_indoor_rh", "Winter Indoor RH", 20.0, 60.0)
+            ]
+            
+            for field, display_name, min_val, max_val in winter_fields:
+                if field in design_conditions:
+                    try:
+                        value = float(design_conditions[field])
+                        if min_val is not None and value < min_val:
+                            is_valid = False
+                            messages.append(f"{display_name} must be at least {min_val}.")
+                        if max_val is not None and value > max_val:
+                            is_valid = False
+                            messages.append(f"{display_name} must be at most {max_val}.")
+                    except (ValueError, TypeError):
+                        is_valid = False
+                        messages.append(f"{display_name} must be a number.")
+            
+            # Check that wet-bulb is less than dry-bulb
+            if "summer_outdoor_db" in design_conditions and "summer_outdoor_wb" in design_conditions:
+                try:
+                    db = float(design_conditions["summer_outdoor_db"])
+                    wb = float(design_conditions["summer_outdoor_wb"])
+                    if wb > db:
+                        is_valid = False
+                        messages.append("Summer Outdoor Wet-Bulb temperature must be less than or equal to Dry-Bulb temperature.")
+                except (ValueError, TypeError):
+                    pass  # Already handled above
+        
+        return is_valid, messages
+    
+    @staticmethod
+    def validate_components(components: Dict[str, List[Any]]) -> Tuple[bool, List[str]]:
+        """
+        Validate building components.
+        
+        Args:
+            components: Dictionary with building components
+            
+        Returns:
+            Tuple containing validation result (True if valid) and list of validation messages
+        """
+        is_valid = True
+        messages = []
+        
+        # Check if any components exist
+        if not any(components.values()):
+            is_valid = False
+            messages.append("At least one building component (wall, roof, floor, window, or door) is required.")
+        
+        # Check wall components
+        for i, wall in enumerate(components.get("walls", [])):
+            # Check required fields
+            if not wall.name:
+                is_valid = False
+                messages.append(f"Wall #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if wall.area <= 0:
+                is_valid = False
+                messages.append(f"Wall #{i+1}: Area must be greater than zero.")
+            
+            if wall.u_value <= 0:
+                is_valid = False
+                messages.append(f"Wall #{i+1}: U-value must be greater than zero.")
+        
+        # Check roof components
+        for i, roof in enumerate(components.get("roofs", [])):
+            # Check required fields
+            if not roof.name:
+                is_valid = False
+                messages.append(f"Roof #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if roof.area <= 0:
+                is_valid = False
+                messages.append(f"Roof #{i+1}: Area must be greater than zero.")
+            
+            if roof.u_value <= 0:
+                is_valid = False
+                messages.append(f"Roof #{i+1}: U-value must be greater than zero.")
+        
+        # Check floor components
+        for i, floor in enumerate(components.get("floors", [])):
+            # Check required fields
+            if not floor.name:
+                is_valid = False
+                messages.append(f"Floor #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if floor.area <= 0:
+                is_valid = False
+                messages.append(f"Floor #{i+1}: Area must be greater than zero.")
+            
+            if floor.u_value <= 0:
+                is_valid = False
+                messages.append(f"Floor #{i+1}: U-value must be greater than zero.")
+        
+        # Check window components
+        for i, window in enumerate(components.get("windows", [])):
+            # Check required fields
+            if not window.name:
+                is_valid = False
+                messages.append(f"Window #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if window.area <= 0:
+                is_valid = False
+                messages.append(f"Window #{i+1}: Area must be greater than zero.")
+            
+            if window.u_value <= 0:
+                is_valid = False
+                messages.append(f"Window #{i+1}: U-value must be greater than zero.")
+            
+            if window.shgc <= 0 or window.shgc > 1:
+                is_valid = False
+                messages.append(f"Window #{i+1}: SHGC must be between 0 and 1.")
+        
+        # Check door components
+        for i, door in enumerate(components.get("doors", [])):
+            # Check required fields
+            if not door.name:
+                is_valid = False
+                messages.append(f"Door #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if door.area <= 0:
+                is_valid = False
+                messages.append(f"Door #{i+1}: Area must be greater than zero.")
+            
+            if door.u_value <= 0:
+                is_valid = False
+                messages.append(f"Door #{i+1}: U-value must be greater than zero.")
+        
+        # Check for minimum requirements
+        if not components.get("walls", []):
+            messages.append("Warning: No walls defined. At least one wall is recommended.")
+        
+        if not components.get("roofs", []):
+            messages.append("Warning: No roofs defined. At least one roof is recommended.")
+        
+        if not components.get("floors", []):
+            messages.append("Warning: No floors defined. At least one floor is recommended.")
+        
+        return is_valid, messages
+    
+    @staticmethod
+    def validate_internal_loads(internal_loads: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        """
+        Validate internal loads inputs.
+        
+        Args:
+            internal_loads: Dictionary with internal loads information
+            
+        Returns:
+            Tuple containing validation result (True if valid) and list of validation messages
+        """
+        is_valid = True
+        messages = []
+        
+        # Check people loads
+        people = internal_loads.get("people", [])
+        for i, person in enumerate(people):
+            # Check required fields
+            if not person.get("name"):
+                is_valid = False
+                messages.append(f"People Load #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if person.get("num_people", 0) < 0:
+                is_valid = False
+                messages.append(f"People Load #{i+1}: Number of people must be non-negative.")
+            
+            if person.get("hours_in_operation", 0) <= 0:
+                is_valid = False
+                messages.append(f"People Load #{i+1}: Hours in operation must be positive.")
+        
+        # Check lighting loads
+        lighting = internal_loads.get("lighting", [])
+        for i, light in enumerate(lighting):
+            # Check required fields
+            if not light.get("name"):
+                is_valid = False
+                messages.append(f"Lighting Load #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if light.get("power", 0) < 0:
+                is_valid = False
+                messages.append(f"Lighting Load #{i+1}: Power must be non-negative.")
+            
+            if light.get("usage_factor", 0) < 0 or light.get("usage_factor", 0) > 1:
+                is_valid = False
+                messages.append(f"Lighting Load #{i+1}: Usage factor must be between 0 and 1.")
+            
+            if light.get("hours_in_operation", 0) <= 0:
+                is_valid = False
+                messages.append(f"Lighting Load #{i+1}: Hours in operation must be positive.")
+        
+        # Check equipment loads
+        equipment = internal_loads.get("equipment", [])
+        for i, equip in enumerate(equipment):
+            # Check required fields
+            if not equip.get("name"):
+                is_valid = False
+                messages.append(f"Equipment Load #{i+1}: Name is required.")
+            
+            # Check numeric fields
+            if equip.get("power", 0) < 0:
+                is_valid = False
+                messages.append(f"Equipment Load #{i+1}: Power must be non-negative.")
+            
+            if equip.get("usage_factor", 0) < 0 or equip.get("usage_factor", 0) > 1:
+                is_valid = False
+                messages.append(f"Equipment Load #{i+1}: Usage factor must be between 0 and 1.")
+            
+            if equip.get("radiation_fraction", 0) < 0 or equip.get("radiation_fraction", 0) > 1:
+                is_valid = False
+                messages.append(f"Equipment Load #{i+1}: Radiation fraction must be between 0 and 1.")
+            
+            if equip.get("hours_in_operation", 0) <= 0:
+                is_valid = False
+                messages.append(f"Equipment Load #{i+1}: Hours in operation must be positive.")
+        
+        return is_valid, messages
+    
+    @staticmethod
+    def validate_calculation_settings(settings: Dict[str, Any]) -> Tuple[bool, List[str]]:
+        """
+        Validate calculation settings.
+        
+        Args:
+            settings: Dictionary with calculation settings
+            
+        Returns:
+            Tuple containing validation result (True if valid) and list of validation messages
+        """
+        is_valid = True
+        messages = []
+        
+        # Check infiltration rate
+        if "infiltration_rate" in settings:
+            try:
+                infiltration_rate = float(settings["infiltration_rate"])
+                if infiltration_rate < 0:
+                    is_valid = False
+                    messages.append("Infiltration rate must be non-negative.")
+            except (ValueError, TypeError):
+                is_valid = False
+                messages.append("Infiltration rate must be a number.")
+        
+        # Check ventilation rate
+        if "ventilation_rate" in settings:
+            try:
+                ventilation_rate = float(settings["ventilation_rate"])
+                if ventilation_rate < 0:
+                    is_valid = False
+                    messages.append("Ventilation rate must be non-negative.")
+            except (ValueError, TypeError):
+                is_valid = False
+                messages.append("Ventilation rate must be a number.")
+        
+        # Check safety factors
+        safety_factors = ["cooling_safety_factor", "heating_safety_factor"]
+        for factor in safety_factors:
+            if factor in settings:
+                try:
+                    value = float(settings[factor])
+                    if value < 0:
+                        is_valid = False
+                        messages.append(f"{factor.replace('_', ' ').title()} must be non-negative.")
+                except (ValueError, TypeError):
+                    is_valid = False
+                    messages.append(f"{factor.replace('_', ' ').title()} must be a number.")
+        
+        return is_valid, messages
+    
+    @staticmethod
+    def display_validation_messages(messages: List[str], container=None) -> None:
+        """
+        Display validation messages in Streamlit.
+        
+        Args:
+            messages: List of validation messages
+            container: Optional Streamlit container to display messages in
+        """
+        if not messages:
+            return
+        
+        # Separate errors and warnings
+        errors = [msg for msg in messages if not msg.startswith("Warning:")]
+        warnings = [msg for msg in messages if msg.startswith("Warning:")]
+        
+        # Use provided container or st directly
+        display = container if container is not None else st
+        
+        # Display errors
+        if errors:
+            error_msg = "Please fix the following errors:\n" + "\n".join([f"- {msg}" for msg in errors])
+            display.error(error_msg)
+        
+        # Display warnings
+        if warnings:
+            warning_msg = "Warnings:\n" + "\n".join([f"- {msg[8:]}" for msg in warnings])
+            display.warning(warning_msg)
+    
+    @staticmethod
+    def validate_and_proceed(
+        session_state: Dict[str, Any],
+        validation_function: Callable[[Dict[str, Any]], Tuple[bool, List[str]]],
+        data_key: str,
+        success_message: str = "Validation successful!",
+        proceed_callback: Optional[Callable] = None
+    ) -> bool:
+        """
+        Validate data and proceed if valid.
+        
+        Args:
+            session_state: Streamlit session state
+            validation_function: Function to validate data
+            data_key: Key for data in session state
+            success_message: Message to display on success
+            proceed_callback: Optional callback function to execute if validation succeeds
+            
+        Returns:
+            Boolean indicating whether validation succeeded
+        """
+        if data_key not in session_state:
+            st.error(f"No {data_key.replace('_', ' ').title()} data found.")
+            return False
+        
+        # Validate data
+        is_valid, messages = validation_function(session_state[data_key])
+        
+        # Display validation messages
+        DataValidation.display_validation_messages(messages)
+        
+        # Proceed if valid
+        if is_valid:
+            st.success(success_message)
+            
+            # Execute callback if provided
+            if proceed_callback is not None:
+                proceed_callback()
+            
+            return True
+        
+        return False
+
+
+# Create a singleton instance
+data_validation = DataValidation()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Initialize session state with dummy data for testing
+    if "building_info" not in st.session_state:
+        st.session_state["building_info"] = {
+            "project_name": "Test Project",
+            "building_name": "Test Building",
+            "location": "New York",
+            "climate_zone": "4A",
+            "building_type": "Office",
+            "floor_area": 1000.0,
+            "num_floors": 2,
+            "floor_height": 3.0,
+            "orientation": "NORTH",
+            "occupancy": 50,
+            "operating_hours": "8:00-18:00",
+            "design_conditions": {
+                "summer_outdoor_db": 35.0,
+                "summer_outdoor_wb": 25.0,
+                "summer_indoor_db": 24.0,
+                "summer_indoor_rh": 50.0,
+                "winter_outdoor_db": -5.0,
+                "winter_outdoor_rh": 80.0,
+                "winter_indoor_db": 21.0,
+                "winter_indoor_rh": 40.0
+            }
+        }
+    
+    # Test validation
+    st.header("Test Building Information Validation")
+    
+    # Add some invalid data for testing
+    if st.button("Make Data Invalid"):
+        st.session_state["building_info"]["floor_area"] = -100.0
+        st.session_state["building_info"]["design_conditions"]["summer_outdoor_wb"] = 40.0
+    
+    # Validate building info
+    if st.button("Validate Building Info"):
+        data_validation.validate_and_proceed(
+            st.session_state,
+            data_validation.validate_building_info,
+            "building_info",
+            "Building information is valid!"
+        )

app/main.py

@@ -0,0 +1,1205 @@
+"""
+HVAC Calculator Code Documentation
+Updated 2025-04-27: Enhanced climate ID generation, input validation, debug mode, and error handling.
+Updated 2025-04-28: Added activity-level-based internal gains, ground temperature validation, ASHRAE 62.1 ventilation rates, negative load prevention, and improved usability.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import json
+import pycountry
+import os
+import sys
+from typing import Dict, List, Any, Optional, Tuple
+
+# Import application modules
+from app.building_info_form import BuildingInfoForm
+from app.component_selection import ComponentSelectionInterface, Orientation, ComponentType, Wall, Roof, Floor, Window, Door
+from app.results_display import ResultsDisplay
+from app.data_validation import DataValidation
+from app.data_persistence import DataPersistence
+from app.data_export import DataExport
+
+# Import data modules
+from data.reference_data import ReferenceData
+from data.climate_data import ClimateData, ClimateLocation
+from data.ashrae_tables import ASHRAETables
+from data.building_components import Wall as WallModel, Roof as RoofModel
+
+# Import utility modules
+from utils.u_value_calculator import UValueCalculator
+from utils.shading_system import ShadingSystem
+from utils.area_calculation_system import AreaCalculationSystem
+from utils.psychrometrics import Psychrometrics
+from utils.heat_transfer import HeatTransferCalculations
+from utils.cooling_load import CoolingLoadCalculator
+from utils.heating_load import HeatingLoadCalculator
+from utils.component_visualization import ComponentVisualization
+from utils.scenario_comparison import ScenarioComparisonVisualization
+from utils.psychrometric_visualization import PsychrometricVisualization
+from utils.time_based_visualization import TimeBasedVisualization
+
+# NEW: ASHRAE 62.1 Ventilation Rates (Table 6.1)
+VENTILATION_RATES = {
+    "Office": {"people_rate": 2.5, "area_rate": 0.3},  # L/s/person, L/s/m²
+    "Classroom": {"people_rate": 5.0, "area_rate": 0.9},
+    "Retail": {"people_rate": 3.8, "area_rate": 0.9},
+    "Restaurant": {"people_rate": 5.0, "area_rate": 1.8},
+    "Custom": {"people_rate": 0.0, "area_rate": 0.0}
+}
+
+class HVACCalculator:
+    def __init__(self):
+        st.set_page_config(
+            page_title="HVAC Load Calculator",
+            page_icon="🌡️",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
+        
+        # Initialize session state
+        if 'page' not in st.session_state:
+            st.session_state.page = 'Building Information'
+        
+        if 'building_info' not in st.session_state:
+            st.session_state.building_info = {"project_name": ""}
+        
+        if 'components' not in st.session_state:
+            st.session_state.components = {
+                'walls': [],
+                'roofs': [],
+                'floors': [],
+                'windows': [],
+                'doors': []
+            }
+        
+        if 'internal_loads' not in st.session_state:
+            st.session_state.internal_loads = {
+                'people': [],
+                'lighting': [],
+                'equipment': []
+            }
+        
+        if 'calculation_results' not in st.session_state:
+            st.session_state.calculation_results = {
+                'cooling': {},
+                'heating': {}
+            }
+        
+        if 'saved_scenarios' not in st.session_state:
+            st.session_state.saved_scenarios = {}
+        
+        if 'climate_data' not in st.session_state:
+            st.session_state.climate_data = {}
+        
+        if 'debug_mode' not in st.session_state:
+            st.session_state.debug_mode = False
+        
+        # Initialize modules
+        self.building_info_form = BuildingInfoForm()
+        self.component_selection = ComponentSelectionInterface()
+        self.results_display = ResultsDisplay()
+        self.data_validation = DataValidation()
+        self.data_persistence = DataPersistence()
+        self.data_export = DataExport()
+        self.cooling_calculator = CoolingLoadCalculator()
+        self.heating_calculator = HeatingLoadCalculator()
+        
+        # Persist ClimateData in session_state
+        if 'climate_data_obj' not in st.session_state:
+            st.session_state.climate_data_obj = ClimateData()
+        self.climate_data = st.session_state.climate_data_obj
+        
+        # Load default climate data if locations are empty
+        try:
+            if not self.climate_data.locations:
+                self.climate_data = ClimateData.from_json("/home/user/app/climate_data.json")
+                st.session_state.climate_data_obj = self.climate_data
+        except FileNotFoundError:
+            st.warning("Default climate data file not found. Please enter climate data manually.")
+        
+        self.setup_layout()
+    
+    def setup_layout(self):
+        st.sidebar.title("HVAC Load Calculator")
+        st.sidebar.markdown("---")
+        
+        st.sidebar.subheader("Navigation")
+        pages = [
+            "Building Information",
+            "Climate Data",
+            "Building Components",
+            "Internal Loads",
+            "Calculation Results",
+            "Export Data"
+        ]
+        
+        selected_page = st.sidebar.radio("Go to", pages, index=pages.index(st.session_state.page))
+        
+        if selected_page != st.session_state.page:
+            st.session_state.page = selected_page
+        
+        self.display_page(st.session_state.page)
+        
+        st.sidebar.markdown("---")
+        st.sidebar.info(
+            "HVAC Load Calculator v1.0.1\n\n"
+            "Based on ASHRAE steady-state calculation methods\n\n"
+            "Developed by: Dr Majed Abuseif\n\n"
+            "School of Architecture and Built Environment\n\n"
+            "Deakin University\n\n"
+            "© 2025"
+        )
+    
+    def display_page(self, page: str):
+        if page == "Building Information":
+            self.building_info_form.display_building_info_form(st.session_state)
+        elif page == "Climate Data":
+            self.climate_data.display_climate_input(st.session_state)
+        elif page == "Building Components":
+            self.component_selection.display_component_selection(st.session_state)
+        elif page == "Internal Loads":
+            self.display_internal_loads()
+        elif page == "Calculation Results":
+            self.display_calculation_results()
+        elif page == "Export Data":
+            self.data_export.display()
+    
+    def generate_climate_id(self, country: str, city: str) -> str:
+        """Generate a climate ID from country and city names."""
+        try:
+            country = country.strip().title()
+            city = city.strip().title()
+            if len(country) < 2 or len(city) < 3:
+                raise ValueError("Country and city names must be at least 2 and 3 characters long, respectively.")
+            return f"{country[:2].upper()}-{city[:3].upper()}"
+        except Exception as e:
+            raise ValueError(f"Invalid country or city name: {str(e)}")
+    
+    def validate_calculation_inputs(self) -> Tuple[bool, str]:
+        """Validate inputs for cooling and heating calculations."""
+        building_info = st.session_state.get('building_info', {})
+        components = st.session_state.get('components', {})
+        climate_data = st.session_state.get('climate_data', {})
+        
+        # Check building info
+        if not building_info.get('floor_area', 0) > 0:
+            return False, "Floor area must be positive."
+        if not any(components.get(key, []) for key in ['walls', 'roofs', 'windows']):
+            return False, "At least one wall, roof, or window must be defined."
+        
+        # NEW: Validate climate data using climate_data.py
+        if not climate_data:
+            return False, "Climate data is missing."
+        if not self.climate_data.validate_climate_data(climate_data):
+            return False, "Invalid climate data format or values."
+        
+        # Validate components
+        for component_type in ['walls', 'roofs', 'windows', 'doors', 'floors']:
+            for comp in components.get(component_type, []):
+                if comp.area <= 0:
+                    return False, f"Invalid area for {component_type}: {comp.name}"
+                if comp.u_value <= 0:
+                    return False, f"Invalid U-value for {component_type}: {comp.name}"
+                # NEW: Validate ground temperature for floors
+                if component_type == 'floors' and getattr(comp, 'ground_contact', False):
+                    if not -10 <= comp.ground_temperature_c <= 40:
+                        return False, f"Ground temperature for {comp.name} must be between -10°C and 40°C"
+                    # NEW: Validate perimeter
+                    if getattr(comp, 'perimeter', 0) < 0:
+                        return False, f"Perimeter for {comp.name} cannot be negative"
+        
+        # NEW: Validate ventilation rate
+        if building_info.get('ventilation_rate', 0) < 0:
+            return False, "Ventilation rate cannot be negative"
+        if building_info.get('zone_type', '') == 'Custom' and building_info.get('ventilation_rate', 0) == 0:
+            return False, "Custom ventilation rate must be specified"
+        
+        return True, "Inputs valid."
+    
+    def validate_internal_load(self, load_type: str, new_load: Dict) -> Tuple[bool, str]:
+        """Validate if a new internal load is unique and within limits."""
+        loads = st.session_state.internal_loads.get(load_type, [])
+        max_loads = 50
+        
+        if len(loads) >= max_loads:
+            return False, f"Maximum of {max_loads} {load_type} loads reached."
+        
+        # Check for duplicates based on key attributes
+        for existing_load in loads:
+            if load_type == 'people':
+                if (existing_load['name'] == new_load['name'] and
+                    existing_load['num_people'] == new_load['num_people'] and
+                    existing_load['activity_level'] == new_load['activity_level'] and
+                    existing_load['zone_type'] == new_load['zone_type'] and
+                    existing_load['hours_in_operation'] == new_load['hours_in_operation']):
+                    return False, f"Duplicate people load '{new_load['name']}' already exists."
+            elif load_type == 'lighting':
+                if (existing_load['name'] == new_load['name'] and
+                    existing_load['power'] == new_load['power'] and
+                    existing_load['usage_factor'] == new_load['usage_factor'] and
+                    existing_load['zone_type'] == new_load['zone_type'] and
+                    existing_load['hours_in_operation'] == new_load['hours_in_operation']):
+                    return False, f"Duplicate lighting load '{new_load['name']}' already exists."
+            elif load_type == 'equipment':
+                if (existing_load['name'] == new_load['name'] and
+                    existing_load['power'] == new_load['power'] and
+                    existing_load['usage_factor'] == new_load['usage_factor'] and
+                    existing_load['radiation_fraction'] == new_load['radiation_fraction'] and
+                    existing_load['zone_type'] == new_load['zone_type'] and
+                    existing_load['hours_in_operation'] == new_load['hours_in_operation']):
+                    return False, f"Duplicate equipment load '{new_load['name']}' already exists."
+        
+        return True, "Valid load."
+    
+    def display_internal_loads(self):
+        st.title("Internal Loads")
+        
+        # Reset button for all internal loads
+        if st.button("Reset All Internal Loads"):
+            st.session_state.internal_loads = {'people': [], 'lighting': [], 'equipment': []}
+            st.success("All internal loads reset!")
+            st.rerun()
+        
+        tabs = st.tabs(["People", "Lighting", "Equipment", "Ventilation"])  # NEW: Added Ventilation tab
+        
+        with tabs[0]:
+            st.subheader("People")
+            with st.form("people_form"):
+                num_people = st.number_input(
+                    "Number of People",
+                    min_value=0,
+                    value=0,
+                    step=1,
+                    help="Total number of occupants in the building"
+                )
+                activity_level = st.selectbox(
+                    "Activity Level",
+                    ["Seated/Resting", "Light Work", "Moderate Work", "Heavy Work"],
+                    help="Select typical activity level (affects internal heat gains per ASHRAE)"
+                )
+                zone_type = st.selectbox(
+                    "Zone Type",
+                    ["Office", "Classroom", "Retail", "Residential"],
+                    help="Select zone type for occupancy characteristics"
+                )
+                hours_in_operation = st.number_input(
+                    "Hours in Operation",
+                    min_value=0.0,
+                    max_value=24.0,
+                    value=8.0,
+                    step=0.5,
+                    help="Daily hours of occupancy"
+                )
+                people_name = st.text_input("Name", value="Occupants")
+                
+                if st.form_submit_button("Add People Load"):
+                    people_load = {
+                        "id": f"people_{len(st.session_state.internal_loads['people'])}",
+                        "name": people_name,
+                        "num_people": num_people,
+                        "activity_level": activity_level,
+                        "zone_type": zone_type,
+                        "hours_in_operation": hours_in_operation
+                    }
+                    is_valid, message = self.validate_internal_load('people', people_load)
+                    if is_valid:
+                        st.session_state.internal_loads['people'].append(people_load)
+                        st.success("People load added!")
+                        st.rerun()
+                    else:
+                        st.error(message)
+            
+            if st.session_state.internal_loads['people']:
+                people_df = pd.DataFrame(st.session_state.internal_loads['people'])
+                st.dataframe(people_df, use_container_width=True)
+                
+                selected_people = st.multiselect(
+                    "Select People Loads to Delete",
+                    [load['id'] for load in st.session_state.internal_loads['people']]
+                )
+                if st.button("Delete Selected People Loads"):
+                    st.session_state.internal_loads['people'] = [
+                        load for load in st.session_state.internal_loads['people']
+                        if load['id'] not in selected_people
+                    ]
+                    st.success("Selected people loads deleted!")
+                    st.rerun()
+        
+        with tabs[1]:
+            st.subheader("Lighting")
+            with st.form("lighting_form"):
+                power = st.number_input(
+                    "Power (W)",
+                    min_value=0.0,
+                    value=1000.0,
+                    step=100.0,
+                    help="Total lighting power consumption"
+                )
+                usage_factor = st.number_input(
+                    "Usage Factor",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=0.8,
+                    step=0.1,
+                    help="Fraction of time lighting is in use (0 to 1)"
+                )
+                zone_type = st.selectbox(
+                    "Zone Type",
+                    ["Office", "Classroom", "Retail", "Residential"],
+                    help="Select zone type for lighting characteristics"
+                )
+                hours_in_operation = st.number_input(
+                    "Hours in Operation",
+                    min_value=0.0,
+                    max_value=24.0,
+                    value=8.0,
+                    step=0.5,
+                    help="Daily hours of lighting operation"
+                )
+                lighting_name = st.text_input("Name", value="General Lighting")
+                
+                if st.form_submit_button("Add Lighting Load"):
+                    lighting_load = {
+                        "id": f"lighting_{len(st.session_state.internal_loads['lighting'])}",
+                        "name": lighting_name,
+                        "power": power,
+                        "usage_factor": usage_factor,
+                        "zone_type": zone_type,
+                        "hours_in_operation": hours_in_operation
+                    }
+                    is_valid, message = self.validate_internal_load('lighting', lighting_load)
+                    if is_valid:
+                        st.session_state.internal_loads['lighting'].append(lighting_load)
+                        st.success("Lighting load added!")
+                        st.rerun()
+                    else:
+                        st.error(message)
+            
+            if st.session_state.internal_loads['lighting']:
+                lighting_df = pd.DataFrame(st.session_state.internal_loads['lighting'])
+                st.dataframe(lighting_df, use_container_width=True)
+                
+                selected_lighting = st.multiselect(
+                    "Select Lighting Loads to Delete",
+                    [load['id'] for load in st.session_state.internal_loads['lighting']]
+                )
+                if st.button("Delete Selected Lighting Loads"):
+                    st.session_state.internal_loads['lighting'] = [
+                        load for load in st.session_state.internal_loads['lighting']
+                        if load['id'] not in selected_lighting
+                    ]
+                    st.success("Selected lighting loads deleted!")
+                    st.rerun()
+        
+        with tabs[2]:
+            st.subheader("Equipment")
+            with st.form("equipment_form"):
+                power = st.number_input(
+                    "Power (W)",
+                    min_value=0.0,
+                    value=500.0,
+                    step=100.0,
+                    help="Total equipment power consumption"
+                )
+                usage_factor = st.number_input(
+                    "Usage Factor",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=0.7,
+                    step=0.1,
+                    help="Fraction of time equipment is in use (0 to 1)"
+                )
+                radiation_fraction = st.number_input(
+                    "Radiation Fraction",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=0.3,
+                    step=0.1,
+                    help="Fraction of heat gain radiated to surroundings"
+                )
+                zone_type = st.selectbox(
+                    "Zone Type",
+                    ["Office", "Classroom", "Retail", "Residential"],
+                    help="Select zone type for equipment characteristics"
+                )
+                hours_in_operation = st.number_input(
+                    "Hours in Operation",
+                    min_value=0.0,
+                    max_value=24.0,
+                    value=8.0,
+                    step=0.5,
+                    help="Daily hours of equipment operation"
+                )
+                equipment_name = st.text_input("Name", value="Office Equipment")
+                
+                if st.form_submit_button("Add Equipment Load"):
+                    equipment_load = {
+                        "id": f"equipment_{len(st.session_state.internal_loads['equipment'])}",
+                        "name": equipment_name,
+                        "power": power,
+                        "usage_factor": usage_factor,
+                        "radiation_fraction": radiation_fraction,
+                        "zone_type": zone_type,
+                        "hours_in_operation": hours_in_operation
+                    }
+                    is_valid, message = self.validate_internal_load('equipment', equipment_load)
+                    if is_valid:
+                        st.session_state.internal_loads['equipment'].append(equipment_load)
+                        st.success("Equipment load added!")
+                        st.rerun()
+                    else:
+                        st.error(message)
+            
+            if st.session_state.internal_loads['equipment']:
+                equipment_df = pd.DataFrame(st.session_state.internal_loads['equipment'])
+                st.dataframe(equipment_df, use_container_width=True)
+                
+                selected_equipment = st.multiselect(
+                    "Select Equipment Loads to Delete",
+                    [load['id'] for load in st.session_state.internal_loads['equipment']]
+                )
+                if st.button("Delete Selected Equipment Loads"):
+                    st.session_state.internal_loads['equipment'] = [
+                        load for load in st.session_state.internal_loads['equipment']
+                        if load['id'] not in selected_equipment
+                    ]
+                    st.success("Selected equipment loads deleted!")
+                    st.rerun()
+        
+        with tabs[3]:  # NEW: Ventilation tab
+            st.subheader("Ventilation Requirements (ASHRAE 62.1)")
+            with st.form("ventilation_form"):
+                col1, col2 = st.columns(2)
+                with col1:
+                    zone_type = st.selectbox(
+                        "Zone Type",
+                        ["Office", "Classroom", "Retail", "Restaurant", "Custom"],
+                        help="Select building zone type for ASHRAE 62.1 ventilation rates"
+                    )
+                    ventilation_method = st.selectbox(
+                        "Ventilation Method",
+                        ["Constant Volume", "Demand-Controlled"],
+                        help="Constant Volume uses fixed rate; Demand-Controlled adjusts based on occupancy"
+                    )
+                with col2:
+                    if zone_type == "Custom":
+                        people_rate = st.number_input(
+                            "Ventilation Rate per Person (L/s/person)",
+                            min_value=0.0,
+                            value=2.5,
+                            step=0.1,
+                            help="Custom ventilation rate per person (ASHRAE 62.1)"
+                        )
+                        area_rate = st.number_input(
+                            "Ventilation Rate per Area (L/s/m²)",
+                            min_value=0.0,
+                            value=0.3,
+                            step=0.1,
+                            help="Custom ventilation rate per floor area (ASHRAE 62.1)"
+                        )
+                    else:
+                        people_rate = VENTILATION_RATES[zone_type]["people_rate"]
+                        area_rate = VENTILATION_RATES[zone_type]["area_rate"]
+                        st.write(f"People Rate: {people_rate} L/s/person (ASHRAE 62.1)")
+                        st.write(f"Area Rate: {area_rate} L/s/m² (ASHRAE 62.1)")
+                
+                if st.form_submit_button("Save Ventilation Settings"):
+                    total_people = sum(load['num_people'] for load in st.session_state.internal_loads.get('people', []))
+                    floor_area = st.session_state.building_info.get('floor_area', 100.0)
+                    ventilation_rate = (
+                        (total_people * people_rate + floor_area * area_rate) / 1000  # Convert L/s to m³/s
+                    )
+                    if ventilation_method == 'Demand-Controlled':
+                        ventilation_rate *= 0.75  # Reduce by 25% for DCV
+                    st.session_state.building_info.update({
+                        'zone_type': zone_type,
+                        'ventilation_method': ventilation_method,
+                        'ventilation_rate': ventilation_rate
+                    })
+                    st.success(f"Ventilation settings saved! Total rate: {ventilation_rate:.3f} m³/s")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.button(
+                "Back to Building Components",
+                on_click=lambda: setattr(st.session_state, "page", "Building Components")
+            )
+        with col2:
+            st.button(
+                "Continue to Calculation Results",
+                on_click=lambda: setattr(st.session_state, "page", "Calculation Results")
+            )
+    
+    def calculate_cooling(self) -> Tuple[bool, str, Dict]:
+        """
+        Calculate cooling loads using CoolingLoadCalculator.
+        Returns: (success, message, results)
+        """
+        try:
+            # Validate inputs
+            valid, message = self.validate_calculation_inputs()
+            if not valid:
+                return False, message, {}
+            
+            # Gather inputs
+            building_components = st.session_state.get('components', {})
+            internal_loads = st.session_state.get('internal_loads', {})
+            building_info = st.session_state.get('building_info', {})
+            
+            # Check climate data
+            if "climate_data" not in st.session_state or not st.session_state["climate_data"]:
+                return False, "Please enter climate data in the 'Climate Data' page.", {}
+            
+            # Extract climate data
+            country = building_info.get('country', '').strip().title()
+            city = building_info.get('city', '').strip().title()
+            if not country or not city:
+                return False, "Country and city must be set in Building Information.", {}
+            climate_id = self.generate_climate_id(country, city)
+            location = self.climate_data.get_location_by_id(climate_id, st.session_state)
+            if not location:
+                available_locations = list(self.climate_data.locations.keys())[:5]
+                return False, f"No climate data for {climate_id}. Available locations: {', '.join(available_locations)}...", {}
+            
+            # Validate climate data
+            if not all(k in location for k in ['summer_design_temp_db', 'summer_design_temp_wb', 'monthly_temps', 'latitude']):
+                return False, f"Invalid climate data for {climate_id}. Missing required fields.", {}
+            
+            # Format conditions
+            outdoor_conditions = {
+                'temperature': location['summer_design_temp_db'],
+                'relative_humidity': location['monthly_humidity'].get('Jul', 50.0),
+                'ground_temperature': location['monthly_temps'].get('Jul', 20.0),
+                'month': 'Jul',
+                'latitude': location['latitude'],  # Pass raw latitude value, validation will happen in cooling_load.py
+                'wind_speed': building_info.get('wind_speed', 4.0),
+                'day_of_year': 204  # Approx. July 23
+            }
+            indoor_conditions = {
+                'temperature': building_info.get('indoor_temp', 24.0),
+                'relative_humidity': building_info.get('indoor_rh', 50.0)
+            }
+            
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Cooling Input State", {
+                    'climate_id': climate_id,
+                    'outdoor_conditions': outdoor_conditions,
+                    'indoor_conditions': indoor_conditions,
+                    'components': {k: len(v) for k, v in building_components.items()},
+                    'internal_loads': {
+                        'people': len(internal_loads.get('people', [])),
+                        'lighting': len(internal_loads.get('lighting', [])),
+                        'equipment': len(internal_loads.get('equipment', []))
+                    },
+                    'building_info': building_info
+                })
+            
+            # Format internal loads
+            formatted_internal_loads = {
+                'people': {
+                    'number': sum(load['num_people'] for load in internal_loads.get('people', [])),
+                    'activity_level': internal_loads.get('people', [{}])[0].get('activity_level', 'Seated/Resting'),
+                    'operating_hours': f"{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)}:00-{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)+10}:00"
+                },
+                'lights': {
+                    'power': sum(load['power'] for load in internal_loads.get('lighting', [])),
+                    'use_factor': internal_loads.get('lighting', [{}])[0].get('usage_factor', 0.8),
+                    'special_allowance': 0.1,
+                    'hours_operation': f"{internal_loads.get('lighting', [{}])[0].get('hours_in_operation', 8)}h"
+                },
+                'equipment': {
+                    'power': sum(load['power'] for load in internal_loads.get('equipment', [])),
+                    'use_factor': internal_loads.get('equipment', [{}])[0].get('usage_factor', 0.7),
+                    'radiation_factor': internal_loads.get('equipment', [{}])[0].get('radiation_fraction', 0.3),
+                    'hours_operation': f"{internal_loads.get('equipment', [{}])[0].get('hours_in_operation', 8)}h"
+                },
+                'infiltration': {
+                    'flow_rate': building_info.get('infiltration_rate', 0.05),
+                    'height': building_info.get('building_height', 3.0),
+                    'crack_length': building_info.get('crack_length', 10.0)
+                },
+                'ventilation': {
+                    'flow_rate': building_info.get('ventilation_rate', 0.1)
+                },
+                'operating_hours': building_info.get('operating_hours', '8:00-18:00')
+            }
+            
+            # Calculate hourly loads
+            hourly_loads = self.cooling_calculator.calculate_hourly_cooling_loads(
+                building_components=building_components,
+                outdoor_conditions=outdoor_conditions,
+                indoor_conditions=indoor_conditions,
+                internal_loads=formatted_internal_loads,
+                building_volume=building_info.get('floor_area', 100.0) * building_info.get('building_height', 3.0)
+            )
+            if not hourly_loads:
+                return False, "Cooling hourly loads calculation failed. Check input data.", {}
+            
+            # Get design loads
+            design_loads = self.cooling_calculator.calculate_design_cooling_load(hourly_loads)
+            if not design_loads:
+                return False, "Cooling design loads calculation failed. Check input data.", {}
+            
+            # Get summary
+            summary = self.cooling_calculator.calculate_cooling_load_summary(design_loads)
+            if not summary:
+                return False, "Cooling load summary calculation failed. Check input data.", {}
+            
+            # Ensure summary has all required keys
+            if 'total' not in summary:
+                # Calculate total if missing
+                if 'total_sensible' in summary and 'total_latent' in summary:
+                    summary['total'] = summary['total_sensible'] + summary['total_latent']
+                else:
+                    # Fallback to sum of design loads if needed
+                    total_load = sum(value for key, value in design_loads.items() if key != 'design_hour')
+                    summary = {
+                        'total_sensible': total_load * 0.7,  # Approximate sensible ratio
+                        'total_latent': total_load * 0.3,    # Approximate latent ratio
+                        'total': total_load
+                    }
+            
+            # Format results for results_display.py
+            floor_area = building_info.get('floor_area', 100.0) or 100.0
+            results = {
+                'total_load': summary['total'] / 1000,  # kW
+                'sensible_load': summary['total_sensible'] / 1000,  # kW
+                'latent_load': summary['total_latent'] / 1000,  # kW
+                'load_per_area': summary['total'] / floor_area,  # W/m²
+                'component_loads': {
+                    'walls': design_loads['walls'] / 1000,
+                    'roof': design_loads['roofs'] / 1000,
+                    'windows': (design_loads['windows_conduction'] + design_loads['windows_solar']) / 1000,
+                    'doors': design_loads['doors'] / 1000,
+                    'people': (design_loads['people_sensible'] + design_loads['people_latent']) / 1000,
+                    'lighting': design_loads['lights'] / 1000,
+                    'equipment': (design_loads['equipment_sensible'] + design_loads['equipment_latent']) / 1000,
+                    'infiltration': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000,
+                    'ventilation': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                },
+                'detailed_loads': {
+                    'walls': [],
+                    'roofs': [],
+                    'windows': [],
+                    'doors': [],
+                    'internal': [],
+                    'infiltration': {
+                        'air_flow': formatted_internal_loads['infiltration']['flow_rate'],
+                        'sensible_load': design_loads['infiltration_sensible'] / 1000,
+                        'latent_load': design_loads['infiltration_latent'] / 1000,
+                        'total_load': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000
+                    },
+                    'ventilation': {
+                        'air_flow': formatted_internal_loads['ventilation']['flow_rate'],
+                        'sensible_load': design_loads['ventilation_sensible'] / 1000,
+                        'latent_load': design_loads['infiltration_latent'] / 1000,
+                        'total_load': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                    }
+                },
+                'building_info': building_info
+            }
+            
+            # Populate detailed loads
+            for wall in building_components.get('walls', []):
+                load = self.cooling_calculator.calculate_wall_cooling_load(
+                    wall=wall,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    month=outdoor_conditions['month'],
+                    hour=design_loads['design_hour'],
+                    latitude=outdoor_conditions['latitude']
+                )
+                results['detailed_loads']['walls'].append({
+                    'name': wall.name,
+                    'orientation': wall.orientation.value,
+                    'area': wall.area,
+                    'u_value': wall.u_value,
+                    'cltd': self.cooling_calculator.ashrae_tables.calculate_corrected_cltd_wall(
+                        wall_group=wall.wall_group,
+                        orientation=wall.orientation.value,
+                        hour=design_loads['design_hour'],
+                        color='Dark',
+                        month=outdoor_conditions['month'],
+                        latitude=outdoor_conditions['latitude'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        outdoor_temp=outdoor_conditions['temperature']
+                    ),
+                    'load': load / 1000
+                })
+            
+            for roof in building_components.get('roofs', []):
+                load = self.cooling_calculator.calculate_roof_cooling_load(
+                    roof=roof,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    month=outdoor_conditions['month'],
+                    hour=design_loads['design_hour'],
+                    latitude=outdoor_conditions['latitude']
+                )
+                results['detailed_loads']['roofs'].append({
+                    'name': roof.name,
+                    'orientation': roof.orientation.value,
+                    'area': roof.area,
+                    'u_value': roof.u_value,
+                    'cltd': self.cooling_calculator.ashrae_tables.calculate_corrected_cltd_roof(
+                        roof_group=roof.roof_group,
+                        hour=design_loads['design_hour'],
+                        color='Dark',
+                        month=outdoor_conditions['month'],
+                        latitude=outdoor_conditions['latitude'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        outdoor_temp=outdoor_conditions['temperature']
+                    ),
+                    'load': load / 1000
+                })
+            
+            for window in building_components.get('windows', []):
+                load_dict = self.cooling_calculator.calculate_window_cooling_load(
+                    window=window,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    month=outdoor_conditions['month'],
+                    hour=design_loads['design_hour'],
+                    latitude=outdoor_conditions['latitude'],
+                    shading_coefficient=window.shading_coefficient
+                )
+                # Ensure load_dict has a 'total' key
+                if 'total' not in load_dict:
+                    if 'conduction' in load_dict and 'solar' in load_dict:
+                        load_dict['total'] = load_dict['conduction'] + load_dict['solar']
+                    else:
+                        load_dict['total'] = window.u_value * window.area * (outdoor_conditions['temperature'] - indoor_conditions['temperature'])
+                
+                # Pass latitude directly to get_scl method which has its own validation
+                results['detailed_loads']['windows'].append({
+                    'name': window.name,
+                    'orientation': window.orientation.value,
+                    'area': window.area,
+                    'u_value': window.u_value,
+                    'shgc': window.shgc,
+                    'shading_device': window.shading_device,
+                    'shading_coefficient': window.shading_coefficient,
+                    'scl': self.cooling_calculator.ashrae_tables.get_scl(
+                        latitude=outdoor_conditions['latitude'],
+                        month=outdoor_conditions['month'].title(),
+                        orientation=window.orientation.value,
+                        hour=design_loads['design_hour']
+                    ),
+                    'load': load_dict['total'] / 1000
+                })
+            
+            for door in building_components.get('doors', []):
+                load = self.cooling_calculator.calculate_door_cooling_load(
+                    door=door,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['doors'].append({
+                    'name': door.name,
+                    'orientation': door.orientation.value,
+                    'area': door.area,
+                    'u_value': door.u_value,
+                    'cltd': outdoor_conditions['temperature'] - indoor_conditions['temperature'],
+                    'load': load / 1000
+                })
+            
+            for load_type, key in [('people', 'people'), ('lighting', 'lights'), ('equipment', 'equipment')]:
+                for load in internal_loads.get(key, []):
+                    if load_type == 'people':
+                        load_dict = self.cooling_calculator.calculate_people_cooling_load(
+                            num_people=load['num_people'],
+                            activity_level=load['activity_level'],
+                            hour=design_loads['design_hour']
+                        )
+                        # Ensure load_dict has a 'total' key
+                        if 'total' not in load_dict and ('sensible' in load_dict or 'latent' in load_dict):
+                            load_dict['total'] = load_dict.get('sensible', 0) + load_dict.get('latent', 0)
+                    elif load_type == 'lighting':
+                        light_load = self.cooling_calculator.calculate_lights_cooling_load(
+                            power=load['power'],
+                            use_factor=load['usage_factor'],
+                            special_allowance=0.1,
+                            hour=design_loads['design_hour']
+                        )
+                        load_dict = {'total': light_load if light_load is not None else 0}
+                    else:
+                        load_dict = self.cooling_calculator.calculate_equipment_cooling_load(
+                            power=load['power'],
+                            use_factor=load['usage_factor'],
+                            radiation_factor=load['radiation_fraction'],
+                            hour=design_loads['design_hour']
+                        )
+                        # Ensure load_dict has a 'total' key
+                        if 'total' not in load_dict and ('sensible' in load_dict or 'latent' in load_dict):
+                            load_dict['total'] = load_dict.get('sensible', 0) + load_dict.get('latent', 0)
+                    results['detailed_loads']['internal'].append({
+                        'type': load_type.capitalize(),
+                        'name': load['name'],
+                        'quantity': load.get('num_people', load.get('power', 1)),
+                        'heat_gain': load_dict.get('sensible', load_dict.get('total', 0)),
+                        'clf': self.cooling_calculator.ashrae_tables.get_clf_people(
+                            zone_type='A',
+                            hours_occupied='6h',  # Using valid '6h' instead of dynamic value that might not exist
+                            hour=design_loads['design_hour']
+                        ) if load_type == 'people' else 1.0,
+                        'load': load_dict.get('total', 0) / 1000
+                    })
+            
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Cooling Results", {
+                    'total_load': results.get('total_load', 'N/A'),
+                    'component_loads': results.get('component_loads', 'N/A'),
+                    'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
+                })
+            
+            return True, "Cooling calculation completed.", results
+        
+        except ValueError as ve:
+            st.error(f"Input error in cooling calculation: {str(ve)}")
+            return False, f"Input error: {str(ve)}", {}
+        except KeyError as ke:
+            st.error(f"Missing data in cooling calculation: {str(ke)}")
+            return False, f"Missing data: {str(ke)}", {}
+        except Exception as e:
+            st.error(f"Unexpected error in cooling calculation: {str(e)}")
+            return False, f"Unexpected error: {str(e)}", {}
+    
+    def calculate_heating(self) -> Tuple[bool, str, Dict]:
+        """
+        Calculate heating loads using HeatingLoadCalculator.
+        Returns: (success, message, results)
+        """
+        try:
+            # Validate inputs
+            valid, message = self.validate_calculation_inputs()
+            if not valid:
+                return False, message, {}
+            
+            # Gather inputs
+            building_components = st.session_state.get('components', {})
+            internal_loads = st.session_state.get('internal_loads', {})
+            building_info = st.session_state.get('building_info', {})
+            
+            # Check climate data
+            if "climate_data" not in st.session_state or not st.session_state["climate_data"]:
+                return False, "Please enter climate data in the 'Climate Data' page.", {}
+            
+            # Extract climate data
+            country = building_info.get('country', '').strip().title()
+            city = building_info.get('city', '').strip().title()
+            if not country or not city:
+                return False, "Country and city must be set in Building Information.", {}
+            climate_id = self.generate_climate_id(country, city)
+            location = self.climate_data.get_location_by_id(climate_id, st.session_state)
+            if not location:
+                available_locations = list(self.climate_data.locations.keys())[:5]
+                return False, f"No climate data for {climate_id}. Available locations: {', '.join(available_locations)}...", {}
+            
+            # Validate climate data
+            if not all(k in location for k in ['winter_design_temp', 'monthly_temps', 'monthly_humidity']):
+                return False, f"Invalid climate data for {climate_id}. Missing required fields.", {}
+            
+            # NEW: Calculate ground temperature from floors or fallback to climate data
+            ground_contact_floors = [f for f in building_components.get('floors', []) if getattr(f, 'ground_contact', False)]
+            ground_temperature = (
+                sum(f.ground_temperature_c for f in ground_contact_floors) / len(ground_contact_floors)
+                if ground_contact_floors else
+                location['monthly_temps'].get('Jan', 10.0)
+            )
+            if not -10 <= ground_temperature <= 40:
+                return False, f"Invalid ground temperature: {ground_temperature}°C", {}
+            
+            # NEW: Skip heating calculation if outdoor temp exceeds indoor temp
+            indoor_temp = building_info.get('indoor_temp', 21.0)
+            outdoor_temp = location['winter_design_temp']
+            if outdoor_temp >= indoor_temp:
+                results = {
+                    'total_load': 0.0,
+                    'load_per_area': 0.0,
+                    'design_heat_loss': 0.0,
+                    'safety_factor': 115.0,
+                    'component_loads': {
+                        'walls': 0.0,
+                        'roof': 0.0,
+                        'floor': 0.0,
+                        'windows': 0.0,
+                        'doors': 0.0,
+                        'infiltration': 0.0,
+                        'ventilation': 0.0
+                    },
+                    'detailed_loads': {
+                        'walls': [],
+                        'roofs': [],
+                        'floors': [],
+                        'windows': [],
+                        'doors': [],
+                        'infiltration': {'air_flow': 0.0, 'delta_t': 0.0, 'load': 0.0},
+                        'ventilation': {'air_flow': 0.0, 'delta_t': 0.0, 'load': 0.0}
+                    },
+                    'building_info': building_info
+                }
+                return True, "No heating required (outdoor temp exceeds indoor temp).", results
+            
+            # Format conditions
+            outdoor_conditions = {
+                'design_temperature': location['winter_design_temp'],
+                'design_relative_humidity': location['monthly_humidity'].get('Jan', 80.0),
+                'ground_temperature': ground_temperature,
+                'wind_speed': building_info.get('wind_speed', 4.0)
+            }
+            indoor_conditions = {
+                'temperature': indoor_temp,
+                'relative_humidity': building_info.get('indoor_rh', 40.0)
+            }
+            
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Heating Input State", {
+                    'climate_id': climate_id,
+                    'outdoor_conditions': outdoor_conditions,
+                    'indoor_conditions': indoor_conditions,
+                    'components': {k: len(v) for k, v in building_components.items()},
+                    'internal_loads': {
+                        'people': len(internal_loads.get('people', [])),
+                        'lighting': len(internal_loads.get('lighting', [])),
+                        'equipment': len(internal_loads.get('equipment', []))
+                    },
+                    'building_info': building_info
+                })
+            
+            # NEW: Activity-level-based sensible gains
+            ACTIVITY_GAINS = {
+                'Seated/Resting': 70.0,  # W/person
+                'Light Work': 85.0,
+                'Moderate Work': 100.0,
+                'Heavy Work': 150.0
+            }
+            
+            # Format internal loads
+            formatted_internal_loads = {
+                'people': {
+                    'number': sum(load['num_people'] for load in internal_loads.get('people', [])),
+                    'sensible_gain': ACTIVITY_GAINS.get(
+                        internal_loads.get('people', [{}])[0].get('activity_level', 'Seated/Resting'),
+                        70.0
+                    ),
+                    'operating_hours': f"{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)}:00-{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)+10}:00"
+                },
+                'lights': {
+                    'power': sum(load['power'] for load in internal_loads.get('lighting', [])),
+                    'use_factor': internal_loads.get('lighting', [{}])[0].get('usage_factor', 0.8),
+                    'hours_operation': f"{internal_loads.get('lighting', [{}])[0].get('hours_in_operation', 8)}h"
+                },
+                'equipment': {
+                    'power': sum(load['power'] for load in internal_loads.get('equipment', [])),
+                    'use_factor': internal_loads.get('equipment', [{}])[0].get('usage_factor', 0.7),
+                    'hours_operation': f"{internal_loads.get('equipment', [{}])[0].get('hours_in_operation', 8)}h"
+                },
+                'infiltration': {
+                    'flow_rate': building_info.get('infiltration_rate', 0.05),
+                    'height': building_info.get('building_height', 3.0),
+                    'crack_length': building_info.get('crack_length', 10.0)
+                },
+                'ventilation': {
+                    'flow_rate': building_info.get('ventilation_rate', 0.1)
+                },
+                'usage_factor': 0.7,
+                'operating_hours': building_info.get('operating_hours', '8:00-18:00')
+            }
+            
+            # Calculate design loads
+            design_loads = self.heating_calculator.calculate_design_heating_load(
+                building_components=building_components,
+                outdoor_conditions=outdoor_conditions,
+                indoor_conditions=indoor_conditions,
+                internal_loads=formatted_internal_loads
+            )
+            if not design_loads:
+                return False, "Heating design loads calculation failed. Check input data.", {}
+            
+            # Get summary
+            summary = self.heating_calculator.calculate_heating_load_summary(design_loads)
+            if not summary:
+                return False, "Heating load summary calculation failed. Check input data.", {}
+            
+            # Format results
+            floor_area = building_info.get('floor_area', 100.0) or 100.0
+            results = {
+                'total_load': summary['total'] / 1000,  # kW
+                'load_per_area': summary['total'] / floor_area,  # W/m²
+                'design_heat_loss': summary['subtotal'] / 1000,  # kW
+                'safety_factor': summary['safety_factor'] * 100,  # %
+                'component_loads': {
+                    'walls': design_loads['walls'] / 1000,
+                    'roof': design_loads['roofs'] / 1000,
+                    'floor': design_loads['floors'] / 1000,
+                    'windows': design_loads['windows'] / 1000,
+                    'doors': design_loads['doors'] / 1000,
+                    'infiltration': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000,
+                    'ventilation': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                },
+                'detailed_loads': {
+                    'walls': [],
+                    'roofs': [],
+                    'floors': [],
+                    'windows': [],
+                    'doors': [],
+                    'infiltration': {
+                        'air_flow': formatted_internal_loads['infiltration']['flow_rate'],
+                        'delta_t': indoor_conditions['temperature'] - outdoor_conditions['design_temperature'],
+                        'load': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000
+                    },
+                    'ventilation': {
+                        'air_flow': formatted_internal_loads['ventilation']['flow_rate'],
+                        'delta_t': indoor_conditions['temperature'] - outdoor_conditions['design_temperature'],
+                        'load': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                    }
+                },
+                'building_info': building_info
+            }
+            
+            # Populate detailed loads
+            delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
+            for wall in building_components.get('walls', []):
+                load = self.heating_calculator.calculate_wall_heating_load(
+                    wall=wall,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['walls'].append({
+                    'name': wall.name,
+                    'orientation': wall.orientation.value,
+                    'area': wall.area,
+                    'u_value': wall.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
+            for roof in building_components.get('roofs', []):
+                load = self.heating_calculator.calculate_roof_heating_load(
+                    roof=roof,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['roofs'].append({
+                    'name': roof.name,
+                    'orientation': roof.orientation.value,
+                    'area': roof.area,
+                    'u_value': roof.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
+            for floor in building_components.get('floors', []):
+                load = self.heating_calculator.calculate_floor_heating_load(
+                    floor=floor,
+                    ground_temp=outdoor_conditions['ground_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['floors'].append({
+                    'name': floor.name,
+                    'area': floor.area,
+                    'u_value': floor.u_value,
+                    'delta_t': indoor_conditions['temperature'] - outdoor_conditions['ground_temperature'],
+                    'load': load / 1000
+                })
+            
+            for window in building_components.get('windows', []):
+                load = self.heating_calculator.calculate_window_heating_load(
+                    window=window,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['windows'].append({
+                    'name': window.name,
+                    'orientation': window.orientation.value,
+                    'area': window.area,
+                    'u_value': window.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
+            for door in building_components.get('doors', []):
+                load = self.heating_calculator.calculate_door_heating_load(
+                    door=door,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['doors'].append({
+                    'name': door.name,
+                    'orientation': door.orientation.value,
+                    'area': door.area,
+                    'u_value': door.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Heating Results", {
+                    'total_load': results.get('total_load', 'N/A'),
+                    'component_loads': results.get('component_loads', 'N/A'),
+                    'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
+                })
+            
+            return True, "Heating calculation completed.", results
+        
+        except ValueError as ve:
+            st.error(f"Input error in heating calculation: {str(ve)}")
+            return False, f"Input error: {str(ve)}", {}
+        except KeyError as ke:
+            st.error(f"Missing data in heating calculation: {str(ke)}")
+            return False, f"Missing data: {str(ke)}", {}
+        except Exception as e:
+            st.error(f"Unexpected error in heating calculation: {str(e)}")
+            return False, f"Unexpected error: {str(e)}", {}
+    
+    def display_calculation_results(self):
+        st.title("Calculation Results")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            calculate_button = st.button("Calculate Loads")
+        with col2:
+            st.session_state.debug_mode = st.checkbox("Debug Mode", value=st.session_state.get('debug_mode', False))
+            
+        if calculate_button:
+            # Reset results
+            st.session_state.calculation_results = {'cooling': {}, 'heating': {}}
+            
+            with st.spinner("Calculating loads..."):
+                # Calculate cooling load
+                cooling_success, cooling_message, cooling_results = self.calculate_cooling()
+                if cooling_success:
+                    st.session_state.calculation_results['cooling'] = cooling_results
+                    st.success(cooling_message)
+                else:
+                    st.error(cooling_message)
+                
+                # Calculate heating load
+                heating_success, heating_message, heating_results = self.calculate_heating()
+                if heating_success:
+                    st.session_state.calculation_results['heating'] = heating_results
+                    st.success(heating_message)
+                else:
+                    st.error(heating_message)
+        
+        # Display results
+        self.results_display.display_results(st.session_state)
+        
+        # Navigation
+        col1, col2 = st.columns(2)
+        with col1:
+            st.button(
+                "Back to Internal Loads",
+                on_click=lambda: setattr(st.session_state, "page", "Internal Loads")
+            )
+        with col2:
+            st.button(
+                "Continue to Export Data",
+                on_click=lambda: setattr(st.session_state, "page", "Export Data")
+            )
+
+if __name__ == "__main__":
+    app = HVACCalculator()

app/results_display.py

@@ -0,0 +1,674 @@
+"""
+Results display module for HVAC Load Calculator.
+This module provides the UI components for displaying calculation results.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Any, Optional, Tuple
+import json
+import os
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime
+
+# Import visualization modules
+from utils.component_visualization import ComponentVisualization
+from utils.scenario_comparison import ScenarioComparisonVisualization
+from utils.psychrometric_visualization import PsychrometricVisualization
+from utils.time_based_visualization import TimeBasedVisualization
+
+
+class ResultsDisplay:
+    """Class for results display interface."""
+    
+    def __init__(self):
+        """Initialize results display interface."""
+        self.component_visualization = ComponentVisualization()
+        self.scenario_comparison = ScenarioComparisonVisualization()
+        self.psychrometric_visualization = PsychrometricVisualization()
+        self.time_based_visualization = TimeBasedVisualization()
+    
+    def display_results(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display calculation results in Streamlit.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.header("Calculation Results")
+        
+        # Check if calculations have been performed
+        if "calculation_results" not in session_state or not session_state["calculation_results"]:
+            st.warning("No calculation results available. Please run calculations first.")
+            return
+        
+        # Create tabs for different result views
+        tab1, tab2, tab3, tab4, tab5 = st.tabs([
+            "Summary", 
+            "Component Breakdown", 
+            "Psychrometric Analysis", 
+            "Time Analysis",
+            "Scenario Comparison"
+        ])
+        
+        with tab1:
+            self._display_summary_results(session_state)
+        
+        with tab2:
+            self._display_component_breakdown(session_state)
+        
+        with tab3:
+            self._display_psychrometric_analysis(session_state)
+        
+        with tab4:
+            self._display_time_analysis(session_state)
+        
+        with tab5:
+            self._display_scenario_comparison(session_state)
+    
+    def _display_summary_results(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display summary of calculation results.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("Summary Results")
+        
+        results = session_state["calculation_results"]
+        
+        # Display project information
+        if "building_info" in session_state:
+            st.write(f"**Project:** {session_state['building_info']['project_name']}")
+            st.write(f"**Building:** {session_state['building_info']['building_name']}")
+            location = f"{session_state['building_info']['city']}, {session_state['building_info']['country']}"
+            st.write(f"**Location:** {location}")
+            st.write(f"**Climate Zone:** {session_state['building_info'].get('climate_zone', 'N/A')}")
+            st.write(f"**Floor Area:** {session_state['building_info']['floor_area']} m²")
+        
+        # Create columns for cooling and heating loads
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.write("### Cooling Load Results")
+            
+            # Check if cooling results are available
+            if not results.get("cooling") or "total_load" not in results["cooling"]:
+                st.warning("Cooling load results are not available. Please check calculation inputs and try again.")
+            else:
+                # Display cooling load metrics
+                cooling_metrics = [
+                    {"name": "Total Cooling Load", "value": results["cooling"]["total_load"], "unit": "kW"},
+                    {"name": "Sensible Cooling Load", "value": results["cooling"]["sensible_load"], "unit": "kW"},
+                    {"name": "Latent Cooling Load", "value": results["cooling"]["latent_load"], "unit": "kW"},
+                    {"name": "Cooling Load per Area", "value": results["cooling"]["load_per_area"], "unit": "W/m²"}
+                ]
+                
+                for metric in cooling_metrics:
+                    st.metric(
+                        label=metric["name"],
+                        value=f"{metric['value']:.2f} {metric['unit']}"
+                    )
+                
+                # Display cooling load pie chart
+                cooling_breakdown = {
+                    "Walls": results["cooling"]["component_loads"]["walls"],
+                    "Roof": results["cooling"]["component_loads"]["roof"],
+                    "Windows": results["cooling"]["component_loads"]["windows"],
+                    "Doors": results["cooling"]["component_loads"]["doors"],
+                    "People": results["cooling"]["component_loads"]["people"],
+                    "Lighting": results["cooling"]["component_loads"]["lighting"],
+                    "Equipment": results["cooling"]["component_loads"]["equipment"],
+                    "Infiltration": results["cooling"]["component_loads"]["infiltration"],
+                    "Ventilation": results["cooling"]["component_loads"]["ventilation"]
+                }
+                
+                fig = px.pie(
+                    values=list(cooling_breakdown.values()),
+                    names=list(cooling_breakdown.keys()),
+                    title="Cooling Load Breakdown",
+                    color_discrete_sequence=px.colors.qualitative.Pastel
+                )
+                
+                fig.update_traces(textposition='inside', textinfo='percent+label')
+                fig.update_layout(uniformtext_minsize=12, uniformtext_mode='hide')
+                
+                st.plotly_chart(fig, use_container_width=True)
+        
+        with col2:
+            st.write("### Heating Load Results")
+            
+            # Check if heating results are available
+            if not results.get("heating") or "total_load" not in results["heating"]:
+                st.warning("Heating load results are not available. Please check calculation inputs and try again.")
+            else:
+                # Display heating load metrics
+                heating_metrics = [
+                    {"name": "Total Heating Load", "value": results["heating"]["total_load"], "unit": "kW"},
+                    {"name": "Heating Load per Area", "value": results["heating"]["load_per_area"], "unit": "W/m²"},
+                    {"name": "Design Heat Loss", "value": results["heating"]["design_heat_loss"], "unit": "kW"},
+                    {"name": "Safety Factor", "value": results["heating"]["safety_factor"], "unit": "%"}
+                ]
+                
+                for metric in heating_metrics:
+                    st.metric(
+                        label=metric["name"],
+                        value=f"{metric['value']:.2f} {metric['unit']}"
+                    )
+                
+                # Display heating load pie chart
+                heating_breakdown = {
+                    "Walls": results["heating"]["component_loads"]["walls"],
+                    "Roof": results["heating"]["component_loads"]["roof"],
+                    "Floor": results["heating"]["component_loads"]["floor"],
+                    "Windows": results["heating"]["component_loads"]["windows"],
+                    "Doors": results["heating"]["component_loads"]["doors"],
+                    "Infiltration": results["heating"]["component_loads"]["infiltration"],
+                    "Ventilation": results["heating"]["component_loads"]["ventilation"]
+                }
+                
+                fig = px.pie(
+                    values=list(heating_breakdown.values()),
+                    names=list(heating_breakdown.keys()),
+                    title="Heating Load Breakdown",
+                    color_discrete_sequence=px.colors.qualitative.Pastel
+                )
+                
+                fig.update_traces(textposition='inside', textinfo='percent+label')
+                fig.update_layout(uniformtext_minsize=12, uniformtext_mode='hide')
+                
+                st.plotly_chart(fig, use_container_width=True)
+        
+        # Display tabular results
+        st.subheader("Detailed Results")
+        
+        # Create tabs for cooling and heating tables
+        tab1, tab2 = st.tabs(["Cooling Load Details", "Heating Load Details"])
+        
+        with tab1:
+            if not results.get("cooling") or "detailed_loads" not in results["cooling"]:
+                st.warning("Cooling load details are not available.")
+            else:
+                # Create cooling load details table
+                cooling_details = []
+                
+                # Add envelope components
+                for wall in results["cooling"]["detailed_loads"]["walls"]:
+                    cooling_details.append({
+                        "Component Type": "Wall",
+                        "Name": wall["name"],
+                        "Orientation": wall["orientation"],
+                        "Area (m²)": wall["area"],
+                        "U-Value (W/m²·K)": wall["u_value"],
+                        "CLTD (°C)": wall["cltd"],
+                        "Load (kW)": wall["load"]
+                    })
+                
+                for roof in results["cooling"]["detailed_loads"]["roofs"]:
+                    cooling_details.append({
+                        "Component Type": "Roof",
+                        "Name": roof["name"],
+                        "Orientation": roof["orientation"],
+                        "Area (m²)": roof["area"],
+                        "U-Value (W/m²·K)": roof["u_value"],
+                        "CLTD (°C)": roof["cltd"],
+                        "Load (kW)": roof["load"]
+                    })
+                
+                for window in results["cooling"]["detailed_loads"]["windows"]:
+                    cooling_details.append({
+                        "Component Type": "Window",
+                        "Name": window["name"],
+                        "Orientation": window["orientation"],
+                        "Area (m²)": window["area"],
+                        "U-Value (W/m²·K)": window["u_value"],
+                        "SHGC": window["shgc"],
+                        "SCL (W/m²)": window["scl"],
+                        "Load (kW)": window["load"]
+                    })
+                
+                for door in results["cooling"]["detailed_loads"]["doors"]:
+                    cooling_details.append({
+                        "Component Type": "Door",
+                        "Name": door["name"],
+                        "Orientation": door["orientation"],
+                        "Area (m²)": door["area"],
+                        "U-Value (W/m²·K)": door["u_value"],
+                        "CLTD (°C)": door["cltd"],
+                        "Load (kW)": door["load"]
+                    })
+                
+                # Add internal loads
+                for internal_load in results["cooling"]["detailed_loads"]["internal"]:
+                    cooling_details.append({
+                        "Component Type": internal_load["type"],
+                        "Name": internal_load["name"],
+                        "Quantity": internal_load["quantity"],
+                        "Heat Gain (W)": internal_load["heat_gain"],
+                        "CLF": internal_load["clf"],
+                        "Load (kW)": internal_load["load"]
+                    })
+                
+                # Add infiltration and ventilation
+                cooling_details.append({
+                    "Component Type": "Infiltration",
+                    "Name": "Air Infiltration",
+                    "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["infiltration"]["air_flow"],
+                    "Sensible Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["sensible_load"],
+                    "Latent Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["latent_load"],
+                    "Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["total_load"]
+                })
+                
+                cooling_details.append({
+                    "Component Type": "Ventilation",
+                    "Name": "Fresh Air",
+                    "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["ventilation"]["air_flow"],
+                    "Sensible Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["sensible_load"],
+                    "Latent Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["latent_load"],
+                    "Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["total_load"]
+                })
+                
+                # Display cooling details table
+                cooling_df = pd.DataFrame(cooling_details)
+                st.dataframe(cooling_df, use_container_width=True)
+        
+        with tab2:
+            if not results.get("heating") or "detailed_loads" not in results["heating"]:
+                st.warning("Heating load details are not available.")
+            else:
+                # Create heating load details table
+                heating_details = []
+                
+                # Add envelope components
+                for wall in results["heating"]["detailed_loads"]["walls"]:
+                    heating_details.append({
+                        "Component Type": "Wall",
+                        "Name": wall["name"],
+                        "Orientation": wall["orientation"],
+                        "Area (m²)": wall["area"],
+                        "U-Value (W/m²·K)": wall["u_value"],
+                        "Temperature Difference (°C)": wall["delta_t"],
+                        "Load (kW)": wall["load"]
+                    })
+                
+                for roof in results["heating"]["detailed_loads"]["roofs"]:
+                    heating_details.append({
+                        "Component Type": "Roof",
+                        "Name": roof["name"],
+                        "Orientation": roof["orientation"],
+                        "Area (m²)": roof["area"],
+                        "U-Value (W/m²·K)": wall["u_value"],
+                        "Temperature Difference (°C)": roof["delta_t"],
+                        "Load (kW)": roof["load"]
+                    })
+                
+                for floor in results["heating"]["detailed_loads"]["floors"]:
+                    heating_details.append({
+                        "Component Type": "Floor",
+                        "Name": floor["name"],
+                        "Area (m²)": floor["area"],
+                        "U-Value (W/m²·K)": floor["u_value"],
+                        "Temperature Difference (°C)": floor["delta_t"],
+                        "Load (kW)": floor["load"]
+                    })
+                
+                for window in results["heating"]["detailed_loads"]["windows"]:
+                    heating_details.append({
+                        "Component Type": "Window",
+                        "Name": window["name"],
+                        "Orientation": window["orientation"],
+                        "Area (m²)": window["area"],
+                        "U-Value (W/m²·K)": window["u_value"],
+                        "Temperature Difference (°C)": window["delta_t"],
+                        "Load (kW)": window["load"]
+                    })
+                
+                for door in results["heating"]["detailed_loads"]["doors"]:
+                    heating_details.append({
+                        "Component Type": "Door",
+                        "Name": door["name"],
+                        "Orientation": door["orientation"],
+                        "Area (m²)": door["area"],
+                        "U-Value (W/m²·K)": door["u_value"],
+                        "Temperature Difference (°C)": door["delta_t"],
+                        "Load (kW)": door["load"]
+                    })
+                
+                # Add infiltration and ventilation
+                heating_details.append({
+                    "Component Type": "Infiltration",
+                    "Name": "Air Infiltration",
+                    "Air Flow (m³/s)": results["heating"]["detailed_loads"]["infiltration"]["air_flow"],
+                    "Temperature Difference (°C)": results["heating"]["detailed_loads"]["infiltration"]["delta_t"],
+                    "Load (kW)": results["heating"]["detailed_loads"]["infiltration"]["load"]
+                })
+                
+                heating_details.append({
+                    "Component Type": "Ventilation",
+                    "Name": "Fresh Air",
+                    "Air Flow (m³/s)": results["heating"]["detailed_loads"]["ventilation"]["air_flow"],
+                    "Temperature Difference (°C)": results["heating"]["detailed_loads"]["ventilation"]["delta_t"],
+                    "Load (kW)": results["heating"]["detailed_loads"]["ventilation"]["load"]
+                })
+                
+                # Display heating details table
+                heating_df = pd.DataFrame(heating_details)
+                st.dataframe(heating_df, use_container_width=True)
+        
+        # Add download buttons for results
+        st.subheader("Download Results")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if results.get("cooling") and "detailed_loads" in results["cooling"]:
+                if st.button("Download Cooling Load Results (CSV)"):
+                    cooling_csv = cooling_df.to_csv(index=False)
+                    st.download_button(
+                        label="Download CSV",
+                        data=cooling_csv,
+                        file_name=f"cooling_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                        mime="text/csv"
+                    )
+        
+        with col2:
+            if results.get("heating") and "detailed_loads" in results["heating"]:
+                if st.button("Download Heating Load Results (CSV)"):
+                    heating_csv = heating_df.to_csv(index=False)
+                    st.download_button(
+                        label="Download CSV",
+                        data=heating_csv,
+                        file_name=f"heating_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                        mime="text/csv"
+                    )
+        
+        # Add button to download full report
+        if st.button("Generate Full Report (Excel)"):
+            st.info("Excel report generation will be implemented in the Export module.")
+    
+    def _display_component_breakdown(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display component breakdown visualization.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("Component Breakdown")
+        
+        if not session_state["calculation_results"].get("cooling") and not session_state["calculation_results"].get("heating"):
+            st.warning("No component breakdown data available.")
+            return
+        
+        # Try to use component visualization module
+        try:
+            self.component_visualization.display_component_breakdown(
+                session_state["calculation_results"],
+                session_state["components"]
+            )
+        except AttributeError:
+            # Fallback visualization if display_component_breakdown is not available
+            st.info("Component visualization module not fully implemented. Displaying default breakdown.")
+            
+            results = session_state["calculation_results"]
+            
+            # Cooling load bar chart
+            if results.get("cooling"):
+                cooling_breakdown = {
+                    "Walls": results["cooling"]["component_loads"]["walls"],
+                    "Roof": results["cooling"]["component_loads"]["roof"],
+                    "Windows": results["cooling"]["component_loads"]["windows"],
+                    "Doors": results["cooling"]["component_loads"]["doors"],
+                    "People": results["cooling"]["component_loads"]["people"],
+                    "Lighting": results["cooling"]["component_loads"]["lighting"],
+                    "Equipment": results["cooling"]["component_loads"]["equipment"],
+                    "Infiltration": results["cooling"]["component_loads"]["infiltration"],
+                    "Ventilation": results["cooling"]["component_loads"]["ventilation"]
+                }
+                
+                fig_cooling = px.bar(
+                    x=list(cooling_breakdown.keys()),
+                    y=list(cooling_breakdown.values()),
+                    title="Cooling Load by Component",
+                    labels={"x": "Component", "y": "Load (kW)"},
+                    color_discrete_sequence=px.colors.qualitative.Pastel
+                )
+                
+                fig_cooling.update_layout(showlegend=False)
+                st.plotly_chart(fig_cooling, use_container_width=True)
+            
+            # Heating load bar chart
+            if results.get("heating"):
+                heating_breakdown = {
+                    "Walls": results["heating"]["component_loads"]["walls"],
+                    "Roof": results["heating"]["component_loads"]["roof"],
+                    "Floor": results["heating"]["component_loads"]["floor"],
+                    "Windows": results["heating"]["component_loads"]["windows"],
+                    "Doors": results["heating"]["component_loads"]["doors"],
+                    "Infiltration": results["heating"]["component_loads"]["infiltration"],
+                    "Ventilation": results["heating"]["component_loads"]["ventilation"]
+                }
+                
+                fig_heating = px.bar(
+                    x=list(heating_breakdown.keys()),
+                    y=list(heating_breakdown.values()),
+                    title="Heating Load by Component",
+                    labels={"x": "Component", "y": "Load (kW)"},
+                    color_discrete_sequence=px.colors.qualitative.Pastel
+                )
+                
+                fig_heating.update_layout(showlegend=False)
+                st.plotly_chart(fig_heating, use_container_width=True)
+    
+    def _display_psychrometric_analysis(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display psychrometric analysis visualization.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("Psychrometric Analysis")
+        
+        if not session_state["calculation_results"].get("cooling"):
+            st.warning("Psychrometric analysis requires cooling load results.")
+            return
+        
+        # Use psychrometric visualization module
+        self.psychrometric_visualization.display_psychrometric_chart(
+            session_state["calculation_results"],
+            session_state["building_info"]
+        )
+    
+    def _display_time_analysis(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display time-based analysis visualization.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("Time Analysis")
+        
+        if not session_state["calculation_results"].get("cooling"):
+            st.warning("Time analysis requires cooling load results.")
+            return
+        
+        # Use time-based visualization module
+        self.time_based_visualization.display_time_analysis(
+            session_state["calculation_results"]
+        )
+    
+    def _display_scenario_comparison(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display scenario comparison visualization.
+        
+        Args:
+            session_state: Streamlit session state containing calculation results
+        """
+        st.subheader("Scenario Comparison")
+        
+        # Check if there are saved scenarios
+        if "saved_scenarios" not in session_state or not session_state["saved_scenarios"]:
+            st.info("No saved scenarios available for comparison. Save the current results as a scenario to enable comparison.")
+            
+            # Add button to save current results as a scenario
+            scenario_name = st.text_input("Scenario Name", value="Baseline")
+            
+            if st.button("Save Current Results as Scenario"):
+                if "saved_scenarios" not in session_state:
+                    session_state["saved_scenarios"] = {}
+                
+                # Save current results as a scenario
+                session_state["saved_scenarios"][scenario_name] = {
+                    "results": session_state["calculation_results"],
+                    "building_info": session_state["building_info"],
+                    "components": session_state["components"],
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                }
+                
+                st.success(f"Scenario '{scenario_name}' saved successfully!")
+                st.rerun()
+        else:
+            # Use scenario comparison module
+            self.scenario_comparison.display_scenario_comparison(
+                session_state["calculation_results"],
+                session_state["saved_scenarios"]
+            )
+            
+            # Add button to save current results as a new scenario
+            st.write("### Save Current Results as New Scenario")
+            
+            scenario_name = st.text_input("Scenario Name", value="Scenario " + str(len(session_state["saved_scenarios"]) + 1))
+            
+            if st.button("Save Current Results as Scenario"):
+                # Save current results as a scenario
+                session_state["saved_scenarios"][scenario_name] = {
+                    "results": session_state["calculation_results"],
+                    "building_info": session_state["building_info"],
+                    "components": session_state["components"],
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                }
+                
+                st.success(f"Scenario '{scenario_name}' saved successfully!")
+                st.rerun()
+            
+            # Add button to delete a scenario
+            st.write("### Delete Scenario")
+            
+            scenario_to_delete = st.selectbox(
+                "Select Scenario to Delete",
+                options=list(session_state["saved_scenarios"].keys())
+            )
+            
+            if st.button("Delete Selected Scenario"):
+                # Delete selected scenario
+                del session_state["saved_scenarios"][scenario_to_delete]
+                
+                st.success(f"Scenario '{scenario_to_delete}' deleted successfully!")
+                st.rerun()
+
+
+# Create a singleton instance
+results_display = ResultsDisplay()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Initialize session state with dummy data for testing
+    if "calculation_results" not in st.session_state:
+        st.session_state["calculation_results"] = {
+            "cooling": {
+                "total_load": 25.5,
+                "sensible_load": 20.0,
+                "latent_load": 5.5,
+                "load_per_area": 85.0,
+                "component_loads": {
+                    "walls": 5.0,
+                    "roof": 3.0,
+                    "windows": 8.0,
+                    "doors": 1.0,
+                    "people": 2.5,
+                    "lighting": 2.0,
+                    "equipment": 1.5,
+                    "infiltration": 1.0,
+                    "ventilation": 1.5
+                },
+                "detailed_loads": {
+                    "walls": [
+                        {"name": "North Wall", "orientation": "NORTH", "area": 20.0, "u_value": 0.5, "cltd": 10.0, "load": 1.0}
+                    ],
+                    "roofs": [
+                        {"name": "Main Roof", "orientation": "HORIZONTAL", "area": 100.0, "u_value": 0.3, "cltd": 15.0, "load": 3.0}
+                    ],
+                    "windows": [
+                        {"name": "South Window", "orientation": "SOUTH", "area": 10.0, "u_value": 2.8, "shgc": 0.7, "scl": 800.0, "load": 8.0}
+                    ],
+                    "doors": [
+                        {"name": "Main Door", "orientation": "NORTH", "area": 2.0, "u_value": 2.0, "cltd": 10.0, "load": 1.0}
+                    ],
+                    "internal": [
+                        {"type": "People", "name": "Occupants", "quantity": 10, "heat_gain": 250, "clf": 1.0, "load": 2.5},
+                        {"type": "Lighting", "name": "General Lighting", "quantity": 1000, "heat_gain": 2000, "clf": 1.0, "load": 2.0},
+                        {"type": "Equipment", "name": "Office Equipment", "quantity": 5, "heat_gain": 300, "clf": 1.0, "load": 1.5}
+                    ],
+                    "infiltration": {
+                        "air_flow": 0.05,
+                        "sensible_load": 0.8,
+                        "latent_load": 0.2,
+                        "total_load": 1.0
+                    },
+                    "ventilation": {
+                        "air_flow": 0.1,
+                        "sensible_load": 1.0,
+                        "latent_load": 0.5,
+                        "total_load": 1.5
+                    }
+                }
+            },
+            "heating": {
+                "total_load": 30.0,
+                "load_per_area": 100.0,
+                "design_heat_loss": 27.0,
+                "safety_factor": 10.0,
+                "component_loads": {
+                    "walls": 8.0,
+                    "roof": 5.0,
+                    "floor": 4.0,
+                    "windows": 7.0,
+                    "doors": 1.0,
+                    "infiltration": 2.0,
+                    "ventilation": 3.0
+                },
+                "detailed_loads": {
+                    "walls": [
+                        {"name": "North Wall", "orientation": "NORTH", "area": 20.0, "u_value": 0.5, "delta_t": 25.0, "load": 8.0}
+                    ],
+                    "roofs": [
+                        {"name": "Main Roof", "orientation": "HORIZONTAL", "area": 100.0, "u_value": 0.3, "delta_t": 25.0, "load": 5.0}
+                    ],
+                    "floors": [
+                        {"name": "Ground Floor", "area": 100.0, "u_value": 0.4, "delta_t": 10.0, "load": 4.0}
+                    ],
+                    "windows": [
+                        {"name": "South Window", "orientation": "SOUTH", "area": 10.0, "u_value": 2.8, "delta_t": 25.0, "load": 7.0}
+                    ],
+                    "doors": [
+                        {"name": "Main Door", "orientation": "NORTH", "area": 2.0, "u_value": 2.0, "delta_t": 25.0, "load": 1.0}
+                    ],
+                    "infiltration": {
+                        "air_flow": 0.05,
+                        "delta_t": 25.0,
+                        "load": 2.0
+                    },
+                    "ventilation": {
+                        "air_flow": 0.1,
+                        "delta_t": 25.0,
+                        "load": 3.0
+                    }
+                }
+            }
+        }
+    
+    # Display results
+    results_display.display_results(st.session_state)

data/ashrae_tables.py

@@ -0,0 +1,744 @@
+"""
+ASHRAE tables module for HVAC Load Calculator.
+Integrates CLTD, SCL, CLF tables, cooling load calculations, climatic corrections, and visualization.
+Combines data from original ashrae_tables.py and enhanced versions with ashrae_tables (3).py.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import matplotlib.pyplot as plt
+from enum import Enum
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+
+class WallGroup(Enum):
+    """Enumeration for ASHRAE wall groups."""
+    A = "A"  # Light construction
+    B = "B"
+    C = "C"
+    D = "D"
+    E = "E"
+    F = "F"
+    G = "G"
+    H = "H"  # Heavy construction
+
+class RoofGroup(Enum):
+    """Enumeration for ASHRAE roof groups."""
+    A = "A"  # Light construction
+    B = "B"
+    C = "C"
+    D = "D"
+    E = "E"
+    F = "F"
+    G = "G"  # Heavy construction
+
+class Orientation(Enum):
+    """Enumeration for building component orientations."""
+    N = "North"
+    NE = "Northeast"
+    E = "East"
+    SE = "Southeast"
+    S = "South"
+    SW = "Southwest"
+    W = "West"
+    NW = "Northwest"
+    HOR = "Horizontal"  # For roofs and floors
+
+class ASHRAETables:
+    """Class for managing ASHRAE tables for load calculations."""
+    
+    def __init__(self):
+        """Initialize ASHRAE tables."""
+        # Load tables
+        self.cltd_wall = self._load_cltd_wall_table()
+        self.cltd_roof = self._load_cltd_roof_table()
+        self.scl = self._load_scl_table()
+        self.clf_lights = self._load_clf_lights_table()
+        self.clf_people = self._load_clf_people_table()
+        self.clf_equipment = self._load_clf_equipment_table()
+        self.heat_gain = self._load_heat_gain_table()
+        
+        # Load correction factors
+        self.latitude_correction = self._load_latitude_correction()
+        self.color_correction = self._load_color_correction()
+        self.month_correction = self._load_month_correction()
+        
+        # Load thermal properties and roof classifications
+        self.thermal_properties = self._load_thermal_properties()
+        self.roof_classifications = self._load_roof_classifications()
+
+    def _validate_cltd_inputs(self, group: str, orientation: str, hour: int, latitude: str, month: str, color: str, is_wall: bool = True) -> Tuple[bool, str]:
+        """Validate inputs for CLTD calculations."""
+        valid_groups = [e.value for e in WallGroup] if is_wall else [e.value for e in RoofGroup]
+        valid_orientations = [e.value for e in Orientation]
+        valid_latitudes = ['24N', '32N', '40N', '48N', '56N']
+        valid_months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+        valid_colors = ['Dark', 'Medium', 'Light']
+    
+        if group not in valid_groups:
+            return False, f"Invalid {'wall' if is_wall else 'roof'} group: {group}. Valid groups: {valid_groups}"
+        if orientation not in valid_orientations:
+            return False, f"Invalid orientation: {orientation}. Valid orientations: {valid_orientations}"
+        if hour not in range(24):
+            return False, "Hour must be between 0 and 23."
+            
+        # Handle numeric latitude values and ensure comprehensive mapping
+        if latitude not in valid_latitudes:
+            # Try to convert numeric latitude to standard format
+            try:
+                # First, handle string representations that might contain direction indicators
+                if isinstance(latitude, str):
+                    # Extract numeric part, removing 'N' or 'S'
+                    lat_str = latitude.upper().strip()
+                    num_part = ''.join(c for c in lat_str if c.isdigit() or c == '.')
+                    lat_val = float(num_part)
+                    
+                    # Adjust for southern hemisphere if needed
+                    if 'S' in lat_str:
+                        lat_val = -lat_val
+                else:
+                    # Handle direct numeric input
+                    lat_val = float(latitude)
+                
+                # Take absolute value for mapping purposes
+                abs_lat = abs(lat_val)
+                
+                # Map to the closest standard latitude
+                if abs_lat < 28:
+                    mapped_latitude = '24N'
+                elif abs_lat < 36:
+                    mapped_latitude = '32N'
+                elif abs_lat < 44:
+                    mapped_latitude = '40N'
+                elif abs_lat < 52:
+                    mapped_latitude = '48N'
+                else:
+                    mapped_latitude = '56N'
+                
+                # Use the mapped latitude for validation
+                latitude = mapped_latitude
+                
+            except (ValueError, TypeError):
+                return False, f"Invalid latitude: {latitude}. Valid latitudes: {valid_latitudes}"
+                
+        if latitude not in valid_latitudes:
+            return False, f"Invalid latitude: {latitude}. Valid latitudes: {valid_latitudes}"
+            
+        if month not in valid_months:
+            return False, f"Invalid month: {month}. Valid months: {valid_months}"
+        if color not in valid_colors:
+            return False, f"Invalid color: {color}. Valid colors: {valid_colors}"
+        return True, "Valid inputs."  
+
+    def _load_cltd_wall_table(self) -> Dict[str, pd.DataFrame]:
+        """
+        Load CLTD tables for walls at 24°N (July).
+        Returns: Dictionary of DataFrames with CLTD values for each wall group.
+        """
+        hours = list(range(24))
+        # CLTD data for wall types 1-12 mapped to groups A-H
+        wall_data = {
+            "A": {  # Type 1: Lightest construction
+                'N': [1, 0, -1, -2, -3, -2, 5, 13, 17, 18, 19, 22, 26, 28, 30, 32, 34, 34, 27, 17, 11, 7, 5, 3],
+                'NE': [1, 0, -1, -2, -3, 0, 17, 39, 51, 53, 48, 39, 32, 30, 30, 30, 30, 28, 24, 18, 13, 10, 7, 5],
+                'E': [1, 0, -1, -2, -3, 0, 18, 44, 59, 63, 59, 48, 36, 32, 31, 30, 32, 32, 29, 24, 19, 13, 10, 7],
+                'SE': [1, 0, -1, -2, -3, -2, 8, 25, 38, 44, 45, 42, 35, 32, 31, 30, 32, 32, 27, 24, 18, 13, 10, 7],
+                'S': [1, 0, -1, -2, -3, -3, -1, 3, 8, 12, 18, 24, 29, 31, 31, 30, 32, 32, 27, 23, 18, 13, 9, 7],
+                'SW': [1, 0, 1, 2, 3, 3, 1, 3, 8, 13, 17, 22, 27, 42, 59, 73, 30, 32, 27, 23, 18, 20, 12, 8],
+                'W': [2, 0, 2, 2, 3, 1, 3, 8, 13, 17, 22, 27, 42, 59, 73, 30, 32, 27, 23, 18, 20, 12, 8, 5],
+                'NW': [2, 0, 1, 2, 2, 3, 1, 3, 8, 13, 17, 22, 27, 42, 59, 73, 30, 32, 27, 23, 18, 20, 12, 8]
+            },
+            "B": {  # Type 2
+                'N': [2, 1, 0, -1, -2, -1, 6, 14, 18, 19, 20, 23, 27, 29, 31, 33, 35, 35, 28, 18, 12, 8, 6, 4],
+                'NE': [2, 1, 0, -1, -2, 1, 18, 40, 52, 54, 49, 40, 33, 31, 31, 31, 31, 29, 25, 19, 14, 11, 8, 6],
+                'E': [2, 1, 0, -1, -2, 1, 19, 45, 60, 64, 60, 49, 37, 33, 32, 31, 33, 33, 30, 25, 20, 14, 11, 8],
+                'SE': [2, 1, 0, -1, -2, -1, 9, 26, 39, 45, 46, 43, 36, 33, 32, 31, 33, 33, 28, 25, 19, 14, 11, 8],
+                'S': [2, 1, 0, -1, -2, -2, 0, 4, 9, 13, 19, 25, 30, 32, 32, 31, 33, 33, 28, 24, 19, 14, 10, 8],
+                'SW': [2, 1, 2, 3, 4, 4, 2, 4, 9, 14, 18, 23, 28, 43, 60, 74, 31, 33, 28, 24, 19, 21, 13, 9],
+                'W': [3, 1, 3, 3, 4, 2, 4, 9, 14, 18, 23, 28, 43, 60, 74, 31, 33, 28, 24, 19, 21, 13, 9, 6],
+                'NW': [3, 1, 2, 3, 3, 4, 2, 4, 9, 14, 18, 23, 28, 43, 60, 74, 31, 33, 28, 24, 19, 21, 13, 9]
+            },
+            "C": {  # Type 3
+                'N': [3, 2, 1, 0, -1, 0, 7, 15, 19, 20, 21, 24, 28, 30, 32, 34, 36, 36, 29, 19, 13, 9, 7, 5],
+                'NE': [3, 2, 1, 0, -1, 2, 19, 41, 53, 55, 50, 41, 34, 32, 32, 32, 32, 30, 26, 20, 15, 12, 9, 7],
+                'E': [3, 2, 1, 0, -1, 2, 20, 46, 61, 65, 61, 50, 38, 34, 33, 32, 34, 34, 31, 26, 21, 15, 12, 9],
+                'SE': [3, 2, 1, 0, -1, 0, 10, 27, 40, 46, 47, 44, 37, 34, 33, 32, 34, 34, 29, 26, 20, 15, 12, 9],
+                'S': [3, 2, 1, 0, -1, -1, 1, 5, 10, 14, 20, 26, 31, 33, 33, 32, 34, 34, 29, 25, 20, 15, 11, 9],
+                'SW': [3, 2, 3, 4, 5, 5, 3, 5, 10, 15, 19, 24, 29, 44, 61, 75, 32, 34, 29, 25, 20, 22, 14, 10],
+                'W': [4, 2, 4, 4, 5, 3, 5, 10, 15, 19, 24, 29, 44, 61, 75, 32, 34, 29, 25, 20, 22, 14, 10, 7],
+                'NW': [4, 2, 3, 4, 4, 5, 3, 5, 10, 15, 19, 24, 29, 44, 61, 75, 32, 34, 29, 25, 20, 22, 14, 10]
+            },
+            "D": {  # Type 4
+                'N': [4, 3, 2, 1, 0, 1, 8, 16, 20, 21, 22, 25, 29, 31, 33, 35, 37, 37, 30, 20, 14, 10, 8, 6],
+                'NE': [4, 3, 2, 1, 0, 3, 20, 42, 54, 56, 51, 42, 35, 33, 33, 33, 33, 31, 27, 21, 16, 13, 10, 8],
+                'E': [4, 3, 2, 1, 0, 3, 21, 47, 62, 66, 62, 51, 39, 35, 34, 33, 35, 35, 32, 27, 22, 16, 13, 10],
+                'SE': [4, 3, 2, 1, 0, 1, 11, 28, 41, 47, 48, 45, 38, 35, 34, 33, 35, 35, 30, 27, 21, 16, 13, 10],
+                'S': [4, 3, 2, 1, 0, 0, 2, 6, 11, 15, 21, 27, 32, 34, 34, 33, 35, 35, 30, 26, 21, 16, 12, 10],
+                'SW': [4, 3, 4, 5, 6, 6, 4, 6, 11, 16, 20, 25, 30, 45, 62, 76, 33, 35, 30, 26, 21, 23, 15, 11],
+                'W': [5, 3, 5, 5, 6, 4, 6, 11, 16, 20, 25, 30, 45, 62, 76, 33, 35, 30, 26, 21, 23, 15, 11, 8],
+                'NW': [5, 3, 4, 5, 5, 6, 4, 6, 11, 16, 20, 25, 30, 45, 62, 76, 33, 35, 30, 26, 21, 23, 15, 11]
+            },
+            "E": {  # Type 5
+                'N': [13, 11, 9, 7, 5, 3, 2, 3, 5, 7, 10, 12, 14, 16, 19, 21, 23, 25, 27, 27, 25, 22, 20, 16],
+                'NE': [13, 11, 8, 7, 5, 3, 3, 6, 12, 20, 26, 31, 33, 33, 32, 32, 32, 33, 31, 29, 27, 24, 21, 18],
+                'E': [14, 11, 9, 7, 5, 4, 3, 6, 13, 22, 31, 36, 39, 39, 39, 39, 39, 31, 31, 29, 26, 22, 19, 18],
+                'SE': [13, 10, 8, 6, 5, 3, 2, 4, 8, 14, 20, 25, 28, 30, 30, 30, 30, 30, 28, 26, 24, 21, 18, 16],
+                'S': [11, 9, 7, 6, 4, 3, 2, 1, 1, 3, 5, 7, 11, 14, 16, 20, 22, 23, 23, 23, 20, 18, 16, 14],
+                'SW': [18, 15, 12, 9, 7, 5, 3, 3, 3, 4, 5, 8, 11, 14, 16, 20, 26, 32, 33, 31, 41, 40, 36, 31],
+                'W': [23, 19, 15, 12, 9, 7, 5, 4, 4, 4, 6, 8, 11, 14, 16, 20, 28, 37, 35, 31, 51, 41, 41, 41],
+                'NW': [21, 17, 14, 11, 8, 6, 4, 3, 3, 4, 6, 8, 11, 14, 16, 20, 28, 37, 35, 31, 41, 41, 41, 41]
+            },
+            "F": {  # Type 6
+                'N': [10, 8, 6, 4, 2, 1, 1, 2, 4, 6, 9, 11, 13, 15, 18, 20, 22, 24, 26, 26, 24, 21, 19, 15],
+                'NE': [10, 8, 6, 4, 2, 2, 2, 5, 11, 19, 25, 30, 32, 32, 31, 31, 31, 32, 30, 28, 26, 23, 20, 17],
+                'E': [11, 8, 6, 4, 2, 3, 2, 5, 12, 21, 30, 35, 38, 38, 38, 38, 38, 30, 30, 28, 25, 21, 18, 17],
+                'SE': [10, 7, 5, 3, 2, 2, 1, 3, 7, 13, 19, 24, 27, 29, 29, 29, 29, 29, 27, 25, 23, 20, 17, 15],
+                'S': [8, 6, 4, 3, 1, 2, 1, 0, 0, 2, 4, 6, 10, 13, 15, 19, 21, 22, 22, 22, 19, 17, 15, 13],
+                'SW': [15, 12, 9, 6, 4, 3, 2, 2, 2, 3, 4, 7, 10, 13, 15, 19, 25, 31, 32, 30, 40, 39, 35, 30],
+                'W': [20, 16, 12, 9, 6, 4, 3, 3, 3, 3, 5, 7, 10, 13, 15, 19, 27, 36, 34, 30, 50, 40, 40, 40],
+                'NW': [18, 14, 11, 8, 5, 4, 3, 2, 2, 3, 5, 7, 10, 13, 15, 19, 27, 36, 34, 30, 40, 40, 40, 40]
+            },
+            "G": {  # Type 7
+                'N': [7, 5, 3, 1, -1, 0, 0, 1, 3, 5, 8, 10, 12, 14, 17, 19, 21, 23, 25, 25, 23, 20, 18, 14],
+                'NE': [7, 5, 3, 1, -1, 1, 1, 4, 10, 18, 24, 29, 31, 31, 30, 30, 30, 31, 29, 27, 25, 22, 19, 16],
+                'E': [8, 5, 3, 1, -1, 2, 1, 4, 11, 20, 29, 34, 37, 37, 37, 37, 37, 29, 29, 27, 24, 20, 17, 16],
+                'SE': [7, 4, 2, 0, -1, 1, 0, 2, 6, 12, 18, 23, 26, 28, 28, 28, 28, 28, 26, 24, 22, 19, 16, 14],
+                'S': [5, 3, 1, 0, -2, 1, 0, -1, -1, 1, 3, 5, 9, 12, 14, 18, 20, 21, 21, 21, 18, 16, 14, 12],
+                'SW': [12, 9, 6, 3, 1, 2, 1, 1, 1, 2, 3, 6, 9, 12, 14, 18, 24, 30, 31, 29, 39, 38, 34, 29],
+                'W': [17, 13, 9, 6, 3, 2, 2, 2, 2, 2, 4, 6, 9, 12, 14, 18, 26, 35, 33, 29, 49, 39, 39, 39],
+                'NW': [15, 11, 8, 5, 2, 3, 2, 1, 1, 2, 4, 6, 9, 12, 14, 18, 26, 35, 33, 29, 39, 39, 39, 39]
+            },
+            "H": {  # Interpolated from types 8-12: Heaviest construction
+                'N': [4, 2, 0, -2, -4, -1, -1, 0, 2, 4, 7, 9, 11, 13, 16, 18, 20, 22, 24, 24, 22, 19, 17, 13],
+                'NE': [4, 2, 0, -2, -4, 0, 0, 3, 9, 17, 23, 28, 30, 30, 29, 29, 29, 30, 28, 26, 24, 21, 18, 15],
+                'E': [5, 2, 0, -2, -4, 1, 0, 3, 10, 19, 28, 33, 36, 36, 36, 36, 36, 28, 28, 26, 23, 19, 16, 15],
+                'SE': [4, 1, -1, -3, -4, 0, -1, 1, 5, 11, 17, 22, 25, 27, 27, 27, 27, 27, 25, 23, 21, 18, 15, 13],
+                'S': [2, 0, -2, -3, -5, 0, -1, -2, -2, 0, 2, 4, 8, 11, 13, 17, 19, 20, 20, 20, 17, 15, 13, 11],
+                'SW': [9, 6, 3, 0, -2, 1, 0, 0, 0, 1, 2, 5, 8, 11, 13, 17, 23, 29, 30, 28, 38, 37, 33, 28],
+                'W': [14, 10, 6, 3, 0, 1, 1, 1, 1, 1, 3, 5, 8, 11, 13, 17, 25, 34, 32, 28, 48, 38, 38, 38],
+                'NW': [12, 8, 5, 2, -1, 2, 1, 0, 0, 1, 3, 5, 8, 11, 13, 17, 25, 34, 32, 28, 38, 38, 38, 38]
+            }
+        }
+        wall_groups = {group: pd.DataFrame(data, index=hours) for group, data in wall_data.items()}
+        return wall_groups
+
+    def _load_cltd_roof_table(self) -> Dict[str, pd.DataFrame]:
+        """
+        Load CLTD tables for roofs at 24°N, 36°N, 48°N (July).
+        Returns: Dictionary of DataFrames with CLTD values for each roof group and latitude.
+        """
+        hours = list(range(24))
+        # CLTD data for roof types mapped to groups A-G across latitudes
+        roof_data = {
+            "24N": {
+                "A": [0, 4, 5, 6, 6, 3, 9, 16, 44, 62, 76, 87, 92, 92, 86, 74, 58, 39, 23, 14, 8, 4, 2, 0],  # Type 1
+                "B": [12, 8, 5, 2, 0, -2, -2, 3, 11, 22, 35, 47, 59, 68, 74, 77, 74, 68, 58, 47, 37, 29, 22, 16],  # Type 3
+                "C": [21, 16, 12, 8, 5, 3, 1, 1, 1, 10, 19, 20, 22, 23, 49, 49, 54, 58, 58, 56, 52, 47, 42, 37],  # Type 5
+                "D": [31, 25, 20, 16, 12, 9, 6, 4, 3, 5, 10, 17, 26, 36, 46, 54, 61, 65, 66, 63, 58, 51, 44, 47],  # Type 9
+                "E": [34, 31, 28, 25, 22, 20, 17, 16, 15, 19, 23, 28, 29, 32, 38, 38, 43, 43, 49, 49, 49, 46, 43, 40],  # Type 13
+                "F": [35, 32, 30, 28, 25, 23, 21, 19, 20, 22, 23, 23, 24, 25, 39, 39, 40, 40, 40, 45, 46, 46, 44, 42],  # Type 14
+                "G": [36, 33, 31, 29, 27, 25, 23, 21, 20, 22, 24, 25, 26, 27, 40, 41, 42, 42, 42, 47, 48, 48, 45, 43]  # Interpolated
+            },
+            "36N": {
+                "A": [0, 2, 4, 5, 6, 6, 12, 28, 45, 61, 75, 84, 90, 90, 84, 79, 71, 62, 66, 59, 50, 42, 47, 0],  # Type 1
+                "B": [12, 8, 5, 2, 0, -2, -1, 14, 13, 24, 25, 26, 27, 28, 38, 39, 40, 40, 43, 45, 46, 46, 43, 40],  # Type 3
+                "C": [21, 16, 12, 8, 5, 3, 1, 12, 15, 12, 21, 22, 23, 32, 39, 40, 40, 40, 40, 45, 46, 46, 43, 40],  # Type 5
+                "D": [32, 26, 21, 16, 13, 10, 8, 14, 17, 19, 20, 22, 23, 24, 39, 40, 40, 40, 40, 45, 46, 46, 43, 40],  # Type 9
+                "E": [34, 31, 28, 25, 23, 20, 18, 16, 16, 20, 22, 22, 23, 24, 39, 39, 40, 40, 40, 45, 46, 46, 44, 42],  # Type 13
+                "F": [35, 32, 30, 28, 25, 23, 21, 19, 20, 22, 23, 23, 24, 25, 39, 39, 40, 40, 40, 45, 46, 46, 44, 42],  # Type 14
+                "G": [36, 33, 31, 29, 27, 25, 23, 21, 20, 22, 24, 25, 26, 27, 40, 41, 42, 42, 42, 47, 48, 48, 45, 43]  # Interpolated
+            },
+            "48N": {
+                "A": [0, 2, 4, 5, 6, 5, 3, 15, 29, 44, 58, 69, 78, 83, 83, 79, 71, 59, 44, 49, 49, 49, 5, 2],  # Type 1
+                "B": [12, 8, 5, 2, 0, -1, 1, 16, 16, 20, 22, 23, 24, 25, 39, 39, 40, 40, 40, 45, 46, 46, 43, 40],  # Type 3
+                "C": [21, 16, 12, 8, 5, 3, 2, 16, 19, 20, 22, 23, 24, 25, 39, 39, 40, 40, 40, 45, 46, 46, 43, 40],  # Type 5
+                "D": [31, 26, 21, 16, 12, 9, 6, 5, 5, 20, 22, 23, 24, 25, 39, 39, 40, 40, 40, 45, 46, 46, 43, 40],  # Type 9
+                "E": [33, 30, 27, 25, 22, 20, 17, 16, 16, 20, 22, 23, 24, 25, 39, 39, 40, 40, 40, 47, 48, 47, 45, 40],  # Type 13
+                "F": [34, 32, 29, 27, 25, 23, 21, 20, 19, 20, 22, 23, 24, 25, 39, 39, 40, 40, 40, 48, 48, 48, 43, 40],  # Type 14
+                "G": [35, 33, 31, 29, 27, 25, 23, 21, 20, 22, 24, 25, 26, 27, 40, 41, 42, 42, 42, 48, 49, 49, 45, 43]  # Interpolated
+            }
+        }
+        roof_groups = {}
+        for lat, groups in roof_data.items():
+            for group, data in groups.items():
+                roof_groups[f"{group}_{lat}"] = pd.DataFrame({"HOR": data}, index=hours)
+        return roof_groups
+
+    def _load_scl_table(self) -> Dict[str, pd.DataFrame]:
+        """
+        Load SCL (Solar Cooling Load) tables for windows.
+        Returns: Dictionary of DataFrames with SCL values for each latitude/month.
+        """
+        hours = list(range(24))
+        # Base SCL data for 40°N (July)
+        scl_40n_jul = {
+            "N": [11, 8, 6, 6, 6, 9, 13, 16, 19, 21, 22, 23, 23, 22, 20, 17, 14, 11, 11, 11, 11, 11, 11, 11],
+            "NE": [11, 8, 6, 6, 6, 19, 75, 113, 121, 103, 75, 40, 31, 27, 23, 19, 14, 11, 11, 11, 11, 11, 11, 11],
+            "E": [11, 8, 6, 6, 6, 13, 55, 159, 232, 251, 222, 157, 82, 43, 32, 24, 17, 11, 11, 11, 11, 11, 11, 11],
+            "SE": [11, 8, 6, 6, 6, 10, 33, 98, 187, 251, 276, 264, 214, 139, 74, 37, 21, 11, 11, 11, 11, 11, 11, 11],
+            "S": [11, 8, 6, 6, 6, 8, 14, 27, 66, 139, 209, 254, 268, 251, 203, 139, 66, 27, 14, 11, 11, 11, 11, 11],
+            "SW": [11, 8, 6, 6, 6, 8, 14, 19, 24, 37, 74, 139, 214, 264, 276, 251, 187, 98, 33, 14, 11, 11, 11, 11],
+            "W": [11, 8, 6, 6, 6, 8, 14, 19, 24, 32, 43, 82, 157, 222, 251, 232, 159, 55, 13, 11, 11, 11, 11, 11],
+            "NW": [11, 8, 6, 6, 6, 8, 14, 19, 24, 27, 31, 40, 75, 103, 121, 113, 75, 19, 11, 11, 11, 11, 11, 11],
+            "HOR": [11, 8, 6, 6, 6, 19, 69, 135, 201, 254, 290, 308, 308, 290, 254, 201, 135, 69, 19, 11, 11, 11, 11, 11]
+        }
+        scl_tables = {"40N_Jul": pd.DataFrame(scl_40n_jul, index=hours)}
+        latitudes = ["24N", "32N", "40N", "48N", "56N"]
+        months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        for lat in latitudes:
+            for month in months:
+                key = f"{lat}_{month}"
+                if key == "40N_Jul":
+                    continue
+                lat_factor = (40 - float(lat[:-1])) / 40
+                month_idx = months.index(month)
+                month_factor = 1 + (month_idx - 6) / 24
+                scl_data = {}
+                for orient in scl_40n_jul:
+                    base_scl = scl_40n_jul[orient]
+                    scl_data[orient] = [max(6, round(v * (1 - lat_factor * 0.2) * month_factor)) for v in base_scl]
+                scl_tables[key] = pd.DataFrame(scl_data, index=hours)
+        return scl_tables
+
+    def _load_clf_lights_table(self) -> pd.DataFrame:
+        """
+        Load CLF (Cooling Load Factor) table for lights.
+        Returns: DataFrame with CLF values for lights by zone type and hours.
+        """
+        hours = list(range(24))
+        clf_lights_data = {
+            "A_8h": [0.85, 0.92, 0.95, 0.95, 0.97, 0.97, 0.98, 0.13, 0.06, 0.04, 0.03, 0.02, 0.02, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "A_10h": [0.85, 0.93, 0.95, 0.97, 0.97, 0.98, 0.98, 0.98, 0.98, 0.98, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "A_12h": [0.86, 0.93, 0.96, 0.97, 0.97, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "B_8h": [0.75, 0.85, 0.90, 0.93, 0.94, 0.95, 0.95, 0.95, 0.12, 0.08, 0.05, 0.04, 0.04, 0.03, 0.03, 0.03, 0.03, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "B_10h": [0.75, 0.86, 0.91, 0.93, 0.94, 0.95, 0.95, 0.95, 0.96, 0.97, 0.24, 0.13, 0.08, 0.06, 0.05, 0.04, 0.04, 0.03, 0.03, 0.03, 0.03, 0.03, 0.02, 0.02],
+            "B_12h": [0.76, 0.86, 0.91, 0.93, 0.95, 0.95, 0.95, 0.95, 0.97, 0.97, 0.97, 0.97, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03, 0.03],
+            "C_8h": [0.70, 0.80, 0.85, 0.88, 0.90, 0.92, 0.93, 0.94, 0.10, 0.07, 0.04, 0.03, 0.03, 0.02, 0.02, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "C_10h": [0.70, 0.81, 0.86, 0.89, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.20, 0.11, 0.07, 0.05, 0.04, 0.03, 0.03, 0.02, 0.02, 0.02, 0.02, 0.02, 0.01, 0.01],
+            "C_12h": [0.71, 0.82, 0.87, 0.90, 0.92, 0.93, 0.94, 0.95, 0.96, 0.96, 0.96, 0.96, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "D_8h": [0.65, 0.75, 0.80, 0.83, 0.85, 0.87, 0.88, 0.89, 0.08, 0.06, 0.03, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "D_10h": [0.65, 0.76, 0.81, 0.84, 0.86, 0.88, 0.89, 0.90, 0.91, 0.92, 0.16, 0.09, 0.06, 0.04, 0.03, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "D_12h": [0.66, 0.77, 0.82, 0.85, 0.87, 0.89, 0.90, 0.91, 0.92, 0.92, 0.92, 0.92, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01]
+        }
+        return pd.DataFrame(clf_lights_data, index=hours)
+
+    def _load_clf_people_table(self) -> pd.DataFrame:
+        """
+        Load CLF (Cooling Load Factor) table for people.
+        Returns: DataFrame with CLF values for people by zone type and hours.
+        """
+        hours = list(range(24))
+        clf_people_data = {
+            "A_2h": [0.75, 0.88, 0.18, 0.08, 0.04, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "A_4h": [0.75, 0.88, 0.93, 0.95, 0.97, 0.10, 0.05, 0.03, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "A_6h": [0.75, 0.88, 0.93, 0.95, 0.97, 0.97, 0.33, 0.11, 0.06, 0.04, 0.03, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "B_2h": [0.65, 0.75, 0.81, 0.85, 0.89, 0.91, 0.93, 0.95, 0.96, 0.97, 0.98, 0.98, 0.99, 0.99, 0.99, 0.99, 0.99, 0.99, 0.99, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "B_4h": [0.65, 0.75, 0.82, 0.87, 0.90, 0.92, 0.94, 0.95, 0.96, 0.97, 0.98, 0.98, 0.99, 0.99, 0.99, 0.99, 0.99, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "B_6h": [0.65, 0.75, 0.82, 0.87, 0.90, 0.92, 0.94, 0.95, 0.96, 0.97, 0.98, 0.98, 0.99, 0.99, 0.99, 0.99, 0.99, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "C_2h": [0.60, 0.70, 0.76, 0.80, 0.84, 0.86, 0.88, 0.90, 0.91, 0.92, 0.93, 0.93, 0.94, 0.94, 0.94, 0.94, 0.94, 0.94, 0.94, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "C_4h": [0.60, 0.70, 0.77, 0.82, 0.85, 0.87, 0.89, 0.90, 0.91, 0.92, 0.93, 0.93, 0.94, 0.94, 0.94, 0.94, 0.94, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "C_6h": [0.60, 0.70, 0.77, 0.82, 0.85, 0.87, 0.89, 0.90, 0.91, 0.92, 0.93, 0.93, 0.94, 0.94, 0.94, 0.94, 0.94, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "D_2h": [0.55, 0.65, 0.71, 0.75, 0.79, 0.81, 0.83, 0.85, 0.86, 0.87, 0.88, 0.88, 0.89, 0.89, 0.89, 0.89, 0.89, 0.89, 0.89, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "D_4h": [0.55, 0.65, 0.72, 0.77, 0.80, 0.82, 0.84, 0.85, 0.86, 0.87, 0.88, 0.88, 0.89, 0.89, 0.89, 0.89, 0.89, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "D_6h": [0.55, 0.65, 0.72, 0.77, 0.80, 0.82, 0.84, 0.85, 0.86, 0.87, 0.88, 0.88, 0.89, 0.89, 0.89, 0.89, 0.89, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00]
+        }
+        return pd.DataFrame(clf_people_data, index=hours)
+
+    def _load_clf_equipment_table(self) -> pd.DataFrame:
+        """
+        Load CLF (Cooling Load Factor) table for equipment.
+        Returns: DataFrame with CLF values for equipment by zone type and hours.
+        """
+        hours = list(range(24))
+        clf_equipment_data = {
+            "A_2h": [0.54, 0.83, 0.26, 0.11, 0.05, 0.03, 0.01, 0.01, 0.01, 0.01, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "A_4h": [0.64, 0.83, 0.90, 0.93, 0.31, 0.14, 0.07, 0.04, 0.03, 0.03, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "A_6h": [0.64, 0.83, 0.90, 0.93, 0.95, 0.95, 0.33, 0.11, 0.06, 0.04, 0.03, 0.02, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "B_2h": [0.50, 0.75, 0.81, 0.85, 0.89, 0.91, 0.93, 0.95, 0.96, 0.97, 0.98, 0.98, 0.99, 0.99, 0.99, 0.99, 0.99, 0.99, 0.99, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "B_4h": [0.50, 0.75, 0.82, 0.87, 0.90, 0.92, 0.94, 0.95, 0.96, 0.97, 0.98, 0.98, 0.99, 0.99, 0.99, 0.99, 0.99, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "B_6h": [0.50, 0.75, 0.82, 0.87, 0.90, 0.92, 0.94, 0.95, 0.96, 0.97, 0.98, 0.98, 0.99, 0.99, 0.99, 0.99, 0.99, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
+            "C_2h": [0.46, 0.70, 0.76, 0.80, 0.84, 0.86, 0.88, 0.90, 0.91, 0.92, 0.93, 0.93, 0.94, 0.94, 0.94, 0.94, 0.94, 0.94, 0.94, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "C_4h": [0.46, 0.70, 0.77, 0.82, 0.85, 0.87, 0.89, 0.90, 0.91, 0.92, 0.93, 0.93, 0.94, 0.94, 0.94, 0.94, 0.94, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "C_6h": [0.46, 0.70, 0.77, 0.82, 0.85, 0.87, 0.89, 0.90, 0.91, 0.92, 0.93, 0.93, 0.94, 0.94, 0.94, 0.94, 0.94, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
+            "D_2h": [0.42, 0.65, 0.71, 0.75, 0.79, 0.81, 0.83, 0.85, 0.86, 0.87, 0.88, 0.88, 0.89, 0.89, 0.89, 0.89, 0.89, 0.89, 0.89, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "D_4h": [0.42, 0.65, 0.72, 0.77, 0.80, 0.82, 0.84, 0.85, 0.86, 0.87, 0.88, 0.88, 0.89, 0.89, 0.89, 0.89, 0.89, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00],
+            "D_6h": [0.42, 0.65, 0.72, 0.77, 0.80, 0.82, 0.84, 0.85, 0.86, 0.87, 0.88, 0.88, 0.89, 0.89, 0.89, 0.89, 0.89, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00]
+        }
+        return pd.DataFrame(clf_equipment_data, index=hours)
+
+    def _load_heat_gain_table(self) -> pd.DataFrame:
+        """
+        Load heat gain table for internal sources.
+        Returns: DataFrame with heat gain values (Btu/h or Btu/h-ft²).
+        """
+        data = {
+            "source": ["people_sensible", "people_latent", "lights", "equipment"],
+            "gain": [250, 200, 3.4, 500]
+        }
+        return pd.DataFrame(data)
+
+    def _load_thermal_properties(self) -> pd.DataFrame:
+        """
+        Load thermal properties for building materials.
+        Returns: DataFrame with U-values, R-values, and density.
+        """
+        data = {
+            "material": [
+                "Brick_4in", "Brick_8in", "Concrete_6in", "Concrete_12in", 
+                "Wood_1in", "Wood_2in", "Insulation_1in", "Insulation_2in", 
+                "Gypsum_0.5in", "Steel_1in"
+            ],
+            "U_value": [0.45, 0.32, 0.51, 0.48, 0.12, 0.08, 0.03, 0.015, 0.32, 0.65],  # Btu/h-ft²-°F
+            "R_value": [2.22, 3.13, 1.96, 2.08, 8.33, 12.5, 33.33, 66.67, 3.13, 1.54],  # ft²-°F-h/Btu
+            "density": [120, 120, 140, 140, 35, 35, 1.5, 1.5, 40, 490]  # lb/ft³
+        }
+        return pd.DataFrame(data)
+
+    def _load_roof_classifications(self) -> pd.DataFrame:
+        """
+        Load roof classification data.
+        Returns: DataFrame with roof type descriptions and properties.
+        """
+        data = {
+            "type": [1, 2, 3, 4, 5, 8, 9, 10, 13, 14],
+            "description": [
+                "Light roof, no insulation", "Light roof, minimal insulation", 
+                "Medium roof, R-10 insulation", "Medium roof, R-15 insulation", 
+                "Heavy roof, R-20 insulation", "Heavy roof, R-25 insulation", 
+                "Concrete slab, R-15 insulation", "Concrete slab, R-20 insulation", 
+                "Metal deck, R-30 insulation", "Metal deck, R-35 insulation"
+            ],
+            "U_value": [0.5, 0.4, 0.3, 0.25, 0.2, 0.15, 0.18, 0.14, 0.1, 0.08],
+            "mass": [10, 15, 50, 60, 100, 120, 150, 160, 80, 90]  # lb/ft²
+        }
+        return pd.DataFrame(data)
+
+    def _load_latitude_correction(self) -> Dict[str, Dict[str, float]]:
+        """
+        Load latitude correction factors for CLTD/SCL values.
+        Returns: Dictionary of correction factors for different latitudes and months.
+        """
+        return {
+            "24N": {"Jan": -5.0, "Feb": -3.5, "Mar": -1.0, "Apr": 2.0, "May": 4.0, "Jun": 5.0, "Jul": 4.5, "Aug": 3.0, "Sep": 1.0, "Oct": -1.5, "Nov": -4.0, "Dec": -5.5},
+            "32N": {"Jan": -4.0, "Feb": -2.5, "Mar": 0.0, "Apr": 2.5, "May": 4.5, "Jun": 5.5, "Jul": 5.0, "Aug": 3.5, "Sep": 1.5, "Oct": -0.5, "Nov": -3.0, "Dec": -4.5},
+            "40N": {"Jan": -3.0, "Feb": -1.5, "Mar": 1.0, "Apr": 3.0, "May": 5.0, "Jun": 6.0, "Jul": 5.5, "Aug": 4.0, "Sep": 2.0, "Oct": 0.0, "Nov": -2.0, "Dec": -3.5},
+            "48N": {"Jan": -2.0, "Feb": -0.5, "Mar": 2.0, "Apr": 4.0, "May": 6.0, "Jun": 7.0, "Jul": 6.5, "Aug": 5.0, "Sep": 3.0, "Oct": 1.0, "Nov": -1.0, "Dec": -2.5},
+            "56N": {"Jan": -1.0, "Feb": 0.5, "Mar": 3.0, "Apr": 5.0, "May": 7.0, "Jun": 8.0, "Jul": 7.5, "Aug": 6.0, "Sep": 4.0, "Oct": 2.0, "Nov": 0.0, "Dec": -1.5}
+        }
+
+    def _load_color_correction(self) -> Dict[str, float]:
+        """
+        Load color correction factors for CLTD values.
+        Returns: Dictionary of correction factors for different colors.
+        """
+        return {"Dark": 0.0, "Medium": -1.0, "Light": -2.0}
+
+    def _load_month_correction(self) -> Dict[str, float]:
+        """
+        Load month correction factors for CLTD values.
+        Returns: Dictionary of correction factors for different months.
+        """
+        return {
+            "Jan": -6.0, "Feb": -5.0, "Mar": -3.0, "Apr": -1.0, "May": 1.0,
+            "Jun": 2.0, "Jul": 2.0, "Aug": 2.0, "Sep": 1.0, "Oct": -1.0,
+            "Nov": -3.0, "Dec": -5.0
+        }
+
+    def _apply_climatic_corrections(self, cltd: float, latitude: str, month: str, color: str, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Apply climatic corrections to CLTD values based on latitude, month, color, and temperature.
+        
+        Args:
+            cltd (float): Base CLTD value.
+            latitude (str): Latitude (e.g., '32N').
+            month (str): Month (e.g., 'Jul').
+            color (str): Surface color ('Dark', 'Medium', 'Light').
+            outdoor_temp (float): Outdoor design temperature (°C).
+            indoor_temp (float): Indoor design temperature (°C).
+        
+        Returns:
+            float: Corrected CLTD value (°C).
+        """
+        try:
+            # Convert temperatures to °F for ASHRAE corrections
+            outdoor_temp_f = outdoor_temp * 9/5 + 32
+            indoor_temp_f = indoor_temp * 9/5 + 32
+            
+            # Get correction factors
+            lat_corr = self.latitude_correction.get(latitude, {}).get(month, 0.0)
+            month_corr = self.month_correction.get(month, 0.0)
+            color_corr = self.color_correction.get(color, 0.0)
+            
+            # Apply temperature difference correction (ASHRAE CLTD correction formula)
+            temp_diff = outdoor_temp_f - indoor_temp_f
+            design_temp_diff = 85 - 78  # ASHRAE base conditions: 85°F outdoor, 78°F indoor
+            temp_corr = (temp_diff - design_temp_diff) * 0.5556  # Convert °F to °C
+            
+            # Total correction
+            corrected_cltd = cltd + lat_corr + month_corr + color_corr + temp_corr
+            
+            # Ensure non-negative CLTD
+            return max(0.0, corrected_cltd)
+        except Exception as e:
+            raise ValueError(f"Error applying climatic corrections: {str(e)}")
+
+    def get_cltd_wall(self, wall_group: str, orientation: str, hour: int) -> float:
+        """Get CLTD value for a wall."""
+        if wall_group not in self.cltd_wall:
+            raise ValueError(f"Invalid wall group: {wall_group}")
+        orientation_map = {e.value: e.name for e in Orientation}
+        orientation_abbr = orientation_map.get(orientation, orientation)
+        if orientation_abbr not in self.cltd_wall[wall_group].columns:
+            raise ValueError(f"Invalid orientation: {orientation}")
+        if hour not in self.cltd_wall[wall_group].index:
+            raise ValueError(f"Invalid hour: {hour}")
+        return float(self.cltd_wall[wall_group].loc[hour, orientation_abbr])
+
+    def get_cltd_roof(self, roof_group: str, latitude: str, hour: int) -> float:
+        """Get CLTD value for a roof."""
+        # Map latitude to standard format before forming the key
+        valid_latitudes = ['24N', '36N', '48N']
+        
+        # Handle numeric or non-standard latitude values
+        if latitude not in valid_latitudes:
+            # Try to convert to standard format
+            try:
+                # First, handle string representations that might contain direction indicators
+                if isinstance(latitude, str):
+                    # Extract numeric part, removing 'N' or 'S'
+                    lat_str = latitude.upper().strip()
+                    num_part = ''.join(c for c in lat_str if c.isdigit() or c == '.')
+                    lat_val = float(num_part)
+                    
+                    # Adjust for southern hemisphere if needed
+                    if 'S' in lat_str:
+                        lat_val = -lat_val
+                else:
+                    # Handle direct numeric input
+                    lat_val = float(latitude)
+                
+                # Take absolute value for mapping purposes
+                abs_lat = abs(lat_val)
+                
+                # Map to the closest standard latitude for roof data
+                if abs_lat < 30:
+                    latitude = '24N'
+                elif abs_lat < 42:
+                    latitude = '36N'
+                else:
+                    latitude = '48N'
+                
+            except (ValueError, TypeError):
+                raise ValueError(f"Invalid latitude format: {latitude}")
+        
+        key = f"{roof_group}_{latitude}"
+        if key not in self.cltd_roof:
+            raise ValueError(f"Invalid roof group or latitude: {key}")
+        if hour not in self.cltd_roof[key].index:
+            raise ValueError(f"Invalid hour: {hour}")
+        return float(self.cltd_roof[key].loc[hour, "HOR"])
+
+    def get_scl(self, latitude: str, month: str, orientation: str, hour: int) -> float:
+        """Get SCL value for a window."""
+        # Map latitude to standard format before forming the key
+        valid_latitudes = ['24N', '32N', '40N', '48N', '56N']
+        
+        # Handle numeric or non-standard latitude values
+        if latitude not in valid_latitudes:
+            # Try to convert to standard format
+            try:
+                # First, handle string representations that might contain direction indicators
+                if isinstance(latitude, str):
+                    # Extract numeric part, removing 'N' or 'S'
+                    lat_str = latitude.upper().strip()
+                    num_part = ''.join(c for c in lat_str if c.isdigit() or c == '.')
+                    lat_val = float(num_part)
+                    
+                    # Adjust for southern hemisphere if needed
+                    if 'S' in lat_str:
+                        lat_val = -lat_val
+                else:
+                    # Handle direct numeric input
+                    lat_val = float(latitude)
+                
+                # Take absolute value for mapping purposes
+                abs_lat = abs(lat_val)
+                
+                # Map to the closest standard latitude for SCL data
+                if abs_lat < 28:
+                    latitude = '24N'
+                elif abs_lat < 36:
+                    latitude = '32N'
+                elif abs_lat < 44:
+                    latitude = '40N'
+                elif abs_lat < 52:
+                    latitude = '48N'
+                else:
+                    latitude = '56N'
+                
+            except (ValueError, TypeError):
+                raise ValueError(f"Invalid latitude format: {latitude}")
+        
+        key = f"{latitude}_{month}"
+        if key not in self.scl:
+            raise ValueError(f"Invalid latitude or month: {key}")
+        orientation_map = {e.value: e.name for e in Orientation}
+        orientation_abbr = orientation_map.get(orientation, orientation)
+        if orientation_abbr not in self.scl[key].columns:
+            raise ValueError(f"Invalid orientation: {orientation}")
+        if hour not in self.scl[key].index:
+            raise ValueError(f"Invalid hour: {hour}")
+        return float(self.scl[key].loc[hour, orientation_abbr])
+
+    def get_clf_lights(self, zone_type: str, hours_on: str, hour: int) -> float:
+        """Get CLF value for lights."""
+        key = f"{zone_type}_{hours_on}"
+        if key not in self.clf_lights.columns:
+            raise ValueError(f"Invalid zone type or hours: {key}")
+        if hour not in self.clf_lights.index:
+            raise ValueError(f"Invalid hour: {hour}")
+        return float(self.clf_lights.loc[hour, key])
+
+    def get_clf_people(self, zone_type: str, hours_occupied: str, hour: int) -> float:
+        """Get CLF value for people."""
+        key = f"{zone_type}_{hours_occupied}"
+        if key not in self.clf_people.columns:
+            raise ValueError(f"Invalid zone type or hours: {key}")
+        if hour not in self.clf_people.index:
+            raise ValueError(f"Invalid hour: {hour}")
+        return float(self.clf_people.loc[hour, key])
+
+    def get_clf_equipment(self, zone_type: str, hours_operated: str, hour: int) -> float:
+        """Get CLF value for equipment."""
+        key = f"{zone_type}_{hours_operated}"
+        if key not in self.clf_equipment.columns:
+            raise ValueError(f"Invalid zone type or hours: {key}")
+        if hour not in self.clf_equipment.index:
+            raise ValueError(f"Invalid hour: {hour}")
+        return float(self.clf_equipment.loc[hour, key])
+
+    def get_thermal_property(self, material: str, property_type: str) -> float:
+        """
+        Get thermal property for a material.
+        
+        Args:
+            material (str): Material name (e.g., 'Brick_4in').
+            property_type (str): Property to retrieve ('U_value', 'R_value', 'density').
+        
+        Returns:
+            float: Value of the specified thermal property.
+        
+        Raises:
+            ValueError: If material or property_type is invalid.
+        """
+        if material not in self.thermal_properties['material'].values:
+            raise ValueError(f"Invalid material: {material}")
+        if property_type not in ['U_value', 'R_value', 'density']:
+            raise ValueError(f"Invalid property type: {property_type}")
+        return float(self.thermal_properties.loc[self.thermal_properties['material'] == material, property_type].iloc[0])
+
+    def get_heat_gain(self, source: str) -> float:
+        """
+        Get heat gain value for an internal source.
+        
+        Args:
+            source (str): Source type ('people_sensible', 'people_latent', 'lights', 'equipment').
+        
+        Returns:
+            float: Heat gain value (Btu/h or Btu/h-ft²).
+        
+        Raises:
+            ValueError: If source is invalid.
+        """
+        if source not in self.heat_gain['source'].values:
+            raise ValueError(f"Invalid source: {source}")
+        return float(self.heat_gain.loc[self.heat_gain['source'] == source, 'gain'].iloc[0])
+
+    def plot_cooling_load(self, cooling_loads: List[float], title: str = "Cooling Load Profile", filename: str = "cooling_load.png") -> None:
+        """
+        Plot the cooling load profile over 24 hours.
+        
+        Args:
+            cooling_loads (List[float]): List of cooling load values for each hour.
+            title (str): Plot title.
+            filename (str): Output filename for the plot.
+        """
+        if len(cooling_loads) != 24:
+            raise ValueError("Cooling loads must contain 24 hourly values")
+        
+        plt.figure(figsize=(10, 6))
+        hours = list(range(24))
+        plt.plot(hours, cooling_loads, marker='o', linestyle='-', color='b')
+        plt.title(title)
+        plt.xlabel("Hour of Day")
+        plt.ylabel("Cooling Load (Btu/h)")
+        plt.grid(True)
+        plt.xticks(hours)
+        plt.savefig(filename)
+        plt.close()
+
+    def calculate_corrected_cltd_wall(self, wall_group: str, orientation: str, hour: int, latitude: str, month: str, color: str, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate corrected CLTD for a wall with climatic corrections.
+    
+        Args:
+            wall_group (str): Wall group (e.g., 'A', 'B', ..., 'H').
+            orientation (str): Wall orientation (e.g., 'North', 'East', etc.).
+            hour (int): Hour of the day (0-23).
+            latitude (str): Latitude (e.g., '32N').
+            month (str): Month (e.g., 'Jul').
+            color (str): Surface color ('Dark', 'Medium', 'Light').
+            outdoor_temp (float): Outdoor design temperature (°C).
+            indoor_temp (float): Indoor design temperature (°C).
+    
+        Returns:
+            float: Corrected CLTD value (°C).
+    
+        Raises:
+            ValueError: If inputs are invalid or correction fails.
+        """
+        valid, message = self._validate_cltd_inputs(wall_group, orientation, hour, latitude, month, color, is_wall=True)
+        if not valid:
+            raise ValueError(message)
+        try:
+            # Get base CLTD
+            base_cltd = self.get_cltd_wall(wall_group, orientation, hour)
+            # Apply climatic corrections
+            corrected_cltd = self._apply_climatic_corrections(base_cltd, latitude, month, color, outdoor_temp, indoor_temp)
+            return corrected_cltd
+        except Exception as e:
+            raise ValueError(f"Error calculating corrected CLTD for wall: {str(e)}")
+
+    def calculate_corrected_cltd_roof(self, roof_group: str, latitude: str, hour: int, month: str, color: str, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate corrected CLTD for a roof with climatic corrections.
+    
+        Args:
+            roof_group (str): Roof group (e.g., 'A', 'B', ..., 'G').
+            latitude (str): Latitude (e.g., '24N', '36N', '48N').
+            hour (int): Hour of the day (0-23).
+            month (str): Month (e.g., 'Jul').
+            color (str): Surface color ('Dark', 'Medium', 'Light').
+            outdoor_temp (float): Outdoor design temperature (°C).
+            indoor_temp (float): Indoor design temperature (°C).
+    
+        Returns:
+            float: Corrected CLTD value (°C).
+    
+        Raises:
+            ValueError: If inputs are invalid or correction fails.
+        """
+        valid, message = self._validate_cltd_inputs(roof_group, 'Horizontal', hour, latitude, month, color, is_wall=False)
+        if not valid:
+            raise ValueError(message)
+        try:
+            # Get base CLTD
+            base_cltd = self.get_cltd_roof(roof_group, latitude, hour)
+            # Apply climatic corrections
+            corrected_cltd = self._apply_climatic_corrections(base_cltd, latitude, month, color, outdoor_temp, indoor_temp)
+            return corrected_cltd
+        except Exception as e:
+            raise ValueError(f"Error calculating corrected CLTD for roof: {str(e)}")

data/building_components.py

@@ -0,0 +1,568 @@
+"""
+Building component data models for HVAC Load Calculator.
+This module defines the data structures for walls, roofs, floors, windows, doors, and other building components.
+Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.2.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Dict, Optional, Union
+import numpy as np
+from data.drapery import Drapery
+
+
+class Orientation(Enum):
+    """Enumeration for building component orientations."""
+    NORTH = "NORTH"
+    NORTHEAST = "NORTHEAST"
+    EAST = "EAST"
+    SOUTHEAST = "SOUTHEAST"
+    SOUTH = "SOUTH"
+    SOUTHWEST = "SOUTHWEST"
+    WEST = "WEST"
+    NORTHWEST = "NORTHWEST"
+    HORIZONTAL = "HORIZONTAL"  # For roofs and floors
+    NOT_APPLICABLE = "N/A"  # For components without orientation
+
+
+class ComponentType(Enum):
+    """Enumeration for building component types."""
+    WALL = "WALL"
+    ROOF = "ROOF"
+    FLOOR = "FLOOR"
+    WINDOW = "WINDOW"
+    DOOR = "DOOR"
+    SKYLIGHT = "SKYLIGHT"
+
+
+class MaterialLayer:
+    """Class representing a single material layer in a building component."""
+    
+    def __init__(self, name: str, thickness: float, conductivity: float, 
+                 density: float = None, specific_heat: float = None):
+        """
+        Initialize a material layer.
+        
+        Args:
+            name: Name of the material
+            thickness: Thickness of the layer in meters
+            conductivity: Thermal conductivity in W/(m·K)
+            density: Density in kg/m³ (optional)
+            specific_heat: Specific heat capacity in J/(kg·K) (optional)
+        """
+        self.name = name
+        self.thickness = thickness  # m
+        self.conductivity = conductivity  # W/(m·K)
+        self.density = density  # kg/m³
+        self.specific_heat = specific_heat  # J/(kg·K)
+    
+    @property
+    def r_value(self) -> float:
+        """Calculate the thermal resistance (R-value) of the layer in m²·K/W."""
+        if self.conductivity == 0:
+            return float('inf')  # Avoid division by zero
+        return self.thickness / self.conductivity
+    
+    @property
+    def thermal_mass(self) -> Optional[float]:
+        """Calculate the thermal mass of the layer in J/(m²·K)."""
+        if self.density is None or self.specific_heat is None:
+            return None
+        return self.thickness * self.density * self.specific_heat
+    
+    def to_dict(self) -> Dict:
+        """Convert the material layer to a dictionary."""
+        return {
+            "name": self.name,
+            "thickness": self.thickness,
+            "conductivity": self.conductivity,
+            "density": self.density,
+            "specific_heat": self.specific_heat,
+            "r_value": self.r_value,
+            "thermal_mass": self.thermal_mass
+        }
+
+
+@dataclass
+class BuildingComponent:
+    """Base class for all building components."""
+    
+    id: str
+    name: str
+    component_type: ComponentType
+    u_value: float  # W/(m²·K)
+    area: float  # m²
+    orientation: Orientation = Orientation.NOT_APPLICABLE
+    color: str = "Medium"  # Light, Medium, Dark
+    material_layers: List[MaterialLayer] = field(default_factory=list)
+    
+    def __post_init__(self):
+        """Validate component data after initialization."""
+        if self.area <= 0:
+            raise ValueError("Area must be greater than zero")
+        if self.u_value < 0:
+            raise ValueError("U-value cannot be negative")
+    
+    @property
+    def r_value(self) -> float:
+        """Calculate the total thermal resistance (R-value) in m²·K/W."""
+        return 1 / self.u_value if self.u_value > 0 else float('inf')
+    
+    @property
+    def total_r_value_from_layers(self) -> Optional[float]:
+        """Calculate the total R-value from material layers if available."""
+        if not self.material_layers:
+            return None
+        
+        # Add surface resistances (interior and exterior)
+        r_si = 0.13  # m²·K/W (interior surface resistance)
+        r_se = 0.04  # m²·K/W (exterior surface resistance)
+        
+        # Sum the R-values of all layers
+        r_layers = sum(layer.r_value for layer in self.material_layers)
+        
+        return r_si + r_layers + r_se
+    
+    @property
+    def calculated_u_value(self) -> Optional[float]:
+        """Calculate U-value from material layers if available."""
+        total_r = self.total_r_value_from_layers
+        if total_r is None or total_r == 0:
+            return None
+        return 1 / total_r
+    
+    def heat_transfer_rate(self, delta_t: float) -> float:
+        """
+        Calculate heat transfer rate through the component.
+        
+        Args:
+            delta_t: Temperature difference across the component in K or °C
+            
+        Returns:
+            Heat transfer rate in Watts
+        """
+        return self.u_value * self.area * delta_t
+    
+    def to_dict(self) -> Dict:
+        """Convert the building component to a dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "component_type": self.component_type.value,
+            "u_value": self.u_value,
+            "area": self.area,
+            "orientation": self.orientation.value,
+            "color": self.color,
+            "r_value": self.r_value,
+            "material_layers": [layer.to_dict() for layer in self.material_layers],
+            "calculated_u_value": self.calculated_u_value,
+            "total_r_value_from_layers": self.total_r_value_from_layers
+        }
+
+
+@dataclass
+class Wall(BuildingComponent):
+    """Class representing a wall component."""
+    
+    VALID_WALL_GROUPS = {"A", "B", "C", "D", "E", "F", "G", "H"}  # ASHRAE wall groups for CLTD
+    
+    has_sun_exposure: bool = True
+    wall_type: str = "Custom"  # Brick, Concrete, Wood Frame, etc.
+    wall_group: str = "A"  # ASHRAE wall group (A, B, C, D, E, F, G, H)
+    gross_area: float = None  # m² (before subtracting windows/doors)
+    net_area: float = None  # m² (after subtracting windows/doors)
+    windows: List[str] = field(default_factory=list)  # List of window IDs
+    doors: List[str] = field(default_factory=list)  # List of door IDs
+    
+    def __post_init__(self):
+        """Initialize wall-specific attributes."""
+        super().__post_init__()
+        self.component_type = ComponentType.WALL
+        
+        # Validate wall_group
+        if self.wall_group not in self.VALID_WALL_GROUPS:
+            raise ValueError(f"Invalid wall_group: {self.wall_group}. Must be one of {self.VALID_WALL_GROUPS}")
+        
+        # Set net area equal to area if not specified
+        if self.net_area is None:
+            self.net_area = self.area
+        
+        # Set gross area equal to net area if not specified
+        if self.gross_area is None:
+            self.gross_area = self.net_area
+    
+    def update_net_area(self, window_areas: Dict[str, float], door_areas: Dict[str, float]):
+        """
+        Update the net wall area by subtracting windows and doors.
+        
+        Args:
+            window_areas: Dictionary mapping window IDs to areas
+            door_areas: Dictionary mapping door IDs to areas
+        """
+        total_window_area = sum(window_areas.get(window_id, 0) for window_id in self.windows)
+        total_door_area = sum(door_areas.get(door_id, 0) for door_id in self.doors)
+        
+        self.net_area = self.gross_area - total_window_area - total_door_area
+        self.area = self.net_area  # Update the main area property
+        
+        if self.net_area <= 0:
+            raise ValueError("Net wall area cannot be negative or zero")
+    
+    def to_dict(self) -> Dict:
+        """Convert the wall to a dictionary."""
+        wall_dict = super().to_dict()
+        wall_dict.update({
+            "has_sun_exposure": self.has_sun_exposure,
+            "wall_type": self.wall_type,
+            "wall_group": self.wall_group,
+            "gross_area": self.gross_area,
+            "net_area": self.net_area,
+            "windows": self.windows,
+            "doors": self.doors
+        })
+        return wall_dict
+
+
+@dataclass
+class Roof(BuildingComponent):
+    """Class representing a roof component."""
+    
+    VALID_ROOF_GROUPS = {"A", "B", "C", "D", "E", "F", "G"}  # ASHRAE roof groups for CLTD
+    
+    roof_type: str = "Custom"  # Flat, Pitched, etc.
+    roof_group: str = "A"  # ASHRAE roof group
+    pitch: float = 0.0  # Roof pitch in degrees
+    has_suspended_ceiling: bool = False
+    ceiling_plenum_height: float = 0.0  # m
+    
+    def __post_init__(self):
+        """Initialize roof-specific attributes."""
+        super().__post_init__()
+        self.component_type = ComponentType.ROOF
+        self.orientation = Orientation.HORIZONTAL
+        
+        # Validate roof_group
+        if self.roof_group not in self.VALID_ROOF_GROUPS:
+            raise ValueError(f"Invalid roof_group: {self.roof_group}. Must be one of {self.VALID_ROOF_GROUPS}")
+    
+    def to_dict(self) -> Dict:
+        """Convert the roof to a dictionary."""
+        roof_dict = super().to_dict()
+        roof_dict.update({
+            "roof_type": self.roof_type,
+            "roof_group": self.roof_group,
+            "pitch": self.pitch,
+            "has_suspended_ceiling": self.has_suspended_ceiling,
+            "ceiling_plenum_height": self.ceiling_plenum_height
+        })
+        return roof_dict
+
+
+@dataclass
+class Floor(BuildingComponent):
+    """Class representing a floor component."""
+    
+    floor_type: str = "Custom"  # Slab-on-grade, Raised, etc.
+    is_ground_contact: bool = False
+    perimeter_length: float = 0.0  # m (for slab-on-grade floors)
+    insulated: bool = False  # Added to indicate insulation status
+    ground_temperature_c: float = None  # Added for ground temperature in °C
+    
+    def __post_init__(self):
+        """Initialize floor-specific attributes."""
+        super().__post_init__()
+        self.component_type = ComponentType.FLOOR
+        self.orientation = Orientation.HORIZONTAL
+    
+    def to_dict(self) -> Dict:
+        """Convert the floor to a dictionary."""
+        floor_dict = super().to_dict()
+        floor_dict.update({
+            "floor_type": self.floor_type,
+            "is_ground_contact": self.is_ground_contact,
+            "perimeter_length": self.perimeter_length,
+            "insulated": self.insulated,
+            "ground_temperature_c": self.ground_temperature_c
+        })
+        return floor_dict
+
+
+@dataclass
+class Fenestration(BuildingComponent):
+    """Base class for fenestration components (windows, doors, skylights)."""
+    
+    shgc: float = 0.7  # Solar Heat Gain Coefficient
+    vt: float = 0.7  # Visible Transmittance
+    frame_type: str = "Aluminum"  # Aluminum, Wood, Vinyl, etc.
+    frame_width: float = 0.05  # m
+    has_shading: bool = False
+    shading_type: str = None  # Internal, External, Between-glass
+    shading_coefficient: float = 1.0  # 0-1 (1 = no shading)
+    
+    def __post_init__(self):
+        """Initialize fenestration-specific attributes."""
+        super().__post_init__()
+        
+        if self.shgc < 0 or self.shgc > 1:
+            raise ValueError("SHGC must be between 0 and 1")
+        if self.vt < 0 or self.vt > 1:
+            raise ValueError("VT must be between 0 and 1")
+        if self.shading_coefficient < 0 or self.shading_coefficient > 1:
+            raise ValueError("Shading coefficient must be between 0 and 1")
+    
+    @property
+    def effective_shgc(self) -> float:
+        """Calculate the effective SHGC considering shading."""
+        return self.shgc * self.shading_coefficient
+    
+    def to_dict(self) -> Dict:
+        """Convert the fenestration to a dictionary."""
+        fenestration_dict = super().to_dict()
+        fenestration_dict.update({
+            "shgc": self.shgc,
+            "vt": self.vt,
+            "frame_type": self.frame_type,
+            "frame_width": self.frame_width,
+            "has_shading": self.has_shading,
+            "shading_type": self.shading_type,
+            "shading_coefficient": self.shading_coefficient,
+            "effective_shgc": self.effective_shgc
+        })
+        return fenestration_dict
+
+
+@dataclass
+class Window(Fenestration):
+    """Class representing a window component."""
+    
+    window_type: str = "Custom"  # Single, Double, Triple glazed, etc.
+    glazing_layers: int = 2  # Number of glazing layers
+    gas_fill: str = "Air"  # Air, Argon, Krypton, etc.
+    low_e_coating: bool = False
+    width: float = 1.0  # m
+    height: float = 1.0  # m
+    wall_id: str = None  # ID of the wall containing this window
+    drapery: Optional[Drapery] = None  # Drapery object
+    
+    def __post_init__(self):
+        """Initialize window-specific attributes."""
+        super().__post_init__()
+        self.component_type = ComponentType.WINDOW
+        
+        # Calculate area from width and height if not provided
+        if self.area <= 0 and self.width > 0 and self.height > 0:
+            self.area = self.width * self.height
+        
+        # Initialize drapery if not provided
+        if self.drapery is None:
+            self.drapery = Drapery(enabled=False)
+    
+    @classmethod
+    def from_classification(cls, id: str, name: str, u_value: float, area: float, 
+                           shgc: float, orientation: Orientation, wall_id: str,
+                           drapery_classification: str, fullness: float = 1.0, **kwargs) -> 'Window':
+        """
+        Create window object with drapery from ASHRAE classification.
+        
+        Args:
+            id: Unique identifier
+            name: Window name
+            u_value: Window U-value in W/m²K
+            area: Window area in m²
+            shgc: Solar Heat Gain Coefficient (0-1)
+            orientation: Window orientation
+            wall_id: ID of the wall containing this window
+            drapery_classification: ASHRAE drapery classification (e.g., ID, IM, IIL)
+            fullness: Fullness factor (0-2)
+            **kwargs: Additional arguments for Window attributes
+            
+        Returns:
+            Window object
+        """
+        drapery = Drapery.from_classification(drapery_classification, fullness)
+        return cls(
+            id=id,
+            name=name,
+            component_type=ComponentType.WINDOW,
+            u_value=u_value,
+            area=area,
+            shgc=shgc,
+            orientation=orientation,
+            drapery=drapery,
+            wall_id=wall_id,
+            **kwargs
+        )
+    
+    def get_effective_u_value(self) -> float:
+        """Get effective U-value with drapery adjustment."""
+        if self.drapery and self.drapery.enabled:
+            return self.drapery.calculate_u_value_adjustment(self.u_value)
+        return self.u_value
+    
+    def get_shading_coefficient(self) -> float:
+        """Get shading coefficient with drapery."""
+        if self.drapery and self.drapery.enabled:
+            return self.drapery.calculate_shading_coefficient(self.shgc)
+        return self.shading_coefficient
+    
+    def get_iac(self) -> float:
+        """Get Interior Attenuation Coefficient with drapery."""
+        if self.drapery and self.drapery.enabled:
+            return self.drapery.calculate_iac(self.shgc)
+        return 1.0  # No attenuation
+    
+    def to_dict(self) -> Dict:
+        """Convert the window to a dictionary."""
+        window_dict = super().to_dict()
+        window_dict.update({
+            "window_type": self.window_type,
+            "glazing_layers": self.glazing_layers,
+            "gas_fill": self.gas_fill,
+            "low_e_coating": self.low_e_coating,
+            "width": self.width,
+            "height": self.height,
+            "wall_id": self.wall_id,
+            "drapery": self.drapery.to_dict() if self.drapery else None,
+            "drapery_classification": self.drapery.get_classification() if self.drapery and self.drapery.enabled else None
+        })
+        return window_dict
+
+
+@dataclass
+class Door(Fenestration):
+    """Class representing a door component."""
+    
+    door_type: str = "Custom"  # Solid, Partially glazed, etc.
+    glazing_percentage: float = 0.0  # Percentage of door area that is glazed (0-100)
+    width: float = 0.9  # m
+    height: float = 2.1  # m
+    wall_id: str = None  # ID of the wall containing this door
+    
+    def __post_init__(self):
+        """Initialize door-specific attributes."""
+        super().__post_init__()
+        self.component_type = ComponentType.DOOR
+        
+        # Calculate area from width and height if not provided
+        if self.area <= 0 and self.width > 0 and self.height > 0:
+            self.area = self.width * self.height
+        
+        if self.glazing_percentage < 0 or self.glazing_percentage > 100:
+            raise ValueError("Glazing percentage must be between 0 and 100")
+    
+    @property
+    def glazing_area(self) -> float:
+        """Calculate the glazed area of the door in m²."""
+        return self.area * (self.glazing_percentage / 100)
+    
+    @property
+    def opaque_area(self) -> float:
+        """Calculate the opaque area of the door in m²."""
+        return self.area - self.glazing_area
+    
+    def to_dict(self) -> Dict:
+        """Convert the door to a dictionary."""
+        door_dict = super().to_dict()
+        door_dict.update({
+            "door_type": self.door_type,
+            "glazing_percentage": self.glazing_percentage,
+            "width": self.width,
+            "height": self.height,
+            "wall_id": self.wall_id,
+            "glazing_area": self.glazing_area,
+            "opaque_area": self.opaque_area
+        })
+        return door_dict
+
+
+@dataclass
+class Skylight(Fenestration):
+    """Class representing a skylight component."""
+    
+    skylight_type: str = "Custom"  # Flat, Domed, etc.
+    glazing_layers: int = 2  # Number of glazing layers
+    gas_fill: str = "Air"  # Air, Argon, Krypton, etc.
+    low_e_coating: bool = False
+    width: float = 1.0  # m
+    length: float = 1.0  # m
+    roof_id: str = None  # ID of the roof containing this skylight
+    
+    def __post_init__(self):
+        """Initialize skylight-specific attributes."""
+        super().__post_init__()
+        self.component_type = ComponentType.SKYLIGHT
+        self.orientation = Orientation.HORIZONTAL
+        
+        # Calculate area from width and length if not provided
+        if self.area <= 0 and self.width > 0 and self.length > 0:
+            self.area = self.width * self.length
+    
+    def to_dict(self) -> Dict:
+        """Convert the skylight to a dictionary."""
+        skylight_dict = super().to_dict()
+        skylight_dict.update({
+            "skylight_type": self.skylight_type,
+            "glazing_layers": self.glazing_layers,
+            "gas_fill": self.gas_fill,
+            "low_e_coating": self.low_e_coating,
+            "width": self.width,
+            "length": self.length,
+            "roof_id": self.roof_id
+        })
+        return skylight_dict
+
+
+class BuildingComponentFactory:
+    """Factory class for creating building components."""
+    
+    @staticmethod
+    def create_component(component_data: Dict) -> BuildingComponent:
+        """
+        Create a building component from a dictionary of data.
+        
+        Args:
+            component_data: Dictionary containing component data
+            
+        Returns:
+            A BuildingComponent object of the appropriate type
+        """
+        component_type = component_data.get("component_type")
+        
+        # Convert string component_type to ComponentType enum
+        if isinstance(component_type, str):
+            component_type = ComponentType[component_type]
+        
+        # Handle drapery for Window components
+        if component_type == ComponentType.WINDOW:
+            drapery_data = component_data.pop("drapery", None)
+            drapery_classification = component_data.pop("drapery_classification", None)
+            if drapery_classification:
+                fullness = drapery_data.get("fullness", 1.0) if drapery_data else 1.0
+                component_data["drapery"] = Drapery.from_classification(drapery_classification, fullness)
+            elif drapery_data:
+                component_data["drapery"] = Drapery.from_dict(drapery_data)
+        
+        # Convert orientation to Orientation enum
+        if "orientation" in component_data and isinstance(component_data["orientation"], str):
+            component_data["orientation"] = Orientation[component_data["orientation"]]
+        
+        # Convert material_layers to MaterialLayer objects
+        if "material_layers" in component_data:
+            component_data["material_layers"] = [
+                MaterialLayer(**layer) for layer in component_data["material_layers"]
+            ]
+        
+        if component_type == ComponentType.WALL:
+            return Wall(**component_data)
+        elif component_type == ComponentType.ROOF:
+            return Roof(**component_data)
+        elif component_type == ComponentType.FLOOR:
+            return Floor(**component_data)
+        elif component_type == ComponentType.WINDOW:
+            return Window(**component_data)
+        elif component_type == ComponentType.DOOR:
+            return Door(**component_data)
+        elif component_type == ComponentType.SKYLIGHT:
+            return Skylight(**component_data)
+        else:
+            raise ValueError(f"Unknown component type: {component_type}")

data/climate_data.py

@@ -0,0 +1,599 @@
+"""
+ASHRAE 169 climate data module for HVAC Load Calculator.
+This module provides access to climate data for various locations based on ASHRAE 169 standard.
+
+Author: Dr Majed Abuseif
+Date: March 2025
+Version: 1.0.0
+"""
+
+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
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+
+@dataclass
+class ClimateLocation:
+    """Class representing a climate location with ASHRAE 169 data."""
+    
+    id: str
+    country: str
+    state_province: str
+    city: str
+    latitude: float
+    longitude: float
+    elevation: float  # meters
+    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)
+    monthly_temps: Dict[str, float]  # Average monthly temperatures (°C)
+    monthly_humidity: Dict[str, float]  # Average monthly relative humidity (%)
+    
+    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,
+            "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,
+            "monthly_temps": self.monthly_temps,
+            "monthly_humidity": self.monthly_humidity
+        }
+
+class ClimateData:
+    """Class for managing ASHRAE 169 climate data."""
+    
+    def __init__(self):
+        """Initialize climate data."""
+        self.locations = {}
+        self.countries = []
+        self.country_states = {}
+    
+    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 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 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",
+            "climate_zone", "heating_degree_days", "cooling_degree_days",
+            "winter_design_temp", "summer_design_temp_db", "summer_design_temp_wb",
+            "summer_daily_range", "monthly_temps", "monthly_humidity"
+        ]
+        month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        
+        for field in required_fields:
+            if field not in data:
+                return False
+        
+        if not (-90 <= data["latitude"] <= 90 and -180 <= data["longitude"] <= 180):
+            return False
+        if data["elevation"] < 0:
+            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"]:
+            return False
+        if not (data["heating_degree_days"] >= 0 and data["cooling_degree_days"] >= 0):
+            return False
+        if not (-50 <= data["winter_design_temp"] <= 20):
+            return False
+        if not (0 <= data["summer_design_temp_db"] <= 50 and 0 <= data["summer_design_temp_wb"] <= 40):
+            return False
+        if data["summer_daily_range"] < 0:
+            return False
+        
+        for month in month_names:
+            if month not in data["monthly_temps"] or month not in data["monthly_humidity"]:
+                return False
+            if not (-50 <= data["monthly_temps"][month] <= 50):
+                return False
+            if not (0 <= data["monthly_humidity"][month] <= 100):
+                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
+
+    def display_climate_input(self, session_state: Dict[str, Any]):
+        """Display form for manual input or EPW upload in Streamlit."""
+        st.title("Climate Data")
+        
+        if not session_state.building_info.get("country") or not session_state.building_info.get("city"):
+            st.warning("Please enter country and city in Building Information first.")
+            st.button("Go to Building Information", on_click=lambda: setattr(session_state, "page", "Building Information"))
+            return
+        
+        st.subheader(f"Location: {session_state.building_info['country']}, {session_state.building_info['city']}")
+        tab1, tab2 = st.tabs(["Manual Input", "Upload EPW File"])
+        
+        # Manual Input Tab
+        with tab1:
+            with st.form("manual_climate_form"):
+                col1, col2 = st.columns(2)
+                with col1:
+                    latitude = st.number_input(
+                        "Latitude",
+                        min_value=-90.0,
+                        max_value=90.0,
+                        value=0.0,
+                        step=0.1,
+                        help="Enter the latitude of the location in degrees (e.g., 64.1 for Reykjavik)"
+                    )
+                    longitude = st.number_input(
+                        "Longitude",
+                        min_value=-180.0,
+                        max_value=180.0,
+                        value=0.0,
+                        step=0.1,
+                        help="Enter the longitude of the location in degrees (e.g., -21.9 for Reykjavik)"
+                    )
+                    elevation = st.number_input(
+                        "Elevation (m)",
+                        min_value=0.0,
+                        value=0.0,
+                        step=10.0,
+                        help="Enter the elevation of the location above sea level in meters"
+                    )
+                    climate_zone = st.selectbox(
+                        "Climate Zone",
+                        ["0A", "0B", "1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"],
+                        help="Select the ASHRAE climate zone for the location (e.g., 6A for cold, humid climates)"
+                    )
+                
+                with col2:
+                    hdd = st.number_input(
+                        "Heating Degree Days (base 18°C)",
+                        min_value=0.0,
+                        value=0.0,
+                        step=100.0,
+                        help="Enter the annual heating degree days using an 18°C base temperature"
+                    )
+                    cdd = st.number_input(
+                        "Cooling Degree Days (base 18°C)",
+                        min_value=0.0,
+                        value=0.0,
+                        step=100.0,
+                        help="Enter the annual cooling degree days using an 18°C base temperature"
+                    )
+                    winter_design_temp = st.number_input(
+                        "Winter Design Temp (99.6%) (°C)",
+                        min_value=-50.0,
+                        max_value=20.0,
+                        value=0.0,
+                        step=0.5,
+                        help="Enter the 99.6% winter design temperature in °C (extreme cold condition)"
+                    )
+                    summer_design_temp_db = st.number_input(
+                        "Summer Design Temp DB (0.4%) (°C)",
+                        min_value=0.0,
+                        max_value=50.0,
+                        value=35.0,
+                        step=0.5,
+                        help="Enter the 0.4% summer design dry-bulb temperature in °C (extreme hot condition)"
+                    )
+                    summer_design_temp_wb = st.number_input(
+                        "Summer Design Temp WB (0.4%) (°C)",
+                        min_value=0.0,
+                        max_value=40.0,
+                        value=25.0,
+                        step=0.5,
+                        help="Enter the 0.4% summer design wet-bulb temperature in °C (for humidity consideration)"
+                    )
+                    summer_daily_range = st.number_input(
+                        "Summer Daily Range (°C)",
+                        min_value=0.0,
+                        value=5.0,
+                        step=0.5,
+                        help="Enter the average daily temperature range in summer in °C"
+                    )
+                
+                # Monthly Data with clear titles (no help added here)
+                monthly_temps = {}
+                monthly_humidity = {}
+                month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+                
+                st.subheader("Monthly Temperatures")
+                col1, col2 = st.columns(2)
+                with col1:
+                    for month in month_names[:6]:
+                        monthly_temps[month] = st.number_input(f"{month} Temp (°C)", min_value=-50.0, max_value=50.0, value=20.0, step=0.5, key=f"temp_{month}")
+                with col2:
+                    for month in month_names[6:]:
+                        monthly_temps[month] = st.number_input(f"{month} Temp (°C)", min_value=-50.0, max_value=50.0, value=20.0, step=0.5, key=f"temp_{month}")
+                
+                st.subheader("Monthly Humidity")
+                col1, col2 = st.columns(2)
+                with col1:
+                    for month in month_names[:6]:
+                        monthly_humidity[month] = st.number_input(f"{month} Humidity (%)", min_value=0.0, max_value=100.0, value=50.0, step=5.0, key=f"hum_{month}")
+                with col2:
+                    for month in month_names[6:]:
+                        monthly_humidity[month] = st.number_input(f"{month} Humidity (%)", min_value=0.0, max_value=100.0, value=50.0, step=5.0, key=f"hum_{month}")
+                
+                if st.form_submit_button("Save Climate Data"):
+                    try:
+                        # Generate ID internally using country and city from session_state
+                        generated_id = f"{session_state.building_info['country'][:2].upper()}-{session_state.building_info['city'][:3].upper()}"
+                        location = ClimateLocation(
+                            id=generated_id,
+                            country=session_state.building_info["country"],
+                            state_province="N/A",  # Default since input removed
+                            city=session_state.building_info["city"],
+                            latitude=latitude,
+                            longitude=longitude,
+                            elevation=elevation,
+                            climate_zone=climate_zone,
+                            heating_degree_days=hdd,
+                            cooling_degree_days=cdd,
+                            winter_design_temp=winter_design_temp,
+                            summer_design_temp_db=summer_design_temp_db,
+                            summer_design_temp_wb=summer_design_temp_wb,
+                            summer_daily_range=summer_daily_range,
+                            monthly_temps=monthly_temps,
+                            monthly_humidity=monthly_humidity
+                        )
+                        self.add_location(location)
+                        climate_data_dict = location.to_dict()
+                        if not self.validate_climate_data(climate_data_dict):
+                            raise ValueError("Invalid climate data. Please check all inputs.")
+                        session_state["climate_data"] = climate_data_dict  # Save to session state
+                        st.success("Climate data saved manually!")
+                        st.write(f"Debug: Saved climate data for {location.city} (ID: {location.id}): {climate_data_dict}")  # Debug
+                        self.display_design_conditions(location)
+                        self.visualize_data(location, epw_data=None)
+                    except Exception as e:
+                        st.error(f"Error saving climate data: {str(e)}. Please check inputs and try again.")
+
+        # EPW Upload Tab
+        with tab2:
+            uploaded_file = st.file_uploader("Upload EPW File", type=["epw"])
+            if uploaded_file:
+                try:
+                    epw_content = uploaded_file.read().decode("utf-8")
+                    epw_lines = epw_content.splitlines()
+                    header = next(line for line in epw_lines if line.startswith("LOCATION"))
+                    header_parts = header.split(",")
+                    latitude = float(header_parts[6])
+                    longitude = float(header_parts[7])
+                    elevation = float(header_parts[8])
+                    
+                    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.")
+                    
+                    for col in epw_data.columns:
+                        epw_data[col] = pd.to_numeric(epw_data[col], errors='coerce')
+                    
+                    months = epw_data[1].values  # Month
+                    dry_bulb = epw_data[6].values  # Dry-bulb temperature (°C)
+                    humidity = epw_data[8].values  # Relative humidity (%)
+                    pressure = epw_data[9].values  # Atmospheric pressure (Pa)
+                    
+                    wet_bulb = self.calculate_wet_bulb(dry_bulb, humidity)
+                    
+                    if np.all(np.isnan(dry_bulb)) or np.all(np.isnan(humidity)) or np.all(np.isnan(wet_bulb)):
+                        raise ValueError("Dry bulb, humidity, or calculated wet bulb data is entirely NaN.")
+                    
+                    daily_temps = np.nanmean(dry_bulb.reshape(-1, 24), axis=1)
+                    hdd = round(np.nansum(np.maximum(18 - daily_temps, 0)))
+                    cdd = round(np.nansum(np.maximum(daily_temps - 18, 0)))
+                    
+                    winter_design_temp = round(np.nanpercentile(dry_bulb, 0.4), 1)
+                    summer_design_temp_db = round(np.nanpercentile(dry_bulb, 99.6), 1)
+                    summer_design_temp_wb = round(np.nanpercentile(wet_bulb, 99.6), 1)
+                    summer_mask = (months >= 6) & (months <= 8)
+                    summer_temps = dry_bulb[summer_mask].reshape(-1, 24)
+                    summer_daily_range = round(np.nanmean(np.nanmax(summer_temps, axis=1) - np.nanmin(summer_temps, axis=1)), 1)
+                    
+                    monthly_temps = {}
+                    monthly_humidity = {}
+                    month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+                    for i in range(1, 13):
+                        month_mask = (months == i)
+                        monthly_temps[month_names[i-1]] = round(np.nanmean(dry_bulb[month_mask]), 1)
+                        monthly_humidity[month_names[i-1]] = round(np.nanmean(humidity[month_mask]), 1)
+                    
+                    avg_humidity = np.nanmean(humidity)
+                    climate_zone = self.assign_climate_zone(hdd, cdd, avg_humidity)
+                    
+                    location = ClimateLocation(
+                        id=f"{session_state.building_info['country'][:2].upper()}-{session_state.building_info['city'][:3].upper()}",
+                        country=session_state.building_info["country"],
+                        state_province="N/A",
+                        city=session_state.building_info["city"],
+                        latitude=latitude,
+                        longitude=longitude,
+                        elevation=elevation,
+                        climate_zone=climate_zone,
+                        heating_degree_days=hdd,
+                        cooling_degree_days=cdd,
+                        winter_design_temp=winter_design_temp,
+                        summer_design_temp_db=summer_design_temp_db,
+                        summer_design_temp_wb=summer_design_temp_wb,
+                        summer_daily_range=summer_daily_range,
+                        monthly_temps=monthly_temps,
+                        monthly_humidity=monthly_humidity
+                    )
+                    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  # Save to session state
+                    st.success("Climate data extracted from EPW file with calculated Wet Bulb Temperature!")
+                    st.write(f"Debug: Saved climate data for {location.city} (ID: {location.id}): {climate_data_dict}")  # Debug
+                    self.display_design_conditions(location)
+                    self.visualize_data(location, epw_data=epw_data)
+                except Exception as e:
+                    st.error(f"Error processing EPW file: {str(e)}. Ensure it has 8760 hourly records and correct format.")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            st.button("Back to Building Information", on_click=lambda: setattr(session_state, "page", "Building Information"))
+        with col2:
+            if self.locations:
+                st.button("Continue to Building Components", on_click=lambda: setattr(session_state, "page", "Building Components"))
+            else:
+                st.button("Continue to Building Components", disabled=True)
+
+        # Display saved session state data (if any)
+        if "climate_data" in session_state and session_state["climate_data"]:
+            st.subheader("Saved Climate Data")
+            st.json(session_state["climate_data"])  # Display as JSON for clarity
+
+    def display_design_conditions(self, location: ClimateLocation):
+        """Display a table of design conditions including additional parameters for HVAC calculations."""
+        st.subheader("Design Conditions for HVAC Calculations")
+        
+        design_data = pd.DataFrame({
+            "Parameter": [
+                "Latitude",
+                "Longitude",
+                "Elevation (m)",
+                "Climate Zone",
+                "Heating Degree Days (base 18°C)",
+                "Cooling Degree Days (base 18°C)",
+                "Winter Design Temperature (99.6%)",
+                "Summer Design Dry-Bulb Temp (0.4%)",
+                "Summer Design Wet-Bulb Temp (0.4%)",
+                "Summer Daily Temperature Range"
+            ],
+            "Value": [
+                f"{location.latitude}°",
+                f"{location.longitude}°",
+                f"{location.elevation} m",
+                location.climate_zone,
+                f"{location.heating_degree_days} HDD",
+                f"{location.cooling_degree_days} CDD",
+                f"{location.winter_design_temp} °C",
+                f"{location.summer_design_temp_db} °C",
+                f"{location.summer_design_temp_wb} °C",
+                f"{location.summer_daily_range} °C"
+            ]
+        })
+        
+        month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        monthly_temp_data = pd.DataFrame({
+            "Parameter": [f"{month} Avg Temp" for month in month_names],
+            "Value": [f"{location.monthly_temps[month]} °C" for month in month_names]
+        })
+        
+        monthly_humidity_data = pd.DataFrame({
+            "Parameter": [f"{month} Avg Humidity" for month in month_names],
+            "Value": [f"{location.monthly_humidity[month]} %" for month in month_names]
+        })
+        
+        full_design_data = pd.concat([design_data, monthly_temp_data, monthly_humidity_data], ignore_index=True)
+        st.table(full_design_data)
+
+    @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"
+
+    @staticmethod
+    def visualize_data(location: ClimateLocation, epw_data: Optional[pd.DataFrame] = None):
+        """Visualize monthly temperature and humidity data."""
+        st.subheader("Monthly Climate Data Visualization")
+        
+        months = list(range(1, 13))
+        month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        temps_avg = [location.monthly_temps[m] for m in month_names]
+        humidity_avg = [location.monthly_humidity[m] for m in month_names]
+        
+        fig_temp = go.Figure()
+        fig_temp.add_trace(go.Scatter(
+            x=months,
+            y=temps_avg,
+            mode='lines+markers',
+            name='Avg Temperature (°C)',
+            line=dict(color='red'),
+            marker=dict(size=8)
+        ))
+        
+        if epw_data is not None:
+            dry_bulb = epw_data[6].values
+            month_col = epw_data[1].values
+            temps_min = []
+            temps_max = []
+            for i in range(1, 13):
+                month_mask = (month_col == i)
+                temps_min.append(round(np.nanmin(dry_bulb[month_mask]), 1))
+                temps_max.append(round(np.nanmax(dry_bulb[month_mask]), 1))
+            fig_temp.add_trace(go.Scatter(
+                x=months,
+                y=temps_max,
+                mode='lines',
+                name='Max Temperature (°C)',
+                line=dict(color='red', dash='dash'),
+                opacity=0.5
+            ))
+            fig_temp.add_trace(go.Scatter(
+                x=months,
+                y=temps_min,
+                mode='lines',
+                name='Min Temperature (°C)',
+                line=dict(color='red', dash='dash'),
+                opacity=0.5,
+                fill='tonexty',
+                fillcolor='rgba(255, 0, 0, 0.1)'
+            ))
+        
+        fig_temp.update_layout(
+            title='Monthly Temperatures',
+            xaxis_title='Month',
+            yaxis_title='Temperature (°C)',
+            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names),
+            legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
+        )
+        st.plotly_chart(fig_temp, use_container_width=True)
+        
+        fig_hum = go.Figure()
+        fig_hum.add_trace(go.Scatter(
+            x=months,
+            y=humidity_avg,
+            mode='lines+markers',
+            name='Avg Humidity (%)',
+            line=dict(color='blue'),
+            marker=dict(size=8)
+        ))
+        
+        if epw_data is not None:
+            humidity = epw_data[8].values
+            month_col = epw_data[1].values
+            humidity_min = []
+            humidity_max = []
+            for i in range(1, 13):
+                month_mask = (month_col == i)
+                humidity_min.append(round(np.nanmin(humidity[month_mask]), 1))
+                humidity_max.append(round(np.nanmax(humidity[month_mask]), 1))
+            fig_hum.add_trace(go.Scatter(
+                x=months,
+                y=humidity_max,
+                mode='lines',
+                name='Max Humidity (%)',
+                line=dict(color='blue', dash='dash'),
+                opacity=0.5
+            ))
+            fig_hum.add_trace(go.Scatter(
+                x=months,
+                y=humidity_min,
+                mode='lines',
+                name='Min Humidity (%)',
+                line=dict(color='blue', dash='dash'),
+                opacity=0.5,
+                fill='tonexty',
+                fillcolor='rgba(0, 0, 255, 0.1)'
+            ))
+        
+        fig_hum.update_layout(
+            title='Monthly Relative Humidity',
+            xaxis_title='Month',
+            yaxis_title='Relative Humidity (%)',
+            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names),
+            legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
+        )
+        st.plotly_chart(fig_hum, use_container_width=True)
+
+    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():
+            location = ClimateLocation(**loc_dict)
+            climate_data.add_location(location)
+        return climate_data
+
+if __name__ == "__main__":
+    climate_data = ClimateData()
+    session_state = {"building_info": {"country": "Iceland", "city": "Reyugalvik"}, "page": "Climate Data"}
+    climate_data.display_climate_input(session_state)

data/drapery.py

@@ -0,0 +1,304 @@
+"""
+Drapery module for HVAC Load Calculator.
+This module provides classes and functions for handling drapery properties
+and calculating their effects on window heat transfer.
+
+Based on ASHRAE principles for drapery thermal characteristics.
+"""
+
+from typing import Dict, Any, Optional, Tuple
+from enum import Enum
+
+
+class DraperyOpenness(Enum):
+    """Enum for drapery openness classification."""
+    OPEN = "Open (>25%)"
+    SEMI_OPEN = "Semi-open (7-25%)"
+    CLOSED = "Closed (0-7%)"
+
+
+class DraperyColor(Enum):
+    """Enum for drapery color/reflectance classification."""
+    DARK = "Dark (0-25%)"
+    MEDIUM = "Medium (25-50%)"
+    LIGHT = "Light (>50%)"
+
+
+class Drapery:
+    """Class for drapery properties and calculations."""
+    
+    def __init__(self, 
+                 openness: float = 0.05, 
+                 reflectance: float = 0.5, 
+                 transmittance: float = 0.3, 
+                 fullness: float = 1.0,
+                 enabled: bool = True):
+        """
+        Initialize drapery object.
+        
+        Args:
+            openness: Openness factor (0-1), fraction of fabric area that is open
+            reflectance: Reflectance factor (0-1), fraction of incident radiation reflected
+            transmittance: Transmittance factor (0-1), fraction of incident radiation transmitted
+            fullness: Fullness factor (0-2), ratio of fabric width to covered width
+            enabled: Whether the drapery is enabled/present
+        """
+        self.openness = max(0.0, min(1.0, openness))
+        self.reflectance = max(0.0, min(1.0, reflectance))
+        self.transmittance = max(0.0, min(1.0, transmittance))
+        self.fullness = max(0.0, min(2.0, fullness))
+        self.enabled = enabled
+        
+        # Calculate derived properties
+        self.absorptance = 1.0 - self.reflectance - self.transmittance
+        
+        # Classify drapery based on openness and reflectance
+        self.openness_class = self._classify_openness(self.openness)
+        self.color_class = self._classify_color(self.reflectance)
+    
+    @staticmethod
+    def _classify_openness(openness: float) -> DraperyOpenness:
+        """Classify drapery based on openness factor."""
+        if openness > 0.25:
+            return DraperyOpenness.OPEN
+        elif openness > 0.07:
+            return DraperyOpenness.SEMI_OPEN
+        else:
+            return DraperyOpenness.CLOSED
+    
+    @staticmethod
+    def _classify_color(reflectance: float) -> DraperyColor:
+        """Classify drapery based on reflectance factor."""
+        if reflectance > 0.5:
+            return DraperyColor.LIGHT
+        elif reflectance > 0.25:
+            return DraperyColor.MEDIUM
+        else:
+            return DraperyColor.DARK
+    
+    def get_classification(self) -> str:
+        """Get drapery classification string."""
+        openness_map = {
+            DraperyOpenness.OPEN: "I",
+            DraperyOpenness.SEMI_OPEN: "II",
+            DraperyOpenness.CLOSED: "III"
+        }
+        
+        color_map = {
+            DraperyColor.DARK: "D",
+            DraperyColor.MEDIUM: "M",
+            DraperyColor.LIGHT: "L"
+        }
+        
+        return f"{openness_map[self.openness_class]}{color_map[self.color_class]}"
+    
+    def calculate_iac(self, glazing_shgc: float = 0.87) -> float:
+        """
+        Calculate Interior Attenuation Coefficient (IAC) for the drapery.
+        
+        The IAC represents the fraction of heat flow that enters the room
+        after being modified by the drapery.
+        
+        Args:
+            glazing_shgc: Solar Heat Gain Coefficient of the glazing (default: 0.87 for clear glass)
+            
+        Returns:
+            IAC value (0-1)
+        """
+        if not self.enabled:
+            return 1.0  # No attenuation if drapery is not enabled
+        
+        # Calculate base IAC for flat drapery (no fullness)
+        # This is based on the principles from the Keyes Universal Chart
+        # and ASHRAE's IAC calculation methods
+        
+        # Calculate yarn reflectance (based on openness and reflectance)
+        if self.openness < 0.0001:  # Prevent division by zero
+            yarn_reflectance = self.reflectance
+        else:
+            yarn_reflectance = self.reflectance / (1.0 - self.openness)
+            yarn_reflectance = min(1.0, yarn_reflectance)  # Cap at 1.0
+        
+        # Base IAC calculation using fabric properties
+        # This is a simplified version of the ASHWAT model calculations
+        base_iac = 1.0 - (1.0 - self.openness) * (1.0 - self.transmittance / (1.0 - self.openness)) * yarn_reflectance
+        
+        # Adjust for fullness
+        # Fullness creates multiple reflections between adjacent fabric surfaces
+        if self.fullness <= 0.0:
+            fullness_factor = 1.0
+        else:
+            # Fullness effect increases with higher fullness values
+            # More fullness means more fabric area and more reflections
+            fullness_factor = 1.0 - 0.15 * (self.fullness / 2.0)
+            
+        # Apply fullness adjustment
+        adjusted_iac = base_iac * fullness_factor
+        
+        # Ensure IAC is within valid range
+        adjusted_iac = max(0.1, min(1.0, adjusted_iac))
+        
+        return adjusted_iac
+    
+    def calculate_shading_coefficient(self, glazing_shgc: float = 0.87) -> float:
+        """
+        Calculate shading coefficient for the drapery.
+        
+        The shading coefficient is the ratio of solar heat gain through
+        the window with the drapery to that of standard clear glass.
+        
+        Args:
+            glazing_shgc: Solar Heat Gain Coefficient of the glazing (default: 0.87 for clear glass)
+            
+        Returns:
+            Shading coefficient (0-1)
+        """
+        # Calculate IAC
+        iac = self.calculate_iac(glazing_shgc)
+        
+        # Calculate shading coefficient
+        # SC = IAC * SHGC / 0.87
+        shading_coefficient = iac * glazing_shgc / 0.87
+        
+        return shading_coefficient
+    
+    def calculate_u_value_adjustment(self, base_u_value: float) -> float:
+        """
+        Calculate U-value adjustment for the drapery.
+        
+        The drapery adds thermal resistance to the window assembly,
+        reducing the overall U-value.
+        
+        Args:
+            base_u_value: Base U-value of the window without drapery (W/m²K)
+            
+        Returns:
+            Adjusted U-value (W/m²K)
+        """
+        if not self.enabled:
+            return base_u_value  # No adjustment if drapery is not enabled
+        
+        # Calculate additional thermal resistance based on drapery properties
+        # This is a simplified approach based on ASHRAE principles
+        
+        # Base resistance from drapery
+        # More closed fabrics provide more resistance
+        base_resistance = 0.05  # m²K/W, typical for medium-weight drapery
+        
+        # Adjust for openness (more closed = more resistance)
+        openness_factor = 1.0 - self.openness
+        
+        # Adjust for fullness (more fullness = more resistance due to air gaps)
+        fullness_factor = 1.0 + 0.25 * self.fullness
+        
+        # Calculate total additional resistance
+        additional_resistance = base_resistance * openness_factor * fullness_factor
+        
+        # Convert base U-value to resistance
+        base_resistance = 1.0 / base_u_value
+        
+        # Add drapery resistance
+        total_resistance = base_resistance + additional_resistance
+        
+        # Convert back to U-value
+        adjusted_u_value = 1.0 / total_resistance
+        
+        return adjusted_u_value
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert drapery object to dictionary."""
+        return {
+            "openness": self.openness,
+            "reflectance": self.reflectance,
+            "transmittance": self.transmittance,
+            "fullness": self.fullness,
+            "enabled": self.enabled,
+            "absorptance": self.absorptance,
+            "openness_class": self.openness_class.value,
+            "color_class": self.color_class.value,
+            "classification": self.get_classification()
+        }
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'Drapery':
+        """Create drapery object from dictionary."""
+        return cls(
+            openness=data.get("openness", 0.05),
+            reflectance=data.get("reflectance", 0.5),
+            transmittance=data.get("transmittance", 0.3),
+            fullness=data.get("fullness", 1.0),
+            enabled=data.get("enabled", True)
+        )
+    
+    @classmethod
+    def from_classification(cls, classification: str, fullness: float = 1.0) -> 'Drapery':
+        """
+        Create drapery object from ASHRAE classification.
+        
+        Args:
+            classification: ASHRAE classification (ID, IM, IL, IID, IIM, IIL, IIID, IIIM, IIIL)
+            fullness: Fullness factor (0-2)
+            
+        Returns:
+            Drapery object
+        """
+        # Parse classification
+        if len(classification) < 2:
+            raise ValueError(f"Invalid classification: {classification}")
+        
+        # Handle single-character openness class (I) vs two-character (II, III)
+        if classification.startswith("II") or classification.startswith("III"):
+            if classification.startswith("III"):
+                openness_class = "III"
+                color_class = classification[3] if len(classification) > 3 else ""
+            else:  # II
+                openness_class = "II"
+                color_class = classification[2] if len(classification) > 2 else ""
+        else:  # I
+            openness_class = "I"
+            color_class = classification[1] if len(classification) > 1 else ""
+        
+        # Set default values
+        openness = 0.05
+        reflectance = 0.5
+        transmittance = 0.3
+        
+        # Set openness based on class
+        if openness_class == "I":
+            openness = 0.3  # Open (>25%)
+        elif openness_class == "II":
+            openness = 0.15  # Semi-open (7-25%)
+        elif openness_class == "III":
+            openness = 0.03  # Closed (0-7%)
+        
+        # Set reflectance and transmittance based on color class
+        if color_class == "D":
+            reflectance = 0.2  # Dark (0-25%)
+            transmittance = 0.05
+        elif color_class == "M":
+            reflectance = 0.4  # Medium (25-50%)
+            transmittance = 0.15
+        elif color_class == "L":
+            reflectance = 0.7  # Light (>50%)
+            transmittance = 0.2
+        
+        return cls(
+            openness=openness,
+            reflectance=reflectance,
+            transmittance=transmittance,
+            fullness=fullness
+        )
+
+
+# Predefined drapery types based on ASHRAE classifications
+PREDEFINED_DRAPERIES = {
+    "ID": Drapery.from_classification("ID"),
+    "IM": Drapery.from_classification("IM"),
+    "IL": Drapery.from_classification("IL"),
+    "IID": Drapery.from_classification("IID"),
+    "IIM": Drapery.from_classification("IIM"),
+    "IIL": Drapery.from_classification("IIL"),
+    "IIID": Drapery.from_classification("IIID"),
+    "IIIM": Drapery.from_classification("IIIM"),
+    "IIIL": Drapery.from_classification("IIIL")
+}

data/reference_data.py

@@ -0,0 +1,447 @@
+"""
+Reference data structures for HVAC Load Calculator.
+This module contains reference data for materials, construction types, and other HVAC-related data.
+"""
+
+from typing import Dict, List, Any, Optional
+import pandas as pd
+import json
+import os
+import logging
+from uuid import uuid4
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+DEFAULT_DATA_FILE = os.path.join(DATA_DIR, "reference_data.json")
+
+
+class ReferenceData:
+    """Class for managing reference data for the HVAC calculator."""
+
+    def __init__(self):
+        """Initialize reference data structures."""
+        self.materials = {}
+        self.wall_types = {}
+        self.roof_types = {}
+        self.floor_types = {}
+        self.window_types = {}
+        self.door_types = {}
+        self.internal_loads = {}
+        
+        try:
+            self._load_all_data()
+        except Exception as e:
+            logger.error(f"Error initializing reference data: {str(e)}")
+            raise
+
+    def _load_all_data(self) -> None:
+        """Load all reference data, attempting to load from JSON first."""
+        try:
+            if os.path.exists(DEFAULT_DATA_FILE):
+                self._load_from_json(DEFAULT_DATA_FILE)
+            else:
+                self._load_default_data()
+                self.export_to_json(DEFAULT_DATA_FILE)
+        except Exception as e:
+            logger.error(f"Error loading reference data: {str(e)}")
+            self._load_default_data()  # Fallback to default data
+
+    def _load_default_data(self) -> None:
+        """Load default reference data."""
+        self.materials = self._load_materials()
+        self.wall_types = self._load_wall_types()
+        self.roof_types = self._load_roof_types()
+        self.floor_types = self._load_floor_types()
+        self.window_types = self._load_window_types()
+        self.door_types = self._load_door_types()
+        self.internal_loads = self._load_internal_loads()
+
+    def _load_materials(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load material properties.
+        Returns:
+            Dictionary of material properties
+        """
+        return {
+            "brick": {
+                "id": str(uuid4()),
+                "name": "Common Brick",
+                "conductivity": 0.72,  # W/(m·K)
+                "density": 1920,  # kg/m³
+                "specific_heat": 840,  # J/(kg·K)
+                "typical_thickness": 0.1,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.7
+            },
+            "concrete": {
+                "id": str(uuid4()),
+                "name": "Concrete",
+                "conductivity": 1.4,  # W/(m·K)
+                "density": 2300,  # kg/m³
+                "specific_heat": 880,  # J/(kg·K)
+                "typical_thickness": 0.2,  # m
+                "emissivity": 0.92,
+                "solar_absorptance": 0.65
+            },
+            "mineral_wool": {
+                "id": str(uuid4()),
+                "name": "Mineral Wool Insulation",
+                "conductivity": 0.04,  # W/(m·K)
+                "density": 30,  # kg/m³
+                "specific_heat": 840,  # J/(kg·K)
+                "typical_thickness": 0.1,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.6
+            },
+            # Additional materials
+            "polyurethane_foam": {
+                "id": str(uuid4()),
+                "name": "Polyurethane Foam",
+                "conductivity": 0.025,  # W/(m·K)
+                "density": 40,  # kg/m³
+                "specific_heat": 1500,  # J/(kg·K)
+                "typical_thickness": 0.05,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.6
+            },
+            "fiberglass_insulation": {
+                "id": str(uuid4()),
+                "name": "Fiberglass Insulation",
+                "conductivity": 0.045,  # W/(m·K)
+                "density": 12,  # kg/m³
+                "specific_heat": 850,  # J/(kg·K)
+                "typical_thickness": 0.15,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.6
+            },
+            "stucco": {
+                "id": str(uuid4()),
+                "name": "Stucco",
+                "conductivity": 0.7,  # W/(m·K)
+                "density": 1850,  # kg/m³
+                "specific_heat": 900,  # J/(kg·K)
+                "typical_thickness": 0.025,  # m
+                "emissivity": 0.92,
+                "solar_absorptance": 0.5
+            }
+            # Add more materials as needed
+        }
+
+    def _load_wall_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined wall types.
+        Returns:
+            Dictionary of wall types with properties
+        """
+        return {
+            "brick_veneer_wood_frame": {
+                "id": str(uuid4()),
+                "name": "Brick Veneer with Wood Frame",
+                "description": "Brick veneer with wood frame, insulation, and gypsum board",
+                "u_value": 0.35,  # W/(m²·K)
+                "wall_group": "B",
+                "layers": [
+                    {"material": "brick", "thickness": 0.1},
+                    {"material": "air_gap", "thickness": 0.025},
+                    {"material": "wood", "thickness": 0.038},
+                    {"material": "mineral_wool", "thickness": 0.089},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ],
+                "thermal_mass": 180,  # kg/m²
+                "color": "Medium"
+            },
+            "insulated_concrete_form": {
+                "id": str(uuid4()),
+                "name": "Insulated Concrete Form",
+                "description": "ICF with EPS insulation and concrete core",
+                "u_value": 0.25,  # W/(m²·K)
+                "wall_group": "C",
+                "layers": [
+                    {"material": "eps_insulation", "thickness": 0.05},
+                    {"material": "concrete", "thickness": 0.15},
+                    {"material": "eps_insulation", "thickness": 0.05},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ],
+                "thermal_mass": 220,  # kg/m²
+                "color": "Light"
+            },
+            # Additional wall types
+            "sip_panel": {
+                "id": str(uuid4()),
+                "name": "Structural Insulated Panel",
+                "description": "SIP with OSB and EPS core",
+                "u_value": 0.28,  # W/(m²·K)
+                "wall_group": "A",
+                "layers": [
+                    {"material": "wood", "thickness": 0.012},
+                    {"material": "eps_insulation", "thickness": 0.15},
+                    {"material": "wood", "thickness": 0.012},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ],
+                "thermal_mass": 80,  # kg/m²
+                "color": "Light"
+            }
+        }
+
+    def _load_roof_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined roof types.
+        Returns:
+            Dictionary of roof types with properties
+        """
+        return {
+            "flat_roof_concrete": {
+                "id": str(uuid4()),
+                "name": "Flat Concrete Roof with Insulation",
+                "description": "Flat concrete roof with insulation and ceiling",
+                "u_value": 0.25,  # W/(m²·K)
+                "roof_group": "B",
+                "layers": [
+                    {"material": "concrete", "thickness": 0.15},
+                    {"material": "eps_insulation", "thickness": 0.15},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ],
+                "solar_absorptance": 0.7,
+                "emissivity": 0.9
+            },
+            "green_roof": {
+                "id": str(uuid4()),
+                "name": "Green Roof",
+                "description": "Vegetated roof with insulation and drainage",
+                "u_value": 0.22,  # W/(m²·K)
+                "roof_group": "A",
+                "layers": [
+                    {"material": "soil", "thickness": 0.1},
+                    {"material": "eps_insulation", "thickness": 0.1},
+                    {"material": "concrete", "thickness": 0.1},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ],
+                "solar_absorptance": 0.5,
+                "emissivity": 0.95
+            }
+        }
+
+    def _load_floor_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined floor types.
+        Returns:
+            Dictionary of floor types with properties
+        """
+        return {
+            "concrete_slab_on_grade": {
+                "id": str(uuid4()),
+                "name": "Concrete Slab on Grade",
+                "description": "Concrete slab on grade with insulation",
+                "u_value": 0.3,  # W/(m²·K)
+                "is_ground_contact": True,
+                "layers": [
+                    {"material": "concrete", "thickness": 0.1},
+                    {"material": "eps_insulation", "thickness": 0.05}
+                ],
+                "thermal_mass": 230  # kg/m²
+            },
+            "radiant_floor": {
+                "id": str(uuid4()),
+                "name": "Radiant Floor",
+                "description": "Concrete floor with radiant heating and insulation",
+                "u_value": 0.27,  # W/(m²·K)
+                "is_ground_contact": True,
+                "layers": [
+                    {"material": "tile", "thickness": 0.015},
+                    {"material": "concrete", "thickness": 0.1},
+                    {"material": "eps_insulation", "thickness": 0.075}
+                ],
+                "thermal_mass": 240  # kg/m²
+            }
+        }
+
+    def _load_window_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined window types.
+        Returns:
+            Dictionary of window types with properties
+        """
+        return {
+            "double_glazed_argon_low_e": {
+                "id": str(uuid4()),
+                "name": "Double Glazed with Argon and Low-E",
+                "description": "Double glazed window with argon fill, low-e coating, and vinyl frame",
+                "u_value": 1.4,  # W/(m²·K)
+                "shgc": 0.4,
+                "vt": 0.7,
+                "glazing_layers": 2,
+                "gas_fill": "Argon",
+                "frame_type": "Vinyl",
+                "low_e_coating": True,
+                "frame_factor": 0.15
+            },
+            "electrochromic_window": {
+                "id": str(uuid4()),
+                "name": "Electrochromic Window",
+                "description": "Smart window with dynamic tinting",
+                "u_value": 1.2,  # W/(m²·K)
+                "shgc": 0.35,
+                "vt": 0.65,
+                "glazing_layers": 2,
+                "gas_fill": "Argon",
+                "frame_type": "Fiberglass",
+                "low_e_coating": True,
+                "frame_factor": 0.12
+            }
+        }
+
+    def _load_door_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined door types.
+        Returns:
+            Dictionary of door types with properties
+        """
+        return {
+            "insulated_steel_door": {
+                "id": str(uuid4()),
+                "name": "Insulated Steel Door",
+                "description": "Insulated steel door with no glazing",
+                "u_value": 1.2,  # W/(m²·K)
+                "glazing_percentage": 0,
+                "door_type": "Solid",
+                "thermal_mass": 50  # kg/m²
+            },
+            "insulated_fiberglass_door": {
+                "id": str(uuid4()),
+                "name": "Insulated Fiberglass Door",
+                "description": "Insulated fiberglass door with small glazing",
+                "u_value": 1.5,  # W/(m²·K)
+                "glazing_percentage": 10,
+                "door_type": "Partially glazed",
+                "shgc": 0.7,
+                "vt": 0.8,
+                "thermal_mass": 40  # kg/m²
+            }
+        }
+
+    def _load_internal_loads(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load internal load data.
+        Returns:
+            Dictionary of internal load types with properties
+        """
+        return {
+            "occupancy": {
+                "office_typing": {
+                    "id": str(uuid4()),
+                    "name": "Office Typing",
+                    "sensible_heat": 75,  # W per person
+                    "latent_heat": 55,  # W per person
+                    "metabolic_rate": 1.2  # met
+                },
+                "retail_sales": {
+                    "id": str(uuid4()),
+                    "name": "Retail Sales",
+                    "sensible_heat": 80,  # W per person
+                    "latent_heat": 70,  # W per person
+                    "metabolic_rate": 1.4  # met
+                }
+            },
+            "lighting": {
+                "led_high_efficiency": {
+                    "id": str(uuid4()),
+                    "name": "High Efficiency LED",
+                    "power_density_range": [4, 8],  # W/m²
+                    "heat_to_space": 0.85,
+                    "efficacy": 120  # lm/W
+                }
+            },
+            "equipment": {
+                "computer_workstation": {
+                    "id": str(uuid4()),
+                    "name": "Computer Workstation",
+                    "power_density_range": [15, 25],  # W/m²
+                    "sensible_fraction": 0.95,
+                    "latent_fraction": 0.05
+                }
+            }
+        }
+
+    def _load_from_json(self, file_path: str) -> None:
+        """
+        Load reference data from JSON file.
+        Args:
+            file_path: Path to JSON file
+        """
+        try:
+            with open(file_path, 'r') as f:
+                data = json.load(f)
+            self.materials = data.get("materials", self.materials)
+            self.wall_types = data.get("wall_types", self.wall_types)
+            self.roof_types = data.get("roof_types", self.roof_types)
+            self.floor_types = data.get("floor_types", self.floor_types)
+            self.window_types = data.get("window_types", self.window_types)
+            self.door_types = data.get("door_types", self.door_types)
+            self.internal_loads = data.get("internal_loads", self.internal_loads)
+            logger.info(f"Successfully loaded reference data from {file_path}")
+        except Exception as e:
+            logger.error(f"Error loading JSON data from {file_path}: {str(e)}")
+            raise
+
+    def export_to_json(self, file_path: str) -> None:
+        """
+        Export all reference data to a JSON file.
+        Args:
+            file_path: Path to the output JSON file
+        """
+        try:
+            data = {
+                "materials": self.materials,
+                "wall_types": self.wall_types,
+                "roof_types": self.roof_types,
+                "floor_types": self.floor_types,
+                "window_types": self.window_types,
+                "door_types": self.door_types,
+                "internal_loads": self.internal_loads
+            }
+            with open(file_path, 'w') as f:
+                json.dump(data, f, indent=4)
+            logger.info(f"Successfully exported reference data to {file_path}")
+        except Exception as e:
+            logger.error(f"Error exporting to JSON: {str(e)}")
+            raise
+
+    # Getter methods with validation
+    def get_material(self, material_id: str) -> Optional[Dict[str, Any]]:
+        return self.materials.get(material_id)
+
+    def get_wall_type(self, wall_type_id: str) -> Optional[Dict[str, Any]]:
+        return self.wall_types.get(wall_type_id)
+
+    def get_roof_type(self, roof_type_id: str) -> Optional[Dict[str, Any]]:
+        return self.roof_types.get(roof_type_id)
+
+    def get_floor_type(self, floor_type_id: str) -> Optional[Dict[str, Any]]:
+        return self.floor_types.get(floor_type_id)
+
+    def get_window_type(self, window_type_id: str) -> Optional[Dict[str, Any]]:
+        return self.window_types.get(window_type_id)
+
+    def get_door_type(self, door_type_id: str) -> Optional[Dict[str, Any]]:
+        return self.door_types.get(door_type_id)
+
+    def get_internal_load(self, load_type: str, load_id: str) -> Optional[Dict[str, Any]]:
+        return self.internal_loads.get(load_type, {}).get(load_id)
+
+
+# Singleton instance
+try:
+    reference_data = ReferenceData()
+except Exception as e:
+    logger.error(f"Failed to create ReferenceData instance: {str(e)}")
+    raise
+
+if __name__ == "__main__":
+    try:
+        reference_data.export_to_json(DEFAULT_DATA_FILE)
+    except Exception as e:
+        logger.error(f"Error exporting default data: {str(e)}")

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

requirements.txt

@@ -1,3 +1,8 @@
-altair
-pandas
-streamlit
+streamlit==1.28.0
+pandas==2.0.3
+numpy==1.24.3
+plotly==5.18.0
+matplotlib==3.7.2
+openpyxl==3.1.2
+xlsxwriter==3.1.2
+pycountry==1.2

utils/area_calculation_system.py

@@ -0,0 +1,523 @@
+"""
+Area calculation system module for HVAC Load Calculator.
+This module implements net wall area calculation and area validation functions.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import json
+from dataclasses import dataclass, field
+
+# Import data models
+from data.building_components import Wall, Window, Door, Orientation, ComponentType
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+class AreaCalculationSystem:
+    """Class for managing area calculations and validations."""
+    
+    def __init__(self):
+        """Initialize area calculation system."""
+        self.walls = {}
+        self.windows = {}
+        self.doors = {}
+    
+    def add_wall(self, wall: Wall) -> None:
+        """
+        Add a wall to the area calculation system.
+        
+        Args:
+            wall: Wall object
+        """
+        self.walls[wall.id] = wall
+    
+    def add_window(self, window: Window) -> None:
+        """
+        Add a window to the area calculation system.
+        
+        Args:
+            window: Window object
+        """
+        self.windows[window.id] = window
+    
+    def add_door(self, door: Door) -> None:
+        """
+        Add a door to the area calculation system.
+        
+        Args:
+            door: Door object
+        """
+        self.doors[door.id] = door
+    
+    def remove_wall(self, wall_id: str) -> bool:
+        """
+        Remove a wall from the area calculation system.
+        
+        Args:
+            wall_id: Wall identifier
+            
+        Returns:
+            True if the wall was removed, False otherwise
+        """
+        if wall_id not in self.walls:
+            return False
+        
+        # Remove all windows and doors associated with this wall
+        for window_id, window in list(self.windows.items()):
+            if window.wall_id == wall_id:
+                del self.windows[window_id]
+        
+        for door_id, door in list(self.doors.items()):
+            if door.wall_id == wall_id:
+                del self.doors[door_id]
+        
+        del self.walls[wall_id]
+        return True
+    
+    def remove_window(self, window_id: str) -> bool:
+        """
+        Remove a window from the area calculation system.
+        
+        Args:
+            window_id: Window identifier
+            
+        Returns:
+            True if the window was removed, False otherwise
+        """
+        if window_id not in self.windows:
+            return False
+        
+        # Remove window from associated wall
+        window = self.windows[window_id]
+        if window.wall_id and window.wall_id in self.walls:
+            wall = self.walls[window.wall_id]
+            if window_id in wall.windows:
+                wall.windows.remove(window_id)
+                self._update_wall_net_area(wall.id)
+        
+        del self.windows[window_id]
+        return True
+    
+    def remove_door(self, door_id: str) -> bool:
+        """
+        Remove a door from the area calculation system.
+        
+        Args:
+            door_id: Door identifier
+            
+        Returns:
+            True if the door was removed, False otherwise
+        """
+        if door_id not in self.doors:
+            return False
+        
+        # Remove door from associated wall
+        door = self.doors[door_id]
+        if door.wall_id and door.wall_id in self.walls:
+            wall = self.walls[door.wall_id]
+            if door_id in wall.doors:
+                wall.doors.remove(door_id)
+                self._update_wall_net_area(wall.id)
+        
+        del self.doors[door_id]
+        return True
+    
+    def assign_window_to_wall(self, window_id: str, wall_id: str) -> bool:
+        """
+        Assign a window to a wall.
+        
+        Args:
+            window_id: Window identifier
+            wall_id: Wall identifier
+            
+        Returns:
+            True if the window was assigned, False otherwise
+        """
+        if window_id not in self.windows or wall_id not in self.walls:
+            return False
+        
+        window = self.windows[window_id]
+        wall = self.walls[wall_id]
+        
+        # Remove window from previous wall if assigned
+        if window.wall_id and window.wall_id in self.walls and window.wall_id != wall_id:
+            prev_wall = self.walls[window.wall_id]
+            if window_id in prev_wall.windows:
+                prev_wall.windows.remove(window_id)
+                self._update_wall_net_area(prev_wall.id)
+        
+        # Assign window to new wall
+        window.wall_id = wall_id
+        window.orientation = wall.orientation
+        
+        # Add window to wall's window list if not already there
+        if window_id not in wall.windows:
+            wall.windows.append(window_id)
+        
+        # Update wall net area
+        self._update_wall_net_area(wall_id)
+        
+        return True
+    
+    def assign_door_to_wall(self, door_id: str, wall_id: str) -> bool:
+        """
+        Assign a door to a wall.
+        
+        Args:
+            door_id: Door identifier
+            wall_id: Wall identifier
+            
+        Returns:
+            True if the door was assigned, False otherwise
+        """
+        if door_id not in self.doors or wall_id not in self.walls:
+            return False
+        
+        door = self.doors[door_id]
+        wall = self.walls[wall_id]
+        
+        # Remove door from previous wall if assigned
+        if door.wall_id and door.wall_id in self.walls and door.wall_id != wall_id:
+            prev_wall = self.walls[door.wall_id]
+            if door_id in prev_wall.doors:
+                prev_wall.doors.remove(door_id)
+                self._update_wall_net_area(prev_wall.id)
+        
+        # Assign door to new wall
+        door.wall_id = wall_id
+        door.orientation = wall.orientation
+        
+        # Add door to wall's door list if not already there
+        if door_id not in wall.doors:
+            wall.doors.append(door_id)
+        
+        # Update wall net area
+        self._update_wall_net_area(wall_id)
+        
+        return True
+    
+    def _update_wall_net_area(self, wall_id: str) -> None:
+        """
+        Update the net area of a wall by subtracting windows and doors.
+        
+        Args:
+            wall_id: Wall identifier
+        """
+        if wall_id not in self.walls:
+            return
+        
+        wall = self.walls[wall_id]
+        
+        # Calculate total window area
+        total_window_area = sum(self.windows[window_id].area 
+                               for window_id in wall.windows 
+                               if window_id in self.windows)
+        
+        # Calculate total door area
+        total_door_area = sum(self.doors[door_id].area 
+                             for door_id in wall.doors 
+                             if door_id in self.doors)
+        
+        # Update wall net area
+        if wall.gross_area is None:
+            wall.gross_area = wall.area
+        
+        wall.net_area = wall.gross_area - total_window_area - total_door_area
+        wall.area = wall.net_area  # Update the main area property
+    
+    def update_all_net_areas(self) -> None:
+        """Update the net areas of all walls."""
+        for wall_id in self.walls:
+            self._update_wall_net_area(wall_id)
+    
+    def validate_areas(self) -> List[Dict[str, Any]]:
+        """
+        Validate all areas and return a list of validation issues.
+        
+        Returns:
+            List of validation issues
+        """
+        issues = []
+        
+        # Check for negative or zero net wall areas
+        for wall_id, wall in self.walls.items():
+            if wall.net_area <= 0:
+                issues.append({
+                    "type": "error",
+                    "component_id": wall_id,
+                    "component_type": "Wall",
+                    "message": f"Wall '{wall.name}' has a negative or zero net area. "
+                              f"Gross area: {wall.gross_area} m², "
+                              f"Window area: {sum(self.windows[window_id].area for window_id in wall.windows if window_id in self.windows)} m², "
+                              f"Door area: {sum(self.doors[door_id].area for door_id in wall.doors if door_id in self.doors)} m², "
+                              f"Net area: {wall.net_area} m²."
+                })
+            elif wall.net_area < 0.5:
+                issues.append({
+                    "type": "warning",
+                    "component_id": wall_id,
+                    "component_type": "Wall",
+                    "message": f"Wall '{wall.name}' has a very small net area ({wall.net_area} m²). "
+                              f"Consider adjusting window and door sizes."
+                })
+        
+        # Check for windows without walls
+        for window_id, window in self.windows.items():
+            if not window.wall_id:
+                issues.append({
+                    "type": "warning",
+                    "component_id": window_id,
+                    "component_type": "Window",
+                    "message": f"Window '{window.name}' is not assigned to any wall."
+                })
+            elif window.wall_id not in self.walls:
+                issues.append({
+                    "type": "error",
+                    "component_id": window_id,
+                    "component_type": "Window",
+                    "message": f"Window '{window.name}' is assigned to a non-existent wall (ID: {window.wall_id})."
+                })
+        
+        # Check for doors without walls
+        for door_id, door in self.doors.items():
+            if not door.wall_id:
+                issues.append({
+                    "type": "warning",
+                    "component_id": door_id,
+                    "component_type": "Door",
+                    "message": f"Door '{door.name}' is not assigned to any wall."
+                })
+            elif door.wall_id not in self.walls:
+                issues.append({
+                    "type": "error",
+                    "component_id": door_id,
+                    "component_type": "Door",
+                    "message": f"Door '{door.name}' is assigned to a non-existent wall (ID: {door.wall_id})."
+                })
+        
+        # Check for windows and doors with zero area
+        for window_id, window in self.windows.items():
+            if window.area <= 0:
+                issues.append({
+                    "type": "error",
+                    "component_id": window_id,
+                    "component_type": "Window",
+                    "message": f"Window '{window.name}' has a zero or negative area ({window.area} m²)."
+                })
+        
+        for door_id, door in self.doors.items():
+            if door.area <= 0:
+                issues.append({
+                    "type": "error",
+                    "component_id": door_id,
+                    "component_type": "Door",
+                    "message": f"Door '{door.name}' has a zero or negative area ({door.area} m²)."
+                })
+        
+        return issues
+    
+    def get_wall_components(self, wall_id: str) -> Dict[str, List[str]]:
+        """
+        Get all components (windows and doors) associated with a wall.
+        
+        Args:
+            wall_id: Wall identifier
+            
+        Returns:
+            Dictionary with lists of window and door IDs
+        """
+        if wall_id not in self.walls:
+            return {"windows": [], "doors": []}
+        
+        wall = self.walls[wall_id]
+        return {
+            "windows": [window_id for window_id in wall.windows if window_id in self.windows],
+            "doors": [door_id for door_id in wall.doors if door_id in self.doors]
+        }
+    
+    def get_wall_area_breakdown(self, wall_id: str) -> Dict[str, float]:
+        """
+        Get a breakdown of wall areas (gross, net, windows, doors).
+        
+        Args:
+            wall_id: Wall identifier
+            
+        Returns:
+            Dictionary with area breakdown
+        """
+        if wall_id not in self.walls:
+            return {}
+        
+        wall = self.walls[wall_id]
+        
+        # Calculate total window area
+        window_area = sum(self.windows[window_id].area 
+                         for window_id in wall.windows 
+                         if window_id in self.windows)
+        
+        # Calculate total door area
+        door_area = sum(self.doors[door_id].area 
+                       for door_id in wall.doors 
+                       if door_id in self.doors)
+        
+        return {
+            "gross_area": wall.gross_area,
+            "net_area": wall.net_area,
+            "window_area": window_area,
+            "door_area": door_area
+        }
+    
+    def get_total_areas(self) -> Dict[str, float]:
+        """
+        Get total areas for all component types.
+        
+        Returns:
+            Dictionary with total areas
+        """
+        # Calculate total wall areas
+        total_wall_gross_area = sum(wall.gross_area for wall in self.walls.values() if wall.gross_area is not None)
+        total_wall_net_area = sum(wall.net_area for wall in self.walls.values() if wall.net_area is not None)
+        
+        # Calculate total window area
+        total_window_area = sum(window.area for window in self.windows.values())
+        
+        # Calculate total door area
+        total_door_area = sum(door.area for door in self.doors.values())
+        
+        return {
+            "total_wall_gross_area": total_wall_gross_area,
+            "total_wall_net_area": total_wall_net_area,
+            "total_window_area": total_window_area,
+            "total_door_area": total_door_area
+        }
+    
+    def get_areas_by_orientation(self) -> Dict[str, Dict[str, float]]:
+        """
+        Get areas for all component types grouped by orientation.
+        
+        Returns:
+            Dictionary with areas by orientation
+        """
+        # Initialize result dictionary
+        result = {}
+        
+        # Process walls
+        for wall in self.walls.values():
+            orientation = wall.orientation.value
+            if orientation not in result:
+                result[orientation] = {
+                    "wall_gross_area": 0,
+                    "wall_net_area": 0,
+                    "window_area": 0,
+                    "door_area": 0
+                }
+            
+            result[orientation]["wall_gross_area"] += wall.gross_area if wall.gross_area is not None else 0
+            result[orientation]["wall_net_area"] += wall.net_area if wall.net_area is not None else 0
+        
+        # Process windows
+        for window in self.windows.values():
+            orientation = window.orientation.value
+            if orientation not in result:
+                result[orientation] = {
+                    "wall_gross_area": 0,
+                    "wall_net_area": 0,
+                    "window_area": 0,
+                    "door_area": 0
+                }
+            
+            result[orientation]["window_area"] += window.area
+        
+        # Process doors
+        for door in self.doors.values():
+            orientation = door.orientation.value
+            if orientation not in result:
+                result[orientation] = {
+                    "wall_gross_area": 0,
+                    "wall_net_area": 0,
+                    "window_area": 0,
+                    "door_area": 0
+                }
+            
+            result[orientation]["door_area"] += door.area
+        
+        return result
+    
+    def export_to_json(self, file_path: str) -> None:
+        """
+        Export all components to a JSON file.
+        
+        Args:
+            file_path: Path to the output JSON file
+        """
+        data = {
+            "walls": {wall_id: wall.to_dict() for wall_id, wall in self.walls.items()},
+            "windows": {window_id: window.to_dict() for window_id, window in self.windows.items()},
+            "doors": {door_id: door.to_dict() for door_id, door in self.doors.items()}
+        }
+        
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4)
+    
+    def import_from_json(self, file_path: str) -> Tuple[int, int, int]:
+        """
+        Import components from a JSON file.
+        
+        Args:
+            file_path: Path to the input JSON file
+            
+        Returns:
+            Tuple with counts of walls, windows, and doors imported
+        """
+        from data.building_components import BuildingComponentFactory
+        
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        wall_count = 0
+        window_count = 0
+        door_count = 0
+        
+        # Import walls
+        for wall_id, wall_data in data.get("walls", {}).items():
+            try:
+                wall = BuildingComponentFactory.create_component(wall_data)
+                self.walls[wall_id] = wall
+                wall_count += 1
+            except Exception as e:
+                print(f"Error importing wall {wall_id}: {e}")
+        
+        # Import windows
+        for window_id, window_data in data.get("windows", {}).items():
+            try:
+                window = BuildingComponentFactory.create_component(window_data)
+                self.windows[window_id] = window
+                window_count += 1
+            except Exception as e:
+                print(f"Error importing window {window_id}: {e}")
+        
+        # Import doors
+        for door_id, door_data in data.get("doors", {}).items():
+            try:
+                door = BuildingComponentFactory.create_component(door_data)
+                self.doors[door_id] = door
+                door_count += 1
+            except Exception as e:
+                print(f"Error importing door {door_id}: {e}")
+        
+        # Update all net areas
+        self.update_all_net_areas()
+        
+        return (wall_count, window_count, door_count)
+
+
+# Create a singleton instance
+area_calculation_system = AreaCalculationSystem()
+
+# Export area calculation system to JSON if needed
+if __name__ == "__main__":
+    area_calculation_system.export_to_json(os.path.join(DATA_DIR, "data", "area_calculation_system.json"))

utils/component_library.py

@@ -0,0 +1,365 @@
+"""
+Component library module for HVAC Load Calculator.
+This module implements the preset component database and component selection interface.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import json
+import uuid
+from dataclasses import asdict
+
+# Import data models
+from data.building_components import (
+    BuildingComponent, Wall, Roof, Floor, Window, Door, Skylight,
+    MaterialLayer, Orientation, ComponentType, BuildingComponentFactory
+)
+from data.reference_data import reference_data
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+class ComponentLibrary:
+    """Class for managing building component library."""
+    
+    def __init__(self):
+        """Initialize component library."""
+        self.components = {}
+        self.load_preset_components()
+    
+    def load_preset_components(self):
+        """Load preset components from reference data."""
+        # Load preset walls
+        for wall_id, wall_data in reference_data.wall_types.items():
+            # Create material layers
+            material_layers = []
+            for layer_data in wall_data.get("layers", []):
+                material_id = layer_data.get("material")
+                thickness = layer_data.get("thickness")
+                
+                material = reference_data.get_material(material_id)
+                if material:
+                    layer = MaterialLayer(
+                        name=material["name"],
+                        thickness=thickness,
+                        conductivity=material["conductivity"],
+                        density=material.get("density"),
+                        specific_heat=material.get("specific_heat")
+                    )
+                    material_layers.append(layer)
+            
+            # Create wall component
+            component_id = f"preset_wall_{wall_id}"
+            wall = Wall(
+                id=component_id,
+                name=wall_data["name"],
+                component_type=ComponentType.WALL,
+                u_value=wall_data["u_value"],
+                area=1.0,  # Area will be set when component is used
+                orientation=Orientation.NOT_APPLICABLE,  # Orientation will be set when component is used
+                wall_type=wall_data["name"],
+                wall_group=wall_data["wall_group"],
+                material_layers=material_layers
+            )
+            
+            self.components[component_id] = wall
+        
+        # Load preset roofs
+        for roof_id, roof_data in reference_data.roof_types.items():
+            # Create material layers
+            material_layers = []
+            for layer_data in roof_data.get("layers", []):
+                material_id = layer_data.get("material")
+                thickness = layer_data.get("thickness")
+                
+                material = reference_data.get_material(material_id)
+                if material:
+                    layer = MaterialLayer(
+                        name=material["name"],
+                        thickness=thickness,
+                        conductivity=material["conductivity"],
+                        density=material.get("density"),
+                        specific_heat=material.get("specific_heat")
+                    )
+                    material_layers.append(layer)
+            
+            # Create roof component
+            component_id = f"preset_roof_{roof_id}"
+            roof = Roof(
+                id=component_id,
+                name=roof_data["name"],
+                component_type=ComponentType.ROOF,
+                u_value=roof_data["u_value"],
+                area=1.0,  # Area will be set when component is used
+                orientation=Orientation.HORIZONTAL,
+                roof_type=roof_data["name"],
+                roof_group=roof_data["roof_group"],
+                material_layers=material_layers
+            )
+            
+            self.components[component_id] = roof
+        
+        # Load preset floors
+        for floor_id, floor_data in reference_data.floor_types.items():
+            # Create material layers
+            material_layers = []
+            for layer_data in floor_data.get("layers", []):
+                material_id = layer_data.get("material")
+                thickness = layer_data.get("thickness")
+                
+                material = reference_data.get_material(material_id)
+                if material:
+                    layer = MaterialLayer(
+                        name=material["name"],
+                        thickness=thickness,
+                        conductivity=material["conductivity"],
+                        density=material.get("density"),
+                        specific_heat=material.get("specific_heat")
+                    )
+                    material_layers.append(layer)
+            
+            # Create floor component
+            component_id = f"preset_floor_{floor_id}"
+            floor = Floor(
+                id=component_id,
+                name=floor_data["name"],
+                component_type=ComponentType.FLOOR,
+                u_value=floor_data["u_value"],
+                area=1.0,  # Area will be set when component is used
+                orientation=Orientation.HORIZONTAL,
+                floor_type=floor_data["name"],
+                is_ground_contact=floor_data["is_ground_contact"],
+                material_layers=material_layers
+            )
+            
+            self.components[component_id] = floor
+        
+        # Load preset windows
+        for window_id, window_data in reference_data.window_types.items():
+            # Create window component
+            component_id = f"preset_window_{window_id}"
+            window = Window(
+                id=component_id,
+                name=window_data["name"],
+                component_type=ComponentType.WINDOW,
+                u_value=window_data["u_value"],
+                area=1.0,  # Area will be set when component is used
+                orientation=Orientation.NOT_APPLICABLE,  # Orientation will be set when component is used
+                shgc=window_data["shgc"],
+                vt=window_data["vt"],
+                window_type=window_data["name"],
+                glazing_layers=window_data["glazing_layers"],
+                gas_fill=window_data["gas_fill"],
+                low_e_coating=window_data["low_e_coating"]
+            )
+            
+            self.components[component_id] = window
+        
+        # Load preset doors
+        for door_id, door_data in reference_data.door_types.items():
+            # Create door component
+            component_id = f"preset_door_{door_id}"
+            door = Door(
+                id=component_id,
+                name=door_data["name"],
+                component_type=ComponentType.DOOR,
+                u_value=door_data["u_value"],
+                area=1.0,  # Area will be set when component is used
+                orientation=Orientation.NOT_APPLICABLE,  # Orientation will be set when component is used
+                door_type=door_data["door_type"],
+                glazing_percentage=door_data["glazing_percentage"],
+                shgc=door_data.get("shgc", 0.0),
+                vt=door_data.get("vt", 0.0)
+            )
+            
+            self.components[component_id] = door
+    
+    def get_component(self, component_id: str) -> Optional[BuildingComponent]:
+        """
+        Get a component by ID.
+        
+        Args:
+            component_id: Component identifier
+            
+        Returns:
+            BuildingComponent object or None if not found
+        """
+        return self.components.get(component_id)
+    
+    def get_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
+        """
+        Get all components of a specific type.
+        
+        Args:
+            component_type: Component type
+            
+        Returns:
+            List of BuildingComponent objects
+        """
+        return [comp for comp in self.components.values() if comp.component_type == component_type]
+    
+    def get_preset_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
+        """
+        Get all preset components of a specific type.
+        
+        Args:
+            component_type: Component type
+            
+        Returns:
+            List of BuildingComponent objects
+        """
+        return [comp for comp in self.components.values() 
+                if comp.component_type == component_type and comp.id.startswith("preset_")]
+    
+    def get_custom_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
+        """
+        Get all custom components of a specific type.
+        
+        Args:
+            component_type: Component type
+            
+        Returns:
+            List of BuildingComponent objects
+        """
+        return [comp for comp in self.components.values() 
+                if comp.component_type == component_type and comp.id.startswith("custom_")]
+    
+    def add_component(self, component: BuildingComponent) -> str:
+        """
+        Add a component to the library.
+        
+        Args:
+            component: BuildingComponent object
+            
+        Returns:
+            Component ID
+        """
+        if component.id in self.components:
+            # Generate a new ID if the component ID already exists
+            component.id = f"custom_{component.component_type.value.lower()}_{str(uuid.uuid4())[:8]}"
+        
+        self.components[component.id] = component
+        return component.id
+    
+    def update_component(self, component_id: str, component: BuildingComponent) -> bool:
+        """
+        Update a component in the library.
+        
+        Args:
+            component_id: ID of the component to update
+            component: Updated BuildingComponent object
+            
+        Returns:
+            True if the component was updated, False otherwise
+        """
+        if component_id not in self.components:
+            return False
+        
+        # Preserve the original ID
+        component.id = component_id
+        self.components[component_id] = component
+        return True
+    
+    def remove_component(self, component_id: str) -> bool:
+        """
+        Remove a component from the library.
+        
+        Args:
+            component_id: ID of the component to remove
+            
+        Returns:
+            True if the component was removed, False otherwise
+        """
+        if component_id not in self.components:
+            return False
+        
+        # Don't allow removing preset components
+        if component_id.startswith("preset_"):
+            return False
+        
+        del self.components[component_id]
+        return True
+    
+    def clone_component(self, component_id: str, new_name: str = None) -> Optional[str]:
+        """
+        Clone a component in the library.
+        
+        Args:
+            component_id: ID of the component to clone
+            new_name: Name for the cloned component (optional)
+            
+        Returns:
+            ID of the cloned component or None if the original component was not found
+        """
+        if component_id not in self.components:
+            return None
+        
+        # Get the original component
+        original = self.components[component_id]
+        
+        # Create a copy of the component
+        component_dict = asdict(original)
+        
+        # Generate a new ID
+        component_dict["id"] = f"custom_{original.component_type.value.lower()}_{str(uuid.uuid4())[:8]}"
+        
+        # Set new name if provided
+        if new_name:
+            component_dict["name"] = new_name
+        else:
+            component_dict["name"] = f"Copy of {original.name}"
+        
+        # Create a new component
+        new_component = BuildingComponentFactory.create_component(component_dict)
+        
+        # Add the new component to the library
+        self.components[new_component.id] = new_component
+        
+        return new_component.id
+    
+    def export_to_json(self, file_path: str) -> None:
+        """
+        Export all components to a JSON file.
+        
+        Args:
+            file_path: Path to the output JSON file
+        """
+        data = {comp_id: comp.to_dict() for comp_id, comp in self.components.items()}
+        
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4)
+    
+    def import_from_json(self, file_path: str) -> int:
+        """
+        Import components from a JSON file.
+        
+        Args:
+            file_path: Path to the input JSON file
+            
+        Returns:
+            Number of components imported
+        """
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        count = 0
+        for comp_id, comp_data in data.items():
+            try:
+                component = BuildingComponentFactory.create_component(comp_data)
+                self.components[comp_id] = component
+                count += 1
+            except Exception as e:
+                print(f"Error importing component {comp_id}: {e}")
+        
+        return count
+
+
+# Create a singleton instance
+component_library = ComponentLibrary()
+
+# Export component library to JSON if needed
+if __name__ == "__main__":
+    component_library.export_to_json(os.path.join(DATA_DIR, "component_library.json"))

utils/component_visualization.py

@@ -0,0 +1,721 @@
+"""
+Hierarchical component visualization module for HVAC Load Calculator.
+This module provides visualization tools for building components.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple
+import math
+
+# Import data models
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+
+
+class ComponentVisualization:
+    """Class for hierarchical component visualization."""
+    
+    @staticmethod
+    def create_component_summary_table(components: Dict[str, List[Any]]) -> pd.DataFrame:
+        """
+        Create a summary table of building components.
+        
+        Args:
+            components: Dictionary with lists of building components
+            
+        Returns:
+            DataFrame with component summary
+        """
+        # Initialize data
+        data = []
+        
+        # Process walls
+        for wall in components.get("walls", []):
+            data.append({
+                "Component Type": "Wall",
+                "Name": wall.name,
+                "Orientation": wall.orientation.name,
+                "Area (m²)": wall.area,
+                "U-Value (W/m²·K)": wall.u_value,
+                "Heat Transfer (W/K)": wall.area * wall.u_value
+            })
+        
+        # Process roofs
+        for roof in components.get("roofs", []):
+            data.append({
+                "Component Type": "Roof",
+                "Name": roof.name,
+                "Orientation": roof.orientation.name,
+                "Area (m²)": roof.area,
+                "U-Value (W/m²·K)": roof.u_value,
+                "Heat Transfer (W/K)": roof.area * roof.u_value
+            })
+        
+        # Process floors
+        for floor in components.get("floors", []):
+            data.append({
+                "Component Type": "Floor",
+                "Name": floor.name,
+                "Orientation": "Horizontal",
+                "Area (m²)": floor.area,
+                "U-Value (W/m²·K)": floor.u_value,
+                "Heat Transfer (W/K)": floor.area * floor.u_value
+            })
+        
+        # Process windows
+        for window in components.get("windows", []):
+            data.append({
+                "Component Type": "Window",
+                "Name": window.name,
+                "Orientation": window.orientation.name,
+                "Area (m²)": window.area,
+                "U-Value (W/m²·K)": window.u_value,
+                "Heat Transfer (W/K)": window.area * window.u_value,
+                "SHGC": window.shgc if hasattr(window, "shgc") else None
+            })
+        
+        # Process doors
+        for door in components.get("doors", []):
+            data.append({
+                "Component Type": "Door",
+                "Name": door.name,
+                "Orientation": door.orientation.name,
+                "Area (m²)": door.area,
+                "U-Value (W/m²·K)": door.u_value,
+                "Heat Transfer (W/K)": door.area * door.u_value
+            })
+        
+        # Create DataFrame
+        df = pd.DataFrame(data)
+        
+        return df
+    
+    @staticmethod
+    def create_component_area_chart(components: Dict[str, List[Any]]) -> go.Figure:
+        """
+        Create a pie chart of component areas.
+        
+        Args:
+            components: Dictionary with lists of building components
+            
+        Returns:
+            Plotly figure with component area breakdown
+        """
+        # Calculate total areas by component type
+        areas = {
+            "Walls": sum(wall.area for wall in components.get("walls", [])),
+            "Roofs": sum(roof.area for roof in components.get("roofs", [])),
+            "Floors": sum(floor.area for floor in components.get("floors", [])),
+            "Windows": sum(window.area for window in components.get("windows", [])),
+            "Doors": sum(door.area for door in components.get("doors", []))
+        }
+        
+        # Create labels and values
+        labels = list(areas.keys())
+        values = list(areas.values())
+        
+        # Create pie chart
+        fig = go.Figure(data=[go.Pie(
+            labels=labels,
+            values=values,
+            hole=0.3,
+            textinfo="label+percent",
+            insidetextorientation="radial"
+        )])
+        
+        # Update layout
+        fig.update_layout(
+            title="Building Component Areas",
+            height=500,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_orientation_area_chart(components: Dict[str, List[Any]]) -> go.Figure:
+        """
+        Create a bar chart of areas by orientation.
+        
+        Args:
+            components: Dictionary with lists of building components
+            
+        Returns:
+            Plotly figure with area breakdown by orientation
+        """
+        # Initialize areas by orientation
+        orientation_areas = {
+            "NORTH": 0,
+            "NORTHEAST": 0,
+            "EAST": 0,
+            "SOUTHEAST": 0,
+            "SOUTH": 0,
+            "SOUTHWEST": 0,
+            "WEST": 0,
+            "NORTHWEST": 0,
+            "HORIZONTAL": 0
+        }
+        
+        # Calculate areas by orientation for walls
+        for wall in components.get("walls", []):
+            orientation_areas[wall.orientation.name] += wall.area
+        
+        # Calculate areas by orientation for windows
+        for window in components.get("windows", []):
+            orientation_areas[window.orientation.name] += window.area
+        
+        # Calculate areas by orientation for doors
+        for door in components.get("doors", []):
+            orientation_areas[door.orientation.name] += door.area
+        
+        # Add roofs and floors to horizontal
+        for roof in components.get("roofs", []):
+            if roof.orientation.name == "HORIZONTAL":
+                orientation_areas["HORIZONTAL"] += roof.area
+            else:
+                orientation_areas[roof.orientation.name] += roof.area
+        
+        for floor in components.get("floors", []):
+            orientation_areas["HORIZONTAL"] += floor.area
+        
+        # Create labels and values
+        orientations = []
+        areas = []
+        
+        for orientation, area in orientation_areas.items():
+            if area > 0:
+                orientations.append(orientation)
+                areas.append(area)
+        
+        # Create bar chart
+        fig = go.Figure(data=[go.Bar(
+            x=orientations,
+            y=areas,
+            text=areas,
+            texttemplate="%{y:.1f} m²",
+            textposition="auto"
+        )])
+        
+        # Update layout
+        fig.update_layout(
+            title="Building Component Areas by Orientation",
+            xaxis_title="Orientation",
+            yaxis_title="Area (m²)",
+            height=500
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_heat_transfer_chart(components: Dict[str, List[Any]]) -> go.Figure:
+        """
+        Create a bar chart of heat transfer coefficients by component type.
+        
+        Args:
+            components: Dictionary with lists of building components
+            
+        Returns:
+            Plotly figure with heat transfer breakdown
+        """
+        # Calculate heat transfer by component type
+        heat_transfer = {
+            "Walls": sum(wall.area * wall.u_value for wall in components.get("walls", [])),
+            "Roofs": sum(roof.area * roof.u_value for roof in components.get("roofs", [])),
+            "Floors": sum(floor.area * floor.u_value for floor in components.get("floors", [])),
+            "Windows": sum(window.area * window.u_value for window in components.get("windows", [])),
+            "Doors": sum(door.area * door.u_value for door in components.get("doors", []))
+        }
+        
+        # Create labels and values
+        labels = list(heat_transfer.keys())
+        values = list(heat_transfer.values())
+        
+        # Create bar chart
+        fig = go.Figure(data=[go.Bar(
+            x=labels,
+            y=values,
+            text=values,
+            texttemplate="%{y:.1f} W/K",
+            textposition="auto"
+        )])
+        
+        # Update layout
+        fig.update_layout(
+            title="Heat Transfer Coefficients by Component Type",
+            xaxis_title="Component Type",
+            yaxis_title="Heat Transfer Coefficient (W/K)",
+            height=500
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_3d_building_model(components: Dict[str, List[Any]]) -> go.Figure:
+        """
+        Create a 3D visualization of the building components.
+        
+        Args:
+            components: Dictionary with lists of building components
+            
+        Returns:
+            Plotly figure with 3D building model
+        """
+        # Initialize figure
+        fig = go.Figure()
+        
+        # Define colors
+        colors = {
+            "Wall": "lightblue",
+            "Roof": "red",
+            "Floor": "brown",
+            "Window": "skyblue",
+            "Door": "orange"
+        }
+        
+        # Define orientation vectors
+        orientation_vectors = {
+            "NORTH": (0, 1, 0),
+            "NORTHEAST": (0.7071, 0.7071, 0),
+            "EAST": (1, 0, 0),
+            "SOUTHEAST": (0.7071, -0.7071, 0),
+            "SOUTH": (0, -1, 0),
+            "SOUTHWEST": (-0.7071, -0.7071, 0),
+            "WEST": (-1, 0, 0),
+            "NORTHWEST": (-0.7071, 0.7071, 0),
+            "HORIZONTAL": (0, 0, 1)
+        }
+        
+        # Define building dimensions (simplified model)
+        building_width = 10
+        building_depth = 10
+        building_height = 3
+        
+        # Create walls
+        for i, wall in enumerate(components.get("walls", [])):
+            orientation = wall.orientation.name
+            vector = orientation_vectors[orientation]
+            
+            # Determine wall position and dimensions
+            if orientation in ["NORTH", "SOUTH"]:
+                width = building_width
+                height = building_height
+                depth = 0.3
+                
+                if orientation == "NORTH":
+                    x = 0
+                    y = building_depth / 2
+                else:  # SOUTH
+                    x = 0
+                    y = -building_depth / 2
+                
+                z = building_height / 2
+                
+            elif orientation in ["EAST", "WEST"]:
+                width = 0.3
+                height = building_height
+                depth = building_depth
+                
+                if orientation == "EAST":
+                    x = building_width / 2
+                    y = 0
+                else:  # WEST
+                    x = -building_width / 2
+                    y = 0
+                
+                z = building_height / 2
+            
+            else:  # Diagonal orientations
+                width = building_width / 2
+                height = building_height
+                depth = 0.3
+                
+                if orientation == "NORTHEAST":
+                    x = building_width / 4
+                    y = building_depth / 4
+                elif orientation == "SOUTHEAST":
+                    x = building_width / 4
+                    y = -building_depth / 4
+                elif orientation == "SOUTHWEST":
+                    x = -building_width / 4
+                    y = -building_depth / 4
+                else:  # NORTHWEST
+                    x = -building_width / 4
+                    y = building_depth / 4
+                
+                z = building_height / 2
+            
+            # Add wall to figure
+            fig.add_trace(go.Mesh3d(
+                x=[x - width/2, x + width/2, x + width/2, x - width/2, x - width/2, x + width/2, x + width/2, x - width/2],
+                y=[y - depth/2, y - depth/2, y + depth/2, y + depth/2, y - depth/2, y - depth/2, y + depth/2, y + depth/2],
+                z=[z - height/2, z - height/2, z - height/2, z - height/2, z + height/2, z + height/2, z + height/2, z + height/2],
+                i=[0, 0, 0, 1, 4, 4],
+                j=[1, 2, 4, 2, 5, 6],
+                k=[2, 3, 7, 3, 6, 7],
+                color=colors["Wall"],
+                opacity=0.7,
+                name=f"Wall: {wall.name}"
+            ))
+        
+        # Create roof
+        for i, roof in enumerate(components.get("roofs", [])):
+            # Add roof to figure
+            fig.add_trace(go.Mesh3d(
+                x=[-building_width/2, building_width/2, building_width/2, -building_width/2],
+                y=[-building_depth/2, -building_depth/2, building_depth/2, building_depth/2],
+                z=[building_height, building_height, building_height, building_height],
+                i=[0],
+                j=[1],
+                k=[2],
+                color=colors["Roof"],
+                opacity=0.7,
+                name=f"Roof: {roof.name}"
+            ))
+            
+            fig.add_trace(go.Mesh3d(
+                x=[-building_width/2, -building_width/2, building_width/2],
+                y=[building_depth/2, -building_depth/2, -building_depth/2],
+                z=[building_height, building_height, building_height],
+                i=[0],
+                j=[1],
+                k=[2],
+                color=colors["Roof"],
+                opacity=0.7,
+                name=f"Roof: {roof.name}"
+            ))
+        
+        # Create floor
+        for i, floor in enumerate(components.get("floors", [])):
+            # Add floor to figure
+            fig.add_trace(go.Mesh3d(
+                x=[-building_width/2, building_width/2, building_width/2, -building_width/2],
+                y=[-building_depth/2, -building_depth/2, building_depth/2, building_depth/2],
+                z=[0, 0, 0, 0],
+                i=[0],
+                j=[1],
+                k=[2],
+                color=colors["Floor"],
+                opacity=0.7,
+                name=f"Floor: {floor.name}"
+            ))
+            
+            fig.add_trace(go.Mesh3d(
+                x=[-building_width/2, -building_width/2, building_width/2],
+                y=[building_depth/2, -building_depth/2, -building_depth/2],
+                z=[0, 0, 0],
+                i=[0],
+                j=[1],
+                k=[2],
+                color=colors["Floor"],
+                opacity=0.7,
+                name=f"Floor: {floor.name}"
+            ))
+        
+        # Create windows
+        for i, window in enumerate(components.get("windows", [])):
+            orientation = window.orientation.name
+            vector = orientation_vectors[orientation]
+            
+            # Determine window position and dimensions
+            window_width = 1.5
+            window_height = 1.2
+            window_depth = 0.1
+            
+            if orientation == "NORTH":
+                x = i * 3 - building_width/4
+                y = building_depth / 2
+                z = building_height / 2
+            elif orientation == "SOUTH":
+                x = i * 3 - building_width/4
+                y = -building_depth / 2
+                z = building_height / 2
+            elif orientation == "EAST":
+                x = building_width / 2
+                y = i * 3 - building_depth/4
+                z = building_height / 2
+            elif orientation == "WEST":
+                x = -building_width / 2
+                y = i * 3 - building_depth/4
+                z = building_height / 2
+            else:
+                # Skip diagonal orientations for simplicity
+                continue
+            
+            # Add window to figure
+            fig.add_trace(go.Mesh3d(
+                x=[x - window_width/2, x + window_width/2, x + window_width/2, x - window_width/2, x - window_width/2, x + window_width/2, x + window_width/2, x - window_width/2],
+                y=[y - window_depth/2, y - window_depth/2, y + window_depth/2, y + window_depth/2, y - window_depth/2, y - window_depth/2, y + window_depth/2, y + window_depth/2],
+                z=[z - window_height/2, z - window_height/2, z - window_height/2, z - window_height/2, z + window_height/2, z + window_height/2, z + window_height/2, z + window_height/2],
+                i=[0, 0, 0, 1, 4, 4],
+                j=[1, 2, 4, 2, 5, 6],
+                k=[2, 3, 7, 3, 6, 7],
+                color=colors["Window"],
+                opacity=0.5,
+                name=f"Window: {window.name}"
+            ))
+        
+        # Create doors
+        for i, door in enumerate(components.get("doors", [])):
+            orientation = door.orientation.name
+            vector = orientation_vectors[orientation]
+            
+            # Determine door position and dimensions
+            door_width = 1.0
+            door_height = 2.0
+            door_depth = 0.1
+            
+            if orientation == "NORTH":
+                x = i * 3
+                y = building_depth / 2
+                z = door_height / 2
+            elif orientation == "SOUTH":
+                x = i * 3
+                y = -building_depth / 2
+                z = door_height / 2
+            elif orientation == "EAST":
+                x = building_width / 2
+                y = i * 3
+                z = door_height / 2
+            elif orientation == "WEST":
+                x = -building_width / 2
+                y = i * 3
+                z = door_height / 2
+            else:
+                # Skip diagonal orientations for simplicity
+                continue
+            
+            # Add door to figure
+            fig.add_trace(go.Mesh3d(
+                x=[x - door_width/2, x + door_width/2, x + door_width/2, x - door_width/2, x - door_width/2, x + door_width/2, x + door_width/2, x - door_width/2],
+                y=[y - door_depth/2, y - door_depth/2, y + door_depth/2, y + door_depth/2, y - door_depth/2, y - door_depth/2, y + door_depth/2, y + door_depth/2],
+                z=[z - door_height/2, z - door_height/2, z - door_height/2, z - door_height/2, z + door_height/2, z + door_height/2, z + door_height/2, z + door_height/2],
+                i=[0, 0, 0, 1, 4, 4],
+                j=[1, 2, 4, 2, 5, 6],
+                k=[2, 3, 7, 3, 6, 7],
+                color=colors["Door"],
+                opacity=0.7,
+                name=f"Door: {door.name}"
+            ))
+        
+        # Update layout
+        fig.update_layout(
+            title="3D Building Model",
+            scene=dict(
+                xaxis_title="X",
+                yaxis_title="Y",
+                zaxis_title="Z",
+                aspectmode="data"
+            ),
+            height=700,
+            margin=dict(l=0, r=0, b=0, t=30)
+        )
+        
+        return fig
+    
+    @staticmethod
+    def display_component_visualization(components: Dict[str, List[Any]]) -> None:
+        """
+        Display component visualization in Streamlit.
+        
+        Args:
+            components: Dictionary with lists of building components
+        """
+        st.header("Building Component Visualization")
+        
+        # Create tabs for different visualizations
+        tab1, tab2, tab3, tab4, tab5 = st.tabs([
+            "Component Summary", 
+            "Area Breakdown", 
+            "Orientation Analysis", 
+            "Heat Transfer Analysis",
+            "3D Building Model"
+        ])
+        
+        with tab1:
+            st.subheader("Component Summary")
+            df = ComponentVisualization.create_component_summary_table(components)
+            st.dataframe(df, use_container_width=True)
+            
+            # Add download button for CSV
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download Component Summary as CSV",
+                data=csv,
+                file_name="component_summary.csv",
+                mime="text/csv"
+            )
+        
+        with tab2:
+            st.subheader("Area Breakdown")
+            fig = ComponentVisualization.create_component_area_chart(components)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tab3:
+            st.subheader("Orientation Analysis")
+            fig = ComponentVisualization.create_orientation_area_chart(components)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tab4:
+            st.subheader("Heat Transfer Analysis")
+            fig = ComponentVisualization.create_heat_transfer_chart(components)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tab5:
+            st.subheader("3D Building Model")
+            fig = ComponentVisualization.create_3d_building_model(components)
+            st.plotly_chart(fig, use_container_width=True)
+
+
+# Create a singleton instance
+component_visualization = ComponentVisualization()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+    
+    # Create sample building components
+    walls = [
+        Wall(
+            id="wall1",
+            name="North Wall",
+            component_type=ComponentType.WALL,
+            u_value=0.5,
+            area=20.0,
+            orientation=Orientation.NORTH,
+            wall_type="Brick",
+            wall_group="B"
+        ),
+        Wall(
+            id="wall2",
+            name="South Wall",
+            component_type=ComponentType.WALL,
+            u_value=0.5,
+            area=20.0,
+            orientation=Orientation.SOUTH,
+            wall_type="Brick",
+            wall_group="B"
+        ),
+        Wall(
+            id="wall3",
+            name="East Wall",
+            component_type=ComponentType.WALL,
+            u_value=0.5,
+            area=15.0,
+            orientation=Orientation.EAST,
+            wall_type="Brick",
+            wall_group="B"
+        ),
+        Wall(
+            id="wall4",
+            name="West Wall",
+            component_type=ComponentType.WALL,
+            u_value=0.5,
+            area=15.0,
+            orientation=Orientation.WEST,
+            wall_type="Brick",
+            wall_group="B"
+        )
+    ]
+    
+    roofs = [
+        Roof(
+            id="roof1",
+            name="Flat Roof",
+            component_type=ComponentType.ROOF,
+            u_value=0.3,
+            area=100.0,
+            orientation=Orientation.HORIZONTAL,
+            roof_type="Concrete",
+            roof_group="C"
+        )
+    ]
+    
+    floors = [
+        Floor(
+            id="floor1",
+            name="Ground Floor",
+            component_type=ComponentType.FLOOR,
+            u_value=0.4,
+            area=100.0,
+            floor_type="Concrete"
+        )
+    ]
+    
+    windows = [
+        Window(
+            id="window1",
+            name="North Window 1",
+            component_type=ComponentType.WINDOW,
+            u_value=2.8,
+            area=4.0,
+            orientation=Orientation.NORTH,
+            shgc=0.7,
+            vt=0.8,
+            window_type="Double Glazed",
+            glazing_layers=2,
+            gas_fill="Air",
+            low_e_coating=False
+        ),
+        Window(
+            id="window2",
+            name="South Window 1",
+            component_type=ComponentType.WINDOW,
+            u_value=2.8,
+            area=6.0,
+            orientation=Orientation.SOUTH,
+            shgc=0.7,
+            vt=0.8,
+            window_type="Double Glazed",
+            glazing_layers=2,
+            gas_fill="Air",
+            low_e_coating=False
+        ),
+        Window(
+            id="window3",
+            name="East Window 1",
+            component_type=ComponentType.WINDOW,
+            u_value=2.8,
+            area=3.0,
+            orientation=Orientation.EAST,
+            shgc=0.7,
+            vt=0.8,
+            window_type="Double Glazed",
+            glazing_layers=2,
+            gas_fill="Air",
+            low_e_coating=False
+        )
+    ]
+    
+    doors = [
+        Door(
+            id="door1",
+            name="Front Door",
+            component_type=ComponentType.DOOR,
+            u_value=2.0,
+            area=2.0,
+            orientation=Orientation.SOUTH,
+            door_type="Solid Wood"
+        )
+    ]
+    
+    # Create components dictionary
+    components = {
+        "walls": walls,
+        "roofs": roofs,
+        "floors": floors,
+        "windows": windows,
+        "doors": doors
+    }
+    
+    # Display component visualization
+    component_visualization.display_component_visualization(components)

utils/cooling_load.py

@@ -0,0 +1,1029 @@
+"""
+Cooling load calculation module for HVAC Load Calculator.
+Implements ASHRAE steady-state methods with Cooling Load Temperature Difference (CLTD).
+Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.5.
+
+Author: Dr Majed Abuseif
+Date: April 2025
+Version: 1.0.6
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import numpy as np
+import logging
+from data.ashrae_tables import ASHRAETables
+from utils.heat_transfer import HeatTransferCalculations
+from utils.psychrometrics import Psychrometrics
+from app.component_selection import Wall, Roof, Window, Door, Orientation
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class CoolingLoadCalculator:
+    """Class for cooling load calculations based on ASHRAE steady-state methods."""
+    
+    def __init__(self, debug_mode: bool = False):
+        """
+        Initialize cooling load calculator.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.5.
+        
+        Args:
+            debug_mode: Enable debug logging if True
+        """
+        self.ashrae_tables = ASHRAETables()
+        self.heat_transfer = HeatTransferCalculations()
+        self.psychrometrics = Psychrometrics()
+        self.hours = list(range(24))
+        self.valid_latitudes = ['24N', '32N', '40N', '48N', '56N']
+        self.valid_months = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
+        self.valid_wall_groups = ['A', 'B', 'C', 'D']
+        self.valid_roof_groups = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
+        self.debug_mode = debug_mode
+        if debug_mode:
+            logger.setLevel(logging.DEBUG)
+    
+    def validate_latitude(self, latitude: Any) -> str:
+        """
+        Validate and normalize latitude input.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Section 14.2.
+        
+        Args:
+            latitude: Latitude input (str, float, or other)
+            
+        Returns:
+            Valid latitude string ('24N', '32N', '40N', '48N', '56N')
+        """
+        try:
+            if not isinstance(latitude, str):
+                try:
+                    lat_val = float(latitude)
+                    if lat_val <= 28:
+                        return '24N'
+                    elif lat_val <= 36:
+                        return '32N'
+                    elif lat_val <= 44:
+                        return '40N'
+                    elif lat_val <= 52:
+                        return '48N'
+                    else:
+                        return '56N'
+                except (ValueError, TypeError):
+                    latitude = str(latitude)
+            
+            latitude = latitude.strip().upper()
+            if self.debug_mode:
+                logger.debug(f"Validating latitude: {latitude}")
+            
+            if '_' in latitude:
+                parts = latitude.split('_')
+                if len(parts) > 1:
+                    lat_part = parts[0]
+                    if self.debug_mode:
+                        logger.warning(f"Detected concatenated input: {latitude}. Using latitude={lat_part}")
+                    latitude = lat_part
+            
+            if '.' in latitude or any(c.isdigit() for c in latitude):
+                num_part = ''.join(c for c in latitude if c.isdigit() or c == '.')
+                try:
+                    lat_val = float(num_part)
+                    if lat_val <= 28:
+                        mapped_latitude = '24N'
+                    elif lat_val <= 36:
+                        mapped_latitude = '32N'
+                    elif lat_val <= 44:
+                        mapped_latitude = '40N'
+                    elif lat_val <= 52:
+                        mapped_latitude = '48N'
+                    else:
+                        mapped_latitude = '56N'
+                    if self.debug_mode:
+                        logger.debug(f"Mapped numerical latitude {lat_val} to {mapped_latitude}")
+                    return mapped_latitude
+                except ValueError:
+                    if self.debug_mode:
+                        logger.warning(f"Cannot parse numerical latitude: {latitude}. Defaulting to '32N'")
+                    return '32N'
+            
+            if latitude in self.valid_latitudes:
+                return latitude
+            
+            if self.debug_mode:
+                logger.warning(f"Invalid latitude: {latitude}. Defaulting to '32N'")
+            return '32N'
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error validating latitude {latitude}: {str(e)}")
+            return '32N'
+    
+    def validate_month(self, month: Any) -> str:
+        """
+        Validate and normalize month input.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Section 14.2.
+        
+        Args:
+            month: Month input (str or other)
+            
+        Returns:
+            Valid month string in uppercase
+        """
+        try:
+            if not isinstance(month, str):
+                month = str(month)
+            
+            month_upper = month.strip().upper()
+            if month_upper not in self.valid_months:
+                if self.debug_mode:
+                    logger.warning(f"Invalid month: {month}. Defaulting to 'JUL'")
+                return 'JUL'
+            return month_upper
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error validating month {month}: {str(e)}")
+            return 'JUL'
+    
+    def validate_hour(self, hour: Any) -> int:
+        """
+        Validate and normalize hour input.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Section 14.2.
+        
+        Args:
+            hour: Hour input (int, float, or other)
+            
+        Returns:
+            Valid hour integer (0-23)
+        """
+        try:
+            hour = int(float(str(hour)))
+            if not 0 <= hour <= 23:
+                if self.debug_mode:
+                    logger.warning(f"Invalid hour: {hour}. Defaulting to 15")
+                return 15
+            return hour
+        except (ValueError, TypeError):
+            if self.debug_mode:
+                logger.warning(f"Invalid hour format: {hour}. Defaulting to 15")
+            return 15
+    
+    def validate_conditions(self, outdoor_temp: float, indoor_temp: float, 
+                          outdoor_rh: float, indoor_rh: float) -> None:
+        """
+        Validate temperature and relative humidity inputs.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Section 1.2.
+        
+        Args:
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            outdoor_rh: Outdoor relative humidity in %
+            indoor_rh: Indoor relative humidity in %
+            
+        Raises:
+            ValueError: If inputs are invalid
+        """
+        if not -50 <= outdoor_temp <= 60 or not -50 <= indoor_temp <= 60:
+            raise ValueError("Temperatures must be between -50°C and 60°C")
+        if not 0 <= outdoor_rh <= 100 or not 0 <= indoor_rh <= 100:
+            raise ValueError("Relative humidities must be between 0 and 100%")
+        if outdoor_temp - indoor_temp < 1:
+            raise ValueError("Outdoor temperature must be at least 1°C above indoor temperature for cooling")
+    
+    def calculate_hourly_cooling_loads(
+        self,
+        building_components: Dict[str, List[Any]],
+        outdoor_conditions: Dict[str, Any],
+        indoor_conditions: Dict[str, Any],
+        internal_loads: Dict[str, Any],
+        building_volume: float,
+        p_atm: float = 101325
+    ) -> Dict[str, Any]:
+        """
+        Calculate hourly cooling loads for all components.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.5.
+        
+        Args:
+            building_components: Dictionary of building components
+            outdoor_conditions: Outdoor weather conditions (temperature, relative_humidity, latitude, month)
+            indoor_conditions: Indoor design conditions (temperature, relative_humidity)
+            internal_loads: Internal heat gains (people, lights, equipment, infiltration, ventilation)
+            building_volume: Building volume in cubic meters
+            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            
+        Returns:
+            Dictionary containing hourly cooling loads
+        """
+        hourly_loads = {
+            'walls': {h: 0.0 for h in range(1, 25)},
+            'roofs': {h: 0.0 for h in range(1, 25)},
+            'windows_conduction': {h: 0.0 for h in range(1, 25)},
+            'windows_solar': {h: 0.0 for h in range(1, 25)},
+            'doors': {h: 0.0 for h in range(1, 25)},
+            'people_sensible': {h: 0.0 for h in range(1, 25)},
+            'people_latent': {h: 0.0 for h in range(1, 25)},
+            'lights': {h: 0.0 for h in range(1, 25)},
+            'equipment_sensible': {h: 0.0 for h in range(1, 25)},
+            'equipment_latent': {h: 0.0 for h in range(1, 25)},
+            'infiltration_sensible': {h: 0.0 for h in range(1, 25)},
+            'infiltration_latent': {h: 0.0 for h in range(1, 25)},
+            'ventilation_sensible': {h: 0.0 for h in range(1, 25)},
+            'ventilation_latent': {h: 0.0 for h in range(1, 25)}
+        }
+        
+        try:
+            # Validate conditions
+            self.validate_conditions(
+                outdoor_conditions['temperature'],
+                indoor_conditions['temperature'],
+                outdoor_conditions.get('relative_humidity', 50.0),
+                indoor_conditions.get('relative_humidity', 50.0)
+            )
+            
+            latitude = self.validate_latitude(outdoor_conditions.get('latitude', '32N'))
+            month = self.validate_month(outdoor_conditions.get('month', 'JUL'))
+            if self.debug_mode:
+                logger.debug(f"calculate_hourly_cooling_loads: latitude={latitude}, month={month}, outdoor_conditions={outdoor_conditions}")
+
+            # Calculate loads for walls
+            for wall in building_components.get('walls', []):
+                for hour in range(24):
+                    load = self.calculate_wall_cooling_load(
+                        wall=wall,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        month=month,
+                        hour=hour,
+                        latitude=latitude
+                    )
+                    hourly_loads['walls'][hour + 1] += load
+            
+            # Calculate loads for roofs
+            for roof in building_components.get('roofs', []):
+                for hour in range(24):
+                    load = self.calculate_roof_cooling_load(
+                        roof=roof,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        month=month,
+                        hour=hour,
+                        latitude=latitude
+                    )
+                    hourly_loads['roofs'][hour + 1] += load
+            
+            # Calculate loads for windows
+            for window in building_components.get('windows', []):
+                for hour in range(24):
+                    load_dict = self.calculate_window_cooling_load(
+                        window=window,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        month=month,
+                        hour=hour,
+                        latitude=latitude,
+                        shading_coefficient=window.shading_coefficient
+                    )
+                    hourly_loads['windows_conduction'][hour + 1] += load_dict['conduction']
+                    hourly_loads['windows_solar'][hour + 1] += load_dict['solar']
+            
+            # Calculate loads for doors
+            for door in building_components.get('doors', []):
+                for hour in range(24):
+                    load = self.calculate_door_cooling_load(
+                        door=door,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature']
+                    )
+                    hourly_loads['doors'][hour + 1] += load
+            
+            # Calculate internal loads
+            for hour in range(24):
+                # People loads
+                people_load = self.calculate_people_cooling_load(
+                    num_people=internal_loads['people']['number'],
+                    activity_level=internal_loads['people']['activity_level'],
+                    hour=hour
+                )
+                hourly_loads['people_sensible'][hour + 1] += people_load['sensible']
+                hourly_loads['people_latent'][hour + 1] += people_load['latent']
+                
+                # Lighting loads
+                lights_load = self.calculate_lights_cooling_load(
+                    power=internal_loads['lights']['power'],
+                    use_factor=internal_loads['lights']['use_factor'],
+                    special_allowance=internal_loads['lights']['special_allowance'],
+                    hour=hour
+                )
+                hourly_loads['lights'][hour + 1] += lights_load
+                
+                # Equipment loads
+                equipment_load = self.calculate_equipment_cooling_load(
+                    power=internal_loads['equipment']['power'],
+                    use_factor=internal_loads['equipment']['use_factor'],
+                    radiation_factor=internal_loads['equipment']['radiation_factor'],
+                    hour=hour
+                )
+                hourly_loads['equipment_sensible'][hour + 1] += equipment_load['sensible']
+                hourly_loads['equipment_latent'][hour + 1] += equipment_load['latent']
+                
+                # Infiltration loads
+                infiltration_load = self.calculate_infiltration_cooling_load(
+                    flow_rate=internal_loads['infiltration']['flow_rate'],
+                    building_volume=building_volume,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    outdoor_rh=outdoor_conditions['relative_humidity'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    indoor_rh=indoor_conditions['relative_humidity'],
+                    p_atm=p_atm
+                )
+                hourly_loads['infiltration_sensible'][hour + 1] += infiltration_load['sensible']
+                hourly_loads['infiltration_latent'][hour + 1] += infiltration_load['latent']
+                
+                # Ventilation loads
+                ventilation_load = self.calculate_ventilation_cooling_load(
+                    flow_rate=internal_loads['ventilation']['flow_rate'],
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    outdoor_rh=outdoor_conditions['relative_humidity'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    indoor_rh=indoor_conditions['relative_humidity'],
+                    p_atm=p_atm
+                )
+                hourly_loads['ventilation_sensible'][hour + 1] += ventilation_load['sensible']
+                hourly_loads['ventilation_latent'][hour + 1] += ventilation_load['latent']
+        
+            return hourly_loads
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_hourly_cooling_loads: {str(e)}")
+            raise Exception(f"Error in calculate_hourly_cooling_loads: {str(e)}")
+    
+    def calculate_design_cooling_load(self, hourly_loads: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Calculate design cooling load based on peak hourly loads.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.5.
+        
+        Args:
+            hourly_loads: Dictionary of hourly cooling loads
+            
+        Returns:
+            Dictionary containing design cooling loads
+        """
+        try:
+            design_loads = {}
+            total_loads = []
+            
+            for hour in range(1, 25):
+                total_load = sum([
+                    hourly_loads['walls'][hour],
+                    hourly_loads['roofs'][hour],
+                    hourly_loads['windows_conduction'][hour],
+                    hourly_loads['windows_solar'][hour],
+                    hourly_loads['doors'][hour],
+                    hourly_loads['people_sensible'][hour],
+                    hourly_loads['people_latent'][hour],
+                    hourly_loads['lights'][hour],
+                    hourly_loads['equipment_sensible'][hour],
+                    hourly_loads['equipment_latent'][hour],
+                    hourly_loads['infiltration_sensible'][hour],
+                    hourly_loads['infiltration_latent'][hour],
+                    hourly_loads['ventilation_sensible'][hour],
+                    hourly_loads['ventilation_latent'][hour]
+                ])
+                total_loads.append(total_load)
+            
+            design_hour = range(1, 25)[np.argmax(total_loads)]
+            
+            design_loads = {
+                'design_hour': design_hour,
+                'walls': hourly_loads['walls'][design_hour],
+                'roofs': hourly_loads['roofs'][design_hour],
+                'windows_conduction': hourly_loads['windows_conduction'][design_hour],
+                'windows_solar': hourly_loads['windows_solar'][design_hour],
+                'doors': hourly_loads['doors'][design_hour],
+                'people_sensible': hourly_loads['people_sensible'][design_hour],
+                'people_latent': hourly_loads['people_latent'][design_hour],
+                'lights': hourly_loads['lights'][design_hour],
+                'equipment_sensible': hourly_loads['equipment_sensible'][design_hour],
+                'equipment_latent': hourly_loads['equipment_latent'][design_hour],
+                'infiltration_sensible': hourly_loads['infiltration_sensible'][design_hour],
+                'infiltration_latent': hourly_loads['infiltration_latent'][design_hour],
+                'ventilation_sensible': hourly_loads['ventilation_sensible'][design_hour],
+                'ventilation_latent': hourly_loads['ventilation_latent'][design_hour]
+            }
+            
+            return design_loads
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_design_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_design_cooling_load: {str(e)}")
+    
+    def calculate_cooling_load_summary(self, design_loads: Dict[str, Any]) -> Dict[str, float]:
+        """
+        Calculate summary of cooling loads.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.5.
+        
+        Args:
+            design_loads: Dictionary of design cooling loads
+            
+        Returns:
+            Dictionary containing cooling load summary
+        """
+        try:
+            total_sensible = (
+                design_loads['walls'] +
+                design_loads['roofs'] +
+                design_loads['windows_conduction'] +
+                design_loads['windows_solar'] +
+                design_loads['doors'] +
+                design_loads['people_sensible'] +
+                design_loads['lights'] +
+                design_loads['equipment_sensible'] +
+                design_loads['infiltration_sensible'] +
+                design_loads['ventilation_sensible']
+            )
+            
+            total_latent = (
+                design_loads['people_latent'] +
+                design_loads['equipment_latent'] +
+                design_loads['infiltration_latent'] +
+                design_loads['ventilation_latent']
+            )
+            
+            total = total_sensible + total_latent
+            
+            return {
+                'total_sensible': total_sensible,
+                'total_latent': total_latent,
+                'total': total
+            }
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_cooling_load_summary: {str(e)}")
+            raise Exception(f"Error in calculate_cooling_load_summary: {str(e)}")
+    
+    def calculate_wall_cooling_load(
+        self,
+        wall: Wall,
+        outdoor_temp: float,
+        indoor_temp: float,
+        month: str,
+        hour: int,
+        latitude: str
+    ) -> float:
+        """
+        Calculate cooling load for a wall using CLTD method.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.10.
+        
+        Args:
+            wall: Wall component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
+            month: Design month
+            hour: Hour of the day
+            latitude: Latitude (e.g., '24N')
+            
+        Returns:
+            Cooling load in Watts
+        """
+        try:
+            latitude = self.validate_latitude(latitude)
+            month = self.validate_month(month)
+            hour = self.validate_hour(hour)
+            if self.debug_mode:
+                logger.debug(f"calculate_wall_cooling_load: latitude={latitude}, month={month}, hour={hour}, wall_group={wall.wall_group}, orientation={wall.orientation.value}")
+
+            wall_group = str(wall.wall_group).upper()
+            if wall_group not in self.valid_wall_groups:
+                numeric_map = {'1': 'A', '2': 'B', '3': 'C', '4': 'D'}
+                if wall_group in numeric_map:
+                    wall_group = numeric_map[wall_group]
+                    if self.debug_mode:
+                        logger.info(f"Mapped wall_group {wall.wall_group} to {wall_group}")
+                else:
+                    if self.debug_mode:
+                        logger.warning(f"Invalid wall group: {wall_group}. Defaulting to 'A'")
+                    wall_group = 'A'
+
+            try:
+                cltd = self.ashrae_tables.calculate_corrected_cltd_wall(
+                    wall_group=wall_group,
+                    orientation=wall.orientation.value,
+                    hour=hour,
+                    color='Dark',
+                    month=month,
+                    latitude=latitude,
+                    indoor_temp=indoor_temp,
+                    outdoor_temp=outdoor_temp
+                )
+            except Exception as e:
+                if self.debug_mode:
+                    logger.error(f"calculate_corrected_cltd_wall failed for wall_group={wall_group}: {str(e)}")
+                    logger.warning("Using default CLTD=8.0°C")
+                cltd = 8.0
+            
+            load = wall.u_value * wall.area * cltd
+            if self.debug_mode:
+                logger.debug(f"Wall load: u_value={wall.u_value}, area={wall.area}, cltd={cltd}, load={load}")
+            return max(load, 0.0)
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_wall_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_wall_cooling_load: {str(e)}")
+    
+    def calculate_roof_cooling_load(
+        self,
+        roof: Roof,
+        outdoor_temp: float,
+        indoor_temp: float,
+        month: str,
+        hour: int,
+        latitude: str
+    ) -> float:
+        """
+        Calculate cooling load for a roof using CLTD method.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.10.
+        
+        Args:
+            roof: Roof component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
+            month: Design month
+            hour: Hour of the day
+            latitude: Latitude (e.g., '24N')
+            
+        Returns:
+            Cooling load in Watts
+        """
+        try:
+            latitude = self.validate_latitude(latitude)
+            month = self.validate_month(month)
+            hour = self.validate_hour(hour)
+            if self.debug_mode:
+                logger.debug(f"calculate_roof_cooling_load: latitude={latitude}, month={month}, hour={hour}, roof_group={roof.roof_group}")
+
+            roof_group = str(roof.roof_group).upper()
+            if roof_group not in self.valid_roof_groups:
+                numeric_map = {'1': 'A', '2': 'B', '3': 'C', '4': 'D', '5': 'E', '6': 'F', '7': 'G', '8': 'G'}
+                if roof_group in numeric_map:
+                    roof_group = numeric_map[roof_group]
+                    if self.debug_mode:
+                        logger.info(f"Mapped roof_group {roof.roof_group} to {roof_group}")
+                else:
+                    if self.debug_mode:
+                        logger.warning(f"Invalid roof group: {roof_group}. Defaulting to 'A'")
+                    roof_group = 'A'
+            
+            try:
+                cltd = self.ashrae_tables.calculate_corrected_cltd_roof(
+                    roof_group=roof_group,
+                    hour=hour,
+                    color='Dark',
+                    month=month,
+                    latitude=latitude,
+                    indoor_temp=indoor_temp,
+                    outdoor_temp=outdoor_temp
+                )
+            except Exception as e:
+                if self.debug_mode:
+                    logger.error(f"calculate_corrected_cltd_roof failed for roof_group={roof_group}: {str(e)}")
+                    logger.warning("Using default CLTD=8.0°C")
+                cltd = 8.0
+            
+            load = roof.u_value * roof.area * cltd
+            if self.debug_mode:
+                logger.debug(f"Roof load: u_value={roof.u_value}, area={roof.area}, cltd={cltd}, load={load}")
+            return max(load, 0.0)
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_roof_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_roof_cooling_load: {str(e)}")
+    
+    def calculate_window_cooling_load(
+        self,
+        window: Window,
+        outdoor_temp: float,
+        indoor_temp: float,
+        month: str,
+        hour: int,
+        latitude: str,
+        shading_coefficient: float
+    ) -> Dict[str, float]:
+        """
+        Calculate cooling load for a window (conduction and solar).
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equations 18.12-18.13.
+        
+        Args:
+            window: Window component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
+            month: Design month
+            hour: Hour of the day
+            latitude: Latitude (e.g., '24N')
+            shading_coefficient: Shading coefficient
+            
+        Returns:
+            Dictionary with conduction, solar, and total loads in Watts
+        """
+        try:
+            latitude = self.validate_latitude(latitude)
+            month = self.validate_month(month)
+            hour = self.validate_hour(hour)
+            if self.debug_mode:
+                logger.debug(f"calculate_window_cooling_load: latitude={latitude}, month={month}, hour={hour}, orientation={window.orientation.value}")
+
+            # Conduction load
+            cltd = outdoor_temp - indoor_temp
+            conduction_load = window.u_value * window.area * cltd
+
+            # Solar load
+            try:
+                scl = self.ashrae_tables.get_scl(
+                    latitude=latitude,
+                    month=month,
+                    orientation=window.orientation.value,
+                    hour=hour
+                )
+            except Exception as e:
+                if self.debug_mode:
+                    logger.error(f"get_scl failed for latitude={latitude}, month={month}, orientation={window.orientation.value}: {str(e)}")
+                    logger.warning("Using default SCL=100 W/m²")
+                scl = 100.0
+
+            solar_load = window.area * window.shgc * shading_coefficient * scl
+
+            total_load = conduction_load + solar_load
+            if self.debug_mode:
+                logger.debug(f"Window load: conduction={conduction_load}, solar={solar_load}, total={total_load}")
+
+            return {
+                'conduction': max(conduction_load, 0.0),
+                'solar': max(solar_load, 0.0),
+                'total': max(total_load, 0.0)
+            }
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_window_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_window_cooling_load: {str(e)}")
+    
+    def calculate_door_cooling_load(
+        self,
+        door: Door,
+        outdoor_temp: float,
+        indoor_temp: float
+    ) -> float:
+        """
+        Calculate cooling load for a door.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
+        
+        Args:
+            door: Door component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
+            
+        Returns:
+            Cooling load in Watts
+        """
+        try:
+            if self.debug_mode:
+                logger.debug(f"calculate_door_cooling_load: u_value={door.u_value}, area={door.area}")
+
+            cltd = outdoor_temp - indoor_temp
+            load = door.u_value * door.area * cltd
+            if self.debug_mode:
+                logger.debug(f"Door load: cltd={cltd}, load={load}")
+            return max(load, 0.0)
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_door_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_door_cooling_load: {str(e)}")
+    
+    def calculate_people_cooling_load(
+        self,
+        num_people: int,
+        activity_level: str,
+        hour: int
+    ) -> Dict[str, float]:
+        """
+        Calculate cooling load from people.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Table 18.4.
+        
+        Args:
+            num_people: Number of people
+            activity_level: Activity level ('Seated/Resting', 'Light Work', etc.)
+            hour: Hour of the day
+            
+        Returns:
+            Dictionary with sensible and latent loads in Watts
+        """
+        try:
+            hour = self.validate_hour(hour)
+            if self.debug_mode:
+                logger.debug(f"calculate_people_cooling_load: num_people={num_people}, activity_level={activity_level}, hour={hour}")
+
+            heat_gains = {
+                'Seated/Resting': {'sensible': 70, 'latent': 45},
+                'Light Work': {'sensible': 85, 'latent': 65},
+                'Moderate Work': {'sensible': 100, 'latent': 100},
+                'Heavy Work': {'sensible': 145, 'latent': 170}
+            }
+
+            gains = heat_gains.get(activity_level, heat_gains['Seated/Resting'])
+            if activity_level not in heat_gains:
+                if self.debug_mode:
+                    logger.warning(f"Invalid activity_level: {activity_level}. Defaulting to 'Seated/Resting'")
+
+            try:
+                clf = self.ashrae_tables.get_clf_people(
+                    zone_type='A',
+                    hours_occupied='6h',
+                    hour=hour
+                )
+            except Exception as e:
+                if self.debug_mode:
+                    logger.error(f"get_clf_people failed: {str(e)}")
+                    logger.warning("Using default CLF=0.5")
+                clf = 0.5
+
+            sensible_load = num_people * gains['sensible'] * clf
+            latent_load = num_people * gains['latent']
+            if self.debug_mode:
+                logger.debug(f"People load: sensible={sensible_load}, latent={latent_load}, clf={clf}")
+
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0)
+            }
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_people_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_people_cooling_load: {str(e)}")
+    
+    def calculate_lights_cooling_load(
+        self,
+        power: float,
+        use_factor: float,
+        special_allowance: float,
+        hour: int
+    ) -> float:
+        """
+        Calculate cooling load from lighting.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Table 18.5.
+        
+        Args:
+            power: Total lighting power (W)
+            use_factor: Usage factor (0.0 to 1.0)
+            special_allowance: Special allowance factor
+            hour: Hour of the day
+            
+        Returns:
+            Cooling load in Watts
+        """
+        try:
+            hour = self.validate_hour(hour)
+            if self.debug_mode:
+                logger.debug(f"calculate_lights_cooling_load: power={power}, use_factor={use_factor}, special_allowance={special_allowance}, hour={hour}")
+
+            try:
+                clf = self.ashrae_tables.get_clf_lights(
+                    zone_type='A',
+                    hours_occupied='6h',
+                    hour=hour
+                )
+            except Exception as e:
+                if self.debug_mode:
+                    logger.error(f"get_clf_lights failed: {str(e)}")
+                    logger.warning("Using default CLF=0.8")
+                clf = 0.8
+
+            load = power * use_factor * special_allowance * clf
+            if self.debug_mode:
+                logger.debug(f"Lights load: clf={clf}, load={load}")
+            return max(load, 0.0)
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_lights_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_lights_cooling_load: {str(e)}")
+    
+    def calculate_equipment_cooling_load(
+        self,
+        power: float,
+        use_factor: float,
+        radiation_factor: float,
+        hour: int
+    ) -> Dict[str, float]:
+        """
+        Calculate cooling load from equipment.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Table 18.6.
+        
+        Args:
+            power: Total equipment power (W)
+            use_factor: Usage factor (0.0 to 1.0)
+            radiation_factor: Radiation factor (0.0 to 1.0)
+            hour: Hour of the day
+            
+        Returns:
+            Dictionary with sensible and latent loads in Watts
+        """
+        try:
+            hour = self.validate_hour(hour)
+            if self.debug_mode:
+                logger.debug(f"calculate_equipment_cooling_load: power={power}, use_factor={use_factor}, radiation_factor={radiation_factor}, hour={hour}")
+
+            try:
+                clf = self.ashrae_tables.get_clf_equipment(
+                    zone_type='A',
+                    hours_operated='6h',
+                    hour=hour
+                )
+            except Exception as e:
+                if self.debug_mode:
+                    logger.error(f"get_clf_equipment failed: {str(e)}")
+                    logger.warning("Using default CLF=0.7")
+                clf = 0.7
+
+            sensible_load = power * use_factor * radiation_factor * clf
+            latent_load = power * use_factor * (1 - radiation_factor)
+            if self.debug_mode:
+                logger.debug(f"Equipment load: sensible={sensible_load}, latent={latent_load}, clf={clf}")
+
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0)
+            }
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_equipment_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_equipment_cooling_load: {str(e)}")
+    
+    def calculate_infiltration_cooling_load(
+        self,
+        flow_rate: float,
+        building_volume: float,
+        outdoor_temp: float,
+        outdoor_rh: float,
+        indoor_temp: float,
+        indoor_rh: float,
+        p_atm: float = 101325
+    ) -> Dict[str, float]:
+        """
+        Calculate cooling load from infiltration.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equations 18.5-18.6.
+        
+        Args:
+            flow_rate: Infiltration flow rate (m³/s)
+            building_volume: Building volume (m³)
+            outdoor_temp: Outdoor temperature (°C)
+            outdoor_rh: Outdoor relative humidity (%)
+            indoor_temp: Indoor temperature (°C)
+            indoor_rh: Indoor relative humidity (%)
+            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            
+        Returns:
+            Dictionary with sensible and latent loads in Watts
+        """
+        try:
+            if self.debug_mode:
+                logger.debug(f"calculate_infiltration_cooling_load: flow_rate={flow_rate}, building_volume={building_volume}, outdoor_temp={outdoor_temp}, indoor_temp={indoor_temp}")
+
+            self.validate_conditions(outdoor_temp, indoor_temp, outdoor_rh, indoor_rh)
+            if flow_rate < 0 or building_volume <= 0:
+                raise ValueError("Flow rate cannot be negative and building volume must be positive")
+
+            # Calculate air changes per hour (ACH)
+            ach = (flow_rate * 3600) / building_volume if building_volume > 0 else 0.5
+            if ach < 0:
+                if self.debug_mode:
+                    logger.warning(f"Invalid ACH: {ach}. Defaulting to 0.5")
+                ach = 0.5
+
+            # Calculate humidity ratio difference
+            outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh, p_atm)
+            indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh, p_atm)
+            delta_w = max(0, outdoor_w - indoor_w)
+
+            # Calculate sensible and latent loads using heat_transfer methods
+            sensible_load = self.heat_transfer.infiltration_heat_transfer(
+                flow_rate, outdoor_temp - indoor_temp, indoor_temp, indoor_rh, p_atm
+            )
+            latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+                flow_rate, delta_w, indoor_temp, indoor_rh, p_atm
+            )
+
+            if self.debug_mode:
+                logger.debug(f"Infiltration load: sensible={sensible_load}, latent={latent_load}, ach={ach}, outdoor_w={outdoor_w}, indoor_w={indoor_w}")
+
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0)
+            }
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_infiltration_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_infiltration_cooling_load: {str(e)}")
+    
+    def calculate_ventilation_cooling_load(
+        self,
+        flow_rate: float,
+        outdoor_temp: float,
+        outdoor_rh: float,
+        indoor_temp: float,
+        indoor_rh: float,
+        p_atm: float = 101325
+    ) -> Dict[str, float]:
+        """
+        Calculate cooling load from ventilation.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equations 18.5-18.6.
+        
+        Args:
+            flow_rate: Ventilation flow rate (m³/s)
+            outdoor_temp: Outdoor temperature (°C)
+            outdoor_rh: Outdoor relative humidity (%)
+            indoor_temp: Indoor temperature (°C)
+            indoor_rh: Indoor relative humidity (%)
+            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            
+        Returns:
+            Dictionary with sensible and latent loads in Watts
+        """
+        try:
+            if self.debug_mode:
+                logger.debug(f"calculate_ventilation_cooling_load: flow_rate={flow_rate}, outdoor_temp={outdoor_temp}, indoor_temp={indoor_temp}")
+
+            self.validate_conditions(outdoor_temp, indoor_temp, outdoor_rh, indoor_rh)
+            if flow_rate < 0:
+                raise ValueError("Flow rate cannot be negative")
+
+            # Calculate humidity ratio difference
+            outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh, p_atm)
+            indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh, p_atm)
+            delta_w = max(0, outdoor_w - indoor_w)
+
+            # Calculate sensible and latent loads using heat_transfer methods
+            sensible_load = self.heat_transfer.infiltration_heat_transfer(
+                flow_rate, outdoor_temp - indoor_temp, indoor_temp, indoor_rh, p_atm
+            )
+            latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+                flow_rate, delta_w, indoor_temp, indoor_rh, p_atm
+            )
+
+            if self.debug_mode:
+                logger.debug(f"Ventilation load: sensible={sensible_load}, latent={latent_load}, outdoor_w={outdoor_w}, indoor_w={indoor_w}")
+
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0)
+            }
+        
+        except Exception as e:
+            if self.debug_mode:
+                logger.error(f"Error in calculate_ventilation_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_ventilation_cooling_load: {str(e)}")
+
+# Example usage
+if __name__ == "__main__":
+    calculator = CoolingLoadCalculator(debug_mode=True)
+    
+    # Example inputs
+    components = {
+        'walls': [Wall(id="w1", name="North Wall", area=20.0, u_value=0.5, orientation=Orientation.NORTH, wall_group='A')],
+        'roofs': [Roof(id="r1", name="Main Roof", area=100.0, u_value=0.3, orientation=Orientation.HORIZONTAL, roof_group='A')],
+        'windows': [Window(id="win1", name="South Window", area=10.0, u_value=2.8, orientation=Orientation.SOUTH, shgc=0.7, shading_coefficient=0.8)],
+        'doors': [Door(id="d1", name="Main Door", area=2.0, u_value=2.0, orientation=Orientation.NORTH)]
+    }
+    outdoor_conditions = {
+        'temperature': 35.0,
+        'relative_humidity': 60.0,
+        'latitude': '32N',
+        'month': 'JUL'
+    }
+    indoor_conditions = {
+        'temperature': 24.0,
+        'relative_humidity': 50.0
+    }
+    internal_loads = {
+        'people': {'number': 10, 'activity_level': 'Seated/Resting'},
+        'lights': {'power': 1000.0, 'use_factor': 0.8, 'special_allowance': 1.0},
+        'equipment': {'power': 500.0, 'use_factor': 0.7, 'radiation_factor': 0.5},
+        'infiltration': {'flow_rate': 0.05},
+        'ventilation': {'flow_rate': 0.1}
+    }
+    building_volume = 300.0
+    
+    # Calculate hourly loads
+    hourly_loads = calculator.calculate_hourly_cooling_loads(
+        components, outdoor_conditions, indoor_conditions, internal_loads, building_volume
+    )
+    design_loads = calculator.calculate_design_cooling_load(hourly_loads)
+    summary = calculator.calculate_cooling_load_summary(design_loads)
+    
+    logger.info(f"Design Cooling Load Summary: {summary}")

utils/heat_transfer.py

@@ -0,0 +1,327 @@
+"""
+Heat transfer calculation module for HVAC Load Calculator.
+This module implements heat transfer calculations for conduction, infiltration, and solar effects.
+Reference: ASHRAE Handbook—Fundamentals (2017), Chapters 16 and 18.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import math
+import numpy as np
+import logging
+from dataclasses import dataclass
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import utility modules
+from utils.psychrometrics import Psychrometrics
+
+# Import data modules
+from data.building_components import Orientation
+
+
+class SolarCalculations:
+    """Class for solar geometry and radiation calculations."""
+    
+    def validate_angle(self, angle: float, name: str, min_val: float, max_val: float) -> None:
+        """
+        Validate angle inputs for solar calculations.
+        
+        Args:
+            angle: Angle in degrees
+            name: Name of the angle
+            min_val: Minimum allowed value
+            max_val: Maximum allowed value
+            
+        Raises:
+            ValueError: If angle is out of range
+        """
+        if not min_val <= angle <= max_val:
+            raise ValueError(f"{name} {angle}° must be between {min_val}° and {max_val}°")
+
+    def solar_declination(self, day_of_year: int) -> float:
+        """
+        Calculate solar declination angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.6.
+        
+        Args:
+            day_of_year: Day of the year (1-365)
+            
+        Returns:
+            Declination angle in degrees
+        """
+        if not 1 <= day_of_year <= 365:
+            raise ValueError("Day of year must be between 1 and 365")
+        
+        declination = 23.45 * math.sin(math.radians(360 * (284 + day_of_year) / 365))
+        self.validate_angle(declination, "Declination angle", -23.45, 23.45)
+        return declination
+
+    def solar_hour_angle(self, hour: float) -> float:
+        """
+        Calculate solar hour angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.7.
+        
+        Args:
+            hour: Hour of the day (0-23)
+            
+        Returns:
+            Hour angle in degrees
+        """
+        if not 0 <= hour <= 24:
+            raise ValueError("Hour must be between 0 and 24")
+        
+        hour_angle = (hour - 12) * 15
+        self.validate_angle(hour_angle, "Hour angle", -180, 180)
+        return hour_angle
+
+    def solar_altitude(self, latitude: float, declination: float, hour_angle: float) -> float:
+        """
+        Calculate solar altitude angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.8.
+        
+        Args:
+            latitude: Latitude in degrees
+            declination: Declination angle in degrees
+            hour_angle: Hour angle in degrees
+            
+        Returns:
+            Altitude angle in degrees
+        """
+        self.validate_angle(latitude, "Latitude", -90, 90)
+        self.validate_angle(declination, "Declination", -23.45, 23.45)
+        self.validate_angle(hour_angle, "Hour angle", -180, 180)
+        
+        sin_beta = (math.sin(math.radians(latitude)) * math.sin(math.radians(declination)) +
+                    math.cos(math.radians(latitude)) * math.cos(math.radians(declination)) *
+                    math.cos(math.radians(hour_angle)))
+        beta = math.degrees(math.asin(sin_beta))
+        self.validate_angle(beta, "Altitude angle", 0, 90)
+        return beta
+
+    def solar_azimuth(self, latitude: float, declination: float, hour_angle: float, altitude: float) -> float:
+        """
+        Calculate solar azimuth angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.9.
+        
+        Args:
+            latitude: Latitude in degrees
+            declination: Declination angle in degrees
+            hour_angle: Hour angle in degrees
+            altitude: Altitude angle in degrees
+            
+        Returns:
+            Azimuth angle in degrees
+        """
+        self.validate_angle(latitude, "Latitude", -90, 90)
+        self.validate_angle(declination, "Declination", -23.45, 23.45)
+        self.validate_angle(hour_angle, "Hour angle", -180, 180)
+        self.validate_angle(altitude, "Altitude", 0, 90)
+        
+        sin_phi = (math.cos(math.radians(declination)) * math.sin(math.radians(hour_angle)) /
+                   math.cos(math.radians(altitude)))
+        phi = math.degrees(math.asin(sin_phi))
+        
+        if hour_angle > 0:
+            phi = 180 - phi
+        elif hour_angle < 0:
+            phi = -180 - phi
+        
+        self.validate_angle(phi, "Azimuth angle", -180, 180)
+        return phi
+
+
+class HeatTransferCalculations:
+    """Class for heat transfer calculations."""
+    
+    def __init__(self):
+        """
+        Initialize heat transfer calculations with psychrometrics and solar calculations.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16.
+        """
+        self.psychrometrics = Psychrometrics()
+        self.solar = SolarCalculations()
+        self.debug_mode = False
+    
+    def conduction_heat_transfer(self, u_value: float, area: float, delta_t: float) -> float:
+        """
+        Calculate heat transfer via conduction.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
+        
+        Args:
+            u_value: U-value of the component in W/(m²·K)
+            area: Area of the component in m²
+            delta_t: Temperature difference in °C
+            
+        Returns:
+            Heat transfer rate in W
+        """
+        if u_value < 0 or area < 0:
+            raise ValueError("U-value and area must be non-negative")
+        
+        q = u_value * area * delta_t
+        return q
+
+    def infiltration_heat_transfer(self, flow_rate: float, delta_t: float, 
+                                 t_db: float, rh: float, p_atm: float = 101325) -> float:
+        """
+        Calculate sensible heat transfer due to infiltration or ventilation.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.5.
+        
+        Args:
+            flow_rate: Air flow rate in m³/s
+            delta_t: Temperature difference in °C
+            t_db: Dry-bulb temperature for air properties in °C
+            rh: Relative humidity in % (0-100)
+            p_atm: Atmospheric pressure in Pa
+            
+        Returns:
+            Sensible heat transfer rate in W
+        """
+        if flow_rate < 0:
+            raise ValueError("Flow rate cannot be negative")
+        
+        # Calculate air density and specific heat using psychrometrics
+        w = self.psychrometrics.humidity_ratio(t_db, rh, p_atm)
+        rho = self.psychrometrics.density(t_db, w, p_atm)
+        c_p = 1006 + 1860 * w  # Specific heat of moist air in J/(kg·K)
+        
+        q = flow_rate * rho * c_p * delta_t
+        return q
+
+    def infiltration_latent_heat_transfer(self, flow_rate: float, delta_w: float, 
+                                        t_db: float, rh: float, p_atm: float = 101325) -> float:
+        """
+        Calculate latent heat transfer due to infiltration or ventilation.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.6.
+        
+        Args:
+            flow_rate: Air flow rate in m³/s
+            delta_w: Humidity ratio difference in kg/kg
+            t_db: Dry-bulb temperature for air properties in °C
+            rh: Relative humidity in % (0-100)
+            p_atm: Atmospheric pressure in Pa
+            
+        Returns:
+            Latent heat transfer rate in W
+        """
+        if flow_rate < 0 or delta_w < 0:
+            raise ValueError("Flow rate and humidity ratio difference cannot be negative")
+        
+        # Calculate air density and latent heat
+        w = self.psychrometrics.humidity_ratio(t_db, rh, p_atm)
+        rho = self.psychrometrics.density(t_db, w, p_atm)
+        h_fg = 2501000 + 1840 * t_db  # Latent heat of vaporization in J/kg
+        
+        q = flow_rate * rho * h_fg * delta_w
+        return q
+
+    def wind_pressure_difference(self, wind_speed: float) -> float:
+        """
+        Calculate pressure difference due to wind.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Equation 16.3.
+        
+        Args:
+            wind_speed: Wind speed in m/s
+            
+        Returns:
+            Pressure difference in Pa
+        """
+        if wind_speed < 0:
+            raise ValueError("Wind speed cannot be negative")
+        
+        c_p = 0.6  # Wind pressure coefficient
+        rho_air = 1.2  # Air density at standard conditions in kg/m³
+        delta_p = 0.5 * c_p * rho_air * wind_speed**2
+        return delta_p
+
+    def stack_pressure_difference(self, height: float, t_inside: float, t_outside: float) -> float:
+        """
+        Calculate pressure difference due to stack effect.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Equation 16.4.
+        
+        Args:
+            height: Height of the building in m
+            t_inside: Inside temperature in K
+            t_outside: Outside temperature in K
+            
+        Returns:
+            Pressure difference in Pa
+        """
+        if height < 0 or t_inside <= 0 or t_outside <= 0:
+            raise ValueError("Height and temperatures must be positive")
+        
+        g = 9.81  # Gravitational acceleration in m/s²
+        rho_air = 1.2  # Air density at standard conditions in kg/m³
+        delta_p = rho_air * g * height * (1 / t_outside - 1 / t_inside)
+        return delta_p
+
+    def combined_pressure_difference(self, wind_pd: float, stack_pd: float) -> float:
+        """
+        Calculate combined pressure difference from wind and stack effects.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Section 16.2.
+        
+        Args:
+            wind_pd: Wind pressure difference in Pa
+            stack_pd: Stack pressure difference in Pa
+            
+        Returns:
+            Combined pressure difference in Pa
+        """
+        delta_p = math.sqrt(wind_pd**2 + stack_pd**2)
+        return delta_p
+
+    def crack_method_infiltration(self, crack_length: float, crack_width: float, delta_p: float) -> float:
+        """
+        Calculate infiltration flow rate using crack method.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Equation 16.5.
+        
+        Args:
+            crack_length: Length of cracks in m
+            crack_width: Width of cracks in m
+            delta_p: Pressure difference across cracks in Pa
+            
+        Returns:
+            Infiltration flow rate in m³/s
+        """
+        if crack_length < 0 or crack_width < 0 or delta_p < 0:
+            raise ValueError("Crack dimensions and pressure difference cannot be negative")
+        
+        c_d = 0.65  # Discharge coefficient
+        area = crack_length * crack_width
+        rho_air = 1.2  # Air density at standard conditions in kg/m³
+        q = c_d * area * math.sqrt(2 * delta_p / rho_air)
+        return q
+
+
+# Example usage
+if __name__ == "__main__":
+    heat_transfer = HeatTransferCalculations()
+    heat_transfer.debug_mode = True
+    
+    # Example conduction calculation
+    u_value = 0.5  # W/(m²·K)
+    area = 20.0  # m²
+    delta_t = 26.0  # °C
+    q_conduction = heat_transfer.conduction_heat_transfer(u_value, area, delta_t)
+    logger.info(f"Conduction heat transfer: {q_conduction:.2f} W")
+    
+    # Example infiltration calculation
+    flow_rate = 0.05  # m³/s
+    delta_t = 26.0  # °C
+    t_db = 21.0  # °C
+    rh = 40.0  # %
+    p_atm = 101325  # Pa
+    q_infiltration = heat_transfer.infiltration_heat_transfer(flow_rate, delta_t, t_db, rh, p_atm)
+    logger.info(f"Infiltration sensible heat transfer: {q_infiltration:.2f} W")
+    
+    # Example solar calculation
+    latitude = 40.0  # degrees
+    day_of_year = 172  # June 21
+    hour = 12.0  # Noon
+    declination = heat_transfer.solar.solar_declination(day_of_year)
+    hour_angle = heat_transfer.solar.solar_hour_angle(hour)
+    altitude = heat_transfer.solar.solar_altitude(latitude, declination, hour_angle)
+    azimuth = heat_transfer.solar.solar_azimuth(latitude, declination, hour_angle, altitude)
+    logger.info(f"Solar altitude: {altitude:.2f}°, Azimuth: {azimuth:.2f}°")

utils/heating_load.py

@@ -0,0 +1,610 @@
+"""
+Heating load calculation module for HVAC Load Calculator.
+Implements ASHRAE steady-state methods with simplified thermal lag for compatibility.
+Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import math
+import numpy as np
+import logging
+from enum import Enum
+from dataclasses import dataclass
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import utility modules
+from utils.psychrometrics import Psychrometrics
+from utils.heat_transfer import HeatTransferCalculations
+
+# Import data modules
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+
+
+class HeatingLoadCalculator:
+    """Class for heating load calculations based on ASHRAE steady-state methods."""
+    
+    def __init__(self, debug_mode: bool = False):
+        """
+        Initialize heating load calculator with psychrometric and heat transfer calculations.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
+        
+        Args:
+            debug_mode: Enable debug logging if True
+        """
+        self.psychrometrics = Psychrometrics()
+        self.heat_transfer = HeatTransferCalculations()
+        self.safety_factor = 1.15  # 15% safety factor for design loads
+        self.debug_mode = debug_mode
+        if debug_mode:
+            logger.setLevel(logging.DEBUG)
+    
+    def validate_inputs(self, components: Dict[str, List[Any]], outdoor_temp: float, indoor_temp: float) -> None:
+        """
+        Validate input parameters for heating load calculations.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
+        
+        Args:
+            components: Dictionary of building components
+            outdoor_temp: Outdoor design temperature in °C
+            indoor_temp: Indoor design temperature in °C
+            
+        Raises:
+            ValueError: If inputs are invalid
+        """
+        if not components:
+            raise ValueError("Building components dictionary cannot be empty")
+        for component_type, comp_list in components.items():
+            if not isinstance(comp_list, list):
+                raise ValueError(f"Components for {component_type} must be a list")
+            for comp in comp_list:
+                if not hasattr(comp, 'area') or comp.area <= 0:
+                    raise ValueError(f"Invalid area for {component_type}: {comp.name}")
+                if not hasattr(comp, 'u_value') or comp.u_value <= 0:
+                    raise ValueError(f"Invalid U-value for {component_type}: {comp.name}")
+        if not -50 <= outdoor_temp <= 60 or not -50 <= indoor_temp <= 60:
+            raise ValueError("Temperatures must be between -50°C and 60°C")
+        if indoor_temp - outdoor_temp < 1:
+            raise ValueError("Indoor temperature must be at least 1°C above outdoor temperature for heating")
+
+    def calculate_wall_heating_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load for a wall, with simplified thermal lag.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
+        
+        Args:
+            wall: Wall component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        delta_t = indoor_temp - outdoor_temp
+        if delta_t <= 1:
+            return 0.0  # Skip calculation for small temperature differences
+        
+        # Use default lag factor (no thermal mass adjustment)
+        lag_factor = 1.0
+        adjusted_delta_t = delta_t * lag_factor
+        
+        load = self.heat_transfer.conduction_heat_transfer(wall.u_value, wall.area, adjusted_delta_t)
+        return max(0, load)
+
+    def calculate_roof_heating_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load for a roof, with simplified thermal lag.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
+        
+        Args:
+            roof: Roof component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        delta_t = indoor_temp - outdoor_temp
+        if delta_t <= 1:
+            return 0.0
+        
+        lag_factor = 1.0
+        adjusted_delta_t = delta_t * lag_factor
+        
+        load = self.heat_transfer.conduction_heat_transfer(roof.u_value, roof.area, adjusted_delta_t)
+        return max(0, load)
+
+    def calculate_floor_heating_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load for a floor, using dynamic F-factor for ground contact.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.3.
+        
+        Args:
+            floor: Floor component
+            ground_temp: Ground temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        delta_t = indoor_temp - ground_temp
+        if delta_t <= 1:
+            return 0.0
+        
+        if floor.is_ground_contact:
+            # Dynamic F-factor based on insulation
+            f_factor = 0.3 if floor.insulated else 0.73  # W/m·K
+            load = f_factor * floor.perimeter_length * delta_t
+        else:
+            load = self.heat_transfer.conduction_heat_transfer(floor.u_value, floor.area, delta_t)
+        
+        if self.debug_mode:
+            logger.debug(f"Floor {floor.name} load: {load:.2f} W, Delta T: {delta_t:.2f}°C")
+        
+        return max(0, load)
+
+    def calculate_window_heating_load(self, window: Window, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load for a window.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
+        
+        Args:
+            window: Window component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        delta_t = indoor_temp - outdoor_temp
+        if delta_t <= 1:
+            return 0.0
+        
+        load = self.heat_transfer.conduction_heat_transfer(window.u_value, window.area, delta_t)
+        return max(0, load)
+
+    def calculate_door_heating_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load for a door.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
+        
+        Args:
+            door: Door component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        delta_t = indoor_temp - outdoor_temp
+        if delta_t <= 1:
+            return 0.0
+        
+        load = self.heat_transfer.conduction_heat_transfer(door.u_value, door.area, delta_t)
+        return max(0, load)
+
+    def calculate_infiltration_heating_load(self, indoor_conditions: Dict[str, float], 
+                                          outdoor_conditions: Dict[str, float], 
+                                          infiltration: Dict[str, float], 
+                                          building_height: float,
+                                          p_atm: float = 101325) -> Tuple[float, float]:
+        """
+        Calculate sensible and latent heating loads due to infiltration.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equations 18.5-18.6.
+        
+        Args:
+            indoor_conditions: Indoor conditions (temperature, relative_humidity)
+            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity, wind_speed)
+            infiltration: Infiltration parameters (flow_rate, crack_length, height)
+            building_height: Building height in m
+            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            
+        Returns:
+            Tuple of sensible and latent loads in W
+        """
+        delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
+        if delta_t <= 1:
+            return 0.0, 0.0
+        
+        # Calculate pressure differences
+        wind_pd = self.heat_transfer.wind_pressure_difference(outdoor_conditions['wind_speed'])
+        stack_pd = self.heat_transfer.stack_pressure_difference(
+            building_height, 
+            indoor_conditions['temperature'] + 273.15, 
+            outdoor_conditions['design_temperature'] + 273.15
+        )
+        total_pd = self.heat_transfer.combined_pressure_difference(wind_pd, stack_pd)
+        
+        # Calculate infiltration flow rate
+        crack_length = infiltration.get('crack_length', 20.0)
+        flow_rate = self.heat_transfer.crack_method_infiltration(crack_length, 0.0002, total_pd)
+        
+        # Calculate humidity ratio difference
+        w_indoor = self.psychrometrics.humidity_ratio(
+            indoor_conditions['temperature'], 
+            indoor_conditions['relative_humidity'],
+            p_atm
+        )
+        w_outdoor = self.psychrometrics.humidity_ratio(
+            outdoor_conditions['design_temperature'], 
+            outdoor_conditions['design_relative_humidity'],
+            p_atm
+        )
+        delta_w = max(0, w_indoor - w_outdoor)
+        
+        # Calculate sensible and latent loads using indoor conditions for air properties
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(
+            flow_rate, delta_t, 
+            indoor_conditions['temperature'], 
+            indoor_conditions['relative_humidity'],
+            p_atm
+        )
+        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+            flow_rate, delta_w, 
+            indoor_conditions['temperature'], 
+            indoor_conditions['relative_humidity'],
+            p_atm
+        )
+        
+        if self.debug_mode:
+            logger.debug(f"Infiltration flow rate: {flow_rate:.6f} m³/s, Sensible load: {sensible_load:.2f} W, Latent load: {latent_load:.2f} W")
+        
+        return max(0, sensible_load), max(0, latent_load)
+
+    def calculate_ventilation_heating_load(self, ventilation: Dict[str, float], 
+                                         indoor_conditions: Dict[str, float], 
+                                         outdoor_conditions: Dict[str, float],
+                                         p_atm: float = 101325) -> Tuple[float, float]:
+        """
+        Calculate sensible and latent heating loads due to ventilation.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equations 18.5-18.6.
+        
+        Args:
+            ventilation: Ventilation parameters (flow_rate)
+            indoor_conditions: Indoor conditions (temperature, relative_humidity)
+            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity)
+            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            
+        Returns:
+            Tuple of sensible and latent loads in W
+        """
+        delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
+        if delta_t <= 1:
+            return 0.0, 0.0
+        
+        flow_rate = ventilation['flow_rate']
+        
+        w_indoor = self.psychrometrics.humidity_ratio(
+            indoor_conditions['temperature'], 
+            indoor_conditions['relative_humidity'],
+            p_atm
+        )
+        w_outdoor = self.psychrometrics.humidity_ratio(
+            outdoor_conditions['design_temperature'], 
+            outdoor_conditions['design_relative_humidity'],
+            p_atm
+        )
+        delta_w = max(0, w_indoor - w_outdoor)
+        
+        # Calculate sensible and latent loads using indoor conditions for air properties
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(
+            flow_rate, delta_t,
+            indoor_conditions['temperature'],
+            indoor_conditions['relative_humidity'],
+            p_atm
+        )
+        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+            flow_rate, delta_w,
+            indoor_conditions['temperature'],
+            indoor_conditions['relative_humidity'],
+            p_atm
+        )
+        
+        if self.debug_mode:
+            logger.debug(f"Ventilation flow rate: {flow_rate:.6f} m³/s, Sensible load: {sensible_load:.2f} W, Latent load: {latent_load:.2f} W")
+        
+        return max(0, sensible_load), max(0, latent_load)
+
+    def calculate_internal_gains(self, internal_loads: Dict[str, Any]) -> float:
+        """
+        Calculate internal heat gains from people, lighting, and equipment.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.4.
+        
+        Args:
+            internal_loads: Internal loads (people, lights, equipment)
+            
+        Returns:
+            Total internal gains in W
+        """
+        total_gains = 0.0
+        
+        # People gains
+        people = internal_loads.get('people', {})
+        if people.get('number', 0) > 0:
+            sensible_gain = people.get('sensible_gain', 70.0)
+            total_gains += people['number'] * sensible_gain
+        
+        # Lighting gains
+        lights = internal_loads.get('lights', {})
+        if lights.get('power', 0) > 0:
+            total_gains += lights['power'] * lights.get('use_factor', 0.8)
+        
+        # Equipment gains
+        equipment = internal_loads.get('equipment', {})
+        if equipment.get('power', 0) > 0:
+            total_gains += equipment['power'] * equipment.get('use_factor', 0.7)
+        
+        return max(0, total_gains)
+
+    def calculate_design_heating_load(self, building_components: Dict[str, List[Any]], 
+                                    outdoor_conditions: Dict[str, float], 
+                                    indoor_conditions: Dict[str, float], 
+                                    internal_loads: Dict[str, Any],
+                                    p_atm: float = 101325) -> Dict[str, float]:
+        """
+        Calculate design heating loads for all components.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
+        
+        Args:
+            building_components: Dictionary of building components
+            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity, ground_temperature, wind_speed)
+            indoor_conditions: Indoor conditions (temperature, relative_humidity)
+            internal_loads: Internal loads (people, lights, equipment, infiltration, ventilation)
+            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            
+        Returns:
+            Dictionary of design loads in W
+        """
+        try:
+            self.validate_inputs(building_components, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        except ValueError as e:
+            raise ValueError(f"Input validation failed: {str(e)}")
+        
+        loads = {
+            'walls': 0.0,
+            'roofs': 0.0,
+            'floors': 0.0,
+            'windows': 0.0,
+            'doors': 0.0,
+            'infiltration_sensible': 0.0,
+            'infiltration_latent': 0.0,
+            'ventilation_sensible': 0.0,
+            'ventilation_latent': 0.0,
+            'internal_gains': 0.0
+        }
+        
+        # Calculate envelope loads
+        for wall in building_components.get('walls', []):
+            loads['walls'] += self.calculate_wall_heating_load(wall, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        for roof in building_components.get('roofs', []):
+            loads['roofs'] += self.calculate_roof_heating_load(roof, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        for floor in building_components.get('floors', []):
+            loads['floors'] += self.calculate_floor_heating_load(floor, outdoor_conditions['ground_temperature'], indoor_conditions['temperature'])
+        
+        for window in building_components.get('windows', []):
+            loads['windows'] += self.calculate_window_heating_load(window, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        for door in building_components.get('doors', []):
+            loads['doors'] += self.calculate_door_heating_load(door, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        # Calculate infiltration and ventilation loads
+        building_height = internal_loads.get('infiltration', {}).get('height', 3.0)
+        infiltration_sensible, infiltration_latent = self.calculate_infiltration_heating_load(
+            indoor_conditions, outdoor_conditions, internal_loads.get('infiltration', {}), building_height, p_atm
+        )
+        loads['infiltration_sensible'] = infiltration_sensible
+        loads['infiltration_latent'] = infiltration_latent
+        
+        ventilation_sensible, ventilation_latent = self.calculate_ventilation_heating_load(
+            internal_loads.get('ventilation', {}), indoor_conditions, outdoor_conditions, p_atm
+        )
+        loads['ventilation_sensible'] = ventilation_sensible
+        loads['ventilation_latent'] = ventilation_latent
+        
+        # Calculate internal gains (negative for heating)
+        loads['internal_gains'] = -self.calculate_internal_gains(internal_loads)
+        
+        return loads
+
+    def calculate_heating_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
+        """
+        Summarize heating loads with safety factor.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
+        
+        Args:
+            design_loads: Dictionary of design loads in W
+            
+        Returns:
+            Summary dictionary with total, subtotal, and safety factor
+        """
+        subtotal = sum(
+            load for key, load in design_loads.items()
+            if key not in ['internal_gains'] and load > 0
+        )
+        internal_gains = design_loads.get('internal_gains', 0)
+        
+        total = max(0, subtotal + internal_gains) * self.safety_factor
+        
+        return {
+            'subtotal': subtotal,
+            'internal_gains': internal_gains,
+            'total': total,
+            'safety_factor': self.safety_factor
+        }
+
+    def calculate_heating_degree_days(self, base_temp: float, monthly_temps: Dict[str, float]) -> float:
+        """
+        Calculate heating degree days for a year.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Section 14.3.
+        
+        Args:
+            base_temp: Base temperature for HDD calculation in °C
+            monthly_temps: Dictionary of monthly average temperatures
+            
+        Returns:
+            Total heating degree days
+        """
+        hdd = 0.0
+        days_per_month = {
+            'Jan': 31, 'Feb': 28, 'Mar': 31, 'Apr': 30, 'May': 31, 'Jun': 30,
+            'Jul': 31, 'Aug': 31, 'Sep': 30, 'Oct': 31, 'Nov': 30, 'Dec': 31
+        }
+        
+        for month, temp in monthly_temps.items():
+            if temp < base_temp:
+                hdd += (base_temp - temp) * days_per_month[month]
+        
+        return hdd
+
+    def calculate_annual_heating_energy(self, design_loads: Dict[str, float], 
+                                      monthly_temps: Dict[str, float], 
+                                      indoor_temp: float, 
+                                      operating_hours: str) -> float:
+        """
+        Calculate annual heating energy consumption.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Section 14.3.
+        
+        Args:
+            design_loads: Dictionary of design loads in W
+            monthly_temps: Dictionary of monthly average temperatures
+            indoor_temp: Indoor design temperature in °C
+            operating_hours: Operating hours (e.g., '8:00-18:00')
+            
+        Returns:
+            Annual heating energy in kWh
+        """
+        base_temp = indoor_temp
+        hdd = self.calculate_heating_degree_days(base_temp, monthly_temps)
+        
+        # Parse operating hours
+        start_hour, end_hour = map(lambda x: int(x.split(':')[0]), operating_hours.split('-'))
+        daily_hours = end_hour - start_hour
+        
+        # Calculate design condition degree days
+        design_temp = min(monthly_temps.values())
+        design_delta_t = indoor_temp - design_temp
+        if design_delta_t <= 1:
+            return 0.0
+        
+        total_load = self.calculate_heating_load_summary(design_loads)['total']
+        
+        # Scale load by HDD and operating hours
+        annual_energy = (total_load / design_delta_t) * hdd * (daily_hours / 24) / 1000  # kWh
+        
+        return max(0, annual_energy)
+
+    def calculate_monthly_heating_loads(self, building_components: Dict[str, List[Any]], 
+                                      outdoor_conditions: Dict[str, float], 
+                                      indoor_conditions: Dict[str, float], 
+                                      internal_loads: Dict[str, Any], 
+                                      monthly_temps: Dict[str, float],
+                                      p_atm: float = 101325) -> Dict[str, float]:
+        """
+        Calculate monthly heating loads.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
+        
+        Args:
+            building_components: Dictionary of building components
+            outdoor_conditions: Outdoor conditions
+            indoor_conditions: Indoor conditions
+            internal_loads: Internal loads
+            monthly_temps: Dictionary of monthly average temperatures
+            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            
+        Returns:
+            Dictionary of monthly heating loads in kW
+        """
+        monthly_loads = {}
+        days_per_month = {
+            'Jan': 31, 'Feb': 28, 'Mar': 31, 'Apr': 30, 'May': 31, 'Jun': 30,
+            'Jul': 31, 'Aug': 31, 'Sep': 30, 'Oct': 31, 'Nov': 30, 'Dec': 31
+        }
+        
+        for month, temp in monthly_temps.items():
+            modified_outdoor = outdoor_conditions.copy()
+            modified_outdoor['design_temperature'] = temp
+            modified_outdoor['ground_temperature'] = temp
+            
+            try:
+                design_loads = self.calculate_design_heating_load(
+                    building_components, modified_outdoor, indoor_conditions, internal_loads, p_atm
+                )
+                summary = self.calculate_heating_load_summary(design_loads)
+                monthly_loads[month] = summary['total'] / 1000  # kW
+            except ValueError:
+                monthly_loads[month] = 0.0  # Skip invalid months
+        
+        return monthly_loads
+
+# Example usage
+if __name__ == "__main__":
+    calculator = HeatingLoadCalculator(debug_mode=True)
+    
+    # Example building components
+    components = {
+        'walls': [Wall(id="w1", name="North Wall", area=20.0, u_value=0.5, orientation=Orientation.NORTH)],
+        'roofs': [Roof(id="r1", name="Main Roof", area=100.0, u_value=0.3, orientation=Orientation.HORIZONTAL)],
+        'floors': [Floor(id="f1", name="Ground Floor", area=100.0, u_value=0.4, perimeter_length=40.0, 
+                        is_ground_contact=True, insulated=True, ground_temperature_c=10.0)],
+        'windows': [Window(id="win1", name="South Window", area=10.0, u_value=2.8, orientation=Orientation.SOUTH, 
+                          shgc=0.7, shading_coefficient=0.8)],
+        'doors': [Door(id="d1", name="Main Door", area=2.0, u_value=2.0, orientation=Orientation.NORTH)]
+    }
+    
+    outdoor_conditions = {
+        'design_temperature': -5.0,
+        'design_relative_humidity': 80.0,
+        'ground_temperature': 10.0,
+        'wind_speed': 4.0
+    }
+    indoor_conditions = {
+        'temperature': 21.0,
+        'relative_humidity': 40.0
+    }
+    internal_loads = {
+        'people': {'number': 10, 'sensible_gain': 70.0, 'operating_hours': '8:00-18:00'},
+        'lights': {'power': 1000.0, 'use_factor': 0.8, 'hours_operation': '8h'},
+        'equipment': {'power': 500.0, 'use_factor': 0.7, 'hours_operation': '8h'},
+        'infiltration': {'flow_rate': 0.05, 'height': 3.0, 'crack_length': 20.0},
+        'ventilation': {'flow_rate': 0.1},
+        'operating_hours': '8:00-18:00'
+    }
+    monthly_temps = {
+        'Jan': -5.0, 'Feb': -3.0, 'Mar': 2.0, 'Apr': 8.0, 'May': 14.0, 'Jun': 19.0,
+        'Jul': 22.0, 'Aug': 21.0, 'Sep': 16.0, 'Oct': 10.0, 'Nov': 4.0, 'Dec': -2.0
+    }
+    
+    # Calculate design loads
+    design_loads = calculator.calculate_design_heating_load(components, outdoor_conditions, indoor_conditions, internal_loads)
+    summary = calculator.calculate_heating_load_summary(design_loads)
+    
+    # Log results
+    logger.info(f"Total Heating Load: {summary['total']:.2f} W")
+    logger.info(f"Wall Load: {design_loads['walls']:.2f} W")
+    logger.info(f"Roof Load: {design_loads['roofs']:.2f} W")
+    logger.info(f"Floor Load: {design_loads['floors']:.2f} W")
+    logger.info(f"Window Load: {design_loads['windows']:.2f} W")
+    logger.info(f"Door Load: {design_loads['doors']:.2f} W")
+    logger.info(f"Infiltration Sensible Load: {design_loads['infiltration_sensible']:.2f} W")
+    logger.info(f"Infiltration Latent Load: {design_loads['infiltration_latent']:.2f} W")
+    logger.info(f"Ventilation Sensible Load: {design_loads['ventilation_sensible']:.2f} W")
+    logger.info(f"Ventilation Latent Load: {design_loads['ventilation_latent']:.2f} W")
+    logger.info(f"Internal Gains: {design_loads['internal_gains']:.2f} W")
+    
+    # Calculate annual energy
+    annual_energy = calculator.calculate_annual_heating_energy(
+        design_loads, monthly_temps, indoor_conditions['temperature'], internal_loads['operating_hours']
+    )
+    logger.info(f"Annual Heating Energy: {annual_energy:.2f} kWh")
+    
+    # Calculate monthly loads
+    monthly_loads = calculator.calculate_monthly_heating_loads(
+        components, outdoor_conditions, indoor_conditions, internal_loads, monthly_temps
+    )
+    logger.info("Monthly Heating Loads (kW):")
+    for month, load in monthly_loads.items():
+        logger.info(f"{month}: {load:.2f} kW")

utils/psychrometric_visualization.py

@@ -0,0 +1,635 @@
+"""
+Psychrometric visualization module for HVAC Load Calculator.
+This module provides visualization tools for psychrometric processes.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple
+import math
+
+# Import psychrometrics module
+from utils.psychrometrics import Psychrometrics
+
+
+class PsychrometricVisualization:
+    """Class for psychrometric visualization."""
+    
+    def __init__(self):
+        """Initialize psychrometric visualization."""
+        self.psychrometrics = Psychrometrics()
+        
+        # Define temperature and humidity ratio ranges for chart
+        self.temp_min = -10
+        self.temp_max = 50
+        self.w_min = 0
+        self.w_max = 0.030
+        
+        # Define standard atmospheric pressure
+        self.pressure = 101325  # Pa
+    
+    def create_psychrometric_chart(self, points: Optional[List[Dict[str, Any]]] = None,
+                                  processes: Optional[List[Dict[str, Any]]] = None,
+                                  comfort_zone: Optional[Dict[str, Any]] = None) -> go.Figure:
+        """
+        Create an interactive psychrometric chart.
+        
+        Args:
+            points: List of points to plot on the chart
+            processes: List of processes to plot on the chart
+            comfort_zone: Dictionary with comfort zone parameters
+            
+        Returns:
+            Plotly figure with psychrometric chart
+        """
+        # Create figure
+        fig = go.Figure()
+        
+        # Generate temperature and humidity ratio grids
+        temp_range = np.linspace(self.temp_min, self.temp_max, 100)
+        w_range = np.linspace(self.w_min, self.w_max, 100)
+        
+        # Generate saturation curve
+        sat_temps = np.linspace(self.temp_min, self.temp_max, 100)
+        sat_w = [self.psychrometrics.humidity_ratio(t, 100, self.pressure) for t in sat_temps]
+        
+        # Plot saturation curve
+        fig.add_trace(go.Scatter(
+            x=sat_temps,
+            y=sat_w,
+            mode="lines",
+            line=dict(color="blue", width=2),
+            name="Saturation Curve"
+        ))
+        
+        # Generate constant RH curves
+        rh_values = [10, 20, 30, 40, 50, 60, 70, 80, 90]
+        
+        for rh in rh_values:
+            rh_temps = np.linspace(self.temp_min, self.temp_max, 50)
+            rh_w = [self.psychrometrics.humidity_ratio(t, rh, self.pressure) for t in rh_temps]
+            
+            # Filter out values above saturation
+            valid_points = [(t, w) for t, w in zip(rh_temps, rh_w) if w <= self.psychrometrics.humidity_ratio(t, 100, self.pressure)]
+            
+            if valid_points:
+                valid_temps, valid_w = zip(*valid_points)
+                
+                fig.add_trace(go.Scatter(
+                    x=valid_temps,
+                    y=valid_w,
+                    mode="lines",
+                    line=dict(color="rgba(0, 0, 255, 0.3)", width=1, dash="dot"),
+                    name=f"{rh}% RH",
+                    hoverinfo="name"
+                ))
+        
+        # Generate constant wet-bulb temperature lines
+        wb_values = np.arange(0, 35, 5)
+        
+        for wb in wb_values:
+            wb_temps = np.linspace(wb, self.temp_max, 50)
+            wb_points = []
+            
+            for t in wb_temps:
+                # Binary search to find humidity ratio for this wet-bulb temperature
+                w_low = 0
+                w_high = self.psychrometrics.humidity_ratio(t, 100, self.pressure)
+                
+                for _ in range(10):  # 10 iterations should be enough for good precision
+                    w_mid = (w_low + w_high) / 2
+                    rh = self.psychrometrics.relative_humidity(t, w_mid, self.pressure)
+                    t_wb_calc = self.psychrometrics.wet_bulb_temperature(t, rh, self.pressure)
+                    
+                    if abs(t_wb_calc - wb) < 0.1:
+                        wb_points.append((t, w_mid))
+                        break
+                    elif t_wb_calc < wb:
+                        w_low = w_mid
+                    else:
+                        w_high = w_mid
+            
+            if wb_points:
+                wb_temps, wb_w = zip(*wb_points)
+                
+                fig.add_trace(go.Scatter(
+                    x=wb_temps,
+                    y=wb_w,
+                    mode="lines",
+                    line=dict(color="rgba(0, 128, 0, 0.3)", width=1, dash="dash"),
+                    name=f"{wb}°C WB",
+                    hoverinfo="name"
+                ))
+        
+        # Generate constant enthalpy lines
+        h_values = np.arange(0, 100, 10) * 1000  # kJ/kg to J/kg
+        
+        for h in h_values:
+            h_temps = np.linspace(self.temp_min, self.temp_max, 50)
+            h_points = []
+            
+            for t in h_temps:
+                # Calculate humidity ratio for this enthalpy
+                w = self.psychrometrics.find_humidity_ratio_for_enthalpy(t, h)
+                
+                if 0 <= w <= self.psychrometrics.humidity_ratio(t, 100, self.pressure):
+                    h_points.append((t, w))
+            
+            if h_points:
+                h_temps, h_w = zip(*h_points)
+                
+                fig.add_trace(go.Scatter(
+                    x=h_temps,
+                    y=h_w,
+                    mode="lines",
+                    line=dict(color="rgba(255, 0, 0, 0.3)", width=1, dash="dashdot"),
+                    name=f"{h/1000:.0f} kJ/kg",
+                    hoverinfo="name"
+                ))
+        
+        # Generate constant specific volume lines
+        v_values = [0.8, 0.85, 0.9, 0.95, 1.0, 1.05]
+        
+        for v in v_values:
+            v_temps = np.linspace(self.temp_min, self.temp_max, 50)
+            v_points = []
+            
+            for t in h_temps:
+                # Binary search to find humidity ratio for this specific volume
+                w_low = 0
+                w_high = self.psychrometrics.humidity_ratio(t, 100, self.pressure)
+                
+                for _ in range(10):  # 10 iterations should be enough for good precision
+                    w_mid = (w_low + w_high) / 2
+                    v_calc = self.psychrometrics.specific_volume(t, w_mid, self.pressure)
+                    
+                    if abs(v_calc - v) < 0.01:
+                        v_points.append((t, w_mid))
+                        break
+                    elif v_calc < v:
+                        w_low = w_mid
+                    else:
+                        w_high = w_mid
+            
+            if v_points:
+                v_temps, v_w = zip(*v_points)
+                
+                fig.add_trace(go.Scatter(
+                    x=v_temps,
+                    y=v_w,
+                    mode="lines",
+                    line=dict(color="rgba(128, 0, 128, 0.3)", width=1, dash="longdash"),
+                    name=f"{v:.2f} m³/kg",
+                    hoverinfo="name"
+                ))
+        
+        # Add comfort zone if specified
+        if comfort_zone:
+            temp_min = comfort_zone.get("temp_min", 20)
+            temp_max = comfort_zone.get("temp_max", 26)
+            rh_min = comfort_zone.get("rh_min", 30)
+            rh_max = comfort_zone.get("rh_max", 60)
+            
+            # Calculate humidity ratios at corners
+            w_bottom_left = self.psychrometrics.humidity_ratio(temp_min, rh_min, self.pressure)
+            w_bottom_right = self.psychrometrics.humidity_ratio(temp_max, rh_min, self.pressure)
+            w_top_right = self.psychrometrics.humidity_ratio(temp_max, rh_max, self.pressure)
+            w_top_left = self.psychrometrics.humidity_ratio(temp_min, rh_max, self.pressure)
+            
+            # Add comfort zone as a filled polygon
+            fig.add_trace(go.Scatter(
+                x=[temp_min, temp_max, temp_max, temp_min, temp_min],
+                y=[w_bottom_left, w_bottom_right, w_top_right, w_top_left, w_bottom_left],
+                fill="toself",
+                fillcolor="rgba(0, 255, 0, 0.2)",
+                line=dict(color="green", width=2),
+                name="Comfort Zone"
+            ))
+        
+        # Add points if specified
+        if points:
+            for i, point in enumerate(points):
+                temp = point.get("temp", 0)
+                rh = point.get("rh", 0)
+                w = point.get("w", self.psychrometrics.humidity_ratio(temp, rh, self.pressure))
+                name = point.get("name", f"Point {i+1}")
+                color = point.get("color", "blue")
+                
+                fig.add_trace(go.Scatter(
+                    x=[temp],
+                    y=[w],
+                    mode="markers+text",
+                    marker=dict(size=10, color=color),
+                    text=[name],
+                    textposition="top center",
+                    name=name,
+                    hovertemplate=(
+                        f"<b>{name}</b><br>" +
+                        "Temperature: %{x:.1f}°C<br>" +
+                        "Humidity Ratio: %{y:.5f} kg/kg<br>" +
+                        f"Relative Humidity: {rh:.1f}%<br>"
+                    )
+                ))
+        
+        # Add processes if specified
+        if processes:
+            for i, process in enumerate(processes):
+                start_point = process.get("start", {})
+                end_point = process.get("end", {})
+                
+                start_temp = start_point.get("temp", 0)
+                start_rh = start_point.get("rh", 0)
+                start_w = start_point.get("w", self.psychrometrics.humidity_ratio(start_temp, start_rh, self.pressure))
+                
+                end_temp = end_point.get("temp", 0)
+                end_rh = end_point.get("rh", 0)
+                end_w = end_point.get("w", self.psychrometrics.humidity_ratio(end_temp, end_rh, self.pressure))
+                
+                name = process.get("name", f"Process {i+1}")
+                color = process.get("color", "red")
+                
+                fig.add_trace(go.Scatter(
+                    x=[start_temp, end_temp],
+                    y=[start_w, end_w],
+                    mode="lines+markers",
+                    line=dict(color=color, width=2, dash="solid"),
+                    marker=dict(size=8, color=color),
+                    name=name
+                ))
+                
+                # Add arrow to indicate direction
+                fig.add_annotation(
+                    x=end_temp,
+                    y=end_w,
+                    ax=start_temp,
+                    ay=start_w,
+                    xref="x",
+                    yref="y",
+                    axref="x",
+                    ayref="y",
+                    showarrow=True,
+                    arrowhead=2,
+                    arrowsize=1,
+                    arrowwidth=2,
+                    arrowcolor=color
+                )
+        
+        # Update layout
+        fig.update_layout(
+            title="Psychrometric Chart",
+            xaxis_title="Dry-Bulb Temperature (°C)",
+            yaxis_title="Humidity Ratio (kg/kg)",
+            xaxis=dict(
+                range=[self.temp_min, self.temp_max],
+                gridcolor="rgba(0, 0, 0, 0.1)",
+                showgrid=True
+            ),
+            yaxis=dict(
+                range=[self.w_min, self.w_max],
+                gridcolor="rgba(0, 0, 0, 0.1)",
+                showgrid=True
+            ),
+            height=700,
+            margin=dict(l=50, r=50, b=50, t=50),
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            ),
+            hovermode="closest"
+        )
+        
+        return fig
+    
+    def create_process_visualization(self, process: Dict[str, Any]) -> go.Figure:
+        """
+        Create a visualization of a psychrometric process.
+        
+        Args:
+            process: Dictionary with process parameters
+            
+        Returns:
+            Plotly figure with process visualization
+        """
+        # Extract process parameters
+        start_point = process.get("start", {})
+        end_point = process.get("end", {})
+        
+        start_temp = start_point.get("temp", 0)
+        start_rh = start_point.get("rh", 0)
+        
+        end_temp = end_point.get("temp", 0)
+        end_rh = end_point.get("rh", 0)
+        
+        # Calculate psychrometric properties
+        start_props = self.psychrometrics.moist_air_properties(start_temp, start_rh, self.pressure)
+        end_props = self.psychrometrics.moist_air_properties(end_temp, end_rh, self.pressure)
+        
+        # Calculate process changes
+        delta_t = end_temp - start_temp
+        delta_w = end_props["humidity_ratio"] - start_props["humidity_ratio"]
+        delta_h = end_props["enthalpy"] - start_props["enthalpy"]
+        
+        # Determine process type
+        process_type = "Unknown"
+        if abs(delta_w) < 0.0001:  # Sensible heating/cooling
+            if delta_t > 0:
+                process_type = "Sensible Heating"
+            else:
+                process_type = "Sensible Cooling"
+        elif abs(delta_t) < 0.1:  # Humidification/Dehumidification
+            if delta_w > 0:
+                process_type = "Humidification"
+            else:
+                process_type = "Dehumidification"
+        elif delta_t > 0 and delta_w > 0:
+            process_type = "Heating and Humidification"
+        elif delta_t < 0 and delta_w < 0:
+            process_type = "Cooling and Dehumidification"
+        elif delta_t > 0 and delta_w < 0:
+            process_type = "Heating and Dehumidification"
+        elif delta_t < 0 and delta_w > 0:
+            process_type = "Cooling and Humidification"
+        
+        # Create figure
+        fig = go.Figure()
+        
+        # Add process to psychrometric chart
+        chart_fig = self.create_psychrometric_chart(
+            points=[
+                {"temp": start_temp, "rh": start_rh, "name": "Start", "color": "blue"},
+                {"temp": end_temp, "rh": end_rh, "name": "End", "color": "red"}
+            ],
+            processes=[
+                {"start": {"temp": start_temp, "rh": start_rh}, 
+                 "end": {"temp": end_temp, "rh": end_rh}, 
+                 "name": process_type, 
+                 "color": "green"}
+            ]
+        )
+        
+        # Create process diagram
+        # Create data for process parameters
+        params = [
+            "Dry-Bulb Temperature (°C)",
+            "Relative Humidity (%)",
+            "Humidity Ratio (g/kg)",
+            "Enthalpy (kJ/kg)",
+            "Wet-Bulb Temperature (°C)",
+            "Dew Point Temperature (°C)",
+            "Specific Volume (m³/kg)"
+        ]
+        
+        start_values = [
+            start_props["dry_bulb_temperature"],
+            start_props["relative_humidity"],
+            start_props["humidity_ratio"] * 1000,  # Convert to g/kg
+            start_props["enthalpy"] / 1000,  # Convert to kJ/kg
+            start_props["wet_bulb_temperature"],
+            start_props["dew_point_temperature"],
+            start_props["specific_volume"]
+        ]
+        
+        end_values = [
+            end_props["dry_bulb_temperature"],
+            end_props["relative_humidity"],
+            end_props["humidity_ratio"] * 1000,  # Convert to g/kg
+            end_props["enthalpy"] / 1000,  # Convert to kJ/kg
+            end_props["wet_bulb_temperature"],
+            end_props["dew_point_temperature"],
+            end_props["specific_volume"]
+        ]
+        
+        delta_values = [end - start for start, end in zip(start_values, end_values)]
+        
+        # Create table
+        table_fig = go.Figure(data=[go.Table(
+            header=dict(
+                values=["Parameter", "Start", "End", "Change"],
+                fill_color="paleturquoise",
+                align="left",
+                font=dict(size=12)
+            ),
+            cells=dict(
+                values=[
+                    params,
+                    [f"{val:.2f}" for val in start_values],
+                    [f"{val:.2f}" for val in end_values],
+                    [f"{val:.2f}" for val in delta_values]
+                ],
+                fill_color="lavender",
+                align="left",
+                font=dict(size=11)
+            )
+        )])
+        
+        table_fig.update_layout(
+            title=f"Process Parameters: {process_type}",
+            height=300,
+            margin=dict(l=0, r=0, b=0, t=30)
+        )
+        
+        return chart_fig, table_fig
+    
+    def display_psychrometric_visualization(self) -> None:
+        """
+        Display psychrometric visualization in Streamlit.
+        """
+        st.header("Psychrometric Visualization")
+        
+        # Create tabs for different visualizations
+        tab1, tab2, tab3 = st.tabs([
+            "Interactive Psychrometric Chart", 
+            "Process Visualization", 
+            "Comfort Zone Analysis"
+        ])
+        
+        with tab1:
+            st.subheader("Interactive Psychrometric Chart")
+            
+            # Add controls for points
+            st.write("Add points to the chart:")
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                point1_temp = st.number_input("Point 1 Temperature (°C)", -10.0, 50.0, 20.0, key="point1_temp")
+                point1_rh = st.number_input("Point 1 RH (%)", 0.0, 100.0, 50.0, key="point1_rh")
+            
+            with col2:
+                point2_temp = st.number_input("Point 2 Temperature (°C)", -10.0, 50.0, 30.0, key="point2_temp")
+                point2_rh = st.number_input("Point 2 RH (%)", 0.0, 100.0, 40.0, key="point2_rh")
+            
+            with col3:
+                show_process = st.checkbox("Show Process Line", True, key="show_process")
+                process_name = st.text_input("Process Name", "Cooling Process", key="process_name")
+            
+            # Create points
+            points = [
+                {"temp": point1_temp, "rh": point1_rh, "name": "Point 1", "color": "blue"},
+                {"temp": point2_temp, "rh": point2_rh, "name": "Point 2", "color": "red"}
+            ]
+            
+            # Create process if enabled
+            processes = []
+            if show_process:
+                processes.append({
+                    "start": {"temp": point1_temp, "rh": point1_rh},
+                    "end": {"temp": point2_temp, "rh": point2_rh},
+                    "name": process_name,
+                    "color": "green"
+                })
+            
+            # Create and display chart
+            fig = self.create_psychrometric_chart(points=points, processes=processes)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Display point properties
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.subheader("Point 1 Properties")
+                props1 = self.psychrometrics.moist_air_properties(point1_temp, point1_rh, self.pressure)
+                st.write(f"Dry-Bulb Temperature: {props1['dry_bulb_temperature']:.2f} °C")
+                st.write(f"Relative Humidity: {props1['relative_humidity']:.2f} %")
+                st.write(f"Humidity Ratio: {props1['humidity_ratio']*1000:.2f} g/kg")
+                st.write(f"Enthalpy: {props1['enthalpy']/1000:.2f} kJ/kg")
+                st.write(f"Wet-Bulb Temperature: {props1['wet_bulb_temperature']:.2f} °C")
+                st.write(f"Dew Point Temperature: {props1['dew_point_temperature']:.2f} °C")
+            
+            with col2:
+                st.subheader("Point 2 Properties")
+                props2 = self.psychrometrics.moist_air_properties(point2_temp, point2_rh, self.pressure)
+                st.write(f"Dry-Bulb Temperature: {props2['dry_bulb_temperature']:.2f} °C")
+                st.write(f"Relative Humidity: {props2['relative_humidity']:.2f} %")
+                st.write(f"Humidity Ratio: {props2['humidity_ratio']*1000:.2f} g/kg")
+                st.write(f"Enthalpy: {props2['enthalpy']/1000:.2f} kJ/kg")
+                st.write(f"Wet-Bulb Temperature: {props2['wet_bulb_temperature']:.2f} °C")
+                st.write(f"Dew Point Temperature: {props2['dew_point_temperature']:.2f} °C")
+        
+        with tab2:
+            st.subheader("Process Visualization")
+            
+            # Add controls for process
+            st.write("Define a psychrometric process:")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.write("Starting Point")
+                start_temp = st.number_input("Temperature (°C)", -10.0, 50.0, 24.0, key="start_temp")
+                start_rh = st.number_input("RH (%)", 0.0, 100.0, 50.0, key="start_rh")
+            
+            with col2:
+                st.write("Ending Point")
+                end_temp = st.number_input("Temperature (°C)", -10.0, 50.0, 14.0, key="end_temp")
+                end_rh = st.number_input("RH (%)", 0.0, 100.0, 90.0, key="end_rh")
+            
+            # Create process
+            process = {
+                "start": {"temp": start_temp, "rh": start_rh},
+                "end": {"temp": end_temp, "rh": end_rh}
+            }
+            
+            # Create and display process visualization
+            chart_fig, table_fig = self.create_process_visualization(process)
+            
+            st.plotly_chart(chart_fig, use_container_width=True)
+            st.plotly_chart(table_fig, use_container_width=True)
+            
+            # Calculate process energy requirements
+            start_props = self.psychrometrics.moist_air_properties(start_temp, start_rh, self.pressure)
+            end_props = self.psychrometrics.moist_air_properties(end_temp, end_rh, self.pressure)
+            
+            delta_h = end_props["enthalpy"] - start_props["enthalpy"]  # J/kg
+            
+            st.subheader("Energy Calculations")
+            
+            air_flow = st.number_input("Air Flow Rate (m³/s)", 0.1, 100.0, 1.0, key="air_flow")
+            
+            # Calculate mass flow rate
+            density = start_props["density"]  # kg/m³
+            mass_flow = air_flow * density  # kg/s
+            
+            # Calculate energy rate
+            energy_rate = mass_flow * delta_h  # W
+            
+            st.write(f"Air Density: {density:.2f} kg/m³")
+            st.write(f"Mass Flow Rate: {mass_flow:.2f} kg/s")
+            st.write(f"Enthalpy Change: {delta_h/1000:.2f} kJ/kg")
+            st.write(f"Energy Rate: {energy_rate/1000:.2f} kW")
+        
+        with tab3:
+            st.subheader("Comfort Zone Analysis")
+            
+            # Add controls for comfort zone
+            st.write("Define comfort zone parameters:")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                temp_min = st.number_input("Minimum Temperature (°C)", 10.0, 30.0, 20.0, key="temp_min")
+                temp_max = st.number_input("Maximum Temperature (°C)", 10.0, 30.0, 26.0, key="temp_max")
+            
+            with col2:
+                rh_min = st.number_input("Minimum RH (%)", 0.0, 100.0, 30.0, key="rh_min")
+                rh_max = st.number_input("Maximum RH (%)", 0.0, 100.0, 60.0, key="rh_max")
+            
+            # Create comfort zone
+            comfort_zone = {
+                "temp_min": temp_min,
+                "temp_max": temp_max,
+                "rh_min": rh_min,
+                "rh_max": rh_max
+            }
+            
+            # Add point to check if it's in comfort zone
+            st.write("Check if a point is within the comfort zone:")
+            
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                check_temp = st.number_input("Temperature (°C)", -10.0, 50.0, 22.0, key="check_temp")
+                check_rh = st.number_input("RH (%)", 0.0, 100.0, 45.0, key="check_rh")
+            
+            # Check if point is in comfort zone
+            in_comfort_zone = (
+                temp_min <= check_temp <= temp_max and
+                rh_min <= check_rh <= rh_max
+            )
+            
+            with col2:
+                if in_comfort_zone:
+                    st.success("✅ Point is within the comfort zone")
+                else:
+                    st.error("❌ Point is outside the comfort zone")
+                
+                # Calculate properties
+                check_props = self.psychrometrics.moist_air_properties(check_temp, check_rh, self.pressure)
+                st.write(f"Humidity Ratio: {check_props['humidity_ratio']*1000:.2f} g/kg")
+                st.write(f"Enthalpy: {check_props['enthalpy']/1000:.2f} kJ/kg")
+                st.write(f"Wet-Bulb Temperature: {check_props['wet_bulb_temperature']:.2f} °C")
+            
+            # Create and display chart with comfort zone
+            fig = self.create_psychrometric_chart(
+                points=[{"temp": check_temp, "rh": check_rh, "name": "Test Point", "color": "purple"}],
+                comfort_zone=comfort_zone
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+
+
+# Create a singleton instance
+psychrometric_visualization = PsychrometricVisualization()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Display psychrometric visualization
+    psychrometric_visualization.display_psychrometric_visualization()

utils/psychrometrics.py

@@ -0,0 +1,581 @@
+"""
+Psychrometric module for HVAC Load Calculator.
+This module implements psychrometric calculations for air properties.
+Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import math
+import numpy as np
+
+# Constants
+ATMOSPHERIC_PRESSURE = 101325  # Standard atmospheric pressure in Pa
+WATER_MOLECULAR_WEIGHT = 18.01534  # kg/kmol
+DRY_AIR_MOLECULAR_WEIGHT = 28.9645  # kg/kmol
+UNIVERSAL_GAS_CONSTANT = 8314.462618  # J/(kmol·K)
+GAS_CONSTANT_DRY_AIR = UNIVERSAL_GAS_CONSTANT / DRY_AIR_MOLECULAR_WEIGHT  # J/(kg·K)
+GAS_CONSTANT_WATER_VAPOR = UNIVERSAL_GAS_CONSTANT / WATER_MOLECULAR_WEIGHT  # J/(kg·K)
+
+
+class Psychrometrics:
+    """Class for psychrometric calculations."""
+    
+    @staticmethod
+    def validate_inputs(t_db: float, rh: Optional[float] = None, p_atm: Optional[float] = None) -> None:
+        """
+        Validate input parameters for psychrometric calculations.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            rh: Relative humidity in % (0-100), optional
+            p_atm: Atmospheric pressure in Pa, optional
+            
+        Raises:
+            ValueError: If inputs are invalid
+        """
+        if not -50 <= t_db <= 60:
+            raise ValueError(f"Temperature {t_db}°C must be between -50°C and 60°C")
+        if rh is not None and not 0 <= rh <= 100:
+            raise ValueError(f"Relative humidity {rh}% must be between 0 and 100%")
+        if p_atm is not None and p_atm <= 0:
+            raise ValueError(f"Atmospheric pressure {p_atm} Pa must be positive")
+
+    @staticmethod
+    def saturation_pressure(t_db: float) -> float:
+        """
+        Calculate saturation pressure of water vapor.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equations 5 and 6.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            
+        Returns:
+            Saturation pressure in Pa
+        """
+        Psychrometrics.validate_inputs(t_db)
+        
+        # Convert temperature to Kelvin
+        t_k = t_db + 273.15
+        
+        # ASHRAE Fundamentals 2017 Chapter 1, Equation 5 & 6
+        if t_db >= 0:
+            # Equation 5 for temperatures above freezing
+            c1 = -5.8002206e3
+            c2 = 1.3914993
+            c3 = -4.8640239e-2
+            c4 = 4.1764768e-5
+            c5 = -1.4452093e-8
+            c6 = 6.5459673
+        else:
+            # Equation 6 for temperatures below freezing
+            c1 = -5.6745359e3
+            c2 = 6.3925247
+            c3 = -9.6778430e-3
+            c4 = 6.2215701e-7
+            c5 = 2.0747825e-9
+            c6 = -9.4840240e-13
+            c7 = 4.1635019
+        
+        # Calculate natural log of saturation pressure in Pa
+        if t_db >= 0:
+            ln_p_ws = c1 / t_k + c2 + c3 * t_k + c4 * t_k**2 + c5 * t_k**3 + c6 * math.log(t_k)
+        else:
+            ln_p_ws = c1 / t_k + c2 + c3 * t_k + c4 * t_k**2 + c5 * t_k**3 + c6 * t_k**4 + c7 * math.log(t_k)
+        
+        # Convert from natural log to actual pressure in Pa
+        p_ws = math.exp(ln_p_ws)
+        
+        return p_ws
+    
+    @staticmethod
+    def humidity_ratio(t_db: float, rh: float, p_atm: float = ATMOSPHERIC_PRESSURE) -> float:
+        """
+        Calculate humidity ratio (mass of water vapor per unit mass of dry air).
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equation 20.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            rh: Relative humidity (0-100)
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Humidity ratio in kg water vapor / kg dry air
+        """
+        Psychrometrics.validate_inputs(t_db, rh, p_atm)
+        
+        # Convert relative humidity to decimal
+        rh_decimal = rh / 100.0
+        
+        # Calculate saturation pressure
+        p_ws = Psychrometrics.saturation_pressure(t_db)
+        
+        # Calculate partial pressure of water vapor
+        p_w = rh_decimal * p_ws
+        
+        if p_w >= p_atm:
+            raise ValueError("Partial pressure of water vapor exceeds atmospheric pressure")
+        
+        # Calculate humidity ratio
+        w = 0.621945 * p_w / (p_atm - p_w)
+        
+        return w
+    
+    @staticmethod
+    def relative_humidity(t_db: float, w: float, p_atm: float = ATMOSPHERIC_PRESSURE) -> float:
+        """
+        Calculate relative humidity from humidity ratio.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equation 20 (rearranged).
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            w: Humidity ratio in kg water vapor / kg dry air
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Relative humidity (0-100)
+        """
+        Psychrometrics.validate_inputs(t_db, p_atm=p_atm)
+        if w < 0:
+            raise ValueError("Humidity ratio cannot be negative")
+        
+        # Calculate saturation pressure
+        p_ws = Psychrometrics.saturation_pressure(t_db)
+        
+        # Calculate partial pressure of water vapor
+        p_w = p_atm * w / (0.621945 + w)
+        
+        # Calculate relative humidity
+        rh = 100.0 * p_w / p_ws
+        
+        return rh
+    
+    @staticmethod
+    def wet_bulb_temperature(t_db: float, rh: float, p_atm: float = ATMOSPHERIC_PRESSURE) -> float:
+        """
+        Calculate wet-bulb temperature using iterative method.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equation 35.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            rh: Relative humidity (0-100)
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Wet-bulb temperature in °C
+        """
+        Psychrometrics.validate_inputs(t_db, rh, p_atm)
+        
+        # Calculate humidity ratio at given conditions
+        w = Psychrometrics.humidity_ratio(t_db, rh, p_atm)
+        
+        # Initial guess for wet-bulb temperature
+        t_wb = t_db
+        
+        # Iterative solution
+        max_iterations = 100
+        tolerance = 0.001  # °C
+        
+        for i in range(max_iterations):
+            # Validate wet-bulb temperature
+            Psychrometrics.validate_inputs(t_wb)
+            
+            # Calculate saturation pressure at wet-bulb temperature
+            p_ws_wb = Psychrometrics.saturation_pressure(t_wb)
+            
+            # Calculate saturation humidity ratio at wet-bulb temperature
+            w_s_wb = 0.621945 * p_ws_wb / (p_atm - p_ws_wb)
+            
+            # Calculate humidity ratio from wet-bulb temperature
+            h_fg = 2501000 + 1840 * t_wb  # Latent heat of vaporization at t_wb in J/kg
+            c_pa = 1006  # Specific heat of dry air in J/(kg·K)
+            c_pw = 1860  # Specific heat of water vapor in J/(kg·K)
+            
+            w_calc = ((h_fg - c_pw * (t_db - t_wb)) * w_s_wb - c_pa * (t_db - t_wb)) / (h_fg + c_pw * t_db - c_pw * t_wb)
+            
+            # Check convergence
+            if abs(w - w_calc) < tolerance:
+                break
+            
+            # Adjust wet-bulb temperature
+            if w_calc > w:
+                t_wb -= 0.1
+            else:
+                t_wb += 0.1
+        
+        return t_wb
+    
+    @staticmethod
+    def dew_point_temperature(t_db: float, rh: float) -> float:
+        """
+        Calculate dew point temperature.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equations 39 and 40.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            rh: Relative humidity (0-100)
+            
+        Returns:
+            Dew point temperature in °C
+        """
+        Psychrometrics.validate_inputs(t_db, rh)
+        
+        # Convert relative humidity to decimal
+        rh_decimal = rh / 100.0
+        
+        # Calculate saturation pressure
+        p_ws = Psychrometrics.saturation_pressure(t_db)
+        
+        # Calculate partial pressure of water vapor
+        p_w = rh_decimal * p_ws
+        
+        # Calculate dew point temperature
+        alpha = math.log(p_w / 1000.0)  # Convert to kPa for the formula
+        
+        if t_db >= 0:
+            # For temperatures above freezing
+            c14 = 6.54
+            c15 = 14.526
+            c16 = 0.7389
+            c17 = 0.09486
+            c18 = 0.4569
+            
+            t_dp = c14 + c15 * alpha + c16 * alpha**2 + c17 * alpha**3 + c18 * p_w**(0.1984)
+        else:
+            # For temperatures below freezing
+            c14 = 6.09
+            c15 = 12.608
+            c16 = 0.4959
+            
+            t_dp = c14 + c15 * alpha + c16 * alpha**2
+        
+        return t_dp
+    
+    @staticmethod
+    def enthalpy(t_db: float, w: float) -> float:
+        """
+        Calculate specific enthalpy of moist air.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equation 30.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            w: Humidity ratio in kg water vapor / kg dry air
+            
+        Returns:
+            Specific enthalpy in J/kg dry air
+        """
+        Psychrometrics.validate_inputs(t_db)
+        if w < 0:
+            raise ValueError("Humidity ratio cannot be negative")
+        
+        c_pa = 1006  # Specific heat of dry air in J/(kg·K)
+        h_fg = 2501000  # Latent heat of vaporization at 0°C in J/kg
+        c_pw = 1860  # Specific heat of water vapor in J/(kg·K)
+        
+        h = c_pa * t_db + w * (h_fg + c_pw * t_db)
+        
+        return h
+    
+    @staticmethod
+    def specific_volume(t_db: float, w: float, p_atm: float = ATMOSPHERIC_PRESSURE) -> float:
+        """
+        Calculate specific volume of moist air.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equation 28.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            w: Humidity ratio in kg water vapor / kg dry air
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Specific volume in m³/kg dry air
+        """
+        Psychrometrics.validate_inputs(t_db, p_atm=p_atm)
+        if w < 0:
+            raise ValueError("Humidity ratio cannot be negative")
+        
+        # Convert temperature to Kelvin
+        t_k = t_db + 273.15
+        
+        r_da = GAS_CONSTANT_DRY_AIR  # Gas constant for dry air in J/(kg·K)
+        
+        v = r_da * t_k * (1 + 1.607858 * w) / p_atm
+        
+        return v
+    
+    @staticmethod
+    def density(t_db: float, w: float, p_atm: float = ATMOSPHERIC_PRESSURE) -> float:
+        """
+        Calculate density of moist air.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, derived from Equation 28.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            w: Humidity ratio in kg water vapor / kg dry air
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Density in kg/m³
+        """
+        Psychrometrics.validate_inputs(t_db, p_atm=p_atm)
+        if w < 0:
+            raise ValueError("Humidity ratio cannot be negative")
+        
+        # Calculate specific volume
+        v = Psychrometrics.specific_volume(t_db, w, p_atm)
+        
+        # Density is the reciprocal of specific volume
+        rho = (1 + w) / v
+        
+        return rho
+    
+    @staticmethod
+    def moist_air_properties(t_db: float, rh: float, p_atm: float = ATMOSPHERIC_PRESSURE) -> Dict[str, float]:
+        """
+        Calculate all psychrometric properties of moist air.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            rh: Relative humidity (0-100)
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Dictionary with all psychrometric properties
+        """
+        Psychrometrics.validate_inputs(t_db, rh, p_atm)
+        
+        # Calculate humidity ratio
+        w = Psychrometrics.humidity_ratio(t_db, rh, p_atm)
+        
+        # Calculate wet-bulb temperature
+        t_wb = Psychrometrics.wet_bulb_temperature(t_db, rh, p_atm)
+        
+        # Calculate dew point temperature
+        t_dp = Psychrometrics.dew_point_temperature(t_db, rh)
+        
+        # Calculate enthalpy
+        h = Psychrometrics.enthalpy(t_db, w)
+        
+        # Calculate specific volume
+        v = Psychrometrics.specific_volume(t_db, w, p_atm)
+        
+        # Calculate density
+        rho = Psychrometrics.density(t_db, w, p_atm)
+        
+        # Calculate saturation pressure
+        p_ws = Psychrometrics.saturation_pressure(t_db)
+        
+        # Calculate partial pressure of water vapor
+        p_w = rh / 100.0 * p_ws
+        
+        # Return all properties
+        return {
+            "dry_bulb_temperature": t_db,
+            "wet_bulb_temperature": t_wb,
+            "dew_point_temperature": t_dp,
+            "relative_humidity": rh,
+            "humidity_ratio": w,
+            "enthalpy": h,
+            "specific_volume": v,
+            "density": rho,
+            "saturation_pressure": p_ws,
+            "partial_pressure": p_w,
+            "atmospheric_pressure": p_atm
+        }
+    
+    @staticmethod
+    def find_humidity_ratio_for_enthalpy(t_db: float, h: float) -> float:
+        """
+        Find humidity ratio for a given dry-bulb temperature and enthalpy.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equation 30 (rearranged).
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            h: Specific enthalpy in J/kg dry air
+            
+        Returns:
+            Humidity ratio in kg water vapor / kg dry air
+        """
+        Psychrometrics.validate_inputs(t_db)
+        if h < 0:
+            raise ValueError("Enthalpy cannot be negative")
+        
+        c_pa = 1006  # Specific heat of dry air in J/(kg·K)
+        h_fg = 2501000  # Latent heat of vaporization at 0°C in J/kg
+        c_pw = 1860  # Specific heat of water vapor in J/(kg·K)
+        
+        w = (h - c_pa * t_db) / (h_fg + c_pw * t_db)
+        
+        return max(0, w)
+    
+    @staticmethod
+    def find_temperature_for_enthalpy(w: float, h: float) -> float:
+        """
+        Find dry-bulb temperature for a given humidity ratio and enthalpy.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Equation 30 (rearranged).
+        
+        Args:
+            w: Humidity ratio in kg water vapor / kg dry air
+            h: Specific enthalpy in J/kg dry air
+            
+        Returns:
+            Dry-bulb temperature in °C
+        """
+        if w < 0:
+            raise ValueError("Humidity ratio cannot be negative")
+        if h < 0:
+            raise ValueError("Enthalpy cannot be negative")
+        
+        c_pa = 1006  # Specific heat of dry air in J/(kg·K)
+        h_fg = 2501000  # Latent heat of vaporization at 0°C in J/kg
+        c_pw = 1860  # Specific heat of water vapor in J/(kg·K)
+        
+        t_db = (h - w * h_fg) / (c_pa + w * c_pw)
+        
+        Psychrometrics.validate_inputs(t_db)
+        return t_db
+    
+    @staticmethod
+    def sensible_heat_ratio(q_sensible: float, q_total: float) -> float:
+        """
+        Calculate sensible heat ratio.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Section 1.5.
+        
+        Args:
+            q_sensible: Sensible heat load in W
+            q_total: Total heat load in W
+            
+        Returns:
+            Sensible heat ratio (0-1)
+        """
+        if q_total == 0:
+            return 1.0
+        if q_sensible < 0 or q_total < 0:
+            raise ValueError("Heat loads cannot be negative")
+        
+        return q_sensible / q_total
+    
+    @staticmethod
+    def air_flow_rate_for_load(q_sensible: float, t_supply: float, t_return: float, 
+                              rh_return: float = 50.0, p_atm: float = ATMOSPHERIC_PRESSURE) -> Dict[str, float]:
+        """
+        Calculate required air flow rate for a given sensible load.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Section 1.6.
+        
+        Args:
+            q_sensible: Sensible heat load in W
+            t_supply: Supply air temperature in °C
+            t_return: Return air temperature in °C
+            rh_return: Return air relative humidity in % (default: 50%)
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Dictionary with air flow rate in different units
+        """
+        Psychrometrics.validate_inputs(t_return, rh_return, p_atm)
+        Psychrometrics.validate_inputs(t_supply)
+        
+        # Calculate return air properties
+        w_return = Psychrometrics.humidity_ratio(t_return, rh_return, p_atm)
+        rho_return = Psychrometrics.density(t_return, w_return, p_atm)
+        
+        # Calculate specific heat of moist air
+        c_pa = 1006  # Specific heat of dry air in J/(kg·K)
+        c_pw = 1860  # Specific heat of water vapor in J/(kg·K)
+        c_p_moist = c_pa + w_return * c_pw
+        
+        # Calculate mass flow rate
+        delta_t = t_return - t_supply
+        if delta_t == 0:
+            raise ValueError("Supply and return temperatures cannot be equal")
+        
+        m_dot = q_sensible / (c_p_moist * delta_t)
+        
+        # Calculate volumetric flow rate
+        v_dot = m_dot / rho_return
+        
+        # Convert to different units
+        v_dot_m3_s = v_dot
+        v_dot_m3_h = v_dot * 3600
+        v_dot_cfm = v_dot * 2118.88
+        v_dot_l_s = v_dot * 1000
+        
+        return {
+            "mass_flow_rate_kg_s": m_dot,
+            "volumetric_flow_rate_m3_s": v_dot_m3_s,
+            "volumetric_flow_rate_m3_h": v_dot_m3_h,
+            "volumetric_flow_rate_cfm": v_dot_cfm,
+            "volumetric_flow_rate_l_s": v_dot_l_s
+        }
+    
+    @staticmethod
+    def mixing_air_properties(m1: float, t_db1: float, rh1: float, 
+                             m2: float, t_db2: float, rh2: float, 
+                             p_atm: float = ATMOSPHERIC_PRESSURE) -> Dict[str, float]:
+        """
+        Calculate properties of mixed airstreams.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 1, Section 1.7.
+        
+        Args:
+            m1: Mass flow rate of airstream 1 in kg/s
+            t_db1: Dry-bulb temperature of airstream 1 in °C
+            rh1: Relative humidity of airstream 1 in %
+            m2: Mass flow rate of airstream 2 in kg/s
+            t_db2: Dry-bulb temperature of airstream 2 in °C
+            rh2: Relative humidity of airstream 2 in %
+            p_atm: Atmospheric pressure in Pa (default: standard atmospheric pressure)
+            
+        Returns:
+            Dictionary with mixed air properties
+        """
+        Psychrometrics.validate_inputs(t_db1, rh1, p_atm)
+        Psychrometrics.validate_inputs(t_db2, rh2, p_atm)
+        if m1 < 0 or m2 < 0:
+            raise ValueError("Mass flow rates cannot be negative")
+        
+        # Calculate humidity ratios
+        w1 = Psychrometrics.humidity_ratio(t_db1, rh1, p_atm)
+        w2 = Psychrometrics.humidity_ratio(t_db2, rh2, p_atm)
+        
+        # Calculate enthalpies
+        h1 = Psychrometrics.enthalpy(t_db1, w1)
+        h2 = Psychrometrics.enthalpy(t_db2, w2)
+        
+        # Calculate mixed air properties
+        m_total = m1 + m2
+        
+        if m_total == 0:
+            raise ValueError("Total mass flow rate cannot be zero")
+        
+        w_mix = (m1 * w1 + m2 * w2) / m_total
+        h_mix = (m1 * h1 + m2 * h2) / m_total
+        
+        # Find dry-bulb temperature for the mixed air
+        t_db_mix = Psychrometrics.find_temperature_for_enthalpy(w_mix, h_mix)
+        
+        # Calculate relative humidity for the mixed air
+        rh_mix = Psychrometrics.relative_humidity(t_db_mix, w_mix, p_atm)
+        
+        # Return mixed air properties
+        return Psychrometrics.moist_air_properties(t_db_mix, rh_mix, p_atm)
+
+
+# Create a singleton instance
+psychrometrics = Psychrometrics()
+
+# Example usage
+if __name__ == "__main__":
+    # Calculate properties of air at 25°C and 50% RH
+    properties = psychrometrics.moist_air_properties(25, 50)
+    
+    print("Air Properties at 25°C and 50% RH:")
+    print(f"Dry-bulb temperature: {properties['dry_bulb_temperature']:.2f} °C")
+    print(f"Wet-bulb temperature: {properties['wet_bulb_temperature']:.2f} °C")
+    print(f"Dew point temperature: {properties['dew_point_temperature']:.2f} °C")
+    print(f"Relative humidity: {properties['relative_humidity']:.2f} %")
+    print(f"Humidity ratio: {properties['humidity_ratio']:.6f} kg/kg")
+    print(f"Enthalpy: {properties['enthalpy']/1000:.2f} kJ/kg")
+    print(f"Specific volume: {properties['specific_volume']:.4f} m³/kg")
+    print(f"Density: {properties['density']:.4f} kg/m³")
+    print(f"Saturation pressure: {properties['saturation_pressure']/1000:.2f} kPa")
+    print(f"Partial pressure: {properties['partial_pressure']/1000:.2f} kPa")

utils/scenario_comparison.py

@@ -0,0 +1,675 @@
+"""
+Scenario comparison visualization module for HVAC Load Calculator.
+This module provides visualization tools for comparing different scenarios.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple
+import math
+
+# Import calculation modules
+from utils.cooling_load import CoolingLoadCalculator
+from utils.heating_load import HeatingLoadCalculator
+
+
+class ScenarioComparisonVisualization:
+    """Class for scenario comparison visualization."""
+    
+    @staticmethod
+    def create_scenario_summary_table(scenarios: Dict[str, Dict[str, Any]]) -> pd.DataFrame:
+        """
+        Create a summary table of different scenarios.
+        
+        Args:
+            scenarios: Dictionary with scenario data
+            
+        Returns:
+            DataFrame with scenario summary
+        """
+        # Initialize data
+        data = []
+        
+        # Process scenarios
+        for scenario_name, scenario_data in scenarios.items():
+            # Extract cooling and heating loads
+            cooling_loads = scenario_data.get("cooling_loads", {})
+            heating_loads = scenario_data.get("heating_loads", {})
+            
+            # Create summary row
+            row = {
+                "Scenario": scenario_name,
+                "Cooling Load (W)": cooling_loads.get("total", 0),
+                "Sensible Heat Ratio": cooling_loads.get("sensible_heat_ratio", 0),
+                "Heating Load (W)": heating_loads.get("total", 0)
+            }
+            
+            # Add to data
+            data.append(row)
+        
+        # Create DataFrame
+        df = pd.DataFrame(data)
+        
+        return df
+    
+    @staticmethod
+    def create_load_comparison_chart(scenarios: Dict[str, Dict[str, Any]], load_type: str = "cooling") -> go.Figure:
+        """
+        Create a bar chart comparing loads across scenarios.
+        
+        Args:
+            scenarios: Dictionary with scenario data
+            load_type: Type of load to compare ("cooling" or "heating")
+            
+        Returns:
+            Plotly figure with load comparison
+        """
+        # Initialize data
+        scenario_names = []
+        total_loads = []
+        component_loads = {}
+        
+        # Process scenarios
+        for scenario_name, scenario_data in scenarios.items():
+            # Extract loads based on load type
+            if load_type == "cooling":
+                loads = scenario_data.get("cooling_loads", {})
+                components = ["walls", "roofs", "floors", "windows_conduction", "windows_solar", 
+                             "doors", "infiltration_sensible", "infiltration_latent", 
+                             "people_sensible", "people_latent", "lights", "equipment_sensible", "equipment_latent"]
+            else:  # heating
+                loads = scenario_data.get("heating_loads", {})
+                components = ["walls", "roofs", "floors", "windows", "doors", 
+                             "infiltration_sensible", "infiltration_latent", 
+                             "ventilation_sensible", "ventilation_latent"]
+            
+            # Add scenario name
+            scenario_names.append(scenario_name)
+            
+            # Add total load
+            total_loads.append(loads.get("total", 0))
+            
+            # Add component loads
+            for component in components:
+                if component not in component_loads:
+                    component_loads[component] = []
+                
+                component_loads[component].append(loads.get(component, 0))
+        
+        # Create figure
+        fig = go.Figure()
+        
+        # Add total load bars
+        fig.add_trace(go.Bar(
+            x=scenario_names,
+            y=total_loads,
+            name="Total Load",
+            marker_color="rgba(55, 83, 109, 0.7)",
+            opacity=0.7
+        ))
+        
+        # Add component load bars
+        for component, loads in component_loads.items():
+            # Skip components with zero loads
+            if sum(loads) == 0:
+                continue
+            
+            # Format component name for display
+            display_name = component.replace("_", " ").title()
+            
+            fig.add_trace(go.Bar(
+                x=scenario_names,
+                y=loads,
+                name=display_name,
+                visible="legendonly"
+            ))
+        
+        # Update layout
+        title = f"{load_type.title()} Load Comparison"
+        y_title = f"{load_type.title()} Load (W)"
+        
+        fig.update_layout(
+            title=title,
+            xaxis_title="Scenario",
+            yaxis_title=y_title,
+            barmode="group",
+            height=500,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_percentage_difference_chart(scenarios: Dict[str, Dict[str, Any]], 
+                                         baseline_scenario: str,
+                                         load_type: str = "cooling") -> go.Figure:
+        """
+        Create a bar chart showing percentage differences from a baseline scenario.
+        
+        Args:
+            scenarios: Dictionary with scenario data
+            baseline_scenario: Name of the baseline scenario
+            load_type: Type of load to compare ("cooling" or "heating")
+            
+        Returns:
+            Plotly figure with percentage difference chart
+        """
+        # Check if baseline scenario exists
+        if baseline_scenario not in scenarios:
+            raise ValueError(f"Baseline scenario '{baseline_scenario}' not found in scenarios")
+        
+        # Get baseline loads
+        if load_type == "cooling":
+            baseline_loads = scenarios[baseline_scenario].get("cooling_loads", {})
+            components = ["walls", "roofs", "floors", "windows_conduction", "windows_solar", 
+                         "doors", "infiltration_sensible", "infiltration_latent", 
+                         "people_sensible", "people_latent", "lights", "equipment_sensible", "equipment_latent"]
+        else:  # heating
+            baseline_loads = scenarios[baseline_scenario].get("heating_loads", {})
+            components = ["walls", "roofs", "floors", "windows", "doors", 
+                         "infiltration_sensible", "infiltration_latent", 
+                         "ventilation_sensible", "ventilation_latent"]
+        
+        baseline_total = baseline_loads.get("total", 0)
+        
+        # Initialize data
+        scenario_names = []
+        percentage_diffs = []
+        component_diffs = {}
+        
+        # Process scenarios (excluding baseline)
+        for scenario_name, scenario_data in scenarios.items():
+            if scenario_name == baseline_scenario:
+                continue
+            
+            # Extract loads based on load type
+            if load_type == "cooling":
+                loads = scenario_data.get("cooling_loads", {})
+            else:  # heating
+                loads = scenario_data.get("heating_loads", {})
+            
+            # Add scenario name
+            scenario_names.append(scenario_name)
+            
+            # Calculate percentage difference for total load
+            scenario_total = loads.get("total", 0)
+            if baseline_total != 0:
+                percentage_diff = (scenario_total - baseline_total) / baseline_total * 100
+            else:
+                percentage_diff = 0
+            
+            percentage_diffs.append(percentage_diff)
+            
+            # Calculate percentage differences for components
+            for component in components:
+                if component not in component_diffs:
+                    component_diffs[component] = []
+                
+                baseline_component = baseline_loads.get(component, 0)
+                scenario_component = loads.get(component, 0)
+                
+                if baseline_component != 0:
+                    component_diff = (scenario_component - baseline_component) / baseline_component * 100
+                else:
+                    component_diff = 0
+                
+                component_diffs[component].append(component_diff)
+        
+        # Create figure
+        fig = go.Figure()
+        
+        # Add total percentage difference bars
+        fig.add_trace(go.Bar(
+            x=scenario_names,
+            y=percentage_diffs,
+            name="Total Load",
+            marker_color="rgba(55, 83, 109, 0.7)",
+            opacity=0.7
+        ))
+        
+        # Add component percentage difference bars
+        for component, diffs in component_diffs.items():
+            # Skip components with zero differences
+            if sum([abs(diff) for diff in diffs]) == 0:
+                continue
+            
+            # Format component name for display
+            display_name = component.replace("_", " ").title()
+            
+            fig.add_trace(go.Bar(
+                x=scenario_names,
+                y=diffs,
+                name=display_name,
+                visible="legendonly"
+            ))
+        
+        # Update layout
+        title = f"{load_type.title()} Load Percentage Difference from {baseline_scenario}"
+        y_title = "Percentage Difference (%)"
+        
+        fig.update_layout(
+            title=title,
+            xaxis_title="Scenario",
+            yaxis_title=y_title,
+            barmode="group",
+            height=500,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
+        )
+        
+        # Add zero line
+        fig.add_shape(
+            type="line",
+            x0=-0.5,
+            x1=len(scenario_names) - 0.5,
+            y0=0,
+            y1=0,
+            line=dict(
+                color="black",
+                width=1,
+                dash="dash"
+            )
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_radar_chart(scenarios: Dict[str, Dict[str, Any]], load_type: str = "cooling") -> go.Figure:
+        """
+        Create a radar chart comparing key metrics across scenarios.
+        
+        Args:
+            scenarios: Dictionary with scenario data
+            load_type: Type of load to compare ("cooling" or "heating")
+            
+        Returns:
+            Plotly figure with radar chart
+        """
+        # Define metrics based on load type
+        if load_type == "cooling":
+            metrics = [
+                "total",
+                "total_sensible",
+                "total_latent",
+                "walls",
+                "roofs",
+                "windows_conduction",
+                "windows_solar",
+                "infiltration_sensible",
+                "people_sensible",
+                "lights",
+                "equipment_sensible"
+            ]
+            metric_names = [
+                "Total Load",
+                "Sensible Load",
+                "Latent Load",
+                "Walls",
+                "Roofs",
+                "Windows (Conduction)",
+                "Windows (Solar)",
+                "Infiltration",
+                "People",
+                "Lights",
+                "Equipment"
+            ]
+        else:  # heating
+            metrics = [
+                "total",
+                "walls",
+                "roofs",
+                "floors",
+                "windows",
+                "doors",
+                "infiltration_sensible",
+                "ventilation_sensible"
+            ]
+            metric_names = [
+                "Total Load",
+                "Walls",
+                "Roofs",
+                "Floors",
+                "Windows",
+                "Doors",
+                "Infiltration",
+                "Ventilation"
+            ]
+        
+        # Initialize figure
+        fig = go.Figure()
+        
+        # Process scenarios
+        for scenario_name, scenario_data in scenarios.items():
+            # Extract loads based on load type
+            if load_type == "cooling":
+                loads = scenario_data.get("cooling_loads", {})
+            else:  # heating
+                loads = scenario_data.get("heating_loads", {})
+            
+            # Extract metric values
+            values = [loads.get(metric, 0) for metric in metrics]
+            
+            # Add trace
+            fig.add_trace(go.Scatterpolar(
+                r=values,
+                theta=metric_names,
+                fill="toself",
+                name=scenario_name
+            ))
+        
+        # Update layout
+        title = f"{load_type.title()} Load Comparison (Radar Chart)"
+        
+        fig.update_layout(
+            title=title,
+            polar=dict(
+                radialaxis=dict(
+                    visible=True,
+                    range=[0, max([max([scenarios[s].get(f"{load_type}_loads", {}).get(m, 0) for m in metrics]) for s in scenarios]) * 1.1]
+                )
+            ),
+            height=600,
+            showlegend=True
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_parallel_coordinates_chart(scenarios: Dict[str, Dict[str, Any]]) -> go.Figure:
+        """
+        Create a parallel coordinates chart comparing scenarios.
+        
+        Args:
+            scenarios: Dictionary with scenario data
+            
+        Returns:
+            Plotly figure with parallel coordinates chart
+        """
+        # Initialize data
+        data = []
+        
+        # Process scenarios
+        for scenario_name, scenario_data in scenarios.items():
+            # Extract cooling and heating loads
+            cooling_loads = scenario_data.get("cooling_loads", {})
+            heating_loads = scenario_data.get("heating_loads", {})
+            
+            # Create data point
+            point = {
+                "Scenario": scenario_name,
+                "Cooling Load (W)": cooling_loads.get("total", 0),
+                "Heating Load (W)": heating_loads.get("total", 0),
+                "Sensible Heat Ratio": cooling_loads.get("sensible_heat_ratio", 0),
+                "Walls (Cooling)": cooling_loads.get("walls", 0),
+                "Windows (Cooling)": cooling_loads.get("windows_conduction", 0) + cooling_loads.get("windows_solar", 0),
+                "Internal Gains (Cooling)": cooling_loads.get("people_sensible", 0) + cooling_loads.get("lights", 0) + cooling_loads.get("equipment_sensible", 0),
+                "Walls (Heating)": heating_loads.get("walls", 0),
+                "Windows (Heating)": heating_loads.get("windows", 0),
+                "Infiltration (Heating)": heating_loads.get("infiltration_sensible", 0)
+            }
+            
+            # Add to data
+            data.append(point)
+        
+        # Create DataFrame
+        df = pd.DataFrame(data)
+        
+        # Create figure
+        fig = px.parallel_coordinates(
+            df,
+            color="Cooling Load (W)",
+            labels={
+                "Scenario": "Scenario",
+                "Cooling Load (W)": "Cooling Load (W)",
+                "Heating Load (W)": "Heating Load (W)",
+                "Sensible Heat Ratio": "Sensible Heat Ratio",
+                "Walls (Cooling)": "Walls (Cooling)",
+                "Windows (Cooling)": "Windows (Cooling)",
+                "Internal Gains (Cooling)": "Internal Gains (Cooling)",
+                "Walls (Heating)": "Walls (Heating)",
+                "Windows (Heating)": "Windows (Heating)",
+                "Infiltration (Heating)": "Infiltration (Heating)"
+            },
+            color_continuous_scale=px.colors.sequential.Viridis
+        )
+        
+        # Update layout
+        fig.update_layout(
+            title="Scenario Comparison (Parallel Coordinates)",
+            height=600
+        )
+        
+        return fig
+    
+    @staticmethod
+    def display_scenario_comparison(scenarios: Dict[str, Dict[str, Any]]) -> None:
+        """
+        Display scenario comparison visualization in Streamlit.
+        
+        Args:
+            scenarios: Dictionary with scenario data
+        """
+        st.header("Scenario Comparison Visualization")
+        
+        # Check if scenarios exist
+        if not scenarios:
+            st.warning("No scenarios available for comparison.")
+            return
+        
+        # Create tabs for different visualizations
+        tab1, tab2, tab3, tab4, tab5 = st.tabs([
+            "Scenario Summary", 
+            "Load Comparison", 
+            "Percentage Difference", 
+            "Radar Chart",
+            "Parallel Coordinates"
+        ])
+        
+        with tab1:
+            st.subheader("Scenario Summary")
+            df = ScenarioComparisonVisualization.create_scenario_summary_table(scenarios)
+            st.dataframe(df, use_container_width=True)
+            
+            # Add download button for CSV
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download Scenario Summary as CSV",
+                data=csv,
+                file_name="scenario_summary.csv",
+                mime="text/csv"
+            )
+        
+        with tab2:
+            st.subheader("Load Comparison")
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="load_comparison_type"
+            )
+            
+            # Create and display chart
+            fig = ScenarioComparisonVisualization.create_load_comparison_chart(scenarios, load_type)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tab3:
+            st.subheader("Percentage Difference")
+            
+            # Add baseline scenario selector
+            baseline_scenario = st.selectbox(
+                "Select Baseline Scenario",
+                list(scenarios.keys()),
+                key="baseline_scenario"
+            )
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="percentage_diff_type"
+            )
+            
+            # Create and display chart
+            try:
+                fig = ScenarioComparisonVisualization.create_percentage_difference_chart(
+                    scenarios, baseline_scenario, load_type
+                )
+                st.plotly_chart(fig, use_container_width=True)
+            except ValueError as e:
+                st.error(str(e))
+        
+        with tab4:
+            st.subheader("Radar Chart")
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="radar_chart_type"
+            )
+            
+            # Create and display chart
+            fig = ScenarioComparisonVisualization.create_radar_chart(scenarios, load_type)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tab5:
+            st.subheader("Parallel Coordinates")
+            
+            # Create and display chart
+            fig = ScenarioComparisonVisualization.create_parallel_coordinates_chart(scenarios)
+            st.plotly_chart(fig, use_container_width=True)
+
+
+# Create a singleton instance
+scenario_comparison = ScenarioComparisonVisualization()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Create sample scenarios
+    scenarios = {
+        "Base Case": {
+            "cooling_loads": {
+                "total": 5000,
+                "total_sensible": 4000,
+                "total_latent": 1000,
+                "sensible_heat_ratio": 0.8,
+                "walls": 1000,
+                "roofs": 800,
+                "floors": 200,
+                "windows_conduction": 500,
+                "windows_solar": 800,
+                "doors": 100,
+                "infiltration_sensible": 300,
+                "infiltration_latent": 200,
+                "people_sensible": 300,
+                "people_latent": 200,
+                "lights": 400,
+                "equipment_sensible": 400,
+                "equipment_latent": 600
+            },
+            "heating_loads": {
+                "total": 6000,
+                "walls": 1500,
+                "roofs": 1000,
+                "floors": 500,
+                "windows": 1200,
+                "doors": 200,
+                "infiltration_sensible": 800,
+                "infiltration_latent": 0,
+                "ventilation_sensible": 800,
+                "ventilation_latent": 0,
+                "internal_gains_offset": 1000
+            }
+        },
+        "Improved Insulation": {
+            "cooling_loads": {
+                "total": 4200,
+                "total_sensible": 3500,
+                "total_latent": 700,
+                "sensible_heat_ratio": 0.83,
+                "walls": 600,
+                "roofs": 500,
+                "floors": 150,
+                "windows_conduction": 500,
+                "windows_solar": 800,
+                "doors": 100,
+                "infiltration_sensible": 300,
+                "infiltration_latent": 200,
+                "people_sensible": 300,
+                "people_latent": 200,
+                "lights": 400,
+                "equipment_sensible": 400,
+                "equipment_latent": 300
+            },
+            "heating_loads": {
+                "total": 4500,
+                "walls": 900,
+                "roofs": 600,
+                "floors": 300,
+                "windows": 1200,
+                "doors": 200,
+                "infiltration_sensible": 800,
+                "infiltration_latent": 0,
+                "ventilation_sensible": 800,
+                "ventilation_latent": 0,
+                "internal_gains_offset": 1000
+            }
+        },
+        "Better Windows": {
+            "cooling_loads": {
+                "total": 4000,
+                "total_sensible": 3300,
+                "total_latent": 700,
+                "sensible_heat_ratio": 0.83,
+                "walls": 1000,
+                "roofs": 800,
+                "floors": 200,
+                "windows_conduction": 250,
+                "windows_solar": 400,
+                "doors": 100,
+                "infiltration_sensible": 300,
+                "infiltration_latent": 200,
+                "people_sensible": 300,
+                "people_latent": 200,
+                "lights": 400,
+                "equipment_sensible": 400,
+                "equipment_latent": 300
+            },
+            "heating_loads": {
+                "total": 5000,
+                "walls": 1500,
+                "roofs": 1000,
+                "floors": 500,
+                "windows": 600,
+                "doors": 200,
+                "infiltration_sensible": 800,
+                "infiltration_latent": 0,
+                "ventilation_sensible": 800,
+                "ventilation_latent": 0,
+                "internal_gains_offset": 1000
+            }
+        }
+    }
+    
+    # Display scenario comparison
+    scenario_comparison.display_scenario_comparison(scenarios)

utils/shading_system.py

@@ -0,0 +1,350 @@
+"""
+Shading system module for HVAC Load Calculator.
+This module implements shading type selection and coverage percentage interface.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import json
+from enum import Enum
+from dataclasses import dataclass
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+class ShadingType(Enum):
+    """Enumeration for shading types."""
+    NONE = "None"
+    INTERNAL = "Internal"
+    EXTERNAL = "External"
+    BETWEEN_GLASS = "Between-glass"
+
+
+@dataclass
+class ShadingDevice:
+    """Class representing a shading device."""
+    
+    id: str
+    name: str
+    shading_type: ShadingType
+    shading_coefficient: float  # 0-1 (1 = no shading)
+    coverage_percentage: float = 100.0  # 0-100%
+    description: str = ""
+    
+    def __post_init__(self):
+        """Validate shading device data after initialization."""
+        if self.shading_coefficient < 0 or self.shading_coefficient > 1:
+            raise ValueError("Shading coefficient must be between 0 and 1")
+        if self.coverage_percentage < 0 or self.coverage_percentage > 100:
+            raise ValueError("Coverage percentage must be between 0 and 100")
+    
+    @property
+    def effective_shading_coefficient(self) -> float:
+        """Calculate the effective shading coefficient considering coverage percentage."""
+        # If coverage is less than 100%, the effective coefficient is a weighted average
+        # between the device coefficient and 1.0 (no shading)
+        coverage_factor = self.coverage_percentage / 100.0
+        return self.shading_coefficient * coverage_factor + 1.0 * (1 - coverage_factor)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the shading device to a dictionary."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "shading_type": self.shading_type.value,
+            "shading_coefficient": self.shading_coefficient,
+            "coverage_percentage": self.coverage_percentage,
+            "description": self.description,
+            "effective_shading_coefficient": self.effective_shading_coefficient
+        }
+
+
+class ShadingSystem:
+    """Class for managing shading devices and calculations."""
+    
+    def __init__(self):
+        """Initialize shading system."""
+        self.shading_devices = {}
+        self.load_preset_devices()
+    
+    def load_preset_devices(self) -> None:
+        """Load preset shading devices."""
+        # Internal shading devices
+        self.shading_devices["preset_venetian_blinds"] = ShadingDevice(
+            id="preset_venetian_blinds",
+            name="Venetian Blinds",
+            shading_type=ShadingType.INTERNAL,
+            shading_coefficient=0.6,
+            description="Standard internal venetian blinds"
+        )
+        
+        self.shading_devices["preset_roller_shade"] = ShadingDevice(
+            id="preset_roller_shade",
+            name="Roller Shade",
+            shading_type=ShadingType.INTERNAL,
+            shading_coefficient=0.7,
+            description="Standard internal roller shade"
+        )
+        
+        self.shading_devices["preset_drapes_light"] = ShadingDevice(
+            id="preset_drapes_light",
+            name="Light Drapes",
+            shading_type=ShadingType.INTERNAL,
+            shading_coefficient=0.8,
+            description="Light-colored internal drapes"
+        )
+        
+        self.shading_devices["preset_drapes_dark"] = ShadingDevice(
+            id="preset_drapes_dark",
+            name="Dark Drapes",
+            shading_type=ShadingType.INTERNAL,
+            shading_coefficient=0.5,
+            description="Dark-colored internal drapes"
+        )
+        
+        # External shading devices
+        self.shading_devices["preset_overhang"] = ShadingDevice(
+            id="preset_overhang",
+            name="Overhang",
+            shading_type=ShadingType.EXTERNAL,
+            shading_coefficient=0.4,
+            description="External overhang"
+        )
+        
+        self.shading_devices["preset_louvers"] = ShadingDevice(
+            id="preset_louvers",
+            name="Louvers",
+            shading_type=ShadingType.EXTERNAL,
+            shading_coefficient=0.3,
+            description="External louvers"
+        )
+        
+        self.shading_devices["preset_exterior_screen"] = ShadingDevice(
+            id="preset_exterior_screen",
+            name="Exterior Screen",
+            shading_type=ShadingType.EXTERNAL,
+            shading_coefficient=0.5,
+            description="External screen"
+        )
+        
+        # Between-glass shading devices
+        self.shading_devices["preset_between_glass_blinds"] = ShadingDevice(
+            id="preset_between_glass_blinds",
+            name="Between-glass Blinds",
+            shading_type=ShadingType.BETWEEN_GLASS,
+            shading_coefficient=0.5,
+            description="Blinds between glass panes"
+        )
+    
+    def get_device(self, device_id: str) -> Optional[ShadingDevice]:
+        """
+        Get a shading device by ID.
+        
+        Args:
+            device_id: Device identifier
+            
+        Returns:
+            ShadingDevice object or None if not found
+        """
+        return self.shading_devices.get(device_id)
+    
+    def get_devices_by_type(self, shading_type: ShadingType) -> List[ShadingDevice]:
+        """
+        Get all shading devices of a specific type.
+        
+        Args:
+            shading_type: Shading type
+            
+        Returns:
+            List of ShadingDevice objects
+        """
+        return [device for device in self.shading_devices.values() 
+                if device.shading_type == shading_type]
+    
+    def get_preset_devices(self) -> List[ShadingDevice]:
+        """
+        Get all preset shading devices.
+        
+        Returns:
+            List of ShadingDevice objects
+        """
+        return [device for device_id, device in self.shading_devices.items() 
+                if device_id.startswith("preset_")]
+    
+    def get_custom_devices(self) -> List[ShadingDevice]:
+        """
+        Get all custom shading devices.
+        
+        Returns:
+            List of ShadingDevice objects
+        """
+        return [device for device_id, device in self.shading_devices.items() 
+                if device_id.startswith("custom_")]
+    
+    def add_device(self, name: str, shading_type: ShadingType, 
+                  shading_coefficient: float, coverage_percentage: float = 100.0,
+                  description: str = "") -> str:
+        """
+        Add a custom shading device.
+        
+        Args:
+            name: Device name
+            shading_type: Shading type
+            shading_coefficient: Shading coefficient (0-1)
+            coverage_percentage: Coverage percentage (0-100)
+            description: Device description
+            
+        Returns:
+            Device ID
+        """
+        import uuid
+        
+        device_id = f"custom_shading_{str(uuid.uuid4())[:8]}"
+        device = ShadingDevice(
+            id=device_id,
+            name=name,
+            shading_type=shading_type,
+            shading_coefficient=shading_coefficient,
+            coverage_percentage=coverage_percentage,
+            description=description
+        )
+        
+        self.shading_devices[device_id] = device
+        return device_id
+    
+    def update_device(self, device_id: str, name: str = None, 
+                     shading_coefficient: float = None, 
+                     coverage_percentage: float = None,
+                     description: str = None) -> bool:
+        """
+        Update a shading device.
+        
+        Args:
+            device_id: Device identifier
+            name: New device name (optional)
+            shading_coefficient: New shading coefficient (optional)
+            coverage_percentage: New coverage percentage (optional)
+            description: New device description (optional)
+            
+        Returns:
+            True if the device was updated, False otherwise
+        """
+        if device_id not in self.shading_devices:
+            return False
+        
+        # Don't allow updating preset devices
+        if device_id.startswith("preset_"):
+            return False
+        
+        device = self.shading_devices[device_id]
+        
+        if name is not None:
+            device.name = name
+        
+        if shading_coefficient is not None:
+            if shading_coefficient < 0 or shading_coefficient > 1:
+                return False
+            device.shading_coefficient = shading_coefficient
+        
+        if coverage_percentage is not None:
+            if coverage_percentage < 0 or coverage_percentage > 100:
+                return False
+            device.coverage_percentage = coverage_percentage
+        
+        if description is not None:
+            device.description = description
+        
+        return True
+    
+    def remove_device(self, device_id: str) -> bool:
+        """
+        Remove a shading device.
+        
+        Args:
+            device_id: Device identifier
+            
+        Returns:
+            True if the device was removed, False otherwise
+        """
+        if device_id not in self.shading_devices:
+            return False
+        
+        # Don't allow removing preset devices
+        if device_id.startswith("preset_"):
+            return False
+        
+        del self.shading_devices[device_id]
+        return True
+    
+    def calculate_effective_shgc(self, base_shgc: float, device_id: str) -> float:
+        """
+        Calculate the effective SHGC (Solar Heat Gain Coefficient) with shading.
+        
+        Args:
+            base_shgc: Base SHGC of the window
+            device_id: Shading device identifier
+            
+        Returns:
+            Effective SHGC with shading
+        """
+        if device_id not in self.shading_devices:
+            return base_shgc
+        
+        device = self.shading_devices[device_id]
+        return base_shgc * device.effective_shading_coefficient
+    
+    def export_to_json(self, file_path: str) -> None:
+        """
+        Export all shading devices to a JSON file.
+        
+        Args:
+            file_path: Path to the output JSON file
+        """
+        data = {device_id: device.to_dict() for device_id, device in self.shading_devices.items()}
+        
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4)
+    
+    def import_from_json(self, file_path: str) -> int:
+        """
+        Import shading devices from a JSON file.
+        
+        Args:
+            file_path: Path to the input JSON file
+            
+        Returns:
+            Number of devices imported
+        """
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        count = 0
+        for device_id, device_data in data.items():
+            try:
+                shading_type = ShadingType(device_data["shading_type"])
+                device = ShadingDevice(
+                    id=device_id,
+                    name=device_data["name"],
+                    shading_type=shading_type,
+                    shading_coefficient=device_data["shading_coefficient"],
+                    coverage_percentage=device_data.get("coverage_percentage", 100.0),
+                    description=device_data.get("description", "")
+                )
+                
+                self.shading_devices[device_id] = device
+                count += 1
+            except Exception as e:
+                print(f"Error importing shading device {device_id}: {e}")
+        
+        return count
+
+
+# Create a singleton instance
+shading_system = ShadingSystem()
+
+# Export shading system to JSON if needed
+if __name__ == "__main__":
+    shading_system.export_to_json(os.path.join(DATA_DIR, "data", "shading_system.json"))

utils/time_based_visualization.py

@@ -0,0 +1,745 @@
+"""
+Time-based visualization module for HVAC Load Calculator.
+This module provides visualization tools for time-based load analysis.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from typing import Dict, List, Any, Optional, Tuple
+import math
+import calendar
+from datetime import datetime, timedelta
+
+
+class TimeBasedVisualization:
+    """Class for time-based visualization."""
+    
+    @staticmethod
+    def create_hourly_load_profile(hourly_loads: Dict[str, List[float]], 
+                                  date: str = "Jul 15") -> go.Figure:
+        """
+        Create an hourly load profile chart.
+        
+        Args:
+            hourly_loads: Dictionary with hourly load data
+            date: Date for the profile (e.g., "Jul 15")
+            
+        Returns:
+            Plotly figure with hourly load profile
+        """
+        # Create hour labels
+        hours = list(range(24))
+        hour_labels = [f"{h}:00" for h in hours]
+        
+        # Create figure
+        fig = go.Figure()
+        
+        # Add total load trace
+        if "total" in hourly_loads:
+            fig.add_trace(go.Scatter(
+                x=hour_labels,
+                y=hourly_loads["total"],
+                mode="lines+markers",
+                name="Total Load",
+                line=dict(color="rgba(55, 83, 109, 1)", width=3),
+                marker=dict(size=8)
+            ))
+        
+        # Add component load traces
+        for component, loads in hourly_loads.items():
+            if component == "total":
+                continue
+            
+            # Format component name for display
+            display_name = component.replace("_", " ").title()
+            
+            fig.add_trace(go.Scatter(
+                x=hour_labels,
+                y=loads,
+                mode="lines+markers",
+                name=display_name,
+                marker=dict(size=6),
+                line=dict(width=2)
+            ))
+        
+        # Update layout
+        fig.update_layout(
+            title=f"Hourly Load Profile ({date})",
+            xaxis_title="Hour of Day",
+            yaxis_title="Load (W)",
+            height=500,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            ),
+            hovermode="x unified"
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_daily_load_profile(daily_loads: Dict[str, List[float]], 
+                                 month: str = "July") -> go.Figure:
+        """
+        Create a daily load profile chart for a month.
+        
+        Args:
+            daily_loads: Dictionary with daily load data
+            month: Month name
+            
+        Returns:
+            Plotly figure with daily load profile
+        """
+        # Get number of days in month
+        month_num = list(calendar.month_name).index(month)
+        year = datetime.now().year
+        num_days = calendar.monthrange(year, month_num)[1]
+        
+        # Create day labels
+        days = list(range(1, num_days + 1))
+        day_labels = [f"{d}" for d in days]
+        
+        # Create figure
+        fig = go.Figure()
+        
+        # Add total load trace
+        if "total" in daily_loads:
+            fig.add_trace(go.Scatter(
+                x=day_labels,
+                y=daily_loads["total"][:num_days],
+                mode="lines+markers",
+                name="Total Load",
+                line=dict(color="rgba(55, 83, 109, 1)", width=3),
+                marker=dict(size=8)
+            ))
+        
+        # Add component load traces
+        for component, loads in daily_loads.items():
+            if component == "total":
+                continue
+            
+            # Format component name for display
+            display_name = component.replace("_", " ").title()
+            
+            fig.add_trace(go.Scatter(
+                x=day_labels,
+                y=loads[:num_days],
+                mode="lines+markers",
+                name=display_name,
+                marker=dict(size=6),
+                line=dict(width=2)
+            ))
+        
+        # Update layout
+        fig.update_layout(
+            title=f"Daily Load Profile ({month})",
+            xaxis_title="Day of Month",
+            yaxis_title="Load (W)",
+            height=500,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            ),
+            hovermode="x unified"
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_monthly_load_comparison(monthly_loads: Dict[str, List[float]],
+                                      load_type: str = "cooling") -> go.Figure:
+        """
+        Create a monthly load comparison chart.
+        
+        Args:
+            monthly_loads: Dictionary with monthly load data
+            load_type: Type of load ("cooling" or "heating")
+            
+        Returns:
+            Plotly figure with monthly load comparison
+        """
+        # Create month labels
+        months = list(calendar.month_name)[1:]
+        
+        # Create figure
+        fig = go.Figure()
+        
+        # Add total load bars
+        if "total" in monthly_loads:
+            fig.add_trace(go.Bar(
+                x=months,
+                y=monthly_loads["total"],
+                name="Total Load",
+                marker_color="rgba(55, 83, 109, 0.7)",
+                opacity=0.7
+            ))
+        
+        # Add component load bars
+        for component, loads in monthly_loads.items():
+            if component == "total":
+                continue
+            
+            # Format component name for display
+            display_name = component.replace("_", " ").title()
+            
+            fig.add_trace(go.Bar(
+                x=months,
+                y=loads,
+                name=display_name,
+                visible="legendonly"
+            ))
+        
+        # Update layout
+        title = f"Monthly {load_type.title()} Load Comparison"
+        y_title = f"{load_type.title()} Load (kWh)"
+        
+        fig.update_layout(
+            title=title,
+            xaxis_title="Month",
+            yaxis_title=y_title,
+            height=500,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            ),
+            hovermode="x unified"
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_annual_load_distribution(annual_loads: Dict[str, float],
+                                       load_type: str = "cooling") -> go.Figure:
+        """
+        Create an annual load distribution pie chart.
+        
+        Args:
+            annual_loads: Dictionary with annual load data by component
+            load_type: Type of load ("cooling" or "heating")
+            
+        Returns:
+            Plotly figure with annual load distribution
+        """
+        # Extract components and values
+        components = []
+        values = []
+        
+        for component, load in annual_loads.items():
+            if component == "total":
+                continue
+            
+            # Format component name for display
+            display_name = component.replace("_", " ").title()
+            components.append(display_name)
+            values.append(load)
+        
+        # Create pie chart
+        fig = go.Figure(data=[go.Pie(
+            labels=components,
+            values=values,
+            hole=0.3,
+            textinfo="label+percent",
+            insidetextorientation="radial"
+        )])
+        
+        # Update layout
+        title = f"Annual {load_type.title()} Load Distribution"
+        
+        fig.update_layout(
+            title=title,
+            height=500,
+            legend=dict(
+                orientation="h",
+                yanchor="bottom",
+                y=1.02,
+                xanchor="right",
+                x=1
+            )
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_peak_load_analysis(peak_loads: Dict[str, Dict[str, Any]],
+                                 load_type: str = "cooling") -> go.Figure:
+        """
+        Create a peak load analysis chart.
+        
+        Args:
+            peak_loads: Dictionary with peak load data
+            load_type: Type of load ("cooling" or "heating")
+            
+        Returns:
+            Plotly figure with peak load analysis
+        """
+        # Extract peak load data
+        components = []
+        values = []
+        times = []
+        
+        for component, data in peak_loads.items():
+            if component == "total":
+                continue
+            
+            # Format component name for display
+            display_name = component.replace("_", " ").title()
+            components.append(display_name)
+            values.append(data["value"])
+            times.append(data["time"])
+        
+        # Create bar chart
+        fig = go.Figure(data=[go.Bar(
+            x=components,
+            y=values,
+            text=times,
+            textposition="auto",
+            hovertemplate="<b>%{x}</b><br>Peak Load: %{y:.0f} W<br>Time: %{text}<extra></extra>"
+        )])
+        
+        # Update layout
+        title = f"Peak {load_type.title()} Load Analysis"
+        y_title = f"Peak {load_type.title()} Load (W)"
+        
+        fig.update_layout(
+            title=title,
+            xaxis_title="Component",
+            yaxis_title=y_title,
+            height=500
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_load_duration_curve(hourly_loads: List[float],
+                                  load_type: str = "cooling") -> go.Figure:
+        """
+        Create a load duration curve.
+        
+        Args:
+            hourly_loads: List of hourly loads for the year
+            load_type: Type of load ("cooling" or "heating")
+            
+        Returns:
+            Plotly figure with load duration curve
+        """
+        # Sort loads in descending order
+        sorted_loads = sorted(hourly_loads, reverse=True)
+        
+        # Create hour indices
+        hours = list(range(1, len(sorted_loads) + 1))
+        
+        # Create figure
+        fig = go.Figure(data=[go.Scatter(
+            x=hours,
+            y=sorted_loads,
+            mode="lines",
+            line=dict(color="rgba(55, 83, 109, 1)", width=2),
+            fill="tozeroy",
+            fillcolor="rgba(55, 83, 109, 0.2)"
+        )])
+        
+        # Update layout
+        title = f"{load_type.title()} Load Duration Curve"
+        x_title = "Hours"
+        y_title = f"{load_type.title()} Load (W)"
+        
+        fig.update_layout(
+            title=title,
+            xaxis_title=x_title,
+            yaxis_title=y_title,
+            height=500,
+            xaxis=dict(
+                type="log",
+                range=[0, math.log10(len(hours))]
+            )
+        )
+        
+        return fig
+    
+    @staticmethod
+    def create_heat_map(hourly_data: List[List[float]],
+                       x_labels: List[str],
+                       y_labels: List[str],
+                       title: str,
+                       colorscale: str = "Viridis") -> go.Figure:
+        """
+        Create a heat map visualization.
+        
+        Args:
+            hourly_data: 2D list of hourly data
+            x_labels: Labels for x-axis
+            y_labels: Labels for y-axis
+            title: Chart title
+            colorscale: Colorscale for the heatmap
+            
+        Returns:
+            Plotly figure with heat map
+        """
+        # Create figure
+        fig = go.Figure(data=go.Heatmap(
+            z=hourly_data,
+            x=x_labels,
+            y=y_labels,
+            colorscale=colorscale,
+            colorbar=dict(title="Load (W)")
+        ))
+        
+        # Update layout
+        fig.update_layout(
+            title=title,
+            height=600,
+            xaxis=dict(
+                title="Hour of Day",
+                tickmode="array",
+                tickvals=list(range(0, 24, 2)),
+                ticktext=[f"{h}:00" for h in range(0, 24, 2)]
+            ),
+            yaxis=dict(
+                title="Day",
+                autorange="reversed"
+            )
+        )
+        
+        return fig
+    
+    @staticmethod
+    def display_time_based_visualization(cooling_loads: Dict[str, Any] = None,
+                                        heating_loads: Dict[str, Any] = None) -> None:
+        """
+        Display time-based visualization in Streamlit.
+        
+        Args:
+            cooling_loads: Dictionary with cooling load data
+            heating_loads: Dictionary with heating load data
+        """
+        st.header("Time-Based Visualization")
+        
+        # Check if load data exists
+        if cooling_loads is None and heating_loads is None:
+            st.warning("No load data available for visualization.")
+            
+            # Create sample data for demonstration
+            st.info("Using sample data for demonstration.")
+            
+            # Generate sample cooling loads
+            cooling_loads = {
+                "hourly": {
+                    "total": [1000 + 500 * math.sin(h * math.pi / 12) + 1000 * math.sin(h * math.pi / 6) for h in range(24)],
+                    "walls": [300 + 150 * math.sin(h * math.pi / 12) for h in range(24)],
+                    "roofs": [400 + 200 * math.sin(h * math.pi / 12) for h in range(24)],
+                    "windows": [500 + 300 * math.sin(h * math.pi / 6) for h in range(24)],
+                    "internal": [200 + 100 * math.sin(h * math.pi / 8) for h in range(24)]
+                },
+                "daily": {
+                    "total": [2000 + 1000 * math.sin(d * math.pi / 15) for d in range(1, 32)],
+                    "walls": [600 + 300 * math.sin(d * math.pi / 15) for d in range(1, 32)],
+                    "roofs": [800 + 400 * math.sin(d * math.pi / 15) for d in range(1, 32)],
+                    "windows": [1000 + 500 * math.sin(d * math.pi / 15) for d in range(1, 32)]
+                },
+                "monthly": {
+                    "total": [1000, 1200, 1500, 2000, 2500, 3000, 3500, 3200, 2800, 2000, 1500, 1200],
+                    "walls": [300, 350, 400, 500, 600, 700, 800, 750, 650, 500, 400, 350],
+                    "roofs": [400, 450, 500, 600, 700, 800, 900, 850, 750, 600, 500, 450],
+                    "windows": [500, 550, 600, 700, 800, 900, 1000, 950, 850, 700, 600, 550]
+                },
+                "annual": {
+                    "total": 25000,
+                    "walls": 6000,
+                    "roofs": 8000,
+                    "windows": 9000,
+                    "internal": 2000
+                },
+                "peak": {
+                    "total": {"value": 3500, "time": "Jul 15, 15:00"},
+                    "walls": {"value": 800, "time": "Jul 15, 16:00"},
+                    "roofs": {"value": 900, "time": "Jul 15, 14:00"},
+                    "windows": {"value": 1000, "time": "Jul 15, 15:00"},
+                    "internal": {"value": 200, "time": "Jul 15, 17:00"}
+                }
+            }
+            
+            # Generate sample heating loads
+            heating_loads = {
+                "hourly": {
+                    "total": [3000 - 1000 * math.sin(h * math.pi / 12) for h in range(24)],
+                    "walls": [900 - 300 * math.sin(h * math.pi / 12) for h in range(24)],
+                    "roofs": [1200 - 400 * math.sin(h * math.pi / 12) for h in range(24)],
+                    "windows": [1500 - 500 * math.sin(h * math.pi / 12) for h in range(24)]
+                },
+                "daily": {
+                    "total": [3000 - 1000 * math.sin(d * math.pi / 15) for d in range(1, 32)],
+                    "walls": [900 - 300 * math.sin(d * math.pi / 15) for d in range(1, 32)],
+                    "roofs": [1200 - 400 * math.sin(d * math.pi / 15) for d in range(1, 32)],
+                    "windows": [1500 - 500 * math.sin(d * math.pi / 15) for d in range(1, 32)]
+                },
+                "monthly": {
+                    "total": [3500, 3200, 2800, 2000, 1500, 1000, 800, 1000, 1500, 2000, 2800, 3500],
+                    "walls": [1050, 960, 840, 600, 450, 300, 240, 300, 450, 600, 840, 1050],
+                    "roofs": [1400, 1280, 1120, 800, 600, 400, 320, 400, 600, 800, 1120, 1400],
+                    "windows": [1750, 1600, 1400, 1000, 750, 500, 400, 500, 750, 1000, 1400, 1750]
+                },
+                "annual": {
+                    "total": 25000,
+                    "walls": 7500,
+                    "roofs": 10000,
+                    "windows": 12500,
+                    "infiltration": 5000
+                },
+                "peak": {
+                    "total": {"value": 3500, "time": "Jan 15, 06:00"},
+                    "walls": {"value": 1050, "time": "Jan 15, 06:00"},
+                    "roofs": {"value": 1400, "time": "Jan 15, 06:00"},
+                    "windows": {"value": 1750, "time": "Jan 15, 06:00"},
+                    "infiltration": {"value": 500, "time": "Jan 15, 06:00"}
+                }
+            }
+        
+        # Create tabs for different visualizations
+        tab1, tab2, tab3, tab4, tab5 = st.tabs([
+            "Hourly Profiles", 
+            "Monthly Comparison", 
+            "Annual Distribution", 
+            "Peak Load Analysis",
+            "Heat Maps"
+        ])
+        
+        with tab1:
+            st.subheader("Hourly Load Profiles")
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="hourly_profile_type"
+            )
+            
+            # Add date selector
+            date = st.selectbox(
+                "Select Date",
+                ["Jan 15", "Apr 15", "Jul 15", "Oct 15"],
+                index=2,
+                key="hourly_profile_date"
+            )
+            
+            # Get appropriate load data
+            if load_type == "cooling":
+                hourly_data = cooling_loads.get("hourly", {})
+            else:
+                hourly_data = heating_loads.get("hourly", {})
+            
+            # Create and display chart
+            fig = TimeBasedVisualization.create_hourly_load_profile(hourly_data, date)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Add daily profile option
+            st.subheader("Daily Load Profiles")
+            
+            # Add month selector
+            month = st.selectbox(
+                "Select Month",
+                list(calendar.month_name)[1:],
+                index=6,  # July
+                key="daily_profile_month"
+            )
+            
+            # Get appropriate load data
+            if load_type == "cooling":
+                daily_data = cooling_loads.get("daily", {})
+            else:
+                daily_data = heating_loads.get("daily", {})
+            
+            # Create and display chart
+            fig = TimeBasedVisualization.create_daily_load_profile(daily_data, month)
+            st.plotly_chart(fig, use_container_width=True)
+        
+        with tab2:
+            st.subheader("Monthly Load Comparison")
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="monthly_comparison_type"
+            )
+            
+            # Get appropriate load data
+            if load_type == "cooling":
+                monthly_data = cooling_loads.get("monthly", {})
+            else:
+                monthly_data = heating_loads.get("monthly", {})
+            
+            # Create and display chart
+            fig = TimeBasedVisualization.create_monthly_load_comparison(monthly_data, load_type)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Add download button for CSV
+            monthly_df = pd.DataFrame(monthly_data)
+            monthly_df.index = list(calendar.month_name)[1:]
+            
+            csv = monthly_df.to_csv().encode('utf-8')
+            st.download_button(
+                label=f"Download Monthly {load_type.title()} Loads as CSV",
+                data=csv,
+                file_name=f"monthly_{load_type}_loads.csv",
+                mime="text/csv"
+            )
+        
+        with tab3:
+            st.subheader("Annual Load Distribution")
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="annual_distribution_type"
+            )
+            
+            # Get appropriate load data
+            if load_type == "cooling":
+                annual_data = cooling_loads.get("annual", {})
+            else:
+                annual_data = heating_loads.get("annual", {})
+            
+            # Create and display chart
+            fig = TimeBasedVisualization.create_annual_load_distribution(annual_data, load_type)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Display annual total
+            total = annual_data.get("total", 0)
+            st.metric(f"Total Annual {load_type.title()} Load", f"{total:,.0f} kWh")
+            
+            # Add download button for CSV
+            annual_df = pd.DataFrame({"Component": list(annual_data.keys()), "Load (kWh)": list(annual_data.values())})
+            
+            csv = annual_df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label=f"Download Annual {load_type.title()} Loads as CSV",
+                data=csv,
+                file_name=f"annual_{load_type}_loads.csv",
+                mime="text/csv"
+            )
+        
+        with tab4:
+            st.subheader("Peak Load Analysis")
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="peak_load_type"
+            )
+            
+            # Get appropriate load data
+            if load_type == "cooling":
+                peak_data = cooling_loads.get("peak", {})
+            else:
+                peak_data = heating_loads.get("peak", {})
+            
+            # Create and display chart
+            fig = TimeBasedVisualization.create_peak_load_analysis(peak_data, load_type)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Display peak total
+            peak_total = peak_data.get("total", {}).get("value", 0)
+            peak_time = peak_data.get("total", {}).get("time", "")
+            
+            st.metric(f"Peak {load_type.title()} Load", f"{peak_total:,.0f} W")
+            st.write(f"Peak Time: {peak_time}")
+            
+            # Add download button for CSV
+            peak_df = pd.DataFrame({
+                "Component": list(peak_data.keys()),
+                "Peak Load (W)": [data.get("value", 0) for data in peak_data.values()],
+                "Time": [data.get("time", "") for data in peak_data.values()]
+            })
+            
+            csv = peak_df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label=f"Download Peak {load_type.title()} Loads as CSV",
+                data=csv,
+                file_name=f"peak_{load_type}_loads.csv",
+                mime="text/csv"
+            )
+        
+        with tab5:
+            st.subheader("Heat Maps")
+            
+            # Add load type selector
+            load_type = st.radio(
+                "Select Load Type",
+                ["cooling", "heating"],
+                horizontal=True,
+                key="heat_map_type"
+            )
+            
+            # Add month selector
+            month = st.selectbox(
+                "Select Month",
+                list(calendar.month_name)[1:],
+                index=6,  # July
+                key="heat_map_month"
+            )
+            
+            # Generate heat map data
+            month_num = list(calendar.month_name).index(month)
+            year = datetime.now().year
+            num_days = calendar.monthrange(year, month_num)[1]
+            
+            # Get appropriate hourly data
+            if load_type == "cooling":
+                hourly_data = cooling_loads.get("hourly", {}).get("total", [])
+            else:
+                hourly_data = heating_loads.get("hourly", {}).get("total", [])
+            
+            # Create 2D array for heat map
+            heat_map_data = []
+            for day in range(1, num_days + 1):
+                # Generate hourly data with day-to-day variation
+                day_factor = 1 + 0.2 * math.sin(day * math.pi / 15)
+                day_data = [load * day_factor for load in hourly_data]
+                heat_map_data.append(day_data)
+            
+            # Create hour and day labels
+            hour_labels = list(range(24))
+            day_labels = list(range(1, num_days + 1))
+            
+            # Create and display heat map
+            title = f"{load_type.title()} Load Heat Map ({month})"
+            colorscale = "Hot" if load_type == "cooling" else "Ice"
+            
+            fig = TimeBasedVisualization.create_heat_map(heat_map_data, hour_labels, day_labels, title, colorscale)
+            st.plotly_chart(fig, use_container_width=True)
+            
+            # Add explanation
+            st.info(
+                "The heat map shows the hourly load pattern for each day of the selected month. "
+                "Darker colors indicate higher loads. This visualization helps identify peak load periods "
+                "and daily/weekly patterns."
+            )
+
+
+# Create a singleton instance
+time_based_visualization = TimeBasedVisualization()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Display time-based visualization with sample data
+    time_based_visualization.display_time_based_visualization()

utils/u_value_calculator.py

@@ -0,0 +1,457 @@
+"""
+U-Value calculator module for HVAC Load Calculator.
+This module implements the layer-by-layer assembly builder and U-value calculation functions.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import json
+from dataclasses import dataclass, field
+
+# Import data models
+from data.building_components import MaterialLayer
+from data.reference_data import reference_data
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+@dataclass
+class MaterialAssembly:
+    """Class representing a material assembly for U-value calculation."""
+    
+    name: str
+    description: str = ""
+    layers: List[MaterialLayer] = field(default_factory=list)
+    
+    # Surface resistances (m²·K/W)
+    r_si: float = 0.13  # Interior surface resistance
+    r_se: float = 0.04  # Exterior surface resistance
+    
+    def add_layer(self, layer: MaterialLayer) -> None:
+        """
+        Add a material layer to the assembly.
+        
+        Args:
+            layer: MaterialLayer object
+        """
+        self.layers.append(layer)
+    
+    def remove_layer(self, index: int) -> bool:
+        """
+        Remove a material layer from the assembly.
+        
+        Args:
+            index: Index of the layer to remove
+            
+        Returns:
+            True if the layer was removed, False otherwise
+        """
+        if index < 0 or index >= len(self.layers):
+            return False
+        
+        self.layers.pop(index)
+        return True
+    
+    def move_layer(self, from_index: int, to_index: int) -> bool:
+        """
+        Move a material layer within the assembly.
+        
+        Args:
+            from_index: Current index of the layer
+            to_index: New index for the layer
+            
+        Returns:
+            True if the layer was moved, False otherwise
+        """
+        if (from_index < 0 or from_index >= len(self.layers) or
+            to_index < 0 or to_index >= len(self.layers)):
+            return False
+        
+        layer = self.layers.pop(from_index)
+        self.layers.insert(to_index, layer)
+        return True
+    
+    @property
+    def total_thickness(self) -> float:
+        """Calculate the total thickness of the assembly in meters."""
+        return sum(layer.thickness for layer in self.layers)
+    
+    @property
+    def r_value_layers(self) -> float:
+        """Calculate the total thermal resistance of all layers in m²·K/W."""
+        return sum(layer.r_value for layer in self.layers)
+    
+    @property
+    def r_value_total(self) -> float:
+        """Calculate the total thermal resistance including surface resistances in m²·K/W."""
+        return self.r_si + self.r_value_layers + self.r_se
+    
+    @property
+    def u_value(self) -> float:
+        """Calculate the U-value of the assembly in W/(m²·K)."""
+        if self.r_value_total == 0:
+            return float('inf')
+        return 1 / self.r_value_total
+    
+    @property
+    def thermal_mass(self) -> Optional[float]:
+        """Calculate the total thermal mass of the assembly in J/(m²·K)."""
+        masses = [layer.thermal_mass for layer in self.layers]
+        if None in masses:
+            return None
+        return sum(masses)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the material assembly to a dictionary."""
+        return {
+            "name": self.name,
+            "description": self.description,
+            "layers": [layer.to_dict() for layer in self.layers],
+            "r_si": self.r_si,
+            "r_se": self.r_se,
+            "total_thickness": self.total_thickness,
+            "r_value_layers": self.r_value_layers,
+            "r_value_total": self.r_value_total,
+            "u_value": self.u_value,
+            "thermal_mass": self.thermal_mass
+        }
+
+
+class UValueCalculator:
+    """Class for calculating U-values of material assemblies."""
+    
+    def __init__(self):
+        """Initialize U-value calculator."""
+        self.assemblies = {}
+        self.load_preset_assemblies()
+    
+    def load_preset_assemblies(self) -> None:
+        """Load preset material assemblies."""
+        # Create preset assemblies from reference data
+        
+        # Wall assemblies
+        for wall_id, wall_data in reference_data.wall_types.items():
+            # Create material layers
+            layers = []
+            for layer_data in wall_data.get("layers", []):
+                material_id = layer_data.get("material")
+                thickness = layer_data.get("thickness")
+                
+                material = reference_data.get_material(material_id)
+                if material:
+                    layer = MaterialLayer(
+                        name=material["name"],
+                        thickness=thickness,
+                        conductivity=material["conductivity"],
+                        density=material.get("density"),
+                        specific_heat=material.get("specific_heat")
+                    )
+                    layers.append(layer)
+            
+            # Create assembly
+            assembly_id = f"preset_wall_{wall_id}"
+            assembly = MaterialAssembly(
+                name=wall_data["name"],
+                description=wall_data["description"],
+                layers=layers
+            )
+            
+            self.assemblies[assembly_id] = assembly
+        
+        # Roof assemblies
+        for roof_id, roof_data in reference_data.roof_types.items():
+            # Create material layers
+            layers = []
+            for layer_data in roof_data.get("layers", []):
+                material_id = layer_data.get("material")
+                thickness = layer_data.get("thickness")
+                
+                material = reference_data.get_material(material_id)
+                if material:
+                    layer = MaterialLayer(
+                        name=material["name"],
+                        thickness=thickness,
+                        conductivity=material["conductivity"],
+                        density=material.get("density"),
+                        specific_heat=material.get("specific_heat")
+                    )
+                    layers.append(layer)
+            
+            # Create assembly
+            assembly_id = f"preset_roof_{roof_id}"
+            assembly = MaterialAssembly(
+                name=roof_data["name"],
+                description=roof_data["description"],
+                layers=layers
+            )
+            
+            self.assemblies[assembly_id] = assembly
+        
+        # Floor assemblies
+        for floor_id, floor_data in reference_data.floor_types.items():
+            # Create material layers
+            layers = []
+            for layer_data in floor_data.get("layers", []):
+                material_id = layer_data.get("material")
+                thickness = layer_data.get("thickness")
+                
+                material = reference_data.get_material(material_id)
+                if material:
+                    layer = MaterialLayer(
+                        name=material["name"],
+                        thickness=thickness,
+                        conductivity=material["conductivity"],
+                        density=material.get("density"),
+                        specific_heat=material.get("specific_heat")
+                    )
+                    layers.append(layer)
+            
+            # Create assembly
+            assembly_id = f"preset_floor_{floor_id}"
+            assembly = MaterialAssembly(
+                name=floor_data["name"],
+                description=floor_data["description"],
+                layers=layers
+            )
+            
+            self.assemblies[assembly_id] = assembly
+    
+    def get_assembly(self, assembly_id: str) -> Optional[MaterialAssembly]:
+        """
+        Get a material assembly by ID.
+        
+        Args:
+            assembly_id: Assembly identifier
+            
+        Returns:
+            MaterialAssembly object or None if not found
+        """
+        return self.assemblies.get(assembly_id)
+    
+    def get_preset_assemblies(self) -> Dict[str, MaterialAssembly]:
+        """
+        Get all preset material assemblies.
+        
+        Returns:
+            Dictionary of preset MaterialAssembly objects
+        """
+        return {assembly_id: assembly for assembly_id, assembly in self.assemblies.items()
+                if assembly_id.startswith("preset_")}
+    
+    def get_custom_assemblies(self) -> Dict[str, MaterialAssembly]:
+        """
+        Get all custom material assemblies.
+        
+        Returns:
+            Dictionary of custom MaterialAssembly objects
+        """
+        return {assembly_id: assembly for assembly_id, assembly in self.assemblies.items()
+                if assembly_id.startswith("custom_")}
+    
+    def create_assembly(self, name: str, description: str = "") -> str:
+        """
+        Create a new material assembly.
+        
+        Args:
+            name: Assembly name
+            description: Assembly description
+            
+        Returns:
+            Assembly ID
+        """
+        import uuid
+        
+        assembly_id = f"custom_assembly_{str(uuid.uuid4())[:8]}"
+        assembly = MaterialAssembly(name=name, description=description)
+        
+        self.assemblies[assembly_id] = assembly
+        return assembly_id
+    
+    def add_layer_to_assembly(self, assembly_id: str, material_id: str, thickness: float) -> bool:
+        """
+        Add a material layer to an assembly.
+        
+        Args:
+            assembly_id: Assembly identifier
+            material_id: Material identifier
+            thickness: Layer thickness in meters
+            
+        Returns:
+            True if the layer was added, False otherwise
+        """
+        if assembly_id not in self.assemblies:
+            return False
+        
+        material = reference_data.get_material(material_id)
+        if not material:
+            return False
+        
+        layer = MaterialLayer(
+            name=material["name"],
+            thickness=thickness,
+            conductivity=material["conductivity"],
+            density=material.get("density"),
+            specific_heat=material.get("specific_heat")
+        )
+        
+        self.assemblies[assembly_id].add_layer(layer)
+        return True
+    
+    def add_custom_layer_to_assembly(self, assembly_id: str, name: str, thickness: float,
+                                    conductivity: float, density: float = None,
+                                    specific_heat: float = None) -> bool:
+        """
+        Add a custom material layer to an assembly.
+        
+        Args:
+            assembly_id: Assembly identifier
+            name: Layer name
+            thickness: Layer thickness in meters
+            conductivity: Thermal conductivity in W/(m·K)
+            density: Density in kg/m³ (optional)
+            specific_heat: Specific heat capacity in J/(kg·K) (optional)
+            
+        Returns:
+            True if the layer was added, False otherwise
+        """
+        if assembly_id not in self.assemblies:
+            return False
+        
+        layer = MaterialLayer(
+            name=name,
+            thickness=thickness,
+            conductivity=conductivity,
+            density=density,
+            specific_heat=specific_heat
+        )
+        
+        self.assemblies[assembly_id].add_layer(layer)
+        return True
+    
+    def remove_layer_from_assembly(self, assembly_id: str, layer_index: int) -> bool:
+        """
+        Remove a material layer from an assembly.
+        
+        Args:
+            assembly_id: Assembly identifier
+            layer_index: Index of the layer to remove
+            
+        Returns:
+            True if the layer was removed, False otherwise
+        """
+        if assembly_id not in self.assemblies:
+            return False
+        
+        return self.assemblies[assembly_id].remove_layer(layer_index)
+    
+    def move_layer_in_assembly(self, assembly_id: str, from_index: int, to_index: int) -> bool:
+        """
+        Move a material layer within an assembly.
+        
+        Args:
+            assembly_id: Assembly identifier
+            from_index: Current index of the layer
+            to_index: New index for the layer
+            
+        Returns:
+            True if the layer was moved, False otherwise
+        """
+        if assembly_id not in self.assemblies:
+            return False
+        
+        return self.assemblies[assembly_id].move_layer(from_index, to_index)
+    
+    def calculate_u_value(self, assembly_id: str) -> Optional[float]:
+        """
+        Calculate the U-value of an assembly.
+        
+        Args:
+            assembly_id: Assembly identifier
+            
+        Returns:
+            U-value in W/(m²·K) or None if the assembly was not found
+        """
+        if assembly_id not in self.assemblies:
+            return None
+        
+        return self.assemblies[assembly_id].u_value
+    
+    def calculate_r_value(self, assembly_id: str) -> Optional[float]:
+        """
+        Calculate the R-value of an assembly.
+        
+        Args:
+            assembly_id: Assembly identifier
+            
+        Returns:
+            R-value in m²·K/W or None if the assembly was not found
+        """
+        if assembly_id not in self.assemblies:
+            return None
+        
+        return self.assemblies[assembly_id].r_value_total
+    
+    def export_to_json(self, file_path: str) -> None:
+        """
+        Export all assemblies to a JSON file.
+        
+        Args:
+            file_path: Path to the output JSON file
+        """
+        data = {assembly_id: assembly.to_dict() for assembly_id, assembly in self.assemblies.items()}
+        
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4)
+    
+    def import_from_json(self, file_path: str) -> int:
+        """
+        Import assemblies from a JSON file.
+        
+        Args:
+            file_path: Path to the input JSON file
+            
+        Returns:
+            Number of assemblies imported
+        """
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        count = 0
+        for assembly_id, assembly_data in data.items():
+            try:
+                # Create assembly
+                assembly = MaterialAssembly(
+                    name=assembly_data["name"],
+                    description=assembly_data.get("description", ""),
+                    r_si=assembly_data.get("r_si", 0.13),
+                    r_se=assembly_data.get("r_se", 0.04)
+                )
+                
+                # Add layers
+                for layer_data in assembly_data.get("layers", []):
+                    layer = MaterialLayer(
+                        name=layer_data["name"],
+                        thickness=layer_data["thickness"],
+                        conductivity=layer_data["conductivity"],
+                        density=layer_data.get("density"),
+                        specific_heat=layer_data.get("specific_heat")
+                    )
+                    assembly.add_layer(layer)
+                
+                self.assemblies[assembly_id] = assembly
+                count += 1
+            except Exception as e:
+                print(f"Error importing assembly {assembly_id}: {e}")
+        
+        return count
+
+
+# Create a singleton instance
+u_value_calculator = UValueCalculator()
+
+# Export U-value calculator to JSON if needed
+if __name__ == "__main__":
+    u_value_calculator.export_to_json(os.path.join(DATA_DIR, "data", "u_value_calculator.json"))