Update data/building_components.py

data/building_components.py

@@ -1,19 +1,16 @@
 """
-HVAC Component Selection Module
-Combines all components into a single Streamlit UI with 6 tabs.
+Building component data models for HVAC Load Calculator.
+This module defines the data structures for walls, roofs, floors, windows, doors, and other building components.
 """
 
-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 Dict, List, Any, Optional
+from typing import List, Dict, Optional, Union
+import numpy as np
+
 
-# --- Enums ---
 class Orientation(Enum):
+    """Enumeration for building component orientations."""
     NORTH = "North"
     NORTHEAST = "Northeast"
     EAST = "East"
@@ -22,46 +19,130 @@ class Orientation(Enum):
     SOUTHWEST = "Southwest"
     WEST = "West"
     NORTHWEST = "Northwest"
-    HORIZONTAL = "Horizontal"
-    NOT_APPLICABLE = "N/A"
+    HORIZONTAL = "Horizontal"  # For roofs and floors
+    NOT_APPLICABLE = "N/A"  # For components without orientation
+
 
 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:
-    name: str
-    thickness: float  # in mm
-    conductivity: float  # W/(m·K)
+    """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
+        }
+
 
 @dataclass
 class BuildingComponent:
-    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²
+    """Base class for all building components."""
+    
+    id: str
+    name: str
+    component_type: ComponentType
+    u_value: float  # W/(m²·K)
+    area: float  # m²
     orientation: Orientation = Orientation.NOT_APPLICABLE
+    color: str = "Medium"  # Light, Medium, Dark
     material_layers: List[MaterialLayer] = field(default_factory=list)
-
+    
     def __post_init__(self):
-        if self.area < 0:
-            raise ValueError("Area cannot be negative")
+        """Validate component data after initialization."""
+        if self.area <= 0:
+            raise ValueError("Area must be greater than zero")
         if self.u_value < 0:
             raise ValueError("U-value cannot be negative")
-
-    def to_dict(self) -> dict:
+    
+    @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."""
         return {
             "id": self.id,
             "name": self.name,
@@ -69,628 +150,316 @@ class BuildingComponent:
             "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]
+            "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
         }
 
+
 @dataclass
 class Wall(BuildingComponent):
-    wall_type: str = "Brick"
-    wall_group: str = "B"
-
+    """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
+    
     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):
-    roof_type: str = "Concrete"
-    roof_group: str = "C"
-
+    """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
+    
     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):
-    floor_type: str = "Concrete"
-
+    """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)
+    
     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 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"
-
+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)
+    
     def __post_init__(self):
+        """Initialize fenestration-specific attributes."""
         super().__post_init__()
-        self.component_type = ComponentType.WINDOW
-        if not 0 <= self.shgc <= 1:
+        
+        if self.shgc < 0 or self.shgc > 1:
             raise ValueError("SHGC must be between 0 and 1")
-        if not 0 <= self.vt <= 1:
+        if self.vt < 0 or self.vt > 1:
             raise ValueError("VT must be between 0 and 1")
-
-    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
+        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 base_dict
+        return fenestration_dict
 
-@dataclass
-class Door(BuildingComponent):
-    door_type: str = "Solid Wood"
 
+@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
+    
     def __post_init__(self):
+        """Initialize window-specific attributes."""
         super().__post_init__()
-        self.component_type = ComponentType.DOOR
+        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
 
-    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 ShadingDevice:
-    id: str
-    name: str
-    shading_type: ShadingType
-    shading_coefficient: float
-    coverage_percentage: float = 100.0
-    description: str = ""
-
+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
+    
     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()
-
-# --- 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")
-        
-        if 'components' not in session_state:
-            session_state.components = {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []}
-        
-        tabs = st.tabs(["Walls", "Roofs", "Floors", "Windows", "Doors", "U-Value Calculator"])
-        
-        with tabs[0]:
-            self._display_component_tab(session_state, ComponentType.WALL)
-        with tabs[1]:
-            self._display_component_tab(session_state, ComponentType.ROOF)
-        with tabs[2]:
-            self._display_component_tab(session_state, ComponentType.FLOOR)
-        with tabs[3]:
-            self._display_component_tab(session_state, ComponentType.WINDOW)
-        with tabs[4]:
-            self._display_component_tab(session_state, ComponentType.DOOR)
-        with tabs[5]:
-            self._display_u_value_calculator_tab(session_state)
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("Save Components"):
-                self._save_components(session_state)
-        with col2:
-            uploaded_file = st.file_uploader("Load Components", type=["json"])
-            if uploaded_file and st.button("Load Uploaded Components"):
-                self._load_components(session_state, uploaded_file)
-
-    def _display_component_tab(self, session_state: Any, component_type: ComponentType) -> None:
-        type_name = component_type.value.lower()
-        st.subheader(f"{type_name.capitalize()} Components")
+        """Initialize door-specific attributes."""
+        super().__post_init__()
+        self.component_type = ComponentType.DOOR
         
-        with st.expander(f"Add {type_name.capitalize()}", expanded=False):
-            self._display_add_component_form(session_state, component_type)
+        # 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
         
-        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.")
+        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
 
-    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)}")
 
-    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)
-        
-        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.")
+@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
         
-        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}"]
+        # 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
 
-    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()
 
-    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])
+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.
         
-        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()
+        Args:
+            component_data: Dictionary containing component data
             
-            if st.button("Remove Last Layer"):
-                if session_state.material_layers:
-                    session_state.material_layers.pop()
-                    st.rerun()
+        Returns:
+            A BuildingComponent object of the appropriate type
+        """
+        component_type = component_data.get("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)
+        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}")