Update data/reference_data.py

data/reference_data.py

@@ -7,16 +7,51 @@ from typing import Dict, List, Any, Optional
 import pandas as pd
 import json
 import os
+import logging
+from uuid import uuid4
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # Define paths
 DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+DEFAULT_DATA_FILE = os.path.join(DATA_DIR, "reference_data.json")
 
 
 class ReferenceData:
     """Class for managing reference data for the HVAC calculator."""
-    
+
     def __init__(self):
         """Initialize reference data structures."""
+        self.materials = {}
+        self.wall_types = {}
+        self.roof_types = {}
+        self.floor_types = {}
+        self.window_types = {}
+        self.door_types = {}
+        self.internal_loads = {}
+        
+        try:
+            self._load_all_data()
+        except Exception as e:
+            logger.error(f"Error initializing reference data: {str(e)}")
+            raise
+
+    def _load_all_data(self) -> None:
+        """Load all reference data, attempting to load from JSON first."""
+        try:
+            if os.path.exists(DEFAULT_DATA_FILE):
+                self._load_from_json(DEFAULT_DATA_FILE)
+            else:
+                self._load_default_data()
+                self.export_to_json(DEFAULT_DATA_FILE)
+        except Exception as e:
+            logger.error(f"Error loading reference data: {str(e)}")
+            self._load_default_data()  # Fallback to default data
+
+    def _load_default_data(self) -> None:
+        """Load default reference data."""
         self.materials = self._load_materials()
         self.wall_types = self._load_wall_types()
         self.roof_types = self._load_roof_types()
@@ -24,590 +59,389 @@ class ReferenceData:
         self.window_types = self._load_window_types()
         self.door_types = self._load_door_types()
         self.internal_loads = self._load_internal_loads()
-    
+
     def _load_materials(self) -> Dict[str, Dict[str, Any]]:
         """
-        Load material properties from reference data.
-        
+        Load material properties.
         Returns:
             Dictionary of material properties
         """
-        # This would typically load from a JSON or CSV file
-        # For now, we'll define some common materials inline
         return {
             "brick": {
+                "id": str(uuid4()),
                 "name": "Common Brick",
                 "conductivity": 0.72,  # W/(m·K)
                 "density": 1920,  # kg/m³
                 "specific_heat": 840,  # J/(kg·K)
-                "typical_thickness": 0.1  # m
+                "typical_thickness": 0.1,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.7
             },
             "concrete": {
+                "id": str(uuid4()),
                 "name": "Concrete",
                 "conductivity": 1.4,  # W/(m·K)
                 "density": 2300,  # kg/m³
                 "specific_heat": 880,  # J/(kg·K)
-                "typical_thickness": 0.2  # m
+                "typical_thickness": 0.2,  # m
+                "emissivity": 0.92,
+                "solar_absorptance": 0.65
             },
             "mineral_wool": {
+                "id": str(uuid4()),
                 "name": "Mineral Wool Insulation",
                 "conductivity": 0.04,  # W/(m·K)
                 "density": 30,  # kg/m³
                 "specific_heat": 840,  # J/(kg·K)
-                "typical_thickness": 0.1  # m
-            },
-            "eps_insulation": {
-                "name": "EPS Insulation",
-                "conductivity": 0.035,  # W/(m·K)
-                "density": 25,  # kg/m³
-                "specific_heat": 1400,  # J/(kg·K)
-                "typical_thickness": 0.1  # m
+                "typical_thickness": 0.1,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.6
             },
-            "gypsum_board": {
-                "name": "Gypsum Board",
-                "conductivity": 0.25,  # W/(m·K)
-                "density": 900,  # kg/m³
-                "specific_heat": 1000,  # J/(kg·K)
-                "typical_thickness": 0.0125  # m
+            # Additional materials
+            "polyurethane_foam": {
+                "id": str(uuid4()),
+                "name": "Polyurethane Foam",
+                "conductivity": 0.025,  # W/(m·K)
+                "density": 40,  # kg/m³
+                "specific_heat": 1500,  # J/(kg·K)
+                "typical_thickness": 0.05,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.6
             },
-            "wood": {
-                "name": "Wood (Pine)",
-                "conductivity": 0.14,  # W/(m·K)
-                "density": 500,  # kg/m³
-                "specific_heat": 1600,  # J/(kg·K)
-                "typical_thickness": 0.025  # m
+            "fiberglass_insulation": {
+                "id": str(uuid4()),
+                "name": "Fiberglass Insulation",
+                "conductivity": 0.045,  # W/(m·K)
+                "density": 12,  # kg/m³
+                "specific_heat": 850,  # J/(kg·K)
+                "typical_thickness": 0.15,  # m
+                "emissivity": 0.9,
+                "solar_absorptance": 0.6
             },
-            "steel": {
-                "name": "Steel",
-                "conductivity": 50,  # W/(m·K)
-                "density": 7800,  # kg/m³
-                "specific_heat": 450,  # J/(kg·K)
-                "typical_thickness": 0.005  # m
-            },
-            "glass": {
-                "name": "Glass",
-                "conductivity": 1.0,  # W/(m·K)
-                "density": 2500,  # kg/m³
-                "specific_heat": 840,  # J/(kg·K)
-                "typical_thickness": 0.006  # m
-            },
-            "air_gap": {
-                "name": "Air Gap",
-                "conductivity": 0.024,  # W/(m·K)
-                "density": 1.2,  # kg/m³
-                "specific_heat": 1000,  # J/(kg·K)
-                "typical_thickness": 0.025  # m
-            },
-            "concrete_block": {
-                "name": "Concrete Block",
-                "conductivity": 0.51,  # W/(m·K)
-                "density": 1400,  # kg/m³
-                "specific_heat": 1000,  # J/(kg·K)
-                "typical_thickness": 0.2  # m
-            },
-            "asphalt_shingle": {
-                "name": "Asphalt Shingle",
+            "stucco": {
+                "id": str(uuid4()),
+                "name": "Stucco",
                 "conductivity": 0.7,  # W/(m·K)
-                "density": 1100,  # kg/m³
-                "specific_heat": 1260,  # J/(kg·K)
-                "typical_thickness": 0.006  # m
-            },
-            "carpet": {
-                "name": "Carpet",
-                "conductivity": 0.06,  # W/(m·K)
-                "density": 200,  # kg/m³
-                "specific_heat": 1300,  # J/(kg·K)
-                "typical_thickness": 0.01  # m
-            },
-            "vinyl_flooring": {
-                "name": "Vinyl Flooring",
-                "conductivity": 0.17,  # W/(m·K)
-                "density": 1200,  # kg/m³
-                "specific_heat": 1460,  # J/(kg·K)
-                "typical_thickness": 0.003  # m
+                "density": 1850,  # kg/m³
+                "specific_heat": 900,  # J/(kg·K)
+                "typical_thickness": 0.025,  # m
+                "emissivity": 0.92,
+                "solar_absorptance": 0.5
             }
+            # Add more materials as needed
         }
-    
+
     def _load_wall_types(self) -> Dict[str, Dict[str, Any]]:
         """
-        Load predefined wall types from reference data.
-        
+        Load predefined wall types.
         Returns:
             Dictionary of wall types with properties
         """
         return {
             "brick_veneer_wood_frame": {
-                "name": "Brick veneer with wood frame",
+                "id": str(uuid4()),
+                "name": "Brick Veneer with Wood Frame",
                 "description": "Brick veneer with wood frame, insulation, and gypsum board",
                 "u_value": 0.35,  # W/(m²·K)
-                "wall_group": "B",  # ASHRAE wall group
+                "wall_group": "B",
                 "layers": [
                     {"material": "brick", "thickness": 0.1},
                     {"material": "air_gap", "thickness": 0.025},
                     {"material": "wood", "thickness": 0.038},
                     {"material": "mineral_wool", "thickness": 0.089},
                     {"material": "gypsum_board", "thickness": 0.0125}
-                ]
+                ],
+                "thermal_mass": 180,  # kg/m²
+                "color": "Medium"
             },
-            "concrete_block_insulated": {
-                "name": "Concrete block with interior insulation",
-                "description": "Concrete block wall with interior insulation and gypsum board",
-                "u_value": 0.48,  # W/(m²·K)
-                "wall_group": "C",  # ASHRAE wall group
+            "insulated_concrete_form": {
+                "id": str(uuid4()),
+                "name": "Insulated Concrete Form",
+                "description": "ICF with EPS insulation and concrete core",
+                "u_value": 0.25,  # W/(m²·K)
+                "wall_group": "C",
                 "layers": [
-                    {"material": "concrete_block", "thickness": 0.2},
+                    {"material": "eps_insulation", "thickness": 0.05},
+                    {"material": "concrete", "thickness": 0.15},
                     {"material": "eps_insulation", "thickness": 0.05},
                     {"material": "gypsum_board", "thickness": 0.0125}
-                ]
-            },
-            "precast_concrete_panel": {
-                "name": "Precast concrete panel",
-                "description": "Precast concrete panel with insulation and gypsum board",
-                "u_value": 0.45,  # W/(m²·K)
-                "wall_group": "D",  # ASHRAE wall group
-                "layers": [
-                    {"material": "concrete", "thickness": 0.1},
-                    {"material": "eps_insulation", "thickness": 0.075},
-                    {"material": "gypsum_board", "thickness": 0.0125}
-                ]
-            },
-            "metal_panel_insulated": {
-                "name": "Metal panel with insulation",
-                "description": "Metal panel wall with insulation and interior finish",
-                "u_value": 0.4,  # W/(m²·K)
-                "wall_group": "E",  # ASHRAE wall group
-                "layers": [
-                    {"material": "steel", "thickness": 0.001},
-                    {"material": "mineral_wool", "thickness": 0.1},
-                    {"material": "gypsum_board", "thickness": 0.0125}
-                ]
+                ],
+                "thermal_mass": 220,  # kg/m²
+                "color": "Light"
             },
-            "wood_frame_wall": {
-                "name": "Wood frame wall",
-                "description": "Wood frame wall with insulation and gypsum board",
-                "u_value": 0.3,  # W/(m²·K)
-                "wall_group": "A",  # ASHRAE wall group
+            # Additional wall types
+            "sip_panel": {
+                "id": str(uuid4()),
+                "name": "Structural Insulated Panel",
+                "description": "SIP with OSB and EPS core",
+                "u_value": 0.28,  # W/(m²·K)
+                "wall_group": "A",
                 "layers": [
-                    {"material": "wood", "thickness": 0.019},
-                    {"material": "air_gap", "thickness": 0.025},
-                    {"material": "wood", "thickness": 0.038},
-                    {"material": "mineral_wool", "thickness": 0.14},
+                    {"material": "wood", "thickness": 0.012},
+                    {"material": "eps_insulation", "thickness": 0.15},
+                    {"material": "wood", "thickness": 0.012},
                     {"material": "gypsum_board", "thickness": 0.0125}
-                ]
+                ],
+                "thermal_mass": 80,  # kg/m²
+                "color": "Light"
             }
         }
-    
+
     def _load_roof_types(self) -> Dict[str, Dict[str, Any]]:
         """
-        Load predefined roof types from reference data.
-        
+        Load predefined roof types.
         Returns:
             Dictionary of roof types with properties
         """
         return {
             "flat_roof_concrete": {
-                "name": "Flat concrete roof with insulation",
+                "id": str(uuid4()),
+                "name": "Flat Concrete Roof with Insulation",
                 "description": "Flat concrete roof with insulation and ceiling",
                 "u_value": 0.25,  # W/(m²·K)
-                "roof_group": "B",  # ASHRAE roof group
+                "roof_group": "B",
                 "layers": [
                     {"material": "concrete", "thickness": 0.15},
                     {"material": "eps_insulation", "thickness": 0.15},
                     {"material": "gypsum_board", "thickness": 0.0125}
-                ]
+                ],
+                "solar_absorptance": 0.7,
+                "emissivity": 0.9
             },
-            "pitched_roof_wood": {
-                "name": "Pitched wood roof with insulation",
-                "description": "Pitched wood roof with insulation and ceiling",
-                "u_value": 0.2,  # W/(m²·K)
-                "roof_group": "A",  # ASHRAE roof group
-                "layers": [
-                    {"material": "asphalt_shingle", "thickness": 0.006},
-                    {"material": "wood", "thickness": 0.019},
-                    {"material": "air_gap", "thickness": 0.025},
-                    {"material": "mineral_wool", "thickness": 0.2},
-                    {"material": "gypsum_board", "thickness": 0.0125}
-                ]
-            },
-            "metal_deck_roof": {
-                "name": "Metal deck roof with insulation",
-                "description": "Metal deck roof with insulation and ceiling",
-                "u_value": 0.3,  # W/(m²·K)
-                "roof_group": "C",  # ASHRAE roof group
+            "green_roof": {
+                "id": str(uuid4()),
+                "name": "Green Roof",
+                "description": "Vegetated roof with insulation and drainage",
+                "u_value": 0.22,  # W/(m²·K)
+                "roof_group": "A",
                 "layers": [
-                    {"material": "steel", "thickness": 0.001},
+                    {"material": "soil", "thickness": 0.1},
                     {"material": "eps_insulation", "thickness": 0.1},
-                    {"material": "air_gap", "thickness": 0.1},
+                    {"material": "concrete", "thickness": 0.1},
                     {"material": "gypsum_board", "thickness": 0.0125}
-                ]
+                ],
+                "solar_absorptance": 0.5,
+                "emissivity": 0.95
             }
         }
-    
+
     def _load_floor_types(self) -> Dict[str, Dict[str, Any]]:
         """
-        Load predefined floor types from reference data.
-        
+        Load predefined floor types.
         Returns:
             Dictionary of floor types with properties
         """
         return {
             "concrete_slab_on_grade": {
-                "name": "Concrete slab on grade",
+                "id": str(uuid4()),
+                "name": "Concrete Slab on Grade",
                 "description": "Concrete slab on grade with insulation",
                 "u_value": 0.3,  # W/(m²·K)
                 "is_ground_contact": True,
                 "layers": [
                     {"material": "concrete", "thickness": 0.1},
                     {"material": "eps_insulation", "thickness": 0.05}
-                ]
-            },
-            "suspended_concrete_floor": {
-                "name": "Suspended concrete floor",
-                "description": "Suspended concrete floor with insulation",
-                "u_value": 0.25,  # W/(m²·K)
-                "is_ground_contact": False,
-                "layers": [
-                    {"material": "concrete", "thickness": 0.15},
-                    {"material": "eps_insulation", "thickness": 0.1},
-                    {"material": "gypsum_board", "thickness": 0.0125}
-                ]
+                ],
+                "thermal_mass": 230  # kg/m²
             },
-            "wood_joist_floor": {
-                "name": "Wood joist floor",
-                "description": "Wood joist floor with insulation",
-                "u_value": 0.22,  # W/(m²·K)
-                "is_ground_contact": False,
-                "layers": [
-                    {"material": "wood", "thickness": 0.025},
-                    {"material": "air_gap", "thickness": 0.15},
-                    {"material": "mineral_wool", "thickness": 0.15},
-                    {"material": "gypsum_board", "thickness": 0.0125}
-                ]
-            },
-            "carpet_on_concrete": {
-                "name": "Carpet on concrete",
-                "description": "Carpet on concrete slab with insulation",
-                "u_value": 0.28,  # W/(m²·K)
+            "radiant_floor": {
+                "id": str(uuid4()),
+                "name": "Radiant Floor",
+                "description": "Concrete floor with radiant heating and insulation",
+                "u_value": 0.27,  # W/(m²·K)
                 "is_ground_contact": True,
                 "layers": [
-                    {"material": "carpet", "thickness": 0.01},
+                    {"material": "tile", "thickness": 0.015},
                     {"material": "concrete", "thickness": 0.1},
-                    {"material": "eps_insulation", "thickness": 0.05}
-                ]
+                    {"material": "eps_insulation", "thickness": 0.075}
+                ],
+                "thermal_mass": 240  # kg/m²
             }
         }
-    
+
     def _load_window_types(self) -> Dict[str, Dict[str, Any]]:
         """
-        Load predefined window types from reference data.
-        
+        Load predefined window types.
         Returns:
             Dictionary of window types with properties
         """
         return {
-            "single_glazed": {
-                "name": "Single glazed window",
-                "description": "Single glazed window with aluminum frame",
-                "u_value": 5.8,  # W/(m²·K)
-                "shgc": 0.86,  # Solar Heat Gain Coefficient
-                "vt": 0.9,  # Visible Transmittance
-                "glazing_layers": 1,
-                "gas_fill": "Air",
-                "frame_type": "Aluminum",
-                "low_e_coating": False
-            },
-            "double_glazed_air": {
-                "name": "Double glazed window with air",
-                "description": "Double glazed window with air gap and aluminum frame",
-                "u_value": 2.8,  # W/(m²·K)
-                "shgc": 0.76,  # Solar Heat Gain Coefficient
-                "vt": 0.81,  # Visible Transmittance
-                "glazing_layers": 2,
-                "gas_fill": "Air",
-                "frame_type": "Aluminum",
-                "low_e_coating": False
-            },
             "double_glazed_argon_low_e": {
-                "name": "Double glazed window with argon and low-e coating",
+                "id": str(uuid4()),
+                "name": "Double Glazed with Argon and Low-E",
                 "description": "Double glazed window with argon fill, low-e coating, and vinyl frame",
                 "u_value": 1.4,  # W/(m²·K)
-                "shgc": 0.4,  # Solar Heat Gain Coefficient
-                "vt": 0.7,  # Visible Transmittance
+                "shgc": 0.4,
+                "vt": 0.7,
                 "glazing_layers": 2,
                 "gas_fill": "Argon",
                 "frame_type": "Vinyl",
-                "low_e_coating": True
+                "low_e_coating": True,
+                "frame_factor": 0.15
             },
-            "triple_glazed_argon_low_e": {
-                "name": "Triple glazed window with argon and low-e coating",
-                "description": "Triple glazed window with argon fill, low-e coating, and vinyl frame",
-                "u_value": 0.8,  # W/(m²·K)
-                "shgc": 0.3,  # Solar Heat Gain Coefficient
-                "vt": 0.6,  # Visible Transmittance
-                "glazing_layers": 3,
+            "electrochromic_window": {
+                "id": str(uuid4()),
+                "name": "Electrochromic Window",
+                "description": "Smart window with dynamic tinting",
+                "u_value": 1.2,  # W/(m²·K)
+                "shgc": 0.35,
+                "vt": 0.65,
+                "glazing_layers": 2,
                 "gas_fill": "Argon",
-                "frame_type": "Vinyl",
-                "low_e_coating": True
+                "frame_type": "Fiberglass",
+                "low_e_coating": True,
+                "frame_factor": 0.12
             }
         }
-    
+
     def _load_door_types(self) -> Dict[str, Dict[str, Any]]:
         """
-        Load predefined door types from reference data.
-        
+        Load predefined door types.
         Returns:
             Dictionary of door types with properties
         """
         return {
-            "solid_wood_door": {
-                "name": "Solid wood door",
-                "description": "Solid wood door with no glazing",
-                "u_value": 2.2,  # W/(m²·K)
-                "glazing_percentage": 0,
-                "door_type": "Solid"
-            },
             "insulated_steel_door": {
-                "name": "Insulated steel door",
+                "id": str(uuid4()),
+                "name": "Insulated Steel Door",
                 "description": "Insulated steel door with no glazing",
                 "u_value": 1.2,  # W/(m²·K)
                 "glazing_percentage": 0,
-                "door_type": "Solid"
+                "door_type": "Solid",
+                "thermal_mass": 50  # kg/m²
             },
-            "partially_glazed_door": {
-                "name": "Partially glazed door",
-                "description": "Wood door with 25% glazing",
-                "u_value": 2.8,  # W/(m²·K)
-                "glazing_percentage": 25,
+            "insulated_fiberglass_door": {
+                "id": str(uuid4()),
+                "name": "Insulated Fiberglass Door",
+                "description": "Insulated fiberglass door with small glazing",
+                "u_value": 1.5,  # W/(m²·K)
+                "glazing_percentage": 10,
                 "door_type": "Partially glazed",
-                "shgc": 0.76,  # Solar Heat Gain Coefficient for the glazed portion
-                "vt": 0.81  # Visible Transmittance for the glazed portion
-            },
-            "glass_door": {
-                "name": "Glass door",
-                "description": "Full glass door with aluminum frame",
-                "u_value": 3.8,  # W/(m²·K)
-                "glazing_percentage": 90,
-                "door_type": "Glass",
-                "shgc": 0.76,  # Solar Heat Gain Coefficient
-                "vt": 0.81  # Visible Transmittance
+                "shgc": 0.7,
+                "vt": 0.8,
+                "thermal_mass": 40  # kg/m²
             }
         }
-    
+
     def _load_internal_loads(self) -> Dict[str, Dict[str, Any]]:
         """
-        Load internal load data from reference data.
-        
+        Load internal load data.
         Returns:
             Dictionary of internal load types with properties
         """
         return {
             "occupancy": {
-                "seated_very_light_work": {
-                    "name": "Seated, very light work",
-                    "sensible_heat": 70,  # W per person
-                    "latent_heat": 45  # W per person
-                },
-                "office_work_standing": {
-                    "name": "Office work, standing",
+                "office_typing": {
+                    "id": str(uuid4()),
+                    "name": "Office Typing",
                     "sensible_heat": 75,  # W per person
-                    "latent_heat": 55  # W per person
+                    "latent_heat": 55,  # W per person
+                    "metabolic_rate": 1.2  # met
                 },
-                "light_physical_work": {
-                    "name": "Light physical work",
+                "retail_sales": {
+                    "id": str(uuid4()),
+                    "name": "Retail Sales",
                     "sensible_heat": 80,  # W per person
-                    "latent_heat": 140  # W per person
-                },
-                "medium_physical_work": {
-                    "name": "Medium physical work",
-                    "sensible_heat": 90,  # W per person
-                    "latent_heat": 185  # W per person
-                },
-                "heavy_physical_work": {
-                    "name": "Heavy physical work",
-                    "sensible_heat": 170,  # W per person
-                    "latent_heat": 255  # W per person
+                    "latent_heat": 70,  # W per person
+                    "metabolic_rate": 1.4  # met
                 }
             },
             "lighting": {
-                "led": {
-                    "name": "LED",
-                    "power_density_range": [5, 10],  # W/m²
-                    "heat_to_space": 0.9  # Fraction of power that becomes heat
-                },
-                "fluorescent": {
-                    "name": "Fluorescent",
-                    "power_density_range": [10, 15],  # W/m²
-                    "heat_to_space": 0.95  # Fraction of power that becomes heat
-                },
-                "incandescent": {
-                    "name": "Incandescent",
-                    "power_density_range": [15, 25],  # W/m²
-                    "heat_to_space": 0.98  # Fraction of power that becomes heat
-                },
-                "halogen": {
-                    "name": "Halogen",
-                    "power_density_range": [12, 20],  # W/m²
-                    "heat_to_space": 0.97  # Fraction of power that becomes heat
+                "led_high_efficiency": {
+                    "id": str(uuid4()),
+                    "name": "High Efficiency LED",
+                    "power_density_range": [4, 8],  # W/m²
+                    "heat_to_space": 0.85,
+                    "efficacy": 120  # lm/W
                 }
             },
             "equipment": {
-                "office_equipment": {
-                    "name": "Office Equipment",
-                    "power_density_range": [10, 20],  # W/m²
-                    "sensible_fraction": 0.9,
-                    "latent_fraction": 0.1
-                },
-                "kitchen_equipment": {
-                    "name": "Kitchen Equipment",
-                    "power_density_range": [30, 200],  # W/m²
-                    "sensible_fraction": 0.6,
-                    "latent_fraction": 0.4
-                },
-                "manufacturing_equipment": {
-                    "name": "Manufacturing Equipment",
-                    "power_density_range": [20, 100],  # W/m²
-                    "sensible_fraction": 0.8,
-                    "latent_fraction": 0.2
+                "computer_workstation": {
+                    "id": str(uuid4()),
+                    "name": "Computer Workstation",
+                    "power_density_range": [15, 25],  # W/m²
+                    "sensible_fraction": 0.95,
+                    "latent_fraction": 0.05
                 }
             }
         }
-    
-    def get_material(self, material_id: str) -> Optional[Dict[str, Any]]:
+
+    def _load_from_json(self, file_path: str) -> None:
         """
-        Get material properties by ID.
-        
+        Load reference data from JSON file.
         Args:
-            material_id: Material identifier
-            
-        Returns:
-            Dictionary of material properties or None if not found
-        """
-        return self.materials.get(material_id)
-    
-    def get_wall_type(self, wall_type_id: str) -> Optional[Dict[str, Any]]:
+            file_path: Path to JSON file
+        """
+        try:
+            with open(file_path, 'r') as f:
+                data = json.load(f)
+            self.materials = data.get("materials", self.materials)
+            self.wall_types = data.get("wall_types", self.wall_types)
+            self.roof_types = data.get("roof_types", self.roof_types)
+            self.floor_types = data.get("floor_types", self.floor_types)
+            self.window_types = data.get("window_types", self.window_types)
+            self.door_types = data.get("door_types", self.door_types)
+            self.internal_loads = data.get("internal_loads", self.internal_loads)
+            logger.info(f"Successfully loaded reference data from {file_path}")
+        except Exception as e:
+            logger.error(f"Error loading JSON data from {file_path}: {str(e)}")
+            raise
+
+    def export_to_json(self, file_path: str) -> None:
         """
-        Get wall type properties by ID.
-        
+        Export all reference data to a JSON file.
         Args:
-            wall_type_id: Wall type identifier
-            
-        Returns:
-            Dictionary of wall type properties or None if not found
+            file_path: Path to the output JSON file
         """
+        try:
+            data = {
+                "materials": self.materials,
+                "wall_types": self.wall_types,
+                "roof_types": self.roof_types,
+                "floor_types": self.floor_types,
+                "window_types": self.window_types,
+                "door_types": self.door_types,
+                "internal_loads": self.internal_loads
+            }
+            with open(file_path, 'w') as f:
+                json.dump(data, f, indent=4)
+            logger.info(f"Successfully exported reference data to {file_path}")
+        except Exception as e:
+            logger.error(f"Error exporting to JSON: {str(e)}")
+            raise
+
+    # Getter methods with validation
+    def get_material(self, material_id: str) -> Optional[Dict[str, Any]]:
+        return self.materials.get(material_id)
+
+    def get_wall_type(self, wall_type_id: str) -> Optional[Dict[str, Any]]:
         return self.wall_types.get(wall_type_id)
-    
+
     def get_roof_type(self, roof_type_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get roof type properties by ID.
-        
-        Args:
-            roof_type_id: Roof type identifier
-            
-        Returns:
-            Dictionary of roof type properties or None if not found
-        """
         return self.roof_types.get(roof_type_id)
-    
+
     def get_floor_type(self, floor_type_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get floor type properties by ID.
-        
-        Args:
-            floor_type_id: Floor type identifier
-            
-        Returns:
-            Dictionary of floor type properties or None if not found
-        """
         return self.floor_types.get(floor_type_id)
-    
+
     def get_window_type(self, window_type_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get window type properties by ID.
-        
-        Args:
-            window_type_id: Window type identifier
-            
-        Returns:
-            Dictionary of window type properties or None if not found
-        """
         return self.window_types.get(window_type_id)
-    
+
     def get_door_type(self, door_type_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get door type properties by ID.
-        
-        Args:
-            door_type_id: Door type identifier
-            
-        Returns:
-            Dictionary of door type properties or None if not found
-        """
         return self.door_types.get(door_type_id)
-    
+
     def get_internal_load(self, load_type: str, load_id: str) -> Optional[Dict[str, Any]]:
-        """
-        Get internal load properties by type and ID.
-        
-        Args:
-            load_type: Type of internal load (occupancy, lighting, equipment)
-            load_id: Internal load identifier
-            
-        Returns:
-            Dictionary of internal load properties or None if not found
-        """
-        if load_type in self.internal_loads:
-            return self.internal_loads[load_type].get(load_id)
-        return None
-    
-    def export_to_json(self, file_path: str) -> None:
-        """
-        Export all reference data to a JSON file.
-        
-        Args:
-            file_path: Path to the output JSON file
-        """
-        data = {
-            "materials": self.materials,
-            "wall_types": self.wall_types,
-            "roof_types": self.roof_types,
-            "floor_types": self.floor_types,
-            "window_types": self.window_types,
-            "door_types": self.door_types,
-            "internal_loads": self.internal_loads
-        }
-        
-        with open(file_path, 'w') as f:
-            json.dump(data, f, indent=4)
-    
-    @classmethod
-    def from_json(cls, file_path: str) -> 'ReferenceData':
-        """
-        Create a ReferenceData instance from a JSON file.
-        
-        Args:
-            file_path: Path to the input JSON file
-            
-        Returns:
-            A new ReferenceData instance
-        """
-        with open(file_path, 'r') as f:
-            data = json.load(f)
-        
-        ref_data = cls()
-        ref_data.materials = data.get("materials", ref_data.materials)
-        ref_data.wall_types = data.get("wall_types", ref_data.wall_types)
-        ref_data.roof_types = data.get("roof_types", ref_data.roof_types)
-        ref_data.floor_types = data.get("floor_types", ref_data.floor_types)
-        ref_data.window_types = data.get("window_types", ref_data.window_types)
-        ref_data.door_types = data.get("door_types", ref_data.door_types)
-        ref_data.internal_loads = data.get("internal_loads", ref_data.internal_loads)
-        
-        return ref_data
+        return self.internal_loads.get(load_type, {}).get(load_id)
 
 
-# Create a singleton instance
-reference_data = ReferenceData()
+# Singleton instance
+try:
+    reference_data = ReferenceData()
+except Exception as e:
+    logger.error(f"Failed to create ReferenceData instance: {str(e)}")
+    raise
 
-# Export reference data to JSON if needed
 if __name__ == "__main__":
-    reference_data.export_to_json(os.path.join(DATA_DIR, "reference_data.json"))
+    try:
+        reference_data.export_to_json(DEFAULT_DATA_FILE)
+    except Exception as e:
+        logger.error(f"Error exporting default data: {str(e)}")