Update app/component_selection.py

app/component_selection.py

@@ -331,7 +331,49 @@ class ComponentSelectionInterface:
         self.shading_system = shading_system
         self.reference_data = reference_data
 
-    # ... other methods like display_component_selection, _display_component_tab, etc. ...
+    def display_component_selection(self, session_state: Any) -> None:
+        st.title("Building Components")
+        
+        if 'components' not in session_state:
+            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
+        
+        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
+        
+        with tabs[0]:
+            self._display_component_tab(session_state, ComponentType.WALL)
+        with tabs[1]:
+            self._display_component_tab(session_state, ComponentType.ROOF)
+        with tabs[2]:
+            self._display_component_tab(session_state, ComponentType.FLOOR)
+        with tabs[3]:
+            self._display_component_tab(session_state, ComponentType.WINDOW)
+        with tabs[4]:
+            self._display_component_tab(session_state, ComponentType.DOOR)
+        with tabs[5]:
+            self._display_u_value_calculator_tab(session_state)
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Save Components"):
+                self._save_components(session_state)
+        with col2:
+            uploaded_file = st.file_uploader("Load Components", type=["json"])
+            if uploaded_file and st.button("Load Uploaded Components"):
+                self._load_components(session_state, uploaded_file)
+
+    def _display_component_tab(self, session_state: Any, component_type: ComponentType) -> None:
+        type_name = component_type.value.lower()
+        st.subheader(f"{type_name.capitalize()} Components")
+        
+        with st.expander(f"Add {type_name.capitalize()}", expanded=False):
+            self._display_add_component_form(session_state, component_type)
+        
+        components = session_state.components.get(type_name + 's', [])
+        if components:
+            st.subheader(f"Existing {type_name.capitalize()} Components")
+            self._display_components_table(session_state, component_type, components)
+        else:
+            st.info(f"No {type_name} components defined yet.")
 
     def _display_add_component_form(self, session_state: Any, component_type: ComponentType) -> None:
         type_name = component_type.value.lower()
@@ -456,7 +498,131 @@ class ComponentSelectionInterface:
         if session_state[f"add_{type_name}_submitted"]:
             session_state[f"add_{type_name}_submitted"] = False
 
-    # ... other methods ...
+    def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[BuildingComponent]) -> None:
+        type_name = component_type.value.lower()
+        data = []
+        for comp in components:
+            row = {"Name": comp.name, "Area (m²)": comp.area, "U-Value (W/m²·K)": comp.u_value, "Orientation": comp.orientation.value, "ID": comp.id}
+            if component_type == ComponentType.WALL:
+                row.update({"Wall Type": comp.wall_type, "Wall Group": comp.wall_group})
+            elif component_type == ComponentType.ROOF:
+                row.update({"Roof Type": comp.roof_type, "Roof Group": comp.roof_group})
+            elif component_type == ComponentType.FLOOR:
+                row.update({"Floor Type": comp.floor_type})
+            elif component_type == ComponentType.WINDOW:
+                row.update({"SHGC": comp.shgc, "VT": comp.vt, "Window Type": comp.window_type,
+                           "Effective SHGC": self.shading_system.calculate_effective_shgc(comp.shgc, comp.shading_device_id)})
+            elif component_type == ComponentType.DOOR:
+                row.update({"Door Type": comp.door_type})
+            data.append(row)
+        
+        df = pd.DataFrame(data)
+        display_cols = [col for col in df.columns if col != "ID"]
+        st.dataframe(df[display_cols], use_container_width=True)
+        
+        for i, row in df.iterrows():
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button("Edit", key=f"edit_{row['ID']}"):
+                    session_state[f"edit_{type_name}"] = row["ID"]
+                    st.rerun()
+            with col2:
+                if st.button("Delete", key=f"delete_{row['ID']}"):
+                    if not row["ID"].startswith("preset_"):
+                        self.component_library.remove_component(row["ID"])
+                        session_state.components[type_name + 's'] = [c for c in components if c.id != row["ID"]]
+                        st.success(f"Deleted {row['Name']}")
+                        st.rerun()
+                    else:
+                        st.warning("Cannot delete preset components.")
+        
+        if f"edit_{type_name}" in session_state:
+            self._display_edit_component_form(session_state, component_type, session_state[f"edit_{type_name}"])
+            del session_state[f"edit_{type_name}"]
+
+    def _display_edit_component_form(self, session_state: Any, component_type: ComponentType, component_id: str) -> None:
+        type_name = component_type.value.lower()
+        component = next((c for c in session_state.components[type_name + 's'] if c.id == component_id), None)
+        if not component:
+            st.error("Component not found.")
+            return
+        
+        with st.form(f"edit_{component_id}_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", value=component.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=component.area, step=0.1)
+                if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation], 
+                                             index=[o.value for o in Orientation].index(component.orientation.value))
+                else:
+                    orientation = Orientation.HORIZONTAL.value
+            
+            with col2:
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=component.u_value, step=0.01)
+                if component_type == ComponentType.WALL:
+                    wall_type = st.text_input("Wall Type", value=component.wall_type)
+                    wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], 
+                                            index=["A", "B", "C", "D", "E", "F", "G", "H"].index(component.wall_group))
+                elif component_type == ComponentType.ROOF:
+                    roof_type = st.text_input("Roof Type", value=component.roof_type)
+                    roof_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], 
+                                            index=["A", "B", "C", "D", "E", "F", "G"].index(component.roof_group))
+                elif component_type == ComponentType.FLOOR:
+                    floor_type = st.text_input("Floor Type", value=component.floor_type)
+                elif component_type == ComponentType.WINDOW:
+                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=component.shgc, step=0.01)
+                    vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=component.vt, step=0.01)
+                    window_type = st.text_input("Window Type", value=component.window_type)
+                    glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=[1, 2, 3].index(component.glazing_layers))
+                    gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], 
+                                          index=["Air", "Argon", "Krypton"].index(component.gas_fill))
+                    low_e_coating = st.checkbox("Low-E Coating", value=component.low_e_coating)
+                    shading_options = {d.name: d.id for d in self.shading_system.shading_devices.values()}
+                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), 
+                                                index=list(shading_options.keys()).index(self.shading_system.get_device(component.shading_device_id).name))
+                    coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, 
+                                             value=self.shading_system.get_device(component.shading_device_id).coverage_percentage, step=5.0)
+                    device = self.shading_system.get_device(shading_options[shading_device])
+                    device.coverage_percentage = coverage
+                    st.write(f"Effective SHGC: {self.shading_system.calculate_effective_shgc(shgc, shading_options[shading_device]):.2f}")
+                elif component_type == ComponentType.DOOR:
+                    door_type = st.text_input("Door Type", value=component.door_type)
+            
+            submitted = st.form_submit_button("Update Component")
+            if submitted:
+                if not name:
+                    st.error(f"{type_name.capitalize()} name is required!")
+                elif area <= 0:
+                    st.error(f"{type_name.capitalize()} area must be greater than zero!")
+                elif u_value <= 0:
+                    st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
+                else:
+                    component.name = name
+                    component.area = area
+                    component.u_value = u_value
+                    component.orientation = Orientation(orientation)
+                    if component_type == ComponentType.WALL:
+                        component.wall_type = wall_type
+                        component.wall_group = wall_group
+                    elif component_type == ComponentType.ROOF:
+                        component.roof_type = roof_type
+                        component.roof_group = roof_group
+                    elif component_type == ComponentType.FLOOR:
+                        component.floor_type = floor_type
+                    elif component_type == ComponentType.WINDOW:
+                        component.shgc = shgc
+                        component.vt = vt
+                        component.window_type = window_type
+                        component.glazing_layers = glazing_layers
+                        component.gas_fill = gas_fill
+                        component.low_e_coating = low_e_coating
+                        component.shading_device_id = shading_options[shading_device]
+                    elif component_type == ComponentType.DOOR:
+                        component.door_type = door_type
+                    self.component_library.update_component(component_id, component)
+                    st.success(f"Updated {name}")
+                    st.rerun()
 
     def _display_u_value_calculator_tab(self, session_state: Any) -> None:
         st.subheader("U-Value Calculator")
@@ -546,41 +712,6 @@ class ComponentSelectionInterface:
                 session_state.material_layers.pop()
                 st.rerun()
 
-    # ... other methods like _display_components_table, _save_components, etc. ...
-            
-        with st.form("material_layer_form"):
-            col1, col2 = st.columns(2)
-            with col1:
-                material_selection = st.radio("Material Selection", ["Select from Presets", "Custom Material"])
-                if material_selection == "Select from Presets":
-                    preset_materials = self.u_value_calculator.get_preset_materials()
-                    material_options = {m["name"]: m for m in preset_materials}
-                    material_name = st.selectbox("Material", options=list(material_options.keys()))
-                    conductivity = material_options[material_name]["conductivity"]
-                    st.number_input("Conductivity (W/m·K)", value=conductivity, disabled=True)
-                else:
-                    material_name = st.text_input("Material Name", "Custom Material")
-                    conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=1.0, step=0.01)
-            
-            with col2:
-                thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
-                if conductivity > 0:
-                    r_value = thickness / 1000 / conductivity
-                    st.metric("Layer R-Value", f"{r_value:.3f} m²·K/W")
-            
-            submitted = st.form_submit_button("Add Layer")
-            if submitted:
-                if not material_name:
-                    st.error("Material name is required!")
-                elif thickness <= 0:
-                    st.error("Thickness must be greater than zero!")
-                elif conductivity <= 0:
-                    st.error("Conductivity must be greater than zero!")
-                else:
-                    session_state.material_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
-                    st.success(f"Added layer: {material_name}")
-                    st.rerun()
-
     def _save_components(self, session_state: Any) -> None:
         components_dict = {
             "walls": [c.to_dict() for c in session_state.components["walls"]],