Update app/component_selection.py

app/component_selection.py

@@ -12,6 +12,7 @@ import uuid
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Dict, List, Any, Optional
+import io
 
 # --- Enums ---
 class Orientation(Enum):
@@ -77,14 +78,17 @@ class BuildingComponent:
 class Wall(BuildingComponent):
     wall_type: str = "Brick"
     wall_group: str = "B"
+    shading_percentage: float = 0.0  # New attribute for shading percentage
 
     def __post_init__(self):
         super().__post_init__()
         self.component_type = ComponentType.WALL
+        if not 0 <= self.shading_percentage <= 100:
+            raise ValueError("Shading percentage must be between 0 and 100")
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
-        base_dict.update({"wall_type": self.wall_type, "wall_group": self.wall_group})
+        base_dict.update({"wall_type": self.wall_type, "wall_group": self.wall_group, "shading_percentage": self.shading_percentage})
         return base_dict
 
 @dataclass
@@ -223,36 +227,28 @@ class ReferenceData:
                 "mat_005": {"name": "Wood", "conductivity": 0.15}
             },
             "wall_types": {
-                "preset_wall_001": {
-                    "id": "preset_wall_001", "name": "Standard Brick Wall", "component_type": "Wall",
-                    "u_value": 0.5, "area": 0.0, "orientation": "North", "wall_type": "Brick", "wall_group": "B"
-                }
+                "preset_wall_001": {"id": "preset_wall_001", "name": "Brick Wall (Single Layer)", "component_type": "Wall", "u_value": 2.0, "area": 0.0, "orientation": "North", "wall_type": "Brick", "wall_group": "B", "shading_percentage": 0.0},
+                "preset_wall_002": {"id": "preset_wall_002", "name": "Insulated Brick Wall", "component_type": "Wall", "u_value": 0.5, "area": 0.0, "orientation": "North", "wall_type": "Insulated Brick", "wall_group": "B", "shading_percentage": 0.0},
+                "preset_wall_003": {"id": "preset_wall_003", "name": "Concrete Block Wall", "component_type": "Wall", "u_value": 1.8, "area": 0.0, "orientation": "North", "wall_type": "Concrete Block", "wall_group": "C", "shading_percentage": 0.0},
+                "preset_wall_004": {"id": "preset_wall_004", "name": "Insulated Concrete Wall", "component_type": "Wall", "u_value": 0.4, "area": 0.0, "orientation": "North", "wall_type": "Insulated Concrete", "wall_group": "C", "shading_percentage": 0.0},
+                "preset_wall_005": {"id": "preset_wall_005", "name": "Timber Frame Wall", "component_type": "Wall", "u_value": 0.3, "area": 0.0, "orientation": "North", "wall_type": "Timber Frame", "wall_group": "D", "shading_percentage": 0.0},
+                "preset_wall_006": {"id": "preset_wall_006", "name": "Cavity Wall (Brick + Insulation)", "component_type": "Wall", "u_value": 0.6, "area": 0.0, "orientation": "North", "wall_type": "Cavity Brick", "wall_group": "B", "shading_percentage": 0.0},
+                "preset_wall_007": {"id": "preset_wall_007", "name": "Lightweight Panel Wall", "component_type": "Wall", "u_value": 1.0, "area": 0.0, "orientation": "North", "wall_type": "Lightweight Panel", "wall_group": "E", "shading_percentage": 0.0},
+                "preset_wall_008": {"id": "preset_wall_008", "name": "Reinforced Concrete Wall", "component_type": "Wall", "u_value": 1.5, "area": 0.0, "orientation": "North", "wall_type": "Reinforced Concrete", "wall_group": "C", "shading_percentage": 0.0},
+                "preset_wall_009": {"id": "preset_wall_009", "name": "SIP Wall (Structural Insulated Panel)", "component_type": "Wall", "u_value": 0.25, "area": 0.0, "orientation": "North", "wall_type": "SIP", "wall_group": "F", "shading_percentage": 0.0},
+                "preset_wall_010": {"id": "preset_wall_010", "name": "Custom Wall", "component_type": "Wall", "u_value": 0.5, "area": 0.0, "orientation": "North", "wall_type": "Custom", "wall_group": "G", "shading_percentage": 0.0}
             },
             "roof_types": {
-                "preset_roof_001": {
-                    "id": "preset_roof_001", "name": "Concrete Roof", "component_type": "Roof",
-                    "u_value": 0.3, "area": 0.0, "orientation": "Horizontal", "roof_type": "Concrete", "roof_group": "C"
-                }
+                "preset_roof_001": {"id": "preset_roof_001", "name": "Concrete Roof", "component_type": "Roof", "u_value": 0.3, "area": 0.0, "orientation": "Horizontal", "roof_type": "Concrete", "roof_group": "C"}
             },
             "floor_types": {
-                "preset_floor_001": {
-                    "id": "preset_floor_001", "name": "Concrete Floor", "component_type": "Floor",
-                    "u_value": 0.4, "area": 0.0, "orientation": "Horizontal", "floor_type": "Concrete"
-                }
+                "preset_floor_001": {"id": "preset_floor_001", "name": "Concrete Floor", "component_type": "Floor", "u_value": 0.4, "area": 0.0, "orientation": "Horizontal", "floor_type": "Concrete"}
             },
             "window_types": {
-                "preset_window_001": {
-                    "id": "preset_window_001", "name": "Double Glazed Window", "component_type": "Window",
-                    "u_value": 2.8, "area": 0.0, "orientation": "North", "shgc": 0.7, "vt": 0.8,
-                    "window_type": "Double Glazed", "glazing_layers": 2, "gas_fill": "Air", "low_e_coating": False,
-                    "shading_device_id": "preset_none"
-                }
+                "preset_window_001": {"id": "preset_window_001", "name": "Double Glazed Window", "component_type": "Window", "u_value": 2.8, "area": 0.0, "orientation": "North", "shgc": 0.7, "vt": 0.8, "window_type": "Double Glazed", "glazing_layers": 2, "gas_fill": "Air", "low_e_coating": False, "shading_device_id": "preset_none"}
             },
             "door_types": {
-                "preset_door_001": {
-                    "id": "preset_door_001", "name": "Solid Wood Door", "component_type": "Door",
-                    "u_value": 2.0, "area": 0.0, "orientation": "North", "door_type": "Solid Wood"
-                }
+                "preset_door_001": {"id": "preset_door_001", "name": "Solid Wood Door", "component_type": "Door", "u_value": 2.0, "area": 0.0, "orientation": "North", "door_type": "Solid Wood"}
             }
         }
 
@@ -366,7 +362,10 @@ class ComponentSelectionInterface:
         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)
+            if component_type == ComponentType.WALL:
+                self._display_add_wall_form(session_state)
+            else:
+                self._display_add_component_form(session_state, component_type)
         
         components = session_state.components.get(type_name + 's', [])
         if components:
@@ -375,11 +374,87 @@ class ComponentSelectionInterface:
         else:
             st.info(f"No {type_name} components defined yet.")
 
+    def _display_add_wall_form(self, session_state: Any) -> None:
+        # Wall-specific form with manual entry and Excel upload options
+        st.write("Add walls manually or upload an Excel file.")
+        wall_method = st.radio("Add Wall Method", ["Manual Entry", "Excel Upload"])
+        
+        if wall_method == "Manual Entry":
+            with st.form("add_wall_form"):
+                col1, col2 = st.columns(2)
+                with col1:
+                    name = st.text_input("Name", "New Wall")
+                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation], index=0)
+                with col2:
+                    preset_walls = self.component_library.get_preset_components_by_type(ComponentType.WALL)
+                    wall_options = {comp.name: comp for comp in preset_walls}
+                    selected_wall = st.selectbox("Select Wall Type", options=list(wall_options.keys()))
+                    component = wall_options[selected_wall]
+                    if selected_wall == "Custom Wall":
+                        u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, max_value=9.0, value=0.5, step=0.01)
+                    else:
+                        u_value = st.number_input("U-Value (W/m²·K)", value=component.u_value, disabled=True)
+                    shading_percentage = st.number_input("Shading Percentage (%)", min_value=0.0, max_value=100.0, value=0.0, step=5.0)
+                
+                submitted = st.form_submit_button("Add Wall")
+                if submitted:
+                    if not name:
+                        st.error("Wall name is required!")
+                    elif area <= 0:
+                        st.error("Wall area must be greater than zero!")
+                    elif u_value <= 0 or u_value >= 9:
+                        st.error("Wall U-value must be between 0 and 9!")
+                    else:
+                        new_wall = Wall(
+                            id=str(uuid.uuid4()), name=name, u_value=u_value, area=area,
+                            orientation=Orientation(orientation), wall_type=component.wall_type,
+                            wall_group=component.wall_group, shading_percentage=shading_percentage
+                        )
+                        self.component_library.add_component(new_wall)
+                        session_state.components['walls'].append(new_wall)
+                        st.success(f"Added {new_wall.name}")
+                        st.rerun()
+        
+        elif wall_method == "Excel Upload":
+            st.info("Upload an Excel file with columns: Name, Area (m²), U-Value (W/m²·K), Orientation, Wall Type, Wall Group, Shading (%)")
+            uploaded_file = st.file_uploader("Upload Walls Excel", type=["xlsx"], key="wall_upload")
+            if uploaded_file and st.button("Process Excel"):
+                df = pd.read_excel(uploaded_file)
+                required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Shading (%)"]
+                if not all(col in df.columns for col in required_cols):
+                    st.error("Excel file must contain all required columns!")
+                else:
+                    for _, row in df.iterrows():
+                        try:
+                            new_wall = Wall(
+                                id=str(uuid.uuid4()), name=row["Name"], u_value=row["U-Value (W/m²·K)"],
+                                area=row["Area (m²)"], orientation=Orientation(row["Orientation"]),
+                                wall_type=row["Wall Type"], wall_group=row["Wall Group"],
+                                shading_percentage=row["Shading (%)"]
+                            )
+                            self.component_library.add_component(new_wall)
+                            session_state.components['walls'].append(new_wall)
+                        except ValueError as e:
+                            st.error(f"Error in row: {row['Name']} - {str(e)}")
+                    st.success("Walls uploaded successfully!")
+                    st.rerun()
+            # Provide a downloadable template
+            template_df = pd.DataFrame(columns=required_cols)
+            buffer = io.BytesIO()
+            with pd.ExcelWriter(buffer, engine='xlsxwriter') as writer:
+                template_df.to_excel(writer, index=False)
+            st.download_button(
+                label="Download Wall Template",
+                data=buffer.getvalue(),
+                file_name="wall_template.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            )
+
     def _display_add_component_form(self, session_state: Any, component_type: ComponentType) -> None:
         type_name = component_type.value.lower()
         preset_components = self.component_library.get_preset_components_by_type(component_type)
         
-        # Add a flag to prevent infinite rerun
         if f"add_{type_name}_submitted" not in session_state:
             session_state[f"add_{type_name}_submitted"] = False
         
@@ -400,10 +475,7 @@ class ComponentSelectionInterface:
                     selected_preset = st.selectbox(f"Select Preset {type_name.capitalize()}", options=list(preset_options.keys()))
                     component = self.component_library.get_component(preset_options[selected_preset])
                     u_value = st.number_input("U-Value (W/m²·K)", value=component.u_value, disabled=True)
-                    if component_type == ComponentType.WALL:
-                        st.text_input("Wall Type", value=component.wall_type, disabled=True)
-                        st.text_input("Wall Group", value=component.wall_group, disabled=True)
-                    elif component_type == ComponentType.ROOF:
+                    if component_type == ComponentType.ROOF:
                         st.text_input("Roof Type", value=component.roof_type, disabled=True)
                         st.text_input("Roof Group", value=component.roof_group, disabled=True)
                     elif component_type == ComponentType.FLOOR:
@@ -416,10 +488,7 @@ class ComponentSelectionInterface:
                         st.text_input("Door Type", value=component.door_type, disabled=True)
                 else:
                     u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=0.5, step=0.01)
-                    if component_type == ComponentType.WALL:
-                        wall_type = st.text_input("Wall Type", "Custom")
-                        wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], index=1)
-                    elif component_type == ComponentType.ROOF:
+                    if component_type == ComponentType.ROOF:
                         roof_type = st.text_input("Roof Type", "Custom")
                         roof_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], index=2)
                     elif component_type == ComponentType.FLOOR:
@@ -433,10 +502,6 @@ class ComponentSelectionInterface:
                         low_e_coating = st.checkbox("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=0)
-                        coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, value=100.0, 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", "Custom")
             
@@ -453,21 +518,15 @@ class ComponentSelectionInterface:
                         if selection_method == "Select from Presets" and preset_components:
                             component_id = preset_options[selected_preset]
                             component = self.component_library.get_component(component_id)
-                            # Create a copy of __dict__ and remove overlapping keys
                             preset_attrs = component.__dict__.copy()
-                            for key in ['id', 'name', 'area', 'orientation']:  # Remove keys we explicitly provide
+                            for key in ['id', 'name', 'area', 'orientation']:
                                 preset_attrs.pop(key, None)
                             new_component = component.__class__(
                                 id=str(uuid.uuid4()), name=name, area=area, 
                                 orientation=Orientation(orientation), **preset_attrs
                             )
                         else:
-                            if component_type == ComponentType.WALL:
-                                new_component = Wall(
-                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                    orientation=Orientation(orientation), wall_type=wall_type, wall_group=wall_group
-                                )
-                            elif component_type == ComponentType.ROOF:
+                            if component_type == ComponentType.ROOF:
                                 new_component = Roof(
                                     id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
                                     orientation=Orientation(orientation), roof_type=roof_type, roof_group=roof_group
@@ -478,7 +537,7 @@ class ComponentSelectionInterface:
                                     orientation=Orientation(orientation), floor_type=floor_type
                                 )
                             elif component_type == ComponentType.WINDOW:
-                                new_component = Wall(
+                                new_component = Window(
                                     id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
                                     orientation=Orientation(orientation), shgc=shgc, vt=vt, window_type=window_type,
                                     glazing_layers=glazing_layers, gas_fill=gas_fill, low_e_coating=low_e_coating,
@@ -492,12 +551,11 @@ class ComponentSelectionInterface:
                         self.component_library.add_component(new_component)
                         session_state.components[type_name + 's'].append(new_component)
                         st.success(f"Added {new_component.name}")
-                        session_state[f"add_{type_name}_submitted"] = True  # Set flag to prevent rerun loop
+                        session_state[f"add_{type_name}_submitted"] = True
                         st.rerun()
                     except ValueError as e:
                         st.error(f"Error: {str(e)}")
         
-        # Reset the flag after rerun to allow new submissions
         if session_state[f"add_{type_name}_submitted"]:
             session_state[f"add_{type_name}_submitted"] = False
 
@@ -507,7 +565,7 @@ class ComponentSelectionInterface:
         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})
+                row.update({"Wall Type": comp.wall_type, "Wall Group": comp.wall_group, "Shading (%)": comp.shading_percentage})
             elif component_type == ComponentType.ROOF:
                 row.update({"Roof Type": comp.roof_type, "Roof Group": comp.roof_group})
             elif component_type == ComponentType.FLOOR:
@@ -521,25 +579,49 @@ class ComponentSelectionInterface:
         
         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 component_type == ComponentType.WALL:
+            # Custom table rendering for walls with delete button next to each row
+            st.write("Walls Table:")
+            for i, row in df.iterrows():
+                cols = st.columns([2, 1, 1, 1, 1, 1, 1, 1])
+                cols[0].write(row["Name"])
+                cols[1].write(row["Area (m²)"])
+                cols[2].write(row["U-Value (W/m²·K)"])
+                cols[3].write(row["Orientation"])
+                cols[4].write(row["Wall Type"])
+                cols[5].write(row["Wall Group"])
+                cols[6].write(row["Shading (%)"])
+                if cols[7].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"]]
+                        session_state.components['walls'] = [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.")
+            # Download walls table as CSV
+            csv = df[display_cols].to_csv(index=False)
+            st.download_button(label="Download Walls Table", data=csv, file_name="walls_table.csv", mime="text/csv")
+        else:
+            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:
+        if f"edit_{type_name}" in session_state and component_type != ComponentType.WALL:
             self._display_edit_component_form(session_state, component_type, session_state[f"edit_{type_name}"])
             del session_state[f"edit_{type_name}"]
 
@@ -563,13 +645,9 @@ class ComponentSelectionInterface:
             
             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:
-                    wall_type = st.text_input("Roof Type", value=component.roof_type)
-                    wall_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], 
+                if 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)
@@ -584,11 +662,6 @@ class ComponentSelectionInterface:
                     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)
             
@@ -605,10 +678,7 @@ class ComponentSelectionInterface:
                     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:
+                    if component_type == ComponentType.ROOF:
                         component.roof_type = roof_type
                         component.roof_group = roof_group
                     elif component_type == ComponentType.FLOOR:
@@ -670,10 +740,9 @@ class ComponentSelectionInterface:
                     self.component_library.update_component(component.id, component)
                     session_state.material_layers = []
                     st.success(f"U-Value set to {u_value:.3f} W/m²·K for {component.name}")
-                    session_state.u_value_applied = True  # Set flag to prevent rerun loop
+                    session_state.u_value_applied = True
                     st.rerun()
         
-        # Reset the flag after rerun to allow new calculations
         if session_state.u_value_applied:
             session_state.u_value_applied = False