Update data/building_components.py

data/building_components.py

@@ -1,16 +1,19 @@
 """
-Building component data models for HVAC Load Calculator.
-This module defines the data structures for walls, roofs, floors, windows, doors, and other building components.
+HVAC Component Selection Module
+Combines all components into a single Streamlit UI with 6 tabs.
 """
 
+import streamlit as st
+import pandas as pd
+import numpy as np
+import json
+import uuid
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import List, Dict, Optional, Union
-import numpy as np
-
+from typing import Dict, List, Any, Optional
 
+# --- Enums ---
 class Orientation(Enum):
-    """Enumeration for building component orientations."""
     NORTH = "North"
     NORTHEAST = "Northeast"
     EAST = "East"
@@ -19,130 +22,46 @@ class Orientation(Enum):
     SOUTHWEST = "Southwest"
     WEST = "West"
     NORTHWEST = "Northwest"
-    HORIZONTAL = "Horizontal"  # For roofs and floors
-    NOT_APPLICABLE = "N/A"  # For components without orientation
-
+    HORIZONTAL = "Horizontal"
+    NOT_APPLICABLE = "N/A"
 
 class ComponentType(Enum):
-    """Enumeration for building component types."""
     WALL = "Wall"
     ROOF = "Roof"
     FLOOR = "Floor"
     WINDOW = "Window"
     DOOR = "Door"
-    SKYLIGHT = "Skylight"
 
+class ShadingType(Enum):
+    NONE = "None"
+    INTERNAL = "Internal"
+    EXTERNAL = "External"
+    BETWEEN_GLASS = "Between-glass"
 
+# --- Data Models ---
+@dataclass
 class MaterialLayer:
-    """Class representing a single material layer in a building component."""
-    
-    def __init__(self, name: str, thickness: float, conductivity: float, 
-                 density: float = None, specific_heat: float = None):
-        """
-        Initialize a material layer.
-        
-        Args:
-            name: Name of the material
-            thickness: Thickness of the layer in meters
-            conductivity: Thermal conductivity in W/(m·K)
-            density: Density in kg/m³ (optional)
-            specific_heat: Specific heat capacity in J/(kg·K) (optional)
-        """
-        self.name = name
-        self.thickness = thickness  # m
-        self.conductivity = conductivity  # W/(m·K)
-        self.density = density  # kg/m³
-        self.specific_heat = specific_heat  # J/(kg·K)
-    
-    @property
-    def r_value(self) -> float:
-        """Calculate the thermal resistance (R-value) of the layer in m²·K/W."""
-        if self.conductivity == 0:
-            return float('inf')  # Avoid division by zero
-        return self.thickness / self.conductivity
-    
-    @property
-    def thermal_mass(self) -> Optional[float]:
-        """Calculate the thermal mass of the layer in J/(m²·K)."""
-        if self.density is None or self.specific_heat is None:
-            return None
-        return self.thickness * self.density * self.specific_heat
-    
-    def to_dict(self) -> Dict:
-        """Convert the material layer to a dictionary."""
-        return {
-            "name": self.name,
-            "thickness": self.thickness,
-            "conductivity": self.conductivity,
-            "density": self.density,
-            "specific_heat": self.specific_heat,
-            "r_value": self.r_value,
-            "thermal_mass": self.thermal_mass
-        }
-
+    name: str
+    thickness: float  # in mm
+    conductivity: float  # W/(m·K)
 
 @dataclass
 class BuildingComponent:
-    """Base class for all building components."""
-    
-    id: str
-    name: str
-    component_type: ComponentType
-    u_value: float  # W/(m²·K)
-    area: float  # m²
+    id: str = field(default_factory=lambda: str(uuid.uuid4()))
+    name: str = "Unnamed Component"
+    component_type: ComponentType = ComponentType.WALL
+    u_value: float = 0.0  # W/(m²·K)
+    area: float = 0.0  # m²
     orientation: Orientation = Orientation.NOT_APPLICABLE
-    color: str = "Medium"  # Light, Medium, Dark
     material_layers: List[MaterialLayer] = field(default_factory=list)
-    
+
     def __post_init__(self):
-        """Validate component data after initialization."""
-        if self.area <= 0:
-            raise ValueError("Area must be greater than zero")
+        if self.area < 0:
+            raise ValueError("Area cannot be negative")
         if self.u_value < 0:
             raise ValueError("U-value cannot be negative")
-    
-    @property
-    def r_value(self) -> float:
-        """Calculate the total thermal resistance (R-value) in m²·K/W."""
-        return 1 / self.u_value if self.u_value > 0 else float('inf')
-    
-    @property
-    def total_r_value_from_layers(self) -> Optional[float]:
-        """Calculate the total R-value from material layers if available."""
-        if not self.material_layers:
-            return None
-        
-        # Add surface resistances (interior and exterior)
-        r_si = 0.13  # m²·K/W (interior surface resistance)
-        r_se = 0.04  # m²·K/W (exterior surface resistance)
-        
-        # Sum the R-values of all layers
-        r_layers = sum(layer.r_value for layer in self.material_layers)
-        
-        return r_si + r_layers + r_se
-    
-    @property
-    def calculated_u_value(self) -> Optional[float]:
-        """Calculate U-value from material layers if available."""
-        total_r = self.total_r_value_from_layers
-        if total_r is None or total_r == 0:
-            return None
-        return 1 / total_r
-    
-    def heat_transfer_rate(self, delta_t: float) -> float:
-        """
-        Calculate heat transfer rate through the component.
-        
-        Args:
-            delta_t: Temperature difference across the component in K or °C
-            
-        Returns:
-            Heat transfer rate in Watts
-        """
-        return self.u_value * self.area * delta_t
-    
-    def to_dict(self) -> Dict:
-        """Convert the building component to a dictionary."""
+
+    def to_dict(self) -> dict:
         return {
             "id": self.id,
             "name": self.name,
@@ -150,316 +69,628 @@ class BuildingComponent:
             "u_value": self.u_value,
             "area": self.area,
             "orientation": self.orientation.value,
-            "color": self.color,
-            "r_value": self.r_value,
-            "material_layers": [layer.to_dict() for layer in self.material_layers],
-            "calculated_u_value": self.calculated_u_value,
-            "total_r_value_from_layers": self.total_r_value_from_layers
+            "material_layers": [{"name": l.name, "thickness": l.thickness, "conductivity": l.conductivity} for l in self.material_layers]
         }
 
-
 @dataclass
 class Wall(BuildingComponent):
-    """Class representing a wall component."""
-    
-    has_sun_exposure: bool = True
-    wall_type: str = "Custom"  # Brick, Concrete, Wood Frame, etc.
-    wall_group: str = "A"  # ASHRAE wall group (A, B, C, D, E, F, G, H)
-    gross_area: float = None  # m² (before subtracting windows/doors)
-    net_area: float = None  # m² (after subtracting windows/doors)
-    windows: List[str] = field(default_factory=list)  # List of window IDs
-    doors: List[str] = field(default_factory=list)  # List of door IDs
-    
+    wall_type: str = "Brick"
+    wall_group: str = "B"
+
     def __post_init__(self):
-        """Initialize wall-specific attributes."""
         super().__post_init__()
         self.component_type = ComponentType.WALL
-        
-        # Set net area equal to area if not specified
-        if self.net_area is None:
-            self.net_area = self.area
-        
-        # Set gross area equal to net area if not specified
-        if self.gross_area is None:
-            self.gross_area = self.net_area
-    
-    def update_net_area(self, window_areas: Dict[str, float], door_areas: Dict[str, float]):
-        """
-        Update the net wall area by subtracting windows and doors.
-        
-        Args:
-            window_areas: Dictionary mapping window IDs to areas
-            door_areas: Dictionary mapping door IDs to areas
-        """
-        total_window_area = sum(window_areas.get(window_id, 0) for window_id in self.windows)
-        total_door_area = sum(door_areas.get(door_id, 0) for door_id in self.doors)
-        
-        self.net_area = self.gross_area - total_window_area - total_door_area
-        self.area = self.net_area  # Update the main area property
-        
-        if self.net_area <= 0:
-            raise ValueError("Net wall area cannot be negative or zero")
-    
-    def to_dict(self) -> Dict:
-        """Convert the wall to a dictionary."""
-        wall_dict = super().to_dict()
-        wall_dict.update({
-            "has_sun_exposure": self.has_sun_exposure,
-            "wall_type": self.wall_type,
-            "wall_group": self.wall_group,
-            "gross_area": self.gross_area,
-            "net_area": self.net_area,
-            "windows": self.windows,
-            "doors": self.doors
-        })
-        return wall_dict
 
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({"wall_type": self.wall_type, "wall_group": self.wall_group})
+        return base_dict
 
 @dataclass
 class Roof(BuildingComponent):
-    """Class representing a roof component."""
-    
-    roof_type: str = "Custom"  # Flat, Pitched, etc.
-    roof_group: str = "A"  # ASHRAE roof group
-    pitch: float = 0.0  # Roof pitch in degrees
-    has_suspended_ceiling: bool = False
-    ceiling_plenum_height: float = 0.0  # m
-    
+    roof_type: str = "Concrete"
+    roof_group: str = "C"
+
     def __post_init__(self):
-        """Initialize roof-specific attributes."""
         super().__post_init__()
         self.component_type = ComponentType.ROOF
         self.orientation = Orientation.HORIZONTAL
-    
-    def to_dict(self) -> Dict:
-        """Convert the roof to a dictionary."""
-        roof_dict = super().to_dict()
-        roof_dict.update({
-            "roof_type": self.roof_type,
-            "roof_group": self.roof_group,
-            "pitch": self.pitch,
-            "has_suspended_ceiling": self.has_suspended_ceiling,
-            "ceiling_plenum_height": self.ceiling_plenum_height
-        })
-        return roof_dict
 
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({"roof_type": self.roof_type, "roof_group": self.roof_group})
+        return base_dict
 
 @dataclass
 class Floor(BuildingComponent):
-    """Class representing a floor component."""
-    
-    floor_type: str = "Custom"  # Slab-on-grade, Raised, etc.
-    is_ground_contact: bool = False
-    perimeter_length: float = 0.0  # m (for slab-on-grade floors)
-    
+    floor_type: str = "Concrete"
+
     def __post_init__(self):
-        """Initialize floor-specific attributes."""
         super().__post_init__()
         self.component_type = ComponentType.FLOOR
         self.orientation = Orientation.HORIZONTAL
-    
-    def to_dict(self) -> Dict:
-        """Convert the floor to a dictionary."""
-        floor_dict = super().to_dict()
-        floor_dict.update({
-            "floor_type": self.floor_type,
-            "is_ground_contact": self.is_ground_contact,
-            "perimeter_length": self.perimeter_length
-        })
-        return floor_dict
 
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({"floor_type": self.floor_type})
+        return base_dict
 
 @dataclass
-class Fenestration(BuildingComponent):
-    """Base class for fenestration components (windows, doors, skylights)."""
-    
-    shgc: float = 0.7  # Solar Heat Gain Coefficient
-    vt: float = 0.7  # Visible Transmittance
-    frame_type: str = "Aluminum"  # Aluminum, Wood, Vinyl, etc.
-    frame_width: float = 0.05  # m
-    has_shading: bool = False
-    shading_type: str = None  # Internal, External, Between-glass
-    shading_coefficient: float = 1.0  # 0-1 (1 = no shading)
-    
+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"
+
     def __post_init__(self):
-        """Initialize fenestration-specific attributes."""
         super().__post_init__()
-        
-        if self.shgc < 0 or self.shgc > 1:
+        self.component_type = ComponentType.WINDOW
+        if not 0 <= self.shgc <= 1:
             raise ValueError("SHGC must be between 0 and 1")
-        if self.vt < 0 or self.vt > 1:
+        if not 0 <= self.vt <= 1:
             raise ValueError("VT must be between 0 and 1")
-        if self.shading_coefficient < 0 or self.shading_coefficient > 1:
-            raise ValueError("Shading coefficient must be between 0 and 1")
-    
-    @property
-    def effective_shgc(self) -> float:
-        """Calculate the effective SHGC considering shading."""
-        return self.shgc * self.shading_coefficient
-    
-    def to_dict(self) -> Dict:
-        """Convert the fenestration to a dictionary."""
-        fenestration_dict = super().to_dict()
-        fenestration_dict.update({
-            "shgc": self.shgc,
-            "vt": self.vt,
-            "frame_type": self.frame_type,
-            "frame_width": self.frame_width,
-            "has_shading": self.has_shading,
-            "shading_type": self.shading_type,
-            "shading_coefficient": self.shading_coefficient,
-            "effective_shgc": self.effective_shgc
-        })
-        return fenestration_dict
 
+    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
+        })
+        return base_dict
 
 @dataclass
-class Window(Fenestration):
-    """Class representing a window component."""
-    
-    window_type: str = "Custom"  # Single, Double, Triple glazed, etc.
-    glazing_layers: int = 2  # Number of glazing layers
-    gas_fill: str = "Air"  # Air, Argon, Krypton, etc.
-    low_e_coating: bool = False
-    width: float = 1.0  # m
-    height: float = 1.0  # m
-    wall_id: str = None  # ID of the wall containing this window
-    
+class Door(BuildingComponent):
+    door_type: str = "Solid Wood"
+
     def __post_init__(self):
-        """Initialize window-specific attributes."""
         super().__post_init__()
-        self.component_type = ComponentType.WINDOW
-        
-        # Calculate area from width and height if not provided
-        if self.area <= 0 and self.width > 0 and self.height > 0:
-            self.area = self.width * self.height
-    
-    def to_dict(self) -> Dict:
-        """Convert the window to a dictionary."""
-        window_dict = super().to_dict()
-        window_dict.update({
-            "window_type": self.window_type,
-            "glazing_layers": self.glazing_layers,
-            "gas_fill": self.gas_fill,
-            "low_e_coating": self.low_e_coating,
-            "width": self.width,
-            "height": self.height,
-            "wall_id": self.wall_id
-        })
-        return window_dict
+        self.component_type = ComponentType.DOOR
 
+    def to_dict(self) -> dict:
+        base_dict = super().to_dict()
+        base_dict.update({"door_type": self.door_type})
+        return base_dict
 
+# --- Shading System ---
 @dataclass
-class Door(Fenestration):
-    """Class representing a door component."""
-    
-    door_type: str = "Custom"  # Solid, Partially glazed, etc.
-    glazing_percentage: float = 0.0  # Percentage of door area that is glazed (0-100)
-    width: float = 0.9  # m
-    height: float = 2.1  # m
-    wall_id: str = None  # ID of the wall containing this door
-    
+class ShadingDevice:
+    id: str
+    name: str
+    shading_type: ShadingType
+    shading_coefficient: float
+    coverage_percentage: float = 100.0
+    description: str = ""
+
     def __post_init__(self):
-        """Initialize door-specific attributes."""
-        super().__post_init__()
-        self.component_type = ComponentType.DOOR
+        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()
+
+# --- Component Library ---
+class ComponentLibrary:
+    def __init__(self):
+        self.components = {}
+        self._load_preset_components()
+
+    def _load_preset_components(self):
+        for data_set in [reference_data["wall_types"], reference_data["roof_types"], 
+                        reference_data["floor_types"], reference_data["window_types"], 
+                        reference_data["door_types"]]:
+            for component_data in data_set.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:
+            del self.components[component_id]
+
+component_library = ComponentLibrary()
+
+# --- Reference Data ---
+reference_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}
+    },
+    "wall_types": {
+        "preset_wall_001": {
+            "id": "preset_wall_001", "name": "Standard Brick Wall", "component_type": "Wall",
+            "u_value": 0.5, "area": 0.0, "orientation": "North", "wall_type": "Brick", "wall_group": "B"
+        }
+    },
+    "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"
+        }
+    },
+    "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"
+        }
+    },
+    "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"
+        }
+    },
+    "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"
+        }
+    }
+}
+
+# --- Component Selection Interface ---
+class ComponentSelectionInterface:
+    def display_component_selection(self, session_state: Any) -> None:
+        st.title("Building Components")
         
-        # Calculate area from width and height if not provided
-        if self.area <= 0 and self.width > 0 and self.height > 0:
-            self.area = self.width * self.height
+        if 'components' not in session_state:
+            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
         
-        if self.glazing_percentage < 0 or self.glazing_percentage > 100:
-            raise ValueError("Glazing percentage must be between 0 and 100")
-    
-    @property
-    def glazing_area(self) -> float:
-        """Calculate the glazed area of the door in m²."""
-        return self.area * (self.glazing_percentage / 100)
-    
-    @property
-    def opaque_area(self) -> float:
-        """Calculate the opaque area of the door in m²."""
-        return self.area - self.glazing_area
-    
-    def to_dict(self) -> Dict:
-        """Convert the door to a dictionary."""
-        door_dict = super().to_dict()
-        door_dict.update({
-            "door_type": self.door_type,
-            "glazing_percentage": self.glazing_percentage,
-            "width": self.width,
-            "height": self.height,
-            "wall_id": self.wall_id,
-            "glazing_area": self.glazing_area,
-            "opaque_area": self.opaque_area
-        })
-        return door_dict
+        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
+        
+        with tabs[0]:
+            self._display_component_tab(session_state, ComponentType.WALL)
+        with tabs[1]:
+            self._display_component_tab(session_state, ComponentType.ROOF)
+        with tabs[2]:
+            self._display_component_tab(session_state, ComponentType.FLOOR)
+        with tabs[3]:
+            self._display_component_tab(session_state, ComponentType.WINDOW)
+        with tabs[4]:
+            self._display_component_tab(session_state, ComponentType.DOOR)
+        with tabs[5]:
+            self._display_u_value_calculator_tab(session_state)
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Save Components"):
+                self._save_components(session_state)
+        with col2:
+            uploaded_file = st.file_uploader("Load Components", type=["json"])
+            if uploaded_file and st.button("Load Uploaded Components"):
+                self._load_components(session_state, uploaded_file)
+
+    def _display_component_tab(self, session_state: Any, component_type: ComponentType) -> None:
+        type_name = component_type.value.lower()
+        st.subheader(f"{type_name.capitalize()} Components")
+        
+        with st.expander(f"Add {type_name.capitalize()}", expanded=False):
+            self._display_add_component_form(session_state, component_type)
+        
+        components = session_state.components.get(type_name + 's', [])
+        if components:
+            st.subheader(f"Existing {type_name.capitalize()} Components")
+            self._display_components_table(session_state, component_type, components)
+        else:
+            st.info(f"No {type_name} components defined yet.")
 
+    def _display_add_component_form(self, session_state: Any, component_type: ComponentType) -> None:
+        type_name = component_type.value.lower()
+        preset_components = component_library.get_preset_components_by_type(component_type)
+        
+        with st.form(f"add_{type_name}_form"):
+            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)
+                else:
+                    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 = component_library.get_component(preset_options[selected_preset])
+                    u_value = st.number_input("U-Value (W/m²·K)", value=component.u_value, disabled=True)
+                    if component_type == ComponentType.WALL:
+                        st.text_input("Wall Type", value=component.wall_type, disabled=True)
+                        st.text_input("Wall Group", value=component.wall_group, disabled=True)
+                    elif component_type == ComponentType.ROOF:
+                        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)
+                else:
+                    u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=0.5, step=0.01)
+                    if component_type == ComponentType.WALL:
+                        wall_type = st.text_input("Wall Type", "Custom")
+                        wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], index=1)
+                    elif component_type == ComponentType.ROOF:
+                        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 shading_system.shading_devices.values()}
+                        shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), index=0)
+                        coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, value=100.0, step=5.0)
+                        device = shading_system.get_device(shading_options[shading_device])
+                        device.coverage_percentage = coverage
+                        st.write(f"Effective SHGC: {shading_system.calculate_effective_shgc(shgc, shading_options[shading_device]):.2f}")
+                    elif component_type == ComponentType.DOOR:
+                        door_type = st.text_input("Door Type", "Custom")
+            
+            submitted = st.form_submit_button("Add 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:
+                    try:
+                        if selection_method == "Select from Presets" and preset_components:
+                            component_id = preset_options[selected_preset]
+                            component = component_library.get_component(component_id)
+                            new_component = component.__class__(id=str(uuid.uuid4()), name=name, area=area, 
+                                                              orientation=Orientation(orientation), **component.__dict__)
+                            del new_component.__dict__["id"]
+                        else:
+                            if component_type == ComponentType.WALL:
+                                new_component = Wall(id=str(uuid.uuid4()), name=name, u_value=u_value, area=area, 
+                                                  orientation=Orientation(orientation), wall_type=wall_type, wall_group=wall_group)
+                            elif component_type == ComponentType.ROOF:
+                                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)
+                        component_library.add_component(new_component)
+                        session_state.components[type_name + 's'].append(new_component)
+                        st.success(f"Added {new_component.name}")
+                        st.rerun()
+                    except ValueError as e:
+                        st.error(f"Error: {str(e)}")
 
-@dataclass
-class Skylight(Fenestration):
-    """Class representing a skylight component."""
-    
-    skylight_type: str = "Custom"  # Flat, Domed, etc.
-    glazing_layers: int = 2  # Number of glazing layers
-    gas_fill: str = "Air"  # Air, Argon, Krypton, etc.
-    low_e_coating: bool = False
-    width: float = 1.0  # m
-    length: float = 1.0  # m
-    roof_id: str = None  # ID of the roof containing this skylight
-    
-    def __post_init__(self):
-        """Initialize skylight-specific attributes."""
-        super().__post_init__()
-        self.component_type = ComponentType.SKYLIGHT
-        self.orientation = Orientation.HORIZONTAL
+    def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[BuildingComponent]) -> None:
+        type_name = component_type.value.lower()
+        data = []
+        for comp in components:
+            row = {"Name": comp.name, "Area (m²)": comp.area, "U-Value (W/m²·K)": comp.u_value, "Orientation": comp.orientation.value, "ID": comp.id}
+            if component_type == ComponentType.WALL:
+                row.update({"Wall Type": comp.wall_type, "Wall Group": comp.wall_group})
+            elif component_type == ComponentType.ROOF:
+                row.update({"Roof Type": comp.roof_type, "Roof Group": comp.roof_group})
+            elif component_type == ComponentType.FLOOR:
+                row.update({"Floor Type": comp.floor_type})
+            elif component_type == ComponentType.WINDOW:
+                row.update({"SHGC": comp.shgc, "VT": comp.vt, "Window Type": comp.window_type,
+                           "Effective SHGC": 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)
         
-        # Calculate area from width and length if not provided
-        if self.area <= 0 and self.width > 0 and self.length > 0:
-            self.area = self.width * self.length
-    
-    def to_dict(self) -> Dict:
-        """Convert the skylight to a dictionary."""
-        skylight_dict = super().to_dict()
-        skylight_dict.update({
-            "skylight_type": self.skylight_type,
-            "glazing_layers": self.glazing_layers,
-            "gas_fill": self.gas_fill,
-            "low_e_coating": self.low_e_coating,
-            "width": self.width,
-            "length": self.length,
-            "roof_id": self.roof_id
-        })
-        return skylight_dict
+        df = pd.DataFrame(data)
+        display_cols = [col for col in df.columns if col != "ID"]
+        st.dataframe(df[display_cols], use_container_width=True)
+        
+        for i, row in df.iterrows():
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button("Edit", key=f"edit_{row['ID']}"):
+                    session_state[f"edit_{type_name}"] = row["ID"]
+                    st.rerun()
+            with col2:
+                if st.button("Delete", key=f"delete_{row['ID']}"):
+                    if not row["ID"].startswith("preset_"):
+                        component_library.remove_component(row["ID"])
+                        session_state.components[type_name + 's'] = [c for c in components if c.id != row["ID"]]
+                        st.success(f"Deleted {row['Name']}")
+                        st.rerun()
+                    else:
+                        st.warning("Cannot delete preset components.")
+        
+        if f"edit_{type_name}" in session_state:
+            self._display_edit_component_form(session_state, component_type, session_state[f"edit_{type_name}"])
+            del session_state[f"edit_{type_name}"]
 
+    def _display_edit_component_form(self, session_state: Any, component_type: ComponentType, component_id: str) -> None:
+        type_name = component_type.value.lower()
+        component = next((c for c in session_state.components[type_name + 's'] if c.id == component_id), None)
+        if not component:
+            st.error("Component not found.")
+            return
+        
+        with st.form(f"edit_{component_id}_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Name", value=component.name)
+                area = st.number_input("Area (m²)", min_value=0.0, value=component.area, step=0.1)
+                if component_type not in [ComponentType.ROOF, ComponentType.FLOOR]:
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation], 
+                                             index=[o.value for o in Orientation].index(component.orientation.value))
+                else:
+                    orientation = Orientation.HORIZONTAL.value
+            
+            with col2:
+                u_value = st.number_input("U-Value (W/m²·K)", min_value=0.0, value=component.u_value, step=0.01)
+                if component_type == ComponentType.WALL:
+                    wall_type = st.text_input("Wall Type", value=component.wall_type)
+                    wall_group = st.selectbox("Wall Group", ["A", "B", "C", "D", "E", "F", "G", "H"], 
+                                            index=["A", "B", "C", "D", "E", "F", "G", "H"].index(component.wall_group))
+                elif component_type == ComponentType.ROOF:
+                    roof_type = st.text_input("Roof Type", value=component.roof_type)
+                    roof_group = st.selectbox("Roof Group", ["A", "B", "C", "D", "E", "F", "G"], 
+                                            index=["A", "B", "C", "D", "E", "F", "G"].index(component.roof_group))
+                elif component_type == ComponentType.FLOOR:
+                    floor_type = st.text_input("Floor Type", value=component.floor_type)
+                elif component_type == ComponentType.WINDOW:
+                    shgc = st.number_input("SHGC", min_value=0.0, max_value=1.0, value=component.shgc, step=0.01)
+                    vt = st.number_input("VT", min_value=0.0, max_value=1.0, value=component.vt, step=0.01)
+                    window_type = st.text_input("Window Type", value=component.window_type)
+                    glazing_layers = st.selectbox("Glazing Layers", [1, 2, 3], index=[1, 2, 3].index(component.glazing_layers))
+                    gas_fill = st.selectbox("Gas Fill", ["Air", "Argon", "Krypton"], 
+                                          index=["Air", "Argon", "Krypton"].index(component.gas_fill))
+                    low_e_coating = st.checkbox("Low-E Coating", value=component.low_e_coating)
+                    shading_options = {d.name: d.id for d in shading_system.shading_devices.values()}
+                    shading_device = st.selectbox("Shading Device", options=list(shading_options.keys()), 
+                                                index=list(shading_options.keys()).index(shading_system.get_device(component.shading_device_id).name))
+                    coverage = st.number_input("Coverage (%)", min_value=0.0, max_value=100.0, 
+                                             value=shading_system.get_device(component.shading_device_id).coverage_percentage, step=5.0)
+                    device = shading_system.get_device(shading_options[shading_device])
+                    device.coverage_percentage = coverage
+                    st.write(f"Effective SHGC: {shading_system.calculate_effective_shgc(shgc, shading_options[shading_device]):.2f}")
+                elif component_type == ComponentType.DOOR:
+                    door_type = st.text_input("Door Type", value=component.door_type)
+            
+            submitted = st.form_submit_button("Update Component")
+            if submitted:
+                if not name:
+                    st.error(f"{type_name.capitalize()} name is required!")
+                elif area <= 0:
+                    st.error(f"{type_name.capitalize()} area must be greater than zero!")
+                elif u_value <= 0:
+                    st.error(f"{type_name.capitalize()} U-value must be greater than zero!")
+                else:
+                    component.name = name
+                    component.area = area
+                    component.u_value = u_value
+                    component.orientation = Orientation(orientation)
+                    if component_type == ComponentType.WALL:
+                        component.wall_type = wall_type
+                        component.wall_group = wall_group
+                    elif component_type == ComponentType.ROOF:
+                        component.roof_type = roof_type
+                        component.roof_group = roof_group
+                    elif component_type == ComponentType.FLOOR:
+                        component.floor_type = floor_type
+                    elif component_type == ComponentType.WINDOW:
+                        component.shgc = shgc
+                        component.vt = vt
+                        component.window_type = window_type
+                        component.glazing_layers = glazing_layers
+                        component.gas_fill = gas_fill
+                        component.low_e_coating = low_e_coating
+                        component.shading_device_id = shading_options[shading_device]
+                    elif component_type == ComponentType.DOOR:
+                        component.door_type = door_type
+                    component_library.update_component(component_id, component)
+                    st.success(f"Updated {name}")
+                    st.rerun()
 
-class BuildingComponentFactory:
-    """Factory class for creating building components."""
-    
-    @staticmethod
-    def create_component(component_data: Dict) -> BuildingComponent:
-        """
-        Create a building component from a dictionary of data.
+    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 = []
+        
+        components = []
+        for type_name in ['walls', 'roofs', 'floors', 'windows', 'doors']:
+            components.extend(session_state.components[type_name])
         
-        Args:
-            component_data: Dictionary containing component data
+        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):")
+            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)
+            
+            r_outside = 0.04  # m²·K/W
+            r_inside = 0.13  # m²·K/W
+            r_layers = sum([l["thickness"] / 1000 / l["conductivity"] for l in session_state.material_layers])
+            r_total = r_outside + r_layers + r_inside
+            u_value = 1 / r_total if r_total > 0 else 0
+            
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric("Total R-Value", f"{r_total:.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"):
+                    component.u_value = u_value
+                    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}")
+                    st.rerun()
             
-        Returns:
-            A BuildingComponent object of the appropriate type
-        """
-        component_type = component_data.get("component_type")
+            if st.button("Remove Last Layer"):
+                if session_state.material_layers:
+                    session_state.material_layers.pop()
+                    st.rerun()
         
-        if component_type == ComponentType.WALL.value:
-            return Wall(**component_data)
-        elif component_type == ComponentType.ROOF.value:
-            return Roof(**component_data)
-        elif component_type == ComponentType.FLOOR.value:
-            return Floor(**component_data)
-        elif component_type == ComponentType.WINDOW.value:
-            return Window(**component_data)
-        elif component_type == ComponentType.DOOR.value:
-            return Door(**component_data)
-        elif component_type == ComponentType.SKYLIGHT.value:
-            return Skylight(**component_data)
-        else:
-            raise ValueError(f"Unknown component type: {component_type}")
+        with st.form("material_layer_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                material_selection = st.radio("Material Selection", ["Select from Presets", "Custom Material"])
+                if material_selection == "Select from Presets":
+                    material_options = {m["name"]: mid for mid, m in reference_data["materials"].items()}
+                    material_name = st.selectbox("Material", options=list(material_options.keys()))
+                    conductivity = reference_data["materials"][material_options[material_name]]["conductivity"]
+                    st.number_input("Conductivity (W/m·K)", value=conductivity, disabled=True)
+                else:
+                    material_name = st.text_input("Material Name", "Custom Material")
+                    conductivity = st.number_input("Conductivity (W/m·K)", min_value=0.0, value=1.0, step=0.01)
+            
+            with col2:
+                thickness = st.number_input("Thickness (mm)", min_value=0.0, value=100.0, step=1.0)
+                if conductivity > 0:
+                    r_value = thickness / 1000 / conductivity
+                    st.metric("Layer R-Value", f"{r_value:.3f} m²·K/W")
+            
+            submitted = st.form_submit_button("Add Layer")
+            if submitted:
+                if not material_name:
+                    st.error("Material name is required!")
+                elif thickness <= 0:
+                    st.error("Thickness must be greater than zero!")
+                elif conductivity <= 0:
+                    st.error("Conductivity must be greater than zero!")
+                else:
+                    session_state.material_layers.append({"name": material_name, "thickness": thickness, "conductivity": conductivity})
+                    st.success(f"Added layer: {material_name}")
+                    st.rerun()
+
+    def _save_components(self, session_state: Any) -> None:
+        components_dict = {
+            "walls": [c.to_dict() for c in session_state.components["walls"]],
+            "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"]]
+        }
+        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.")
+
+    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)
+                component_library.add_component(comp)
+                session_state.components[type_name].append(comp)
+        st.success(f"Loaded components successfully.")
+        st.rerun()
+
+# --- Main Execution ---
+if __name__ == "__main__":
+    interface = ComponentSelectionInterface()
+    interface.display_component_selection(st.session_state)