Update app/component_selection.py

app/component_selection.py

@@ -34,12 +34,6 @@ class ComponentType(Enum):
     WINDOW = "Window"
     DOOR = "Door"
 
-class ShadingType(Enum):
-    NONE = "None"
-    INTERNAL = "Internal"
-    EXTERNAL = "External"
-    BETWEEN_GLASS = "Between-glass"
-
 # --- Data Models ---
 @dataclass
 class MaterialLayer:
@@ -55,208 +49,186 @@ class BuildingComponent:
     u_value: float = 0.0  # W/(m²·K)
     area: float = 0.0  # m²
     orientation: Orientation = Orientation.NOT_APPLICABLE
-    material_layers: List[MaterialLayer] = field(default_factory=list)
 
     def __post_init__(self):
-        if self.area < 0:
-            raise ValueError("Area cannot be negative")
-        if self.u_value < 0:
-            raise ValueError("U-value cannot be negative")
+        if self.area <= 0:
+            raise ValueError("Area must be greater than zero")
+        if self.u_value <= 0:
+            raise ValueError("U-value must be greater than zero")
 
     def to_dict(self) -> dict:
         return {
-            "id": self.id,
-            "name": self.name,
-            "component_type": self.component_type.value,
-            "u_value": self.u_value,
-            "area": self.area,
-            "orientation": self.orientation.value,
-            "material_layers": [{"name": l.name, "thickness": l.thickness, "conductivity": l.conductivity} for l in self.material_layers]
+            "id": self.id, "name": self.name, "component_type": self.component_type.value,
+            "u_value": self.u_value, "area": self.area, "orientation": self.orientation.value
         }
 
 @dataclass
 class Wall(BuildingComponent):
     wall_type: str = "Brick"
     wall_group: str = "Wall"
-    shading_percentage: float = 0.0
+    absorptivity: float = 0.6
+    shading_coefficient: float = 1.0
+    infiltration_rate_cfm: float = 0.0
 
     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")
+        if not 0 <= self.absorptivity <= 1:
+            raise ValueError("Absorptivity must be between 0 and 1")
+        if not 0 <= self.shading_coefficient <= 1:
+            raise ValueError("Shading coefficient must be between 0 and 1")
+        if self.infiltration_rate_cfm < 0:
+            raise ValueError("Infiltration rate cannot be negative")
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
-        base_dict.update({"wall_type": self.wall_type, "wall_group": self.wall_group, "shading_percentage": self.shading_percentage})
+        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
+        })
         return base_dict
 
 @dataclass
 class Roof(BuildingComponent):
     roof_type: str = "Concrete"
     roof_group: str = "C"
+    slope: str = "Flat"
+    absorptivity: float = 0.6
 
     def __post_init__(self):
         super().__post_init__()
         self.component_type = ComponentType.ROOF
-        self.orientation = Orientation.HORIZONTAL
+        if not self.orientation == Orientation.HORIZONTAL:
+            self.orientation = Orientation.HORIZONTAL
+        if not 0 <= self.absorptivity <= 1:
+            raise ValueError("Absorptivity must be between 0 and 1")
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
-        base_dict.update({"roof_type": self.roof_type, "roof_group": self.roof_group})
+        base_dict.update({
+            "roof_type": self.roof_type, "roof_group": self.roof_group, "slope": self.slope, "absorptivity": self.absorptivity
+        })
         return base_dict
 
 @dataclass
 class Floor(BuildingComponent):
     floor_type: str = "Concrete"
+    ground_contact: bool = True
+    ground_temperature_c: float = 25.0
 
     def __post_init__(self):
         super().__post_init__()
         self.component_type = ComponentType.FLOOR
-        self.orientation = Orientation.HORIZONTAL
+        self.orientation = Orientation.NOT_APPLICABLE
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
-        base_dict.update({"floor_type": self.floor_type})
+        base_dict.update({
+            "floor_type": self.floor_type, "ground_contact": self.ground_contact, "ground_temperature_c": self.ground_temperature_c
+        })
         return base_dict
 
 @dataclass
 class Window(BuildingComponent):
     shgc: float = 0.7
-    vt: float = 0.7
-    window_type: str = "Double Glazed"
-    glazing_layers: int = 2
-    gas_fill: str = "Air"
-    low_e_coating: bool = False
-    shading_device_id: str = "preset_none"
+    shading_device: str = "None"
+    shading_coefficient: float = 1.0
+    frame_type: str = "Aluminum"
+    frame_percentage: float = 20.0
+    infiltration_rate_cfm: float = 0.0
 
     def __post_init__(self):
         super().__post_init__()
         self.component_type = ComponentType.WINDOW
         if not 0 <= self.shgc <= 1:
             raise ValueError("SHGC must be between 0 and 1")
-        if not 0 <= self.vt <= 1:
-            raise ValueError("VT 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")
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
         base_dict.update({
-            "shgc": self.shgc, "vt": self.vt, "window_type": self.window_type,
-            "glazing_layers": self.glazing_layers, "gas_fill": self.gas_fill,
-            "low_e_coating": self.low_e_coating, "shading_device_id": self.shading_device_id
+            "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
         })
         return base_dict
 
 @dataclass
 class Door(BuildingComponent):
     door_type: str = "Solid Wood"
+    infiltration_rate_cfm: float = 0.0
 
     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")
 
     def to_dict(self) -> dict:
         base_dict = super().to_dict()
-        base_dict.update({"door_type": self.door_type})
+        base_dict.update({"door_type": self.door_type, "infiltration_rate_cfm": self.infiltration_rate_cfm})
         return base_dict
 
-# --- Shading System ---
-@dataclass
-class ShadingDevice:
-    id: str
-    name: str
-    shading_type: ShadingType
-    shading_coefficient: float
-    coverage_percentage: float = 100.0
-    description: str = ""
-
-    def __post_init__(self):
-        if self.shading_coefficient < 0 or self.shading_coefficient > 1:
-            raise ValueError("Shading coefficient must be between 0 and 1")
-        if self.coverage_percentage < 0 or self.coverage_percentage > 100:
-            raise ValueError("Coverage percentage must be between 0 and 100")
-
-    @property
-    def effective_shading_coefficient(self) -> float:
-        coverage_factor = self.coverage_percentage / 100.0
-        return self.shading_coefficient * coverage_factor + 1.0 * (1 - coverage_factor)
-
-    def to_dict(self) -> Dict[str, Any]:
-        return {
-            "id": self.id, "name": self.name, "shading_type": self.shading_type.value,
-            "shading_coefficient": self.shading_coefficient, "coverage_percentage": self.coverage_percentage,
-            "description": self.description, "effective_shading_coefficient": self.effective_shading_coefficient
-        }
-
-class ShadingSystem:
-    def __init__(self):
-        self.shading_devices = {}
-        self.load_preset_devices()
-
-    def load_preset_devices(self) -> None:
-        self.shading_devices["preset_none"] = ShadingDevice(
-            id="preset_none", name="None", shading_type=ShadingType.NONE, shading_coefficient=1.0, description="No shading"
-        )
-        self.shading_devices["preset_venetian_blinds"] = ShadingDevice(
-            id="preset_venetian_blinds", name="Venetian Blinds", shading_type=ShadingType.INTERNAL, shading_coefficient=0.6, description="Standard internal venetian blinds"
-        )
-        self.shading_devices["preset_overhang"] = ShadingDevice(
-            id="preset_overhang", name="Overhang", shading_type=ShadingType.EXTERNAL, shading_coefficient=0.4, description="External overhang"
-        )
-
-    def get_device(self, device_id: str) -> Optional[ShadingDevice]:
-        return self.shading_devices.get(device_id)
-
-    def calculate_effective_shgc(self, base_shgc: float, device_id: str) -> float:
-        device = self.get_device(device_id)
-        if not device:
-            return base_shgc
-        return base_shgc * device.effective_shading_coefficient
-
-shading_system = ShadingSystem()
-
 # --- Reference Data ---
 class ReferenceData:
     def __init__(self):
         self.data = {
             "materials": {
-                "mat_001": {"name": "Concrete", "conductivity": 1.4},
-                "mat_002": {"name": "Insulation", "conductivity": 0.04},
-                "mat_003": {"name": "Brick", "conductivity": 0.8},
-                "mat_004": {"name": "Glass", "conductivity": 1.0},
-                "mat_005": {"name": "Wood", "conductivity": 0.15}
+                "Concrete": {"conductivity": 1.4},
+                "Insulation": {"conductivity": 0.04},
+                "Brick": {"conductivity": 0.8},
+                "Glass": {"conductivity": 1.0},
+                "Wood": {"conductivity": 0.15}
             },
             "wall_types": {
-                "preset_wall_001": {"id": "preset_wall_001", "name": "Brick Wall (Single Layer) (U-value: 2.0 W/m²·K)", "component_type": "Wall", "u_value": 2.0, "area": 0.0, "orientation": "North", "wall_type": "Brick", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_002": {"id": "preset_wall_002", "name": "Insulated Brick Wall (U-value: 0.5 W/m²·K)", "component_type": "Wall", "u_value": 0.5, "area": 0.0, "orientation": "North", "wall_type": "Insulated Brick", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_003": {"id": "preset_wall_003", "name": "Concrete Block Wall (U-value: 1.8 W/m²·K)", "component_type": "Wall", "u_value": 1.8, "area": 0.0, "orientation": "North", "wall_type": "Concrete Block", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_004": {"id": "preset_wall_004", "name": "Insulated Concrete Wall (U-value: 0.4 W/m²·K)", "component_type": "Wall", "u_value": 0.4, "area": 0.0, "orientation": "North", "wall_type": "Insulated Concrete", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_005": {"id": "preset_wall_005", "name": "Timber Frame Wall (U-value: 0.3 W/m²·K)", "component_type": "Wall", "u_value": 0.3, "area": 0.0, "orientation": "North", "wall_type": "Timber Frame", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_006": {"id": "preset_wall_006", "name": "Cavity Wall (Brick + Insulation) (U-value: 0.6 W/m²·K)", "component_type": "Wall", "u_value": 0.6, "area": 0.0, "orientation": "North", "wall_type": "Cavity Brick", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_007": {"id": "preset_wall_007", "name": "Lightweight Panel Wall (U-value: 1.0 W/m²·K)", "component_type": "Wall", "u_value": 1.0, "area": 0.0, "orientation": "North", "wall_type": "Lightweight Panel", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_008": {"id": "preset_wall_008", "name": "Reinforced Concrete Wall (U-value: 1.5 W/m²·K)", "component_type": "Wall", "u_value": 1.5, "area": 0.0, "orientation": "North", "wall_type": "Reinforced Concrete", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_009": {"id": "preset_wall_009", "name": "SIP Wall (Structural Insulated Panel) (U-value: 0.25 W/m²·K)", "component_type": "Wall", "u_value": 0.25, "area": 0.0, "orientation": "North", "wall_type": "SIP", "wall_group": "Wall", "shading_percentage": 0.0},
-                "preset_wall_010": {"id": "preset_wall_010", "name": "Custom Wall (U-value: 0.5 W/m²·K)", "component_type": "Wall", "u_value": 0.5, "area": 0.0, "orientation": "North", "wall_type": "Custom", "wall_group": "Wall", "shading_percentage": 0.0}
+                "Brick Wall": {"u_value": 2.0, "absorptivity": 0.6},
+                "Insulated Brick": {"u_value": 0.5, "absorptivity": 0.6},
+                "Concrete Block": {"u_value": 1.8, "absorptivity": 0.6},
+                "Insulated Concrete": {"u_value": 0.4, "absorptivity": 0.6},
+                "Timber Frame": {"u_value": 0.3, "absorptivity": 0.6},
+                "Cavity Brick": {"u_value": 0.6, "absorptivity": 0.6},
+                "Lightweight Panel": {"u_value": 1.0, "absorptivity": 0.6},
+                "Reinforced Concrete": {"u_value": 1.5, "absorptivity": 0.6},
+                "SIP": {"u_value": 0.25, "absorptivity": 0.6},
+                "Custom": {"u_value": 0.5, "absorptivity": 0.6}
             },
             "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"}
+                "Concrete Roof": {"u_value": 0.3, "absorptivity": 0.6, "group": "C"},
+                "Metal Roof": {"u_value": 1.0, "absorptivity": 0.75, "group": "B"}
+            },
+            "roof_ventilation_methods": {
+                "No Ventilation": 0.0,
+                "Natural Low": 0.1,
+                "Natural High": 0.5,
+                "Mechanical": 1.0
             },
             "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"}
+                "Concrete Slab": {"u_value": 0.4, "ground_contact": True},
+                "Wood Floor": {"u_value": 0.8, "ground_contact": False}
             },
             "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"}
+                "Double Glazed": {"u_value": 2.8, "shgc": 0.7, "frame_type": "Aluminum"},
+                "Single Glazed": {"u_value": 5.0, "shgc": 0.9, "frame_type": "Wood"}
+            },
+            "shading_devices": {
+                "None": 1.0,
+                "Venetian Blinds": 0.6,
+                "Overhang": 0.4,
+                "Roller Shades": 0.5,
+                "Drapes": 0.7
             },
             "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"}
+                "Solid Wood": {"u_value": 2.0},
+                "Glass Door": {"u_value": 3.5}
             }
         }
 
     def get_materials(self) -> List[Dict[str, Any]]:
-        return list(self.data["materials"].values())
-
-    def get_component_data(self, component_type: str) -> Dict[str, Any]:
-        return self.data.get(f"{component_type.lower()}_types", {})
+        return [{"name": k, "conductivity": v["conductivity"]} for k, v in self.data["materials"].items()]
 
 reference_data = ReferenceData()
 
@@ -264,40 +236,12 @@ reference_data = ReferenceData()
 class ComponentLibrary:
     def __init__(self):
         self.components = {}
-        self._load_preset_components()
-
-    def _load_preset_components(self):
-        for type_key in ["wall_types", "roof_types", "floor_types", "window_types", "door_types"]:
-            for component_data in reference_data.data[type_key].values():
-                component_data["orientation"] = Orientation(component_data["orientation"])
-                if component_data["component_type"] == ComponentType.WALL.value:
-                    component = Wall(**component_data)
-                elif component_data["component_type"] == ComponentType.ROOF.value:
-                    component = Roof(**component_data)
-                elif component_data["component_type"] == ComponentType.FLOOR.value:
-                    component = Floor(**component_data)
-                elif component_data["component_type"] == ComponentType.WINDOW.value:
-                    component = Window(**component_data)
-                elif component_data["component_type"] == ComponentType.DOOR.value:
-                    component = Door(**component_data)
-                self.components[component.id] = component
-
-    def get_component(self, component_id: str) -> BuildingComponent:
-        return self.components.get(component_id)
-
-    def get_preset_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
-        return [comp for comp in self.components.values() if comp.component_type == component_type and comp.id.startswith("preset_")]
 
     def add_component(self, component: BuildingComponent):
         self.components[component.id] = component
 
-    def update_component(self, component_id: str, component: BuildingComponent):
-        self.components[component_id] = component
-
     def remove_component(self, component_id: str):
-        if component_id.startswith("preset_"):
-            raise ValueError("Cannot remove preset components")
-        if component_id in self.components:
+        if not component_id.startswith("preset_") and component_id in self.components:
             del self.components[component_id]
 
 component_library = ComponentLibrary()
@@ -307,14 +251,9 @@ class UValueCalculator:
     def __init__(self):
         self.materials = reference_data.get_materials()
 
-    def get_preset_materials(self) -> List[Dict[str, Any]]:
-        return self.materials
-
-    def calculate_u_value(self, layers: List[Dict[str, float]]) -> float:
-        r_outside = 0.04  # m²·K/W
-        r_inside = 0.13  # m²·K/W
+    def calculate_u_value(self, layers: List[Dict[str, float]], outside_resistance: float, inside_resistance: float) -> float:
         r_layers = sum(layer["thickness"] / 1000 / layer["conductivity"] for layer in layers)
-        r_total = r_outside + r_layers + r_inside
+        r_total = outside_resistance + r_layers + inside_resistance
         return 1 / r_total if r_total > 0 else 0
 
 u_value_calculator = UValueCalculator()
@@ -324,7 +263,6 @@ class ComponentSelectionInterface:
     def __init__(self):
         self.component_library = component_library
         self.u_value_calculator = u_value_calculator
-        self.shading_system = shading_system
         self.reference_data = reference_data
 
     def display_component_selection(self, session_state: Any) -> None:
@@ -332,7 +270,11 @@ class ComponentSelectionInterface:
         
         if 'components' not in session_state:
             session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
-        
+        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"])
         
         with tabs[0]:
@@ -348,489 +290,451 @@ class ComponentSelectionInterface:
         with tabs[5]:
             self._display_u_value_calculator_tab(session_state)
         
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("Save Components"):
-                self._save_components(session_state)
-        with col2:
-            uploaded_file = st.file_uploader("Load Components", type=["json"])
-            if uploaded_file and st.button("Load Uploaded Components"):
-                self._load_components(session_state, uploaded_file)
+        if st.button("Save Components"):
+            self._save_components(session_state)
 
     def _display_component_tab(self, session_state: Any, component_type: ComponentType) -> None:
         type_name = component_type.value.lower()
         st.subheader(f"{type_name.capitalize()} Components")
         
-        with st.expander(f"Add {type_name.capitalize()}", expanded=False):
+        with st.expander(f"Add {type_name.capitalize()}", expanded=True):
             if component_type == ComponentType.WALL:
                 self._display_add_wall_form(session_state)
-            else:
-                self._display_add_component_form(session_state, component_type)
+            elif component_type == ComponentType.ROOF:
+                self._display_add_roof_form(session_state)
+            elif component_type == ComponentType.FLOOR:
+                self._display_add_floor_form(session_state)
+            elif component_type == ComponentType.WINDOW:
+                self._display_add_window_form(session_state)
+            elif component_type == ComponentType.DOOR:
+                self._display_add_door_form(session_state)
         
         components = session_state.components.get(type_name + 's', [])
-        if components:
+        if components or component_type == ComponentType.ROOF:
             st.subheader(f"Existing {type_name.capitalize()} Components")
             self._display_components_table(session_state, component_type, components)
 
     def _display_add_wall_form(self, session_state: Any) -> None:
         st.write("Add walls manually or upload a file.")
-        wall_method = st.radio("Add Wall Method", ["Manual Entry", "File Upload"])
-        
-        if wall_method == "Manual Entry":
-            if "add_wall_submitted" not in session_state:
-                session_state.add_wall_submitted = False
-            
+        method = st.radio("Add Wall Method", ["Manual Entry", "File Upload"])
+        if "add_wall_submitted" not in session_state:
+            session_state.add_wall_submitted = False
+
+        if method == "Manual Entry":
             with st.form("add_wall_form", clear_on_submit=True):
                 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)
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation if o != Orientation.HORIZONTAL and o != Orientation.NOT_APPLICABLE], 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()), key="wall_type_select")
-                    component = wall_options[selected_wall]
-                    if "prev_selected_wall" not in session_state or session_state.prev_selected_wall != selected_wall:
-                        session_state.prev_selected_wall = selected_wall
-                        session_state.u_value = component.u_value
-                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, max_value=9.0, value=float(session_state.u_value), step=0.01, key=f"u_value_{selected_wall}")
-                    shading_percentage = st.slider("Shading Percentage (%)", min_value=0.0, max_value=100.0, value=0.0, step=5.0)
-                
+                    wall_options = self.reference_data.data["wall_types"]
+                    selected_wall = st.selectbox("Wall Type", options=list(wall_options.keys()))
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=float(wall_options[selected_wall]["u_value"]), step=0.01)
+                    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)
+
                 submitted = st.form_submit_button("Add Wall")
                 if submitted and not session_state.add_wall_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:
+                    try:
+                        absorptivity_value = float(absorptivity.split("(")[1].strip(")"))
                         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="Wall", shading_percentage=shading_percentage
+                            name=name, u_value=u_value, area=area, orientation=Orientation(orientation),
+                            wall_type=selected_wall, wall_group="Wall", absorptivity=absorptivity_value,
+                            shading_coefficient=shading_coefficient, infiltration_rate_cfm=infiltration_rate
                         )
                         self.component_library.add_component(new_wall)
                         session_state.components['walls'].append(new_wall)
                         st.success(f"Added {new_wall.name}")
                         session_state.add_wall_submitted = True
                         st.rerun()
-            
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
             if session_state.add_wall_submitted:
                 session_state.add_wall_submitted = False
-        
-        elif wall_method == "File Upload":
-            st.info("Upload a CSV or Excel file with columns: Name, Area (m²), U-Value (W/m²·K), Orientation, Wall Type, Wall Group, Shading (%)")
-            # Use a unique key for the file uploader to allow clearing
-            if "file_uploaded" not in session_state:
-                session_state.file_uploaded = False
-            if "uploaded_file_key" not in session_state:
-                session_state.uploaded_file_key = 0
-
-            uploaded_file = st.file_uploader("Upload Walls File", type=["csv", "xlsx"], key=f"wall_upload_{session_state.uploaded_file_key}")
-            required_cols = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Shading (%)"]
-            
-            if uploaded_file and st.button("Process File"):
-                try:
-                    if uploaded_file.name.endswith('.csv'):
-                        encodings = ['utf-8', 'latin1', 'windows-1252']
-                        df = None
-                        for encoding in encodings:
-                            try:
-                                uploaded_file.seek(0)
-                                df = pd.read_csv(uploaded_file, encoding=encoding)
-                                break
-                            except UnicodeDecodeError:
-                                continue
-                        if df is None:
-                            raise UnicodeDecodeError("Unable to decode CSV file with available encodings.")
-                    else:  # .xlsx
-                        df = pd.read_excel(uploaded_file)
-                    
-                    # Normalize column names
-                    df.columns = [col.strip() for col in df.columns]
-                    if "Group" in df.columns and "Wall Group" not in df.columns:
-                        df.rename(columns={"Group": "Wall Group"}, inplace=True)
-                    if not all(col in df.columns for col in required_cols):
-                        st.error(f"File must contain all required columns: {', '.join(required_cols)}")
-                    else:
-                        # Overwrite existing walls
-                        session_state.components['walls'] = []
-                        for comp_id in list(self.component_library.components.keys()):
-                            if not comp_id.startswith("preset_") and self.component_library.components[comp_id].component_type == ComponentType.WALL:
-                                self.component_library.remove_component(comp_id)
-                        for _, row in df.iterrows():
-                            try:
-                                new_wall = Wall(
-                                    id=str(uuid.uuid4()), 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=str(row["Wall Group"]),
-                                    shading_percentage=float(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 and overwritten successfully!")
-                        # Clear the file uploader by incrementing the key
-                        session_state.uploaded_file_key += 1
-                        session_state.file_uploaded = True
-                except Exception as e:
-                    st.error(f"Error processing file: {str(e)}")
-            
-            # Provide a downloadable template
-            template_df = pd.DataFrame(columns=required_cols)
-            buffer = io.BytesIO()
-            template_df.to_csv(buffer, index=False, encoding='utf-8')
-            st.download_button(
-                label="Download Wall Template (CSV)",
-                data=buffer.getvalue(),
-                file_name="wall_template.csv",
-                mime="text/csv"
-            )
-
-    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)
-        
-        if f"add_{type_name}_submitted" not in session_state:
-            session_state[f"add_{type_name}_submitted"] = False
-        
-        with st.form(f"add_{type_name}_form", clear_on_submit=True):
-            col1, col2 = st.columns(2)
-            with col1:
-                name = st.text_input("Name", f"New {type_name.capitalize()}")
-                area = st.number_input("Area (m²)", min_value=0.0, value=1.0, step=0.1)
-                if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
-                    orientation = st.selectbox("Orientation", [o.value for o in Orientation], index=0)
+
+        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)"]
+            st.download_button(label="Download Wall Template", data=pd.DataFrame(columns=required_cols).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):
+                    for _, row in df.iterrows():
+                        try:
+                            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=str(row["Wall Group"]), absorptivity=float(row["Absorptivity"]),
+                                shading_coefficient=float(row["Shading Coefficient"]), infiltration_rate_cfm=float(row["Infiltration Rate (CFM)"])
+                            )
+                            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()
                 else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_roof_form(self, session_state: Any) -> None:
+        st.write("Add roofs manually or upload a file.")
+        method = st.radio("Add Roof Method", ["Manual Entry", "File Upload"])
+        if "add_roof_submitted" not in session_state:
+            session_state.add_roof_submitted = False
+
+        # Shared Roof-Level Fields
+        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
-            
-            with col2:
-                selection_method = st.radio(f"{type_name.capitalize()} Selection Method", ["Select from Presets", "Custom Properties"])
-                if selection_method == "Select from Presets" and preset_components:
-                    preset_options = {comp.name: comp.id for comp in preset_components}
-                    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.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:
-                        st.text_input("Floor Type", value=component.floor_type, disabled=True)
-                    elif component_type == ComponentType.WINDOW:
-                        st.number_input("SHGC", value=component.shgc, disabled=True)
-                        st.number_input("VT", value=component.vt, disabled=True)
-                        st.text_input("Window Type", value=component.window_type, disabled=True)
-                    elif component_type == ComponentType.DOOR:
-                        st.text_input("Door Type", value=component.door_type, disabled=True)
+                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", ["A", "B", "C", "D", "E", "F", "G"], index=2)
+                    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)
+
+                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
+                        )
+                        self.component_library.add_component(new_roof)
+                        session_state.components['roofs'].append(new_roof)
+                        st.success(f"Added {new_roof.name}")
+                        session_state.add_roof_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_roof_submitted:
+                session_state.add_roof_submitted = False
+
+        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"]
+            st.download_button(label="Download Roof Template", data=pd.DataFrame(columns=required_cols).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):
+                    for _, row in df.iterrows():
+                        try:
+                            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=str(row["Roof Group"]), slope=str(row["Slope"]), absorptivity=float(row["Absorptivity"])
+                            )
+                            self.component_library.add_component(new_roof)
+                            session_state.components['roofs'].append(new_roof)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Roofs uploaded successfully!")
+                    st.rerun()
                 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.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:
-                        floor_type = st.text_input("Floor Type", "Custom")
-                    elif component_type == ComponentType.WINDOW:
-                        shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
-                        vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=0.7, step=0.01)
-                        window_type = st.text_input("Window Type", "Custom")
-                        glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=1)
-                        gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], index=0)
-                        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)
-                    elif component_type == ComponentType.DOOR:
-                        door_type = st.text_input("Door Type", "Custom")
-            
-            submitted = st.form_submit_button("Add Component")
-            if submitted and not session_state[f"add_{type_name}_submitted"]:
-                if not name:
-                    st.error(f"{type_name.capitalize()} name is required!")
-                elif area <= 0:
-                    st.error(f"{type_name.capitalize()} area must be greater than zero!")
-                elif u_value <= 0:
-                    st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_floor_form(self, session_state: Any) -> None:
+        st.write("Add floors manually or upload a file.")
+        method = st.radio("Add Floor Method", ["Manual Entry", "File Upload"])
+        if "add_floor_submitted" not in session_state:
+            session_state.add_floor_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_floor_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                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)
+                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)", value=25.0, step=0.1) if ground_contact == "Yes" else 25.0
+
+                submitted = st.form_submit_button("Add Floor")
+                if submitted and not session_state.add_floor_submitted:
+                    try:
+                        new_floor = Floor(
+                            name=name, u_value=u_value, area=area, floor_type=selected_floor,
+                            ground_contact=(ground_contact == "Yes"), ground_temperature_c=ground_temp
+                        )
+                        self.component_library.add_component(new_floor)
+                        session_state.components['floors'].append(new_floor)
+                        st.success(f"Added {new_floor.name}")
+                        session_state.add_floor_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_floor_submitted:
+                session_state.add_floor_submitted = False
+
+        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)"]
+            st.download_button(label="Download Floor Template", data=pd.DataFrame(columns=required_cols).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):
+                    for _, row in df.iterrows():
+                        try:
+                            new_floor = Floor(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                floor_type=str(row["Floor Type"]), ground_contact=(str(row["Ground Contact"]).lower() == "yes"),
+                                ground_temperature_c=float(row["Ground Temperature (°C)"])
+                            )
+                            self.component_library.add_component(new_floor)
+                            session_state.components['floors'].append(new_floor)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Floors uploaded successfully!")
+                    st.rerun()
                 else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_window_form(self, session_state: Any) -> None:
+        st.write("Add windows manually or upload a file.")
+        method = st.radio("Add Window Method", ["Manual Entry", "File Upload"])
+        if "add_window_submitted" not in session_state:
+            session_state.add_window_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_window_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    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()))
+                    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)
+                    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)
+
+                submitted = st.form_submit_button("Add Window")
+                if submitted and not session_state.add_window_submitted:
                     try:
-                        if selection_method == "Select from Presets" and preset_components:
-                            component_id = preset_options[selected_preset]
-                            component = self.component_library.get_component(component_id)
-                            preset_attrs = component.__dict__.copy()
-                            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
+                        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
+                        )
+                        self.component_library.add_component(new_window)
+                        session_state.components['windows'].append(new_window)
+                        st.success(f"Added {new_window.name}")
+                        session_state.add_window_submitted = True
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
+
+            if session_state.add_window_submitted:
+                session_state.add_window_submitted = False
+
+        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")
+            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_window = Window(
+                                name=str(row["Name"]), u_value=float(row["U-Value (W/m²·K)"]), area=float(row["Area (m²)"]),
+                                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)"])
                             )
-                        else:
-                            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
-                                )
-                            elif component_type == ComponentType.FLOOR:
-                                new_component = Floor(
-                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                    orientation=Orientation(orientation), floor_type=floor_type
-                                )
-                            elif component_type == ComponentType.WINDOW:
-                                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,
-                                    shading_device_id=shading_options[shading_device]
-                                )
-                            elif component_type == ComponentType.DOOR:
-                                new_component = Door(
-                                    id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
-                                    orientation=Orientation(orientation), door_type=door_type
-                                )
-                        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
+                            self.component_library.add_component(new_window)
+                            session_state.components['windows'].append(new_window)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Windows uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
+
+    def _display_add_door_form(self, session_state: Any) -> None:
+        st.write("Add doors manually or upload a file.")
+        method = st.radio("Add Door Method", ["Manual Entry", "File Upload"])
+        if "add_door_submitted" not in session_state:
+            session_state.add_door_submitted = False
+
+        if method == "Manual Entry":
+            with st.form("add_door_form", clear_on_submit=True):
+                col1, col2 = st.columns(2)
+                with col1:
+                    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)
+                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)
+
+                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
+                        )
+                        self.component_library.add_component(new_door)
+                        session_state.components['doors'].append(new_door)
+                        st.success(f"Added {new_door.name}")
+                        session_state.add_door_submitted = True
                         st.rerun()
                     except ValueError as e:
                         st.error(f"Error: {str(e)}")
-        
-        if session_state[f"add_{type_name}_submitted"]:
-            session_state[f"add_{type_name}_submitted"] = False
+
+            if session_state.add_door_submitted:
+                session_state.add_door_submitted = False
+
+        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")
+            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_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)"])
+                            )
+                            self.component_library.add_component(new_door)
+                            session_state.components['doors'].append(new_door)
+                        except ValueError as e:
+                            st.error(f"Error in row {row['Name']}: {str(e)}")
+                    st.success("Doors uploaded successfully!")
+                    st.rerun()
+                else:
+                    st.error(f"File must contain: {', '.join(required_cols)}")
 
     def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[BuildingComponent]) -> None:
         type_name = component_type.value.lower()
-        data = []
-        for comp in components:
-            row = {"Name": comp.name, "Area (m²)": comp.area, "U-Value (W/m²·K)": comp.u_value, "Orientation": comp.orientation.value, "ID": comp.id}
-            if component_type == ComponentType.WALL:
-                row.update({"Wall Type": comp.wall_type, "Wall Group": comp.wall_group, "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:
-                row.update({"Floor Type": comp.floor_type})
-            elif component_type == ComponentType.WINDOW:
-                row.update({"SHGC": comp.shgc, "VT": comp.vt, "Window Type": comp.window_type,
-                           "Effective SHGC": self.shading_system.calculate_effective_shgc(comp.shgc, comp.shading_device_id)})
-            elif component_type == ComponentType.DOOR:
-                row.update({"Door Type": comp.door_type})
-            data.append(row)
-        
-        df = pd.DataFrame(data)
-        display_cols = [col for col in df.columns if col != "ID"]
-        
-        if component_type == ComponentType.WALL:
-            # Custom table rendering for walls with delete button in the row
-            st.write("### Walls Table")
-            # Display headers
-            headers = ["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Shading (%)", "Delete"]
-            cols = st.columns([1, 1, 1, 1, 1, 1, 1, 1])
+        if component_type == ComponentType.ROOF:
+            st.write(f"Roof Air Volume: {session_state.roof_air_volume_m3} m³, Ventilation Rate: {session_state.roof_ventilation_ach} ACH")
+
+        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)", "Delete"],
+                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"]
+            }[component_type]
+            cols = st.columns([1] * len(headers))
             for i, header in enumerate(headers):
                 cols[i].write(f"**{header}**")
-            
-            # Display rows
-            for i, row in df.iterrows():
-                cols = st.columns([1, 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['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 (excluding Delete column)
-            csv_df = df[["Name", "Area (m²)", "U-Value (W/m²·K)", "Orientation", "Wall Type", "Wall Group", "Shading (%)"]]
-            csv_buffer = io.BytesIO()
-            csv_df.to_csv(csv_buffer, index=False, encoding='utf-8')
-            st.download_button(label="Download Walls Table", data=csv_buffer.getvalue(), 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 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}"]
 
-    def _display_edit_component_form(self, session_state: Any, component_type: ComponentType, component_id: str) -> None:
-        type_name = component_type.value.lower()
-        component = next((c for c in session_state.components[type_name + 's'] if c.id == component_id), None)
-        if not component:
-            st.error("Component not found.")
-            return
-        
-        with st.form(f"edit_{component_id}_form"):
-            col1, col2 = st.columns(2)
-            with col1:
-                name = st.text_input("Name", value=component.name)
-                area = st.number_input("Area (m²)", min_value=0.0, value=component.area, step=0.1)
-                if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
-                    orientation = st.selectbox("Orientation", [o.value for o in Orientation], 
-                                             index=[o.value for o in Orientation].index(component.orientation.value))
-                else:
-                    orientation = Orientation.HORIZONTAL.value
-            
-            with col2:
-                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=component.u_value, step=0.01)
-                if component_type == ComponentType.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))
+            for comp in 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[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)
+                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)
                 elif component_type == ComponentType.FLOOR:
-                    floor_type = st.text_input("Floor Type", value=component.floor_type)
+                    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")
                 elif component_type == ComponentType.WINDOW:
-                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=component.shgc, step=0.01)
-                    vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=component.vt, step=0.01)
-                    window_type = st.text_input("Window Type", value=component.window_type)
-                    glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=[1, 2, 3].index(component.glazing_layers))
-                    gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], 
-                                          index=["Air", "Argon", "Krypton"].index(component.gas_fill))
-                    low_e_coating = st.checkbox("Low-E Coating", value=component.low_e_coating)
-                    shading_options = {d.name: d.id for d in self.shading_system.shading_devices.values()}
-                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), 
-                                                index=list(shading_options.keys()).index(self.shading_system.get_device(component.shading_device_id).name))
+                    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)
                 elif component_type == ComponentType.DOOR:
-                    door_type = st.text_input("Door Type", value=component.door_type)
-            
-            submitted = st.form_submit_button("Update Component")
-            if submitted:
-                if not name:
-                    st.error(f"{type_name.capitalize()} name is required!")
-                elif area <= 0:
-                    st.error(f"{type_name.capitalize()} area must be greater than zero!")
-                elif u_value <= 0:
-                    st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
-                else:
-                    component.name = name
-                    component.area = area
-                    component.u_value = u_value
-                    component.orientation = Orientation(orientation)
-                    if component_type == ComponentType.ROOF:
-                        component.roof_type = roof_type
-                        component.roof_group = roof_group
-                    elif component_type == ComponentType.FLOOR:
-                        component.floor_type = floor_type
-                    elif component_type == ComponentType.WINDOW:
-                        component.shgc = shgc
-                        component.vt = vt
-                        component.window_type = window_type
-                        component.glazing_layers = glazing_layers
-                        component.gas_fill = gas_fill
-                        component.low_e_coating = low_e_coating
-                        component.shading_device_id = shading_options[shading_device]
-                    elif component_type == ComponentType.DOOR:
-                        component.door_type = door_type
-                    self.component_library.update_component(component_id, component)
-                    st.success(f"Updated {name}")
+                    cols[4].write(comp.door_type)
+                    cols[5].write(comp.infiltration_rate_cfm)
+                if cols[-1].button("Delete", key=f"delete_{comp.id}"):
+                    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}")
                     st.rerun()
 
     def _display_u_value_calculator_tab(self, session_state: Any) -> None:
-        st.subheader("U-Value Calculator")
-        
-        if "material_layers" not in session_state:
-            session_state.material_layers = []
-        
-        if "u_value_applied" not in session_state:
-            session_state.u_value_applied = False
-        
-        components = []
-        for type_name in ['walls', 'roofs', 'floors', 'windows', 'doors']:
-            components.extend(session_state.components[type_name])
-        
-        if not components:
-            st.warning("No components available. Add components first.")
-            return
-        
-        selected_component = st.selectbox("Select Component", options=[c.name for c in components])
-        component = next((c for c in components if c.name == selected_component), None)
-        if not component:
-            st.error("Component not found.")
-            return
-        
-        if session_state.material_layers:
-            st.write("Current Material Layers (outside to inside):")
+        st.subheader("U-Value Calculator (Standalone)")
+        if "u_value_layers" not in session_state:
+            session_state.u_value_layers = []
+
+        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.material_layers)]
-            st.dataframe(pd.DataFrame(layer_data), use_container_width=True)
-            
-            u_value = self.u_value_calculator.calculate_u_value(session_state.material_layers)
-            
-            col1, col2, col3 = st.columns(3)
-            with col1:
-                st.metric("Total R-Value", f"{1/u_value if u_value > 0 else 0:.3f} m²·K/W")
-            with col2:
-                st.metric("U-Value", f"{u_value:.3f} W/m²·K")
-            with col3:
-                if st.button("Use This U-Value") and not session_state.u_value_applied:
-                    component.u_value = u_value
-                    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
-                    st.rerun()
-        
-        if session_state.u_value_applied:
-            session_state.u_value_applied = False
-        
-        with st.form("material_layer_form"):
+                           "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"):
             col1, col2 = st.columns(2)
             with col1:
-                material_selection = st.radio("Material Selection", ["Select from Presets", "Custom Material"])
-                if material_selection == "Select from Presets":
-                    preset_materials = self.u_value_calculator.get_preset_materials()
-                    material_options = {m["name"]: m for m in preset_materials}
-                    material_name = st.selectbox("Material", options=list(material_options.keys()))
-                    conductivity = material_options[material_name]["conductivity"]
-                    st.number_input("Conductivity (W/m·K)", value=conductivity, disabled=True)
-                else:
-                    material_name = st.text_input("Material Name", "Custom Material")
-                    conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=1.0, step=0.01)
-            
+                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)
             with col2:
                 thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
-                if conductivity > 0:
-                    r_value = thickness / 1000 / conductivity
-                    st.metric("Layer R-Value", f"{r_value:.3f} m²·K/W")
-            
             submitted = st.form_submit_button("Add Layer")
             if submitted:
-                if not material_name:
-                    st.error("Material name is required!")
-                elif thickness <= 0:
-                    st.error("Thickness must be greater than zero!")
-                elif conductivity <= 0:
-                    st.error("Conductivity must be greater than zero!")
-                else:
-                    session_state.material_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
-                    st.success(f"Added layer: {material_name}")
+                session_state.u_value_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
+                st.rerun()
+
+        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()
                     st.rerun()
-        
-        if st.button("Remove Last Layer"):
-            if session_state.material_layers:
-                session_state.material_layers.pop()
+        with col2:
+            if st.button("Reset"):
+                session_state.u_value_layers = []
                 st.rerun()
 
     def _save_components(self, session_state: Any) -> None:
@@ -839,7 +743,9 @@ class ComponentSelectionInterface:
             "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"]]
+            "doors": [c.to_dict() for c in session_state.components["doors"]],
+            "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:
@@ -848,27 +754,6 @@ class ComponentSelectionInterface:
             st.download_button(label="Download Components", data=f, file_name="components.json", mime="application/json")
         st.success("Components saved successfully.")
 
-    def _load_components(self, session_state: Any, uploaded_file: Any) -> None:
-        data = json.load(uploaded_file)
-        session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
-        for type_name in data:
-            for comp_dict in data[type_name]:
-                comp_dict["orientation"] = Orientation(comp_dict["orientation"])
-                if type_name == "walls":
-                    comp = Wall(**comp_dict)
-                elif type_name == "roofs":
-                    comp = Roof(**comp_dict)
-                elif type_name == "floors":
-                    comp = Floor(**comp_dict)
-                elif type_name == "windows":
-                    comp = Window(**comp_dict)
-                elif type_name == "doors":
-                    comp = Door(**comp_dict)
-                self.component_library.add_component(comp)
-                session_state.components[type_name].append(comp)
-        st.success("Loaded components successfully.")
-        st.rerun()
-
 # --- Main Execution ---
 if __name__ == "__main__":
     interface = ComponentSelectionInterface()