""" Component selection interface for HVAC Load Calculator. This module provides the UI components for selecting building components. """ import streamlit as st import pandas as pd import numpy as np from typing import Dict, List, Any, Optional, Tuple import json import os import uuid # Import data models from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType from utils.component_library import ComponentLibrary from utils.u_value_calculator import UValueCalculator class ComponentSelection: """Class for component selection interface.""" 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 } # Create tabs for different component types tab1, tab2, tab3, tab4, tab5 = st.tabs([ "Walls", "Roofs", "Floors", "Windows", "Doors" ]) with tab1: self._display_wall_selection(session_state) with tab2: self._display_roof_selection(session_state) with tab3: self._display_floor_selection(session_state) with tab4: self._display_window_selection(session_state) with tab5: self._display_door_selection(session_state) def _display_wall_selection(self, session_state: Dict[str, Any]) -> None: """ Display wall selection interface. Args: session_state: Streamlit session state for storing form data """ st.subheader("Walls") # Display existing walls if session_state["components"]["walls"]: st.write("Existing Walls:") # Create a table of existing walls wall_data = [] for i, wall in enumerate(session_state["components"]["walls"]): wall_data.append({ "ID": i + 1, "Name": wall.name, "Type": wall.wall_type, "U-Value (W/m²K)": f"{wall.u_value:.3f}", "Area (m²)": f"{wall.area:.2f}", "Orientation": wall.orientation.value }) wall_df = pd.DataFrame(wall_data) st.dataframe(wall_df) # Add edit and delete buttons for each wall col1, col2 = st.columns(2) with col1: wall_to_edit = st.selectbox( "Select wall to edit:", options=range(1, len(session_state["components"]["walls"]) + 1), format_func=lambda x: f"Wall #{x}: {session_state['components']['walls'][x-1].name}" ) with col2: edit_col, delete_col = st.columns(2) with edit_col: if st.button("Edit Wall", key="edit_wall"): # Set the wall to edit in session state session_state["wall_to_edit"] = wall_to_edit - 1 with delete_col: if st.button("Delete Wall", key="delete_wall"): # Queue the delete action in pending_actions instead of doing it immediately session_state["pending_actions"]["delete_wall"] = wall_to_edit - 1 # Add new wall form st.write("Add New Wall:") # 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] # 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 def _display_roof_selection(self, session_state: Dict[str, Any]) -> None: """ Display roof selection interface. Args: session_state: Streamlit session state for storing form data """ st.subheader("Roofs") # Display existing roofs if session_state["components"]["roofs"]: st.write("Existing Roofs:") # Create a table of existing roofs roof_data = [] for i, roof in enumerate(session_state["components"]["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}", "Pitch (°)": f"{roof.pitch:.1f}" }) roof_df = pd.DataFrame(roof_data) st.dataframe(roof_df) # Add edit and delete buttons for each roof col1, col2 = st.columns(2) with col1: roof_to_edit = st.selectbox( "Select roof to edit:", options=range(1, len(session_state["components"]["roofs"]) + 1), format_func=lambda x: f"Roof #{x}: {session_state['components']['roofs'][x-1].name}" ) with col2: edit_col, delete_col = st.columns(2) with edit_col: if st.button("Edit Roof", key="edit_roof"): # Set the roof to edit in session state session_state["roof_to_edit"] = roof_to_edit - 1 with delete_col: if st.button("Delete Roof", key="delete_roof"): # Queue the delete action in pending_actions instead of doing it immediately session_state["pending_actions"]["delete_roof"] = roof_to_edit - 1 # Add new roof form st.write("Add New Roof:") # 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] # 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=preset_roof_names.index(roof.roof_type) + 1 if roof and roof.roof_type in preset_roof_names else 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 dimensions col1, col2 = st.columns(2) with col1: roof_length = st.number_input( "Roof Length (m):", min_value=0.1, max_value=100.0, value=20.0 if not roof else (roof.area / 10.0), # Assuming width of 10m if editing step=0.1 ) with col2: roof_width = st.number_input( "Roof Width (m):", min_value=0.1, max_value=100.0, value=10.0 if not roof else (roof.area / roof_length), step=0.1 ) # Calculate roof area roof_area = roof_length * roof_width st.write(f"Roof Area: {roof_area:.2f} m²") # Roof pitch roof_pitch = st.slider( "Roof Pitch (°):", min_value=0.0, max_value=60.0, value=roof.pitch if roof else 0.0, step=1.0 ) # Suspended ceiling has_suspended_ceiling = st.checkbox( "Has Suspended Ceiling", value=roof.has_suspended_ceiling if roof else False ) ceiling_plenum_height = 0.0 if has_suspended_ceiling: ceiling_plenum_height = st.number_input( "Ceiling Plenum Height (m):", min_value=0.1, max_value=5.0, value=roof.ceiling_plenum_height if roof and roof.has_suspended_ceiling else 0.5, step=0.1 ) # Submit button submit_label = "Update Roof" if editing_roof else "Add Roof" submit = st.form_submit_button(submit_label) if submit and not session_state["form_submitted"]["roof_form"]: # Set the form submission flag to prevent infinite loops session_state["form_submitted"]["roof_form"] = True # 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, roof_type="Custom", roof_group="Custom", pitch=roof_pitch, has_suspended_ceiling=has_suspended_ceiling, ceiling_plenum_height=ceiling_plenum_height ) 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, roof_type=selected_roof.roof_type, roof_group=selected_roof.roof_group, pitch=roof_pitch, has_suspended_ceiling=has_suspended_ceiling, ceiling_plenum_height=ceiling_plenum_height, 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: session_state["components"]["roofs"].append(new_roof) st.experimental_rerun() def _display_floor_selection(self, session_state: Dict[str, Any]) -> None: """ Display floor selection interface. Args: session_state: Streamlit session state for storing form data """ st.subheader("Floors") # Display existing floors if session_state["components"]["floors"]: st.write("Existing Floors:") # Create a table of existing floors floor_data = [] for i, floor in enumerate(session_state["components"]["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" }) floor_df = pd.DataFrame(floor_data) st.dataframe(floor_df) # Add edit and delete buttons for each floor col1, col2 = st.columns(2) with col1: floor_to_edit = st.selectbox( "Select floor to edit:", options=range(1, len(session_state["components"]["floors"]) + 1), format_func=lambda x: f"Floor #{x}: {session_state['components']['floors'][x-1].name}" ) with col2: edit_col, delete_col = st.columns(2) with edit_col: if st.button("Edit Floor", key="edit_floor"): # Set the floor to edit in session state session_state["floor_to_edit"] = floor_to_edit - 1 with delete_col: if st.button("Delete Floor", key="delete_floor"): # Queue the delete action in pending_actions instead of doing it immediately session_state["pending_actions"]["delete_floor"] = floor_to_edit - 1 # Add new floor form st.write("Add New Floor:") # 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] # 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=preset_floor_names.index(floor.floor_type) + 1 if floor and floor.floor_type in preset_floor_names else 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 dimensions col1, col2 = st.columns(2) with col1: floor_length = st.number_input( "Floor Length (m):", min_value=0.1, max_value=100.0, value=20.0 if not floor else (floor.area / 10.0), # Assuming width of 10m if editing step=0.1 ) with col2: floor_width = st.number_input( "Floor Width (m):", min_value=0.1, max_value=100.0, value=10.0 if not floor else (floor.area / floor_length), step=0.1 ) # Calculate floor area floor_area = floor_length * floor_width st.write(f"Floor Area: {floor_area:.2f} m²") # Ground contact is_ground_contact = st.checkbox( "Is in Contact with Ground", value=floor.is_ground_contact if floor else False ) perimeter_length = 0.0 if is_ground_contact: perimeter_length = st.number_input( "Perimeter Length (m):", min_value=0.1, max_value=1000.0, value=floor.perimeter_length if floor and floor.is_ground_contact else 2 * (floor_length + floor_width), step=0.1 ) # Submit button submit_label = "Update Floor" if editing_floor else "Add Floor" submit = st.form_submit_button(submit_label) if submit and not session_state["form_submitted"]["floor_form"]: # Set the form submission flag to prevent infinite loops session_state["form_submitted"]["floor_form"] = True # 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 def _display_window_selection(self, session_state: Dict[str, Any]) -> None: """ Display window selection interface. Args: session_state: Streamlit session state for storing form data """ st.subheader("Windows") # Display existing windows if session_state["components"]["windows"]: st.write("Existing Windows:") # Create a table of existing windows window_data = [] for i, window in enumerate(session_state["components"]["windows"]): window_data.append({ "ID": i + 1, "Name": window.name, "Type": window.window_type, "U-Value (W/m²K)": f"{window.u_value:.3f}", "SHGC": f"{window.shgc:.2f}", "Area (m²)": f"{window.area:.2f}", "Orientation": window.orientation.value }) window_df = pd.DataFrame(window_data) st.dataframe(window_df) # Add edit and delete buttons for each window col1, col2 = st.columns(2) with col1: window_to_edit = st.selectbox( "Select window to edit:", options=range(1, len(session_state["components"]["windows"]) + 1), format_func=lambda x: f"Window #{x}: {session_state['components']['windows'][x-1].name}" ) with col2: edit_col, delete_col = st.columns(2) with edit_col: if st.button("Edit Window", key="edit_window"): # Set the window to edit in session state session_state["window_to_edit"] = window_to_edit - 1 with delete_col: if st.button("Delete Window", key="delete_window"): # Queue the delete action in pending_actions instead of doing it immediately session_state["pending_actions"]["delete_window"] = window_to_edit - 1 # Add new window form st.write("Add New Window:") # 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] # 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=preset_window_names.index(window.window_type) + 1 if window and window.window_type in preset_window_names else 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 1.5, step=0.01 ) 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 ) vt = st.number_input( "Visible Transmittance (VT):", min_value=0.0, max_value=1.0, value=window.vt if window else 0.7, step=0.01 ) else: # Get properties from preset window selected_window = next((w for w in preset_windows if w.name == window_type), None) if selected_window: u_value = selected_window.u_value shgc = selected_window.shgc vt = selected_window.vt st.write(f"U-Value: {u_value:.3f} W/m²K") st.write(f"SHGC: {shgc:.2f}") st.write(f"VT: {vt:.2f}") # 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.5 if not window else (window.area / 2.0), # Assuming width of 2m if editing step=0.1 ) with col2: window_width = st.number_input( "Window Width (m):", min_value=0.1, max_value=10.0, value=2.0 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 and window.orientation in orientation_options else 0, format_func=lambda x: x.value ) # Shading has_shading = st.checkbox( "Has Shading", value=window.has_shading if window else False ) shading_type = None shading_coefficient = 1.0 if has_shading: shading_options = ["Internal", "External", "Between-glass"] shading_type = st.selectbox( "Shading Type:", options=shading_options, index=shading_options.index(window.shading_type) if window and window.shading_type in shading_options else 0 ) shading_coefficient = st.slider( "Shading Coefficient:", min_value=0.1, max_value=1.0, value=window.shading_coefficient if window and window.has_shading else 0.7, step=0.1 ) # Wall assignment if session_state["components"]["walls"]: wall_options = [wall.name for wall in session_state["components"]["walls"]] assigned_wall = st.selectbox( "Assign to Wall:", options=["None"] + wall_options, index=0 ) else: assigned_wall = "None" st.warning("No walls available for assignment. Please add walls first.") # Submit button submit_label = "Update Window" if editing_window else "Add Window" submit = st.form_submit_button(submit_label) if submit and not session_state["form_submitted"]["window_form"]: # Set the form submission flag to prevent infinite loops session_state["form_submitted"]["window_form"] = True # 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, vt=vt, window_type="Custom", glazing_layers=2, gas_fill="Air", low_e_coating=False, 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, vt=selected_window.vt, window_type=selected_window.window_type, glazing_layers=selected_window.glazing_layers, gas_fill=selected_window.gas_fill, low_e_coating=selected_window.low_e_coating, 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 # Assign window to wall if selected if assigned_wall != "None": # Find the wall by name for wall in session_state["components"]["walls"]: if wall.name == assigned_wall: # Add window ID to wall's windows list if new_window.id not in wall.windows: wall.windows.append(new_window.id) # Update wall's net area if wall.gross_area is None: wall.gross_area = wall.area wall.net_area = wall.gross_area - sum( w.area for w in session_state["components"]["windows"] if w.id in wall.windows ) - sum( d.area for d in session_state["components"]["doors"] if d.id in wall.doors ) wall.area = wall.net_area break def _display_door_selection(self, session_state: Dict[str, Any]) -> None: """ Display door selection interface. Args: session_state: Streamlit session state for storing form data """ st.subheader("Doors") # Display existing doors if session_state["components"]["doors"]: st.write("Existing Doors:") # Create a table of existing doors door_data = [] for i, door in enumerate(session_state["components"]["doors"]): door_data.append({ "ID": i + 1, "Name": door.name, "Type": door.door_type, "U-Value (W/m²K)": f"{door.u_value:.3f}", "Area (m²)": f"{door.area:.2f}", "Glazing %": f"{door.glazing_percentage:.0f}%", "Orientation": door.orientation.value }) door_df = pd.DataFrame(door_data) st.dataframe(door_df) # Add edit and delete buttons for each door col1, col2 = st.columns(2) with col1: door_to_edit = st.selectbox( "Select door to edit:", options=range(1, len(session_state["components"]["doors"]) + 1), format_func=lambda x: f"Door #{x}: {session_state['components']['doors'][x-1].name}" ) with col2: edit_col, delete_col = st.columns(2) with edit_col: if st.button("Edit Door", key="edit_door"): # Set the door to edit in session state session_state["door_to_edit"] = door_to_edit - 1 with delete_col: if st.button("Delete Door", key="delete_door"): # Queue the delete action in pending_actions instead of doing it immediately session_state["pending_actions"]["delete_door"] = door_to_edit - 1 # Add new door form st.write("Add New Door:") # 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] # 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=preset_door_names.index(door.door_type) + 1 if door and door.door_type in preset_door_names else 0 ) # U-value and glazing percentage 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 ) glazing_percentage = st.slider( "Glazing Percentage (%):", min_value=0, max_value=100, value=int(door.glazing_percentage) if door else 0, step=5 ) # Only show SHGC and VT if door has glazing if glazing_percentage > 0: shgc = st.number_input( "Solar Heat Gain Coefficient (SHGC):", min_value=0.0, max_value=1.0, value=door.shgc if door and door.shgc else 0.7, step=0.01 ) vt = st.number_input( "Visible Transmittance (VT):", min_value=0.0, max_value=1.0, value=door.vt if door and door.vt else 0.7, step=0.01 ) else: shgc = 0.0 vt = 0.0 else: # Get properties from preset door selected_door = next((d for d in preset_doors if d.name == door_type), None) if selected_door: u_value = selected_door.u_value glazing_percentage = selected_door.glazing_percentage shgc = selected_door.shgc vt = selected_door.vt st.write(f"U-Value: {u_value:.3f} W/m²K") st.write(f"Glazing: {glazing_percentage:.0f}%") if glazing_percentage > 0: st.write(f"SHGC: {shgc:.2f}") st.write(f"VT: {vt:.2f}") # 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.1 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 and door.orientation in orientation_options else 0, format_func=lambda x: x.value ) # Wall assignment if session_state["components"]["walls"]: wall_options = [wall.name for wall in session_state["components"]["walls"]] assigned_wall = st.selectbox( "Assign to Wall:", options=["None"] + wall_options, index=0 ) else: assigned_wall = "None" st.warning("No walls available for assignment. Please add walls first.") # Submit button submit_label = "Update Door" if editing_door else "Add Door" submit = st.form_submit_button(submit_label) if submit and not session_state["form_submitted"]["door_form"]: # Set the form submission flag to prevent infinite loops session_state["form_submitted"]["door_form"] = True # 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", glazing_percentage=glazing_percentage, shgc=shgc if glazing_percentage > 0 else 0.0, vt=vt if glazing_percentage > 0 else 0.0 ) 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, glazing_percentage=selected_door.glazing_percentage, shgc=selected_door.shgc, vt=selected_door.vt ) # 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 # Assign door to wall if selected if assigned_wall != "None": # Find the wall by name for wall in session_state["components"]["walls"]: if wall.name == assigned_wall: # Add door ID to wall's doors list if new_door.id not in wall.doors: wall.doors.append(new_door.id) # Update wall's net area if wall.gross_area is None: wall.gross_area = wall.area wall.net_area = wall.gross_area - sum( w.area for w in session_state["components"]["windows"] if w.id in wall.windows ) - sum( d.area for d in session_state["components"]["doors"] if d.id in wall.doors ) wall.area = wall.net_area break