Update app/component_selection.py

app/component_selection.py

@@ -1,6 +1,7 @@
 """
 HVAC Component Selection Module
 Provides UI for selecting building components in the HVAC Load Calculator.
+All dependencies are included within this file for standalone operation.
 """
 
 import streamlit as st
@@ -12,19 +13,150 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import Dict, List, Any, Optional
 
-# Imports from your project structure
-from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
-from data.reference_data import reference_data
-from utils.component_library import ComponentLibrary
-from utils.u_value_calculator import UValueCalculator
+# --- Enums ---
+class Orientation(Enum):
+    NORTH = "North"
+    NORTHEAST = "Northeast"
+    EAST = "East"
+    SOUTHEAST = "Southeast"
+    SOUTH = "South"
+    SOUTHWEST = "Southwest"
+    WEST = "West"
+    NORTHWEST = "Northwest"
+    HORIZONTAL = "Horizontal"
+    NOT_APPLICABLE = "N/A"
+
+class ComponentType(Enum):
+    WALL = "Wall"
+    ROOF = "Roof"
+    FLOOR = "Floor"
+    WINDOW = "Window"
+    DOOR = "Door"
 
-# --- Shading System (New Addition) ---
 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)
+
+@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²
+    orientation: Orientation = Orientation.NOT_APPLICABLE
+    material_layers: List[MaterialLayer] = field(default_factory=list)
+
+    def __post_init__(self):
+        if self.area < 0:
+            raise ValueError("Area cannot be negative")
+        if self.u_value < 0:
+            raise ValueError("U-value cannot be negative")
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "component_type": self.component_type.value,
+            "u_value": self.u_value,
+            "area": self.area,
+            "orientation": self.orientation.value,
+            "material_layers": [{"name": l.name, "thickness": l.thickness, "conductivity": l.conductivity} for l in self.material_layers]
+        }
+
+@dataclass
+class Wall(BuildingComponent):
+    wall_type: str = "Brick"
+    wall_group: str = "B"
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.WALL
+
+    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"
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.ROOF
+        self.orientation = Orientation.HORIZONTAL
+
+    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"
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.FLOOR
+        self.orientation = Orientation.HORIZONTAL
+
+    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"
+
+    def __post_init__(self):
+        super().__post_init__()
+        self.component_type = ComponentType.WINDOW
+        if not 0 <= self.shgc <= 1:
+            raise ValueError("SHGC must be between 0 and 1")
+        if not 0 <= self.vt <= 1:
+            raise ValueError("VT must be between 0 and 1")
+
+    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 Door(BuildingComponent):
+    door_type: str = "Solid Wood"
+
+    def __post_init__(self):
+        super().__post_init__()
+        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 ShadingDevice:
     id: str
@@ -79,12 +211,125 @@ class ShadingSystem:
 
 shading_system = ShadingSystem()
 
+# --- Reference Data ---
+class ReferenceData:
+    def __init__(self):
+        self.data = {
+            "materials": {
+                "mat_001": {"name": "Concrete", "conductivity": 1.4},
+                "mat_002": {"name": "Insulation", "conductivity": 0.04},
+                "mat_003": {"name": "Brick", "conductivity": 0.8},
+                "mat_004": {"name": "Glass", "conductivity": 1.0},
+                "mat_005": {"name": "Wood", "conductivity": 0.15}
+            },
+            "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"
+                }
+            }
+        }
+
+    def get_materials(self) -> List[Dict[str, Any]]:
+        return list(self.data["materials"].values())
+
+    def get_component_data(self, component_type: str) -> Dict[str, Any]:
+        return self.data.get(f"{component_type.lower()}_types", {})
+
+reference_data = ReferenceData()
+
+# --- Component Library ---
+class ComponentLibrary:
+    def __init__(self):
+        self.components = {}
+        self._load_preset_components()
+
+    def _load_preset_components(self):
+        for type_key in ["wall_types", "roof_types", "floor_types", "window_types", "door_types"]:
+            for component_data in reference_data.data[type_key].values():
+                component_data["orientation"] = Orientation(component_data["orientation"])
+                if component_data["component_type"] == ComponentType.WALL.value:
+                    component = Wall(**component_data)
+                elif component_data["component_type"] == ComponentType.ROOF.value:
+                    component = Roof(**component_data)
+                elif component_data["component_type"] == ComponentType.FLOOR.value:
+                    component = Floor(**component_data)
+                elif component_data["component_type"] == ComponentType.WINDOW.value:
+                    component = Window(**component_data)
+                elif component_data["component_type"] == ComponentType.DOOR.value:
+                    component = Door(**component_data)
+                self.components[component.id] = component
+
+    def get_component(self, component_id: str) -> BuildingComponent:
+        return self.components.get(component_id)
+
+    def get_preset_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
+        return [comp for comp in self.components.values() if comp.component_type == component_type and comp.id.startswith("preset_")]
+
+    def add_component(self, component: BuildingComponent):
+        self.components[component.id] = component
+
+    def update_component(self, component_id: str, component: BuildingComponent):
+        self.components[component_id] = component
+
+    def remove_component(self, component_id: str):
+        if component_id.startswith("preset_"):
+            raise ValueError("Cannot remove preset components")
+        if component_id in self.components:
+            del self.components[component_id]
+
+component_library = ComponentLibrary()
+
+# --- U-Value Calculator ---
+class UValueCalculator:
+    def __init__(self):
+        self.materials = reference_data.get_materials()
+
+    def get_preset_materials(self) -> List[Dict[str, Any]]:
+        return self.materials
+
+    def calculate_u_value(self, layers: List[Dict[str, float]]) -> float:
+        r_outside = 0.04  # m²·K/W
+        r_inside = 0.13  # m��·K/W
+        r_layers = sum(layer["thickness"] / 1000 / layer["conductivity"] for layer in layers)
+        r_total = r_outside + r_layers + r_inside
+        return 1 / r_total if r_total > 0 else 0
+
+u_value_calculator = UValueCalculator()
+
 # --- Component Selection Interface ---
 class ComponentSelectionInterface:
     def __init__(self):
-        self.component_library = ComponentLibrary()
-        self.u_value_calculator = UValueCalculator()
+        self.component_library = component_library
+        self.u_value_calculator = u_value_calculator
         self.shading_system = shading_system
+        self.reference_data = reference_data
 
     def display_component_selection(self, session_state: Any) -> None:
         st.title("Building Components")
@@ -140,9 +385,9 @@ class ComponentSelectionInterface:
                 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.name for o in Orientation], index=0)
+                    orientation = st.selectbox("Orientation", [o.value for o in Orientation], index=0)
                 else:
-                    orientation = Orientation.HORIZONTAL.name
+                    orientation = Orientation.HORIZONTAL.value
             
             with col2:
                 selection_method = st.radio(f"{type_name.capitalize()} Selection Method", ["Select from Presets", "Custom Properties"])
@@ -206,36 +451,36 @@ class ComponentSelectionInterface:
                             component = self.component_library.get_component(component_id)
                             new_component = component.__class__(
                                 id=str(uuid.uuid4()), name=name, area=area, 
-                                orientation=Orientation[orientation], **vars(component)
+                                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
+                                    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
+                                    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
+                                    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,
+                                    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
+                                    orientation=Orientation(orientation), door_type=door_type
                                 )
                         self.component_library.add_component(new_component)
                         session_state.components[type_name + 's'].append(new_component)
@@ -244,11 +489,11 @@ class ComponentSelectionInterface:
                     except ValueError as e:
                         st.error(f"Error: {str(e)}")
 
-    def _display_components_table(self, session_state: Any, component_type: ComponentType, components: List[Any]) -> None:
+    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.name, "ID": comp.id}
+            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:
@@ -299,10 +544,10 @@ class ComponentSelectionInterface:
                 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.name for o in Orientation], 
-                                             index=[o.name for o in Orientation].index(component.orientation.name))
+                    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.name
+                    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)
@@ -347,7 +592,7 @@ class ComponentSelectionInterface:
                     component.name = name
                     component.area = area
                     component.u_value = u_value
-                    component.orientation = Orientation[orientation]
+                    component.orientation = Orientation(orientation)
                     if component_type == ComponentType.WALL:
                         component.wall_type = wall_type
                         component.wall_group = wall_group
@@ -397,15 +642,11 @@ class ComponentSelectionInterface:
                          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
+            u_value = self.u_value_calculator.calculate_u_value(session_state.material_layers)
             
             col1, col2, col3 = st.columns(3)
             with col1:
-                st.metric("Total R-Value", f"{r_total:.3f} m²·K/W")
+                st.metric("Total R-Value", f"{1/u_value if u_value > 0 else 0:.3f} m²·K/W")
             with col2:
                 st.metric("U-Value", f"{u_value:.3f} W/m²·K")
             with col3:
@@ -456,16 +697,12 @@ class ComponentSelectionInterface:
 
     def _save_components(self, session_state: Any) -> None:
         components_dict = {
-            "walls": [c.__dict__ for c in session_state.components["walls"]],
-            "roofs": [c.__dict__ for c in session_state.components["roofs"]],
-            "floors": [c.__dict__ for c in session_state.components["floors"]],
-            "windows": [c.__dict__ for c in session_state.components["windows"]],
-            "doors": [c.__dict__ for c in session_state.components["doors"]]
+            "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"]]
         }
-        for type_name in components_dict:
-            for comp in components_dict[type_name]:
-                comp["orientation"] = comp["orientation"].name
-                comp["component_type"] = comp["component_type"].name
         file_path = "components_export.json"
         with open(file_path, 'w') as f:
             json.dump(components_dict, f, indent=4)
@@ -478,8 +715,7 @@ class ComponentSelectionInterface:
         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"]]
-                comp_dict["component_type"] = ComponentType[comp_dict["component_type"]]
+                comp_dict["orientation"] = Orientation(comp_dict["orientation"])
                 if type_name == "walls":
                     comp = Wall(**comp_dict)
                 elif type_name == "roofs":