Upload component_selection.py

app/component_selection.py

@@ -1,9 +1,11 @@
 """
-HVAC Component Selection Module
+Enhanced HVAC Component Selection Module
 Provides UI for selecting building components in the HVAC Load Calculator.
 All dependencies are included within this file for standalone operation.
-Updated 2025-04-28: Added perimeter field to Floor class for F-factor calculations.
-Updated 2025-04-29: Fixed Floors table headings, added insulated field for dynamic F-factor.
+Updated 2025-04-28: Added surface color selection, expanded component types, and skylight support.
+Updated 2025-05-02: Added crack dimensions for walls/doors, drapery properties for windows/skylights, and roof height per enhancement plan.
+
+Author: Dr Majed Abuseif
 """
 
 import streamlit as st
@@ -35,6 +37,37 @@ class ComponentType(Enum):
     FLOOR = "Floor"
     WINDOW = "Window"
     DOOR = "Door"
+    SKYLIGHT = "Skylight"
+
+class SurfaceColor(Enum):
+    DARK = "Dark"
+    MEDIUM = "Medium"
+    LIGHT = "Light"
+
+class GlazingType(Enum):
+    SINGLE_CLEAR = "Single Clear"
+    SINGLE_TINTED = "Single Tinted"
+    DOUBLE_CLEAR = "Double Clear"
+    DOUBLE_TINTED = "Double Tinted"
+    LOW_E = "Low-E"
+    REFLECTIVE = "Reflective"
+
+class FrameType(Enum):
+    ALUMINUM = "Aluminum without Thermal Break"
+    ALUMINUM_THERMAL_BREAK = "Aluminum with Thermal Break"
+    VINYL = "Vinyl/Fiberglass"
+    WOOD = "Wood/Vinyl-Clad Wood"
+    INSULATED = "Insulated"
+
+class DraperyOpenness(Enum):
+    CLOSED = "Closed"
+    SEMI_OPEN = "Semi-Open"
+    OPEN = "Open"
+
+class DraperyColor(Enum):
+    LIGHT = "Light"
+    MEDIUM = "Medium"
+    DARK = "Dark"
 
 # --- Data Models ---
 @dataclass
@@ -71,6 +104,9 @@ class Wall(BuildingComponent):
     absorptivity: float = 0.6
     shading_coefficient: float = 1.0
     infiltration_rate_cfm: float = 0.0
+    surface_color: str = "Dark"  # Added surface color
+    crack_length: float = 0.0  # Added for infiltration (m)
+    crack_width: float = 0.0   # Added for infiltration (m)
 
     def __post_init__(self):
         super().__post_init__()
@@ -81,16 +117,25 @@ class Wall(BuildingComponent):
             raise ValueError("Shading coefficient must be between 0 and 1")
         if self.infiltration_rate_cfm < 0:
             raise ValueError("Infiltration rate cannot be negative")
+        if not 0 <= self.crack_length <= 100:
+            raise ValueError("Crack length must be between 0 and 100 meters")
+        if not 0 <= self.crack_width <= 0.1:
+            raise ValueError("Crack width must be between 0 and 0.1 meters")
         VALID_WALL_GROUPS = {"A", "B", "C", "D", "E", "F", "G", "H"}
         if self.wall_group not in VALID_WALL_GROUPS:
             st.warning(f"Invalid wall_group '{self.wall_group}' for wall '{self.name}'. Defaulting to 'A'.")
             self.wall_group = "A"
+        VALID_SURFACE_COLORS = {"Dark", "Medium", "Light"}
+        if self.surface_color not in VALID_SURFACE_COLORS:
+            st.warning(f"Invalid surface_color '{self.surface_color}' for wall '{self.name}'. Defaulting to 'Dark'.")
+            self.surface_color = "Dark"
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
         base_dict.update({
             "wall_type": self.wall_type, "wall_group": self.wall_group, "absorptivity": self.absorptivity,
-            "shading_coefficient": self.shading_coefficient, "infiltration_rate_cfm": self.infiltration_rate_cfm
+            "shading_coefficient": self.shading_coefficient, "infiltration_rate_cfm": self.infiltration_rate_cfm,
+            "surface_color": self.surface_color, "crack_length": self.crack_length, "crack_width": self.crack_width
         })
         return base_dict
 
@@ -100,6 +145,8 @@ class Roof(BuildingComponent):
     roof_group: str = "A"  # ASHRAE group
     slope: str = "Flat"
     absorptivity: float = 0.6
+    surface_color: str = "Dark"  # Added surface color
+    roof_height: float = 3.0    # Added for stack effect (m)
 
     def __post_init__(self):
         super().__post_init__()
@@ -108,15 +155,23 @@ class Roof(BuildingComponent):
             self.orientation = Orientation.HORIZONTAL
         if not 0 <= self.absorptivity <= 1:
             raise ValueError("Absorptivity must be between 0 and 1")
+        if not 0 <= self.roof_height <= 100:
+            raise ValueError("Roof height must be between 0 and 100 meters")
         VALID_ROOF_GROUPS = {"A", "B", "C", "D", "E", "F", "G"}
         if self.roof_group not in VALID_ROOF_GROUPS:
             st.warning(f"Invalid roof_group '{self.roof_group}' for roof '{self.name}'. Defaulting to 'A'.")
             self.roof_group = "A"
+        VALID_SURFACE_COLORS = {"Dark", "Medium", "Light"}
+        if self.surface_color not in VALID_SURFACE_COLORS:
+            st.warning(f"Invalid surface_color '{self.surface_color}' for roof '{self.name}'. Defaulting to 'Dark'.")
+            self.surface_color = "Dark"
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
         base_dict.update({
-            "roof_type": self.roof_type, "roof_group": self.roof_group, "slope": self.slope, "absorptivity": self.absorptivity
+            "roof_type": self.roof_type, "roof_group": self.roof_group, "slope": self.slope, 
+            "absorptivity": self.absorptivity, "surface_color": self.surface_color,
+            "roof_height": self.roof_height
         })
         return base_dict
 
@@ -126,7 +181,7 @@ class Floor(BuildingComponent):
     ground_contact: bool = True
     ground_temperature_c: float = 25.0
     perimeter: float = 0.0
-    insulated: bool = False  # NEW: For dynamic F-factor
+    insulated: bool = False  # For dynamic F-factor
 
     def __post_init__(self):
         super().__post_init__()
@@ -151,9 +206,13 @@ class Window(BuildingComponent):
     shgc: float = 0.7
     shading_device: str = "None"
     shading_coefficient: float = 1.0
-    frame_type: str = "Aluminum"
+    frame_type: str = "Aluminum without Thermal Break"  # Updated to match FrameType enum
     frame_percentage: float = 20.0
     infiltration_rate_cfm: float = 0.0
+    glazing_type: str = "Double Clear"  # Added glazing type
+    drapery_openness: str = "Open"     # Added for drapery properties
+    drapery_color: str = "Light"       # Added for drapery properties
+    drapery_fullness: float = 1.5      # Added for drapery properties
 
     def __post_init__(self):
         super().__post_init__()
@@ -166,12 +225,25 @@ class Window(BuildingComponent):
             raise ValueError("Frame percentage must be between 0 and 30")
         if self.infiltration_rate_cfm < 0:
             raise ValueError("Infiltration rate cannot be negative")
+        VALID_DRAPERY_OPENNESS = {"Closed", "Semi-Open", "Open"}
+        if self.drapery_openness not in VALID_DRAPERY_OPENNESS:
+            st.warning(f"Invalid drapery_openness '{self.drapery_openness}' for window '{self.name}'. Defaulting to 'Open'.")
+            self.drapery_openness = "Open"
+        VALID_DRAPERY_COLORS = {"Light", "Medium", "Dark"}
+        if self.drapery_color not in VALID_DRAPERY_COLORS:
+            st.warning(f"Invalid drapery_color '{self.drapery_color}' for window '{self.name}'. Defaulting to 'Light'.")
+            self.drapery_color = "Light"
+        if not 1.0 <= self.drapery_fullness <= 2.0:
+            raise ValueError("Drapery fullness must be between 1.0 and 2.0")
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
         base_dict.update({
             "shgc": self.shgc, "shading_device": self.shading_device, "shading_coefficient": self.shading_coefficient,
-            "frame_type": self.frame_type, "frame_percentage": self.frame_percentage, "infiltration_rate_cfm": self.infiltration_rate_cfm
+            "frame_type": self.frame_type, "frame_percentage": self.frame_percentage, 
+            "infiltration_rate_cfm": self.infiltration_rate_cfm, "glazing_type": self.glazing_type,
+            "drapery_openness": self.drapery_openness, "drapery_color": self.drapery_color,
+            "drapery_fullness": self.drapery_fullness
         })
         return base_dict
 
@@ -179,16 +251,72 @@ class Window(BuildingComponent):
 class Door(BuildingComponent):
     door_type: str = "Solid Wood"
     infiltration_rate_cfm: float = 0.0
+    crack_length: float = 0.0  # Added for infiltration (m)
+    crack_width: float = 0.0   # Added for infiltration (m)
 
     def __post_init__(self):
         super().__post_init__()
         self.component_type = ComponentType.DOOR
         if self.infiltration_rate_cfm < 0:
             raise ValueError("Infiltration rate cannot be negative")
+        if not 0 <= self.crack_length <= 100:
+            raise ValueError("Crack length must be between 0 and 100 meters")
+        if not 0 <= self.crack_width <= 0.1:
+            raise ValueError("Crack width must be between 0 and 0.1 meters")
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
-        base_dict.update({"door_type": self.door_type, "infiltration_rate_cfm": self.infiltration_rate_cfm})
+        base_dict.update({
+            "door_type": self.door_type, "infiltration_rate_cfm": self.infiltration_rate_cfm,
+            "crack_length": self.crack_length, "crack_width": self.crack_width
+        })
+        return base_dict
+
+@dataclass
+class Skylight(BuildingComponent):
+    shgc: float = 0.7
+    shading_device: str = "None"
+    shading_coefficient: float = 1.0
+    frame_type: str = "Aluminum without Thermal Break"  # Match FrameType enum
+    frame_percentage: float = 20.0
+    infiltration_rate_cfm: float = 0.0
+    glazing_type: str = "Double Clear"  # Added glazing type
+    drapery_openness: str = "Open"     # Added for drapery properties
+    drapery_color: str = "Light"       # Added for drapery properties
+    drapery_fullness: float = 1.5      # Added for drapery properties
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.SKYLIGHT
+        self.orientation = Orientation.HORIZONTAL
+        if not 0 <= self.shgc <= 1:
+            raise ValueError("SHGC must be between 0 and 1")
+        if not 0 <= self.shading_coefficient <= 1:
+            raise ValueError("Shading coefficient must be between 0 and 1")
+        if not 0 <= self.frame_percentage <= 30:
+            raise ValueError("Frame percentage must be between 0 and 30")
+        if self.infiltration_rate_cfm < 0:
+            raise ValueError("Infiltration rate cannot be negative")
+        VALID_DRAPERY_OPENNESS = {"Closed", "Semi-Open", "Open"}
+        if self.drapery_openness not in VALID_DRAPERY_OPENNESS:
+            st.warning(f"Invalid drapery_openness '{self.drapery_openness}' for skylight '{self.name}'. Defaulting to 'Open'.")
+            self.drapery_openness = "Open"
+        VALID_DRAPERY_COLORS = {"Light", "Medium", "Dark"}
+        if self.drapery_color not in VALID_DRAPERY_COLORS:
+            st.warning(f"Invalid drapery_color '{self.drapery_color}' for skylight '{self.name}'. Defaulting to 'Light'.")
+            self.drapery_color = "Light"
+        if not 1.0 <= self.drapery_fullness <= 2.0:
+            raise ValueError("Drapery fullness must be between 1.0 and 2.0")
+
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({
+            "shgc": self.shgc, "shading_device": self.shading_device, "shading_coefficient": self.shading_coefficient,
+            "frame_type": self.frame_type, "frame_percentage": self.frame_percentage, 
+            "infiltration_rate_cfm": self.infiltration_rate_cfm, "glazing_type": self.glazing_type,
+            "drapery_openness": self.drapery_openness, "drapery_color": self.drapery_color,
+            "drapery_fullness": self.drapery_fullness
+        })
         return base_dict
 
 # --- Reference Data ---
@@ -216,7 +344,11 @@ class ReferenceData:
             },
             "roof_types": {
                 "Concrete Roof": {"u_value": 0.3, "absorptivity": 0.6, "group": "A"},
-                "Metal Roof": {"u_value": 1.0, "absorptivity": 0.75, "group": "B"}
+                "Metal Roof": {"u_value": 1.0, "absorptivity": 0.75, "group": "B"},
+                "Built-up Roof": {"u_value": 0.5, "absorptivity": 0.8, "group": "C"},
+                "Insulated Metal Deck": {"u_value": 0.4, "absorptivity": 0.7, "group": "D"},
+                "Wood Shingle": {"u_value": 0.6, "absorptivity": 0.5, "group": "E"},
+                "Custom": {"u_value": 0.5, "absorptivity": 0.6, "group": "A"}
             },
             "roof_ventilation_methods": {
                 "No Ventilation": 0.0,
@@ -226,22 +358,57 @@ class ReferenceData:
             },
             "floor_types": {
                 "Concrete Slab": {"u_value": 0.4, "ground_contact": True},
-                "Wood Floor": {"u_value": 0.8, "ground_contact": False}
+                "Wood Floor": {"u_value": 0.8, "ground_contact": False},
+                "Insulated Concrete Slab": {"u_value": 0.2, "ground_contact": True},
+                "Raised Floor": {"u_value": 0.5, "ground_contact": False},
+                "Tile on Concrete": {"u_value": 0.45, "ground_contact": True},
+                "Custom": {"u_value": 0.5, "ground_contact": True}
             },
             "window_types": {
-                "Double Glazed": {"u_value": 2.8, "shgc": 0.7, "frame_type": "Aluminum"},
-                "Single Glazed": {"u_value": 5.0, "shgc": 0.9, "frame_type": "Wood"}
+                "Single Clear": {"u_value": 5.0, "shgc": 0.86, "glazing_type": "Single Clear", "frame_type": "Aluminum without Thermal Break"},
+                "Single Tinted": {"u_value": 5.0, "shgc": 0.73, "glazing_type": "Single Tinted", "frame_type": "Aluminum without Thermal Break"},
+                "Double Clear": {"u_value": 2.8, "shgc": 0.76, "glazing_type": "Double Clear", "frame_type": "Aluminum with Thermal Break"},
+                "Double Tinted": {"u_value": 2.8, "shgc": 0.62, "glazing_type": "Double Tinted", "frame_type": "Aluminum with Thermal Break"},
+                "Low-E": {"u_value": 1.8, "shgc": 0.48, "glazing_type": "Low-E", "frame_type": "Vinyl/Fiberglass"},
+                "Reflective": {"u_value": 2.0, "shgc": 0.35, "glazing_type": "Reflective", "frame_type": "Aluminum with Thermal Break"},
+                "Custom": {"u_value": 2.5, "shgc": 0.7, "glazing_type": "Double Clear", "frame_type": "Aluminum with Thermal Break"}
             },
             "shading_devices": {
                 "None": 1.0,
                 "Venetian Blinds": 0.6,
                 "Overhang": 0.4,
                 "Roller Shades": 0.5,
-                "Drapes": 0.7
+                "Drapes": 0.7,
+                "Reflective Film": 0.3
             },
             "door_types": {
                 "Solid Wood": {"u_value": 2.0},
-                "Glass Door": {"u_value": 3.5}
+                "Glass Door": {"u_value": 3.5},
+                "Metal Door": {"u_value": 3.0},
+                "Insulated Metal": {"u_value": 1.2},
+                "Insulated Wood": {"u_value": 1.0},
+                "Custom": {"u_value": 2.0}
+            },
+            "skylight_types": {
+                "Single Clear": {"u_value": 5.5, "shgc": 0.83, "glazing_type": "Single Clear", "frame_type": "Aluminum without Thermal Break"},
+                "Single Tinted": {"u_value": 5.5, "shgc": 0.70, "glazing_type": "Single Tinted", "frame_type": "Aluminum without Thermal Break"},
+                "Double Clear": {"u_value": 3.2, "shgc": 0.70, "glazing_type": "Double Clear", "frame_type": "Aluminum with Thermal Break"},
+                "Double Tinted": {"u_value": 3.2, "shgc": 0.58, "glazing_type": "Double Tinted", "frame_type": "Aluminum with Thermal Break"},
+                "Low-E": {"u_value": 2.2, "shgc": 0.51, "glazing_type": "Low-E", "frame_type": "Vinyl/Fiberglass"},
+                "Reflective": {"u_value": 2.4, "shgc": 0.38, "glazing_type": "Reflective", "frame_type": "Aluminum with Thermal Break"},
+                "Custom": {"u_value": 3.0, "shgc": 0.7, "glazing_type": "Double Clear", "frame_type": "Aluminum with Thermal Break"}
+            },
+            "surface_colors": {
+                "Dark": 0.9,
+                "Medium": 0.6,
+                "Light": 0.3
+            },
+            "frame_types": {
+                "Aluminum without Thermal Break": 1.0,
+                "Aluminum with Thermal Break": 0.8,
+                "Vinyl/Fiberglass": 0.6,
+                "Wood/Vinyl-Clad Wood": 0.5,
+                "Insulated": 0.4
             }
         }
 
@@ -287,13 +454,13 @@ class ComponentSelectionInterface:
         st.title("Building Components")
         
         if 'components' not in session_state:
-            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
+            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': [], 'skylights': []}
         if 'roof_air_volume_m3' not in session_state:
             session_state.roof_air_volume_m3 = 0.0
         if 'roof_ventilation_ach' not in session_state:
             session_state.roof_ventilation_ach = 0.0
 
-        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
+        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "Skylights", "U-Value Calculator"])
         
         with tabs[0]:
             self._display_component_tab(session_state, ComponentType.WALL)
@@ -306,6 +473,8 @@ class ComponentSelectionInterface:
         with tabs[4]:
             self._display_component_tab(session_state, ComponentType.DOOR)
         with tabs[5]:
+            self._display_component_tab(session_state, ComponentType.SKYLIGHT)
+        with tabs[6]:
             self._display_u_value_calculator_tab(session_state)
         
         if st.button("Save Components"):
@@ -326,6 +495,8 @@ class ComponentSelectionInterface:
                 self._display_add_window_form(session_state)
             elif component_type == ComponentType.DOOR:
                 self._display_add_door_form(session_state)
+            elif component_type == ComponentType.SKYLIGHT:
+                self._display_add_skylight_form(session_state)
         
         components = session_state.components.get(type_name + 's', [])
         if components or component_type == ComponentType.ROOF:
@@ -345,6 +516,8 @@ class ComponentSelectionInterface:
                     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 if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
+                    surface_color = st.selectbox("Surface Color", ["Dark", "Medium", "Light"], index=0)
+                    crack_length = st.number_input("Crack Length (m)", min_value=0.0, max_value=100.0, value=0.0, step=0.1)
                 with col2:
                     wall_options = self.reference_data.data["wall_types"]
                     selected_wall = st.selectbox("Wall Type", options=list(wall_options.keys()))
@@ -353,6 +526,7 @@ class ComponentSelectionInterface:
                     absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=2)
                     shading_coefficient = st.number_input("Shading Coefficient", min_value=0.0, max_value=1.0, value=1.0, step=0.05)
                     infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)
+                    crack_width = st.number_input("Crack Width (m)", min_value=0.0, max_value=0.1, value=0.0, step=0.001)
 
                 submitted = st.form_submit_button("Add Wall")
                 if submitted and not session_state.add_wall_submitted:
@@ -361,7 +535,8 @@ class ComponentSelectionInterface:
                         new_wall = Wall(
                             name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
                             wall_type=selected_wall, wall_group=wall_group, absorptivity=absorptivity_value,
-                            shading_coefficient=shading_coefficient, infiltration_rate_cfm=infiltration_rate
+                            shading_coefficient=shading_coefficient, infiltration_rate_cfm=infiltration_rate,
+                            surface_color=surface_color, crack_length=crack_length, crack_width=crack_width
                         )
                         self.component_library.add_component(new_wall)
                         session_state.components['walls'].append(new_wall)
@@ -376,25 +551,34 @@ class ComponentSelectionInterface:
 
         elif method == "File Upload":
             uploaded_file = st.file_uploader("Upload Walls File", type=["csv", "xlsx"], key="wall_upload")
-            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Absorptivity", "Shading Coefficient", "Infiltration Rate (CFM)"]
+            required_cols = [
+                "Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group",
+                "Absorptivity", "Shading Coefficient", "Infiltration Rate (CFM)", "Surface Color",
+                "Crack Length (m)", "Crack Width (m)"
+            ]
             template_data = pd.DataFrame(columns=required_cols)
-            template_data.loc[0] = ["Example Wall", 10.0, 2.0, "North", "Brick Wall", "A", 0.6, 1.0, 0.0]
-            st.download_button(label="Download Wall Template", data=template_data.to_csv(index=False), file_name="wall_template.csv", mime="text/csv")
+            template_data.loc[0] = [
+                "Example Wall", 10.0, 0.5, "North", "Brick Wall", "A", 0.6, 1.0, 0.0, "Dark", 0.0, 0.0
+            ]
+            st.download_button(
+                label="Download Wall Template",
+                data=template_data.to_csv(index=False),
+                file_name="wall_template.csv",
+                mime="text/csv"
+            )
             if uploaded_file:
                 df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                 if all(col in df.columns for col in required_cols):
-                    valid_wall_groups = {"A", "B", "C", "D", "E", "F", "G", "H"}
                     for _, row in df.iterrows():
                         try:
-                            wall_group = str(row["Wall Group"])
-                            if wall_group not in valid_wall_groups:
-                                st.warning(f"Invalid Wall Group '{wall_group}' in row '{row['Name']}'. Defaulting to 'A'.")
-                                wall_group = "A"
                             new_wall = Wall(
                                 name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
                                 orientation=Orientation(row["Orientation"]), wall_type=str(row["Wall Type"]),
-                                wall_group=wall_group, absorptivity=float(row["Absorptivity"]),
-                                shading_coefficient=float(row["Shading Coefficient"]), infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
+                                wall_group=str(row["Wall Group"]), absorptivity=float(row["Absorptivity"]),
+                                shading_coefficient=float(row["Shading Coefficient"]),
+                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"]),
+                                surface_color=str(row["Surface Color"]), crack_length=float(row["Crack Length (m)"]),
+                                crack_width=float(row["Crack Width (m)"])
                             )
                             self.component_library.add_component(new_wall)
                             session_state.components['walls'].append(new_wall)
@@ -411,37 +595,33 @@ class ComponentSelectionInterface:
         if "add_roof_submitted" not in session_state:
             session_state.add_roof_submitted = False
 
-        st.subheader("Roof System Ventilation")
-        air_volume = st.number_input("Air Volume (m³)", min_value=0.0, value=session_state.roof_air_volume_m3, step=1.0, help="Total volume between roof and ceiling")
-        vent_options = {f"{k} (ACH={v})": v for k, v in self.reference_data.data["roof_ventilation_methods"].items()}
-        vent_options["Custom"] = None
-        ventilation_method = st.selectbox("Ventilation Method", options=list(vent_options.keys()), index=0, help="Applies to entire roof system")
-        ventilation_ach = st.number_input("Custom Ventilation Rate (ACH)", min_value=0.0, max_value=10.0, value=0.0, step=0.1) if ventilation_method == "Custom" else vent_options[ventilation_method]
-        session_state.roof_air_volume_m3 = air_volume
-        session_state.roof_ventilation_ach = ventilation_ach
-
         if method == "Manual Entry":
             with st.form("add_roof_form", clear_on_submit=True):
                 col1, col2 = st.columns(2)
                 with col1:
                     name = st.text_input("Name", "New Roof")
                     area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
-                    orientation = Orientation.HORIZONTAL.value
+                    surface_color = st.selectbox("Surface Color", ["Dark", "Medium", "Light"], index=0)
+                    roof_height = st.number_input("Roof Height (m)", min_value=0.0, max_value=100.0, value=3.0, step=0.1)
                 with col2:
                     roof_options = self.reference_data.data["roof_types"]
                     selected_roof = st.selectbox("Roof Type", options=list(roof_options.keys()))
                     u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(roof_options[selected_roof]["u_value"]), step=0.01)
                     roof_group = st.selectbox("Roof Group (ASHRAE)", ["A", "B", "C", "D", "E", "F", "G"], index=0)
-                    slope = st.selectbox("Slope", ["Flat", "Pitched"], index=0)
-                    absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=2)
+                    slope = st.selectbox("Roof Slope", ["Flat", "Low Slope", "Steep Slope"], index=0)
+                    absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark
+
+ (0.9)"], index=2)
 
                 submitted = st.form_submit_button("Add Roof")
                 if submitted and not session_state.add_roof_submitted:
                     try:
                         absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
                         new_roof = Roof(
-                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
-                            roof_type=selected_roof, roof_group=roof_group, slope=slope, absorptivity=absorptivity_value
+                            name=name, u_value=u_value, area=area, orientation=Orientation.HORIZONTAL,
+                            roof_type=selected_roof, roof_group=roof_group, slope=slope,
+                            absorptivity=absorptivity_value, surface_color=surface_color,
+                            roof_height=roof_height
                         )
                         self.component_library.add_component(new_roof)
                         session_state.components['roofs'].append(new_roof)
@@ -454,26 +634,48 @@ class ComponentSelectionInterface:
             if session_state.add_roof_submitted:
                 session_state.add_roof_submitted = False
 
+            # Roof air volume and ventilation
+            st.subheader("Roof Air Volume and Ventilation")
+            col1, col2 = st.columns(2)
+            with col1:
+                roof_air_volume = st.number_input("Roof Air Volume (m³)", min_value=0.0, value=session_state.roof_air_volume_m3, step=1.0)
+            with col2:
+                ventilation_method = st.selectbox("Ventilation Method", list(self.reference_data.data["roof_ventilation_methods"].keys()))
+                ventilation_ach = self.reference_data.data["roof_ventilation_methods"][ventilation_method]
+            
+            if st.button("Update Roof Air Volume and Ventilation"):
+                session_state.roof_air_volume_m3 = roof_air_volume
+                session_state.roof_ventilation_ach = ventilation_ach
+                st.success("Updated roof air volume and ventilation")
+                st.rerun()
+
         elif method == "File Upload":
             uploaded_file = st.file_uploader("Upload Roofs File", type=["csv", "xlsx"], key="roof_upload")
-            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Roof Type", "Roof Group", "Slope", "Absorptivity"]
+            required_cols = [
+                "Name", "Area (m²)", "U-Value (W/m²·K)", "Roof Type", "Roof Group", "Slope",
+                "Absorptivity", "Surface Color", "Roof Height (m)"
+            ]
             template_data = pd.DataFrame(columns=required_cols)
-            template_data.loc[0] = ["Example Roof", 10.0, 0.3, "Horizontal", "Concrete Roof", "A", "Flat", 0.6]
-            st.download_button(label="Download Roof Template", data=template_data.to_csv(index=False), file_name="roof_template.csv", mime="text/csv")
+            template_data.loc[0] = [
+                "Example Roof", 10.0, 0.3, "Concrete Roof", "A", "Flat", 0.6, "Dark", 3.0
+            ]
+            st.download_button(
+                label="Download Roof Template",
+                data=template_data.to_csv(index=False),
+                file_name="roof_template.csv",
+                mime="text/csv"
+            )
             if uploaded_file:
                 df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                 if all(col in df.columns for col in required_cols):
-                    valid_roof_groups = {"A", "B", "C", "D", "E", "F", "G"}
                     for _, row in df.iterrows():
                         try:
-                            roof_group = str(row["Roof Group"])
-                            if roof_group not in valid_roof_groups:
-                                st.warning(f"Invalid Roof Group '{roof_group}' in row '{row['Name']}'. Defaulting to 'A'.")
-                                roof_group = "A"
                             new_roof = Roof(
                                 name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
-                                orientation=Orientation(row["Orientation"]), roof_type=str(row["Roof Type"]),
-                                roof_group=roof_group, slope=str(row["Slope"]), absorptivity=float(row["Absorptivity"])
+                                orientation=Orientation.HORIZONTAL, roof_type=str(row["Roof Type"]),
+                                roof_group=str(row["Roof Group"]), slope=str(row["Slope"]),
+                                absorptivity=float(row["Absorptivity"]), surface_color=str(row["Surface Color"]),
+                                roof_height=float(row["Roof Height (m)"])
                             )
                             self.component_library.add_component(new_roof)
                             session_state.components['roofs'].append(new_roof)
@@ -496,14 +698,14 @@ class ComponentSelectionInterface:
                 with col1:
                     name = st.text_input("Name", "New Floor")
                     area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
-                    perimeter = st.number_input("Perimeter (m)", min_value=0.0, value=0.0, step=0.1)
+                    perimeter = st.number_input("Perimeter (m)", min_value=0.0, value=4.0, step=0.1)
                 with col2:
                     floor_options = self.reference_data.data["floor_types"]
                     selected_floor = st.selectbox("Floor Type", options=list(floor_options.keys()))
                     u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(floor_options[selected_floor]["u_value"]), step=0.01)
                     ground_contact = st.selectbox("Ground Contact", ["Yes", "No"], index=0 if floor_options[selected_floor]["ground_contact"] else 1)
                     ground_temp = st.number_input("Ground Temperature (°C)", min_value=-10.0, max_value=40.0, value=25.0, step=0.1) if ground_contact == "Yes" else 25.0
-                    insulated = st.checkbox("Insulated Floor (e.g., R-10)", value=False)  # NEW: Insulation option
+                    insulated = st.checkbox("Insulated Floor (e.g., R-10)", value=False)
 
                 submitted = st.form_submit_button("Add Floor")
                 if submitted and not session_state.add_floor_submitted:
@@ -526,10 +728,18 @@ class ComponentSelectionInterface:
 
         elif method == "File Upload":
             uploaded_file = st.file_uploader("Upload Floors File", type=["csv", "xlsx"], key="floor_upload")
-            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact", "Ground Temperature (°C)", "Perimeter (m)", "Insulated"]  # NEW: Added Insulated
+            required_cols = [
+                "Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact",
+                "Ground Temperature (°C)", "Perimeter (m)", "Insulated"
+            ]
             template_data = pd.DataFrame(columns=required_cols)
             template_data.loc[0] = ["Example Floor", 10.0, 0.4, "Concrete Slab", "Yes", 25.0, 12.0, "No"]
-            st.download_button(label="Download Floor Template", data=template_data.to_csv(index=False), file_name="floor_template.csv", mime="text/csv")
+            st.download_button(
+                label="Download Floor Template",
+                data=template_data.to_csv(index=False),
+                file_name="floor_template.csv",
+                mime="text/csv"
+            )
             if uploaded_file:
                 df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                 if all(col in df.columns for col in required_cols):
@@ -564,18 +774,22 @@ class ComponentSelectionInterface:
                     name = st.text_input("Name", "New Window")
                     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 if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
-                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
-                with col2:
                     window_options = self.reference_data.data["window_types"]
                     selected_window = st.selectbox("Window Type", options=list(window_options.keys()))
+                    glazing_type = st.selectbox("Glazing Type", [g.value for g in GlazingType], index=2)
+                    drapery_openness = st.selectbox("Drapery Openness", [o.value for o in DraperyOpenness], index=2)
+                with col2:
                     u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(window_options[selected_window]["u_value"]), step=0.01)
+                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=window_options[selected_window]["shgc"], step=0.01)
+                    frame_type = st.selectbox("Frame Type", [f.value for f in FrameType], index=1)
+                    frame_percentage = st.slider("Frame Percentage (%)", min_value=0.0, max_value=30.0, value=20.0)
                     shading_options = {f"{k} (SC={v})": k for k, v in self.reference_data.data["shading_devices"].items()}
                     shading_options["Custom"] = "Custom"
                     shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
                     shading_coefficient = st.number_input("Custom Shading Coefficient", min_value=0.0, max_value=1.0, value=1.0, step=0.05) if shading_device == "Custom" else self.reference_data.data["shading_devices"][shading_options[shading_device]]
-                    frame_type = st.selectbox("Frame Type", ["Aluminum", "Wood", "Vinyl"], index=0)
-                    frame_percentage = st.slider("Frame Percentage (%)", min_value=0.0, max_value=30.0, value=20.0)
                     infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)
+                    drapery_color = st.selectbox("Drapery Color", [c.value for c in DraperyColor], index=0)
+                    drapery_fullness = st.number_input("Drapery Fullness", min_value=1.0, max_value=2.0, value=1.5, step=0.1)
 
                 submitted = st.form_submit_button("Add Window")
                 if submitted and not session_state.add_window_submitted:
@@ -583,7 +797,9 @@ class ComponentSelectionInterface:
                         new_window = Window(
                             name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
                             shgc=shgc, shading_device=shading_options[shading_device], shading_coefficient=shading_coefficient,
-                            frame_type=frame_type, frame_percentage=frame_percentage, infiltration_rate_cfm=infiltration_rate
+                            frame_type=frame_type, frame_percentage=frame_percentage, infiltration_rate_cfm=infiltration_rate,
+                            glazing_type=glazing_type, drapery_openness=drapery_openness, drapery_color=drapery_color,
+                            drapery_fullness=drapery_fullness
                         )
                         self.component_library.add_component(new_window)
                         session_state.components['windows'].append(new_window)
@@ -598,8 +814,22 @@ class ComponentSelectionInterface:
 
         elif method == "File Upload":
             uploaded_file = st.file_uploader("Upload Windows File", type=["csv", "xlsx"], key="window_upload")
-            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "SHGC", "Shading Device", "Shading Coefficient", "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)"]
-            st.download_button(label="Download Window Template", data=pd.DataFrame(columns=required_cols).to_csv(index=False), file_name="window_template.csv", mime="text/csv")
+            required_cols = [
+                "Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "SHGC", "Shading Device",
+                "Shading Coefficient", "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)",
+                "Glazing Type", "Drapery Openness", "Drapery Color", "Drapery Fullness"
+            ]
+            template_data = pd.DataFrame(columns=required_cols)
+            template_data.loc[0] = [
+                "Example Window", 2.0, 2.8, "North", 0.7, "None", 1.0, "Aluminum with Thermal Break",
+                20.0, 0.0, "Double Clear", "Open", "Light", 1.5
+            ]
+            st.download_button(
+                label="Download Window Template",
+                data=template_data.to_csv(index=False),
+                file_name="window_template.csv",
+                mime="text/csv"
+            )
             if uploaded_file:
                 df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                 if all(col in df.columns for col in required_cols):
@@ -610,7 +840,9 @@ class ComponentSelectionInterface:
                                 orientation=Orientation(row["Orientation"]), shgc=float(row["SHGC"]),
                                 shading_device=str(row["Shading Device"]), shading_coefficient=float(row["Shading Coefficient"]),
                                 frame_type=str(row["Frame Type"]), frame_percentage=float(row["Frame Percentage"]),
-                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
+                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"]), glazing_type=str(row["Glazing Type"]),
+                                drapery_openness=str(row["Drapery Openness"]), drapery_color=str(row["Drapery Color"]),
+                                drapery_fullness=float(row["Drapery Fullness"])
                             )
                             self.component_library.add_component(new_window)
                             session_state.components['windows'].append(new_window)
@@ -634,18 +866,21 @@ class ComponentSelectionInterface:
                     name = st.text_input("Name", "New Door")
                     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 if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=0)
+                    crack_length = st.number_input("Crack Length (m)", min_value=0.0, max_value=100.0, value=0.0, step=0.1)
                 with col2:
                     door_options = self.reference_data.data["door_types"]
                     selected_door = st.selectbox("Door Type", options=list(door_options.keys()))
                     u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(door_options[selected_door]["u_value"]), step=0.01)
                     infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)
+                    crack_width = st.number_input("Crack Width (m)", min_value=0.0, max_value=0.1, value=0.0, step=0.001)
 
                 submitted = st.form_submit_button("Add Door")
                 if submitted and not session_state.add_door_submitted:
                     try:
                         new_door = Door(
                             name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
-                            door_type=selected_door, infiltration_rate_cfm=infiltration_rate
+                            door_type=selected_door, infiltration_rate_cfm=infiltration_rate,
+                            crack_length=crack_length, crack_width=crack_width
                         )
                         self.component_library.add_component(new_door)
                         session_state.components['doors'].append(new_door)
@@ -660,8 +895,18 @@ class ComponentSelectionInterface:
 
         elif method == "File Upload":
             uploaded_file = st.file_uploader("Upload Doors File", type=["csv", "xlsx"], key="door_upload")
-            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type", "Infiltration Rate (CFM)"]
-            st.download_button(label="Download Door Template", data=pd.DataFrame(columns=required_cols).to_csv(index=False), file_name="door_template.csv", mime="text/csv")
+            required_cols = [
+                "Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type",
+                "Infiltration Rate (CFM)", "Crack Length (m)", "Crack Width (m)"
+            ]
+            template_data = pd.DataFrame(columns=required_cols)
+            template_data.loc[0] = ["Example Door", 2.0, 2.0, "North", "Solid Wood", 0.0, 0.0, 0.0]
+            st.download_button(
+                label="Download Door Template",
+                data=template_data.to_csv(index=False),
+                file_name="door_template.csv",
+                mime="text/csv"
+            )
             if uploaded_file:
                 df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
                 if all(col in df.columns for col in required_cols):
@@ -670,7 +915,8 @@ class ComponentSelectionInterface:
                             new_door = Door(
                                 name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
                                 orientation=Orientation(row["Orientation"]), door_type=str(row["Door Type"]),
-                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
+                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"]),
+                                crack_length=float(row["Crack Length (m)"]), crack_width=float(row["Crack Width (m)"])
                             )
                             self.component_library.add_component(new_door)
                             session_state.components['doors'].append(new_door)
@@ -681,6 +927,164 @@ class ComponentSelectionInterface:
                 else:
                     st.error(f"File must contain: {', '.join(required_cols)}")
 
+    def _display_add_skylight_form(self, session_state: Any) -> None:
+        st.write("Add skylights manually or upload a file.")
+        method = st.radio("Add Skylight Method", ["Manual Entry", "File Upload"])
+        if "add_skylight_submitted" not in session_state:
+            session_state.add_skylight_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_skylight_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    name = st.text_input("Name", "New Skylight")
+                    area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
+                    skylight_options = self.reference_data.data["skylight_types"]
+                    selected_skylight = st.selectbox("Skylight Type", options=list(skylight_options.keys()))
+                    glazing_type = st.selectbox("Glazing Type", [g.value for g in GlazingType], index=2)
+                    drapery_openness = st.selectbox("Drapery Openness", [o.value for o in DraperyOpenness], index=2)
+                with col2:
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(skylight_options[selected_skylight]["u_value"]), step=0.01)
+                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=skylight_options[selected_skylight]["shgc"], step=0.01)
+                    frame_type = st.selectbox("Frame Type", [f.value for f in FrameType], index=1)
+                    frame_percentage = st.slider("Frame Percentage (%)", min_value=0.0, max_value=30.0, value=20.0)
+                    shading_options = {f"{k} (SC={v})": k for k, v in self.reference_data.data["shading_devices"].items()}
+                    shading_options["Custom"] = "Custom"
+                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
+                    shading_coefficient = st.number_input("Custom Shading Coefficient", min_value=0.0, max_value=1.0, value=1.0, step=0.05) if shading_device == "Custom" else self.reference_data.data["shading_devices"][shading_options[shading_device]]
+                    infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=0.0, step=0.1)
+                    drapery_color = st.selectbox("Drapery Color", [c.value for c in DraperyColor], index=0)
+                    drapery_fullness = st.number_input("Drapery Fullness", min_value=1.0, max_value=2.0, value=1.5, step=0.1)
+
+                submitted = st.form_submit_button("Add Skylight")
+                if submitted and not session_state.add_skylight_submitted:
+                    try:
+                        new_skylight = Skylight(
+                            name=name, u_value=u_value, area=area, orientation=Orientation.HORIZONTAL,
+                            shgc=shgc, shading_device=shading_options[shading_device], shading_coefficient=shading_coefficient,
+                            frame_type=frame_type, frame_percentage=frame_percentage, infiltration_rate_cfm=infiltration_rate,
+                            glazing_type=glazing_type, drapery_openness=drapery_openness, drapery_color=drapery_color,
+                            drapery_fullness=drapery_fullness
+                        )
+                        self.component_library.add_component(new_skylight)
+                        session_state.components['skylights'].append(new_skylight)
+                        st.success(f"Added {new_skylight.name}")
+                        session_state.add_skylight_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_skylight_submitted:
+                session_state.add_skylight_submitted = False
+
+        elif method == "File Upload":
+            uploaded_file = st.file_uploader("Upload Skylights File", type=["csv", "xlsx"], key="skylight_upload")
+            required_cols = [
+                "Name", "Area (m²)", "U-Value (W/m²·K)", "SHGC", "Shading Device", "Shading Coefficient",
+                "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)", "Glazing Type",
+                "Drapery Openness", "Drapery Color", "Drapery Fullness"
+            ]
+            template_data = pd.DataFrame(columns=required_cols)
+            template_data.loc[0] = [
+                "Example Skylight", 1.0, 3.2, 0.7, "None", 1.0, "Aluminum with Thermal Break",
+                20.0, 0.0, "Double Clear", "Open", "Light", 1.5
+            ]
+            st.download_button(
+                label="Download Skylight Template",
+                data=template_data.to_csv(index=False),
+                file_name="skylight_template.csv",
+                mime="text/csv"
+            )
+            if uploaded_file:
+                df = pd.read_csv(uploaded_file) if uploaded_file.name.endswith('.csv') else pd.read_excel(uploaded_file)
+                if all(col in df.columns for col in required_cols):
+                    for _, row in df.iterrows():
+                        try:
+                            new_skylight = Skylight(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                orientation=Orientation.HORIZONTAL, shgc=float(row["SHGC"]),
+                                shading_device=str(row["Shading Device"]), shading_coefficient=float(row["Shading Coefficient"]),
+                                frame_type=str(row["Frame Type"]), frame_percentage=float(row["Frame Percentage"]),
+                                infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"]), glazing_type=str(row["Glazing Type"]),
+                                drapery_openness=str(row["Drapery Openness"]), drapery_color=str(row["Drapery Color"]),
+                                drapery_fullness=float(row["Drapery Fullness"])
+                            )
+                            self.component_library.add_component(new_skylight)
+                            session_state.components['skylights'].append(new_skylight)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Skylights uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_u_value_calculator_tab(self, session_state: Any) -> None:
+        st.subheader("U-Value Calculator")
+        st.write("Calculate U-value based on material layers.")
+        
+        if "u_value_layers" not in session_state:
+            session_state.u_value_layers = []
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            outside_resistance = st.number_input("Outside Surface Resistance (m²·K/W)", min_value=0.0, value=0.04, step=0.01)
+        with col2:
+            inside_resistance = st.number_input("Inside Surface Resistance (m²·K/W)", min_value=0.0, value=0.13, step=0.01)
+        
+        st.subheader("Material Layers")
+        for i, layer in enumerate(session_state.u_value_layers):
+            col1, col2, col3, col4 = st.columns([3, 2, 2, 1])
+            with col1:
+                material_options = [m["name"] for m in self.u_value_calculator.materials]
+                material_index = material_options.index(layer["name"]) if layer["name"] in material_options else 0
+                layer["name"] = st.selectbox(f"Material {i+1}", material_options, index=material_index, key=f"material_{i}")
+            with col2:
+                layer["thickness"] = st.number_input(f"Thickness {i+1} (mm)", min_value=0.1, value=layer["thickness"], step=1.0, key=f"thickness_{i}")
+            with col3:
+                material_conductivity = next((m["conductivity"] for m in self.u_value_calculator.materials if m["name"] == layer["name"]), 1.0)
+                layer["conductivity"] = st.number_input(f"Conductivity {i+1} (W/m·K)", min_value=0.001, value=material_conductivity, step=0.01, key=f"conductivity_{i}")
+            with col4:
+                if st.button("Remove", key=f"remove_{i}"):
+                    session_state.u_value_layers.pop(i)
+                    st.rerun()
+        
+        col1, col2 = st.columns([3, 1])
+        with col1:
+            new_material = st.selectbox("Add Material", [m["name"] for m in self.u_value_calculator.materials])
+            new_thickness = st.number_input("Thickness (mm)", min_value=0.1, value=100.0, step=1.0)
+            new_conductivity = next((m["conductivity"] for m in self.u_value_calculator.materials if m["name"] == new_material), 1.0)
+        with col2:
+            if st.button("Add Layer"):
+                session_state.u_value_layers.append({
+                    "name": new_material,
+                    "thickness": new_thickness,
+                    "conductivity": new_conductivity
+                })
+                st.rerun()
+        
+        if session_state.u_value_layers:
+            u_value = self.u_value_calculator.calculate_u_value(session_state.u_value_layers, outside_resistance, inside_resistance)
+            st.success(f"Calculated U-Value: {u_value:.3f} W/m²·K")
+            
+            # Display R-value breakdown
+            st.subheader("R-Value Breakdown")
+            data = []
+            data.append({"Layer": "Outside Surface", "Thickness (mm)": "-", "Conductivity (W/m·K)": "-", "R-Value (m²·K/W)": outside_resistance})
+            for layer in session_state.u_value_layers:
+                r_value = layer["thickness"] / 1000 / layer["conductivity"]
+                data.append({
+                    "Layer": layer["name"],
+                    "Thickness (mm)": f"{layer['thickness']:.1f}",
+                    "Conductivity (W/m·K)": f"{layer['conductivity']:.3f}",
+                    "R-Value (m²·K/W)": f"{r_value:.3f}"
+                })
+            data.append({"Layer": "Inside Surface", "Thickness (mm)": "-", "Conductivity (W/m·K)": "-", "R-Value (m²·K/W)": inside_resistance})
+            
+            total_r_value = sum(layer["thickness"] / 1000 / layer["conductivity"] for layer in session_state.u_value_layers) + outside_resistance + inside_resistance
+            data.append({"Layer": "Total", "Thickness (mm)": f"{sum(layer['thickness'] for layer in session_state.u_value_layers):.1f}", "Conductivity (W/m·K)": "-", "R-Value (m²·K/W)": f"{total_r_value:.3f}"})
+            
+            st.table(pd.DataFrame(data))
+
     def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[BuildingComponent]) -> None:
         type_name = component_type.value.lower()
         if component_type == ComponentType.ROOF:
@@ -688,114 +1092,402 @@ class ComponentSelectionInterface:
 
         if components:
             headers = {
-                ComponentType.WALL: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Absorptivity", "Shading Coefficient", "Infiltration Rate (CFM)", "Delete"],
-                ComponentType.ROOF: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Roof Type", "Roof Group", "Slope", "Absorptivity", "Delete"],
-                ComponentType.FLOOR: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact", "Ground Temperature (°C)", "Perimeter (m)", "Insulated", "Delete"],  # NEW: Added Insulated
-                ComponentType.WINDOW: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "SHGC", "Shading Device", "Shading Coefficient", "Frame Type", "Frame Percentage", "Infiltration Rate (CFM)", "Delete"],
-                ComponentType.DOOR: ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type", "Infiltration Rate (CFM)", "Delete"]
+                ComponentType.WALL: [
+                    "Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group",
+                    "Absorptivity", "Surface Color", "Crack Length (m)", "Crack Width (m)", "Edit", "Delete"
+                ],
+                ComponentType.ROOF: [
+                    "Name", "Area (m²)", "U-Value (W/m²·K)", "Roof Type", "Roof Group", "Slope",
+                    "Absorptivity", "Surface Color", "Roof Height (m)", "Edit", "Delete"
+                ],
+                ComponentType.FLOOR: [
+                    "Name", "Area (m²)", "U-Value (W/m²·K)", "Floor Type", "Ground Contact",
+                    "Ground Temperature (°C)", "Perimeter (m)", "Insulated", "Edit", "Delete"
+                ],
+                ComponentType.WINDOW: [
+                    "Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Glazing Type", "SHGC",
+                    "Frame Type", "Drapery Openness", "Drapery Color", "Edit", "Delete"
+                ],
+                ComponentType.DOOR: [
+                    "Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Door Type",
+                    "Crack Length (m)", "Crack Width (m)", "Edit", "Delete"
+                ],
+                ComponentType.SKYLIGHT: [
+                    "Name", "Area (m²)", "U-Value (W/m²·K)", "Glazing Type", "SHGC", "Frame Type",
+                    "Drapery Openness", "Drapery Color", "Edit", "Delete"
+                ]
             }[component_type]
             cols = st.columns([1] * len(headers))
             for i, header in enumerate(headers):
                 cols[i].write(f"**{header}**")
 
-            for comp in components:
+            for i, comp in enumerate(components):
                 cols = st.columns([1] * len(headers))
                 cols[0].write(comp.name)
                 cols[1].write(comp.area)
                 cols[2].write(comp.u_value)
-                cols[3].write(comp.orientation.value)
+                
                 if component_type == ComponentType.WALL:
+                    cols[3].write(comp.orientation.value)
                     cols[4].write(comp.wall_type)
                     cols[5].write(comp.wall_group)
                     cols[6].write(comp.absorptivity)
-                    cols[7].write(comp.shading_coefficient)
-                    cols[8].write(comp.infiltration_rate_cfm)
+                    cols[7].write(comp.surface_color)
+                    cols[8].write(comp.crack_length)
+                    cols[9].write(comp.crack_width)
+                    edit_col = 10
                 elif component_type == ComponentType.ROOF:
-                    cols[4].write(comp.roof_type)
-                    cols[5].write(comp.roof_group)
-                    cols[6].write(comp.slope)
-                    cols[7].write(comp.absorptivity)
+                    cols[3].write(comp.roof_type)
+                    cols[4].write(comp.roof_group)
+                    cols[5].write(comp.slope)
+                    cols[6].write(comp.absorptivity)
+                    cols[7].write(comp.surface_color)
+                    cols[8].write(comp.roof_height)
+                    edit_col = 9
                 elif component_type == ComponentType.FLOOR:
-                    cols[4].write(comp.floor_type)
-                    cols[5].write("Yes" if comp.ground_contact else "No")
-                    cols[6].write(comp.ground_temperature_c if comp.ground_contact else "N/A")
-                    cols[7].write(comp.perimeter)
-                    cols[8].write("Yes" if comp.insulated else "No")  # NEW: Display insulated
+                    cols[3].write(comp.floor_type)
+                    cols[4].write("Yes" if comp.ground_contact else "No")
+                    cols[5].write(comp.ground_temperature_c if comp.ground_contact else "N/A")
+                    cols[6].write(comp.perimeter)
+                    cols[7].write("Yes" if comp.insulated else "No")
+                    edit_col = 8
                 elif component_type == ComponentType.WINDOW:
-                    cols[4].write(comp.shgc)
-                    cols[5].write(comp.shading_device)
-                    cols[6].write(comp.shading_coefficient)
-                    cols[7].write(comp.frame_type)
-                    cols[8].write(comp.frame_percentage)
-                    cols[9].write(comp.infiltration_rate_cfm)
+                    cols[3].write(comp.orientation.value)
+                    cols[4].write(comp.glazing_type)
+                    cols[5].write(comp.shgc)
+                    cols[6].write(comp.frame_type)
+                    cols[7].write(comp.drapery_openness)
+                    cols[8].write(comp.drapery_color)
+                    edit_col = 9
                 elif component_type == ComponentType.DOOR:
+                    cols[3].write(comp.orientation.value)
                     cols[4].write(comp.door_type)
-                    cols[5].write(comp.infiltration_rate_cfm)
-                if cols[-1].button("Delete", key=f"delete_{comp.id}"):
+                    cols[5].write(comp.crack_length)
+                    cols[6].write(comp.crack_width)
+                    edit_col = 7
+                elif component_type == ComponentType.SKYLIGHT:
+                    cols[3].write(comp.glazing_type)
+                    cols[4].write(comp.shgc)
+                    cols[5].write(comp.frame_type)
+                    cols[6].write(comp.drapery_openness)
+                    cols[7].write(comp.drapery_color)
+                    edit_col = 8
+                
+                # Edit button
+                if cols[edit_col].button("✏️", key=f"edit_{type_name}_{i}"):
+                    session_state[f"edit_{type_name}"] = i
+                    st.rerun()
+                
+                # Delete button
+                if cols[edit_col + 1].button("🗑️", key=f"delete_{type_name}_{i}"):
                     self.component_library.remove_component(comp.id)
-                    session_state.components[type_name + 's'] = [c for c in components if c.id != comp.id]
-                    st.success(f"Deleted {comp.name}")
+                    session_state.components[type_name + 's'].pop(i)
+                    st.rerun()
+            
+            # Edit form
+            if f"edit_{type_name}" in session_state and session_state[f"edit_{type_name}"] is not None:
+                edit_index = session_state[f"edit_{type_name}"]
+                if 0 <= edit_index < len(components):
+                    comp = components[edit_index]
+                    st.subheader(f"Edit {type_name.capitalize()}: {comp.name}")
+                    
+                    if component_type == ComponentType.WALL:
+                        self._display_edit_wall_form(session_state, comp, edit_index)
+                    elif component_type == ComponentType.ROOF:
+                        self._display_edit_roof_form(session_state, comp, edit_index)
+                    elif component_type == ComponentType.FLOOR:
+                        self._display_edit_floor_form(session_state, comp, edit_index)
+                    elif component_type == ComponentType.WINDOW:
+                        self._display_edit_window_form(session_state, comp, edit_index)
+                    elif component_type == ComponentType.DOOR:
+                        self._display_edit_door_form(session_state, comp, edit_index)
+                    elif component_type == ComponentType.SKYLIGHT:
+                        self._display_edit_skylight_form(session_state, comp, edit_index)
+
+    def _display_edit_wall_form(self, session_state: Any, wall: Wall, index: int) -> None:
+        with st.form(f"edit_wall_form_{index}", clear_on_submit=True):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", wall.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=wall.area, step=0.1)
+                orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=[o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE].index(wall.orientation.value))
+                surface_color = st.selectbox("Surface Color", ["Dark", "Medium", "Light"], index=["Dark", "Medium", "Light"].index(wall.surface_color))
+                crack_length = st.number_input("Crack Length (m)", min_value=0.0, max_value=100.0, value=wall.crack_length, step=0.1)
+            with col2:
+                wall_options = self.reference_data.data["wall_types"]
+                selected_wall = st.selectbox("Wall Type", options=list(wall_options.keys()), index=list(wall_options.keys()).index(wall.wall_type) if wall.wall_type in wall_options else 0)
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=wall.u_value, step=0.01)
+                wall_group = st.selectbox("Wall Group (ASHRAE)", ["A", "B", "C", "D", "E", "F", "G", "H"], index=["A", "B", "C", "D", "E", "F", "G", "H"].index(wall.wall_group))
+                absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"].index(f"{['Light (0.3)', 'Light to Medium (0.45)', 'Medium (0.6)', 'Medium to Dark (0.75)', 'Dark (0.9)'][np.argmin([abs(float(opt.split('(')[1].strip(')')) - wall.absorptivity) for opt in ['Light (0.3)', 'Light to Medium (0.45)', 'Medium (0.6)', 'Medium to Dark (0.75)', 'Dark (0.9)']])]}"))
+                shading_coefficient = st.number_input("Shading Coefficient", min_value=0.0, max_value=1.0, value=wall.shading_coefficient, step=0.05)
+                infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=wall.infiltration_rate_cfm, step=0.1)
+                crack_width = st.number_input("Crack Width (m)", min_value=0.0, max_value=0.1, value=wall.crack_width, step=0.001)
+
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                submitted = st.form_submit_button("Update Wall")
+            with col2:
+                if st.form_submit_button("Cancel"):
+                    session_state[f"edit_wall"] = None
                     st.rerun()
 
-    def _display_u_value_calculator_tab(self, session_state: Any) -> None:
-        st.subheader("U-Value Calculator (Standalone)")
-        if "u_value_layers" not in session_state:
-            session_state.u_value_layers = []
+            if submitted:
+                try:
+                    absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
+                    updated_wall = Wall(
+                        id=wall.id, name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                        wall_type=selected_wall, wall_group=wall_group, absorptivity=absorptivity_value,
+                        shading_coefficient=shading_coefficient, infiltration_rate_cfm=infiltration_rate,
+                        surface_color=surface_color, crack_length=crack_length, crack_width=crack_width
+                    )
+                    self.component_library.components[wall.id] = updated_wall
+                    session_state.components['walls'][index] = updated_wall
+                    st.success(f"Updated {updated_wall.name}")
+                    session_state[f"edit_wall"] = None
+                    st.rerun()
+                except ValueError as e:
+                    st.error(f"Error: {str(e)}")
 
-        if session_state.u_value_layers:
-            st.write("Material Layers (Outside to Inside):")
-            layer_data = [{"Layer": i+1, "Material": l["name"], "Thickness (mm)": l["thickness"], 
-                           "Conductivity (W/m·K)": l["conductivity"], "R-Value (m²·K/W)": l["thickness"] / 1000 / l["conductivity"]} 
-                          for i, l in enumerate(session_state.u_value_layers)]
-            st.dataframe(pd.DataFrame(layer_data))
-            outside_resistance = st.selectbox("Outside Resistance (m²·K/W)", ["Summer (0.04)", "Winter (0.03)", "Custom"], index=0)
-            outside_r = float(st.number_input("Custom Outside Resistance", min_value=0.0, value=0.04, step=0.01)) if outside_resistance == "Custom" else (0.04 if outside_resistance.startswith("Summer") else 0.03)
-            inside_r = st.number_input("Inside Resistance (m²·K/W)", min_value=0.0, value=0.13, step=0.01)
-            u_value = self.u_value_calculator.calculate_u_value(session_state.u_value_layers, outside_r, inside_r)
-            st.metric("U-Value", f"{u_value:.3f} W/m²·K")
-
-        with st.form("u_value_form"):
+    def _display_edit_roof_form(self, session_state: Any, roof: Roof, index: int) -> None:
+        with st.form(f"edit_roof_form_{index}", clear_on_submit=True):
             col1, col2 = st.columns(2)
             with col1:
-                material_options = {m["name"]: m["conductivity"] for m in self.u_value_calculator.materials}
-                material_name = st.selectbox("Material", options=list(material_options.keys()))
-                conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=material_options[material_name], step=0.01)
+                name = st.text_input("Name", roof.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=roof.area, step=0.1)
+                surface_color = st.selectbox("Surface Color", ["Dark", "Medium", "Light"], index=["Dark", "Medium", "Light"].index(roof.surface_color))
+                roof_height = st.number_input("Roof Height (m)", min_value=0.0, max_value=100.0, value=roof.roof_height, step=0.1)
             with col2:
-                thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
-            submitted = st.form_submit_button("Add Layer")
+                roof_options = self.reference_data.data["roof_types"]
+                selected_roof = st.selectbox("Roof Type", options=list(roof_options.keys()), index=list(roof_options.keys()).index(roof.roof_type) if roof.roof_type in roof_options else 0)
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=roof.u_value, step=0.01)
+                roof_group = st.selectbox("Roof Group (ASHRAE)", ["A", "B", "C", "D", "E", "F", "G"], index=["A", "B", "C", "D", "E", "F", "G"].index(roof.roof_group))
+                slope = st.selectbox("Roof Slope", ["Flat", "Low Slope", "Steep Slope"], index=["Flat", "Low Slope", "Steep Slope"].index(roof.slope))
+                absorptivity = st.selectbox("Solar Absorptivity", ["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"], index=["Light (0.3)", "Light to Medium (0.45)", "Medium (0.6)", "Medium to Dark (0.75)", "Dark (0.9)"].index(f"{['Light (0.3)', 'Light to Medium (0.45)', 'Medium (0.6)', 'Medium to Dark (0.75)', 'Dark (0.9)'][np.argmin([abs(float(opt.split('(')[1].strip(')')) - roof.absorptivity) for opt in ['Light (0.3)', 'Light to Medium (0.45)', 'Medium (0.6)', 'Medium to Dark (0.75)', 'Dark (0.9)']])]}"))
+
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                submitted = st.form_submit_button("Update Roof")
+            with col2:
+                if st.form_submit_button("Cancel"):
+                    session_state[f"edit_roof"] = None
+                    st.rerun()
+
             if submitted:
-                session_state.u_value_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
-                st.rerun()
+                try:
+                    absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
+                    updated_roof = Roof(
+                        id=roof.id, name=name, u_value=u_value, area=area, orientation=Orientation.HORIZONTAL,
+                        roof_type=selected_roof, roof_group=roof_group, slope=slope,
+                        absorptivity=absorptivity_value, surface_color=surface_color,
+                        roof_height=roof_height
+                    )
+                    self.component_library.components[roof.id] = updated_roof
+                    session_state.components['roofs'][index] = updated_roof
+                    st.success(f"Updated {updated_roof.name}")
+                    session_state[f"edit_roof"] = None
+                    st.rerun()
+                except ValueError as e:
+                    st.error(f"Error: {str(e)}")
 
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("Remove Last Layer"):
-                if session_state.u_value_layers:
-                    session_state.u_value_layers.pop()
+    def _display_edit_floor_form(self, session_state: Any, floor: Floor, index: int) -> None:
+        with st.form(f"edit_floor_form_{index}", clear_on_submit=True):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", floor.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=floor.area, step=0.1)
+                perimeter = st.number_input("Perimeter (m)", min_value=0.0, value=floor.perimeter, step=0.1)
+            with col2:
+                floor_options = self.reference_data.data["floor_types"]
+                selected_floor = st.selectbox("Floor Type", options=list(floor_options.keys()), index=list(floor_options.keys()).index(floor.floor_type) if floor.floor_type in floor_options else 0)
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=floor.u_value, step=0.01)
+                ground_contact = st.selectbox("Ground Contact", ["Yes", "No"], index=0 if floor.ground_contact else 1)
+                ground_temp = st.number_input("Ground Temperature (°C)", min_value=-10.0, max_value=40.0, value=floor.ground_temperature_c, step=0.1) if ground_contact == "Yes" else floor.ground_temperature_c
+                insulated = st.checkbox("Insulated Floor (e.g., R-10)", value=floor.insulated)
+
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                submitted = st.form_submit_button("Update Floor")
+            with col2:
+                if st.form_submit_button("Cancel"):
+                    session_state[f"edit_floor"] = None
                     st.rerun()
-        with col2:
-            if st.button("Reset"):
-                session_state.u_value_layers = []
-                st.rerun()
+
+            if submitted:
+                try:
+                    updated_floor = Floor(
+                        id=floor.id, name=name, u_value=u_value, area=area, floor_type=selected_floor,
+                        ground_contact=(ground_contact == "Yes"), ground_temperature_c=ground_temp,
+                        perimeter=perimeter, insulated=insulated
+                    )
+                    self.component_library.components[floor.id] = updated_floor
+                    session_state.components['floors'][index] = updated_floor
+                    st.success(f"Updated {updated_floor.name}")
+                    session_state[f"edit_floor"] = None
+                    st.rerun()
+                except ValueError as e:
+                    st.error(f"Error: {str(e)}")
+
+    def _display_edit_window_form(self, session_state: Any, window: Window, index: int) -> None:
+        with st.form(f"edit_window_form_{index}", clear_on_submit=True):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", window.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=window.area, step=0.1)
+                orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=[o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE].index(window.orientation.value))
+                window_options = self.reference_data.data["window_types"]
+                selected_window = st.selectbox("Window Type", options=list(window_options.keys()), index=list(window_options.keys()).index(window.shading_device) if window.shading_device in window_options else 0)
+                glazing_type = st.selectbox("Glazing Type", [g.value for g in GlazingType], index=[g.value for g in GlazingType].index(window.glazing_type))
+                drapery_openness = st.selectbox("Drapery Openness", [o.value for o in DraperyOpenness], index=[o.value for o in DraperyOpenness].index(window.drapery_openness))
+            with col2:
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=window.u_value, step=0.01)
+                shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=window.shgc, step=0.01)
+                frame_type = st.selectbox("Frame Type", [f.value for f in FrameType], index=[f.value for f in FrameType].index(window.frame_type))
+                frame_percentage = st.slider("Frame Percentage (%)", min_value=0.0, max_value=30.0, value=window.frame_percentage)
+                shading_options = {f"{k} (SC={v})": k for k, v in self.reference_data.data["shading_devices"].items()}
+                shading_options["Custom"] = "Custom"
+                shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=list(shading_options.values()).index(window.shading_device) if window.shading_device in shading_options.values() else len(shading_options) - 1)
+                shading_coefficient = st.number_input("Custom Shading Coefficient", min_value=0.0, max_value=1.0, value=window.shading_coefficient, step=0.05) if shading_device == "Custom" else self.reference_data.data["shading_devices"][shading_options[shading_device]]
+                infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=window.infiltration_rate_cfm, step=0.1)
+                drapery_color = st.selectbox("Drapery Color", [c.value for c in DraperyColor], index=[c.value for c in DraperyColor].index(window.drapery_color))
+                drapery_fullness = st.number_input("Drapery Fullness", min_value=1.0, max_value=2.0, value=window.drapery_fullness, step=0.1)
+
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                submitted = st.form_submit_button("Update Window")
+            with col2:
+                if st.form_submit_button("Cancel"):
+                    session_state[f"edit_window"] = None
+                    st.rerun()
+
+            if submitted:
+                try:
+                    updated_window = Window(
+                        id=window.id, name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                        shgc=shgc, shading_device=shading_options[shading_device], shading_coefficient=shading_coefficient,
+                        frame_type=frame_type, frame_percentage=frame_percentage, infiltration_rate_cfm=infiltration_rate,
+                        glazing_type=glazing_type, drapery_openness=drapery_openness, drapery_color=drapery_color,
+                        drapery_fullness=drapery_fullness
+                    )
+                    self.component_library.components[window.id] = updated_window
+                    session_state.components['windows'][index] = updated_window
+                    st.success(f"Updated {updated_window.name}")
+                    session_state[f"edit_window"] = None
+                    st.rerun()
+                except ValueError as e:
+                    st.error(f"Error: {str(e)}")
+
+    def _display_edit_door_form(self, session_state: Any, door: Door, index: int) -> None:
+        with st.form(f"edit_door_form_{index}", clear_on_submit=True):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", door.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=door.area, step=0.1)
+                orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], index=[o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE].index(door.orientation.value))
+                crack_length = st.number_input("Crack Length (m)", min_value=0.0, max_value=100.0, value=door.crack_length, step=0.1)
+            with col2:
+                door_options = self.reference_data.data["door_types"]
+                selected_door = st.selectbox("Door Type", options=list(door_options.keys()), index=list(door_options.keys()).index(door.door_type) if door.door_type in door_options else 0)
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=door.u_value, step=0.01)
+                infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=door.infiltration_rate_cfm, step=0.1)
+                crack_width = st.number_input("Crack Width (m)", min_value=0.0, max_value=0.1, value=door.crack_width, step=0.001)
+
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                submitted = st.form_submit_button("Update Door")
+            with col2:
+                if st.form_submit_button("Cancel"):
+                    session_state[f"edit_door"] = None
+                    st.rerun()
+
+            if submitted:
+                try:
+                    updated_door = Door(
+                        id=door.id, name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                        door_type=selected_door, infiltration_rate_cfm=infiltration_rate,
+                        crack_length=crack_length, crack_width=crack_width
+                    )
+                    self.component_library.components[door.id] = updated_door
+                    session_state.components['doors'][index] = updated_door
+                    st.success(f"Updated {updated_door.name}")
+                    session_state[f"edit_door"] = None
+                    st.rerun()
+                except ValueError as e:
+                    st.error(f"Error: {str(e)}")
+
+    def _display_edit_skylight_form(self, session_state: Any, skylight: Skylight, index: int) -> None:
+        with st.form(f"edit_skylight_form_{index}", clear_on_submit=True):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", skylight.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=skylight.area, step=0.1)
+                skylight_options = self.reference_data.data["skylight_types"]
+                selected_skylight = st.selectbox("Skylight Type", options=list(skylight_options.keys()), index=list(skylight_options.keys()).index(skylight.shading_device) if skylight.shading_device in skylight_options else 0)
+                glazing_type = st.selectbox("Glazing Type", [g.value for g in GlazingType], index=[g.value for g in GlazingType].index(skylight.glazing_type))
+                drapery_openness = st.selectbox("Drapery Openness", [o.value for o in DraperyOpenness], index=[o.value for o in DraperyOpenness].index(skylight.drapery_openness))
+            with col2:
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=skylight.u_value, step=0.01)
+                shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=skylight.shgc, step=0.01)
+                frame_type = st.selectbox("Frame Type", [f.value for f in FrameType], index=[f.value for f in FrameType].index(skylight.frame_type))
+                frame_percentage = st.slider("Frame Percentage (%)", min_value=0.0, max_value=30.0, value=skylight.frame_percentage)
+                shading_options = {f"{k} (SC={v})": k for k, v in self.reference_data.data["shading_devices"].items()}
+                shading_options["Custom"] = "Custom"
+                shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=list(shading_options.values()).index(skylight.shading_device) if skylight.shading_device in shading_options.values() else len(shading_options) - 1)
+                shading_coefficient = st.number_input("Custom Shading Coefficient", min_value=0.0, max_value=1.0, value=skylight.shading_coefficient, step=0.05) if shading_device == "Custom" else self.reference_data.data["shading_devices"][shading_options[shading_device]]
+                infiltration_rate = st.number_input("Infiltration Rate (CFM)", min_value=0.0, value=skylight.infiltration_rate_cfm, step=0.1)
+                drapery_color = st.selectbox("Drapery Color", [c.value for c in DraperyColor], index=[c.value for c in DraperyColor].index(skylight.drapery_color))
+                drapery_fullness = st.number_input("Drapery Fullness", min_value=1.0, max_value=2.0, value=skylight.drapery_fullness, step=0.1)
+
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                submitted = st.form_submit_button("Update Skylight")
+            with col2:
+                if st.form_submit_button("Cancel"):
+                    session_state[f"edit_skylight"] = None
+                    st.rerun()
+
+            if submitted:
+                try:
+                    updated_skylight = Skylight(
+                        id=skylight.id, name=name, u_value=u_value, area=area, orientation=Orientation.HORIZONTAL,
+                        shgc=shgc, shading_device=shading_options[shading_device], shading_coefficient=shading_coefficient,
+                        frame_type=frame_type, frame_percentage=frame_percentage, infiltration_rate_cfm=infiltration_rate,
+                        glazing_type=glazing_type, drapery_openness=drapery_openness, drapery_color=drapery_color,
+                        drapery_fullness=drapery_fullness
+                    )
+                    self.component_library.components[skylight.id] = updated_skylight
+                    session_state.components['skylights'][index] = updated_skylight
+                    st.success(f"Updated {updated_skylight.name}")
+                    session_state[f"edit_skylight"] = None
+                    st.rerun()
+                except ValueError as e:
+                    st.error(f"Error: {str(e)}")
 
     def _save_components(self, session_state: Any) -> None:
-        components_dict = {
-            "walls": [c.to_dict() for c in session_state.components["walls"]],
-            "roofs": [c.to_dict() for c in session_state.components["roofs"]],
-            "floors": [c.to_dict() for c in session_state.components["floors"]],
-            "windows": [c.to_dict() for c in session_state.components["windows"]],
-            "doors": [c.to_dict() for c in session_state.components["doors"]],
+        components_data = {
+            "walls": [comp.to_dict() for comp in session_state.components['walls']],
+            "roofs": [comp.to_dict() for comp in session_state.components['roofs']],
+            "floors": [comp.to_dict() for comp in session_state.components['floors']],
+            "windows": [comp.to_dict() for comp in session_state.components['windows']],
+            "doors": [comp.to_dict() for comp in session_state.components['doors']],
+            "skylights": [comp.to_dict() for comp in session_state.components['skylights']],
             "roof_air_volume_m3": session_state.roof_air_volume_m3,
             "roof_ventilation_ach": session_state.roof_ventilation_ach
         }
-        file_path = "components_export.json"
-        with open(file_path, 'w') as f:
-            json.dump(components_dict, f, indent=4)
-        with open(file_path, 'r') as f:
-            st.download_button(label="Download Components", data=f, file_name="components.json", mime="application/json")
-        st.success("Components saved successfully.")
-
-# --- Main Execution ---
+        buffer = io.StringIO()
+        json.dump(components_data, buffer, indent=2)
+        st.download_button(
+            label="Download Components JSON",
+            data=buffer.getvalue(),
+            file_name="components.json",
+            mime="application/json"
+        )
+        st.success("Components saved! Download the JSON file.")
+
+# --- Main Application ---
+def main():
+    st.set_page_config(page_title="HVAC Component Selection", layout="wide")
+    component_selection = ComponentSelectionInterface()
+    component_selection.display_component_selection(st.session_state)
+
 if __name__ == "__main__":
-    interface = ComponentSelectionInterface()
-    interface.display_component_selection(st.session_state)
+    main()