Spaces:

mabuseif
/

test-29

Sleeping

test-29 / utils /component_library.py

Upload 31 files

91ba325 verified over 1 year ago

15 kB

"""
Component library module for HVAC Load Calculator.
This module implements the preset component database and component selection interface.
"""

from typing import Dict, List, Any, Optional, Tuple
import pandas as pd
import numpy as np
import os
import json
import uuid
from dataclasses import asdict

# Import data models
from data.building_components import (
    BuildingComponent, Wall, Roof, Floor, Window, Door, Skylight,
    MaterialLayer, Orientation, ComponentType, BuildingComponentFactory
)
from data.reference_data import reference_data

# Define paths
DATA_DIR = os.path.dirname(os.path.abspath(__file__))


class ComponentLibrary:
    """Class for managing building component library."""
    
    def __init__(self):
        """Initialize component library."""
        self.components = {}
        self.load_preset_components()
    
    def load_preset_components(self):
        """Load preset components from reference data."""
        # Load preset walls
        for wall_id, wall_data in reference_data.wall_types.items():
            # Create material layers
            material_layers = []
            for layer_data in wall_data.get("layers", []):
                material_id = layer_data.get("material")
                thickness = layer_data.get("thickness")
                
                material = reference_data.get_material(material_id)
                if material:
                    layer = MaterialLayer(
                        name=material["name"],
                        thickness=thickness,
                        conductivity=material["conductivity"],
                        density=material.get("density"),
                        specific_heat=material.get("specific_heat")
                    )
                    material_layers.append(layer)
            
            # Create wall component
            component_id = f"preset_wall_{wall_id}"
            wall = Wall(
                id=component_id,
                name=wall_data["name"],
                component_type=ComponentType.WALL,
                u_value=wall_data["u_value"],
                area=1.0,  # Use a small positive value instead of 0.0
                orientation=Orientation.NOT_APPLICABLE,  # Orientation will be set when component is used
                wall_type=wall_data["name"],
                wall_group=wall_data["wall_group"],
                material_layers=material_layers
            )
            
            self.components[component_id] = wall
        
        # Load preset roofs
        for roof_id, roof_data in reference_data.roof_types.items():
            # Create material layers
            material_layers = []
            for layer_data in roof_data.get("layers", []):
                material_id = layer_data.get("material")
                thickness = layer_data.get("thickness")
                
                material = reference_data.get_material(material_id)
                if material:
                    layer = MaterialLayer(
                        name=material["name"],
                        thickness=thickness,
                        conductivity=material["conductivity"],
                        density=material.get("density"),
                        specific_heat=material.get("specific_heat")
                    )
                    material_layers.append(layer)
            
            # Create roof component
            component_id = f"preset_roof_{roof_id}"
            roof = Roof(
                id=component_id,
                name=roof_data["name"],
                component_type=ComponentType.ROOF,
                u_value=roof_data["u_value"],
                area=1.0,  # Use a small positive value instead of 0.0
                orientation=Orientation.HORIZONTAL,
                roof_type=roof_data["name"],
                roof_group=roof_data["roof_group"],
                material_layers=material_layers
            )
            
            self.components[component_id] = roof
        
        # Load preset floors
        for floor_id, floor_data in reference_data.floor_types.items():
            # Create material layers
            material_layers = []
            for layer_data in floor_data.get("layers", []):
                material_id = layer_data.get("material")
                thickness = layer_data.get("thickness")
                
                material = reference_data.get_material(material_id)
                if material:
                    layer = MaterialLayer(
                        name=material["name"],
                        thickness=thickness,
                        conductivity=material["conductivity"],
                        density=material.get("density"),
                        specific_heat=material.get("specific_heat")
                    )
                    material_layers.append(layer)
            
            # Create floor component
            component_id = f"preset_floor_{floor_id}"
            floor = Floor(
                id=component_id,
                name=floor_data["name"],
                component_type=ComponentType.FLOOR,
                u_value=floor_data["u_value"],
                area=1.0,  # Use a small positive value instead of 0.0
                orientation=Orientation.HORIZONTAL,
                floor_type=floor_data["name"],
                is_ground_contact=floor_data["is_ground_contact"],
                material_layers=material_layers
            )
            
            self.components[component_id] = floor
        
        # Load preset windows
        for window_id, window_data in reference_data.window_types.items():
            # Create window component
            component_id = f"preset_window_{window_id}"
            window = Window(
                id=component_id,
                name=window_data["name"],
                component_type=ComponentType.WINDOW,
                u_value=window_data["u_value"],
                area=1.0,  # Use a small positive value instead of 0.0
                orientation=Orientation.NOT_APPLICABLE,  # Orientation will be set when component is used
                shgc=window_data["shgc"],
                vt=window_data["vt"],
                window_type=window_data["name"],
                glazing_layers=window_data["glazing_layers"],
                gas_fill=window_data["gas_fill"],
                low_e_coating=window_data["low_e_coating"]
            )
            
            self.components[component_id] = window
        
        # Load preset doors
        for door_id, door_data in reference_data.door_types.items():
            # Create door component
            component_id = f"preset_door_{door_id}"
            door = Door(
                id=component_id,
                name=door_data["name"],
                component_type=ComponentType.DOOR,
                u_value=door_data["u_value"],
                area=1.0,  # Use a small positive value instead of 0.0
                orientation=Orientation.NOT_APPLICABLE,  # Orientation will be set when component is used
                door_type=door_data["door_type"],
                glazing_percentage=door_data["glazing_percentage"],
                shgc=door_data.get("shgc", 0.0),
                vt=door_data.get("vt", 0.0)
            )
            
            self.components[component_id] = door
    
    def get_component(self, component_id: str) -> Optional[BuildingComponent]:
        """
        Get a component by ID.
        
        Args:
            component_id: Component identifier
            
        Returns:
            BuildingComponent object or None if not found
        """
        return self.components.get(component_id)
    
    def get_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
        """
        Get all components of a specific type.
        
        Args:
            component_type: Component type
            
        Returns:
            List of BuildingComponent objects
        """
        return [comp for comp in self.components.values() if comp.component_type == component_type]
    
    def get_preset_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
        """
        Get all preset components of a specific type.
        
        Args:
            component_type: Component type
            
        Returns:
            List of BuildingComponent objects
        """
        return [comp for comp in self.components.values() 
                if comp.component_type == component_type and comp.id.startswith("preset_")]
    
    def get_custom_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
        """
        Get all custom components of a specific type.
        
        Args:
            component_type: Component type
            
        Returns:
            List of BuildingComponent objects
        """
        return [comp for comp in self.components.values() 
                if comp.component_type == component_type and comp.id.startswith("custom_")]
    
    def add_component(self, component: BuildingComponent) -> str:
        """
        Add a component to the library.
        
        Args:
            component: BuildingComponent object
            
        Returns:
            Component ID
        """
        if component.id in self.components:
            # Generate a new ID if the component ID already exists
            component.id = f"custom_{component.component_type.value.lower()}_{str(uuid.uuid4())[:8]}"
        
        self.components[component.id] = component
        return component.id
    
    def update_component(self, component_id: str, component: BuildingComponent) -> bool:
        """
        Update a component in the library.
        
        Args:
            component_id: ID of the component to update
            component: Updated BuildingComponent object
            
        Returns:
            True if the component was updated, False otherwise
        """
        if component_id not in self.components:
            return False
        
        # Preserve the original ID
        component.id = component_id
        self.components[component_id] = component
        return True
    
    def remove_component(self, component_id: str) -> bool:
        """
        Remove a component from the library.
        
        Args:
            component_id: ID of the component to remove
            
        Returns:
            True if the component was removed, False otherwise
        """
        if component_id not in self.components:
            return False
        
        # Don't allow removing preset components
        if component_id.startswith("preset_"):
            return False
        
        del self.components[component_id]
        return True
    
    def clone_component(self, component_id: str, new_name: str = None) -> Optional[str]:
        """
        Clone a component in the library.
        
        Args:
            component_id: ID of the component to clone
            new_name: Name for the cloned component (optional)
            
        Returns:
            ID of the cloned component, or None if the original component was not found
        """
        component = self.get_component(component_id)
        if not component:
            return None
        
        # Create a copy of the component
        component_dict = asdict(component)
        
        # Generate a new ID
        component_dict["id"] = f"custom_{component.component_type.value.lower()}_{str(uuid.uuid4())[:8]}"
        
        # Update name if provided
        if new_name:
            component_dict["name"] = new_name
        else:
            component_dict["name"] = f"Copy of {component.name}"
        
        # Create a new component of the same type
        new_component = BuildingComponentFactory.create_component(
            component_type=component.component_type,
            **component_dict
        )
        
        # Add to library
        return self.add_component(new_component)
    
    def export_to_json(self, filepath: str) -> bool:
        """
        Export the component library to a JSON file.
        
        Args:
            filepath: Path to the output JSON file
            
        Returns:
            True if the export was successful, False otherwise
        """
        try:
            # Convert components to dictionaries
            components_dict = {comp_id: comp.to_dict() for comp_id, comp in self.components.items()}
            
            # Write to file
            with open(filepath, 'w') as f:
                json.dump(components_dict, f, indent=2)
            
            return True
        except Exception as e:
            print(f"Error exporting component library: {e}")
            return False
    
    def import_from_json(self, filepath: str) -> bool:
        """
        Import components from a JSON file.
        
        Args:
            filepath: Path to the input JSON file
            
        Returns:
            True if the import was successful, False otherwise
        """
        try:
            # Read from file
            with open(filepath, 'r') as f:
                components_dict = json.load(f)
            
            # Create components from dictionaries
            for comp_id, comp_dict in components_dict.items():
                component_type = ComponentType(comp_dict["component_type"])
                component = BuildingComponentFactory.create_component(
                    component_type=component_type,
                    **comp_dict
                )
                self.components[comp_id] = component
            
            return True
        except Exception as e:
            print(f"Error importing component library: {e}")
            return False


class BuildingComponentFactory:
    """Factory class for creating building components."""
    
    @staticmethod
    def create_component(component_type: ComponentType, **kwargs) -> BuildingComponent:
        """
        Create a building component of the specified type.
        
        Args:
            component_type: Type of component to create
            **kwargs: Component properties
            
        Returns:
            BuildingComponent object
        """
        if component_type == ComponentType.WALL:
            return Wall(**kwargs)
        elif component_type == ComponentType.ROOF:
            return Roof(**kwargs)
        elif component_type == ComponentType.FLOOR:
            return Floor(**kwargs)
        elif component_type == ComponentType.WINDOW:
            return Window(**kwargs)
        elif component_type == ComponentType.DOOR:
            return Door(**kwargs)
        elif component_type == ComponentType.SKYLIGHT:
            return Skylight(**kwargs)
        else:
            raise ValueError(f"Unknown component type: {component_type}")


# Create a singleton instance
component_library = ComponentLibrary()

	"""
	Component library module for HVAC Load Calculator.
	This module implements the preset component database and component selection interface.
	"""

	from typing import Dict, List, Any, Optional, Tuple
	import pandas as pd
	import numpy as np
	import os
	import json
	import uuid
	from dataclasses import asdict

	# Import data models
	from data.building_components import (
	BuildingComponent, Wall, Roof, Floor, Window, Door, Skylight,
	MaterialLayer, Orientation, ComponentType, BuildingComponentFactory
	)
	from data.reference_data import reference_data

	# Define paths
	DATA_DIR = os.path.dirname(os.path.abspath(__file__))


	class ComponentLibrary:
	"""Class for managing building component library."""

	def __init__(self):
	"""Initialize component library."""
	self.components = {}
	self.load_preset_components()

	def load_preset_components(self):
	"""Load preset components from reference data."""
	# Load preset walls
	for wall_id, wall_data in reference_data.wall_types.items():
	# Create material layers
	material_layers = []
	for layer_data in wall_data.get("layers", []):
	material_id = layer_data.get("material")
	thickness = layer_data.get("thickness")

	material = reference_data.get_material(material_id)
	if material:
	layer = MaterialLayer(
	name=material["name"],
	thickness=thickness,
	conductivity=material["conductivity"],
	density=material.get("density"),
	specific_heat=material.get("specific_heat")
	)
	material_layers.append(layer)

	# Create wall component
	component_id = f"preset_wall_{wall_id}"
	wall = Wall(
	id=component_id,
	name=wall_data["name"],
	component_type=ComponentType.WALL,
	u_value=wall_data["u_value"],
	area=1.0, # Use a small positive value instead of 0.0
	orientation=Orientation.NOT_APPLICABLE, # Orientation will be set when component is used
	wall_type=wall_data["name"],
	wall_group=wall_data["wall_group"],
	material_layers=material_layers
	)

	self.components[component_id] = wall

	# Load preset roofs
	for roof_id, roof_data in reference_data.roof_types.items():
	# Create material layers
	material_layers = []
	for layer_data in roof_data.get("layers", []):
	material_id = layer_data.get("material")
	thickness = layer_data.get("thickness")

	material = reference_data.get_material(material_id)
	if material:
	layer = MaterialLayer(
	name=material["name"],
	thickness=thickness,
	conductivity=material["conductivity"],
	density=material.get("density"),
	specific_heat=material.get("specific_heat")
	)
	material_layers.append(layer)

	# Create roof component
	component_id = f"preset_roof_{roof_id}"
	roof = Roof(
	id=component_id,
	name=roof_data["name"],
	component_type=ComponentType.ROOF,
	u_value=roof_data["u_value"],
	area=1.0, # Use a small positive value instead of 0.0
	orientation=Orientation.HORIZONTAL,
	roof_type=roof_data["name"],
	roof_group=roof_data["roof_group"],
	material_layers=material_layers
	)

	self.components[component_id] = roof

	# Load preset floors
	for floor_id, floor_data in reference_data.floor_types.items():
	# Create material layers
	material_layers = []
	for layer_data in floor_data.get("layers", []):
	material_id = layer_data.get("material")
	thickness = layer_data.get("thickness")

	material = reference_data.get_material(material_id)
	if material:
	layer = MaterialLayer(
	name=material["name"],
	thickness=thickness,
	conductivity=material["conductivity"],
	density=material.get("density"),
	specific_heat=material.get("specific_heat")
	)
	material_layers.append(layer)

	# Create floor component
	component_id = f"preset_floor_{floor_id}"
	floor = Floor(
	id=component_id,
	name=floor_data["name"],
	component_type=ComponentType.FLOOR,
	u_value=floor_data["u_value"],
	area=1.0, # Use a small positive value instead of 0.0
	orientation=Orientation.HORIZONTAL,
	floor_type=floor_data["name"],
	is_ground_contact=floor_data["is_ground_contact"],
	material_layers=material_layers
	)

	self.components[component_id] = floor

	# Load preset windows
	for window_id, window_data in reference_data.window_types.items():
	# Create window component
	component_id = f"preset_window_{window_id}"
	window = Window(
	id=component_id,
	name=window_data["name"],
	component_type=ComponentType.WINDOW,
	u_value=window_data["u_value"],
	area=1.0, # Use a small positive value instead of 0.0
	orientation=Orientation.NOT_APPLICABLE, # Orientation will be set when component is used
	shgc=window_data["shgc"],
	vt=window_data["vt"],
	window_type=window_data["name"],
	glazing_layers=window_data["glazing_layers"],
	gas_fill=window_data["gas_fill"],
	low_e_coating=window_data["low_e_coating"]
	)

	self.components[component_id] = window

	# Load preset doors
	for door_id, door_data in reference_data.door_types.items():
	# Create door component
	component_id = f"preset_door_{door_id}"
	door = Door(
	id=component_id,
	name=door_data["name"],
	component_type=ComponentType.DOOR,
	u_value=door_data["u_value"],
	area=1.0, # Use a small positive value instead of 0.0
	orientation=Orientation.NOT_APPLICABLE, # Orientation will be set when component is used
	door_type=door_data["door_type"],
	glazing_percentage=door_data["glazing_percentage"],
	shgc=door_data.get("shgc", 0.0),
	vt=door_data.get("vt", 0.0)
	)

	self.components[component_id] = door

	def get_component(self, component_id: str) -> Optional[BuildingComponent]:
	"""
	Get a component by ID.

	Args:
	component_id: Component identifier

	Returns:
	BuildingComponent object or None if not found
	"""
	return self.components.get(component_id)

	def get_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
	"""
	Get all components of a specific type.

	Args:
	component_type: Component type

	Returns:
	List of BuildingComponent objects
	"""
	return [comp for comp in self.components.values() if comp.component_type == component_type]

	def get_preset_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
	"""
	Get all preset components of a specific type.

	Args:
	component_type: Component type

	Returns:
	List of BuildingComponent objects
	"""
	return [comp for comp in self.components.values()
	if comp.component_type == component_type and comp.id.startswith("preset_")]

	def get_custom_components_by_type(self, component_type: ComponentType) -> List[BuildingComponent]:
	"""
	Get all custom components of a specific type.

	Args:
	component_type: Component type

	Returns:
	List of BuildingComponent objects
	"""
	return [comp for comp in self.components.values()
	if comp.component_type == component_type and comp.id.startswith("custom_")]

	def add_component(self, component: BuildingComponent) -> str:
	"""
	Add a component to the library.

	Args:
	component: BuildingComponent object

	Returns:
	Component ID
	"""
	if component.id in self.components:
	# Generate a new ID if the component ID already exists
	component.id = f"custom_{component.component_type.value.lower()}_{str(uuid.uuid4())[:8]}"

	self.components[component.id] = component
	return component.id

	def update_component(self, component_id: str, component: BuildingComponent) -> bool:
	"""
	Update a component in the library.

	Args:
	component_id: ID of the component to update
	component: Updated BuildingComponent object

	Returns:
	True if the component was updated, False otherwise
	"""
	if component_id not in self.components:
	return False

	# Preserve the original ID
	component.id = component_id
	self.components[component_id] = component
	return True

	def remove_component(self, component_id: str) -> bool:
	"""
	Remove a component from the library.

	Args:
	component_id: ID of the component to remove

	Returns:
	True if the component was removed, False otherwise
	"""
	if component_id not in self.components:
	return False

	# Don't allow removing preset components
	if component_id.startswith("preset_"):
	return False

	del self.components[component_id]
	return True

	def clone_component(self, component_id: str, new_name: str = None) -> Optional[str]:
	"""
	Clone a component in the library.

	Args:
	component_id: ID of the component to clone
	new_name: Name for the cloned component (optional)

	Returns:
	ID of the cloned component, or None if the original component was not found
	"""
	component = self.get_component(component_id)
	if not component:
	return None

	# Create a copy of the component
	component_dict = asdict(component)

	# Generate a new ID
	component_dict["id"] = f"custom_{component.component_type.value.lower()}_{str(uuid.uuid4())[:8]}"

	# Update name if provided
	if new_name:
	component_dict["name"] = new_name
	else:
	component_dict["name"] = f"Copy of {component.name}"

	# Create a new component of the same type
	new_component = BuildingComponentFactory.create_component(
	component_type=component.component_type,
	**component_dict
	)

	# Add to library
	return self.add_component(new_component)

	def export_to_json(self, filepath: str) -> bool:
	"""
	Export the component library to a JSON file.

	Args:
	filepath: Path to the output JSON file

	Returns:
	True if the export was successful, False otherwise
	"""
	try:
	# Convert components to dictionaries
	components_dict = {comp_id: comp.to_dict() for comp_id, comp in self.components.items()}

	# Write to file
	with open(filepath, 'w') as f:
	json.dump(components_dict, f, indent=2)

	return True
	except Exception as e:
	print(f"Error exporting component library: {e}")
	return False

	def import_from_json(self, filepath: str) -> bool:
	"""
	Import components from a JSON file.

	Args:
	filepath: Path to the input JSON file

	Returns:
	True if the import was successful, False otherwise
	"""
	try:
	# Read from file
	with open(filepath, 'r') as f:
	components_dict = json.load(f)

	# Create components from dictionaries
	for comp_id, comp_dict in components_dict.items():
	component_type = ComponentType(comp_dict["component_type"])
	component = BuildingComponentFactory.create_component(
	component_type=component_type,
	**comp_dict
	)
	self.components[comp_id] = component

	return True
	except Exception as e:
	print(f"Error importing component library: {e}")
	return False


	class BuildingComponentFactory:
	"""Factory class for creating building components."""

	@staticmethod
	def create_component(component_type: ComponentType, **kwargs) -> BuildingComponent:
	"""
	Create a building component of the specified type.

	Args:
	component_type: Type of component to create
	**kwargs: Component properties

	Returns:
	BuildingComponent object
	"""
	if component_type == ComponentType.WALL:
	return Wall(**kwargs)
	elif component_type == ComponentType.ROOF:
	return Roof(**kwargs)
	elif component_type == ComponentType.FLOOR:
	return Floor(**kwargs)
	elif component_type == ComponentType.WINDOW:
	return Window(**kwargs)
	elif component_type == ComponentType.DOOR:
	return Door(**kwargs)
	elif component_type == ComponentType.SKYLIGHT:
	return Skylight(**kwargs)
	else:
	raise ValueError(f"Unknown component type: {component_type}")


	# Create a singleton instance
	component_library = ComponentLibrary()