Upload 32 files

app/component_selection_redesign.py

@@ -0,0 +1,1321 @@
+"""
+Component selection interface for HVAC Load Calculator.
+This module provides the UI components for selecting building components.
+This is a redesigned version with simplified grouping by orientation.
+"""
+
+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 ComponentSelectionRedesigned:
+    """Class for redesigned component selection interface with orientation-based grouping."""
+    
+    def __init__(self):
+        """Initialize component selection interface."""
+        self.component_library = ComponentLibrary()
+        self.u_value_calculator = UValueCalculator()
+    
+    def display(self) -> None:
+        """Display component selection interface in Streamlit."""
+        # Check for pending actions in session state and process them
+        self._process_pending_actions(st.session_state)
+        self.display_component_selection(st.session_state)
+    
+    def _process_pending_actions(self, session_state: Dict[str, Any]) -> None:
+        """
+        Process any pending actions stored in session state.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        # Ensure components structure exists
+        if "components" not in session_state:
+            session_state["components"] = {
+                'walls': [],
+                'roofs': [],
+                'floors': [],
+                'windows': [],
+                'doors': []
+            }
+            
+        # Initialize pending actions if not exists
+        if "pending_actions" not in session_state:
+            session_state["pending_actions"] = {}
+            
+        # Ensure all required pending action keys exist
+        required_keys = [
+            "add_wall", "delete_wall",
+            "add_roof", "delete_roof",
+            "add_floor", "delete_floor",
+            "add_window", "delete_window",
+            "add_door", "delete_door"
+        ]
+        
+        for key in required_keys:
+            if key not in session_state["pending_actions"]:
+                session_state["pending_actions"][key] = None
+        
+        # Process add wall action
+        if session_state["pending_actions"].get("add_wall") is not None:
+            new_wall = session_state["pending_actions"]["add_wall"]
+            session_state["components"]["walls"].append(new_wall)
+            session_state["pending_actions"]["add_wall"] = None
+        
+        # Process delete wall action
+        if session_state["pending_actions"].get("delete_wall") is not None:
+            wall_index = session_state["pending_actions"]["delete_wall"]
+            if 0 <= wall_index < len(session_state["components"]["walls"]):
+                session_state["components"]["walls"].pop(wall_index)
+            session_state["pending_actions"]["delete_wall"] = None
+        
+        # Process add roof action
+        if session_state["pending_actions"].get("add_roof") is not None:
+            new_roof = session_state["pending_actions"]["add_roof"]
+            session_state["components"]["roofs"].append(new_roof)
+            session_state["pending_actions"]["add_roof"] = None
+        
+        # Process delete roof action
+        if session_state["pending_actions"].get("delete_roof") is not None:
+            roof_index = session_state["pending_actions"]["delete_roof"]
+            if 0 <= roof_index < len(session_state["components"]["roofs"]):
+                session_state["components"]["roofs"].pop(roof_index)
+            session_state["pending_actions"]["delete_roof"] = None
+        
+        # Process add floor action
+        if session_state["pending_actions"].get("add_floor") is not None:
+            new_floor = session_state["pending_actions"]["add_floor"]
+            session_state["components"]["floors"].append(new_floor)
+            session_state["pending_actions"]["add_floor"] = None
+        
+        # Process delete floor action
+        if session_state["pending_actions"].get("delete_floor") is not None:
+            floor_index = session_state["pending_actions"]["delete_floor"]
+            if 0 <= floor_index < len(session_state["components"]["floors"]):
+                session_state["components"]["floors"].pop(floor_index)
+            session_state["pending_actions"]["delete_floor"] = None
+        
+        # Process add window action
+        if session_state["pending_actions"].get("add_window") is not None:
+            new_window = session_state["pending_actions"]["add_window"]
+            session_state["components"]["windows"].append(new_window)
+            session_state["pending_actions"]["add_window"] = None
+        
+        # Process delete window action
+        if session_state["pending_actions"].get("delete_window") is not None:
+            window_index = session_state["pending_actions"]["delete_window"]
+            if 0 <= window_index < len(session_state["components"]["windows"]):
+                session_state["components"]["windows"].pop(window_index)
+            session_state["pending_actions"]["delete_window"] = None
+        
+        # Process add door action
+        if session_state["pending_actions"].get("add_door") is not None:
+            new_door = session_state["pending_actions"]["add_door"]
+            session_state["components"]["doors"].append(new_door)
+            session_state["pending_actions"]["add_door"] = None
+        
+        # Process delete door action
+        if session_state["pending_actions"].get("delete_door") is not None:
+            door_index = session_state["pending_actions"]["delete_door"]
+            if 0 <= door_index < len(session_state["components"]["doors"]):
+                session_state["components"]["doors"].pop(door_index)
+            session_state["pending_actions"]["delete_door"] = None
+    
+    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": []
+            }
+            
+        # Initialize form submission flags if not exists
+        if "form_submitted" not in session_state:
+            session_state["form_submitted"] = {
+                "wall_form": False,
+                "roof_form": False,
+                "floor_form": False,
+                "window_form": False,
+                "door_form": False
+            }
+        
+        # Display components grouped by orientation
+        self._display_components_by_orientation(session_state)
+        
+        # Display roof and floor components (using building info area)
+        self._display_roof_floor_components(session_state)
+        
+        # Add component buttons
+        st.subheader("Add New Components")
+        col1, col2, col3, col4, col5 = st.columns(5)
+        
+        with col1:
+            if st.button("Add Wall"):
+                session_state["add_component_type"] = "wall"
+                
+        with col2:
+            if st.button("Add Window"):
+                session_state["add_component_type"] = "window"
+                
+        with col3:
+            if st.button("Add Door"):
+                session_state["add_component_type"] = "door"
+                
+        with col4:
+            if st.button("Add Roof"):
+                session_state["add_component_type"] = "roof"
+                
+        with col5:
+            if st.button("Add Floor"):
+                session_state["add_component_type"] = "floor"
+        
+        # Display appropriate form based on selected component type
+        if "add_component_type" in session_state:
+            component_type = session_state["add_component_type"]
+            
+            if component_type == "wall":
+                self._display_wall_form(session_state)
+            elif component_type == "window":
+                self._display_window_form(session_state)
+            elif component_type == "door":
+                self._display_door_form(session_state)
+            elif component_type == "roof":
+                self._display_roof_form(session_state)
+            elif component_type == "floor":
+                self._display_floor_form(session_state)
+    
+    def _display_components_by_orientation(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display components grouped by orientation.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        st.subheader("Components by Orientation")
+        
+        # Get all components
+        walls = session_state["components"]["walls"]
+        windows = session_state["components"]["windows"]
+        doors = session_state["components"]["doors"]
+        
+        # Group components by orientation
+        orientations = [
+            Orientation.NORTH,
+            Orientation.NORTHEAST,
+            Orientation.EAST,
+            Orientation.SOUTHEAST,
+            Orientation.SOUTH,
+            Orientation.SOUTHWEST,
+            Orientation.WEST,
+            Orientation.NORTHWEST
+        ]
+        
+        # Check if there are any components to display
+        has_components = len(walls) > 0 or len(windows) > 0 or len(doors) > 0
+        
+        if not has_components:
+            st.info("No components added yet. Use the buttons below to add components.")
+            return
+        
+        # Display components for each orientation
+        for orientation in orientations:
+            # Filter components by orientation
+            orientation_walls = [wall for wall in walls if wall.orientation == orientation]
+            orientation_windows = [window for window in windows if window.orientation == orientation]
+            orientation_doors = [door for door in doors if door.orientation == orientation]
+            
+            # Skip if no components for this orientation
+            if not orientation_walls and not orientation_windows and not orientation_doors:
+                continue
+            
+            # Display orientation header
+            st.write(f"### {orientation.value} Components")
+            
+            # Create data for all components in this orientation
+            component_data = []
+            
+            # Add walls
+            for i, wall in enumerate(orientation_walls):
+                component_data.append({
+                    "ID": f"W{i+1}",
+                    "Type": "Wall",
+                    "Name": wall.name,
+                    "U-Value (W/m²K)": f"{wall.u_value:.3f}",
+                    "Area (m²)": f"{wall.area:.2f}",
+                    "Group": wall.wall_group
+                })
+            
+            # Add windows
+            for i, window in enumerate(orientation_windows):
+                component_data.append({
+                    "ID": f"G{i+1}",
+                    "Type": "Window",
+                    "Name": window.name,
+                    "U-Value (W/m²K)": f"{window.u_value:.3f}",
+                    "Area (m²)": f"{window.area:.2f}",
+                    "SHGC": f"{window.shgc:.2f}"
+                })
+            
+            # Add doors
+            for i, door in enumerate(orientation_doors):
+                component_data.append({
+                    "ID": f"D{i+1}",
+                    "Type": "Door",
+                    "Name": door.name,
+                    "U-Value (W/m²K)": f"{door.u_value:.3f}",
+                    "Area (m²)": f"{door.area:.2f}",
+                    "Material": door.door_type
+                })
+            
+            # Display components table
+            if component_data:
+                component_df = pd.DataFrame(component_data)
+                st.dataframe(component_df)
+            
+            # Add edit/delete options
+            col1, col2, col3 = st.columns(3)
+            
+            with col1:
+                # Wall edit/delete
+                if orientation_walls:
+                    wall_to_modify = st.selectbox(
+                        f"Select wall ({orientation.value}):",
+                        options=range(len(orientation_walls)),
+                        format_func=lambda x: f"Wall #{x+1}: {orientation_walls[x].name}",
+                        key=f"wall_select_{orientation.value}"
+                    )
+                    
+                    edit_col, delete_col = st.columns(2)
+                    with edit_col:
+                        if st.button("Edit", key=f"edit_wall_{orientation.value}"):
+                            # Find the global index of this wall
+                            global_index = walls.index(orientation_walls[wall_to_modify])
+                            session_state["wall_to_edit"] = global_index
+                            session_state["add_component_type"] = "wall"
+                    
+                    with delete_col:
+                        if st.button("Delete", key=f"delete_wall_{orientation.value}"):
+                            # Find the global index of this wall
+                            global_index = walls.index(orientation_walls[wall_to_modify])
+                            session_state["pending_actions"]["delete_wall"] = global_index
+            
+            with col2:
+                # Window edit/delete
+                if orientation_windows:
+                    window_to_modify = st.selectbox(
+                        f"Select window ({orientation.value}):",
+                        options=range(len(orientation_windows)),
+                        format_func=lambda x: f"Window #{x+1}: {orientation_windows[x].name}",
+                        key=f"window_select_{orientation.value}"
+                    )
+                    
+                    edit_col, delete_col = st.columns(2)
+                    with edit_col:
+                        if st.button("Edit", key=f"edit_window_{orientation.value}"):
+                            # Find the global index of this window
+                            global_index = windows.index(orientation_windows[window_to_modify])
+                            session_state["window_to_edit"] = global_index
+                            session_state["add_component_type"] = "window"
+                    
+                    with delete_col:
+                        if st.button("Delete", key=f"delete_window_{orientation.value}"):
+                            # Find the global index of this window
+                            global_index = windows.index(orientation_windows[window_to_modify])
+                            session_state["pending_actions"]["delete_window"] = global_index
+            
+            with col3:
+                # Door edit/delete
+                if orientation_doors:
+                    door_to_modify = st.selectbox(
+                        f"Select door ({orientation.value}):",
+                        options=range(len(orientation_doors)),
+                        format_func=lambda x: f"Door #{x+1}: {orientation_doors[x].name}",
+                        key=f"door_select_{orientation.value}"
+                    )
+                    
+                    edit_col, delete_col = st.columns(2)
+                    with edit_col:
+                        if st.button("Edit", key=f"edit_door_{orientation.value}"):
+                            # Find the global index of this door
+                            global_index = doors.index(orientation_doors[door_to_modify])
+                            session_state["door_to_edit"] = global_index
+                            session_state["add_component_type"] = "door"
+                    
+                    with delete_col:
+                        if st.button("Delete", key=f"delete_door_{orientation.value}"):
+                            # Find the global index of this door
+                            global_index = doors.index(orientation_doors[door_to_modify])
+                            session_state["pending_actions"]["delete_door"] = global_index
+            
+            st.markdown("---")
+    
+    def _display_roof_floor_components(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display roof and floor components.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        st.subheader("Roof and Floor Components")
+        
+        # Get roof and floor components
+        roofs = session_state["components"]["roofs"]
+        floors = session_state["components"]["floors"]
+        
+        # Check if there are any components to display
+        has_components = len(roofs) > 0 or len(floors) > 0
+        
+        if not has_components:
+            st.info("No roof or floor components added yet. Use the buttons below to add components.")
+            return
+        
+        # Display roof components
+        if roofs:
+            st.write("### Roof Components")
+            
+            # Create data for roof components
+            roof_data = []
+            for i, roof in enumerate(roofs):
+                roof_data.append({
+                    "ID": i + 1,
+                    "Name": roof.name,
+                    "Type": roof.roof_type,
+                    "U-Value (W/m²K)": f"{roof.u_value:.3f}",
+                    "Area (m²)": f"{roof.area:.2f}",
+                    "Group": roof.roof_group
+                })
+            
+            # Display roof table
+            roof_df = pd.DataFrame(roof_data)
+            st.dataframe(roof_df)
+            
+            # Add edit/delete options
+            col1, col2 = st.columns(2)
+            with col1:
+                roof_to_modify = st.selectbox(
+                    "Select roof to modify:",
+                    options=range(len(roofs)),
+                    format_func=lambda x: f"Roof #{x+1}: {roofs[x].name}"
+                )
+            
+            with col2:
+                edit_col, delete_col = st.columns(2)
+                with edit_col:
+                    if st.button("Edit Roof"):
+                        session_state["roof_to_edit"] = roof_to_modify
+                        session_state["add_component_type"] = "roof"
+                
+                with delete_col:
+                    if st.button("Delete Roof"):
+                        session_state["pending_actions"]["delete_roof"] = roof_to_modify
+        
+        # Display floor components
+        if floors:
+            st.write("### Floor Components")
+            
+            # Create data for floor components
+            floor_data = []
+            for i, floor in enumerate(floors):
+                floor_data.append({
+                    "ID": i + 1,
+                    "Name": floor.name,
+                    "Type": floor.floor_type,
+                    "U-Value (W/m²K)": f"{floor.u_value:.3f}",
+                    "Area (m²)": f"{floor.area:.2f}",
+                    "Ground Contact": "Yes" if floor.is_ground_contact else "No"
+                })
+            
+            # Display floor table
+            floor_df = pd.DataFrame(floor_data)
+            st.dataframe(floor_df)
+            
+            # Add edit/delete options
+            col1, col2 = st.columns(2)
+            with col1:
+                floor_to_modify = st.selectbox(
+                    "Select floor to modify:",
+                    options=range(len(floors)),
+                    format_func=lambda x: f"Floor #{x+1}: {floors[x].name}"
+                )
+            
+            with col2:
+                edit_col, delete_col = st.columns(2)
+                with edit_col:
+                    if st.button("Edit Floor"):
+                        session_state["floor_to_edit"] = floor_to_modify
+                        session_state["add_component_type"] = "floor"
+                
+                with delete_col:
+                    if st.button("Delete Floor"):
+                        session_state["pending_actions"]["delete_floor"] = floor_to_modify
+        
+        st.markdown("---")
+    
+    def _display_wall_form(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display wall form for adding or editing a wall.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        # Check if we're editing an existing wall
+        editing_wall = "wall_to_edit" in session_state
+        wall_to_edit = session_state.get("wall_to_edit", None)
+        
+        # Get the wall to edit if we're editing
+        wall = None
+        if editing_wall and wall_to_edit is not None:
+            wall = session_state["components"]["walls"][wall_to_edit]
+        
+        # Form title
+        if editing_wall:
+            st.subheader(f"Edit Wall: {wall.name if wall else ''}")
+        else:
+            st.subheader("Add New Wall")
+        
+        # Wall form
+        with st.form(key="wall_form"):
+            # Wall name
+            wall_name = st.text_input(
+                "Wall Name:",
+                value=wall.name if wall else ""
+            )
+            
+            # Wall type selection
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Get preset wall types
+                preset_walls = self.component_library.get_preset_components_by_type(ComponentType.WALL)
+                preset_wall_names = [wall.name for wall in preset_walls]
+                
+                wall_type = st.selectbox(
+                    "Wall Type:",
+                    options=["Custom"] + preset_wall_names,
+                    index=preset_wall_names.index(wall.wall_type) + 1 if wall and wall.wall_type in preset_wall_names else 0
+                )
+            
+            # U-value
+            with col2:
+                if wall_type == "Custom":
+                    u_value = st.number_input(
+                        "U-Value (W/m²K):",
+                        min_value=0.0,
+                        max_value=10.0,
+                        value=wall.u_value if wall else 0.5,
+                        step=0.01
+                    )
+                else:
+                    # Get U-value from preset wall
+                    selected_wall = next((w for w in preset_walls if w.name == wall_type), None)
+                    u_value = selected_wall.u_value if selected_wall else 0.5
+                    st.write(f"U-Value: {u_value:.3f} W/m²K")
+            
+            # Wall dimensions
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                wall_height = st.number_input(
+                    "Wall Height (m):",
+                    min_value=0.1,
+                    max_value=50.0,
+                    value=3.0 if not wall else (wall.area / 10.0),  # Assuming width of 10m if editing
+                    step=0.1
+                )
+            
+            with col2:
+                wall_width = st.number_input(
+                    "Wall Width (m):",
+                    min_value=0.1,
+                    max_value=100.0,
+                    value=10.0 if not wall else (wall.area / wall_height),
+                    step=0.1
+                )
+            
+            # Calculate wall area
+            wall_area = wall_height * wall_width
+            st.write(f"Wall Area: {wall_area:.2f} m²")
+            
+            # Wall orientation
+            orientation_options = [
+                Orientation.NORTH,
+                Orientation.NORTHEAST,
+                Orientation.EAST,
+                Orientation.SOUTHEAST,
+                Orientation.SOUTH,
+                Orientation.SOUTHWEST,
+                Orientation.WEST,
+                Orientation.NORTHWEST
+            ]
+            
+            orientation = st.selectbox(
+                "Orientation:",
+                options=orientation_options,
+                index=orientation_options.index(wall.orientation) if wall else 0,
+                format_func=lambda x: x.value
+            )
+            
+            # Wall color
+            color_options = ["Light", "Medium", "Dark"]
+            color = st.selectbox(
+                "Color:",
+                options=color_options,
+                index=color_options.index(wall.color) if wall and wall.color in color_options else 1
+            )
+            
+            # Submit button
+            submit_label = "Update Wall" if editing_wall else "Add Wall"
+            submit = st.form_submit_button(submit_label)
+            
+            if submit:
+                # Create or update wall
+                if wall_type == "Custom":
+                    # Create custom wall
+                    new_wall = Wall(
+                        id=f"custom_wall_{str(uuid.uuid4())[:8]}",
+                        name=wall_name,
+                        component_type=ComponentType.WALL,
+                        u_value=u_value,
+                        area=wall_area,
+                        orientation=orientation,
+                        color=color,
+                        wall_type="Custom",
+                        wall_group="Custom"
+                    )
+                else:
+                    # Clone preset wall and update properties
+                    selected_wall = next((w for w in preset_walls if w.name == wall_type), None)
+                    if selected_wall:
+                        new_wall = Wall(
+                            id=f"custom_wall_{str(uuid.uuid4())[:8]}",
+                            name=wall_name,
+                            component_type=ComponentType.WALL,
+                            u_value=selected_wall.u_value,
+                            area=wall_area,
+                            orientation=orientation,
+                            color=color,
+                            wall_type=selected_wall.wall_type,
+                            wall_group=selected_wall.wall_group,
+                            material_layers=selected_wall.material_layers
+                        )
+                
+                # Add or update wall in session state
+                if editing_wall:
+                    session_state["components"]["walls"][wall_to_edit] = new_wall
+                    del session_state["wall_to_edit"]
+                else:
+                    # Queue the add action in pending_actions instead of doing it immediately
+                    session_state["pending_actions"]["add_wall"] = new_wall
+                
+                # Clear the component type selection
+                del session_state["add_component_type"]
+                st.experimental_rerun()
+        
+        # Cancel button outside the form
+        if st.button("Cancel"):
+            if editing_wall:
+                del session_state["wall_to_edit"]
+            del session_state["add_component_type"]
+            st.experimental_rerun()
+    
+    def _display_window_form(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display window form for adding or editing a window.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        # Check if we're editing an existing window
+        editing_window = "window_to_edit" in session_state
+        window_to_edit = session_state.get("window_to_edit", None)
+        
+        # Get the window to edit if we're editing
+        window = None
+        if editing_window and window_to_edit is not None:
+            window = session_state["components"]["windows"][window_to_edit]
+        
+        # Form title
+        if editing_window:
+            st.subheader(f"Edit Window: {window.name if window else ''}")
+        else:
+            st.subheader("Add New Window")
+        
+        # Window form
+        with st.form(key="window_form"):
+            # Window name
+            window_name = st.text_input(
+                "Window Name:",
+                value=window.name if window else ""
+            )
+            
+            # Window type selection
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Get preset window types
+                preset_windows = self.component_library.get_preset_components_by_type(ComponentType.WINDOW)
+                preset_window_names = [window.name for window in preset_windows]
+                
+                window_type = st.selectbox(
+                    "Window Type:",
+                    options=["Custom"] + preset_window_names,
+                    index=0
+                )
+            
+            # U-value and SHGC
+            with col2:
+                if window_type == "Custom":
+                    u_value = st.number_input(
+                        "U-Value (W/m²K):",
+                        min_value=0.0,
+                        max_value=10.0,
+                        value=window.u_value if window else 2.8,
+                        step=0.01
+                    )
+                else:
+                    # Get U-value from preset window
+                    selected_window = next((w for w in preset_windows if w.name == window_type), None)
+                    u_value = selected_window.u_value if selected_window else 2.8
+                    st.write(f"U-Value: {u_value:.3f} W/m²K")
+            
+            # SHGC
+            shgc = st.number_input(
+                "Solar Heat Gain Coefficient (SHGC):",
+                min_value=0.0,
+                max_value=1.0,
+                value=window.shgc if window else 0.7,
+                step=0.01
+            )
+            
+            # Window dimensions
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                window_height = st.number_input(
+                    "Window Height (m):",
+                    min_value=0.1,
+                    max_value=10.0,
+                    value=1.2 if not window else (window.area / 1.5),  # Assuming width of 1.5m if editing
+                    step=0.1
+                )
+            
+            with col2:
+                window_width = st.number_input(
+                    "Window Width (m):",
+                    min_value=0.1,
+                    max_value=10.0,
+                    value=1.5 if not window else (window.area / window_height),
+                    step=0.1
+                )
+            
+            # Calculate window area
+            window_area = window_height * window_width
+            st.write(f"Window Area: {window_area:.2f} m²")
+            
+            # Window orientation
+            orientation_options = [
+                Orientation.NORTH,
+                Orientation.NORTHEAST,
+                Orientation.EAST,
+                Orientation.SOUTHEAST,
+                Orientation.SOUTH,
+                Orientation.SOUTHWEST,
+                Orientation.WEST,
+                Orientation.NORTHWEST
+            ]
+            
+            orientation = st.selectbox(
+                "Orientation:",
+                options=orientation_options,
+                index=orientation_options.index(window.orientation) if window else 0,
+                format_func=lambda x: x.value
+            )
+            
+            # Shading options
+            has_shading = st.checkbox(
+                "Has Shading",
+                value=window.has_shading if window else False
+            )
+            
+            if has_shading:
+                shading_type_options = ["Internal", "External", "Between-glass"]
+                shading_type = st.selectbox(
+                    "Shading Type:",
+                    options=shading_type_options,
+                    index=0 if not window or not window.shading_type else shading_type_options.index(window.shading_type)
+                )
+                
+                shading_coefficient = st.slider(
+                    "Shading Coefficient (0-1):",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=window.shading_coefficient if window else 0.7,
+                    step=0.01
+                )
+            else:
+                shading_type = None
+                shading_coefficient = 1.0
+            
+            # Submit button
+            submit_label = "Update Window" if editing_window else "Add Window"
+            submit = st.form_submit_button(submit_label)
+            
+            if submit:
+                # Create or update window
+                if window_type == "Custom":
+                    # Create custom window
+                    new_window = Window(
+                        id=f"custom_window_{str(uuid.uuid4())[:8]}",
+                        name=window_name,
+                        component_type=ComponentType.WINDOW,
+                        u_value=u_value,
+                        area=window_area,
+                        orientation=orientation,
+                        shgc=shgc,
+                        has_shading=has_shading,
+                        shading_type=shading_type,
+                        shading_coefficient=shading_coefficient
+                    )
+                else:
+                    # Clone preset window and update properties
+                    selected_window = next((w for w in preset_windows if w.name == window_type), None)
+                    if selected_window:
+                        new_window = Window(
+                            id=f"custom_window_{str(uuid.uuid4())[:8]}",
+                            name=window_name,
+                            component_type=ComponentType.WINDOW,
+                            u_value=selected_window.u_value,
+                            area=window_area,
+                            orientation=orientation,
+                            shgc=selected_window.shgc if hasattr(selected_window, 'shgc') else shgc,
+                            has_shading=has_shading,
+                            shading_type=shading_type,
+                            shading_coefficient=shading_coefficient
+                        )
+                
+                # Add or update window in session state
+                if editing_window:
+                    session_state["components"]["windows"][window_to_edit] = new_window
+                    del session_state["window_to_edit"]
+                else:
+                    # Queue the add action in pending_actions instead of doing it immediately
+                    session_state["pending_actions"]["add_window"] = new_window
+                
+                # Clear the component type selection
+                del session_state["add_component_type"]
+                st.experimental_rerun()
+        
+        # Cancel button outside the form
+        if st.button("Cancel"):
+            if editing_window:
+                del session_state["window_to_edit"]
+            del session_state["add_component_type"]
+            st.experimental_rerun()
+    
+    def _display_door_form(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display door form for adding or editing a door.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        # Check if we're editing an existing door
+        editing_door = "door_to_edit" in session_state
+        door_to_edit = session_state.get("door_to_edit", None)
+        
+        # Get the door to edit if we're editing
+        door = None
+        if editing_door and door_to_edit is not None:
+            door = session_state["components"]["doors"][door_to_edit]
+        
+        # Form title
+        if editing_door:
+            st.subheader(f"Edit Door: {door.name if door else ''}")
+        else:
+            st.subheader("Add New Door")
+        
+        # Door form
+        with st.form(key="door_form"):
+            # Door name
+            door_name = st.text_input(
+                "Door Name:",
+                value=door.name if door else ""
+            )
+            
+            # Door type selection
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Get preset door types
+                preset_doors = self.component_library.get_preset_components_by_type(ComponentType.DOOR)
+                preset_door_names = [door.name for door in preset_doors]
+                
+                door_type = st.selectbox(
+                    "Door Type:",
+                    options=["Custom"] + preset_door_names,
+                    index=0
+                )
+            
+            # U-value
+            with col2:
+                if door_type == "Custom":
+                    u_value = st.number_input(
+                        "U-Value (W/m²K):",
+                        min_value=0.0,
+                        max_value=10.0,
+                        value=door.u_value if door else 2.0,
+                        step=0.01
+                    )
+                else:
+                    # Get U-value from preset door
+                    selected_door = next((d for d in preset_doors if d.name == door_type), None)
+                    u_value = selected_door.u_value if selected_door else 2.0
+                    st.write(f"U-Value: {u_value:.3f} W/m²K")
+            
+            # Door dimensions
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                door_height = st.number_input(
+                    "Door Height (m):",
+                    min_value=0.1,
+                    max_value=5.0,
+                    value=2.0 if not door else (door.area / 0.9),  # Assuming width of 0.9m if editing
+                    step=0.1
+                )
+            
+            with col2:
+                door_width = st.number_input(
+                    "Door Width (m):",
+                    min_value=0.1,
+                    max_value=5.0,
+                    value=0.9 if not door else (door.area / door_height),
+                    step=0.1
+                )
+            
+            # Calculate door area
+            door_area = door_height * door_width
+            st.write(f"Door Area: {door_area:.2f} m²")
+            
+            # Door orientation
+            orientation_options = [
+                Orientation.NORTH,
+                Orientation.NORTHEAST,
+                Orientation.EAST,
+                Orientation.SOUTHEAST,
+                Orientation.SOUTH,
+                Orientation.SOUTHWEST,
+                Orientation.WEST,
+                Orientation.NORTHWEST
+            ]
+            
+            orientation = st.selectbox(
+                "Orientation:",
+                options=orientation_options,
+                index=orientation_options.index(door.orientation) if door else 0,
+                format_func=lambda x: x.value
+            )
+            
+            # Submit button
+            submit_label = "Update Door" if editing_door else "Add Door"
+            submit = st.form_submit_button(submit_label)
+            
+            if submit:
+                # Create or update door
+                if door_type == "Custom":
+                    # Create custom door
+                    new_door = Door(
+                        id=f"custom_door_{str(uuid.uuid4())[:8]}",
+                        name=door_name,
+                        component_type=ComponentType.DOOR,
+                        u_value=u_value,
+                        area=door_area,
+                        orientation=orientation,
+                        door_type="Custom"
+                    )
+                else:
+                    # Clone preset door and update properties
+                    selected_door = next((d for d in preset_doors if d.name == door_type), None)
+                    if selected_door:
+                        new_door = Door(
+                            id=f"custom_door_{str(uuid.uuid4())[:8]}",
+                            name=door_name,
+                            component_type=ComponentType.DOOR,
+                            u_value=selected_door.u_value,
+                            area=door_area,
+                            orientation=orientation,
+                            door_type=selected_door.door_type
+                        )
+                
+                # Add or update door in session state
+                if editing_door:
+                    session_state["components"]["doors"][door_to_edit] = new_door
+                    del session_state["door_to_edit"]
+                else:
+                    # Queue the add action in pending_actions instead of doing it immediately
+                    session_state["pending_actions"]["add_door"] = new_door
+                
+                # Clear the component type selection
+                del session_state["add_component_type"]
+                st.experimental_rerun()
+        
+        # Cancel button outside the form
+        if st.button("Cancel"):
+            if editing_door:
+                del session_state["door_to_edit"]
+            del session_state["add_component_type"]
+            st.experimental_rerun()
+    
+    def _display_roof_form(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display roof form for adding or editing a roof.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        # Check if we're editing an existing roof
+        editing_roof = "roof_to_edit" in session_state
+        roof_to_edit = session_state.get("roof_to_edit", None)
+        
+        # Get the roof to edit if we're editing
+        roof = None
+        if editing_roof and roof_to_edit is not None:
+            roof = session_state["components"]["roofs"][roof_to_edit]
+        
+        # Form title
+        if editing_roof:
+            st.subheader(f"Edit Roof: {roof.name if roof else ''}")
+        else:
+            st.subheader("Add New Roof")
+        
+        # Get building floor area from building info if available
+        building_area = 0.0
+        if "building_info" in session_state and "floor_area" in session_state["building_info"]:
+            building_area = session_state["building_info"]["floor_area"]
+        
+        # Roof form
+        with st.form(key="roof_form"):
+            # Roof name
+            roof_name = st.text_input(
+                "Roof Name:",
+                value=roof.name if roof else ""
+            )
+            
+            # Roof type selection
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Get preset roof types
+                preset_roofs = self.component_library.get_preset_components_by_type(ComponentType.ROOF)
+                preset_roof_names = [roof.name for roof in preset_roofs]
+                
+                roof_type = st.selectbox(
+                    "Roof Type:",
+                    options=["Custom"] + preset_roof_names,
+                    index=0
+                )
+            
+            # U-value
+            with col2:
+                if roof_type == "Custom":
+                    u_value = st.number_input(
+                        "U-Value (W/m²K):",
+                        min_value=0.0,
+                        max_value=10.0,
+                        value=roof.u_value if roof else 0.25,
+                        step=0.01
+                    )
+                else:
+                    # Get U-value from preset roof
+                    selected_roof = next((r for r in preset_roofs if r.name == roof_type), None)
+                    u_value = selected_roof.u_value if selected_roof else 0.25
+                    st.write(f"U-Value: {u_value:.3f} W/m²K")
+            
+            # Roof area
+            if building_area > 0:
+                st.write(f"Building Floor Area: {building_area:.2f} m²")
+                use_building_area = st.checkbox(
+                    "Use Building Floor Area",
+                    value=True
+                )
+                
+                if use_building_area:
+                    roof_area = building_area
+                    st.write(f"Roof Area: {roof_area:.2f} m²")
+                else:
+                    roof_area = st.number_input(
+                        "Roof Area (m²):",
+                        min_value=0.1,
+                        max_value=10000.0,
+                        value=roof.area if roof else building_area,
+                        step=1.0
+                    )
+            else:
+                roof_area = st.number_input(
+                    "Roof Area (m²):",
+                    min_value=0.1,
+                    max_value=10000.0,
+                    value=roof.area if roof else 100.0,
+                    step=1.0
+                )
+            
+            # Roof color
+            color_options = ["Light", "Medium", "Dark"]
+            color = st.selectbox(
+                "Color:",
+                options=color_options,
+                index=color_options.index(roof.color) if roof and roof.color in color_options else 1
+            )
+            
+            # Roof pitch
+            roof_pitch = st.number_input(
+                "Roof Pitch (degrees):",
+                min_value=0.0,
+                max_value=60.0,
+                value=roof.pitch if roof else 0.0,
+                step=1.0
+            )
+            
+            # Submit button
+            submit_label = "Update Roof" if editing_roof else "Add Roof"
+            submit = st.form_submit_button(submit_label)
+            
+            if submit:
+                # Create or update roof
+                if roof_type == "Custom":
+                    # Create custom roof
+                    new_roof = Roof(
+                        id=f"custom_roof_{str(uuid.uuid4())[:8]}",
+                        name=roof_name,
+                        component_type=ComponentType.ROOF,
+                        u_value=u_value,
+                        area=roof_area,
+                        orientation=Orientation.HORIZONTAL,
+                        color=color,
+                        roof_type="Custom",
+                        roof_group="Custom",
+                        pitch=roof_pitch
+                    )
+                else:
+                    # Clone preset roof and update properties
+                    selected_roof = next((r for r in preset_roofs if r.name == roof_type), None)
+                    if selected_roof:
+                        new_roof = Roof(
+                            id=f"custom_roof_{str(uuid.uuid4())[:8]}",
+                            name=roof_name,
+                            component_type=ComponentType.ROOF,
+                            u_value=selected_roof.u_value,
+                            area=roof_area,
+                            orientation=Orientation.HORIZONTAL,
+                            color=color,
+                            roof_type=selected_roof.roof_type,
+                            roof_group=selected_roof.roof_group,
+                            pitch=roof_pitch,
+                            material_layers=selected_roof.material_layers
+                        )
+                
+                # Add or update roof in session state
+                if editing_roof:
+                    session_state["components"]["roofs"][roof_to_edit] = new_roof
+                    del session_state["roof_to_edit"]
+                else:
+                    # Queue the add action in pending_actions instead of doing it immediately
+                    session_state["pending_actions"]["add_roof"] = new_roof
+                
+                # Clear the component type selection
+                del session_state["add_component_type"]
+                st.experimental_rerun()
+        
+        # Cancel button outside the form
+        if st.button("Cancel"):
+            if editing_roof:
+                del session_state["roof_to_edit"]
+            del session_state["add_component_type"]
+            st.experimental_rerun()
+    
+    def _display_floor_form(self, session_state: Dict[str, Any]) -> None:
+        """
+        Display floor form for adding or editing a floor.
+        
+        Args:
+            session_state: Streamlit session state
+        """
+        # Check if we're editing an existing floor
+        editing_floor = "floor_to_edit" in session_state
+        floor_to_edit = session_state.get("floor_to_edit", None)
+        
+        # Get the floor to edit if we're editing
+        floor = None
+        if editing_floor and floor_to_edit is not None:
+            floor = session_state["components"]["floors"][floor_to_edit]
+        
+        # Form title
+        if editing_floor:
+            st.subheader(f"Edit Floor: {floor.name if floor else ''}")
+        else:
+            st.subheader("Add New Floor")
+        
+        # Get building floor area from building info if available
+        building_area = 0.0
+        if "building_info" in session_state and "floor_area" in session_state["building_info"]:
+            building_area = session_state["building_info"]["floor_area"]
+        
+        # Floor form
+        with st.form(key="floor_form"):
+            # Floor name
+            floor_name = st.text_input(
+                "Floor Name:",
+                value=floor.name if floor else ""
+            )
+            
+            # Floor type selection
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Get preset floor types
+                preset_floors = self.component_library.get_preset_components_by_type(ComponentType.FLOOR)
+                preset_floor_names = [floor.name for floor in preset_floors]
+                
+                floor_type = st.selectbox(
+                    "Floor Type:",
+                    options=["Custom"] + preset_floor_names,
+                    index=0
+                )
+            
+            # U-value
+            with col2:
+                if floor_type == "Custom":
+                    u_value = st.number_input(
+                        "U-Value (W/m²K):",
+                        min_value=0.0,
+                        max_value=10.0,
+                        value=floor.u_value if floor else 0.25,
+                        step=0.01
+                    )
+                else:
+                    # Get U-value from preset floor
+                    selected_floor = next((f for f in preset_floors if f.name == floor_type), None)
+                    u_value = selected_floor.u_value if selected_floor else 0.25
+                    st.write(f"U-Value: {u_value:.3f} W/m²K")
+            
+            # Floor area
+            if building_area > 0:
+                st.write(f"Building Floor Area: {building_area:.2f} m²")
+                use_building_area = st.checkbox(
+                    "Use Building Floor Area",
+                    value=True
+                )
+                
+                if use_building_area:
+                    floor_area = building_area
+                    st.write(f"Floor Area: {floor_area:.2f} m²")
+                else:
+                    floor_area = st.number_input(
+                        "Floor Area (m²):",
+                        min_value=0.1,
+                        max_value=10000.0,
+                        value=floor.area if floor else building_area,
+                        step=1.0
+                    )
+            else:
+                floor_area = st.number_input(
+                    "Floor Area (m²):",
+                    min_value=0.1,
+                    max_value=10000.0,
+                    value=floor.area if floor else 100.0,
+                    step=1.0
+                )
+            
+            # Ground contact
+            is_ground_contact = st.checkbox(
+                "Is in contact with ground",
+                value=floor.is_ground_contact if floor else True
+            )
+            
+            # Perimeter length (for slab-on-grade floors)
+            if is_ground_contact:
+                perimeter_length = st.number_input(
+                    "Perimeter Length (m):",
+                    min_value=0.0,
+                    max_value=1000.0,
+                    value=floor.perimeter_length if floor else (4 * (floor_area ** 0.5)),  # Estimate perimeter as 4 * sqrt(area) for a square
+                    step=1.0
+                )
+            else:
+                perimeter_length = 0.0
+            
+            # Submit button
+            submit_label = "Update Floor" if editing_floor else "Add Floor"
+            submit = st.form_submit_button(submit_label)
+            
+            if submit:
+                # Create or update floor
+                if floor_type == "Custom":
+                    # Create custom floor
+                    new_floor = Floor(
+                        id=f"custom_floor_{str(uuid.uuid4())[:8]}",
+                        name=floor_name,
+                        component_type=ComponentType.FLOOR,
+                        u_value=u_value,
+                        area=floor_area,
+                        orientation=Orientation.HORIZONTAL,
+                        floor_type="Custom",
+                        is_ground_contact=is_ground_contact,
+                        perimeter_length=perimeter_length
+                    )
+                else:
+                    # Clone preset floor and update properties
+                    selected_floor = next((f for f in preset_floors if f.name == floor_type), None)
+                    if selected_floor:
+                        new_floor = Floor(
+                            id=f"custom_floor_{str(uuid.uuid4())[:8]}",
+                            name=floor_name,
+                            component_type=ComponentType.FLOOR,
+                            u_value=selected_floor.u_value,
+                            area=floor_area,
+                            orientation=Orientation.HORIZONTAL,
+                            floor_type=selected_floor.floor_type,
+                            is_ground_contact=is_ground_contact,
+                            perimeter_length=perimeter_length,
+                            material_layers=selected_floor.material_layers
+                        )
+                
+                # Add or update floor in session state
+                if editing_floor:
+                    session_state["components"]["floors"][floor_to_edit] = new_floor
+                    del session_state["floor_to_edit"]
+                else:
+                    # Queue the add action in pending_actions instead of doing it immediately
+                    session_state["pending_actions"]["add_floor"] = new_floor
+                
+                # Clear the component type selection
+                del session_state["add_component_type"]
+                st.experimental_rerun()
+        
+        # Cancel button outside the form
+        if st.button("Cancel"):
+            if editing_floor:
+                del session_state["floor_to_edit"]
+            del session_state["add_component_type"]
+            st.experimental_rerun()

app/main.py

@@ -23,7 +23,7 @@ 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.component_selection_redesign import ComponentSelectionRedesigned
 from app.results_display import ResultsDisplay
 from app.data_validation import DataValidation
 from app.data_persistence import DataPersistence
@@ -51,20 +51,7 @@ 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
-    """
+    """Main HVAC Calculator application class."""
     
     def __init__(self):
         """Initialize the HVAC Calculator application."""
@@ -76,256 +63,216 @@ class HVACCalculator:
             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': []
-            }
+        # Initialize session state
+        self._initialize_session_state()
         
-        if 'internal_loads' not in st.session_state:
-            st.session_state.internal_loads = {
-                'people': [],
-                'lighting': [],
-                'equipment': []
-            }
+        # Initialize application modules
+        self._initialize_modules()
         
-        if 'calculation_results' not in st.session_state:
+        # Setup application layout
+        self.setup_layout()
+    
+    def _initialize_session_state(self):
+        """Initialize Streamlit session state variables."""
+        # Initialize page navigation
+        if "page" not in st.session_state:
+            st.session_state.page = "building_info"
+        
+        # Initialize calculation results
+        if "calculation_results" not in st.session_state:
             st.session_state.calculation_results = {
-                'cooling': {},
-                'heating': {}
+                "cooling_load": {},
+                "heating_load": {},
+                "psychrometrics": {}
             }
-        
-        if 'scenarios' not in st.session_state:
-            st.session_state.scenarios = []
-        
-        # Initialize application modules
+    
+    def _initialize_modules(self):
+        """Initialize application modules."""
+        # Application modules
         self.building_info_form = BuildingInfoForm()
-        self.component_selection = ComponentSelection()
+        self.component_selection = ComponentSelectionRedesigned()
         self.results_display = ResultsDisplay()
         self.data_validation = DataValidation()
         self.data_persistence = DataPersistence()
         self.data_export = DataExport()
         
-        # Initialize calculation modules
+        # Data modules
+        self.reference_data = ReferenceData()
+        self.climate_data = ClimateData()
+        self.ashrae_tables = ASHRAETables()
+        
+        # Utility modules
+        self.component_library = ComponentLibrary()
+        self.u_value_calculator = UValueCalculator()
+        self.shading_system = ShadingSystem()
+        self.area_calculation_system = AreaCalculationSystem()
+        self.psychrometrics = Psychrometrics()
+        self.heat_transfer = HeatTransfer()
         self.cooling_load = CoolingLoad()
         self.heating_load = HeatingLoad()
-        
-        # Set up the application layout
-        self.setup_layout()
+        self.component_visualization = ComponentVisualization()
+        self.scenario_comparison = ScenarioComparison()
+        self.psychrometric_visualization = PsychrometricVisualization()
+        self.time_based_visualization = TimeBasedVisualization()
     
     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"
-        ]
+        """Setup the application layout."""
+        # Display header
+        st.title("HVAC Load Calculator")
+        st.markdown("A comprehensive tool for calculating heating and cooling loads using ASHRAE methods.")
         
-        selected_page = st.sidebar.radio("Go to", pages, index=pages.index(st.session_state.page))
+        # Setup sidebar
+        self.setup_sidebar()
         
-        # Update session state if page changed
-        if selected_page != st.session_state.page:
-            st.session_state.page = selected_page
+        # Run calculations when button is clicked
+        self.run_calculations()
         
-        # Add calculate button in sidebar
-        if st.sidebar.button("Run Calculations"):
-            self.run_calculations()
-        
-        # Display the selected page
+        # Display current 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 setup_sidebar(self):
+        """Setup the application sidebar."""
+        with st.sidebar:
+            st.header("Navigation")
+            
+            # Navigation buttons
+            if st.button("Building Information", key="nav_building_info"):
+                st.session_state.page = "building_info"
+            
+            if st.button("Building Components", key="nav_components"):
+                st.session_state.page = "components"
+            
+            if st.button("Internal Loads", key="nav_internal_loads"):
+                st.session_state.page = "internal_loads"
+            
+            if st.button("Calculation Results", key="nav_results"):
+                st.session_state.page = "results"
+            
+            if st.button("Export Data", key="nav_export"):
+                st.session_state.page = "export"
+            
+            st.markdown("---")
+            
+            # Run calculations button
+            if st.button("Run Calculations", key="run_calculations"):
+                st.session_state.run_calculations = True
+            
+            st.markdown("---")
+            
+            # Display application info
+            st.subheader("About")
+            st.write("HVAC Load Calculator v1.0.0")
+            st.write("© 2025 Manus AI")
     
     def display_page(self, page: str):
         """
         Display the selected page.
         
         Args:
-            page (str): The page to display
+            page: Page to display
         """
-        if page == "Building Information":
+        if page == "building_info":
             self.building_info_form.display()
-        elif page == "Climate Data":
-            self.display_climate_data()
-        elif page == "Building Components":
+        elif page == "components":
             self.component_selection.display()
-        elif page == "Internal Loads":
+        elif page == "internal_loads":
             self.display_internal_loads()
-        elif page == "Calculation Results":
+        elif page == "results":
             self.results_display.display()
-        elif page == "Export Data":
+        elif page == "export":
             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)
-    
     def display_internal_loads(self):
-        """Display the internal loads page."""
-        st.title("Internal Loads")
+        """Display internal loads interface."""
+        st.header("Internal Loads")
         
-        # 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
+        # Initialize internal loads in session state if not exists
+        if "internal_loads" not in st.session_state:
+            st.session_state.internal_loads = {
+                "people": [],
+                "lighting": [],
+                "equipment": []
+            }
         
         # Create tabs for different internal load types
         tab1, tab2, tab3 = st.tabs(["People", "Lighting", "Equipment"])
         
         with tab1:
-            # Display people loads
-            st.subheader("People Loads")
+            st.subheader("People")
             
             # Display existing people loads
-            if st.session_state.internal_loads.get('people'):
+            if st.session_state.internal_loads["people"]:
                 st.write("Existing People Loads:")
-                people_data = []
                 
-                for i, people_load in enumerate(st.session_state.internal_loads['people']):
+                # Create a table of existing people loads
+                people_data = []
+                for i, load in enumerate(st.session_state.internal_loads["people"]):
                     people_data.append({
-                        "Space": people_load.get('space', 'Unknown'),
-                        "Count": people_load.get('count', 0),
-                        "Activity Level": people_load.get('activity_level', 'Seated, light work')
+                        "ID": i + 1,
+                        "Zone": load.get("zone", "Main Zone"),
+                        "Number of People": load.get("count", 0),
+                        "Activity Level": load.get("activity", "Seated, light work"),
+                        "Sensible Heat (W/person)": load.get("sensible_heat", 70),
+                        "Latent Heat (W/person)": load.get("latent_heat", 45),
+                        "Schedule": load.get("schedule", "8 AM - 6 PM")
                     })
-                    
-                    # Add delete button
-                    if st.button(f"Delete {people_load.get('space', 'Unknown')}", key=f"delete_people_{i}"):
-                        st.session_state.internal_loads['people'].pop(i)
-                        st.experimental_rerun()
                 
-                # Display as table
-                st.table(pd.DataFrame(people_data))
+                people_df = pd.DataFrame(people_data)
+                st.dataframe(people_df)
+                
+                # Add edit and delete buttons for people loads
+                col1, col2 = st.columns(2)
+                with col1:
+                    people_to_edit = st.selectbox(
+                        "Select people load to edit:",
+                        options=range(1, len(st.session_state.internal_loads["people"]) + 1),
+                        format_func=lambda x: f"People Load #{x}: {st.session_state.internal_loads['people'][x-1].get('zone', 'Main Zone')}"
+                    )
+                
+                with col2:
+                    edit_col, delete_col = st.columns(2)
+                    with edit_col:
+                        if st.button("Edit People Load", key="edit_people"):
+                            st.session_state.people_to_edit = people_to_edit - 1
+                    
+                    with delete_col:
+                        if st.button("Delete People Load", key="delete_people"):
+                            st.session_state.internal_loads["people"].pop(people_to_edit - 1)
             
-            # Add new people load
+            # Add new people load form
             st.write("Add New People Load:")
-            with st.form("add_people_form"):
-                space_name = st.text_input("Space Name", "Main Room")
-                people_count = st.number_input("Number of People", min_value=1, value=10)
-                activity_level = st.selectbox(
-                    "Activity Level",
-                    options=[
+            
+            # Check if we're editing an existing people load
+            editing_people = "people_to_edit" in st.session_state
+            people_to_edit = st.session_state.get("people_to_edit", None)
+            
+            # Get the people load to edit if we're editing
+            people_load = None
+            if editing_people and people_to_edit is not None:
+                people_load = st.session_state.internal_loads["people"][people_to_edit]
+            
+            # People load form
+            with st.form(key="people_form"):
+                # Zone name
+                zone_name = st.text_input(
+                    "Zone Name:",
+                    value=people_load.get("zone", "Main Zone") if people_load else "Main Zone"
+                )
+                
+                # Number of people
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    people_count = st.number_input(
+                        "Number of People:",
+                        min_value=1,
+                        max_value=1000,
+                        value=people_load.get("count", 1) if people_load else 1,
+                        step=1
+                    )
+                
+                with col2:
+                    activity_options = [
                         "Seated, resting",
                         "Seated, light work",
                         "Seated, moderate work",
@@ -334,242 +281,438 @@ class HVACCalculator:
                         "Walking, light work",
                         "Walking, moderate work",
                         "Heavy work"
-                    ],
-                    index=1
+                    ]
+                    
+                    activity = st.selectbox(
+                        "Activity Level:",
+                        options=activity_options,
+                        index=activity_options.index(people_load.get("activity", "Seated, light work")) if people_load and people_load.get("activity") in activity_options else 1
+                    )
+                
+                # Heat gains
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    sensible_heat = st.number_input(
+                        "Sensible Heat (W/person):",
+                        min_value=0,
+                        max_value=500,
+                        value=people_load.get("sensible_heat", 70) if people_load else 70,
+                        step=5
+                    )
+                
+                with col2:
+                    latent_heat = st.number_input(
+                        "Latent Heat (W/person):",
+                        min_value=0,
+                        max_value=500,
+                        value=people_load.get("latent_heat", 45) if people_load else 45,
+                        step=5
+                    )
+                
+                # Schedule
+                schedule = st.text_input(
+                    "Schedule (e.g., 8 AM - 6 PM):",
+                    value=people_load.get("schedule", "8 AM - 6 PM") if people_load else "8 AM - 6 PM"
                 )
                 
-                submitted = st.form_submit_button("Add People Load")
+                # Submit button
+                submit_label = "Update People Load" if editing_people else "Add People Load"
+                submit = st.form_submit_button(submit_label)
                 
-                if submitted:
-                    # Add new people load to session state
-                    st.session_state.internal_loads['people'].append({
-                        'space': space_name,
-                        'count': people_count,
-                        'activity_level': activity_level
-                    })
+                if submit:
+                    # Create or update people load
+                    new_people_load = {
+                        "zone": zone_name,
+                        "count": people_count,
+                        "activity": activity,
+                        "sensible_heat": sensible_heat,
+                        "latent_heat": latent_heat,
+                        "schedule": schedule,
+                        "total_sensible": people_count * sensible_heat,
+                        "total_latent": people_count * latent_heat
+                    }
                     
-                    st.success(f"Added {people_count} people in {space_name}")
+                    # Add or update people load in session state
+                    if editing_people:
+                        st.session_state.internal_loads["people"][people_to_edit] = new_people_load
+                        del st.session_state.people_to_edit
+                    else:
+                        st.session_state.internal_loads["people"].append(new_people_load)
         
         with tab2:
-            # Display lighting loads
-            st.subheader("Lighting Loads")
+            st.subheader("Lighting")
             
             # Display existing lighting loads
-            if st.session_state.internal_loads.get('lighting'):
+            if st.session_state.internal_loads["lighting"]:
                 st.write("Existing Lighting Loads:")
-                lighting_data = []
                 
-                for i, lighting_load in enumerate(st.session_state.internal_loads['lighting']):
+                # Create a table of existing lighting loads
+                lighting_data = []
+                for i, load in enumerate(st.session_state.internal_loads["lighting"]):
                     lighting_data.append({
-                        "Space": lighting_load.get('space', 'Unknown'),
-                        "Power (W)": lighting_load.get('power', 0),
-                        "Usage Factor": lighting_load.get('usage_factor', 1.0)
+                        "ID": i + 1,
+                        "Zone": load.get("zone", "Main Zone"),
+                        "Type": load.get("type", "Fluorescent"),
+                        "Power (W)": load.get("power", 0),
+                        "Power Density (W/m²)": load.get("power_density", 0),
+                        "Area (m²)": load.get("area", 0),
+                        "Schedule": load.get("schedule", "8 AM - 6 PM")
                     })
-                    
-                    # Add delete button
-                    if st.button(f"Delete {lighting_load.get('space', 'Unknown')}", key=f"delete_lighting_{i}"):
-                        st.session_state.internal_loads['lighting'].pop(i)
-                        st.experimental_rerun()
                 
-                # Display as table
-                st.table(pd.DataFrame(lighting_data))
+                lighting_df = pd.DataFrame(lighting_data)
+                st.dataframe(lighting_df)
+                
+                # Add edit and delete buttons for lighting loads
+                col1, col2 = st.columns(2)
+                with col1:
+                    lighting_to_edit = st.selectbox(
+                        "Select lighting load to edit:",
+                        options=range(1, len(st.session_state.internal_loads["lighting"]) + 1),
+                        format_func=lambda x: f"Lighting Load #{x}: {st.session_state.internal_loads['lighting'][x-1].get('zone', 'Main Zone')}"
+                    )
+                
+                with col2:
+                    edit_col, delete_col = st.columns(2)
+                    with edit_col:
+                        if st.button("Edit Lighting Load", key="edit_lighting"):
+                            st.session_state.lighting_to_edit = lighting_to_edit - 1
+                    
+                    with delete_col:
+                        if st.button("Delete Lighting Load", key="delete_lighting"):
+                            st.session_state.internal_loads["lighting"].pop(lighting_to_edit - 1)
             
-            # Add new lighting load
+            # Add new lighting load form
             st.write("Add New Lighting Load:")
-            with st.form("add_lighting_form"):
-                space_name = st.text_input("Space Name", "Main Room", key="lighting_space")
-                power = st.number_input("Power (W)", min_value=0.0, value=500.0)
-                usage_factor = st.slider("Usage Factor", min_value=0.0, max_value=1.0, value=1.0, step=0.1)
-                
-                submitted = st.form_submit_button("Add Lighting Load")
-                
-                if submitted:
-                    # Add new lighting load to session state
-                    st.session_state.internal_loads['lighting'].append({
-                        'space': space_name,
-                        'power': power,
-                        'usage_factor': usage_factor
-                    })
+            
+            # Check if we're editing an existing lighting load
+            editing_lighting = "lighting_to_edit" in st.session_state
+            lighting_to_edit = st.session_state.get("lighting_to_edit", None)
+            
+            # Get the lighting load to edit if we're editing
+            lighting_load = None
+            if editing_lighting and lighting_to_edit is not None:
+                lighting_load = st.session_state.internal_loads["lighting"][lighting_to_edit]
+            
+            # Lighting load form
+            with st.form(key="lighting_form"):
+                # Zone name
+                zone_name = st.text_input(
+                    "Zone Name:",
+                    value=lighting_load.get("zone", "Main Zone") if lighting_load else "Main Zone",
+                    key="lighting_zone"
+                )
+                
+                # Lighting type
+                lighting_types = ["Incandescent", "Fluorescent", "LED", "Halogen", "Other"]
+                lighting_type = st.selectbox(
+                    "Lighting Type:",
+                    options=lighting_types,
+                    index=lighting_types.index(lighting_load.get("type", "Fluorescent")) if lighting_load and lighting_load.get("type") in lighting_types else 1
+                )
+                
+                # Input method selection
+                input_method = st.radio(
+                    "Input Method:",
+                    options=["Total Power", "Power Density"],
+                    index=0 if not lighting_load or "power" in lighting_load else 1
+                )
+                
+                if input_method == "Total Power":
+                    # Total power input
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        power = st.number_input(
+                            "Total Power (W):",
+                            min_value=0,
+                            max_value=100000,
+                            value=lighting_load.get("power", 0) if lighting_load else 0,
+                            step=10
+                        )
+                    
+                    with col2:
+                        area = st.number_input(
+                            "Area (m²):",
+                            min_value=0.0,
+                            max_value=10000.0,
+                            value=lighting_load.get("area", 0) if lighting_load else 0,
+                            step=1.0
+                        )
+                    
+                    # Calculate power density
+                    if area > 0:
+                        power_density = power / area
+                    else:
+                        power_density = 0
+                    
+                    st.write(f"Power Density: {power_density:.2f} W/m²")
+                else:
+                    # Power density input
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        power_density = st.number_input(
+                            "Power Density (W/m²):",
+                            min_value=0.0,
+                            max_value=100.0,
+                            value=lighting_load.get("power_density", 0) if lighting_load else 0,
+                            step=0.1
+                        )
+                    
+                    with col2:
+                        area = st.number_input(
+                            "Area (m²):",
+                            min_value=0.0,
+                            max_value=10000.0,
+                            value=lighting_load.get("area", 0) if lighting_load else 0,
+                            step=1.0
+                        )
                     
-                    st.success(f"Added {power} W lighting in {space_name}")
+                    # Calculate total power
+                    power = power_density * area
+                    st.write(f"Total Power: {power:.2f} W")
+                
+                # Schedule
+                schedule = st.text_input(
+                    "Schedule (e.g., 8 AM - 6 PM):",
+                    value=lighting_load.get("schedule", "8 AM - 6 PM") if lighting_load else "8 AM - 6 PM",
+                    key="lighting_schedule"
+                )
+                
+                # Submit button
+                submit_label = "Update Lighting Load" if editing_lighting else "Add Lighting Load"
+                submit = st.form_submit_button(submit_label)
+                
+                if submit:
+                    # Create or update lighting load
+                    new_lighting_load = {
+                        "zone": zone_name,
+                        "type": lighting_type,
+                        "power": power,
+                        "power_density": power_density,
+                        "area": area,
+                        "schedule": schedule
+                    }
+                    
+                    # Add or update lighting load in session state
+                    if editing_lighting:
+                        st.session_state.internal_loads["lighting"][lighting_to_edit] = new_lighting_load
+                        del st.session_state.lighting_to_edit
+                    else:
+                        st.session_state.internal_loads["lighting"].append(new_lighting_load)
         
         with tab3:
-            # Display equipment loads
-            st.subheader("Equipment Loads")
+            st.subheader("Equipment")
             
             # Display existing equipment loads
-            if st.session_state.internal_loads.get('equipment'):
+            if st.session_state.internal_loads["equipment"]:
                 st.write("Existing Equipment Loads:")
-                equipment_data = []
                 
-                for i, equipment_load in enumerate(st.session_state.internal_loads['equipment']):
+                # Create a table of existing equipment loads
+                equipment_data = []
+                for i, load in enumerate(st.session_state.internal_loads["equipment"]):
                     equipment_data.append({
-                        "Space": equipment_load.get('space', 'Unknown'),
-                        "Equipment": equipment_load.get('equipment', 'Unknown'),
-                        "Power (W)": equipment_load.get('power', 0),
-                        "Usage Factor": equipment_load.get('usage_factor', 1.0)
+                        "ID": i + 1,
+                        "Zone": load.get("zone", "Main Zone"),
+                        "Type": load.get("type", "Office Equipment"),
+                        "Sensible Heat (W)": load.get("sensible_heat", 0),
+                        "Latent Heat (W)": load.get("latent_heat", 0),
+                        "Schedule": load.get("schedule", "8 AM - 6 PM")
                     })
-                    
-                    # Add delete button
-                    if st.button(f"Delete {equipment_load.get('equipment', 'Unknown')}", key=f"delete_equipment_{i}"):
-                        st.session_state.internal_loads['equipment'].pop(i)
-                        st.experimental_rerun()
                 
-                # Display as table
-                st.table(pd.DataFrame(equipment_data))
+                equipment_df = pd.DataFrame(equipment_data)
+                st.dataframe(equipment_df)
+                
+                # Add edit and delete buttons for equipment loads
+                col1, col2 = st.columns(2)
+                with col1:
+                    equipment_to_edit = st.selectbox(
+                        "Select equipment load to edit:",
+                        options=range(1, len(st.session_state.internal_loads["equipment"]) + 1),
+                        format_func=lambda x: f"Equipment Load #{x}: {st.session_state.internal_loads['equipment'][x-1].get('zone', 'Main Zone')}"
+                    )
+                
+                with col2:
+                    edit_col, delete_col = st.columns(2)
+                    with edit_col:
+                        if st.button("Edit Equipment Load", key="edit_equipment"):
+                            st.session_state.equipment_to_edit = equipment_to_edit - 1
+                    
+                    with delete_col:
+                        if st.button("Delete Equipment Load", key="delete_equipment"):
+                            st.session_state.internal_loads["equipment"].pop(equipment_to_edit - 1)
             
-            # Add new equipment load
+            # Add new equipment load form
             st.write("Add New Equipment Load:")
-            with st.form("add_equipment_form"):
-                space_name = st.text_input("Space Name", "Main Room", key="equipment_space")
-                equipment_name = st.text_input("Equipment Name", "Computer")
-                power = st.number_input("Power (W)", min_value=0.0, value=200.0, key="equipment_power")
-                usage_factor = st.slider("Usage Factor", min_value=0.0, max_value=1.0, value=0.8, step=0.1, key="equipment_usage")
-                
-                submitted = st.form_submit_button("Add Equipment Load")
-                
-                if submitted:
-                    # Add new equipment load to session state
-                    st.session_state.internal_loads['equipment'].append({
-                        'space': space_name,
-                        'equipment': equipment_name,
-                        'power': power,
-                        'usage_factor': usage_factor
-                    })
-                    
-                    st.success(f"Added {equipment_name} ({power} W) in {space_name}")
-        
-        # Display summary of internal loads
-        st.subheader("Internal Loads Summary")
-        
-        # Calculate total people
-        total_people = 0
-        for people_load in st.session_state.internal_loads.get('people', []):
-            total_people += people_load.get('count', 0)
-        
-        # Calculate total lighting power
-        total_lighting_power = 0
-        for lighting_load in st.session_state.internal_loads.get('lighting', []):
-            total_lighting_power += lighting_load.get('power', 0) * lighting_load.get('usage_factor', 1.0)
-        
-        # Calculate total equipment power
-        total_equipment_power = 0
-        for equipment_load in st.session_state.internal_loads.get('equipment', []):
-            total_equipment_power += equipment_load.get('power', 0) * equipment_load.get('usage_factor', 1.0)
-        
-        # Display metrics
-        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'
-            )
+            # Check if we're editing an existing equipment load
+            editing_equipment = "equipment_to_edit" in st.session_state
+            equipment_to_edit = st.session_state.get("equipment_to_edit", None)
             
-            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()
+            # Get the equipment load to edit if we're editing
+            equipment_load = None
+            if editing_equipment and equipment_to_edit is not None:
+                equipment_load = st.session_state.internal_loads["equipment"][equipment_to_edit]
+            
+            # Equipment load form
+            with st.form(key="equipment_form"):
+                # Zone name
+                zone_name = st.text_input(
+                    "Zone Name:",
+                    value=equipment_load.get("zone", "Main Zone") if equipment_load else "Main Zone",
+                    key="equipment_zone"
+                )
+                
+                # Equipment type
+                equipment_types = ["Office Equipment", "Kitchen Equipment", "Medical Equipment", "Industrial Equipment", "Other"]
+                equipment_type = st.selectbox(
+                    "Equipment Type:",
+                    options=equipment_types,
+                    index=equipment_types.index(equipment_load.get("type", "Office Equipment")) if equipment_load and equipment_load.get("type") in equipment_types else 0
+                )
+                
+                # Heat gains
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    sensible_heat = st.number_input(
+                        "Sensible Heat (W):",
+                        min_value=0,
+                        max_value=100000,
+                        value=equipment_load.get("sensible_heat", 0) if equipment_load else 0,
+                        step=10
+                    )
+                
+                with col2:
+                    latent_heat = st.number_input(
+                        "Latent Heat (W):",
+                        min_value=0,
+                        max_value=100000,
+                        value=equipment_load.get("latent_heat", 0) if equipment_load else 0,
+                        step=10
+                    )
+                
+                # Schedule
+                schedule = st.text_input(
+                    "Schedule (e.g., 8 AM - 6 PM):",
+                    value=equipment_load.get("schedule", "8 AM - 6 PM") if equipment_load else "8 AM - 6 PM",
+                    key="equipment_schedule"
+                )
+                
+                # Submit button
+                submit_label = "Update Equipment Load" if editing_equipment else "Add Equipment Load"
+                submit = st.form_submit_button(submit_label)
+                
+                if submit:
+                    # Create or update equipment load
+                    new_equipment_load = {
+                        "zone": zone_name,
+                        "type": equipment_type,
+                        "sensible_heat": sensible_heat,
+                        "latent_heat": latent_heat,
+                        "schedule": schedule
+                    }
+                    
+                    # Add or update equipment load in session state
+                    if editing_equipment:
+                        st.session_state.internal_loads["equipment"][equipment_to_edit] = new_equipment_load
+                        del st.session_state.equipment_to_edit
+                    else:
+                        st.session_state.internal_loads["equipment"].append(new_equipment_load)
     
     def run_calculations(self):
-        """Run HVAC load calculations and update session state with results."""
-        # Check if required data is available
+        """Run HVAC load calculations."""
+        # Check if calculations should be run
+        if not hasattr(st.session_state, "run_calculations") or not st.session_state.run_calculations:
+            return
+        
+        # Reset the flag
+        st.session_state.run_calculations = False
+        
+        # Validate inputs before running calculations
         if not self.data_validation.validate_calculation_inputs(st.session_state):
-            st.error("Cannot run calculations. Please complete all required inputs first.")
+            st.error("Please fill in all required information before running calculations.")
             return
         
-        # Get building components and design conditions
-        building_components = st.session_state.components
+        # Get input data from session state
         building_info = st.session_state.building_info
+        components = st.session_state.components
         internal_loads = st.session_state.internal_loads
         
-        # Extract design conditions
-        design_conditions = building_info.get('design_conditions', {})
-        
-        # Create climate data dictionary for cooling load calculation
+        # Get climate data
         climate_data = {
-            'outdoor_db': design_conditions.get('summer_outdoor_db', 35),
-            'outdoor_wb': design_conditions.get('summer_outdoor_wb', 25),
-            'indoor_db': design_conditions.get('summer_indoor_db', 24),
-            'indoor_rh': design_conditions.get('summer_indoor_rh', 50),
-            'ground_temp': design_conditions.get('summer_ground_temp', 20),
-            'daily_range': design_conditions.get('summer_daily_range', 8),
-            'month': design_conditions.get('summer_design_month', 7),
-            'latitude': building_info.get('latitude', 40)
+            "location": building_info.get("location", ""),
+            "outdoor_temp": building_info.get("summer_outdoor_temp", 35.0),
+            "outdoor_humidity": building_info.get("summer_outdoor_humidity", 50.0),
+            "indoor_temp": building_info.get("summer_indoor_temp", 24.0),
+            "indoor_humidity": building_info.get("summer_indoor_humidity", 50.0),
+            "daily_range": building_info.get("daily_temp_range", 8.0),
+            "latitude": building_info.get("latitude", "40N"),
+            "month": building_info.get("design_month", 7),
+            "hour": building_info.get("design_hour", 15)
         }
         
-        # Create outdoor conditions dictionary for heating load calculation
-        outdoor_conditions = {
-            'db': design_conditions.get('winter_outdoor_db', 0),
-            'rh': design_conditions.get('winter_outdoor_rh', 80),
-            'ground_temp': design_conditions.get('winter_ground_temp', 10)
-        }
+        # Calculate cooling load
+        cooling_results = self.cooling_load.calculate_total_cooling_load(
+            walls=components.get("walls", []),
+            roofs=components.get("roofs", []),
+            floors=components.get("floors", []),
+            windows=components.get("windows", []),
+            doors=components.get("doors", []),
+            people=internal_loads.get("people", []),
+            lighting=internal_loads.get("lighting", []),
+            equipment=internal_loads.get("equipment", []),
+            infiltration_rate=building_info.get("infiltration_rate", 0.5),
+            floor_area=building_info.get("floor_area", 100.0),
+            climate_data=climate_data
+        )
         
-        # Create indoor conditions dictionary for heating load calculation
-        indoor_conditions = {
-            'db': design_conditions.get('winter_indoor_db', 22),
-            'rh': design_conditions.get('winter_indoor_rh', 40)
+        # Get heating climate data
+        heating_outdoor_conditions = {
+            "temperature": building_info.get("winter_outdoor_temp", -10.0),
+            "humidity": building_info.get("winter_outdoor_humidity", 80.0)
         }
         
-        # Run cooling load calculations with correct parameters
-        cooling_results = self.cooling_load.calculate_total_cooling_load(
-            building_components=building_components,
-            building_info=building_info,
-            climate_data=climate_data,
-            internal_loads=internal_loads,
-            hour=design_conditions.get('summer_design_hour', 15)
-        )
+        heating_indoor_conditions = {
+            "temperature": building_info.get("winter_indoor_temp", 21.0),
+            "humidity": building_info.get("winter_indoor_humidity", 30.0)
+        }
         
-        # Run heating load calculations with correct parameters
+        # Calculate heating load
         heating_results = self.heating_load.calculate_design_heating_load(
-            building_components=building_components,
-            outdoor_conditions=outdoor_conditions,
-            indoor_conditions=indoor_conditions,
-            internal_loads=internal_loads,
-            safety_factor=design_conditions.get('heating_safety_factor', 1.15)
+            walls=components.get("walls", []),
+            roofs=components.get("roofs", []),
+            floors=components.get("floors", []),
+            windows=components.get("windows", []),
+            doors=components.get("doors", []),
+            infiltration_rate=building_info.get("infiltration_rate", 0.5),
+            floor_area=building_info.get("floor_area", 100.0),
+            outdoor_conditions=heating_outdoor_conditions,
+            indoor_conditions=heating_indoor_conditions,
+            safety_factor=building_info.get("heating_safety_factor", 10.0)
         )
         
-        # Calculate load per area
-        floor_area = building_info.get('floor_area', 100)  # Default to 100 m² if not specified
-        
-        cooling_results['load_per_area'] = cooling_results['total_load'] * 1000 / floor_area  # Convert kW to W/m²
-        heating_results['load_per_area'] = heating_results['total_load'] * 1000 / floor_area  # Convert kW to W/m²
+        # Calculate psychrometric properties
+        psychrometric_results = self.psychrometrics.calculate_psychrometric_properties(
+            outdoor_temp=climate_data["outdoor_temp"],
+            outdoor_humidity=climate_data["outdoor_humidity"],
+            indoor_temp=climate_data["indoor_temp"],
+            indoor_humidity=climate_data["indoor_humidity"]
+        )
         
-        # Update session state with calculation results
+        # Store results in session state
         st.session_state.calculation_results = {
-            'cooling': cooling_results,
-            'heating': heating_results
+            "cooling_load": cooling_results,
+            "heating_load": heating_results,
+            "psychrometrics": psychrometric_results
         }
         
-        # Show success message
-        st.success("Calculations completed successfully!")
-        
         # Navigate to results page
-        self.navigate_to("Calculation Results")
+        st.session_state.page = "results"
+        st.success("Calculations completed successfully!")
 
 
+# Run the application
 if __name__ == "__main__":
-    # Create and run the HVAC Calculator application
     app = HVACCalculator()