Upload 23 files

app/building_info_form.py

@@ -0,0 +1,332 @@
+"""
+Building information input form for HVAC Load Calculator.
+This module provides the UI components for entering building information.
+"""
+
+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 data models
+from data.building_components import Orientation, ComponentType
+
+
+class BuildingInfoForm:
+    """Class for building information input form."""
+    
+    @staticmethod
+    def display_building_info_form(session_state: Dict[str, Any]) -> None:
+        """
+        Display building information input form in Streamlit.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.header("Building Information")
+        
+        # Initialize building info in session state if not exists
+        if "building_info" not in session_state:
+            session_state["building_info"] = {
+                "project_name": "",
+                "building_name": "",
+                "location": "",
+                "climate_zone": "",
+                "building_type": "",
+                "floor_area": 0.0,
+                "num_floors": 1,
+                "floor_height": 3.0,
+                "orientation": "NORTH",
+                "occupancy": 0,
+                "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
+                }
+            }
+        
+        # Create form
+        with st.form("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 name of the project"
+                )
+                
+                session_state["building_info"]["building_name"] = st.text_input(
+                    "Building Name",
+                    value=session_state["building_info"]["building_name"],
+                    help="Enter the name of the building"
+                )
+            
+            with col2:
+                session_state["building_info"]["location"] = st.text_input(
+                    "Location",
+                    value=session_state["building_info"]["location"],
+                    help="Enter the location of the building (city, country)"
+                )
+                
+                session_state["building_info"]["climate_zone"] = st.selectbox(
+                    "Climate Zone",
+                    ["1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"],
+                    index=4 if session_state["building_info"]["climate_zone"] == "" else 
+                          ["1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"].index(session_state["building_info"]["climate_zone"]),
+                    help="Select the ASHRAE climate zone for the building location"
+                )
+            
+            st.subheader("Building Characteristics")
+            
+            col1, col2, col3 = st.columns(3)
+            
+            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 type of building"
+                )
+            
+            with col2:
+                session_state["building_info"]["floor_area"] = st.number_input(
+                    "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"
+                )
+            
+            with col3:
+                session_state["building_info"]["num_floors"] = st.number_input(
+                    "Number of Floors",
+                    min_value=1,
+                    value=int(session_state["building_info"]["num_floors"]),
+                    step=1,
+                    help="Enter the number of floors in the building"
+                )
+            
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                session_state["building_info"]["floor_height"] = st.number_input(
+                    "Floor Height (m)",
+                    min_value=2.0,
+                    max_value=10.0,
+                    value=float(session_state["building_info"]["floor_height"]),
+                    step=0.1,
+                    help="Enter the floor-to-floor height in meters"
+                )
+            
+            with col2:
+                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 orientation of the building's main facade"
+                )
+            
+            with col3:
+                session_state["building_info"]["occupancy"] = st.number_input(
+                    "Occupancy (people)",
+                    min_value=0,
+                    value=int(session_state["building_info"]["occupancy"]),
+                    step=1,
+                    help="Enter the total number of occupants"
+                )
+            
+            session_state["building_info"]["operating_hours"] = st.text_input(
+                "Operating Hours",
+                value=session_state["building_info"]["operating_hours"],
+                help="Enter the operating hours of the building (e.g., 8:00-18:00)"
+            )
+            
+            st.subheader("Design Conditions")
+            
+            st.write("Summer Design Conditions")
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                session_state["building_info"]["design_conditions"]["summer_outdoor_db"] = st.number_input(
+                    "Outdoor Dry-Bulb (°C)",
+                    min_value=-10.0,
+                    max_value=50.0,
+                    value=float(session_state["building_info"]["design_conditions"]["summer_outdoor_db"]),
+                    step=0.5,
+                    key="summer_outdoor_db",
+                    help="Enter the summer outdoor design dry-bulb temperature"
+                )
+            
+            with col2:
+                session_state["building_info"]["design_conditions"]["summer_outdoor_wb"] = st.number_input(
+                    "Outdoor Wet-Bulb (°C)",
+                    min_value=-10.0,
+                    max_value=40.0,
+                    value=float(session_state["building_info"]["design_conditions"]["summer_outdoor_wb"]),
+                    step=0.5,
+                    key="summer_outdoor_wb",
+                    help="Enter the summer outdoor design wet-bulb temperature"
+                )
+            
+            with col3:
+                session_state["building_info"]["design_conditions"]["summer_indoor_db"] = st.number_input(
+                    "Indoor Dry-Bulb (°C)",
+                    min_value=18.0,
+                    max_value=30.0,
+                    value=float(session_state["building_info"]["design_conditions"]["summer_indoor_db"]),
+                    step=0.5,
+                    key="summer_indoor_db",
+                    help="Enter the summer indoor design dry-bulb temperature"
+                )
+            
+            with col4:
+                session_state["building_info"]["design_conditions"]["summer_indoor_rh"] = st.number_input(
+                    "Indoor RH (%)",
+                    min_value=30.0,
+                    max_value=70.0,
+                    value=float(session_state["building_info"]["design_conditions"]["summer_indoor_rh"]),
+                    step=5.0,
+                    key="summer_indoor_rh",
+                    help="Enter the summer indoor design relative humidity"
+                )
+            
+            st.write("Winter Design Conditions")
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                session_state["building_info"]["design_conditions"]["winter_outdoor_db"] = st.number_input(
+                    "Outdoor Dry-Bulb (°C)",
+                    min_value=-40.0,
+                    max_value=20.0,
+                    value=float(session_state["building_info"]["design_conditions"]["winter_outdoor_db"]),
+                    step=0.5,
+                    key="winter_outdoor_db",
+                    help="Enter the winter outdoor design dry-bulb temperature"
+                )
+            
+            with col2:
+                session_state["building_info"]["design_conditions"]["winter_outdoor_rh"] = st.number_input(
+                    "Outdoor RH (%)",
+                    min_value=0.0,
+                    max_value=100.0,
+                    value=float(session_state["building_info"]["design_conditions"]["winter_outdoor_rh"]),
+                    step=5.0,
+                    key="winter_outdoor_rh",
+                    help="Enter the winter outdoor design relative humidity"
+                )
+            
+            with col3:
+                session_state["building_info"]["design_conditions"]["winter_indoor_db"] = st.number_input(
+                    "Indoor Dry-Bulb (°C)",
+                    min_value=18.0,
+                    max_value=25.0,
+                    value=float(session_state["building_info"]["design_conditions"]["winter_indoor_db"]),
+                    step=0.5,
+                    key="winter_indoor_db",
+                    help="Enter the winter indoor design dry-bulb temperature"
+                )
+            
+            with col4:
+                session_state["building_info"]["design_conditions"]["winter_indoor_rh"] = st.number_input(
+                    "Indoor RH (%)",
+                    min_value=20.0,
+                    max_value=60.0,
+                    value=float(session_state["building_info"]["design_conditions"]["winter_indoor_rh"]),
+                    step=5.0,
+                    key="winter_indoor_rh",
+                    help="Enter the winter indoor design relative humidity"
+                )
+            
+            # Submit button
+            submitted = st.form_submit_button("Save Building Information")
+            
+            if submitted:
+                st.success("Building information saved successfully!")
+                
+                # Save to file
+                BuildingInfoForm.save_building_info(session_state["building_info"])
+    
+    @staticmethod
+    def save_building_info(building_info: Dict[str, Any], file_path: str = "building_info.json") -> None:
+        """
+        Save building information to a JSON file.
+        
+        Args:
+            building_info: Dictionary with building information
+            file_path: Path to save the JSON file
+        """
+        try:
+            with open(file_path, "w") as f:
+                json.dump(building_info, f, indent=4)
+        except Exception as e:
+            st.error(f"Error saving building information: {e}")
+    
+    @staticmethod
+    def load_building_info(file_path: str = "building_info.json") -> Dict[str, Any]:
+        """
+        Load building information from a JSON file.
+        
+        Args:
+            file_path: Path to the JSON file
+            
+        Returns:
+            Dictionary with building information
+        """
+        if os.path.exists(file_path):
+            try:
+                with open(file_path, "r") as f:
+                    return json.load(f)
+            except Exception as e:
+                st.error(f"Error loading building information: {e}")
+        
+        # Return default building info if file doesn't exist or error occurs
+        return {
+            "project_name": "",
+            "building_name": "",
+            "location": "",
+            "climate_zone": "",
+            "building_type": "",
+            "floor_area": 0.0,
+            "num_floors": 1,
+            "floor_height": 3.0,
+            "orientation": "NORTH",
+            "occupancy": 0,
+            "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
+            }
+        }
+
+
+# Create a singleton instance
+building_info_form = BuildingInfoForm()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Initialize session state
+    if "building_info" not in st.session_state:
+        st.session_state["building_info"] = BuildingInfoForm.load_building_info()
+    
+    # Display building information form
+    building_info_form.display_building_info_form(st.session_state)

app/component_selection.py

@@ -0,0 +1,1674 @@
+"""
+Component selection interface for HVAC Load Calculator.
+This module provides the UI components for selecting building components.
+"""
+
+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 uuid
+
+# Import data models
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+from utils.component_library import ComponentLibrary
+from utils.u_value_calculator import UValueCalculator
+
+
+class ComponentSelectionInterface:
+    """Class for component selection interface."""
+    
+    def __init__(self):
+        """Initialize component selection interface."""
+        self.component_library = ComponentLibrary()
+        self.u_value_calculator = UValueCalculator()
+    
+    def display_component_selection(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display component selection interface in Streamlit.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.header("Building Components")
+        
+        # Initialize components in session state if not exists
+        if "components" not in session_state:
+            session_state["components"] = {
+                "walls": [],
+                "roofs": [],
+                "floors": [],
+                "windows": [],
+                "doors": []
+            }
+        
+        # Create tabs for different component types
+        tab1, tab2, tab3, tab4, tab5 = st.tabs([
+            "Walls", 
+            "Roofs", 
+            "Floors", 
+            "Windows",
+            "Doors"
+        ])
+        
+        with tab1:
+            self._display_wall_selection(session_state)
+        
+        with tab2:
+            self._display_roof_selection(session_state)
+        
+        with tab3:
+            self._display_floor_selection(session_state)
+        
+        with tab4:
+            self._display_window_selection(session_state)
+        
+        with tab5:
+            self._display_door_selection(session_state)
+    
+    def _display_wall_selection(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display wall selection interface.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.subheader("Wall Components")
+        
+        # Display existing walls
+        if session_state["components"]["walls"]:
+            st.write("Existing Walls:")
+            
+            # Create a DataFrame for display
+            wall_data = []
+            for i, wall in enumerate(session_state["components"]["walls"]):
+                wall_data.append({
+                    "ID": wall.id,
+                    "Name": wall.name,
+                    "Orientation": wall.orientation.name,
+                    "Area (m²)": wall.area,
+                    "U-Value (W/m²·K)": wall.u_value,
+                    "Wall Type": wall.wall_type,
+                    "Wall Group": wall.wall_group
+                })
+            
+            wall_df = pd.DataFrame(wall_data)
+            st.dataframe(wall_df, use_container_width=True)
+            
+            # Add edit and delete buttons
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                wall_to_edit = st.selectbox(
+                    "Select Wall to Edit",
+                    options=[f"#{i+1}: {wall.name}" for i, wall in enumerate(session_state["components"]["walls"])],
+                    key="wall_to_edit"
+                )
+                
+                if st.button("Edit Selected Wall", key="edit_wall_button"):
+                    # Get index of wall to edit
+                    wall_index = int(wall_to_edit.split(":")[0][1:]) - 1
+                    
+                    # Set edit flag and index
+                    session_state["edit_wall"] = True
+                    session_state["edit_wall_index"] = wall_index
+                    
+                    # Set form values from selected wall
+                    wall = session_state["components"]["walls"][wall_index]
+                    session_state["wall_name"] = wall.name
+                    session_state["wall_orientation"] = wall.orientation.name
+                    session_state["wall_area"] = wall.area
+                    session_state["wall_u_value"] = wall.u_value
+                    session_state["wall_type"] = wall.wall_type
+                    session_state["wall_group"] = wall.wall_group
+                    
+                    st.experimental_rerun()
+            
+            with col2:
+                wall_to_delete = st.selectbox(
+                    "Select Wall to Delete",
+                    options=[f"#{i+1}: {wall.name}" for i, wall in enumerate(session_state["components"]["walls"])],
+                    key="wall_to_delete"
+                )
+                
+                if st.button("Delete Selected Wall", key="delete_wall_button"):
+                    # Get index of wall to delete
+                    wall_index = int(wall_to_delete.split(":")[0][1:]) - 1
+                    
+                    # Remove wall from session state
+                    session_state["components"]["walls"].pop(wall_index)
+                    
+                    st.success(f"Wall {wall_to_delete} deleted successfully!")
+                    st.experimental_rerun()
+        
+        # Add new wall form
+        st.write("Add New Wall:")
+        
+        # Initialize edit flag if not exists
+        if "edit_wall" not in session_state:
+            session_state["edit_wall"] = False
+            session_state["edit_wall_index"] = -1
+        
+        # Initialize form values if not exists
+        if "wall_name" not in session_state:
+            session_state["wall_name"] = ""
+            session_state["wall_orientation"] = "NORTH"
+            session_state["wall_area"] = 0.0
+            session_state["wall_u_value"] = 0.5
+            session_state["wall_type"] = "Brick"
+            session_state["wall_group"] = "B"
+        
+        # Create form
+        with st.form("wall_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                wall_name = st.text_input(
+                    "Wall Name",
+                    value=session_state["wall_name"],
+                    key="wall_name_input",
+                    help="Enter a descriptive name for the wall"
+                )
+                
+                wall_orientation = st.selectbox(
+                    "Orientation",
+                    options=["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"],
+                    index=["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"].index(session_state["wall_orientation"]),
+                    key="wall_orientation_input",
+                    help="Select the orientation of the wall"
+                )
+                
+                wall_area = st.number_input(
+                    "Area (m²)",
+                    min_value=0.0,
+                    value=session_state["wall_area"],
+                    step=0.1,
+                    key="wall_area_input",
+                    help="Enter the area of the wall in square meters"
+                )
+            
+            with col2:
+                # Option to select from preset or custom
+                wall_selection_method = st.radio(
+                    "Wall Selection Method",
+                    options=["Select from Presets", "Custom U-Value"],
+                    key="wall_selection_method"
+                )
+                
+                if wall_selection_method == "Select from Presets":
+                    # Get preset wall types from component library
+                    preset_walls = self.component_library.get_preset_walls()
+                    wall_types = [wall["name"] for wall in preset_walls]
+                    
+                    wall_type = st.selectbox(
+                        "Wall Type",
+                        options=wall_types,
+                        index=wall_types.index(session_state["wall_type"]) if session_state["wall_type"] in wall_types else 0,
+                        key="wall_type_input",
+                        help="Select the type of wall construction"
+                    )
+                    
+                    # Get U-value from selected preset
+                    selected_wall = next((wall for wall in preset_walls if wall["name"] == wall_type), None)
+                    if selected_wall:
+                        wall_u_value = selected_wall["u_value"]
+                        wall_group = selected_wall["wall_group"]
+                    else:
+                        wall_u_value = session_state["wall_u_value"]
+                        wall_group = session_state["wall_group"]
+                    
+                    # Display U-value (read-only)
+                    st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=wall_u_value,
+                        step=0.01,
+                        key="wall_u_value_display",
+                        disabled=True,
+                        help="U-value of the selected wall type"
+                    )
+                    
+                    # Display wall group (read-only)
+                    st.text_input(
+                        "Wall Group",
+                        value=wall_group,
+                        key="wall_group_display",
+                        disabled=True,
+                        help="ASHRAE wall group for cooling load calculations"
+                    )
+                else:
+                    # Custom U-value input
+                    wall_u_value = st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=session_state["wall_u_value"],
+                        step=0.01,
+                        key="wall_u_value_input",
+                        help="Enter the U-value of the wall"
+                    )
+                    
+                    # Wall group selection
+                    wall_group = st.selectbox(
+                        "Wall Group",
+                        options=["A", "B", "C", "D", "E", "F", "G", "H"],
+                        index=["A", "B", "C", "D", "E", "F", "G", "H"].index(session_state["wall_group"]),
+                        key="wall_group_input",
+                        help="Select the ASHRAE wall group for cooling load calculations"
+                    )
+                    
+                    # Set wall type to "Custom"
+                    wall_type = "Custom"
+            
+            # Submit button
+            if session_state["edit_wall"]:
+                submit_label = "Update Wall"
+            else:
+                submit_label = "Add Wall"
+            
+            submitted = st.form_submit_button(submit_label)
+            
+            if submitted:
+                # Validate inputs
+                if not wall_name:
+                    st.error("Wall name is required!")
+                elif wall_area <= 0:
+                    st.error("Wall area must be greater than zero!")
+                elif wall_u_value <= 0:
+                    st.error("Wall U-value must be greater than zero!")
+                else:
+                    # Create wall object
+                    wall = Wall(
+                        id=str(uuid.uuid4()) if not session_state["edit_wall"] else session_state["components"]["walls"][session_state["edit_wall_index"]].id,
+                        name=wall_name,
+                        component_type=ComponentType.WALL,
+                        u_value=wall_u_value,
+                        area=wall_area,
+                        orientation=Orientation[wall_orientation],
+                        wall_type=wall_type,
+                        wall_group=wall_group
+                    )
+                    
+                    if session_state["edit_wall"]:
+                        # Update existing wall
+                        session_state["components"]["walls"][session_state["edit_wall_index"]] = wall
+                        st.success(f"Wall '{wall_name}' updated successfully!")
+                        
+                        # Reset edit flag
+                        session_state["edit_wall"] = False
+                        session_state["edit_wall_index"] = -1
+                    else:
+                        # Add new wall
+                        session_state["components"]["walls"].append(wall)
+                        st.success(f"Wall '{wall_name}' added successfully!")
+                    
+                    # Reset form values
+                    session_state["wall_name"] = ""
+                    session_state["wall_orientation"] = "NORTH"
+                    session_state["wall_area"] = 0.0
+                    session_state["wall_u_value"] = 0.5
+                    session_state["wall_type"] = "Brick"
+                    session_state["wall_group"] = "B"
+                    
+                    # Save components to file
+                    self.save_components(session_state["components"])
+                    
+                    st.experimental_rerun()
+        
+        # Add U-value calculator button
+        if st.button("Open U-Value Calculator", key="open_u_value_calc_wall"):
+            session_state["show_u_value_calculator"] = True
+            session_state["u_value_calc_component_type"] = "wall"
+            st.experimental_rerun()
+    
+    def _display_roof_selection(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display roof selection interface.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.subheader("Roof Components")
+        
+        # Display existing roofs
+        if session_state["components"]["roofs"]:
+            st.write("Existing Roofs:")
+            
+            # Create a DataFrame for display
+            roof_data = []
+            for i, roof in enumerate(session_state["components"]["roofs"]):
+                roof_data.append({
+                    "ID": roof.id,
+                    "Name": roof.name,
+                    "Orientation": roof.orientation.name,
+                    "Area (m²)": roof.area,
+                    "U-Value (W/m²·K)": roof.u_value,
+                    "Roof Type": roof.roof_type,
+                    "Roof Group": roof.roof_group
+                })
+            
+            roof_df = pd.DataFrame(roof_data)
+            st.dataframe(roof_df, use_container_width=True)
+            
+            # Add edit and delete buttons
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                roof_to_edit = st.selectbox(
+                    "Select Roof to Edit",
+                    options=[f"#{i+1}: {roof.name}" for i, roof in enumerate(session_state["components"]["roofs"])],
+                    key="roof_to_edit"
+                )
+                
+                if st.button("Edit Selected Roof", key="edit_roof_button"):
+                    # Get index of roof to edit
+                    roof_index = int(roof_to_edit.split(":")[0][1:]) - 1
+                    
+                    # Set edit flag and index
+                    session_state["edit_roof"] = True
+                    session_state["edit_roof_index"] = roof_index
+                    
+                    # Set form values from selected roof
+                    roof = session_state["components"]["roofs"][roof_index]
+                    session_state["roof_name"] = roof.name
+                    session_state["roof_orientation"] = roof.orientation.name
+                    session_state["roof_area"] = roof.area
+                    session_state["roof_u_value"] = roof.u_value
+                    session_state["roof_type"] = roof.roof_type
+                    session_state["roof_group"] = roof.roof_group
+                    
+                    st.experimental_rerun()
+            
+            with col2:
+                roof_to_delete = st.selectbox(
+                    "Select Roof to Delete",
+                    options=[f"#{i+1}: {roof.name}" for i, roof in enumerate(session_state["components"]["roofs"])],
+                    key="roof_to_delete"
+                )
+                
+                if st.button("Delete Selected Roof", key="delete_roof_button"):
+                    # Get index of roof to delete
+                    roof_index = int(roof_to_delete.split(":")[0][1:]) - 1
+                    
+                    # Remove roof from session state
+                    session_state["components"]["roofs"].pop(roof_index)
+                    
+                    st.success(f"Roof {roof_to_delete} deleted successfully!")
+                    st.experimental_rerun()
+        
+        # Add new roof form
+        st.write("Add New Roof:")
+        
+        # Initialize edit flag if not exists
+        if "edit_roof" not in session_state:
+            session_state["edit_roof"] = False
+            session_state["edit_roof_index"] = -1
+        
+        # Initialize form values if not exists
+        if "roof_name" not in session_state:
+            session_state["roof_name"] = ""
+            session_state["roof_orientation"] = "HORIZONTAL"
+            session_state["roof_area"] = 0.0
+            session_state["roof_u_value"] = 0.3
+            session_state["roof_type"] = "Concrete"
+            session_state["roof_group"] = "C"
+        
+        # Create form
+        with st.form("roof_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                roof_name = st.text_input(
+                    "Roof Name",
+                    value=session_state["roof_name"],
+                    key="roof_name_input",
+                    help="Enter a descriptive name for the roof"
+                )
+                
+                roof_orientation = st.selectbox(
+                    "Orientation",
+                    options=["HORIZONTAL", "NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"],
+                    index=["HORIZONTAL", "NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"].index(session_state["roof_orientation"]),
+                    key="roof_orientation_input",
+                    help="Select the orientation of the roof (HORIZONTAL for flat roofs)"
+                )
+                
+                roof_area = st.number_input(
+                    "Area (m²)",
+                    min_value=0.0,
+                    value=session_state["roof_area"],
+                    step=0.1,
+                    key="roof_area_input",
+                    help="Enter the area of the roof in square meters"
+                )
+            
+            with col2:
+                # Option to select from preset or custom
+                roof_selection_method = st.radio(
+                    "Roof Selection Method",
+                    options=["Select from Presets", "Custom U-Value"],
+                    key="roof_selection_method"
+                )
+                
+                if roof_selection_method == "Select from Presets":
+                    # Get preset roof types from component library
+                    preset_roofs = self.component_library.get_preset_roofs()
+                    roof_types = [roof["name"] for roof in preset_roofs]
+                    
+                    roof_type = st.selectbox(
+                        "Roof Type",
+                        options=roof_types,
+                        index=roof_types.index(session_state["roof_type"]) if session_state["roof_type"] in roof_types else 0,
+                        key="roof_type_input",
+                        help="Select the type of roof construction"
+                    )
+                    
+                    # Get U-value from selected preset
+                    selected_roof = next((roof for roof in preset_roofs if roof["name"] == roof_type), None)
+                    if selected_roof:
+                        roof_u_value = selected_roof["u_value"]
+                        roof_group = selected_roof["roof_group"]
+                    else:
+                        roof_u_value = session_state["roof_u_value"]
+                        roof_group = session_state["roof_group"]
+                    
+                    # Display U-value (read-only)
+                    st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=roof_u_value,
+                        step=0.01,
+                        key="roof_u_value_display",
+                        disabled=True,
+                        help="U-value of the selected roof type"
+                    )
+                    
+                    # Display roof group (read-only)
+                    st.text_input(
+                        "Roof Group",
+                        value=roof_group,
+                        key="roof_group_display",
+                        disabled=True,
+                        help="ASHRAE roof group for cooling load calculations"
+                    )
+                else:
+                    # Custom U-value input
+                    roof_u_value = st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=session_state["roof_u_value"],
+                        step=0.01,
+                        key="roof_u_value_input",
+                        help="Enter the U-value of the roof"
+                    )
+                    
+                    # Roof group selection
+                    roof_group = st.selectbox(
+                        "Roof Group",
+                        options=["A", "B", "C", "D", "E", "F", "G"],
+                        index=["A", "B", "C", "D", "E", "F", "G"].index(session_state["roof_group"]),
+                        key="roof_group_input",
+                        help="Select the ASHRAE roof group for cooling load calculations"
+                    )
+                    
+                    # Set roof type to "Custom"
+                    roof_type = "Custom"
+            
+            # Submit button
+            if session_state["edit_roof"]:
+                submit_label = "Update Roof"
+            else:
+                submit_label = "Add Roof"
+            
+            submitted = st.form_submit_button(submit_label)
+            
+            if submitted:
+                # Validate inputs
+                if not roof_name:
+                    st.error("Roof name is required!")
+                elif roof_area <= 0:
+                    st.error("Roof area must be greater than zero!")
+                elif roof_u_value <= 0:
+                    st.error("Roof U-value must be greater than zero!")
+                else:
+                    # Create roof object
+                    roof = Roof(
+                        id=str(uuid.uuid4()) if not session_state["edit_roof"] else session_state["components"]["roofs"][session_state["edit_roof_index"]].id,
+                        name=roof_name,
+                        component_type=ComponentType.ROOF,
+                        u_value=roof_u_value,
+                        area=roof_area,
+                        orientation=Orientation[roof_orientation],
+                        roof_type=roof_type,
+                        roof_group=roof_group
+                    )
+                    
+                    if session_state["edit_roof"]:
+                        # Update existing roof
+                        session_state["components"]["roofs"][session_state["edit_roof_index"]] = roof
+                        st.success(f"Roof '{roof_name}' updated successfully!")
+                        
+                        # Reset edit flag
+                        session_state["edit_roof"] = False
+                        session_state["edit_roof_index"] = -1
+                    else:
+                        # Add new roof
+                        session_state["components"]["roofs"].append(roof)
+                        st.success(f"Roof '{roof_name}' added successfully!")
+                    
+                    # Reset form values
+                    session_state["roof_name"] = ""
+                    session_state["roof_orientation"] = "HORIZONTAL"
+                    session_state["roof_area"] = 0.0
+                    session_state["roof_u_value"] = 0.3
+                    session_state["roof_type"] = "Concrete"
+                    session_state["roof_group"] = "C"
+                    
+                    # Save components to file
+                    self.save_components(session_state["components"])
+                    
+                    st.experimental_rerun()
+        
+        # Add U-value calculator button
+        if st.button("Open U-Value Calculator", key="open_u_value_calc_roof"):
+            session_state["show_u_value_calculator"] = True
+            session_state["u_value_calc_component_type"] = "roof"
+            st.experimental_rerun()
+    
+    def _display_floor_selection(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display floor selection interface.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.subheader("Floor Components")
+        
+        # Display existing floors
+        if session_state["components"]["floors"]:
+            st.write("Existing Floors:")
+            
+            # Create a DataFrame for display
+            floor_data = []
+            for i, floor in enumerate(session_state["components"]["floors"]):
+                floor_data.append({
+                    "ID": floor.id,
+                    "Name": floor.name,
+                    "Area (m²)": floor.area,
+                    "U-Value (W/m²·K)": floor.u_value,
+                    "Floor Type": floor.floor_type
+                })
+            
+            floor_df = pd.DataFrame(floor_data)
+            st.dataframe(floor_df, use_container_width=True)
+            
+            # Add edit and delete buttons
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                floor_to_edit = st.selectbox(
+                    "Select Floor to Edit",
+                    options=[f"#{i+1}: {floor.name}" for i, floor in enumerate(session_state["components"]["floors"])],
+                    key="floor_to_edit"
+                )
+                
+                if st.button("Edit Selected Floor", key="edit_floor_button"):
+                    # Get index of floor to edit
+                    floor_index = int(floor_to_edit.split(":")[0][1:]) - 1
+                    
+                    # Set edit flag and index
+                    session_state["edit_floor"] = True
+                    session_state["edit_floor_index"] = floor_index
+                    
+                    # Set form values from selected floor
+                    floor = session_state["components"]["floors"][floor_index]
+                    session_state["floor_name"] = floor.name
+                    session_state["floor_area"] = floor.area
+                    session_state["floor_u_value"] = floor.u_value
+                    session_state["floor_type"] = floor.floor_type
+                    
+                    st.experimental_rerun()
+            
+            with col2:
+                floor_to_delete = st.selectbox(
+                    "Select Floor to Delete",
+                    options=[f"#{i+1}: {floor.name}" for i, floor in enumerate(session_state["components"]["floors"])],
+                    key="floor_to_delete"
+                )
+                
+                if st.button("Delete Selected Floor", key="delete_floor_button"):
+                    # Get index of floor to delete
+                    floor_index = int(floor_to_delete.split(":")[0][1:]) - 1
+                    
+                    # Remove floor from session state
+                    session_state["components"]["floors"].pop(floor_index)
+                    
+                    st.success(f"Floor {floor_to_delete} deleted successfully!")
+                    st.experimental_rerun()
+        
+        # Add new floor form
+        st.write("Add New Floor:")
+        
+        # Initialize edit flag if not exists
+        if "edit_floor" not in session_state:
+            session_state["edit_floor"] = False
+            session_state["edit_floor_index"] = -1
+        
+        # Initialize form values if not exists
+        if "floor_name" not in session_state:
+            session_state["floor_name"] = ""
+            session_state["floor_area"] = 0.0
+            session_state["floor_u_value"] = 0.4
+            session_state["floor_type"] = "Concrete"
+        
+        # Create form
+        with st.form("floor_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                floor_name = st.text_input(
+                    "Floor Name",
+                    value=session_state["floor_name"],
+                    key="floor_name_input",
+                    help="Enter a descriptive name for the floor"
+                )
+                
+                floor_area = st.number_input(
+                    "Area (m²)",
+                    min_value=0.0,
+                    value=session_state["floor_area"],
+                    step=0.1,
+                    key="floor_area_input",
+                    help="Enter the area of the floor in square meters"
+                )
+            
+            with col2:
+                # Option to select from preset or custom
+                floor_selection_method = st.radio(
+                    "Floor Selection Method",
+                    options=["Select from Presets", "Custom U-Value"],
+                    key="floor_selection_method"
+                )
+                
+                if floor_selection_method == "Select from Presets":
+                    # Get preset floor types from component library
+                    preset_floors = self.component_library.get_preset_floors()
+                    floor_types = [floor["name"] for floor in preset_floors]
+                    
+                    floor_type = st.selectbox(
+                        "Floor Type",
+                        options=floor_types,
+                        index=floor_types.index(session_state["floor_type"]) if session_state["floor_type"] in floor_types else 0,
+                        key="floor_type_input",
+                        help="Select the type of floor construction"
+                    )
+                    
+                    # Get U-value from selected preset
+                    selected_floor = next((floor for floor in preset_floors if floor["name"] == floor_type), None)
+                    if selected_floor:
+                        floor_u_value = selected_floor["u_value"]
+                    else:
+                        floor_u_value = session_state["floor_u_value"]
+                    
+                    # Display U-value (read-only)
+                    st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=floor_u_value,
+                        step=0.01,
+                        key="floor_u_value_display",
+                        disabled=True,
+                        help="U-value of the selected floor type"
+                    )
+                else:
+                    # Custom U-value input
+                    floor_u_value = st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=session_state["floor_u_value"],
+                        step=0.01,
+                        key="floor_u_value_input",
+                        help="Enter the U-value of the floor"
+                    )
+                    
+                    # Set floor type to "Custom"
+                    floor_type = "Custom"
+            
+            # Submit button
+            if session_state["edit_floor"]:
+                submit_label = "Update Floor"
+            else:
+                submit_label = "Add Floor"
+            
+            submitted = st.form_submit_button(submit_label)
+            
+            if submitted:
+                # Validate inputs
+                if not floor_name:
+                    st.error("Floor name is required!")
+                elif floor_area <= 0:
+                    st.error("Floor area must be greater than zero!")
+                elif floor_u_value <= 0:
+                    st.error("Floor U-value must be greater than zero!")
+                else:
+                    # Create floor object
+                    floor = Floor(
+                        id=str(uuid.uuid4()) if not session_state["edit_floor"] else session_state["components"]["floors"][session_state["edit_floor_index"]].id,
+                        name=floor_name,
+                        component_type=ComponentType.FLOOR,
+                        u_value=floor_u_value,
+                        area=floor_area,
+                        floor_type=floor_type
+                    )
+                    
+                    if session_state["edit_floor"]:
+                        # Update existing floor
+                        session_state["components"]["floors"][session_state["edit_floor_index"]] = floor
+                        st.success(f"Floor '{floor_name}' updated successfully!")
+                        
+                        # Reset edit flag
+                        session_state["edit_floor"] = False
+                        session_state["edit_floor_index"] = -1
+                    else:
+                        # Add new floor
+                        session_state["components"]["floors"].append(floor)
+                        st.success(f"Floor '{floor_name}' added successfully!")
+                    
+                    # Reset form values
+                    session_state["floor_name"] = ""
+                    session_state["floor_area"] = 0.0
+                    session_state["floor_u_value"] = 0.4
+                    session_state["floor_type"] = "Concrete"
+                    
+                    # Save components to file
+                    self.save_components(session_state["components"])
+                    
+                    st.experimental_rerun()
+        
+        # Add U-value calculator button
+        if st.button("Open U-Value Calculator", key="open_u_value_calc_floor"):
+            session_state["show_u_value_calculator"] = True
+            session_state["u_value_calc_component_type"] = "floor"
+            st.experimental_rerun()
+    
+    def _display_window_selection(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display window selection interface.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.subheader("Window Components")
+        
+        # Display existing windows
+        if session_state["components"]["windows"]:
+            st.write("Existing Windows:")
+            
+            # Create a DataFrame for display
+            window_data = []
+            for i, window in enumerate(session_state["components"]["windows"]):
+                window_data.append({
+                    "ID": window.id,
+                    "Name": window.name,
+                    "Orientation": window.orientation.name,
+                    "Area (m²)": window.area,
+                    "U-Value (W/m²·K)": window.u_value,
+                    "SHGC": window.shgc,
+                    "Window Type": window.window_type
+                })
+            
+            window_df = pd.DataFrame(window_data)
+            st.dataframe(window_df, use_container_width=True)
+            
+            # Add edit and delete buttons
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                window_to_edit = st.selectbox(
+                    "Select Window to Edit",
+                    options=[f"#{i+1}: {window.name}" for i, window in enumerate(session_state["components"]["windows"])],
+                    key="window_to_edit"
+                )
+                
+                if st.button("Edit Selected Window", key="edit_window_button"):
+                    # Get index of window to edit
+                    window_index = int(window_to_edit.split(":")[0][1:]) - 1
+                    
+                    # Set edit flag and index
+                    session_state["edit_window"] = True
+                    session_state["edit_window_index"] = window_index
+                    
+                    # Set form values from selected window
+                    window = session_state["components"]["windows"][window_index]
+                    session_state["window_name"] = window.name
+                    session_state["window_orientation"] = window.orientation.name
+                    session_state["window_area"] = window.area
+                    session_state["window_u_value"] = window.u_value
+                    session_state["window_shgc"] = window.shgc
+                    session_state["window_vt"] = window.vt
+                    session_state["window_type"] = window.window_type
+                    session_state["window_glazing_layers"] = window.glazing_layers
+                    session_state["window_gas_fill"] = window.gas_fill
+                    session_state["window_low_e_coating"] = window.low_e_coating
+                    
+                    st.experimental_rerun()
+            
+            with col2:
+                window_to_delete = st.selectbox(
+                    "Select Window to Delete",
+                    options=[f"#{i+1}: {window.name}" for i, window in enumerate(session_state["components"]["windows"])],
+                    key="window_to_delete"
+                )
+                
+                if st.button("Delete Selected Window", key="delete_window_button"):
+                    # Get index of window to delete
+                    window_index = int(window_to_delete.split(":")[0][1:]) - 1
+                    
+                    # Remove window from session state
+                    session_state["components"]["windows"].pop(window_index)
+                    
+                    st.success(f"Window {window_to_delete} deleted successfully!")
+                    st.experimental_rerun()
+        
+        # Add new window form
+        st.write("Add New Window:")
+        
+        # Initialize edit flag if not exists
+        if "edit_window" not in session_state:
+            session_state["edit_window"] = False
+            session_state["edit_window_index"] = -1
+        
+        # Initialize form values if not exists
+        if "window_name" not in session_state:
+            session_state["window_name"] = ""
+            session_state["window_orientation"] = "NORTH"
+            session_state["window_area"] = 0.0
+            session_state["window_u_value"] = 2.8
+            session_state["window_shgc"] = 0.7
+            session_state["window_vt"] = 0.8
+            session_state["window_type"] = "Double Glazed"
+            session_state["window_glazing_layers"] = 2
+            session_state["window_gas_fill"] = "Air"
+            session_state["window_low_e_coating"] = False
+        
+        # Create form
+        with st.form("window_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                window_name = st.text_input(
+                    "Window Name",
+                    value=session_state["window_name"],
+                    key="window_name_input",
+                    help="Enter a descriptive name for the window"
+                )
+                
+                window_orientation = st.selectbox(
+                    "Orientation",
+                    options=["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"],
+                    index=["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"].index(session_state["window_orientation"]),
+                    key="window_orientation_input",
+                    help="Select the orientation of the window"
+                )
+                
+                window_area = st.number_input(
+                    "Area (m²)",
+                    min_value=0.0,
+                    value=session_state["window_area"],
+                    step=0.1,
+                    key="window_area_input",
+                    help="Enter the area of the window in square meters"
+                )
+            
+            with col2:
+                # Option to select from preset or custom
+                window_selection_method = st.radio(
+                    "Window Selection Method",
+                    options=["Select from Presets", "Custom Properties"],
+                    key="window_selection_method"
+                )
+                
+                if window_selection_method == "Select from Presets":
+                    # Get preset window types from component library
+                    preset_windows = self.component_library.get_preset_windows()
+                    window_types = [window["name"] for window in preset_windows]
+                    
+                    window_type = st.selectbox(
+                        "Window Type",
+                        options=window_types,
+                        index=window_types.index(session_state["window_type"]) if session_state["window_type"] in window_types else 0,
+                        key="window_type_input",
+                        help="Select the type of window"
+                    )
+                    
+                    # Get properties from selected preset
+                    selected_window = next((window for window in preset_windows if window["name"] == window_type), None)
+                    if selected_window:
+                        window_u_value = selected_window["u_value"]
+                        window_shgc = selected_window["shgc"]
+                        window_vt = selected_window["vt"]
+                        window_glazing_layers = selected_window["glazing_layers"]
+                        window_gas_fill = selected_window["gas_fill"]
+                        window_low_e_coating = selected_window["low_e_coating"]
+                    else:
+                        window_u_value = session_state["window_u_value"]
+                        window_shgc = session_state["window_shgc"]
+                        window_vt = session_state["window_vt"]
+                        window_glazing_layers = session_state["window_glazing_layers"]
+                        window_gas_fill = session_state["window_gas_fill"]
+                        window_low_e_coating = session_state["window_low_e_coating"]
+                    
+                    # Display properties (read-only)
+                    st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=window_u_value,
+                        step=0.01,
+                        key="window_u_value_display",
+                        disabled=True,
+                        help="U-value of the selected window type"
+                    )
+                    
+                    st.number_input(
+                        "SHGC",
+                        min_value=0.0,
+                        max_value=1.0,
+                        value=window_shgc,
+                        step=0.01,
+                        key="window_shgc_display",
+                        disabled=True,
+                        help="Solar Heat Gain Coefficient of the selected window type"
+                    )
+                else:
+                    # Custom properties input
+                    window_u_value = st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=session_state["window_u_value"],
+                        step=0.01,
+                        key="window_u_value_input",
+                        help="Enter the U-value of the window"
+                    )
+                    
+                    window_shgc = st.number_input(
+                        "SHGC",
+                        min_value=0.0,
+                        max_value=1.0,
+                        value=session_state["window_shgc"],
+                        step=0.01,
+                        key="window_shgc_input",
+                        help="Enter the Solar Heat Gain Coefficient of the window"
+                    )
+                    
+                    window_vt = st.number_input(
+                        "Visible Transmittance",
+                        min_value=0.0,
+                        max_value=1.0,
+                        value=session_state["window_vt"],
+                        step=0.01,
+                        key="window_vt_input",
+                        help="Enter the Visible Transmittance of the window"
+                    )
+                    
+                    window_glazing_layers = st.selectbox(
+                        "Glazing Layers",
+                        options=[1, 2, 3],
+                        index=[1, 2, 3].index(session_state["window_glazing_layers"]),
+                        key="window_glazing_layers_input",
+                        help="Select the number of glazing layers"
+                    )
+                    
+                    window_gas_fill = st.selectbox(
+                        "Gas Fill",
+                        options=["Air", "Argon", "Krypton"],
+                        index=["Air", "Argon", "Krypton"].index(session_state["window_gas_fill"]),
+                        key="window_gas_fill_input",
+                        help="Select the gas fill between glazing layers"
+                    )
+                    
+                    window_low_e_coating = st.checkbox(
+                        "Low-E Coating",
+                        value=session_state["window_low_e_coating"],
+                        key="window_low_e_coating_input",
+                        help="Check if the window has low-emissivity coating"
+                    )
+                    
+                    # Set window type to "Custom"
+                    window_type = "Custom"
+            
+            # Submit button
+            if session_state["edit_window"]:
+                submit_label = "Update Window"
+            else:
+                submit_label = "Add Window"
+            
+            submitted = st.form_submit_button(submit_label)
+            
+            if submitted:
+                # Validate inputs
+                if not window_name:
+                    st.error("Window name is required!")
+                elif window_area <= 0:
+                    st.error("Window area must be greater than zero!")
+                elif window_u_value <= 0:
+                    st.error("Window U-value must be greater than zero!")
+                elif window_shgc <= 0 or window_shgc > 1:
+                    st.error("Window SHGC must be between 0 and 1!")
+                else:
+                    # Create window object
+                    window = Window(
+                        id=str(uuid.uuid4()) if not session_state["edit_window"] else session_state["components"]["windows"][session_state["edit_window_index"]].id,
+                        name=window_name,
+                        component_type=ComponentType.WINDOW,
+                        u_value=window_u_value,
+                        area=window_area,
+                        orientation=Orientation[window_orientation],
+                        shgc=window_shgc,
+                        vt=window_vt,
+                        window_type=window_type,
+                        glazing_layers=window_glazing_layers,
+                        gas_fill=window_gas_fill,
+                        low_e_coating=window_low_e_coating
+                    )
+                    
+                    if session_state["edit_window"]:
+                        # Update existing window
+                        session_state["components"]["windows"][session_state["edit_window_index"]] = window
+                        st.success(f"Window '{window_name}' updated successfully!")
+                        
+                        # Reset edit flag
+                        session_state["edit_window"] = False
+                        session_state["edit_window_index"] = -1
+                    else:
+                        # Add new window
+                        session_state["components"]["windows"].append(window)
+                        st.success(f"Window '{window_name}' added successfully!")
+                    
+                    # Reset form values
+                    session_state["window_name"] = ""
+                    session_state["window_orientation"] = "NORTH"
+                    session_state["window_area"] = 0.0
+                    session_state["window_u_value"] = 2.8
+                    session_state["window_shgc"] = 0.7
+                    session_state["window_vt"] = 0.8
+                    session_state["window_type"] = "Double Glazed"
+                    session_state["window_glazing_layers"] = 2
+                    session_state["window_gas_fill"] = "Air"
+                    session_state["window_low_e_coating"] = False
+                    
+                    # Save components to file
+                    self.save_components(session_state["components"])
+                    
+                    st.experimental_rerun()
+    
+    def _display_door_selection(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display door selection interface.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.subheader("Door Components")
+        
+        # Display existing doors
+        if session_state["components"]["doors"]:
+            st.write("Existing Doors:")
+            
+            # Create a DataFrame for display
+            door_data = []
+            for i, door in enumerate(session_state["components"]["doors"]):
+                door_data.append({
+                    "ID": door.id,
+                    "Name": door.name,
+                    "Orientation": door.orientation.name,
+                    "Area (m²)": door.area,
+                    "U-Value (W/m²·K)": door.u_value,
+                    "Door Type": door.door_type
+                })
+            
+            door_df = pd.DataFrame(door_data)
+            st.dataframe(door_df, use_container_width=True)
+            
+            # Add edit and delete buttons
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                door_to_edit = st.selectbox(
+                    "Select Door to Edit",
+                    options=[f"#{i+1}: {door.name}" for i, door in enumerate(session_state["components"]["doors"])],
+                    key="door_to_edit"
+                )
+                
+                if st.button("Edit Selected Door", key="edit_door_button"):
+                    # Get index of door to edit
+                    door_index = int(door_to_edit.split(":")[0][1:]) - 1
+                    
+                    # Set edit flag and index
+                    session_state["edit_door"] = True
+                    session_state["edit_door_index"] = door_index
+                    
+                    # Set form values from selected door
+                    door = session_state["components"]["doors"][door_index]
+                    session_state["door_name"] = door.name
+                    session_state["door_orientation"] = door.orientation.name
+                    session_state["door_area"] = door.area
+                    session_state["door_u_value"] = door.u_value
+                    session_state["door_type"] = door.door_type
+                    
+                    st.experimental_rerun()
+            
+            with col2:
+                door_to_delete = st.selectbox(
+                    "Select Door to Delete",
+                    options=[f"#{i+1}: {door.name}" for i, door in enumerate(session_state["components"]["doors"])],
+                    key="door_to_delete"
+                )
+                
+                if st.button("Delete Selected Door", key="delete_door_button"):
+                    # Get index of door to delete
+                    door_index = int(door_to_delete.split(":")[0][1:]) - 1
+                    
+                    # Remove door from session state
+                    session_state["components"]["doors"].pop(door_index)
+                    
+                    st.success(f"Door {door_to_delete} deleted successfully!")
+                    st.experimental_rerun()
+        
+        # Add new door form
+        st.write("Add New Door:")
+        
+        # Initialize edit flag if not exists
+        if "edit_door" not in session_state:
+            session_state["edit_door"] = False
+            session_state["edit_door_index"] = -1
+        
+        # Initialize form values if not exists
+        if "door_name" not in session_state:
+            session_state["door_name"] = ""
+            session_state["door_orientation"] = "NORTH"
+            session_state["door_area"] = 0.0
+            session_state["door_u_value"] = 2.0
+            session_state["door_type"] = "Solid Wood"
+        
+        # Create form
+        with st.form("door_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                door_name = st.text_input(
+                    "Door Name",
+                    value=session_state["door_name"],
+                    key="door_name_input",
+                    help="Enter a descriptive name for the door"
+                )
+                
+                door_orientation = st.selectbox(
+                    "Orientation",
+                    options=["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"],
+                    index=["NORTH", "NORTHEAST", "EAST", "SOUTHEAST", "SOUTH", "SOUTHWEST", "WEST", "NORTHWEST"].index(session_state["door_orientation"]),
+                    key="door_orientation_input",
+                    help="Select the orientation of the door"
+                )
+                
+                door_area = st.number_input(
+                    "Area (m²)",
+                    min_value=0.0,
+                    value=session_state["door_area"],
+                    step=0.1,
+                    key="door_area_input",
+                    help="Enter the area of the door in square meters"
+                )
+            
+            with col2:
+                # Option to select from preset or custom
+                door_selection_method = st.radio(
+                    "Door Selection Method",
+                    options=["Select from Presets", "Custom U-Value"],
+                    key="door_selection_method"
+                )
+                
+                if door_selection_method == "Select from Presets":
+                    # Get preset door types from component library
+                    preset_doors = self.component_library.get_preset_doors()
+                    door_types = [door["name"] for door in preset_doors]
+                    
+                    door_type = st.selectbox(
+                        "Door Type",
+                        options=door_types,
+                        index=door_types.index(session_state["door_type"]) if session_state["door_type"] in door_types else 0,
+                        key="door_type_input",
+                        help="Select the type of door"
+                    )
+                    
+                    # Get U-value from selected preset
+                    selected_door = next((door for door in preset_doors if door["name"] == door_type), None)
+                    if selected_door:
+                        door_u_value = selected_door["u_value"]
+                    else:
+                        door_u_value = session_state["door_u_value"]
+                    
+                    # Display U-value (read-only)
+                    st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=door_u_value,
+                        step=0.01,
+                        key="door_u_value_display",
+                        disabled=True,
+                        help="U-value of the selected door type"
+                    )
+                else:
+                    # Custom U-value input
+                    door_u_value = st.number_input(
+                        "U-Value (W/m²·K)",
+                        min_value=0.0,
+                        value=session_state["door_u_value"],
+                        step=0.01,
+                        key="door_u_value_input",
+                        help="Enter the U-value of the door"
+                    )
+                    
+                    # Set door type to "Custom"
+                    door_type = "Custom"
+            
+            # Submit button
+            if session_state["edit_door"]:
+                submit_label = "Update Door"
+            else:
+                submit_label = "Add Door"
+            
+            submitted = st.form_submit_button(submit_label)
+            
+            if submitted:
+                # Validate inputs
+                if not door_name:
+                    st.error("Door name is required!")
+                elif door_area <= 0:
+                    st.error("Door area must be greater than zero!")
+                elif door_u_value <= 0:
+                    st.error("Door U-value must be greater than zero!")
+                else:
+                    # Create door object
+                    door = Door(
+                        id=str(uuid.uuid4()) if not session_state["edit_door"] else session_state["components"]["doors"][session_state["edit_door_index"]].id,
+                        name=door_name,
+                        component_type=ComponentType.DOOR,
+                        u_value=door_u_value,
+                        area=door_area,
+                        orientation=Orientation[door_orientation],
+                        door_type=door_type
+                    )
+                    
+                    if session_state["edit_door"]:
+                        # Update existing door
+                        session_state["components"]["doors"][session_state["edit_door_index"]] = door
+                        st.success(f"Door '{door_name}' updated successfully!")
+                        
+                        # Reset edit flag
+                        session_state["edit_door"] = False
+                        session_state["edit_door_index"] = -1
+                    else:
+                        # Add new door
+                        session_state["components"]["doors"].append(door)
+                        st.success(f"Door '{door_name}' added successfully!")
+                    
+                    # Reset form values
+                    session_state["door_name"] = ""
+                    session_state["door_orientation"] = "NORTH"
+                    session_state["door_area"] = 0.0
+                    session_state["door_u_value"] = 2.0
+                    session_state["door_type"] = "Solid Wood"
+                    
+                    # Save components to file
+                    self.save_components(session_state["components"])
+                    
+                    st.experimental_rerun()
+        
+        # Add U-value calculator button
+        if st.button("Open U-Value Calculator", key="open_u_value_calc_door"):
+            session_state["show_u_value_calculator"] = True
+            session_state["u_value_calc_component_type"] = "door"
+            st.experimental_rerun()
+    
+    def display_u_value_calculator(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display U-value calculator in Streamlit.
+        
+        Args:
+            session_state: Streamlit session state for storing form data
+        """
+        st.header("U-Value Calculator")
+        
+        # Get component type
+        component_type = session_state.get("u_value_calc_component_type", "wall")
+        
+        # Display component type
+        st.write(f"Calculating U-value for: **{component_type.title()}**")
+        
+        # Initialize material layers if not exists
+        if "material_layers" not in session_state:
+            session_state["material_layers"] = []
+        
+        # Display existing layers
+        if session_state["material_layers"]:
+            st.write("Current Material Layers (from outside to inside):")
+            
+            # Create a DataFrame for display
+            layer_data = []
+            for i, layer in enumerate(session_state["material_layers"]):
+                layer_data.append({
+                    "Layer": i + 1,
+                    "Material": layer["name"],
+                    "Thickness (mm)": layer["thickness"],
+                    "Conductivity (W/m·K)": layer["conductivity"],
+                    "R-Value (m²·K/W)": layer["thickness"] / 1000 / layer["conductivity"]
+                })
+            
+            layer_df = pd.DataFrame(layer_data)
+            st.dataframe(layer_df, use_container_width=True)
+            
+            # Calculate total R-value and U-value
+            r_outside = 0.04  # m²·K/W (outside surface resistance)
+            r_inside = 0.13  # m²·K/W (inside surface resistance)
+            
+            r_layers = sum([layer["thickness"] / 1000 / layer["conductivity"] for layer in session_state["material_layers"]])
+            r_total = r_outside + r_layers + r_inside
+            u_value = 1 / r_total
+            
+            # Display results
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                st.metric("Total R-Value", f"{r_total:.3f} m²·K/W")
+            
+            with col2:
+                st.metric("U-Value", f"{u_value:.3f} W/m²·K")
+            
+            with col3:
+                if st.button("Use This U-Value"):
+                    # Set U-value in the appropriate form
+                    if component_type == "wall":
+                        session_state["wall_u_value"] = u_value
+                    elif component_type == "roof":
+                        session_state["roof_u_value"] = u_value
+                    elif component_type == "floor":
+                        session_state["floor_u_value"] = u_value
+                    elif component_type == "door":
+                        session_state["door_u_value"] = u_value
+                    
+                    # Close calculator
+                    session_state["show_u_value_calculator"] = False
+                    st.success(f"U-value set to {u_value:.3f} W/m²·K")
+                    st.experimental_rerun()
+            
+            # Add delete button
+            if st.button("Remove Last Layer"):
+                if session_state["material_layers"]:
+                    session_state["material_layers"].pop()
+                    st.experimental_rerun()
+        
+        # Add new layer form
+        st.write("Add New Material Layer:")
+        
+        with st.form("material_layer_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Option to select from preset or custom
+                material_selection_method = st.radio(
+                    "Material Selection Method",
+                    options=["Select from Presets", "Custom Material"],
+                    key="material_selection_method"
+                )
+                
+                if material_selection_method == "Select from Presets":
+                    # Get preset materials from U-value calculator
+                    preset_materials = self.u_value_calculator.get_preset_materials()
+                    material_names = [material["name"] for material in preset_materials]
+                    
+                    material_name = st.selectbox(
+                        "Material",
+                        options=material_names,
+                        key="material_name_input",
+                        help="Select a material from the presets"
+                    )
+                    
+                    # Get conductivity from selected preset
+                    selected_material = next((material for material in preset_materials if material["name"] == material_name), None)
+                    if selected_material:
+                        material_conductivity = selected_material["conductivity"]
+                    else:
+                        material_conductivity = 1.0
+                    
+                    # Display conductivity (read-only)
+                    st.number_input(
+                        "Thermal Conductivity (W/m·K)",
+                        min_value=0.0,
+                        value=material_conductivity,
+                        step=0.01,
+                        key="material_conductivity_display",
+                        disabled=True,
+                        help="Thermal conductivity of the selected material"
+                    )
+                else:
+                    # Custom material input
+                    material_name = st.text_input(
+                        "Material Name",
+                        key="custom_material_name_input",
+                        help="Enter a name for the custom material"
+                    )
+                    
+                    material_conductivity = st.number_input(
+                        "Thermal Conductivity (W/m·K)",
+                        min_value=0.0,
+                        value=1.0,
+                        step=0.01,
+                        key="material_conductivity_input",
+                        help="Enter the thermal conductivity of the material"
+                    )
+            
+            with col2:
+                material_thickness = st.number_input(
+                    "Thickness (mm)",
+                    min_value=0.0,
+                    value=100.0,
+                    step=1.0,
+                    key="material_thickness_input",
+                    help="Enter the thickness of the material layer in millimeters"
+                )
+                
+                # Calculate and display R-value
+                if material_conductivity > 0:
+                    r_value = material_thickness / 1000 / material_conductivity
+                    st.metric("Layer R-Value", f"{r_value:.3f} m²·K/W")
+            
+            # Submit button
+            submitted = st.form_submit_button("Add Layer")
+            
+            if submitted:
+                # Validate inputs
+                if not material_name:
+                    st.error("Material name is required!")
+                elif material_thickness <= 0:
+                    st.error("Material thickness must be greater than zero!")
+                elif material_conductivity <= 0:
+                    st.error("Material conductivity must be greater than zero!")
+                else:
+                    # Add material layer
+                    session_state["material_layers"].append({
+                        "name": material_name,
+                        "thickness": material_thickness,
+                        "conductivity": material_conductivity
+                    })
+                    
+                    st.success(f"Material layer '{material_name}' added successfully!")
+                    st.experimental_rerun()
+        
+        # Add close button
+        if st.button("Close Calculator"):
+            session_state["show_u_value_calculator"] = False
+            session_state["material_layers"] = []
+            st.experimental_rerun()
+    
+    def save_components(self, components: Dict[str, List[Any]], file_path: str = "components.json") -> None:
+        """
+        Save components to a JSON file.
+        
+        Args:
+            components: Dictionary with building components
+            file_path: Path to save the JSON file
+        """
+        try:
+            # Convert components to serializable format
+            serializable_components = {
+                "walls": [wall.__dict__ for wall in components["walls"]],
+                "roofs": [roof.__dict__ for roof in components["roofs"]],
+                "floors": [floor.__dict__ for floor in components["floors"]],
+                "windows": [window.__dict__ for window in components["windows"]],
+                "doors": [door.__dict__ for door in components["doors"]]
+            }
+            
+            # Convert Orientation enum to string
+            for component_type in serializable_components:
+                for component in serializable_components[component_type]:
+                    if "orientation" in component and hasattr(component["orientation"], "name"):
+                        component["orientation"] = component["orientation"].name
+                    if "component_type" in component and hasattr(component["component_type"], "name"):
+                        component["component_type"] = component["component_type"].name
+            
+            with open(file_path, "w") as f:
+                json.dump(serializable_components, f, indent=4)
+        except Exception as e:
+            st.error(f"Error saving components: {e}")
+    
+    def load_components(self, file_path: str = "components.json") -> Dict[str, List[Any]]:
+        """
+        Load components from a JSON file.
+        
+        Args:
+            file_path: Path to the JSON file
+            
+        Returns:
+            Dictionary with building components
+        """
+        if os.path.exists(file_path):
+            try:
+                with open(file_path, "r") as f:
+                    serialized_components = json.load(f)
+                
+                # Convert serialized components back to objects
+                components = {
+                    "walls": [],
+                    "roofs": [],
+                    "floors": [],
+                    "windows": [],
+                    "doors": []
+                }
+                
+                # Convert walls
+                for wall_dict in serialized_components.get("walls", []):
+                    wall = Wall(
+                        id=wall_dict.get("id", str(uuid.uuid4())),
+                        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)
+                
+                # Convert roofs
+                for roof_dict in serialized_components.get("roofs", []):
+                    roof = Roof(
+                        id=roof_dict.get("id", str(uuid.uuid4())),
+                        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)
+                
+                # Convert floors
+                for floor_dict in serialized_components.get("floors", []):
+                    floor = Floor(
+                        id=floor_dict.get("id", str(uuid.uuid4())),
+                        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)
+                
+                # Convert windows
+                for window_dict in serialized_components.get("windows", []):
+                    window = Window(
+                        id=window_dict.get("id", str(uuid.uuid4())),
+                        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)
+                
+                # Convert doors
+                for door_dict in serialized_components.get("doors", []):
+                    door = Door(
+                        id=door_dict.get("id", str(uuid.uuid4())),
+                        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
+            except Exception as e:
+                st.error(f"Error loading components: {e}")
+        
+        # Return empty components if file doesn't exist or error occurs
+        return {
+            "walls": [],
+            "roofs": [],
+            "floors": [],
+            "windows": [],
+            "doors": []
+        }
+
+
+# Create a singleton instance
+component_selection = ComponentSelectionInterface()
+
+# Example usage
+if __name__ == "__main__":
+    import streamlit as st
+    
+    # Initialize session state
+    if "components" not in st.session_state:
+        st.session_state["components"] = component_selection.load_components()
+    
+    # Check if U-value calculator should be shown
+    if "show_u_value_calculator" not in st.session_state:
+        st.session_state["show_u_value_calculator"] = False
+    
+    if st.session_state["show_u_value_calculator"]:
+        # Display U-value calculator
+        component_selection.display_u_value_calculator(st.session_state)
+    else:
+        # Display component selection interface
+        component_selection.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,490 @@
+"""
+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("quantity", 0) < 0:
+                is_valid = False
+                messages.append(f"People Load #{i+1}: Quantity must be non-negative.")
+            
+            if person.get("sensible_heat", 0) < 0:
+                is_valid = False
+                messages.append(f"People Load #{i+1}: Sensible heat must be non-negative.")
+            
+            if person.get("latent_heat", 0) < 0:
+                is_valid = False
+                messages.append(f"People Load #{i+1}: Latent heat must be non-negative.")
+        
+        # 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.")
+        
+        # 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.")
+        
+        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('_', ' ')} 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,630 @@
+"""
+HVAC Calculator Code Documentation
+
+This module contains the main Streamlit application for the HVAC Calculator.
+It provides a comprehensive interface for calculating heating and cooling loads
+using ASHRAE methods.
+
+Author: Dr Majed Abuseif
+Date: March 2025
+Version: 1.0.0
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+import matplotlib.pyplot as plt
+import json
+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 ComponentSelection
+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.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+from data.reference_data import ReferenceData
+from data.climate_data import ClimateData
+from data.ashrae_tables import ASHRAETables
+
+# Import utility modules
+from utils.component_library import ComponentLibrary
+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 HeatTransfer
+from utils.cooling_load import CoolingLoad
+from utils.heating_load import HeatingLoad
+from utils.component_visualization import ComponentVisualization
+from utils.scenario_comparison import ScenarioComparison
+from utils.psychrometric_visualization import PsychrometricVisualization
+from utils.time_based_visualization import TimeBasedVisualization
+
+
+class HVACCalculator:
+    """
+    Main HVAC Calculator application class.
+    
+    This class initializes the Streamlit application and manages the navigation
+    between different sections of the calculator.
+    
+    Attributes:
+        building_info_form (BuildingInfoForm): Building information input form
+        component_selection (ComponentSelection): Component selection interface
+        results_display (ResultsDisplay): Results display module
+        data_validation (DataValidation): Data validation module
+        data_persistence (DataPersistence): Data persistence module
+        data_export (DataExport): Data export module
+    """
+    
+    def __init__(self):
+        """Initialize the HVAC Calculator application."""
+        # Set page configuration
+        st.set_page_config(
+            page_title="HVAC Load Calculator",
+            page_icon="🌡️",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
+        
+        # Initialize session state if not exists
+        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 = {}
+        
+        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 'scenarios' not in st.session_state:
+            st.session_state.scenarios = []
+        
+        # Initialize application modules
+        self.building_info_form = BuildingInfoForm()
+        self.component_selection = ComponentSelection()
+        self.results_display = ResultsDisplay()
+        self.data_validation = DataValidation()
+        self.data_persistence = DataPersistence()
+        self.data_export = DataExport()
+        
+        # Set up the application layout
+        self.setup_layout()
+    
+    def setup_layout(self):
+        """Set up the application layout with sidebar navigation."""
+        # Application title
+        st.sidebar.title("HVAC Load Calculator")
+        st.sidebar.markdown("---")
+        
+        # Navigation
+        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))
+        
+        # Update session state if page changed
+        if selected_page != st.session_state.page:
+            st.session_state.page = selected_page
+        
+        # Display the selected page
+        self.display_page(st.session_state.page)
+        
+        # Footer
+        st.sidebar.markdown("---")
+        st.sidebar.info(
+            "HVAC Load Calculator v1.0.0\n\n"
+            "Based on ASHRAE calculation methods\n\n"
+            "© 2025"
+        )
+    
+    def display_page(self, page: str):
+        """
+        Display the selected page.
+        
+        Args:
+            page (str): The page to display
+        """
+        if page == "Building Information":
+            self.building_info_form.display()
+        elif page == "Climate Data":
+            self.display_climate_data()
+        elif page == "Building Components":
+            self.component_selection.display()
+        elif page == "Internal Loads":
+            self.display_internal_loads()
+        elif page == "Calculation Results":
+            self.results_display.display()
+        elif page == "Export Data":
+            self.data_export.display()
+    
+    def display_climate_data(self):
+        """Display the climate data page."""
+        st.title("Climate Data")
+        
+        # Check if building information is available
+        if not st.session_state.building_info:
+            st.warning("Please enter building information first.")
+            st.button("Go to Building Information", on_click=self.navigate_to, args=["Building Information"])
+            return
+        
+        # Get climate zone from building information
+        climate_zone = st.session_state.building_info.get('climate_zone')
+        if not climate_zone:
+            st.error("Climate zone not found in building information.")
+            st.button("Go to Building Information", on_click=self.navigate_to, args=["Building Information"])
+            return
+        
+        # Display climate zone information
+        st.subheader(f"Climate Zone: {climate_zone}")
+        
+        # Get design conditions
+        design_conditions = ClimateData.get_design_conditions(climate_zone)
+        
+        # Display design conditions
+        st.subheader("Design Conditions")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.write("Summer Design Conditions")
+            summer_data = pd.DataFrame({
+                "Parameter": ["Dry-Bulb Temperature", "Wet-Bulb Temperature", "Dew Point"],
+                "Value": [
+                    f"{design_conditions['summer']['db']} °C",
+                    f"{design_conditions['summer']['wb']} °C",
+                    f"{design_conditions['summer']['dp']} °C"
+                ]
+            })
+            st.table(summer_data)
+        
+        with col2:
+            st.write("Winter Design Conditions")
+            winter_data = pd.DataFrame({
+                "Parameter": ["Dry-Bulb Temperature", "Relative Humidity"],
+                "Value": [
+                    f"{design_conditions['winter']['db']} °C",
+                    f"{design_conditions['winter']['rh']} %"
+                ]
+            })
+            st.table(winter_data)
+        
+        # Get monthly temperature data
+        monthly_temps = ClimateData.get_monthly_temperatures(climate_zone)
+        
+        # Prepare data for plotting
+        months = list(range(1, 13))
+        avg_temps = [monthly_temps[m]['avg_db'] for m in months]
+        max_temps = [monthly_temps[m]['max_db'] for m in months]
+        min_temps = [monthly_temps[m]['min_db'] for m in months]
+        
+        # Plot monthly temperature data
+        st.subheader("Monthly Temperature Data")
+        fig = go.Figure()
+        
+        fig.add_trace(go.Scatter(
+            x=months,
+            y=max_temps,
+            mode='lines+markers',
+            name='Maximum Temperature',
+            line=dict(color='red')
+        ))
+        
+        fig.add_trace(go.Scatter(
+            x=months,
+            y=avg_temps,
+            mode='lines+markers',
+            name='Average Temperature',
+            line=dict(color='green')
+        ))
+        
+        fig.add_trace(go.Scatter(
+            x=months,
+            y=min_temps,
+            mode='lines+markers',
+            name='Minimum Temperature',
+            line=dict(color='blue')
+        ))
+        
+        fig.update_layout(
+            title='Monthly Temperature Data',
+            xaxis_title='Month',
+            yaxis_title='Temperature (°C)',
+            xaxis=dict(
+                tickmode='array',
+                tickvals=months,
+                ticktext=['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+            )
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        
+        # Navigation buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            st.button("Back to Building Information", on_click=self.navigate_to, args=["Building Information"])
+        with col2:
+            st.button("Continue to Building Components", on_click=self.navigate_to, args=["Building Components"])
+    
+    def display_internal_loads(self):
+        """Display the internal loads page."""
+        st.title("Internal Loads")
+        
+        # Check if building components are available
+        if not any(st.session_state.components.values()):
+            st.warning("Please define building components first.")
+            st.button("Go to Building Components", on_click=self.navigate_to, args=["Building Components"])
+            return
+        
+        # Tabs for different internal load types
+        tabs = st.tabs(["People", "Lighting", "Equipment"])
+        
+        # People tab
+        with tabs[0]:
+            self.display_people_loads()
+        
+        # Lighting tab
+        with tabs[1]:
+            self.display_lighting_loads()
+        
+        # Equipment tab
+        with tabs[2]:
+            self.display_equipment_loads()
+        
+        # Display summary of internal loads
+        self.display_internal_loads_summary()
+        
+        # Navigation buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            st.button("Back to Building Components", on_click=self.navigate_to, args=["Building Components"])
+        with col2:
+            # Validate internal loads before proceeding
+            if self.data_validation.validate_internal_loads():
+                st.button("Continue to Calculation Results", on_click=self.navigate_to, args=["Calculation Results"])
+            else:
+                st.button("Continue to Calculation Results", disabled=True)
+    
+    def display_people_loads(self):
+        """Display the people loads section."""
+        st.subheader("People")
+        
+        # Form for adding people loads
+        with st.form("people_load_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                name = st.text_input("Name", "Occupants")
+                num_people = st.number_input("Number of People", min_value=1, value=10)
+            
+            with col2:
+                activity_level = st.selectbox(
+                    "Activity Level",
+                    options=["Seated, resting", "Seated, light work", "Office work", "Standing, light work", "Walking", "Heavy work"]
+                )
+                zone_type = st.selectbox(
+                    "Zone Type",
+                    options=["Office", "Residential", "Retail", "Educational", "Healthcare"]
+                )
+            
+            hours_in_operation = st.slider("Hours in Operation", min_value=1, max_value=24, value=8)
+            
+            submitted = st.form_submit_button("Add People Load")
+            
+            if submitted:
+                # Create people load
+                people_load = {
+                    "id": f"people_{len(st.session_state.internal_loads['people'])}",
+                    "name": name,
+                    "num_people": num_people,
+                    "activity_level": activity_level,
+                    "zone_type": zone_type,
+                    "hours_in_operation": hours_in_operation
+                }
+                
+                # Add to session state
+                st.session_state.internal_loads['people'].append(people_load)
+                st.success(f"Added {name} with {num_people} people")
+        
+        # Display existing people loads
+        if st.session_state.internal_loads['people']:
+            st.subheader("Existing People Loads")
+            
+            people_data = []
+            for load in st.session_state.internal_loads['people']:
+                people_data.append({
+                    "Name": load['name'],
+                    "Number of People": load['num_people'],
+                    "Activity Level": load['activity_level'],
+                    "Zone Type": load['zone_type'],
+                    "Hours in Operation": load['hours_in_operation'],
+                    "Actions": load['id']
+                })
+            
+            df = pd.DataFrame(people_data)
+            
+            # Display table with edit and delete buttons
+            for i, row in df.iterrows():
+                col1, col2, col3, col4, col5, col6, col7 = st.columns([2, 1, 2, 2, 1, 1, 1])
+                
+                with col1:
+                    st.write(row["Name"])
+                with col2:
+                    st.write(row["Number of People"])
+                with col3:
+                    st.write(row["Activity Level"])
+                with col4:
+                    st.write(row["Zone Type"])
+                with col5:
+                    st.write(row["Hours in Operation"])
+                with col6:
+                    if st.button("Edit", key=f"edit_{row['Actions']}"):
+                        # Set session state for editing
+                        st.session_state.editing_people = row['Actions']
+                with col7:
+                    if st.button("Delete", key=f"delete_{row['Actions']}"):
+                        # Remove from session state
+                        st.session_state.internal_loads['people'] = [
+                            load for load in st.session_state.internal_loads['people']
+                            if load['id'] != row['Actions']
+                        ]
+                        st.experimental_rerun()
+    
+    def display_lighting_loads(self):
+        """Display the lighting loads section."""
+        st.subheader("Lighting")
+        
+        # Form for adding lighting loads
+        with st.form("lighting_load_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                name = st.text_input("Name", "General Lighting")
+                power = st.number_input("Power (W)", min_value=0.0, value=1000.0)
+            
+            with col2:
+                usage_factor = st.slider("Usage Factor", min_value=0.0, max_value=1.0, value=0.8, step=0.1)
+                zone_type = st.selectbox(
+                    "Zone Type",
+                    options=["Office", "Residential", "Retail", "Educational", "Healthcare"]
+                )
+            
+            hours_in_operation = st.slider("Hours in Operation", min_value=1, max_value=24, value=8)
+            
+            submitted = st.form_submit_button("Add Lighting Load")
+            
+            if submitted:
+                # Create lighting load
+                lighting_load = {
+                    "id": f"lighting_{len(st.session_state.internal_loads['lighting'])}",
+                    "name": name,
+                    "power": power,
+                    "usage_factor": usage_factor,
+                    "zone_type": zone_type,
+                    "hours_in_operation": hours_in_operation
+                }
+                
+                # Add to session state
+                st.session_state.internal_loads['lighting'].append(lighting_load)
+                st.success(f"Added {name} with {power} W")
+        
+        # Display existing lighting loads
+        if st.session_state.internal_loads['lighting']:
+            st.subheader("Existing Lighting Loads")
+            
+            lighting_data = []
+            for load in st.session_state.internal_loads['lighting']:
+                lighting_data.append({
+                    "Name": load['name'],
+                    "Power (W)": load['power'],
+                    "Usage Factor": load['usage_factor'],
+                    "Zone Type": load['zone_type'],
+                    "Hours in Operation": load['hours_in_operation'],
+                    "Actions": load['id']
+                })
+            
+            df = pd.DataFrame(lighting_data)
+            
+            # Display table with edit and delete buttons
+            for i, row in df.iterrows():
+                col1, col2, col3, col4, col5, col6, col7 = st.columns([2, 1, 1, 2, 1, 1, 1])
+                
+                with col1:
+                    st.write(row["Name"])
+                with col2:
+                    st.write(f"{row['Power (W)']:.1f}")
+                with col3:
+                    st.write(f"{row['Usage Factor']:.1f}")
+                with col4:
+                    st.write(row["Zone Type"])
+                with col5:
+                    st.write(row["Hours in Operation"])
+                with col6:
+                    if st.button("Edit", key=f"edit_{row['Actions']}"):
+                        # Set session state for editing
+                        st.session_state.editing_lighting = row['Actions']
+                with col7:
+                    if st.button("Delete", key=f"delete_{row['Actions']}"):
+                        # Remove from session state
+                        st.session_state.internal_loads['lighting'] = [
+                            load for load in st.session_state.internal_loads['lighting']
+                            if load['id'] != row['Actions']
+                        ]
+                        st.experimental_rerun()
+    
+    def display_equipment_loads(self):
+        """Display the equipment loads section."""
+        st.subheader("Equipment")
+        
+        # Form for adding equipment loads
+        with st.form("equipment_load_form"):
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                name = st.text_input("Name", "Office Equipment")
+                power = st.number_input("Power (W)", min_value=0.0, value=500.0)
+            
+            with col2:
+                usage_factor = st.slider("Usage Factor", min_value=0.0, max_value=1.0, value=0.7, step=0.1)
+                radiation_fraction = st.slider("Radiation Fraction", min_value=0.0, max_value=1.0, value=0.3, step=0.1)
+            
+            zone_type = st.selectbox(
+                "Zone Type",
+                options=["Office", "Residential", "Retail", "Educational", "Healthcare"]
+            )
+            
+            hours_in_operation = st.slider("Hours in Operation", min_value=1, max_value=24, value=8)
+            
+            submitted = st.form_submit_button("Add Equipment Load")
+            
+            if submitted:
+                # Create equipment load
+                equipment_load = {
+                    "id": f"equipment_{len(st.session_state.internal_loads['equipment'])}",
+                    "name": name,
+                    "power": power,
+                    "usage_factor": usage_factor,
+                    "radiation_fraction": radiation_fraction,
+                    "zone_type": zone_type,
+                    "hours_in_operation": hours_in_operation
+                }
+                
+                # Add to session state
+                st.session_state.internal_loads['equipment'].append(equipment_load)
+                st.success(f"Added {name} with {power} W")
+        
+        # Display existing equipment loads
+        if st.session_state.internal_loads['equipment']:
+            st.subheader("Existing Equipment Loads")
+            
+            equipment_data = []
+            for load in st.session_state.internal_loads['equipment']:
+                equipment_data.append({
+                    "Name": load['name'],
+                    "Power (W)": load['power'],
+                    "Usage Factor": load['usage_factor'],
+                    "Radiation Fraction": load['radiation_fraction'],
+                    "Zone Type": load['zone_type'],
+                    "Hours in Operation": load['hours_in_operation'],
+                    "Actions": load['id']
+                })
+            
+            df = pd.DataFrame(equipment_data)
+            
+            # Display table with edit and delete buttons
+            for i, row in df.iterrows():
+                col1, col2, col3, col4, col5, col6, col7, col8 = st.columns([2, 1, 1, 1, 2, 1, 1, 1])
+                
+                with col1:
+                    st.write(row["Name"])
+                with col2:
+                    st.write(f"{row['Power (W)']:.1f}")
+                with col3:
+                    st.write(f"{row['Usage Factor']:.1f}")
+                with col4:
+                    st.write(f"{row['Radiation Fraction']:.1f}")
+                with col5:
+                    st.write(row["Zone Type"])
+                with col6:
+                    st.write(row["Hours in Operation"])
+                with col7:
+                    if st.button("Edit", key=f"edit_{row['Actions']}"):
+                        # Set session state for editing
+                        st.session_state.editing_equipment = row['Actions']
+                with col8:
+                    if st.button("Delete", key=f"delete_{row['Actions']}"):
+                        # Remove from session state
+                        st.session_state.internal_loads['equipment'] = [
+                            load for load in st.session_state.internal_loads['equipment']
+                            if load['id'] != row['Actions']
+                        ]
+                        st.experimental_rerun()
+    
+    def display_internal_loads_summary(self):
+        """Display a summary of all internal loads."""
+        st.subheader("Internal Loads Summary")
+        
+        # Check if any internal loads exist
+        if not any(st.session_state.internal_loads.values()):
+            st.info("No internal loads defined yet.")
+            return
+        
+        # Calculate total loads
+        total_people = sum(load['num_people'] for load in st.session_state.internal_loads['people'])
+        total_lighting_power = sum(load['power'] * load['usage_factor'] for load in st.session_state.internal_loads['lighting'])
+        total_equipment_power = sum(load['power'] * load['usage_factor'] for load in st.session_state.internal_loads['equipment'])
+        
+        # Display summary
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            st.metric("Total People", f"{total_people}")
+        
+        with col2:
+            st.metric("Total Lighting Power", f"{total_lighting_power:.1f} W")
+        
+        with col3:
+            st.metric("Total Equipment Power", f"{total_equipment_power:.1f} W")
+        
+        # Display pie chart of internal loads
+        if total_lighting_power > 0 or total_equipment_power > 0:
+            # Estimate people load (assuming 100W per person)
+            people_power = total_people * 100
+            
+            # Create pie chart
+            fig = px.pie(
+                values=[people_power, total_lighting_power, total_equipment_power],
+                names=['People', 'Lighting', 'Equipment'],
+                title='Internal Loads Distribution'
+            )
+            
+            st.plotly_chart(fig, use_container_width=True)
+    
+    def navigate_to(self, page: str):
+        """
+        Navigate to the specified page.
+        
+        Args:
+            page (str): The page to navigate to
+        """
+        st.session_state.page = page
+        st.experimental_rerun()
+
+
+if __name__ == "__main__":
+    # Create and run the HVAC Calculator application
+    app = HVACCalculator()

app/results_display.py

@@ -0,0 +1,592 @@
+"""
+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 ScenarioComparison
+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 = ScenarioComparison()
+        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']}")
+            st.write(f"**Location:** {session_state['building_info']['location']}")
+            st.write(f"**Climate Zone:** {session_state['building_info']['climate_zone']}")
+            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")
+            
+            # 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")
+            
+            # 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:
+            # 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:
+            # 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)": roof["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 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 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)"):
+            # This would be implemented with the export functionality
+            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")
+        
+        # Use component visualization module
+        self.component_visualization.display_component_breakdown(
+            session_state["calculation_results"],
+            session_state["components"]
+        )
+    
+    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")
+        
+        # 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")
+        
+        # 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.experimental_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.experimental_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.experimental_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,702 @@
+"""
+ASHRAE tables module for HVAC Load Calculator.
+This module implements CLTD, SCL, CLF tables and interpolation functions for load calculations.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import json
+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()
+        
+        # Load correction factors
+        self.latitude_correction = self._load_latitude_correction()
+        self.color_correction = self._load_color_correction()
+        self.month_correction = self._load_month_correction()
+    
+    def _load_cltd_wall_table(self) -> Dict[str, pd.DataFrame]:
+        """
+        Load CLTD tables for walls.
+        
+        Returns:
+            Dictionary of DataFrames with CLTD values for each wall group
+        """
+        # This would typically load from CSV files with ASHRAE data
+        # For now, we'll define sample tables inline
+        
+        # Hours of the day (0-23)
+        hours = list(range(24))
+        
+        # Sample CLTD values for wall group A (light construction)
+        # Values for different orientations (N, NE, E, SE, S, SW, W, NW)
+        wall_a_data = {
+            "N": [2, 1, 0, -1, -2, -2, -2, -1, 0, 1, 3, 4, 6, 7, 8, 9, 9, 8, 7, 6, 5, 4, 3, 3],
+            "NE": [1, 0, -1, -1, -2, -1, 1, 4, 7, 9, 10, 11, 11, 10, 9, 8, 7, 6, 5, 4, 3, 3, 2, 1],
+            "E": [1, 0, -1, -1, -2, -1, 2, 6, 10, 13, 15, 16, 15, 14, 12, 10, 8, 6, 5, 4, 3, 2, 2, 1],
+            "SE": [1, 0, -1, -1, -2, -1, 1, 4, 8, 11, 14, 15, 16, 15, 14, 12, 10, 8, 6, 5, 4, 3, 2, 1],
+            "S": [1, 0, -1, -1, -2, -2, -1, 0, 2, 4, 7, 10, 12, 14, 15, 15, 14, 12, 9, 7, 5, 3, 2, 2],
+            "SW": [2, 1, 0, -1, -1, -2, -2, -1, 0, 2, 4, 6, 8, 11, 13, 15, 16, 15, 13, 10, 8, 6, 4, 3],
+            "W": [2, 1, 0, -1, -1, -2, -2, -1, 0, 1, 3, 4, 6, 8, 10, 13, 15, 16, 15, 13, 10, 7, 5, 3],
+            "NW": [2, 1, 0, -1, -1, -2, -2, -1, 0, 1, 2, 3, 5, 6, 7, 9, 11, 12, 12, 11, 9, 7, 5, 3]
+        }
+        
+        # Sample CLTD values for wall group B
+        wall_b_data = {
+            "N": [3, 2, 1, 0, -1, -1, -1, 0, 1, 2, 4, 5, 7, 8, 9, 10, 10, 9, 8, 7, 6, 5, 4, 4],
+            "NE": [2, 1, 0, 0, -1, 0, 2, 5, 8, 10, 11, 12, 12, 11, 10, 9, 8, 7, 6, 5, 4, 4, 3, 2],
+            "E": [2, 1, 0, 0, -1, 0, 3, 7, 11, 14, 16, 17, 16, 15, 13, 11, 9, 7, 6, 5, 4, 3, 3, 2],
+            "SE": [2, 1, 0, 0, -1, 0, 2, 5, 9, 12, 15, 16, 17, 16, 15, 13, 11, 9, 7, 6, 5, 4, 3, 2],
+            "S": [2, 1, 0, 0, -1, -1, 0, 1, 3, 5, 8, 11, 13, 15, 16, 16, 15, 13, 10, 8, 6, 4, 3, 3],
+            "SW": [3, 2, 1, 0, 0, -1, -1, 0, 1, 3, 5, 7, 9, 12, 14, 16, 17, 16, 14, 11, 9, 7, 5, 4],
+            "W": [3, 2, 1, 0, 0, -1, -1, 0, 1, 2, 4, 5, 7, 9, 11, 14, 16, 17, 16, 14, 11, 8, 6, 4],
+            "NW": [3, 2, 1, 0, 0, -1, -1, 0, 1, 2, 3, 4, 6, 7, 8, 10, 12, 13, 13, 12, 10, 8, 6, 4]
+        }
+        
+        # Sample CLTD values for wall group C
+        wall_c_data = {
+            "N": [4, 3, 2, 1, 0, 0, 0, 1, 2, 3, 5, 6, 8, 9, 10, 11, 11, 10, 9, 8, 7, 6, 5, 5],
+            "NE": [3, 2, 1, 1, 0, 1, 3, 6, 9, 11, 12, 13, 13, 12, 11, 10, 9, 8, 7, 6, 5, 5, 4, 3],
+            "E": [3, 2, 1, 1, 0, 1, 4, 8, 12, 15, 17, 18, 17, 16, 14, 12, 10, 8, 7, 6, 5, 4, 4, 3],
+            "SE": [3, 2, 1, 1, 0, 1, 3, 6, 10, 13, 16, 17, 18, 17, 16, 14, 12, 10, 8, 7, 6, 5, 4, 3],
+            "S": [3, 2, 1, 1, 0, 0, 1, 2, 4, 6, 9, 12, 14, 16, 17, 17, 16, 14, 11, 9, 7, 5, 4, 4],
+            "SW": [4, 3, 2, 1, 1, 0, 0, 1, 2, 4, 6, 8, 10, 13, 15, 17, 18, 17, 15, 12, 10, 8, 6, 5],
+            "W": [4, 3, 2, 1, 1, 0, 0, 1, 2, 3, 5, 6, 8, 10, 12, 15, 17, 18, 17, 15, 12, 9, 7, 5],
+            "NW": [4, 3, 2, 1, 1, 0, 0, 1, 2, 3, 4, 5, 7, 8, 9, 11, 13, 14, 14, 13, 11, 9, 7, 5]
+        }
+        
+        # Sample CLTD values for wall group D
+        wall_d_data = {
+            "N": [5, 4, 3, 2, 1, 1, 1, 2, 3, 4, 6, 7, 9, 10, 11, 12, 12, 11, 10, 9, 8, 7, 6, 6],
+            "NE": [4, 3, 2, 2, 1, 2, 4, 7, 10, 12, 13, 14, 14, 13, 12, 11, 10, 9, 8, 7, 6, 6, 5, 4],
+            "E": [4, 3, 2, 2, 1, 2, 5, 9, 13, 16, 18, 19, 18, 17, 15, 13, 11, 9, 8, 7, 6, 5, 5, 4],
+            "SE": [4, 3, 2, 2, 1, 2, 4, 7, 11, 14, 17, 18, 19, 18, 17, 15, 13, 11, 9, 8, 7, 6, 5, 4],
+            "S": [4, 3, 2, 2, 1, 1, 2, 3, 5, 7, 10, 13, 15, 17, 18, 18, 17, 15, 12, 10, 8, 6, 5, 5],
+            "SW": [5, 4, 3, 2, 2, 1, 1, 2, 3, 5, 7, 9, 11, 14, 16, 18, 19, 18, 16, 13, 11, 9, 7, 6],
+            "W": [5, 4, 3, 2, 2, 1, 1, 2, 3, 4, 6, 7, 9, 11, 13, 16, 18, 19, 18, 16, 13, 10, 8, 6],
+            "NW": [5, 4, 3, 2, 2, 1, 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 14, 15, 15, 14, 12, 10, 8, 6]
+        }
+        
+        # Create DataFrames for each wall group
+        wall_groups = {
+            "A": pd.DataFrame(wall_a_data, index=hours),
+            "B": pd.DataFrame(wall_b_data, index=hours),
+            "C": pd.DataFrame(wall_c_data, index=hours),
+            "D": pd.DataFrame(wall_d_data, index=hours),
+            # Groups E-H would be defined similarly
+            # Using group D values for now as placeholders
+            "E": pd.DataFrame(wall_d_data, index=hours),
+            "F": pd.DataFrame(wall_d_data, index=hours),
+            "G": pd.DataFrame(wall_d_data, index=hours),
+            "H": pd.DataFrame(wall_d_data, index=hours)
+        }
+        
+        return wall_groups
+    
+    def _load_cltd_roof_table(self) -> Dict[str, pd.DataFrame]:
+        """
+        Load CLTD tables for roofs.
+        
+        Returns:
+            Dictionary of DataFrames with CLTD values for each roof group
+        """
+        # Hours of the day (0-23)
+        hours = list(range(24))
+        
+        # Sample CLTD values for roof group A (light construction)
+        roof_a_data = [6, 3, 1, -1, -2, -3, 0, 5, 11, 17, 23, 28, 32, 34, 35, 34, 31, 27, 22, 18, 14, 12, 9, 7]
+        
+        # Sample CLTD values for roof group B
+        roof_b_data = [9, 7, 5, 3, 2, 1, 1, 3, 7, 12, 17, 22, 26, 30, 33, 34, 34, 32, 29, 25, 21, 17, 14, 11]
+        
+        # Sample CLTD values for roof group C
+        roof_c_data = [13, 11, 9, 7, 6, 5, 4, 4, 6, 9, 13, 17, 21, 25, 28, 31, 32, 32, 30, 27, 24, 21, 18, 15]
+        
+        # Sample CLTD values for roof group D
+        roof_d_data = [14, 13, 12, 10, 9, 8, 7, 7, 7, 9, 11, 14, 17, 20, 23, 26, 28, 29, 29, 27, 25, 22, 19, 17]
+        
+        # Sample CLTD values for roof group E
+        roof_e_data = [17, 16, 15, 14, 13, 12, 11, 11, 11, 11, 12, 14, 16, 18, 21, 23, 25, 26, 27, 26, 25, 23, 21, 19]
+        
+        # Sample CLTD values for roof group F
+        roof_f_data = [19, 18, 18, 17, 16, 16, 15, 15, 14, 14, 15, 16, 17, 19, 20, 22, 23, 24, 25, 25, 24, 23, 22, 20]
+        
+        # Sample CLTD values for roof group G (heavy construction)
+        roof_g_data = [20, 20, 19, 19, 19, 18, 18, 18, 18, 18, 18, 18, 19, 19, 20, 21, 22, 22, 23, 23, 23, 22, 22, 21]
+        
+        # Create DataFrames for each roof group
+        roof_groups = {
+            "A": pd.DataFrame({"HOR": roof_a_data}, index=hours),
+            "B": pd.DataFrame({"HOR": roof_b_data}, index=hours),
+            "C": pd.DataFrame({"HOR": roof_c_data}, index=hours),
+            "D": pd.DataFrame({"HOR": roof_d_data}, index=hours),
+            "E": pd.DataFrame({"HOR": roof_e_data}, index=hours),
+            "F": pd.DataFrame({"HOR": roof_f_data}, index=hours),
+            "G": pd.DataFrame({"HOR": roof_g_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 orientation
+        """
+        # Hours of the day (0-23)
+        hours = list(range(24))
+        
+        # Sample SCL values for different orientations
+        # Values are for 40° North latitude in July
+        scl_data = {
+            "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]
+        }
+        
+        # Create DataFrame for SCL values
+        scl_table = pd.DataFrame(scl_data, index=hours)
+        
+        # Return as a dictionary with a single entry for now
+        # In a real implementation, there would be tables for different latitudes and months
+        return {"40N_JUL": scl_table}
+    
+    def _load_clf_lights_table(self) -> pd.DataFrame:
+        """
+        Load CLF (Cooling Load Factor) table for lights.
+        
+        Returns:
+            DataFrame with CLF values for lights
+        """
+        # Hours of the day (0-23)
+        hours = list(range(24))
+        
+        # Sample CLF values for lights
+        # Values for different hours of operation
+        clf_lights_data = {
+            "8h": [0.45, 0.27, 0.16, 0.10, 0.06, 0.04, 0.02, 0.01, 0.88, 0.82, 0.71, 0.61, 0.53, 0.45, 0.39, 0.33, 0.28, 0.24, 0.20, 0.17, 0.14, 0.12, 0.10, 0.08],
+            "10h": [0.45, 0.27, 0.16, 0.10, 0.06, 0.04, 0.02, 0.01, 0.88, 0.82, 0.71, 0.61, 0.53, 0.45, 0.39, 0.33, 0.28, 0.88, 0.82, 0.17, 0.14, 0.12, 0.10, 0.08],
+            "12h": [0.45, 0.27, 0.16, 0.10, 0.06, 0.04, 0.02, 0.01, 0.88, 0.82, 0.71, 0.61, 0.53, 0.45, 0.39, 0.33, 0.28, 0.88, 0.82, 0.71, 0.14, 0.12, 0.10, 0.08],
+            "14h": [0.45, 0.27, 0.16, 0.10, 0.06, 0.04, 0.02, 0.01, 0.88, 0.82, 0.71, 0.61, 0.53, 0.45, 0.39, 0.33, 0.28, 0.88, 0.82, 0.71, 0.61, 0.12, 0.10, 0.08],
+            "16h": [0.45, 0.27, 0.16, 0.10, 0.06, 0.04, 0.02, 0.01, 0.88, 0.82, 0.71, 0.61, 0.53, 0.45, 0.39, 0.33, 0.28, 0.88, 0.82, 0.71, 0.61, 0.53, 0.10, 0.08],
+            "18h": [0.45, 0.27, 0.16, 0.10, 0.06, 0.04, 0.02, 0.01, 0.88, 0.82, 0.71, 0.61, 0.53, 0.45, 0.39, 0.33, 0.28, 0.88, 0.82, 0.71, 0.61, 0.53, 0.45, 0.08],
+            "24h": [0.18, 0.16, 0.14, 0.12, 0.11, 0.10, 0.09, 0.08, 0.07, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06, 0.06]
+        }
+        
+        # Create DataFrame for CLF values for lights
+        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
+        """
+        # Hours of the day (0-23)
+        hours = list(range(24))
+        
+        # Sample CLF values for people
+        # Values for different hours of occupancy
+        clf_people_data = {
+            "8h": [0.58, 0.42, 0.30, 0.22, 0.16, 0.12, 0.08, 0.06, 0.93, 0.85, 0.80, 0.75, 0.70, 0.66, 0.62, 0.58, 0.54, 0.50, 0.47, 0.44, 0.41, 0.38, 0.36, 0.33],
+            "10h": [0.58, 0.42, 0.30, 0.22, 0.16, 0.12, 0.08, 0.06, 0.93, 0.85, 0.80, 0.75, 0.70, 0.66, 0.62, 0.58, 0.54, 0.93, 0.85, 0.44, 0.41, 0.38, 0.36, 0.33],
+            "12h": [0.58, 0.42, 0.30, 0.22, 0.16, 0.12, 0.08, 0.06, 0.93, 0.85, 0.80, 0.75, 0.70, 0.66, 0.62, 0.58, 0.54, 0.93, 0.85, 0.80, 0.41, 0.38, 0.36, 0.33],
+            "14h": [0.58, 0.42, 0.30, 0.22, 0.16, 0.12, 0.08, 0.06, 0.93, 0.85, 0.80, 0.75, 0.70, 0.66, 0.62, 0.58, 0.54, 0.93, 0.85, 0.80, 0.75, 0.38, 0.36, 0.33],
+            "16h": [0.58, 0.42, 0.30, 0.22, 0.16, 0.12, 0.08, 0.06, 0.93, 0.85, 0.80, 0.75, 0.70, 0.66, 0.62, 0.58, 0.54, 0.93, 0.85, 0.80, 0.75, 0.70, 0.36, 0.33],
+            "18h": [0.58, 0.42, 0.30, 0.22, 0.16, 0.12, 0.08, 0.06, 0.93, 0.85, 0.80, 0.75, 0.70, 0.66, 0.62, 0.58, 0.54, 0.93, 0.85, 0.80, 0.75, 0.70, 0.66, 0.33],
+            "24h": [0.27, 0.25, 0.23, 0.21, 0.19, 0.17, 0.16, 0.14, 0.13, 0.12, 0.11, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10]
+        }
+        
+        # Create DataFrame for CLF values for people
+        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
+        """
+        # Hours of the day (0-23)
+        hours = list(range(24))
+        
+        # Sample CLF values for equipment
+        # Values for different hours of operation
+        clf_equipment_data = {
+            "8h": [0.50, 0.35, 0.25, 0.18, 0.13, 0.09, 0.06, 0.04, 0.90, 0.83, 0.76, 0.69, 0.62, 0.55, 0.48, 0.41, 0.34, 0.30, 0.26, 0.22, 0.18, 0.16, 0.14, 0.12],
+            "10h": [0.50, 0.35, 0.25, 0.18, 0.13, 0.09, 0.06, 0.04, 0.90, 0.83, 0.76, 0.69, 0.62, 0.55, 0.48, 0.41, 0.34, 0.90, 0.83, 0.22, 0.18, 0.16, 0.14, 0.12],
+            "12h": [0.50, 0.35, 0.25, 0.18, 0.13, 0.09, 0.06, 0.04, 0.90, 0.83, 0.76, 0.69, 0.62, 0.55, 0.48, 0.41, 0.34, 0.90, 0.83, 0.76, 0.18, 0.16, 0.14, 0.12],
+            "14h": [0.50, 0.35, 0.25, 0.18, 0.13, 0.09, 0.06, 0.04, 0.90, 0.83, 0.76, 0.69, 0.62, 0.55, 0.48, 0.41, 0.34, 0.90, 0.83, 0.76, 0.69, 0.16, 0.14, 0.12],
+            "16h": [0.50, 0.35, 0.25, 0.18, 0.13, 0.09, 0.06, 0.04, 0.90, 0.83, 0.76, 0.69, 0.62, 0.55, 0.48, 0.41, 0.34, 0.90, 0.83, 0.76, 0.69, 0.62, 0.14, 0.12],
+            "18h": [0.50, 0.35, 0.25, 0.18, 0.13, 0.09, 0.06, 0.04, 0.90, 0.83, 0.76, 0.69, 0.62, 0.55, 0.48, 0.41, 0.34, 0.90, 0.83, 0.76, 0.69, 0.62, 0.55, 0.12],
+            "24h": [0.23, 0.21, 0.19, 0.17, 0.15, 0.13, 0.12, 0.10, 0.09, 0.08, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07, 0.07]
+        }
+        
+        # Create DataFrame for CLF values for equipment
+        return pd.DataFrame(clf_equipment_data, index=hours)
+    
+    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
+        """
+        # Sample latitude correction factors
+        # Values 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
+        """
+        # Color correction factors
+        return {
+            "Dark": 0.0,  # No correction for dark colors (default)
+            "Medium": -1.0,  # Correction for medium colors
+            "Light": -2.0  # Correction for light colors
+        }
+    
+    def _load_month_correction(self) -> Dict[str, float]:
+        """
+        Load month correction factors for CLTD values.
+        
+        Returns:
+            Dictionary of correction factors for different months
+        """
+        # Month correction factors (relative to July/August)
+        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 get_cltd_wall(self, wall_group: str, orientation: str, hour: int) -> float:
+        """
+        Get CLTD value for a wall.
+        
+        Args:
+            wall_group: ASHRAE wall group (A-H)
+            orientation: Wall orientation (N, NE, E, SE, S, SW, W, NW)
+            hour: Hour of the day (0-23)
+            
+        Returns:
+            CLTD value for the specified wall and hour
+        """
+        # Validate inputs
+        if wall_group not in self.cltd_wall:
+            raise ValueError(f"Invalid wall group: {wall_group}")
+        
+        # Convert orientation to abbreviation if needed
+        orientation_map = {
+            "North": "N", "Northeast": "NE", "East": "E", "Southeast": "SE",
+            "South": "S", "Southwest": "SW", "West": "W", "Northwest": "NW"
+        }
+        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 < 0 or hour > 23:
+            raise ValueError(f"Invalid hour: {hour}")
+        
+        # Get CLTD value
+        return self.cltd_wall[wall_group].loc[hour, orientation_abbr]
+    
+    def get_cltd_roof(self, roof_group: str, hour: int) -> float:
+        """
+        Get CLTD value for a roof.
+        
+        Args:
+            roof_group: ASHRAE roof group (A-G)
+            hour: Hour of the day (0-23)
+            
+        Returns:
+            CLTD value for the specified roof and hour
+        """
+        # Validate inputs
+        if roof_group not in self.cltd_roof:
+            raise ValueError(f"Invalid roof group: {roof_group}")
+        
+        if hour < 0 or hour > 23:
+            raise ValueError(f"Invalid hour: {hour}")
+        
+        # Get CLTD value
+        return self.cltd_roof[roof_group].loc[hour, "HOR"]
+    
+    def get_scl(self, orientation: str, hour: int, latitude: str = "40N_JUL") -> float:
+        """
+        Get SCL value for a window.
+        
+        Args:
+            orientation: Window orientation (N, NE, E, SE, S, SW, W, NW, HOR)
+            hour: Hour of the day (0-23)
+            latitude: Latitude and month key (default: "40N_JUL")
+            
+        Returns:
+            SCL value for the specified window and hour
+        """
+        # Validate inputs
+        if latitude not in self.scl:
+            raise ValueError(f"Invalid latitude: {latitude}")
+        
+        # Convert orientation to abbreviation if needed
+        orientation_map = {
+            "North": "N", "Northeast": "NE", "East": "E", "Southeast": "SE",
+            "South": "S", "Southwest": "SW", "West": "W", "Northwest": "NW",
+            "Horizontal": "HOR"
+        }
+        orientation_abbr = orientation_map.get(orientation, orientation)
+        
+        if orientation_abbr not in self.scl[latitude].columns:
+            raise ValueError(f"Invalid orientation: {orientation}")
+        
+        if hour < 0 or hour > 23:
+            raise ValueError(f"Invalid hour: {hour}")
+        
+        # Get SCL value
+        return self.scl[latitude].loc[hour, orientation_abbr]
+    
+    def get_clf_lights(self, hour: int, hours_operation: str) -> float:
+        """
+        Get CLF value for lights.
+        
+        Args:
+            hour: Hour of the day (0-23)
+            hours_operation: Hours of operation (8h, 10h, 12h, 14h, 16h, 18h, 24h)
+            
+        Returns:
+            CLF value for lights at the specified hour
+        """
+        # Validate inputs
+        if hours_operation not in self.clf_lights.columns:
+            raise ValueError(f"Invalid hours of operation: {hours_operation}")
+        
+        if hour < 0 or hour > 23:
+            raise ValueError(f"Invalid hour: {hour}")
+        
+        # Get CLF value
+        return self.clf_lights.loc[hour, hours_operation]
+    
+    def get_clf_people(self, hour: int, hours_occupancy: str) -> float:
+        """
+        Get CLF value for people.
+        
+        Args:
+            hour: Hour of the day (0-23)
+            hours_occupancy: Hours of occupancy (8h, 10h, 12h, 14h, 16h, 18h, 24h)
+            
+        Returns:
+            CLF value for people at the specified hour
+        """
+        # Validate inputs
+        if hours_occupancy not in self.clf_people.columns:
+            raise ValueError(f"Invalid hours of occupancy: {hours_occupancy}")
+        
+        if hour < 0 or hour > 23:
+            raise ValueError(f"Invalid hour: {hour}")
+        
+        # Get CLF value
+        return self.clf_people.loc[hour, hours_occupancy]
+    
+    def get_clf_equipment(self, hour: int, hours_operation: str) -> float:
+        """
+        Get CLF value for equipment.
+        
+        Args:
+            hour: Hour of the day (0-23)
+            hours_operation: Hours of operation (8h, 10h, 12h, 14h, 16h, 18h, 24h)
+            
+        Returns:
+            CLF value for equipment at the specified hour
+        """
+        # Validate inputs
+        if hours_operation not in self.clf_equipment.columns:
+            raise ValueError(f"Invalid hours of operation: {hours_operation}")
+        
+        if hour < 0 or hour > 23:
+            raise ValueError(f"Invalid hour: {hour}")
+        
+        # Get CLF value
+        return self.clf_equipment.loc[hour, hours_operation]
+    
+    def get_latitude_correction(self, latitude: str, month: str) -> float:
+        """
+        Get latitude correction factor for CLTD/SCL values.
+        
+        Args:
+            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
+            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            
+        Returns:
+            Latitude correction factor
+        """
+        # Validate inputs
+        if latitude not in self.latitude_correction:
+            raise ValueError(f"Invalid latitude: {latitude}")
+        
+        if month not in self.latitude_correction[latitude]:
+            raise ValueError(f"Invalid month: {month}")
+        
+        # Get correction factor
+        return self.latitude_correction[latitude][month]
+    
+    def get_color_correction(self, color: str) -> float:
+        """
+        Get color correction factor for CLTD values.
+        
+        Args:
+            color: Surface color (Dark, Medium, Light)
+            
+        Returns:
+            Color correction factor
+        """
+        # Validate inputs
+        if color not in self.color_correction:
+            raise ValueError(f"Invalid color: {color}")
+        
+        # Get correction factor
+        return self.color_correction[color]
+    
+    def get_month_correction(self, month: str) -> float:
+        """
+        Get month correction factor for CLTD values.
+        
+        Args:
+            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            
+        Returns:
+            Month correction factor
+        """
+        # Validate inputs
+        if month not in self.month_correction:
+            raise ValueError(f"Invalid month: {month}")
+        
+        # Get correction factor
+        return self.month_correction[month]
+    
+    def calculate_corrected_cltd_wall(self, wall_group: str, orientation: str, hour: int, 
+                                     color: str = "Dark", month: str = "Jul", 
+                                     latitude: str = "40N", indoor_temp: float = 25.5, 
+                                     outdoor_temp: float = 35.0) -> float:
+        """
+        Calculate corrected CLTD value for a wall.
+        
+        Args:
+            wall_group: ASHRAE wall group (A-H)
+            orientation: Wall orientation (N, NE, E, SE, S, SW, W, NW)
+            hour: Hour of the day (0-23)
+            color: Surface color (Dark, Medium, Light)
+            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
+            indoor_temp: Indoor design temperature (°C)
+            outdoor_temp: Outdoor design temperature (°C)
+            
+        Returns:
+            Corrected CLTD value for the specified wall and hour
+        """
+        # Get base CLTD value
+        cltd = self.get_cltd_wall(wall_group, orientation, hour)
+        
+        # Apply corrections
+        color_correction = self.get_color_correction(color)
+        month_correction = self.get_month_correction(month)
+        latitude_correction = self.get_latitude_correction(latitude, month)
+        
+        # Temperature correction
+        temp_correction = (indoor_temp - 25.5) + (outdoor_temp - 35.0)
+        
+        # Calculate corrected CLTD
+        corrected_cltd = cltd + color_correction + month_correction + latitude_correction + temp_correction
+        
+        return max(0, corrected_cltd)  # Ensure non-negative value
+    
+    def calculate_corrected_cltd_roof(self, roof_group: str, hour: int, 
+                                     color: str = "Dark", month: str = "Jul", 
+                                     latitude: str = "40N", indoor_temp: float = 25.5, 
+                                     outdoor_temp: float = 35.0) -> float:
+        """
+        Calculate corrected CLTD value for a roof.
+        
+        Args:
+            roof_group: ASHRAE roof group (A-G)
+            hour: Hour of the day (0-23)
+            color: Surface color (Dark, Medium, Light)
+            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
+            indoor_temp: Indoor design temperature (°C)
+            outdoor_temp: Outdoor design temperature (°C)
+            
+        Returns:
+            Corrected CLTD value for the specified roof and hour
+        """
+        # Get base CLTD value
+        cltd = self.get_cltd_roof(roof_group, hour)
+        
+        # Apply corrections
+        color_correction = self.get_color_correction(color)
+        month_correction = self.get_month_correction(month)
+        latitude_correction = self.get_latitude_correction(latitude, month)
+        
+        # Temperature correction
+        temp_correction = (indoor_temp - 25.5) + (outdoor_temp - 35.0)
+        
+        # Calculate corrected CLTD
+        corrected_cltd = cltd + color_correction + month_correction + latitude_correction + temp_correction
+        
+        return max(0, corrected_cltd)  # Ensure non-negative value
+    
+    def interpolate_cltd(self, cltd1: float, cltd2: float, factor: float) -> float:
+        """
+        Interpolate between two CLTD values.
+        
+        Args:
+            cltd1: First CLTD value
+            cltd2: Second CLTD value
+            factor: Interpolation factor (0-1)
+            
+        Returns:
+            Interpolated CLTD value
+        """
+        return cltd1 + factor * (cltd2 - cltd1)
+    
+    def interpolate_scl(self, scl1: float, scl2: float, factor: float) -> float:
+        """
+        Interpolate between two SCL values.
+        
+        Args:
+            scl1: First SCL value
+            scl2: Second SCL value
+            factor: Interpolation factor (0-1)
+            
+        Returns:
+            Interpolated SCL value
+        """
+        return scl1 + factor * (scl2 - scl1)
+    
+    def interpolate_clf(self, clf1: float, clf2: float, factor: float) -> float:
+        """
+        Interpolate between two CLF values.
+        
+        Args:
+            clf1: First CLF value
+            clf2: Second CLF value
+            factor: Interpolation factor (0-1)
+            
+        Returns:
+            Interpolated CLF value
+        """
+        return clf1 + factor * (clf2 - clf1)
+
+
+# Create a singleton instance
+ashrae_tables = ASHRAETables()
+
+# Export tables to CSV if needed
+if __name__ == "__main__":
+    # Export CLTD tables for walls
+    for group, df in ashrae_tables.cltd_wall.items():
+        df.to_csv(os.path.join(DATA_DIR, f"cltd_wall_group_{group}.csv"))
+    
+    # Export CLTD tables for roofs
+    for group, df in ashrae_tables.cltd_roof.items():
+        df.to_csv(os.path.join(DATA_DIR, f"cltd_roof_group_{group}.csv"))
+    
+    # Export SCL table
+    for key, df in ashrae_tables.scl.items():
+        df.to_csv(os.path.join(DATA_DIR, f"scl_{key}.csv"))
+    
+    # Export CLF tables
+    ashrae_tables.clf_lights.to_csv(os.path.join(DATA_DIR, "clf_lights.csv"))
+    ashrae_tables.clf_people.to_csv(os.path.join(DATA_DIR, "clf_people.csv"))
+    ashrae_tables.clf_equipment.to_csv(os.path.join(DATA_DIR, "clf_equipment.csv"))

data/building_components.py

@@ -0,0 +1,465 @@
+"""
+Building component data models for HVAC Load Calculator.
+This module defines the data structures for walls, roofs, floors, windows, doors, and other building components.
+"""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import List, Dict, Optional, Union
+import numpy as np
+
+
+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."""
+    
+    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
+        
+        # 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."""
+    
+    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
+    
+    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)
+    
+    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
+        })
+        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
+    
+    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
+    
+    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
+        })
+        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")
+        
+        if component_type == ComponentType.WALL.value:
+            return Wall(**component_data)
+        elif component_type == ComponentType.ROOF.value:
+            return Roof(**component_data)
+        elif component_type == ComponentType.FLOOR.value:
+            return Floor(**component_data)
+        elif component_type == ComponentType.WINDOW.value:
+            return Window(**component_data)
+        elif component_type == ComponentType.DOOR.value:
+            return Door(**component_data)
+        elif component_type == ComponentType.SKYLIGHT.value:
+            return Skylight(**component_data)
+        else:
+            raise ValueError(f"Unknown component type: {component_type}")

data/climate_data.py

@@ -0,0 +1,428 @@
+"""
+ASHRAE 169 climate data module for HVAC Load Calculator.
+This module provides access to climate data for various locations based on ASHRAE 169 standard.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import json
+from dataclasses import dataclass
+
+# 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
+    
+    # Design conditions
+    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 data
+    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._load_climate_locations()
+        self.countries = sorted(list(set(loc.country for loc in self.locations.values())))
+        self.country_states = self._group_locations_by_country_state()
+    
+    def _load_climate_locations(self) -> Dict[str, ClimateLocation]:
+        """
+        Load climate location data.
+        
+        Returns:
+            Dictionary of climate locations indexed by ID
+        """
+        # This would typically load from a JSON or CSV file with ASHRAE 169 data
+        # For now, we'll define some sample locations inline
+        
+        # Sample monthly data (for all locations in this example)
+        months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        
+        # New York monthly temperatures (°C)
+        ny_temps = {
+            "Jan": 0.5, "Feb": 2.1, "Mar": 6.3, "Apr": 12.5, "May": 18.2, 
+            "Jun": 23.1, "Jul": 25.8, "Aug": 24.9, "Sep": 20.7, "Oct": 14.3, 
+            "Nov": 8.2, "Dec": 2.4
+        }
+        
+        # New York monthly humidity (%)
+        ny_humidity = {
+            "Jan": 65, "Feb": 62, "Mar": 58, "Apr": 55, "May": 60, 
+            "Jun": 65, "Jul": 68, "Aug": 70, "Sep": 68, "Oct": 63, 
+            "Nov": 67, "Dec": 68
+        }
+        
+        # Los Angeles monthly temperatures (°C)
+        la_temps = {
+            "Jan": 14.6, "Feb": 15.1, "Mar": 15.8, "Apr": 17.1, "May": 18.3, 
+            "Jun": 20.1, "Jul": 22.3, "Aug": 22.9, "Sep": 22.1, "Oct": 20.3, 
+            "Nov": 17.2, "Dec": 14.9
+        }
+        
+        # Los Angeles monthly humidity (%)
+        la_humidity = {
+            "Jan": 63, "Feb": 67, "Mar": 70, "Apr": 71, "May": 74, 
+            "Jun": 75, "Jul": 76, "Aug": 76, "Sep": 74, "Oct": 70, 
+            "Nov": 65, "Dec": 63
+        }
+        
+        # Chicago monthly temperatures (°C)
+        chi_temps = {
+            "Jan": -3.5, "Feb": -1.2, "Mar": 4.1, "Apr": 10.3, "May": 16.5, 
+            "Jun": 22.1, "Jul": 24.8, "Aug": 23.9, "Sep": 19.7, "Oct": 12.8, 
+            "Nov": 5.2, "Dec": -1.4
+        }
+        
+        # Chicago monthly humidity (%)
+        chi_humidity = {
+            "Jan": 72, "Feb": 70, "Mar": 65, "Apr": 60, "May": 64, 
+            "Jun": 67, "Jul": 70, "Aug": 73, "Sep": 71, "Oct": 68, 
+            "Nov": 72, "Dec": 75
+        }
+        
+        # London monthly temperatures (°C)
+        lon_temps = {
+            "Jan": 5.2, "Feb": 5.5, "Mar": 7.4, "Apr": 9.9, "May": 13.3, 
+            "Jun": 16.7, "Jul": 18.7, "Aug": 18.3, "Sep": 15.9, "Oct": 12.2, 
+            "Nov": 8.3, "Dec": 5.9
+        }
+        
+        # London monthly humidity (%)
+        lon_humidity = {
+            "Jan": 84, "Feb": 80, "Mar": 76, "Apr": 72, "May": 70, 
+            "Jun": 70, "Jul": 71, "Aug": 72, "Sep": 75, "Oct": 80, 
+            "Nov": 84, "Dec": 86
+        }
+        
+        # Sydney monthly temperatures (°C)
+        syd_temps = {
+            "Jan": 23.5, "Feb": 23.4, "Mar": 22.1, "Apr": 19.5, "May": 16.5, 
+            "Jun": 14.1, "Jul": 13.4, "Aug": 14.5, "Sep": 16.6, "Oct": 18.8, 
+            "Nov": 20.6, "Dec": 22.6
+        }
+        
+        # Sydney monthly humidity (%)
+        syd_humidity = {
+            "Jan": 65, "Feb": 68, "Mar": 68, "Apr": 67, "May": 70, 
+            "Jun": 70, "Jul": 68, "Aug": 63, "Sep": 60, "Oct": 60, 
+            "Nov": 62, "Dec": 63
+        }
+        
+        # Create sample locations
+        locations = {
+            "US-NY-NYC": ClimateLocation(
+                id="US-NY-NYC",
+                country="United States",
+                state_province="New York",
+                city="New York",
+                latitude=40.7128,
+                longitude=-74.0060,
+                elevation=10.0,
+                climate_zone="4A",
+                heating_degree_days=2600,
+                cooling_degree_days=1200,
+                winter_design_temp=-8.3,
+                summer_design_temp_db=32.8,
+                summer_design_temp_wb=25.6,
+                summer_daily_range=8.3,
+                monthly_temps=ny_temps,
+                monthly_humidity=ny_humidity
+            ),
+            "US-CA-LAX": ClimateLocation(
+                id="US-CA-LAX",
+                country="United States",
+                state_province="California",
+                city="Los Angeles",
+                latitude=34.0522,
+                longitude=-118.2437,
+                elevation=93.0,
+                climate_zone="3B",
+                heating_degree_days=800,
+                cooling_degree_days=1200,
+                winter_design_temp=8.3,
+                summer_design_temp_db=32.2,
+                summer_design_temp_wb=23.3,
+                summer_daily_range=6.7,
+                monthly_temps=la_temps,
+                monthly_humidity=la_humidity
+            ),
+            "US-IL-CHI": ClimateLocation(
+                id="US-IL-CHI",
+                country="United States",
+                state_province="Illinois",
+                city="Chicago",
+                latitude=41.8781,
+                longitude=-87.6298,
+                elevation=179.0,
+                climate_zone="5A",
+                heating_degree_days=3500,
+                cooling_degree_days=1000,
+                winter_design_temp=-16.7,
+                summer_design_temp_db=33.3,
+                summer_design_temp_wb=25.6,
+                summer_daily_range=8.9,
+                monthly_temps=chi_temps,
+                monthly_humidity=chi_humidity
+            ),
+            "UK-LDN": ClimateLocation(
+                id="UK-LDN",
+                country="United Kingdom",
+                state_province="England",
+                city="London",
+                latitude=51.5074,
+                longitude=-0.1278,
+                elevation=35.0,
+                climate_zone="4A",
+                heating_degree_days=2500,
+                cooling_degree_days=200,
+                winter_design_temp=-3.9,
+                summer_design_temp_db=28.3,
+                summer_design_temp_wb=20.0,
+                summer_daily_range=10.0,
+                monthly_temps=lon_temps,
+                monthly_humidity=lon_humidity
+            ),
+            "AU-NSW-SYD": ClimateLocation(
+                id="AU-NSW-SYD",
+                country="Australia",
+                state_province="New South Wales",
+                city="Sydney",
+                latitude=-33.8688,
+                longitude=151.2093,
+                elevation=3.0,
+                climate_zone="3C",
+                heating_degree_days=600,
+                cooling_degree_days=900,
+                winter_design_temp=7.2,
+                summer_design_temp_db=31.1,
+                summer_design_temp_wb=24.4,
+                summer_daily_range=7.8,
+                monthly_temps=syd_temps,
+                monthly_humidity=syd_humidity
+            )
+        }
+        
+        return locations
+    
+    def _group_locations_by_country_state(self) -> Dict[str, Dict[str, List[str]]]:
+        """
+        Group locations by country and state/province.
+        
+        Returns:
+            Nested dictionary of countries, states, and cities
+        """
+        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)
+        
+        # Sort states and cities
+        for country in result:
+            for state in result[country]:
+                result[country][state] = sorted(result[country][state])
+        
+        return result
+    
+    def get_location(self, location_id: str) -> Optional[ClimateLocation]:
+        """
+        Get climate location by ID.
+        
+        Args:
+            location_id: Location identifier
+            
+        Returns:
+            ClimateLocation object or None if not found
+        """
+        return self.locations.get(location_id)
+    
+    def find_location(self, country: str, state_province: str = None, city: str = None) -> Optional[ClimateLocation]:
+        """
+        Find a climate location by country, state/province, and city.
+        
+        Args:
+            country: Country name
+            state_province: State or province name (optional)
+            city: City name (optional)
+            
+        Returns:
+            ClimateLocation object or None if not found
+        """
+        for loc in self.locations.values():
+            if loc.country == country:
+                if state_province is None or loc.state_province == state_province:
+                    if city is None or loc.city == city:
+                        return loc
+        return None
+    
+    def find_locations_by_climate_zone(self, climate_zone: str) -> List[ClimateLocation]:
+        """
+        Find climate locations by climate zone.
+        
+        Args:
+            climate_zone: ASHRAE climate zone
+            
+        Returns:
+            List of ClimateLocation objects
+        """
+        return [loc for loc in self.locations.values() if loc.climate_zone == climate_zone]
+    
+    def get_states_for_country(self, country: str) -> List[str]:
+        """
+        Get states/provinces for a country.
+        
+        Args:
+            country: Country name
+            
+        Returns:
+            List of state/province names
+        """
+        if country in self.country_states:
+            return sorted(self.country_states[country].keys())
+        return []
+    
+    def get_cities_for_state(self, country: str, state_province: str) -> List[str]:
+        """
+        Get cities for a state/province.
+        
+        Args:
+            country: Country name
+            state_province: State or province name
+            
+        Returns:
+            List of city names
+        """
+        if country in self.country_states and state_province in self.country_states[country]:
+            return self.country_states[country][state_province]
+        return []
+    
+    def get_location_id(self, country: str, state_province: str, city: str) -> Optional[str]:
+        """
+        Get location ID for a city.
+        
+        Args:
+            country: Country name
+            state_province: State or province name
+            city: City name
+            
+        Returns:
+            Location ID or None if not found
+        """
+        for loc_id, loc in self.locations.items():
+            if (loc.country == country and 
+                loc.state_province == state_province and 
+                loc.city == city):
+                return loc_id
+        return None
+    
+    def export_to_json(self, file_path: str) -> None:
+        """
+        Export all climate data to a JSON file.
+        
+        Args:
+            file_path: Path to the output 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':
+        """
+        Create a ClimateData instance from a JSON file.
+        
+        Args:
+            file_path: Path to the input JSON file
+            
+        Returns:
+            A new ClimateData instance
+        """
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        climate_data = cls()
+        climate_data.locations = {}
+        
+        for loc_id, loc_dict in data.items():
+            climate_data.locations[loc_id] = ClimateLocation(
+                id=loc_dict["id"],
+                country=loc_dict["country"],
+                state_province=loc_dict["state_province"],
+                city=loc_dict["city"],
+                latitude=loc_dict["latitude"],
+                longitude=loc_dict["longitude"],
+                elevation=loc_dict["elevation"],
+                climate_zone=loc_dict["climate_zone"],
+                heating_degree_days=loc_dict["heating_degree_days"],
+                cooling_degree_days=loc_dict["cooling_degree_days"],
+                winter_design_temp=loc_dict["winter_design_temp"],
+                summer_design_temp_db=loc_dict["summer_design_temp_db"],
+                summer_design_temp_wb=loc_dict["summer_design_temp_wb"],
+                summer_daily_range=loc_dict["summer_daily_range"],
+                monthly_temps=loc_dict["monthly_temps"],
+                monthly_humidity=loc_dict["monthly_humidity"]
+            )
+        
+        climate_data.countries = sorted(list(set(loc.country for loc in climate_data.locations.values())))
+        climate_data.country_states = climate_data._group_locations_by_country_state()
+        
+        return climate_data
+
+
+# Create a singleton instance
+climate_data = ClimateData()
+
+# Export climate data to JSON if needed
+if __name__ == "__main__":
+    climate_data.export_to_json(os.path.join(DATA_DIR, "climate_data.json"))

data/reference_data.py

@@ -0,0 +1,613 @@
+"""
+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
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+class ReferenceData:
+    """Class for managing reference data for the HVAC calculator."""
+    
+    def __init__(self):
+        """Initialize reference data structures."""
+        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 from reference data.
+        
+        Returns:
+            Dictionary of material properties
+        """
+        # This would typically load from a JSON or CSV file
+        # For now, we'll define some common materials inline
+        return {
+            "brick": {
+                "name": "Common Brick",
+                "conductivity": 0.72,  # W/(m·K)
+                "density": 1920,  # kg/m³
+                "specific_heat": 840,  # J/(kg·K)
+                "typical_thickness": 0.1  # m
+            },
+            "concrete": {
+                "name": "Concrete",
+                "conductivity": 1.4,  # W/(m·K)
+                "density": 2300,  # kg/m³
+                "specific_heat": 880,  # J/(kg·K)
+                "typical_thickness": 0.2  # m
+            },
+            "mineral_wool": {
+                "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
+            },
+            "eps_insulation": {
+                "name": "EPS Insulation",
+                "conductivity": 0.035,  # W/(m·K)
+                "density": 25,  # kg/m³
+                "specific_heat": 1400,  # J/(kg·K)
+                "typical_thickness": 0.1  # m
+            },
+            "gypsum_board": {
+                "name": "Gypsum Board",
+                "conductivity": 0.25,  # W/(m·K)
+                "density": 900,  # kg/m³
+                "specific_heat": 1000,  # J/(kg·K)
+                "typical_thickness": 0.0125  # m
+            },
+            "wood": {
+                "name": "Wood (Pine)",
+                "conductivity": 0.14,  # W/(m·K)
+                "density": 500,  # kg/m³
+                "specific_heat": 1600,  # J/(kg·K)
+                "typical_thickness": 0.025  # m
+            },
+            "steel": {
+                "name": "Steel",
+                "conductivity": 50,  # W/(m·K)
+                "density": 7800,  # kg/m³
+                "specific_heat": 450,  # J/(kg·K)
+                "typical_thickness": 0.005  # m
+            },
+            "glass": {
+                "name": "Glass",
+                "conductivity": 1.0,  # W/(m·K)
+                "density": 2500,  # kg/m³
+                "specific_heat": 840,  # J/(kg·K)
+                "typical_thickness": 0.006  # m
+            },
+            "air_gap": {
+                "name": "Air Gap",
+                "conductivity": 0.024,  # W/(m·K)
+                "density": 1.2,  # kg/m³
+                "specific_heat": 1000,  # J/(kg·K)
+                "typical_thickness": 0.025  # m
+            },
+            "concrete_block": {
+                "name": "Concrete Block",
+                "conductivity": 0.51,  # W/(m·K)
+                "density": 1400,  # kg/m³
+                "specific_heat": 1000,  # J/(kg·K)
+                "typical_thickness": 0.2  # m
+            },
+            "asphalt_shingle": {
+                "name": "Asphalt Shingle",
+                "conductivity": 0.7,  # W/(m·K)
+                "density": 1100,  # kg/m³
+                "specific_heat": 1260,  # J/(kg·K)
+                "typical_thickness": 0.006  # m
+            },
+            "carpet": {
+                "name": "Carpet",
+                "conductivity": 0.06,  # W/(m·K)
+                "density": 200,  # kg/m³
+                "specific_heat": 1300,  # J/(kg·K)
+                "typical_thickness": 0.01  # m
+            },
+            "vinyl_flooring": {
+                "name": "Vinyl Flooring",
+                "conductivity": 0.17,  # W/(m·K)
+                "density": 1200,  # kg/m³
+                "specific_heat": 1460,  # J/(kg·K)
+                "typical_thickness": 0.003  # m
+            }
+        }
+    
+    def _load_wall_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined wall types from reference data.
+        
+        Returns:
+            Dictionary of wall types with properties
+        """
+        return {
+            "brick_veneer_wood_frame": {
+                "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",  # ASHRAE wall group
+                "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}
+                ]
+            },
+            "concrete_block_insulated": {
+                "name": "Concrete block with interior insulation",
+                "description": "Concrete block wall with interior insulation and gypsum board",
+                "u_value": 0.48,  # W/(m²·K)
+                "wall_group": "C",  # ASHRAE wall group
+                "layers": [
+                    {"material": "concrete_block", "thickness": 0.2},
+                    {"material": "eps_insulation", "thickness": 0.05},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            },
+            "precast_concrete_panel": {
+                "name": "Precast concrete panel",
+                "description": "Precast concrete panel with insulation and gypsum board",
+                "u_value": 0.45,  # W/(m²·K)
+                "wall_group": "D",  # ASHRAE wall group
+                "layers": [
+                    {"material": "concrete", "thickness": 0.1},
+                    {"material": "eps_insulation", "thickness": 0.075},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            },
+            "metal_panel_insulated": {
+                "name": "Metal panel with insulation",
+                "description": "Metal panel wall with insulation and interior finish",
+                "u_value": 0.4,  # W/(m²·K)
+                "wall_group": "E",  # ASHRAE wall group
+                "layers": [
+                    {"material": "steel", "thickness": 0.001},
+                    {"material": "mineral_wool", "thickness": 0.1},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            },
+            "wood_frame_wall": {
+                "name": "Wood frame wall",
+                "description": "Wood frame wall with insulation and gypsum board",
+                "u_value": 0.3,  # W/(m²·K)
+                "wall_group": "A",  # ASHRAE wall group
+                "layers": [
+                    {"material": "wood", "thickness": 0.019},
+                    {"material": "air_gap", "thickness": 0.025},
+                    {"material": "wood", "thickness": 0.038},
+                    {"material": "mineral_wool", "thickness": 0.14},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            }
+        }
+    
+    def _load_roof_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined roof types from reference data.
+        
+        Returns:
+            Dictionary of roof types with properties
+        """
+        return {
+            "flat_roof_concrete": {
+                "name": "Flat concrete roof with insulation",
+                "description": "Flat concrete roof with insulation and ceiling",
+                "u_value": 0.25,  # W/(m²·K)
+                "roof_group": "B",  # ASHRAE roof group
+                "layers": [
+                    {"material": "concrete", "thickness": 0.15},
+                    {"material": "eps_insulation", "thickness": 0.15},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            },
+            "pitched_roof_wood": {
+                "name": "Pitched wood roof with insulation",
+                "description": "Pitched wood roof with insulation and ceiling",
+                "u_value": 0.2,  # W/(m²·K)
+                "roof_group": "A",  # ASHRAE roof group
+                "layers": [
+                    {"material": "asphalt_shingle", "thickness": 0.006},
+                    {"material": "wood", "thickness": 0.019},
+                    {"material": "air_gap", "thickness": 0.025},
+                    {"material": "mineral_wool", "thickness": 0.2},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            },
+            "metal_deck_roof": {
+                "name": "Metal deck roof with insulation",
+                "description": "Metal deck roof with insulation and ceiling",
+                "u_value": 0.3,  # W/(m²·K)
+                "roof_group": "C",  # ASHRAE roof group
+                "layers": [
+                    {"material": "steel", "thickness": 0.001},
+                    {"material": "eps_insulation", "thickness": 0.1},
+                    {"material": "air_gap", "thickness": 0.1},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            }
+        }
+    
+    def _load_floor_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined floor types from reference data.
+        
+        Returns:
+            Dictionary of floor types with properties
+        """
+        return {
+            "concrete_slab_on_grade": {
+                "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}
+                ]
+            },
+            "suspended_concrete_floor": {
+                "name": "Suspended concrete floor",
+                "description": "Suspended concrete floor with insulation",
+                "u_value": 0.25,  # W/(m²·K)
+                "is_ground_contact": False,
+                "layers": [
+                    {"material": "concrete", "thickness": 0.15},
+                    {"material": "eps_insulation", "thickness": 0.1},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            },
+            "wood_joist_floor": {
+                "name": "Wood joist floor",
+                "description": "Wood joist floor with insulation",
+                "u_value": 0.22,  # W/(m²·K)
+                "is_ground_contact": False,
+                "layers": [
+                    {"material": "wood", "thickness": 0.025},
+                    {"material": "air_gap", "thickness": 0.15},
+                    {"material": "mineral_wool", "thickness": 0.15},
+                    {"material": "gypsum_board", "thickness": 0.0125}
+                ]
+            },
+            "carpet_on_concrete": {
+                "name": "Carpet on concrete",
+                "description": "Carpet on concrete slab with insulation",
+                "u_value": 0.28,  # W/(m²·K)
+                "is_ground_contact": True,
+                "layers": [
+                    {"material": "carpet", "thickness": 0.01},
+                    {"material": "concrete", "thickness": 0.1},
+                    {"material": "eps_insulation", "thickness": 0.05}
+                ]
+            }
+        }
+    
+    def _load_window_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined window types from reference data.
+        
+        Returns:
+            Dictionary of window types with properties
+        """
+        return {
+            "single_glazed": {
+                "name": "Single glazed window",
+                "description": "Single glazed window with aluminum frame",
+                "u_value": 5.8,  # W/(m²·K)
+                "shgc": 0.86,  # Solar Heat Gain Coefficient
+                "vt": 0.9,  # Visible Transmittance
+                "glazing_layers": 1,
+                "gas_fill": "Air",
+                "frame_type": "Aluminum",
+                "low_e_coating": False
+            },
+            "double_glazed_air": {
+                "name": "Double glazed window with air",
+                "description": "Double glazed window with air gap and aluminum frame",
+                "u_value": 2.8,  # W/(m²·K)
+                "shgc": 0.76,  # Solar Heat Gain Coefficient
+                "vt": 0.81,  # Visible Transmittance
+                "glazing_layers": 2,
+                "gas_fill": "Air",
+                "frame_type": "Aluminum",
+                "low_e_coating": False
+            },
+            "double_glazed_argon_low_e": {
+                "name": "Double glazed window with argon and low-e coating",
+                "description": "Double glazed window with argon fill, low-e coating, and vinyl frame",
+                "u_value": 1.4,  # W/(m²·K)
+                "shgc": 0.4,  # Solar Heat Gain Coefficient
+                "vt": 0.7,  # Visible Transmittance
+                "glazing_layers": 2,
+                "gas_fill": "Argon",
+                "frame_type": "Vinyl",
+                "low_e_coating": True
+            },
+            "triple_glazed_argon_low_e": {
+                "name": "Triple glazed window with argon and low-e coating",
+                "description": "Triple glazed window with argon fill, low-e coating, and vinyl frame",
+                "u_value": 0.8,  # W/(m²·K)
+                "shgc": 0.3,  # Solar Heat Gain Coefficient
+                "vt": 0.6,  # Visible Transmittance
+                "glazing_layers": 3,
+                "gas_fill": "Argon",
+                "frame_type": "Vinyl",
+                "low_e_coating": True
+            }
+        }
+    
+    def _load_door_types(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load predefined door types from reference data.
+        
+        Returns:
+            Dictionary of door types with properties
+        """
+        return {
+            "solid_wood_door": {
+                "name": "Solid wood door",
+                "description": "Solid wood door with no glazing",
+                "u_value": 2.2,  # W/(m²·K)
+                "glazing_percentage": 0,
+                "door_type": "Solid"
+            },
+            "insulated_steel_door": {
+                "name": "Insulated steel door",
+                "description": "Insulated steel door with no glazing",
+                "u_value": 1.2,  # W/(m²·K)
+                "glazing_percentage": 0,
+                "door_type": "Solid"
+            },
+            "partially_glazed_door": {
+                "name": "Partially glazed door",
+                "description": "Wood door with 25% glazing",
+                "u_value": 2.8,  # W/(m²·K)
+                "glazing_percentage": 25,
+                "door_type": "Partially glazed",
+                "shgc": 0.76,  # Solar Heat Gain Coefficient for the glazed portion
+                "vt": 0.81  # Visible Transmittance for the glazed portion
+            },
+            "glass_door": {
+                "name": "Glass door",
+                "description": "Full glass door with aluminum frame",
+                "u_value": 3.8,  # W/(m²·K)
+                "glazing_percentage": 90,
+                "door_type": "Glass",
+                "shgc": 0.76,  # Solar Heat Gain Coefficient
+                "vt": 0.81  # Visible Transmittance
+            }
+        }
+    
+    def _load_internal_loads(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Load internal load data from reference data.
+        
+        Returns:
+            Dictionary of internal load types with properties
+        """
+        return {
+            "occupancy": {
+                "seated_very_light_work": {
+                    "name": "Seated, very light work",
+                    "sensible_heat": 70,  # W per person
+                    "latent_heat": 45  # W per person
+                },
+                "office_work_standing": {
+                    "name": "Office work, standing",
+                    "sensible_heat": 75,  # W per person
+                    "latent_heat": 55  # W per person
+                },
+                "light_physical_work": {
+                    "name": "Light physical work",
+                    "sensible_heat": 80,  # W per person
+                    "latent_heat": 140  # W per person
+                },
+                "medium_physical_work": {
+                    "name": "Medium physical work",
+                    "sensible_heat": 90,  # W per person
+                    "latent_heat": 185  # W per person
+                },
+                "heavy_physical_work": {
+                    "name": "Heavy physical work",
+                    "sensible_heat": 170,  # W per person
+                    "latent_heat": 255  # W per person
+                }
+            },
+            "lighting": {
+                "led": {
+                    "name": "LED",
+                    "power_density_range": [5, 10],  # W/m²
+                    "heat_to_space": 0.9  # Fraction of power that becomes heat
+                },
+                "fluorescent": {
+                    "name": "Fluorescent",
+                    "power_density_range": [10, 15],  # W/m²
+                    "heat_to_space": 0.95  # Fraction of power that becomes heat
+                },
+                "incandescent": {
+                    "name": "Incandescent",
+                    "power_density_range": [15, 25],  # W/m²
+                    "heat_to_space": 0.98  # Fraction of power that becomes heat
+                },
+                "halogen": {
+                    "name": "Halogen",
+                    "power_density_range": [12, 20],  # W/m²
+                    "heat_to_space": 0.97  # Fraction of power that becomes heat
+                }
+            },
+            "equipment": {
+                "office_equipment": {
+                    "name": "Office Equipment",
+                    "power_density_range": [10, 20],  # W/m²
+                    "sensible_fraction": 0.9,
+                    "latent_fraction": 0.1
+                },
+                "kitchen_equipment": {
+                    "name": "Kitchen Equipment",
+                    "power_density_range": [30, 200],  # W/m²
+                    "sensible_fraction": 0.6,
+                    "latent_fraction": 0.4
+                },
+                "manufacturing_equipment": {
+                    "name": "Manufacturing Equipment",
+                    "power_density_range": [20, 100],  # W/m²
+                    "sensible_fraction": 0.8,
+                    "latent_fraction": 0.2
+                }
+            }
+        }
+    
+    def get_material(self, material_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get material properties by ID.
+        
+        Args:
+            material_id: Material identifier
+            
+        Returns:
+            Dictionary of material properties or None if not found
+        """
+        return self.materials.get(material_id)
+    
+    def get_wall_type(self, wall_type_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get wall type properties by ID.
+        
+        Args:
+            wall_type_id: Wall type identifier
+            
+        Returns:
+            Dictionary of wall type properties or None if not found
+        """
+        return self.wall_types.get(wall_type_id)
+    
+    def get_roof_type(self, roof_type_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get roof type properties by ID.
+        
+        Args:
+            roof_type_id: Roof type identifier
+            
+        Returns:
+            Dictionary of roof type properties or None if not found
+        """
+        return self.roof_types.get(roof_type_id)
+    
+    def get_floor_type(self, floor_type_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get floor type properties by ID.
+        
+        Args:
+            floor_type_id: Floor type identifier
+            
+        Returns:
+            Dictionary of floor type properties or None if not found
+        """
+        return self.floor_types.get(floor_type_id)
+    
+    def get_window_type(self, window_type_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get window type properties by ID.
+        
+        Args:
+            window_type_id: Window type identifier
+            
+        Returns:
+            Dictionary of window type properties or None if not found
+        """
+        return self.window_types.get(window_type_id)
+    
+    def get_door_type(self, door_type_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get door type properties by ID.
+        
+        Args:
+            door_type_id: Door type identifier
+            
+        Returns:
+            Dictionary of door type properties or None if not found
+        """
+        return self.door_types.get(door_type_id)
+    
+    def get_internal_load(self, load_type: str, load_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get internal load properties by type and ID.
+        
+        Args:
+            load_type: Type of internal load (occupancy, lighting, equipment)
+            load_id: Internal load identifier
+            
+        Returns:
+            Dictionary of internal load properties or None if not found
+        """
+        if load_type in self.internal_loads:
+            return self.internal_loads[load_type].get(load_id)
+        return None
+    
+    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
+        """
+        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)
+    
+    @classmethod
+    def from_json(cls, file_path: str) -> 'ReferenceData':
+        """
+        Create a ReferenceData instance from a JSON file.
+        
+        Args:
+            file_path: Path to the input JSON file
+            
+        Returns:
+            A new ReferenceData instance
+        """
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        
+        ref_data = cls()
+        ref_data.materials = data.get("materials", ref_data.materials)
+        ref_data.wall_types = data.get("wall_types", ref_data.wall_types)
+        ref_data.roof_types = data.get("roof_types", ref_data.roof_types)
+        ref_data.floor_types = data.get("floor_types", ref_data.floor_types)
+        ref_data.window_types = data.get("window_types", ref_data.window_types)
+        ref_data.door_types = data.get("door_types", ref_data.door_types)
+        ref_data.internal_loads = data.get("internal_loads", ref_data.internal_loads)
+        
+        return ref_data
+
+
+# Create a singleton instance
+reference_data = ReferenceData()
+
+# Export reference data to JSON if needed
+if __name__ == "__main__":
+    reference_data.export_to_json(os.path.join(DATA_DIR, "reference_data.json"))

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=0.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=0.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=0.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=0.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=0.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,774 @@
+"""
+Cooling load calculation module for HVAC Load Calculator.
+This module implements the CLTD/CLF method for calculating cooling loads.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import math
+import numpy as np
+import pandas as pd
+import os
+from datetime import datetime, timedelta
+from enum import Enum
+
+# Import data models and utilities
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+from data.ashrae_tables import ashrae_tables
+from utils.psychrometrics import Psychrometrics
+from utils.heat_transfer import HeatTransferCalculations
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+class CoolingLoadCalculator:
+    """Class for calculating cooling loads using the CLTD/CLF method."""
+    
+    def __init__(self):
+        """Initialize cooling load calculator."""
+        self.heat_transfer = HeatTransferCalculations()
+        self.psychrometrics = Psychrometrics()
+        self.ashrae_tables = ashrae_tables
+    
+    def calculate_wall_cooling_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float, 
+                                   month: str, hour: int, latitude: str = "40N",
+                                   color: str = "Dark") -> float:
+        """
+        Calculate cooling load through a wall using the CLTD method.
+        
+        Args:
+            wall: Wall object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            hour: Hour of the day (0-23)
+            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
+            color: Surface color (Dark, Medium, Light)
+            
+        Returns:
+            Cooling load in W
+        """
+        # Get wall properties
+        u_value = wall.u_value
+        area = wall.area
+        orientation = wall.orientation.value
+        wall_group = wall.wall_group
+        
+        # Calculate corrected CLTD
+        cltd = self.ashrae_tables.calculate_corrected_cltd_wall(
+            wall_group=wall_group,
+            orientation=orientation,
+            hour=hour,
+            color=color,
+            month=month,
+            latitude=latitude,
+            indoor_temp=indoor_temp,
+            outdoor_temp=outdoor_temp
+        )
+        
+        # Calculate cooling load
+        cooling_load = u_value * area * cltd
+        
+        return cooling_load
+    
+    def calculate_roof_cooling_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float, 
+                                   month: str, hour: int, latitude: str = "40N",
+                                   color: str = "Dark") -> float:
+        """
+        Calculate cooling load through a roof using the CLTD method.
+        
+        Args:
+            roof: Roof object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            hour: Hour of the day (0-23)
+            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
+            color: Surface color (Dark, Medium, Light)
+            
+        Returns:
+            Cooling load in W
+        """
+        # Get roof properties
+        u_value = roof.u_value
+        area = roof.area
+        roof_group = roof.roof_group
+        
+        # Calculate corrected CLTD
+        cltd = self.ashrae_tables.calculate_corrected_cltd_roof(
+            roof_group=roof_group,
+            hour=hour,
+            color=color,
+            month=month,
+            latitude=latitude,
+            indoor_temp=indoor_temp,
+            outdoor_temp=outdoor_temp
+        )
+        
+        # Calculate cooling load
+        cooling_load = u_value * area * cltd
+        
+        return cooling_load
+    
+    def calculate_window_cooling_load(self, window: Window, outdoor_temp: float, indoor_temp: float, 
+                                     month: str, hour: int, latitude: str = "40N_JUL",
+                                     shading_coefficient: float = 1.0) -> Dict[str, float]:
+        """
+        Calculate cooling load through a window using the CLTD/SCL method.
+        
+        Args:
+            window: Window object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            hour: Hour of the day (0-23)
+            latitude: Latitude and month key (default: "40N_JUL")
+            shading_coefficient: Shading coefficient (0-1)
+            
+        Returns:
+            Dictionary with conduction, solar, and total cooling loads in W
+        """
+        # Get window properties
+        u_value = window.u_value
+        area = window.area
+        orientation = window.orientation.value
+        shgc = window.shgc
+        
+        # Calculate conduction cooling load
+        delta_t = outdoor_temp - indoor_temp
+        conduction_load = u_value * area * delta_t
+        
+        # Calculate solar cooling load
+        scl = self.ashrae_tables.get_scl(orientation, hour, latitude)
+        solar_load = area * shgc * shading_coefficient * scl
+        
+        # Calculate total cooling load
+        total_load = conduction_load + solar_load
+        
+        return {
+            "conduction": conduction_load,
+            "solar": solar_load,
+            "total": total_load
+        }
+    
+    def calculate_door_cooling_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate cooling load through a door using simple conduction.
+        
+        Args:
+            door: Door object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Cooling load in W
+        """
+        # Get door properties
+        u_value = door.u_value
+        area = door.area
+        
+        # Calculate cooling load
+        delta_t = outdoor_temp - indoor_temp
+        cooling_load = u_value * area * delta_t
+        
+        return cooling_load
+    
+    def calculate_floor_cooling_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate cooling load through a floor.
+        
+        Args:
+            floor: Floor object
+            ground_temp: Ground or adjacent space temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Cooling load in W
+        """
+        # Get floor properties
+        u_value = floor.u_value
+        area = floor.area
+        
+        # Calculate cooling load
+        delta_t = ground_temp - indoor_temp
+        cooling_load = u_value * area * delta_t
+        
+        # Return positive value for heat gain, zero for heat loss
+        return max(0, cooling_load)
+    
+    def calculate_infiltration_cooling_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
+                                          outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+        """
+        Calculate sensible and latent cooling loads due to infiltration.
+        
+        Args:
+            flow_rate: Infiltration flow rate in m³/s
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            outdoor_rh: Outdoor relative humidity in %
+            indoor_rh: Indoor relative humidity in %
+            
+        Returns:
+            Dictionary with sensible, latent, and total cooling loads in W
+        """
+        # Calculate sensible cooling load
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(
+            flow_rate=flow_rate,
+            delta_t=outdoor_temp - indoor_temp
+        )
+        
+        # Calculate humidity ratios
+        w_outdoor = self.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
+        w_indoor = self.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
+        
+        # Calculate latent cooling load
+        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+            flow_rate=flow_rate,
+            delta_w=w_outdoor - w_indoor
+        )
+        
+        # Calculate total cooling load
+        total_load = sensible_load + latent_load
+        
+        return {
+            "sensible": sensible_load,
+            "latent": latent_load,
+            "total": total_load
+        }
+    
+    def calculate_ventilation_cooling_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
+                                         outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+        """
+        Calculate sensible and latent cooling loads due to ventilation.
+        
+        Args:
+            flow_rate: Ventilation flow rate in m³/s
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            outdoor_rh: Outdoor relative humidity in %
+            indoor_rh: Indoor relative humidity in %
+            
+        Returns:
+            Dictionary with sensible, latent, and total cooling loads in W
+        """
+        # Ventilation load calculation is the same as infiltration
+        return self.calculate_infiltration_cooling_load(
+            flow_rate=flow_rate,
+            outdoor_temp=outdoor_temp,
+            indoor_temp=indoor_temp,
+            outdoor_rh=outdoor_rh,
+            indoor_rh=indoor_rh
+        )
+    
+    def calculate_people_cooling_load(self, num_people: int, activity_level: str, 
+                                    hours_occupancy: str, hour: int) -> Dict[str, float]:
+        """
+        Calculate sensible and latent cooling loads due to people.
+        
+        Args:
+            num_people: Number of people
+            activity_level: Activity level (Seated/Resting, Light work, Medium work, Heavy work)
+            hours_occupancy: Hours of occupancy (8h, 10h, 12h, 14h, 16h, 18h, 24h)
+            hour: Hour of the day (0-23)
+            
+        Returns:
+            Dictionary with sensible, latent, and total cooling loads in W
+        """
+        # Define heat gains for different activity levels
+        activity_gains = {
+            "Seated/Resting": {"sensible": 70, "latent": 45},
+            "Light work": {"sensible": 75, "latent": 55},
+            "Medium work": {"sensible": 85, "latent": 80},
+            "Heavy work": {"sensible": 95, "latent": 145}
+        }
+        
+        # Get heat gains for the specified activity level
+        if activity_level not in activity_gains:
+            raise ValueError(f"Invalid activity level: {activity_level}")
+        
+        sensible_gain = activity_gains[activity_level]["sensible"]
+        latent_gain = activity_gains[activity_level]["latent"]
+        
+        # Get CLF for the specified hour and occupancy
+        clf = self.ashrae_tables.get_clf_people(hour, hours_occupancy)
+        
+        # Calculate cooling loads
+        sensible_load = num_people * sensible_gain * clf
+        latent_load = num_people * latent_gain  # Latent load is not affected by CLF
+        total_load = sensible_load + latent_load
+        
+        return {
+            "sensible": sensible_load,
+            "latent": latent_load,
+            "total": total_load
+        }
+    
+    def calculate_lights_cooling_load(self, power: float, use_factor: float, 
+                                    special_allowance: float, hours_operation: str, 
+                                    hour: int) -> float:
+        """
+        Calculate cooling load due to lights.
+        
+        Args:
+            power: Installed lighting power in W
+            use_factor: Usage factor (0-1)
+            special_allowance: Special allowance factor for fixtures (0-1)
+            hours_operation: Hours of operation (8h, 10h, 12h, 14h, 16h, 18h, 24h)
+            hour: Hour of the day (0-23)
+            
+        Returns:
+            Cooling load in W
+        """
+        # Get CLF for the specified hour and operation
+        clf = self.ashrae_tables.get_clf_lights(hour, hours_operation)
+        
+        # Calculate cooling load
+        cooling_load = power * use_factor * (1 + special_allowance) * clf
+        
+        return cooling_load
+    
+    def calculate_equipment_cooling_load(self, power: float, use_factor: float, 
+                                       radiation_factor: float, hours_operation: str, 
+                                       hour: int) -> Dict[str, float]:
+        """
+        Calculate sensible and latent cooling loads due to equipment.
+        
+        Args:
+            power: Equipment power in W
+            use_factor: Usage factor (0-1)
+            radiation_factor: Radiation factor (0-1)
+            hours_operation: Hours of operation (8h, 10h, 12h, 14h, 16h, 18h, 24h)
+            hour: Hour of the day (0-23)
+            
+        Returns:
+            Dictionary with sensible, latent, and total cooling loads in W
+        """
+        # Get CLF for the specified hour and operation
+        clf = self.ashrae_tables.get_clf_equipment(hour, hours_operation)
+        
+        # Calculate sensible cooling load
+        sensible_load = power * use_factor * radiation_factor * clf
+        
+        # Calculate latent cooling load (if any)
+        latent_load = power * use_factor * (1 - radiation_factor)
+        
+        # Calculate total cooling load
+        total_load = sensible_load + latent_load
+        
+        return {
+            "sensible": sensible_load,
+            "latent": latent_load,
+            "total": total_load
+        }
+    
+    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]) -> Dict[int, Dict[str, float]]:
+        """
+        Calculate hourly cooling loads for a building.
+        
+        Args:
+            building_components: Dictionary with lists of building components
+            outdoor_conditions: Dictionary with outdoor conditions
+            indoor_conditions: Dictionary with indoor conditions
+            internal_loads: Dictionary with internal loads
+            
+        Returns:
+            Dictionary with hourly cooling loads
+        """
+        # Extract building components
+        walls = building_components.get("walls", [])
+        roofs = building_components.get("roofs", [])
+        floors = building_components.get("floors", [])
+        windows = building_components.get("windows", [])
+        doors = building_components.get("doors", [])
+        
+        # Extract outdoor conditions
+        outdoor_temp = outdoor_conditions.get("temperature", 35.0)
+        outdoor_rh = outdoor_conditions.get("relative_humidity", 50.0)
+        ground_temp = outdoor_conditions.get("ground_temperature", 20.0)
+        month = outdoor_conditions.get("month", "Jul")
+        latitude = outdoor_conditions.get("latitude", "40N")
+        
+        # Extract indoor conditions
+        indoor_temp = indoor_conditions.get("temperature", 24.0)
+        indoor_rh = indoor_conditions.get("relative_humidity", 50.0)
+        
+        # Extract internal loads
+        people = internal_loads.get("people", {})
+        lights = internal_loads.get("lights", {})
+        equipment = internal_loads.get("equipment", {})
+        infiltration = internal_loads.get("infiltration", {})
+        ventilation = internal_loads.get("ventilation", {})
+        
+        # Initialize hourly cooling loads
+        hourly_loads = {}
+        
+        # Calculate cooling loads for each hour
+        for hour in range(24):
+            # Initialize loads for this hour
+            loads = {
+                "walls": 0,
+                "roofs": 0,
+                "floors": 0,
+                "windows_conduction": 0,
+                "windows_solar": 0,
+                "doors": 0,
+                "infiltration_sensible": 0,
+                "infiltration_latent": 0,
+                "ventilation_sensible": 0,
+                "ventilation_latent": 0,
+                "people_sensible": 0,
+                "people_latent": 0,
+                "lights": 0,
+                "equipment_sensible": 0,
+                "equipment_latent": 0,
+                "total_sensible": 0,
+                "total_latent": 0,
+                "total": 0
+            }
+            
+            # Calculate wall loads
+            for wall in walls:
+                wall_load = self.calculate_wall_cooling_load(
+                    wall=wall,
+                    outdoor_temp=outdoor_temp,
+                    indoor_temp=indoor_temp,
+                    month=month,
+                    hour=hour,
+                    latitude=latitude,
+                    color=wall.color if hasattr(wall, "color") else "Dark"
+                )
+                loads["walls"] += wall_load
+            
+            # Calculate roof loads
+            for roof in roofs:
+                roof_load = self.calculate_roof_cooling_load(
+                    roof=roof,
+                    outdoor_temp=outdoor_temp,
+                    indoor_temp=indoor_temp,
+                    month=month,
+                    hour=hour,
+                    latitude=latitude,
+                    color=roof.color if hasattr(roof, "color") else "Dark"
+                )
+                loads["roofs"] += roof_load
+            
+            # Calculate floor loads
+            for floor in floors:
+                floor_load = self.calculate_floor_cooling_load(
+                    floor=floor,
+                    ground_temp=ground_temp,
+                    indoor_temp=indoor_temp
+                )
+                loads["floors"] += floor_load
+            
+            # Calculate window loads
+            for window in windows:
+                window_loads = self.calculate_window_cooling_load(
+                    window=window,
+                    outdoor_temp=outdoor_temp,
+                    indoor_temp=indoor_temp,
+                    month=month,
+                    hour=hour,
+                    latitude=f"{latitude}_{month.upper()}",
+                    shading_coefficient=window.shading_coefficient if hasattr(window, "shading_coefficient") else 1.0
+                )
+                loads["windows_conduction"] += window_loads["conduction"]
+                loads["windows_solar"] += window_loads["solar"]
+            
+            # Calculate door loads
+            for door in doors:
+                door_load = self.calculate_door_cooling_load(
+                    door=door,
+                    outdoor_temp=outdoor_temp,
+                    indoor_temp=indoor_temp
+                )
+                loads["doors"] += door_load
+            
+            # Calculate infiltration loads
+            if infiltration:
+                flow_rate = infiltration.get("flow_rate", 0.0)
+                infiltration_loads = self.calculate_infiltration_cooling_load(
+                    flow_rate=flow_rate,
+                    outdoor_temp=outdoor_temp,
+                    indoor_temp=indoor_temp,
+                    outdoor_rh=outdoor_rh,
+                    indoor_rh=indoor_rh
+                )
+                loads["infiltration_sensible"] = infiltration_loads["sensible"]
+                loads["infiltration_latent"] = infiltration_loads["latent"]
+            
+            # Calculate ventilation loads
+            if ventilation:
+                flow_rate = ventilation.get("flow_rate", 0.0)
+                ventilation_loads = self.calculate_ventilation_cooling_load(
+                    flow_rate=flow_rate,
+                    outdoor_temp=outdoor_temp,
+                    indoor_temp=indoor_temp,
+                    outdoor_rh=outdoor_rh,
+                    indoor_rh=indoor_rh
+                )
+                loads["ventilation_sensible"] = ventilation_loads["sensible"]
+                loads["ventilation_latent"] = ventilation_loads["latent"]
+            
+            # Calculate people loads
+            if people:
+                num_people = people.get("number", 0)
+                activity_level = people.get("activity_level", "Seated/Resting")
+                hours_occupancy = people.get("hours_occupancy", "8h")
+                
+                people_loads = self.calculate_people_cooling_load(
+                    num_people=num_people,
+                    activity_level=activity_level,
+                    hours_occupancy=hours_occupancy,
+                    hour=hour
+                )
+                loads["people_sensible"] = people_loads["sensible"]
+                loads["people_latent"] = people_loads["latent"]
+            
+            # Calculate lights loads
+            if lights:
+                power = lights.get("power", 0.0)
+                use_factor = lights.get("use_factor", 1.0)
+                special_allowance = lights.get("special_allowance", 0.0)
+                hours_operation = lights.get("hours_operation", "8h")
+                
+                lights_load = self.calculate_lights_cooling_load(
+                    power=power,
+                    use_factor=use_factor,
+                    special_allowance=special_allowance,
+                    hours_operation=hours_operation,
+                    hour=hour
+                )
+                loads["lights"] = lights_load
+            
+            # Calculate equipment loads
+            if equipment:
+                power = equipment.get("power", 0.0)
+                use_factor = equipment.get("use_factor", 1.0)
+                radiation_factor = equipment.get("radiation_factor", 0.7)
+                hours_operation = equipment.get("hours_operation", "8h")
+                
+                equipment_loads = self.calculate_equipment_cooling_load(
+                    power=power,
+                    use_factor=use_factor,
+                    radiation_factor=radiation_factor,
+                    hours_operation=hours_operation,
+                    hour=hour
+                )
+                loads["equipment_sensible"] = equipment_loads["sensible"]
+                loads["equipment_latent"] = equipment_loads["latent"]
+            
+            # Calculate total loads
+            loads["total_sensible"] = (
+                loads["walls"] + loads["roofs"] + loads["floors"] +
+                loads["windows_conduction"] + loads["windows_solar"] +
+                loads["doors"] + loads["infiltration_sensible"] +
+                loads["ventilation_sensible"] + loads["people_sensible"] +
+                loads["lights"] + loads["equipment_sensible"]
+            )
+            
+            loads["total_latent"] = (
+                loads["infiltration_latent"] + loads["ventilation_latent"] +
+                loads["people_latent"] + loads["equipment_latent"]
+            )
+            
+            loads["total"] = loads["total_sensible"] + loads["total_latent"]
+            
+            # Store loads for this hour
+            hourly_loads[hour] = loads
+        
+        return hourly_loads
+    
+    def calculate_design_cooling_load(self, hourly_loads: Dict[int, Dict[str, float]]) -> Dict[str, float]:
+        """
+        Calculate design cooling load based on hourly loads.
+        
+        Args:
+            hourly_loads: Dictionary with hourly cooling loads
+            
+        Returns:
+            Dictionary with design cooling loads
+        """
+        # Find hour with maximum total load
+        max_hour = max(hourly_loads.keys(), key=lambda h: hourly_loads[h]["total"])
+        
+        # Get loads for the design hour
+        design_loads = hourly_loads[max_hour].copy()
+        
+        # Add design hour information
+        design_loads["design_hour"] = max_hour
+        
+        return design_loads
+    
+    def calculate_cooling_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
+        """
+        Calculate cooling load summary.
+        
+        Args:
+            design_loads: Dictionary with design cooling loads
+            
+        Returns:
+            Dictionary with cooling load summary
+        """
+        # Calculate envelope loads
+        envelope_loads = (
+            design_loads["walls"] + design_loads["roofs"] + design_loads["floors"] +
+            design_loads["windows_conduction"] + design_loads["windows_solar"] +
+            design_loads["doors"]
+        )
+        
+        # Calculate ventilation and infiltration loads
+        ventilation_loads = design_loads["ventilation_sensible"] + design_loads["ventilation_latent"]
+        infiltration_loads = design_loads["infiltration_sensible"] + design_loads["infiltration_latent"]
+        
+        # Calculate internal loads
+        internal_loads = (
+            design_loads["people_sensible"] + design_loads["people_latent"] +
+            design_loads["lights"] + design_loads["equipment_sensible"] + design_loads["equipment_latent"]
+        )
+        
+        # Calculate sensible heat ratio
+        shr = design_loads["total_sensible"] / design_loads["total"] if design_loads["total"] > 0 else 1.0
+        
+        # Create summary
+        summary = {
+            "envelope_loads": envelope_loads,
+            "ventilation_loads": ventilation_loads,
+            "infiltration_loads": infiltration_loads,
+            "internal_loads": internal_loads,
+            "total_sensible": design_loads["total_sensible"],
+            "total_latent": design_loads["total_latent"],
+            "total": design_loads["total"],
+            "sensible_heat_ratio": shr,
+            "design_hour": design_loads["design_hour"]
+        }
+        
+        return summary
+
+
+# Create a singleton instance
+cooling_load_calculator = CoolingLoadCalculator()
+
+# Example usage
+if __name__ == "__main__":
+    # Create sample building components
+    from data.building_components import Wall, Roof, Window, Door, Orientation, ComponentType
+    
+    # Create a sample wall
+    wall = Wall(
+        id="wall1",
+        name="Exterior Wall",
+        component_type=ComponentType.WALL,
+        u_value=0.5,
+        area=20.0,
+        orientation=Orientation.SOUTH,
+        wall_type="Brick",
+        wall_group="B"
+    )
+    
+    # Create a sample roof
+    roof = Roof(
+        id="roof1",
+        name="Flat Roof",
+        component_type=ComponentType.ROOF,
+        u_value=0.3,
+        area=50.0,
+        orientation=Orientation.HORIZONTAL,
+        roof_type="Concrete",
+        roof_group="C"
+    )
+    
+    # Create a sample window
+    window = Window(
+        id="window1",
+        name="South Window",
+        component_type=ComponentType.WINDOW,
+        u_value=2.8,
+        area=5.0,
+        orientation=Orientation.SOUTH,
+        shgc=0.7,
+        vt=0.8,
+        window_type="Double Glazed",
+        glazing_layers=2,
+        gas_fill="Air",
+        low_e_coating=False
+    )
+    
+    # Define building components
+    building_components = {
+        "walls": [wall],
+        "roofs": [roof],
+        "windows": [window],
+        "doors": [],
+        "floors": []
+    }
+    
+    # Define conditions
+    outdoor_conditions = {
+        "temperature": 35.0,
+        "relative_humidity": 50.0,
+        "ground_temperature": 20.0,
+        "month": "Jul",
+        "latitude": "40N"
+    }
+    
+    indoor_conditions = {
+        "temperature": 24.0,
+        "relative_humidity": 50.0
+    }
+    
+    # Define internal loads
+    internal_loads = {
+        "people": {
+            "number": 3,
+            "activity_level": "Seated/Resting",
+            "hours_occupancy": "8h"
+        },
+        "lights": {
+            "power": 500.0,
+            "use_factor": 0.9,
+            "special_allowance": 0.1,
+            "hours_operation": "8h"
+        },
+        "equipment": {
+            "power": 1000.0,
+            "use_factor": 0.7,
+            "radiation_factor": 0.7,
+            "hours_operation": "8h"
+        },
+        "infiltration": {
+            "flow_rate": 0.05
+        },
+        "ventilation": {
+            "flow_rate": 0.1
+        }
+    }
+    
+    # Calculate hourly cooling loads
+    hourly_loads = cooling_load_calculator.calculate_hourly_cooling_loads(
+        building_components=building_components,
+        outdoor_conditions=outdoor_conditions,
+        indoor_conditions=indoor_conditions,
+        internal_loads=internal_loads
+    )
+    
+    # Calculate design cooling load
+    design_loads = cooling_load_calculator.calculate_design_cooling_load(hourly_loads)
+    
+    # Calculate cooling load summary
+    summary = cooling_load_calculator.calculate_cooling_load_summary(design_loads)
+    
+    # Print results
+    print("Cooling Load Summary:")
+    print(f"Envelope Loads: {summary['envelope_loads']:.2f} W")
+    print(f"Ventilation Loads: {summary['ventilation_loads']:.2f} W")
+    print(f"Infiltration Loads: {summary['infiltration_loads']:.2f} W")
+    print(f"Internal Loads: {summary['internal_loads']:.2f} W")
+    print(f"Total Sensible: {summary['total_sensible']:.2f} W")
+    print(f"Total Latent: {summary['total_latent']:.2f} W")
+    print(f"Total: {summary['total']:.2f} W")
+    print(f"Sensible Heat Ratio: {summary['sensible_heat_ratio']:.2f}")
+    print(f"Design Hour: {summary['design_hour']}")

utils/heat_transfer.py

@@ -0,0 +1,548 @@
+"""
+Shared calculation functions module for HVAC Load Calculator.
+This module implements common heat transfer calculations used in both cooling and heating load calculations.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import math
+import numpy as np
+import pandas as pd
+import os
+
+# Import data models and utilities
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation
+from utils.psychrometrics import Psychrometrics
+
+# Define constants
+STEFAN_BOLTZMANN_CONSTANT = 5.67e-8  # W/(m²·K⁴)
+SOLAR_CONSTANT = 1367  # W/m²
+EARTH_TILT_ANGLE = 23.45  # degrees
+
+
+class HeatTransferCalculations:
+    """Class for shared heat transfer calculations."""
+    
+    @staticmethod
+    def conduction_heat_transfer(u_value: float, area: float, delta_t: float) -> float:
+        """
+        Calculate conduction heat transfer through a building component.
+        
+        Args:
+            u_value: U-value of the component in W/(m²·K)
+            area: Area of the component in m²
+            delta_t: Temperature difference across the component in K (or °C)
+            
+        Returns:
+            Heat transfer rate in W
+        """
+        return u_value * area * delta_t
+    
+    @staticmethod
+    def convection_heat_transfer(h_c: float, area: float, delta_t: float) -> float:
+        """
+        Calculate convection heat transfer.
+        
+        Args:
+            h_c: Convection heat transfer coefficient in W/(m²·K)
+            area: Surface area in m²
+            delta_t: Temperature difference between surface and fluid in K (or °C)
+            
+        Returns:
+            Heat transfer rate in W
+        """
+        return h_c * area * delta_t
+    
+    @staticmethod
+    def radiation_heat_transfer(emissivity: float, area: float, t_surface: float, t_surroundings: float) -> float:
+        """
+        Calculate radiation heat transfer.
+        
+        Args:
+            emissivity: Surface emissivity (0-1)
+            area: Surface area in m²
+            t_surface: Surface temperature in K
+            t_surroundings: Surroundings temperature in K
+            
+        Returns:
+            Heat transfer rate in W
+        """
+        return emissivity * STEFAN_BOLTZMANN_CONSTANT * area * (t_surface**4 - t_surroundings**4)
+    
+    @staticmethod
+    def infiltration_heat_transfer(flow_rate: float, delta_t: float, density: float = 1.2, specific_heat: float = 1006) -> float:
+        """
+        Calculate sensible heat transfer due to infiltration or ventilation.
+        
+        Args:
+            flow_rate: Volumetric flow rate in m³/s
+            delta_t: Temperature difference between indoor and outdoor air in K (or °C)
+            density: Air density in kg/m³ (default: 1.2 kg/m³)
+            specific_heat: Specific heat capacity of air in J/(kg·K) (default: 1006 J/(kg·K))
+            
+        Returns:
+            Heat transfer rate in W
+        """
+        return flow_rate * density * specific_heat * delta_t
+    
+    @staticmethod
+    def infiltration_latent_heat_transfer(flow_rate: float, delta_w: float, density: float = 1.2, latent_heat: float = 2501000) -> float:
+        """
+        Calculate latent heat transfer due to infiltration or ventilation.
+        
+        Args:
+            flow_rate: Volumetric flow rate in m³/s
+            delta_w: Humidity ratio difference between indoor and outdoor air in kg/kg
+            density: Air density in kg/m³ (default: 1.2 kg/m³)
+            latent_heat: Latent heat of vaporization in J/kg (default: 2501000 J/kg)
+            
+        Returns:
+            Heat transfer rate in W
+        """
+        return flow_rate * density * latent_heat * delta_w
+    
+    @staticmethod
+    def air_exchange_rate_to_flow_rate(ach: float, volume: float) -> float:
+        """
+        Convert air changes per hour to volumetric flow rate.
+        
+        Args:
+            ach: Air changes per hour (1/h)
+            volume: Room or building volume in m³
+            
+        Returns:
+            Volumetric flow rate in m³/s
+        """
+        return ach * volume / 3600
+    
+    @staticmethod
+    def flow_rate_to_air_exchange_rate(flow_rate: float, volume: float) -> float:
+        """
+        Convert volumetric flow rate to air changes per hour.
+        
+        Args:
+            flow_rate: Volumetric flow rate in m³/s
+            volume: Room or building volume in m³
+            
+        Returns:
+            Air changes per hour (1/h)
+        """
+        return flow_rate * 3600 / volume
+    
+    @staticmethod
+    def crack_method_infiltration(crack_length: float, coefficient: float, pressure_difference: float, exponent: float = 0.65) -> float:
+        """
+        Calculate infiltration using the crack method.
+        
+        Args:
+            crack_length: Length of cracks in m
+            coefficient: Flow coefficient in m³/(s·m·Pa^n)
+            pressure_difference: Pressure difference in Pa
+            exponent: Flow exponent (default: 0.65)
+            
+        Returns:
+            Infiltration flow rate in m³/s
+        """
+        return coefficient * crack_length * pressure_difference**exponent
+    
+    @staticmethod
+    def wind_pressure_difference(wind_speed: float, wind_coefficient: float, density: float = 1.2) -> float:
+        """
+        Calculate pressure difference due to wind.
+        
+        Args:
+            wind_speed: Wind speed in m/s
+            wind_coefficient: Wind pressure coefficient (dimensionless)
+            density: Air density in kg/m³ (default: 1.2 kg/m³)
+            
+        Returns:
+            Pressure difference in Pa
+        """
+        return 0.5 * density * wind_speed**2 * wind_coefficient
+    
+    @staticmethod
+    def stack_pressure_difference(height: float, indoor_temp: float, outdoor_temp: float, 
+                                 neutral_plane_height: float = None, gravity: float = 9.81) -> float:
+        """
+        Calculate pressure difference due to stack effect.
+        
+        Args:
+            height: Height from reference level in m
+            indoor_temp: Indoor temperature in K
+            outdoor_temp: Outdoor temperature in K
+            neutral_plane_height: Height of neutral pressure plane in m (default: half of height)
+            gravity: Acceleration due to gravity in m/s² (default: 9.81 m/s²)
+            
+        Returns:
+            Pressure difference in Pa
+        """
+        if neutral_plane_height is None:
+            neutral_plane_height = height / 2
+        
+        # Calculate pressure difference
+        return gravity * (height - neutral_plane_height) * (outdoor_temp - indoor_temp) / outdoor_temp
+    
+    @staticmethod
+    def combined_pressure_difference(wind_pd: float, stack_pd: float) -> float:
+        """
+        Calculate combined pressure difference from wind and stack effects.
+        
+        Args:
+            wind_pd: Pressure difference due to wind in Pa
+            stack_pd: Pressure difference due to stack effect in Pa
+            
+        Returns:
+            Combined pressure difference in Pa
+        """
+        # Simple quadrature combination
+        return math.sqrt(wind_pd**2 + stack_pd**2)
+    
+    @staticmethod
+    def solar_declination(day_of_year: int) -> float:
+        """
+        Calculate solar declination angle.
+        
+        Args:
+            day_of_year: Day of the year (1-365)
+            
+        Returns:
+            Solar declination angle in degrees
+        """
+        return EARTH_TILT_ANGLE * math.sin(2 * math.pi * (day_of_year - 81) / 365)
+    
+    @staticmethod
+    def solar_hour_angle(solar_time: float) -> float:
+        """
+        Calculate solar hour angle.
+        
+        Args:
+            solar_time: Solar time in hours (0-24)
+            
+        Returns:
+            Solar hour angle in degrees
+        """
+        return 15 * (solar_time - 12)
+    
+    @staticmethod
+    def solar_altitude(latitude: float, declination: float, hour_angle: float) -> float:
+        """
+        Calculate solar altitude angle.
+        
+        Args:
+            latitude: Latitude in degrees
+            declination: Solar declination angle in degrees
+            hour_angle: Solar hour angle in degrees
+            
+        Returns:
+            Solar altitude angle in degrees
+        """
+        # Convert angles to radians
+        lat_rad = math.radians(latitude)
+        decl_rad = math.radians(declination)
+        hour_rad = math.radians(hour_angle)
+        
+        # Calculate solar altitude
+        sin_altitude = (math.sin(lat_rad) * math.sin(decl_rad) + 
+                       math.cos(lat_rad) * math.cos(decl_rad) * math.cos(hour_rad))
+        
+        return math.degrees(math.asin(sin_altitude))
+    
+    @staticmethod
+    def solar_azimuth(latitude: float, declination: float, hour_angle: float, altitude: float) -> float:
+        """
+        Calculate solar azimuth angle.
+        
+        Args:
+            latitude: Latitude in degrees
+            declination: Solar declination angle in degrees
+            hour_angle: Solar hour angle in degrees
+            altitude: Solar altitude angle in degrees
+            
+        Returns:
+            Solar azimuth angle in degrees (0° = South, positive westward)
+        """
+        # Convert angles to radians
+        lat_rad = math.radians(latitude)
+        decl_rad = math.radians(declination)
+        hour_rad = math.radians(hour_angle)
+        alt_rad = math.radians(altitude)
+        
+        # Calculate solar azimuth
+        cos_azimuth = ((math.sin(decl_rad) * math.cos(lat_rad) - 
+                      math.cos(decl_rad) * math.sin(lat_rad) * math.cos(hour_rad)) / 
+                      math.cos(alt_rad))
+        
+        # Constrain to [-1, 1] to avoid domain errors
+        cos_azimuth = max(-1, min(1, cos_azimuth))
+        
+        # Calculate azimuth angle
+        azimuth = math.degrees(math.acos(cos_azimuth))
+        
+        # Adjust for morning hours (negative hour angle)
+        if hour_angle < 0:
+            azimuth = -azimuth
+        
+        return azimuth
+    
+    @staticmethod
+    def incident_angle(surface_tilt: float, surface_azimuth: float, 
+                      solar_altitude: float, solar_azimuth: float) -> float:
+        """
+        Calculate angle of incidence on a surface.
+        
+        Args:
+            surface_tilt: Surface tilt angle from horizontal in degrees (0° = horizontal, 90° = vertical)
+            surface_azimuth: Surface azimuth angle in degrees (0° = South, positive westward)
+            solar_altitude: Solar altitude angle in degrees
+            solar_azimuth: Solar azimuth angle in degrees
+            
+        Returns:
+            Incident angle in degrees
+        """
+        # Convert angles to radians
+        surf_tilt_rad = math.radians(surface_tilt)
+        surf_azim_rad = math.radians(surface_azimuth)
+        solar_alt_rad = math.radians(solar_altitude)
+        solar_azim_rad = math.radians(solar_azimuth)
+        
+        # Calculate incident angle
+        cos_incident = (math.sin(solar_alt_rad) * math.cos(surf_tilt_rad) + 
+                       math.cos(solar_alt_rad) * math.sin(surf_tilt_rad) * 
+                       math.cos(solar_azim_rad - surf_azim_rad))
+        
+        # Constrain to [-1, 1] to avoid domain errors
+        cos_incident = max(-1, min(1, cos_incident))
+        
+        return math.degrees(math.acos(cos_incident))
+    
+    @staticmethod
+    def direct_normal_irradiance(altitude: float, atmospheric_clearness: float = 1.0) -> float:
+        """
+        Calculate direct normal irradiance.
+        
+        Args:
+            altitude: Solar altitude angle in degrees
+            atmospheric_clearness: Atmospheric clearness factor (0-1)
+            
+        Returns:
+            Direct normal irradiance in W/m²
+        """
+        if altitude <= 0:
+            return 0
+        
+        # Simple model based on air mass
+        air_mass = 1 / math.sin(math.radians(altitude))
+        
+        # Limit air mass to reasonable values
+        air_mass = min(air_mass, 38)
+        
+        # Calculate direct normal irradiance
+        dni = SOLAR_CONSTANT * atmospheric_clearness**air_mass
+        
+        return dni
+    
+    @staticmethod
+    def diffuse_horizontal_irradiance(dni: float, altitude: float, clearness: float = 0.2) -> float:
+        """
+        Calculate diffuse horizontal irradiance.
+        
+        Args:
+            dni: Direct normal irradiance in W/m²
+            altitude: Solar altitude angle in degrees
+            clearness: Sky clearness factor (0-1)
+            
+        Returns:
+            Diffuse horizontal irradiance in W/m²
+        """
+        if altitude <= 0:
+            return 0
+        
+        # Simple model for diffuse irradiance
+        return dni * clearness * math.sin(math.radians(altitude))
+    
+    @staticmethod
+    def global_horizontal_irradiance(dni: float, dhi: float, altitude: float) -> float:
+        """
+        Calculate global horizontal irradiance.
+        
+        Args:
+            dni: Direct normal irradiance in W/m²
+            dhi: Diffuse horizontal irradiance in W/m²
+            altitude: Solar altitude angle in degrees
+            
+        Returns:
+            Global horizontal irradiance in W/m²
+        """
+        if altitude <= 0:
+            return 0
+        
+        # Calculate direct horizontal component
+        direct_horizontal = dni * math.sin(math.radians(altitude))
+        
+        # Calculate global horizontal irradiance
+        return direct_horizontal + dhi
+    
+    @staticmethod
+    def irradiance_on_surface(dni: float, dhi: float, incident_angle: float, 
+                             surface_tilt: float, ground_reflectance: float = 0.2) -> float:
+        """
+        Calculate total irradiance on a surface.
+        
+        Args:
+            dni: Direct normal irradiance in W/m²
+            dhi: Diffuse horizontal irradiance in W/m²
+            incident_angle: Incident angle in degrees
+            surface_tilt: Surface tilt angle from horizontal in degrees
+            ground_reflectance: Ground reflectance (albedo) (0-1)
+            
+        Returns:
+            Total irradiance on the surface in W/m²
+        """
+        # Convert angles to radians
+        incident_rad = math.radians(incident_angle)
+        tilt_rad = math.radians(surface_tilt)
+        
+        # Calculate direct component
+        if incident_angle < 90:
+            direct = dni * math.cos(incident_rad)
+        else:
+            direct = 0
+        
+        # Calculate diffuse component (simple isotropic model)
+        diffuse = dhi * (1 + math.cos(tilt_rad)) / 2
+        
+        # Calculate ground-reflected component
+        reflected = (dni * math.sin(math.radians(incident_angle)) + dhi) * ground_reflectance * (1 - math.cos(tilt_rad)) / 2
+        
+        # Calculate total irradiance
+        return direct + diffuse + reflected
+    
+    @staticmethod
+    def solar_heat_gain(irradiance: float, area: float, shgc: float, 
+                       shading_coefficient: float = 1.0, frame_factor: float = 0.85) -> float:
+        """
+        Calculate solar heat gain through a window.
+        
+        Args:
+            irradiance: Total irradiance on the window in W/m²
+            area: Window area in m²
+            shgc: Solar Heat Gain Coefficient (0-1)
+            shading_coefficient: External shading coefficient (0-1)
+            frame_factor: Ratio of glazing area to total window area (0-1)
+            
+        Returns:
+            Solar heat gain in W
+        """
+        return irradiance * area * shgc * shading_coefficient * frame_factor
+    
+    @staticmethod
+    def internal_gains(occupants: int, lights_power: float, equipment_power: float,
+                      occupant_sensible_gain: float = 70, occupant_latent_gain: float = 45) -> Dict[str, float]:
+        """
+        Calculate internal heat gains.
+        
+        Args:
+            occupants: Number of occupants
+            lights_power: Lighting power in W
+            equipment_power: Equipment power in W
+            occupant_sensible_gain: Sensible heat gain per occupant in W (default: 70 W)
+            occupant_latent_gain: Latent heat gain per occupant in W (default: 45 W)
+            
+        Returns:
+            Dictionary with sensible, latent, and total heat gains in W
+        """
+        # Calculate occupant gains
+        occupant_sensible = occupants * occupant_sensible_gain
+        occupant_latent = occupants * occupant_latent_gain
+        
+        # Calculate total sensible and latent gains
+        sensible_gain = occupant_sensible + lights_power + equipment_power
+        latent_gain = occupant_latent
+        
+        return {
+            "sensible": sensible_gain,
+            "latent": latent_gain,
+            "total": sensible_gain + latent_gain
+        }
+    
+    @staticmethod
+    def thermal_mass_effect(mass: float, specific_heat: float, delta_t: float) -> float:
+        """
+        Calculate heat storage in thermal mass.
+        
+        Args:
+            mass: Mass of the material in kg
+            specific_heat: Specific heat capacity in J/(kg·K)
+            delta_t: Temperature change in K (or °C)
+            
+        Returns:
+            Heat stored in J
+        """
+        return mass * specific_heat * delta_t
+    
+    @staticmethod
+    def thermal_lag_factor(thermal_mass: float, time_constant: float, time_step: float) -> float:
+        """
+        Calculate thermal lag factor for dynamic heat transfer.
+        
+        Args:
+            thermal_mass: Thermal mass in J/K
+            time_constant: Time constant in hours
+            time_step: Time step in hours
+            
+        Returns:
+            Thermal lag factor (0-1)
+        """
+        return 1 - math.exp(-time_step / time_constant)
+    
+    @staticmethod
+    def temperature_swing(heat_gain: float, thermal_mass: float) -> float:
+        """
+        Calculate temperature swing due to heat gain and thermal mass.
+        
+        Args:
+            heat_gain: Heat gain in J
+            thermal_mass: Thermal mass in J/K
+            
+        Returns:
+            Temperature swing in K (or °C)
+        """
+        return heat_gain / thermal_mass
+    
+    @staticmethod
+    def sol_air_temperature(outdoor_temp: float, solar_irradiance: float, 
+                           surface_absorptivity: float, surface_resistance: float) -> float:
+        """
+        Calculate sol-air temperature.
+        
+        Args:
+            outdoor_temp: Outdoor air temperature in °C
+            solar_irradiance: Solar irradiance on the surface in W/m²
+            surface_absorptivity: Surface solar absorptivity (0-1)
+            surface_resistance: Surface heat transfer resistance in m²·K/W
+            
+        Returns:
+            Sol-air temperature in °C
+        """
+        return outdoor_temp + solar_irradiance * surface_absorptivity * surface_resistance
+
+
+# Create a singleton instance
+heat_transfer = HeatTransferCalculations()
+
+# Example usage
+if __name__ == "__main__":
+    # Calculate conduction heat transfer
+    q_cond = heat_transfer.conduction_heat_transfer(u_value=0.5, area=10, delta_t=20)
+    print(f"Conduction heat transfer: {q_cond:.2f} W")
+    
+    # Calculate infiltration heat transfer
+    q_inf = heat_transfer.infiltration_heat_transfer(flow_rate=0.1, delta_t=20)
+    print(f"Infiltration heat transfer: {q_inf:.2f} W")
+    
+    # Calculate solar heat gain
+    q_solar = heat_transfer.solar_heat_gain(irradiance=500, area=5, shgc=0.7)
+    print(f"Solar heat gain: {q_solar:.2f} W")
+    
+    # Calculate internal gains
+    gains = heat_transfer.internal_gains(occupants=3, lights_power=200, equipment_power=500)
+    print(f"Internal gains - Sensible: {gains['sensible']:.2f} W, Latent: {gains['latent']:.2f} W, Total: {gains['total']:.2f} W")

utils/heating_load.py

@@ -0,0 +1,683 @@
+"""
+Heating load calculation module for HVAC Load Calculator.
+This module implements steady-state methods for calculating heating loads.
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import math
+import numpy as np
+import pandas as pd
+import os
+from datetime import datetime, timedelta
+from enum import Enum
+
+# Import data models and utilities
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+from utils.psychrometrics import Psychrometrics
+from utils.heat_transfer import HeatTransferCalculations
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+
+class HeatingLoadCalculator:
+    """Class for calculating heating loads using steady-state methods."""
+    
+    def __init__(self):
+        """Initialize heating load calculator."""
+        self.heat_transfer = HeatTransferCalculations()
+        self.psychrometrics = Psychrometrics()
+    
+    def calculate_wall_heating_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load through a wall using steady-state conduction.
+        
+        Args:
+            wall: Wall object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        # Get wall properties
+        u_value = wall.u_value
+        area = wall.area
+        
+        # Calculate heating load
+        delta_t = indoor_temp - outdoor_temp
+        heating_load = u_value * area * delta_t
+        
+        return heating_load
+    
+    def calculate_roof_heating_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load through a roof using steady-state conduction.
+        
+        Args:
+            roof: Roof object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        # Get roof properties
+        u_value = roof.u_value
+        area = roof.area
+        
+        # Calculate heating load
+        delta_t = indoor_temp - outdoor_temp
+        heating_load = u_value * area * delta_t
+        
+        return heating_load
+    
+    def calculate_floor_heating_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load through a floor.
+        
+        Args:
+            floor: Floor object
+            ground_temp: Ground or adjacent space temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        # Get floor properties
+        u_value = floor.u_value
+        area = floor.area
+        
+        # Calculate heating load
+        delta_t = indoor_temp - ground_temp
+        heating_load = u_value * area * delta_t
+        
+        return heating_load
+    
+    def calculate_window_heating_load(self, window: Window, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load through a window using steady-state conduction.
+        
+        Args:
+            window: Window object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        # Get window properties
+        u_value = window.u_value
+        area = window.area
+        
+        # Calculate heating load
+        delta_t = indoor_temp - outdoor_temp
+        heating_load = u_value * area * delta_t
+        
+        return heating_load
+    
+    def calculate_door_heating_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load through a door using steady-state conduction.
+        
+        Args:
+            door: Door object
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        # Get door properties
+        u_value = door.u_value
+        area = door.area
+        
+        # Calculate heating load
+        delta_t = indoor_temp - outdoor_temp
+        heating_load = u_value * area * delta_t
+        
+        return heating_load
+    
+    def calculate_infiltration_heating_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
+                                          outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+        """
+        Calculate sensible and latent heating loads due to infiltration.
+        
+        Args:
+            flow_rate: Infiltration flow rate in m³/s
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            outdoor_rh: Outdoor relative humidity in %
+            indoor_rh: Indoor relative humidity in %
+            
+        Returns:
+            Dictionary with sensible, latent, and total heating loads in W
+        """
+        # Calculate sensible heating load
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(
+            flow_rate=flow_rate,
+            delta_t=indoor_temp - outdoor_temp
+        )
+        
+        # Calculate humidity ratios
+        w_outdoor = self.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
+        w_indoor = self.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
+        
+        # Calculate latent heating load (only if indoor humidity is higher than outdoor)
+        delta_w = w_indoor - w_outdoor
+        if delta_w > 0:
+            latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+                flow_rate=flow_rate,
+                delta_w=delta_w
+            )
+        else:
+            latent_load = 0
+        
+        # Calculate total heating load
+        total_load = sensible_load + latent_load
+        
+        return {
+            "sensible": sensible_load,
+            "latent": latent_load,
+            "total": total_load
+        }
+    
+    def calculate_ventilation_heating_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
+                                         outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+        """
+        Calculate sensible and latent heating loads due to ventilation.
+        
+        Args:
+            flow_rate: Ventilation flow rate in m³/s
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            outdoor_rh: Outdoor relative humidity in %
+            indoor_rh: Indoor relative humidity in %
+            
+        Returns:
+            Dictionary with sensible, latent, and total heating loads in W
+        """
+        # Ventilation load calculation is the same as infiltration
+        return self.calculate_infiltration_heating_load(
+            flow_rate=flow_rate,
+            outdoor_temp=outdoor_temp,
+            indoor_temp=indoor_temp,
+            outdoor_rh=outdoor_rh,
+            indoor_rh=indoor_rh
+        )
+    
+    def calculate_internal_gains_offset(self, people_load: float, lights_load: float, 
+                                      equipment_load: float, usage_factor: float = 0.7) -> float:
+        """
+        Calculate internal gains offset for heating load.
+        
+        Args:
+            people_load: Heat gain from people in W
+            lights_load: Heat gain from lights in W
+            equipment_load: Heat gain from equipment in W
+            usage_factor: Usage factor for internal gains (0-1)
+            
+        Returns:
+            Internal gains offset in W
+        """
+        # Calculate total internal gains
+        total_gains = people_load + lights_load + equipment_load
+        
+        # Apply usage factor
+        offset = total_gains * usage_factor
+        
+        return offset
+    
+    def calculate_design_heating_load(self, building_components: Dict[str, List[Any]], 
+                                    outdoor_conditions: Dict[str, Any],
+                                    indoor_conditions: Dict[str, Any],
+                                    internal_loads: Dict[str, Any],
+                                    safety_factor: float = 1.15) -> Dict[str, float]:
+        """
+        Calculate design heating load for a building.
+        
+        Args:
+            building_components: Dictionary with lists of building components
+            outdoor_conditions: Dictionary with outdoor conditions
+            indoor_conditions: Dictionary with indoor conditions
+            internal_loads: Dictionary with internal loads
+            safety_factor: Safety factor for heating load (default: 1.15)
+            
+        Returns:
+            Dictionary with design heating loads
+        """
+        # Extract building components
+        walls = building_components.get("walls", [])
+        roofs = building_components.get("roofs", [])
+        floors = building_components.get("floors", [])
+        windows = building_components.get("windows", [])
+        doors = building_components.get("doors", [])
+        
+        # Extract outdoor conditions
+        outdoor_temp = outdoor_conditions.get("design_temperature", -10.0)
+        outdoor_rh = outdoor_conditions.get("design_relative_humidity", 80.0)
+        ground_temp = outdoor_conditions.get("ground_temperature", 10.0)
+        
+        # Extract indoor conditions
+        indoor_temp = indoor_conditions.get("temperature", 21.0)
+        indoor_rh = indoor_conditions.get("relative_humidity", 40.0)
+        
+        # Extract internal loads
+        people = internal_loads.get("people", {})
+        lights = internal_loads.get("lights", {})
+        equipment = internal_loads.get("equipment", {})
+        infiltration = internal_loads.get("infiltration", {})
+        ventilation = internal_loads.get("ventilation", {})
+        
+        # Initialize loads
+        loads = {
+            "walls": 0,
+            "roofs": 0,
+            "floors": 0,
+            "windows": 0,
+            "doors": 0,
+            "infiltration_sensible": 0,
+            "infiltration_latent": 0,
+            "ventilation_sensible": 0,
+            "ventilation_latent": 0,
+            "internal_gains_offset": 0,
+            "subtotal": 0,
+            "safety_factor": safety_factor,
+            "total": 0
+        }
+        
+        # Calculate wall loads
+        for wall in walls:
+            wall_load = self.calculate_wall_heating_load(
+                wall=wall,
+                outdoor_temp=outdoor_temp,
+                indoor_temp=indoor_temp
+            )
+            loads["walls"] += wall_load
+        
+        # Calculate roof loads
+        for roof in roofs:
+            roof_load = self.calculate_roof_heating_load(
+                roof=roof,
+                outdoor_temp=outdoor_temp,
+                indoor_temp=indoor_temp
+            )
+            loads["roofs"] += roof_load
+        
+        # Calculate floor loads
+        for floor in floors:
+            floor_load = self.calculate_floor_heating_load(
+                floor=floor,
+                ground_temp=ground_temp,
+                indoor_temp=indoor_temp
+            )
+            loads["floors"] += floor_load
+        
+        # Calculate window loads
+        for window in windows:
+            window_load = self.calculate_window_heating_load(
+                window=window,
+                outdoor_temp=outdoor_temp,
+                indoor_temp=indoor_temp
+            )
+            loads["windows"] += window_load
+        
+        # Calculate door loads
+        for door in doors:
+            door_load = self.calculate_door_heating_load(
+                door=door,
+                outdoor_temp=outdoor_temp,
+                indoor_temp=indoor_temp
+            )
+            loads["doors"] += door_load
+        
+        # Calculate infiltration loads
+        if infiltration:
+            flow_rate = infiltration.get("flow_rate", 0.0)
+            infiltration_loads = self.calculate_infiltration_heating_load(
+                flow_rate=flow_rate,
+                outdoor_temp=outdoor_temp,
+                indoor_temp=indoor_temp,
+                outdoor_rh=outdoor_rh,
+                indoor_rh=indoor_rh
+            )
+            loads["infiltration_sensible"] = infiltration_loads["sensible"]
+            loads["infiltration_latent"] = infiltration_loads["latent"]
+        
+        # Calculate ventilation loads
+        if ventilation:
+            flow_rate = ventilation.get("flow_rate", 0.0)
+            ventilation_loads = self.calculate_ventilation_heating_load(
+                flow_rate=flow_rate,
+                outdoor_temp=outdoor_temp,
+                indoor_temp=indoor_temp,
+                outdoor_rh=outdoor_rh,
+                indoor_rh=indoor_rh
+            )
+            loads["ventilation_sensible"] = ventilation_loads["sensible"]
+            loads["ventilation_latent"] = ventilation_loads["latent"]
+        
+        # Calculate internal gains offset
+        people_load = people.get("number", 0) * people.get("sensible_gain", 70)
+        lights_load = lights.get("power", 0) * lights.get("use_factor", 1.0)
+        equipment_load = equipment.get("power", 0) * equipment.get("use_factor", 1.0)
+        
+        loads["internal_gains_offset"] = self.calculate_internal_gains_offset(
+            people_load=people_load,
+            lights_load=lights_load,
+            equipment_load=equipment_load,
+            usage_factor=internal_loads.get("usage_factor", 0.7)
+        )
+        
+        # Calculate subtotal
+        loads["subtotal"] = (
+            loads["walls"] + loads["roofs"] + loads["floors"] +
+            loads["windows"] + loads["doors"] +
+            loads["infiltration_sensible"] + loads["infiltration_latent"] +
+            loads["ventilation_sensible"] + loads["ventilation_latent"] -
+            loads["internal_gains_offset"]
+        )
+        
+        # Apply safety factor
+        loads["total"] = loads["subtotal"] * safety_factor
+        
+        return loads
+    
+    def calculate_heating_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
+        """
+        Calculate heating load summary.
+        
+        Args:
+            design_loads: Dictionary with design heating loads
+            
+        Returns:
+            Dictionary with heating load summary
+        """
+        # Calculate envelope loads
+        envelope_loads = (
+            design_loads["walls"] + design_loads["roofs"] + design_loads["floors"] +
+            design_loads["windows"] + design_loads["doors"]
+        )
+        
+        # Calculate ventilation and infiltration loads
+        ventilation_loads = design_loads["ventilation_sensible"] + design_loads["ventilation_latent"]
+        infiltration_loads = design_loads["infiltration_sensible"] + design_loads["infiltration_latent"]
+        
+        # Create summary
+        summary = {
+            "envelope_loads": envelope_loads,
+            "ventilation_loads": ventilation_loads,
+            "infiltration_loads": infiltration_loads,
+            "internal_gains_offset": design_loads["internal_gains_offset"],
+            "subtotal": design_loads["subtotal"],
+            "safety_factor": design_loads["safety_factor"],
+            "total": design_loads["total"]
+        }
+        
+        return summary
+    
+    def calculate_monthly_heating_loads(self, design_loads: Dict[str, float], 
+                                      monthly_temps: Dict[str, float],
+                                      design_temp: float, indoor_temp: float) -> Dict[str, float]:
+        """
+        Calculate monthly heating loads based on design load and monthly temperatures.
+        
+        Args:
+            design_loads: Dictionary with design heating loads
+            monthly_temps: Dictionary with monthly average temperatures
+            design_temp: Design outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Dictionary with monthly heating loads
+        """
+        # Calculate design temperature difference
+        design_delta_t = indoor_temp - design_temp
+        
+        # Calculate monthly loads
+        monthly_loads = {}
+        
+        for month, temp in monthly_temps.items():
+            # Calculate temperature difference for this month
+            delta_t = indoor_temp - temp
+            
+            # Skip months where outdoor temperature is higher than indoor
+            if delta_t <= 0:
+                monthly_loads[month] = 0
+                continue
+            
+            # Calculate load ratio based on temperature difference
+            load_ratio = delta_t / design_delta_t
+            
+            # Calculate monthly load
+            monthly_loads[month] = design_loads["total"] * load_ratio
+        
+        return monthly_loads
+    
+    def calculate_heating_degree_days(self, monthly_temps: Dict[str, float], 
+                                    base_temp: float = 18.0) -> Dict[str, float]:
+        """
+        Calculate heating degree days for each month.
+        
+        Args:
+            monthly_temps: Dictionary with monthly average temperatures
+            base_temp: Base temperature for degree days in °C (default: 18°C)
+            
+        Returns:
+            Dictionary with monthly heating degree days
+        """
+        # Calculate monthly heating degree days
+        monthly_hdds = {}
+        
+        for month, temp in monthly_temps.items():
+            # Calculate degree days
+            days_in_month = 30  # Approximate
+            if month in ["Apr", "Jun", "Sep", "Nov"]:
+                days_in_month = 30
+            elif month == "Feb":
+                days_in_month = 28  # Ignore leap years for simplicity
+            else:
+                days_in_month = 31
+            
+            # Calculate daily degree days
+            daily_hdd = max(0, base_temp - temp)
+            
+            # Calculate monthly degree days
+            monthly_hdds[month] = daily_hdd * days_in_month
+        
+        return monthly_hdds
+    
+    def calculate_annual_heating_energy(self, monthly_loads: Dict[str, float], 
+                                      heating_system_efficiency: float = 0.8) -> Dict[str, float]:
+        """
+        Calculate annual heating energy consumption.
+        
+        Args:
+            monthly_loads: Dictionary with monthly heating loads in W
+            heating_system_efficiency: Heating system efficiency (0-1)
+            
+        Returns:
+            Dictionary with monthly and annual heating energy in kWh
+        """
+        # Calculate monthly energy consumption
+        monthly_energy = {}
+        annual_energy = 0
+        
+        for month, load in monthly_loads.items():
+            # Calculate hours in month
+            hours_in_month = 24 * 30  # Approximate
+            if month in ["Apr", "Jun", "Sep", "Nov"]:
+                hours_in_month = 24 * 30
+            elif month == "Feb":
+                hours_in_month = 24 * 28  # Ignore leap years for simplicity
+            else:
+                hours_in_month = 24 * 31
+            
+            # Calculate energy in kWh
+            energy = load * hours_in_month / 1000 / heating_system_efficiency
+            
+            # Store monthly energy
+            monthly_energy[month] = energy
+            
+            # Add to annual total
+            annual_energy += energy
+        
+        # Add annual total to results
+        monthly_energy["annual"] = annual_energy
+        
+        return monthly_energy
+
+
+# Create a singleton instance
+heating_load_calculator = HeatingLoadCalculator()
+
+# Example usage
+if __name__ == "__main__":
+    # Create sample building components
+    from data.building_components import Wall, Roof, Window, Door, Orientation, ComponentType
+    
+    # Create a sample wall
+    wall = Wall(
+        id="wall1",
+        name="Exterior Wall",
+        component_type=ComponentType.WALL,
+        u_value=0.5,
+        area=20.0,
+        orientation=Orientation.NORTH,
+        wall_type="Brick",
+        wall_group="B"
+    )
+    
+    # Create a sample roof
+    roof = Roof(
+        id="roof1",
+        name="Flat Roof",
+        component_type=ComponentType.ROOF,
+        u_value=0.3,
+        area=50.0,
+        orientation=Orientation.HORIZONTAL,
+        roof_type="Concrete",
+        roof_group="C"
+    )
+    
+    # Create a sample window
+    window = Window(
+        id="window1",
+        name="North Window",
+        component_type=ComponentType.WINDOW,
+        u_value=2.8,
+        area=5.0,
+        orientation=Orientation.NORTH,
+        shgc=0.7,
+        vt=0.8,
+        window_type="Double Glazed",
+        glazing_layers=2,
+        gas_fill="Air",
+        low_e_coating=False
+    )
+    
+    # Define building components
+    building_components = {
+        "walls": [wall],
+        "roofs": [roof],
+        "windows": [window],
+        "doors": [],
+        "floors": []
+    }
+    
+    # Define conditions
+    outdoor_conditions = {
+        "design_temperature": -10.0,
+        "design_relative_humidity": 80.0,
+        "ground_temperature": 10.0
+    }
+    
+    indoor_conditions = {
+        "temperature": 21.0,
+        "relative_humidity": 40.0
+    }
+    
+    # Define internal loads
+    internal_loads = {
+        "people": {
+            "number": 3,
+            "sensible_gain": 70
+        },
+        "lights": {
+            "power": 500.0,
+            "use_factor": 0.9
+        },
+        "equipment": {
+            "power": 1000.0,
+            "use_factor": 0.7
+        },
+        "infiltration": {
+            "flow_rate": 0.05
+        },
+        "ventilation": {
+            "flow_rate": 0.1
+        },
+        "usage_factor": 0.7
+    }
+    
+    # Calculate design heating load
+    design_loads = heating_load_calculator.calculate_design_heating_load(
+        building_components=building_components,
+        outdoor_conditions=outdoor_conditions,
+        indoor_conditions=indoor_conditions,
+        internal_loads=internal_loads
+    )
+    
+    # Calculate heating load summary
+    summary = heating_load_calculator.calculate_heating_load_summary(design_loads)
+    
+    # Define monthly temperatures
+    monthly_temps = {
+        "Jan": -5.0,
+        "Feb": -3.0,
+        "Mar": 2.0,
+        "Apr": 8.0,
+        "May": 14.0,
+        "Jun": 18.0,
+        "Jul": 21.0,
+        "Aug": 20.0,
+        "Sep": 16.0,
+        "Oct": 10.0,
+        "Nov": 4.0,
+        "Dec": -2.0
+    }
+    
+    # Calculate monthly heating loads
+    monthly_loads = heating_load_calculator.calculate_monthly_heating_loads(
+        design_loads=design_loads,
+        monthly_temps=monthly_temps,
+        design_temp=outdoor_conditions["design_temperature"],
+        indoor_temp=indoor_conditions["temperature"]
+    )
+    
+    # Calculate heating degree days
+    hdds = heating_load_calculator.calculate_heating_degree_days(monthly_temps)
+    
+    # Calculate annual heating energy
+    energy = heating_load_calculator.calculate_annual_heating_energy(monthly_loads)
+    
+    # Print results
+    print("Heating Load Summary:")
+    print(f"Envelope Loads: {summary['envelope_loads']:.2f} W")
+    print(f"Ventilation Loads: {summary['ventilation_loads']:.2f} W")
+    print(f"Infiltration Loads: {summary['infiltration_loads']:.2f} W")
+    print(f"Internal Gains Offset: {summary['internal_gains_offset']:.2f} W")
+    print(f"Subtotal: {summary['subtotal']:.2f} W")
+    print(f"Safety Factor: {summary['safety_factor']:.2f}")
+    print(f"Total: {summary['total']:.2f} W")
+    
+    print("\nMonthly Heating Loads:")
+    for month, load in monthly_loads.items():
+        print(f"{month}: {load:.2f} W")
+    
+    print("\nHeating Degree Days:")
+    for month, hdd in hdds.items():
+        print(f"{month}: {hdd:.2f} HDD")
+    
+    print("\nAnnual Heating Energy:")
+    print(f"Total: {energy['annual']:.2f} kWh")

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,502 @@
+"""
+Psychrometric module for HVAC Load Calculator.
+This module implements psychrometric calculations for air properties.
+"""
+
+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 saturation_pressure(t_db: float) -> float:
+        """
+        Calculate saturation pressure of water vapor.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            
+        Returns:
+            Saturation pressure in Pa
+        """
+        # 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).
+        
+        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
+        """
+        # 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 humidity ratio
+        # ASHRAE Fundamentals 2017 Chapter 1, Equation 20
+        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.
+        
+        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)
+        """
+        # Calculate saturation pressure
+        p_ws = Psychrometrics.saturation_pressure(t_db)
+        
+        # Calculate partial pressure of water vapor
+        # Rearranged from ASHRAE Fundamentals 2017 Chapter 1, Equation 20
+        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.
+        
+        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
+        """
+        # 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):
+            # 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
+            # ASHRAE Fundamentals 2017 Chapter 1, Equation 35
+            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.
+        
+        Args:
+            t_db: Dry-bulb temperature in °C
+            rh: Relative humidity (0-100)
+            
+        Returns:
+            Dew point temperature in °C
+        """
+        # 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
+        # ASHRAE Fundamentals 2017 Chapter 1, Equation 39 and 40
+        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.
+        
+        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
+        """
+        # ASHRAE Fundamentals 2017 Chapter 1, Equation 30
+        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.
+        
+        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
+        """
+        # Convert temperature to Kelvin
+        t_k = t_db + 273.15
+        
+        # ASHRAE Fundamentals 2017 Chapter 1, Equation 28
+        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.
+        
+        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³
+        """
+        # 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.
+        
+        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
+        """
+        # 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.
+        
+        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
+        """
+        # Rearrange ASHRAE Fundamentals 2017 Chapter 1, Equation 30
+        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)  # Ensure non-negative value
+    
+    @staticmethod
+    def find_temperature_for_enthalpy(w: float, h: float) -> float:
+        """
+        Find dry-bulb temperature for a given humidity ratio and enthalpy.
+        
+        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
+        """
+        # Rearrange ASHRAE Fundamentals 2017 Chapter 1, Equation 30
+        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)
+        
+        return t_db
+    
+    @staticmethod
+    def sensible_heat_ratio(q_sensible: float, q_total: float) -> float:
+        """
+        Calculate sensible heat ratio.
+        
+        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
+        
+        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.
+        
+        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
+        """
+        # 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.
+        
+        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
+        """
+        # 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"))