Update utils/heating_load.py

utils/heating_load.py

@@ -1,48 +1,157 @@
 """
 Heating load calculation module for HVAC Load Calculator.
-This module implements enhanced steady-state methods with thermal mass effects,
-pressure-driven infiltration, and schedule-based internal gains.
+Implements enhanced steady-state methods with thermal mass effects, pressure-driven infiltration, and schedule-based internal gains.
 Updated 2025-04-28: Added F-factor for floor losses, ground temperature validation, and negative load prevention.
+Updated 2025-04-30: Added dynamic F-factor, climate skip logic, debug prints, and restored original features (summary, annual energy).
 """
 
-from typing import Dict, List, Any, Optional, Tuple
+from typing import Dict, List, Any, Optional
 import math
 import numpy as np
-import pandas as pd
-import os
-from datetime import datetime, timedelta
+from datetime import datetime, time
 from enum import Enum
 
-# Import data models and utilities
-from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
-from utils.psychrometrics import Psychrometrics
-from utils.heat_transfer import HeatTransferCalculations
+# --- Enums ---
+class Orientation(Enum):
+    """Represents building component orientations."""
+    NORTH = "North"
+    NORTHEAST = "Northeast"
+    EAST = "East"
+    SOUTHEAST = "Southeast"
+    SOUTH = "South"
+    SOUTHWEST = "Southwest"
+    WEST = "West"
+    NORTHWEST = "Northwest"
+    HORIZONTAL = "Horizontal"
+    NOT_APPLICABLE = "N/A"
 
-# Define paths
-DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+class ComponentType(Enum):
+    """Represents types of building components."""
+    WALL = "Wall"
+    ROOF = "Roof"
+    FLOOR = "Floor"
+    WINDOW = "Window"
+    DOOR = "Door"
 
+# --- Data Models ---
+@dataclass
+class BuildingComponent:
+    """Base class for building components."""
+    id: str
+    name: str
+    component_type: ComponentType
+    u_value: float  # W/(m²·K)
+    area: float  # m²
+    orientation: Orientation
+
+@dataclass
+class Wall(BuildingComponent):
+    """Wall component with thermal and solar properties."""
+    wall_type: str
+    wall_group: str
+    absorptivity: float
+    shading_coefficient: float
+    infiltration_rate_cfm: float
+    thermal_mass: float = 100000.0  # J/K
+    time_constant: float = 2.0      # hours
+
+@dataclass
+class Roof(BuildingComponent):
+    """Roof component with ventilation properties."""
+    roof_type: str
+    roof_group: str
+    slope: str
+    absorptivity: float
+    thermal_mass: float = 200000.0  # J/K
+    time_constant: float = 3.0      # hours
+
+@dataclass
+class Floor(BuildingComponent):
+    """Floor component with ground contact and insulation properties."""
+    floor_type: str
+    ground_contact: bool
+    ground_temperature_c: float
+    perimeter: float
+    insulated: bool = False
+    thermal_mass: float = 150000.0  # J/K
+    time_constant: float = 2.5      # hours
+
+@dataclass
+class Window(BuildingComponent):
+    """Window component with solar and frame properties."""
+    shgc: float
+    shading_device: str
+    shading_coefficient: float
+    frame_type: str
+    frame_percentage: float
+    infiltration_rate_cfm: float
+
+@dataclass
+class Door(BuildingComponent):
+    """Door component with infiltration properties."""
+    door_type: str
+    infiltration_rate_cfm: float
+
+# --- Constants ---
+AIR_DENSITY = 1.2  # kg/m³
+SPECIFIC_HEAT = 1000  # J/(kg·K)
+LATENT_HEAT_VAPORIZATION = 2260e3  # J/kg
+STANDARD_PRESSURE = 101325  # Pa
+GRAVITY = 9.81  # m/s²
+
+# --- Utility Classes (Embedded to Replace External Dependencies) ---
+class Psychrometrics:
+    """Simplified psychrometric calculations."""
+    def humidity_ratio(self, temp_c: float, rh: float) -> float:
+        """Calculate humidity ratio (kg/kg dry air)."""
+        p_sat = 610.78 * np.exp(17.2694 * temp_c / (temp_c + 237.3))
+        p_v = rh / 100 * p_sat
+        return 0.62198 * p_v / (STANDARD_PRESSURE - p_v)
+
+class HeatTransferCalculations:
+    """Simplified heat transfer calculations."""
+    def thermal_lag_factor(self, thermal_mass: float, time_constant: float, time_step: float) -> float:
+        """Calculate thermal lag factor for transient effects."""
+        return 1.0 - np.exp(-time_step / time_constant) if time_constant > 0 else 1.0
+
+    def wind_pressure_difference(self, wind_speed: float, wind_coefficient: float = 0.4) -> float:
+        """Calculate wind-induced pressure difference (Pa)."""
+        return 0.5 * AIR_DENSITY * wind_coefficient * wind_speed ** 2
+
+    def stack_pressure_difference(self, height: float, indoor_temp_k: float, outdoor_temp_k: float) -> float:
+        """Calculate stack effect pressure difference (Pa)."""
+        delta_t = abs(indoor_temp_k - outdoor_temp_k)
+        return 0.034 * AIR_DENSITY * height * delta_t / min(indoor_temp_k, outdoor_temp_k)
+
+    def combined_pressure_difference(self, wind_pd: float, stack_pd: float) -> float:
+        """Combine wind and stack pressure differences (Pa)."""
+        return np.sqrt(wind_pd ** 2 + stack_pd ** 2)
+
+    def crack_method_infiltration(self, crack_length: float, coefficient: float, pressure_difference: float) -> float:
+        """Calculate infiltration flow rate (m³/s)."""
+        flow_rate = coefficient * crack_length * np.sqrt(pressure_difference)
+        print(f"Infiltration: Crack Length: {crack_length} m, Pressure: {pressure_difference:.2f} Pa, Flow Rate: {flow_rate:.6f} m³/s")
+        return flow_rate
+
+    def infiltration_heat_transfer(self, flow_rate: float, delta_t: float) -> float:
+        """Calculate sensible heat transfer due to infiltration (W)."""
+        return AIR_DENSITY * SPECIFIC_HEAT * flow_rate * delta_t
+
+    def infiltration_latent_heat_transfer(self, flow_rate: float, delta_w: float) -> float:
+        """Calculate latent heat transfer due to infiltration (W)."""
+        return AIR_DENSITY * LATENT_HEAT_VAPORIZATION * flow_rate * delta_w
+
+# --- Heating Load Calculator ---
 class HeatingLoadCalculator:
-    """Class for calculating heating loads using enhanced steady-state methods."""
+    """Class for calculating heating loads with enhanced steady-state methods."""
     
     def __init__(self):
-        """Initialize heating load calculator with heat transfer and psychrometrics utilities."""
+        """Initialize with embedded utilities."""
         self.heat_transfer = HeatTransferCalculations()
         self.psychrometrics = Psychrometrics()
-    
+
     def validate_inputs(self, temp: float, rh: float, area: float, u_value: float, ground_temp: Optional[float] = None) -> None:
-        """
-        Validate input parameters for calculations.
-        
-        Args:
-            temp: Temperature in °C
-            rh: Relative humidity in %
-            area: Area in m²
-            u_value: U-value in W/(m²·K)
-            ground_temp: Ground temperature in °C (optional)
-            
-        Raises:
-            ValueError: If inputs are out of acceptable ranges
-        """
+        """Validate input parameters."""
         if not -50 <= temp <= 60:
             raise ValueError(f"Temperature {temp}°C is outside valid range (-50 to 60°C)")
         if not 0 <= rh <= 100:
@@ -53,309 +162,121 @@ class HeatingLoadCalculator:
             raise ValueError(f"U-value {u_value} W/(m²·K) cannot be negative")
         if ground_temp is not None and not -10 <= ground_temp <= 40:
             raise ValueError(f"Ground temperature {ground_temp}°C is outside valid range (-10 to 40°C)")
-    
+
     def calculate_wall_heating_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float) -> float:
-        """
-        Calculate heating load through a wall with thermal mass effects.
-        
-        Args:
-            wall: Wall object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            
-        Returns:
-            Heating load in W
-        """
+        """Calculate wall heating load with thermal mass effects."""
         self.validate_inputs(outdoor_temp, 80.0, wall.area, wall.u_value)
-        
-        u_value = wall.u_value
-        area = wall.area
         delta_t = indoor_temp - outdoor_temp
-        
-        # Apply thermal mass effect
-        thermal_mass = getattr(wall, "thermal_mass", 100000)  # J/K, default
-        time_constant = getattr(wall, "time_constant", 2.0)  # hours, default
-        lag_factor = self.heat_transfer.thermal_lag_factor(thermal_mass, time_constant, 1.0)
-        
-        heating_load = u_value * area * delta_t * lag_factor
-        
+        lag_factor = self.heat_transfer.thermal_lag_factor(wall.thermal_mass, wall.time_constant, 1.0)
+        heating_load = wall.u_value * wall.area * delta_t * lag_factor
         return max(0, heating_load)
-    
+
     def calculate_roof_heating_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float) -> float:
-        """
-        Calculate heating load through a roof with thermal mass effects.
-        
-        Args:
-            roof: Roof object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            
-        Returns:
-            Heating load in W
-        """
+        """Calculate roof heating load with thermal mass effects."""
         self.validate_inputs(outdoor_temp, 80.0, roof.area, roof.u_value)
-        
-        u_value = roof.u_value
-        area = roof.area
         delta_t = indoor_temp - outdoor_temp
-        
-        # Apply thermal mass effect
-        thermal_mass = getattr(roof, "thermal_mass", 200000)  # J/K, default
-        time_constant = getattr(roof, "time_constant", 3.0)  # hours, default
-        lag_factor = self.heat_transfer.thermal_lag_factor(thermal_mass, time_constant, 1.0)
-        
-        heating_load = u_value * area * delta_t * lag_factor
-        
+        lag_factor = self.heat_transfer.thermal_lag_factor(roof.thermal_mass, roof.time_constant, 1.0)
+        heating_load = roof.u_value * roof.area * delta_t * lag_factor
         return max(0, heating_load)
-    
+
     def calculate_floor_heating_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
-        """
-        Calculate heating load through a floor with thermal mass effects and perimeter losses.
-        
-        Args:
-            floor: Floor object
-            ground_temp: Ground or adjacent space temperature in °C
-            indoor_temp: Indoor temperature in °C
-            
-        Returns:
-            Heating load in W
-        """
-        self.validate_inputs(ground_temp, 80.0, floor.area, floor.u_value, ground_temp=ground_temp)
-        
-        heating_load = 0.0
+        """Calculate floor heating load with perimeter losses and thermal mass."""
+        self.validate_inputs(ground_temp, 80.0, floor.area, floor.u_value, ground_temp)
         delta_t = indoor_temp - ground_temp
-        
-        # Area-based conduction
-        u_value = floor.u_value
-        area = floor.area
-        thermal_mass = getattr(floor, "thermal_mass", 150000)  # J/K, default
-        time_constant = getattr(floor, "time_constant", 2.5)  # hours, default
-        lag_factor = self.heat_transfer.thermal_lag_factor(thermal_mass, time_constant, 1.0)
-        conduction_load = u_value * area * delta_t * lag_factor
-        
-        heating_load += conduction_load
-        
-        # NEW: Perimeter losses (F-factor method, ASHRAE Fundamentals Chapter 18)
-        if getattr(floor, 'ground_contact', False):
-            perimeter = getattr(floor, 'perimeter', 0.0)
-            if perimeter < 0:
-                raise ValueError(f"Perimeter for floor {floor.name} cannot be negative")
-            if perimeter > 0:
-                f_factor = 0.73  # W/(m·K) for uninsulated slab-on-grade (Table 18.3)
-                perimeter_load = f_factor * perimeter * delta_t
-                heating_load += perimeter_load
-        
+        lag_factor = self.heat_transfer.thermal_lag_factor(floor.thermal_mass, floor.time_constant, 1.0)
+        conduction_load = floor.u_value * floor.area * delta_t * lag_factor
+        f_factor = 0.3 if floor.insulated else 0.73  # Dynamic F-factor
+        perimeter_load = f_factor * floor.perimeter * delta_t if floor.ground_contact else 0
+        heating_load = conduction_load + perimeter_load
+        print(f"Floor {floor.name}: Conduction: {conduction_load:.2f} W, Perimeter: {perimeter_load:.2f} W, Total: {heating_load:.2f} W")
         return max(0, heating_load)
-    
+
     def calculate_window_heating_load(self, window: Window, outdoor_temp: float, indoor_temp: float) -> float:
-        """
-        Calculate heating load through a window using steady-state conduction.
-        
-        Args:
-            window: Window object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            
-        Returns:
-            Heating load in W
-        """
+        """Calculate window heating load."""
         self.validate_inputs(outdoor_temp, 80.0, window.area, window.u_value)
-        
-        u_value = window.u_value
-        area = window.area
         delta_t = indoor_temp - outdoor_temp
-        heating_load = u_value * area * delta_t
-        
-        return max(0, heating_load)
-    
+        return max(0, window.u_value * window.area * delta_t)
+
     def calculate_door_heating_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
-        """
-        Calculate heating load through a door using steady-state conduction.
-        
-        Args:
-            door: Door object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            
-        Returns:
-            Heating load in W
-        """
+        """Calculate door heating load."""
         self.validate_inputs(outdoor_temp, 80.0, door.area, door.u_value)
-        
-        u_value = door.u_value
-        area = door.area
         delta_t = indoor_temp - outdoor_temp
-        heating_load = u_value * area * delta_t
-        
-        return max(0, heating_load)
-    
+        return max(0, door.u_value * door.area * delta_t)
+
     def calculate_infiltration_heating_load(self, building_volume: float, outdoor_temp: float, 
                                            indoor_temp: float, outdoor_rh: float, indoor_rh: float,
                                            wind_speed: float = 4.0, height: float = 3.0,
-                                           crack_length: float = 10.0) -> Dict[str, float]:
-        """
-        Calculate sensible and latent heating loads due to pressure-driven infiltration.
-        
-        Args:
-            building_volume: Building volume in m³
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            outdoor_rh: Outdoor relative humidity in %
-            indoor_rh: Indoor relative humidity in %
-            wind_speed: Wind speed in m/s (default: 4.0 m/s)
-            height: Building height in m (default: 3.0 m)
-            crack_length: Total crack length in m (default: 10.0 m)
-            
-        Returns:
-            Dictionary with sensible, latent, and total heating loads in W
-        """
+                                           crack_length: float = 20.0) -> Dict[str, float]:
+        """Calculate infiltration heating loads."""
         self.validate_inputs(outdoor_temp, outdoor_rh, building_volume, 0.0)
-        
-        # Calculate infiltration flow rate
         wind_pd = self.heat_transfer.wind_pressure_difference(wind_speed, wind_coefficient=0.4)
-        stack_pd = self.heat_transfer.stack_pressure_difference(
-            height=height,
-            indoor_temp=indoor_temp + 273.15,
-            outdoor_temp=outdoor_temp + 273.15
-        )
+        stack_pd = self.heat_transfer.stack_pressure_difference(height, indoor_temp + 273.15, outdoor_temp + 273.15)
         total_pd = self.heat_transfer.combined_pressure_difference(wind_pd, stack_pd)
-        flow_rate = self.heat_transfer.crack_method_infiltration(
-            crack_length=crack_length,
-            coefficient=0.0001,
-            pressure_difference=total_pd
-        )
-        
-        # Calculate sensible heating load
-        sensible_load = self.heat_transfer.infiltration_heat_transfer(
-            flow_rate=flow_rate,
-            delta_t=indoor_temp - outdoor_temp
-        )
-        
-        # Calculate humidity ratios
+        flow_rate = self.heat_transfer.crack_method_infiltration(crack_length, coefficient=0.0002, total_pd)  # Adjusted coefficient
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(flow_rate, indoor_temp - outdoor_temp)
         w_outdoor = self.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
         w_indoor = self.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
-        
-        # Calculate latent heating load
-        delta_w = w_indoor - w_outdoor
-        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
-            flow_rate=flow_rate,
-            delta_w=delta_w
-        ) if delta_w > 0 else 0
-        
-        total_load = sensible_load + latent_load
-        
+        delta_w = max(0, w_indoor - w_outdoor)
+        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(flow_rate, delta_w)
         return {
             "sensible": max(0, sensible_load),
             "latent": max(0, latent_load),
-            "total": max(0, total_load)
+            "total": max(0, sensible_load + latent_load)
         }
-    
+
     def calculate_ventilation_heating_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
-                                         outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
-        """
-        Calculate sensible and latent heating loads due to ventilation.
-        
-        Args:
-            flow_rate: Ventilation flow rate in m³/s
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            outdoor_rh: Outdoor relative humidity in %
-            indoor_rh: Indoor relative humidity in %
-            
-        Returns:
-            Dictionary with sensible, latent, and total heating loads in W
-        """
+                                          outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+        """Calculate ventilation heating loads."""
         self.validate_inputs(outdoor_temp, outdoor_rh, 0.0, 0.0)
-        
-        sensible_load = self.heat_transfer.infiltration_heat_transfer(
-            flow_rate=flow_rate,
-            delta_t=indoor_temp - outdoor_temp
-        )
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(flow_rate, indoor_temp - outdoor_temp)
         w_outdoor = self.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
         w_indoor = self.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
-        delta_w = w_indoor - w_outdoor
-        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
-            flow_rate=flow_rate,
-            delta_w=delta_w
-        ) if delta_w > 0 else 0
-        total_load = sensible_load + latent_load
-        
+        delta_w = max(0, w_indoor - w_outdoor)
+        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(flow_rate, delta_w)
         return {
             "sensible": max(0, sensible_load),
             "latent": max(0, latent_load),
-            "total": max(0, total_load)
+            "total": max(0, sensible_load + latent_load)
         }
-    
+
     def calculate_internal_gains_offset(self, people_load: float, lights_load: float, 
-                                      equipment_load: float, usage_factor: float = 0.7,
-                                      hour: int = 0, schedule: Optional[List[float]] = None) -> float:
-        """
-        Calculate internal gains offset for heating load with schedule.
-        
-        Args:
-            people_load: Heat gain from people in W
-            lights_load: Heat gain from lights in W
-            equipment_load: Heat gain from equipment in W
-            usage_factor: Usage factor for internal gains (0-1)
-            hour: Hour of the day (0-23)
-            schedule: List of 24 hourly gain factors (0-1, default: None)
-            
-        Returns:
-            Internal gains offset in W
-        """
+                                       equipment_load: float, usage_factor: float = 0.7,
+                                       hour: int = 12, schedule: Optional[List[float]] = None) -> float:
+        """Calculate internal gains offset with schedule."""
         total_gains = people_load + lights_load + equipment_load
-        schedule_factor = 1.0
-        if schedule and len(schedule) == 24:
-            schedule_factor = schedule[hour]
-        offset = total_gains * usage_factor * schedule_factor
-        return max(0, offset)
-    
+        schedule_factor = schedule[hour] if schedule and len(schedule) == 24 else 1.0
+        return max(0, total_gains * usage_factor * schedule_factor)
+
     def calculate_design_heating_load(self, building_components: Dict[str, List[Any]], 
-                                    outdoor_conditions: Dict[str, Any],
-                                    indoor_conditions: Dict[str, Any],
-                                    internal_loads: Dict[str, Any],
-                                    building_volume: float = 300.0,
-                                    safety_factor: float = 1.15) -> Dict[str, float]:
-        """
-        Calculate design heating load for a building with enhanced calculations.
-        
-        Args:
-            building_components: Dictionary with lists of building components
-            outdoor_conditions: Dictionary with outdoor conditions
-            indoor_conditions: Dictionary with indoor conditions
-            internal_loads: Dictionary with internal loads
-            building_volume: Building volume in m³ (default: 300 m³)
-            safety_factor: Safety factor for heating load (default: 1.15)
-            
-        Returns:
-            Dictionary with design heating loads
-        """
-        walls = building_components.get("walls", [])
-        roofs = building_components.get("roofs", [])
-        floors = building_components.get("floors", [])
-        windows = building_components.get("windows", [])
-        doors = building_components.get("doors", [])
-        
+                                     outdoor_conditions: Dict[str, Any],
+                                     indoor_conditions: Dict[str, Any],
+                                     internal_loads: Dict[str, Any],
+                                     building_volume: float = 300.0,
+                                     safety_factor: float = 1.15) -> Dict[str, float]:
+        """Calculate design heating load."""
         outdoor_temp = outdoor_conditions.get("design_temperature", -10.0)
         outdoor_rh = outdoor_conditions.get("design_relative_humidity", 80.0)
         ground_temp = outdoor_conditions.get("ground_temperature", 10.0)
         wind_speed = outdoor_conditions.get("wind_speed", 4.0)
-        
         indoor_temp = indoor_conditions.get("temperature", 21.0)
         indoor_rh = indoor_conditions.get("relative_humidity", 40.0)
-        
-        people = internal_loads.get("people", {})
-        lights = internal_loads.get("lights", {})
-        equipment = internal_loads.get("equipment", {})
-        infiltration = internal_loads.get("infiltration", {})
-        ventilation = internal_loads.get("ventilation", {})
-        
+
+        # Climate skip logic
+        if outdoor_temp >= indoor_temp - 1:
+            return {
+                "walls": 0, "roofs": 0, "floors": 0, "windows": 0, "doors": 0,
+                "infiltration_sensible": 0, "infiltration_latent": 0,
+                "ventilation_sensible": 0, "ventilation_latent": 0,
+                "internal_gains_offset": 0, "subtotal": 0,
+                "safety_factor": safety_factor, "total": 0
+            }
+
         loads = {
-            "walls": 0,
-            "roofs": 0,
-            "floors": 0,
-            "windows": 0,
-            "doors": 0,
+            "walls": sum(self.calculate_wall_heating_load(wall, outdoor_temp, indoor_temp) for wall in building_components.get("walls", [])),
+            "roofs": sum(self.calculate_roof_heating_load(roof, outdoor_temp, indoor_temp) for roof in building_components.get("roofs", [])),
+            "floors": sum(self.calculate_floor_heating_load(floor, ground_temp, indoor_temp) for floor in building_components.get("floors", [])),
+            "windows": sum(self.calculate_window_heating_load(window, outdoor_temp, indoor_temp) for window in building_components.get("windows", [])),
+            "doors": sum(self.calculate_door_heating_load(door, outdoor_temp, indoor_temp) for door in building_components.get("doors", [])),
             "infiltration_sensible": 0,
             "infiltration_latent": 0,
             "ventilation_sensible": 0,
@@ -365,99 +286,51 @@ class HeatingLoadCalculator:
             "safety_factor": safety_factor,
             "total": 0
         }
-        
-        # Calculate loads
-        for wall in walls:
-            loads["walls"] += self.calculate_wall_heating_load(wall, outdoor_temp, indoor_temp)
-        for roof in roofs:
-            loads["roofs"] += self.calculate_roof_heating_load(roof, outdoor_temp, indoor_temp)
-        for floor in floors:
-            loads["floors"] += self.calculate_floor_heating_load(floor, ground_temp, indoor_temp)
-        for window in windows:
-            loads["windows"] += self.calculate_window_heating_load(window, outdoor_temp, indoor_temp)
-        for door in doors:
-            loads["doors"] += self.calculate_door_heating_load(door, outdoor_temp, indoor_temp)
-        
-        # Calculate infiltration loads
-        if infiltration:
+
+        if internal_loads.get("infiltration"):
             infiltration_loads = self.calculate_infiltration_heating_load(
-                building_volume=building_volume,
-                outdoor_temp=outdoor_temp,
-                indoor_temp=indoor_temp,
-                outdoor_rh=outdoor_rh,
-                indoor_rh=indoor_rh,
-                wind_speed=wind_speed,
-                height=infiltration.get("height", 3.0),
-                crack_length=infiltration.get("crack_length", 10.0)
+                building_volume, outdoor_temp, indoor_temp, outdoor_rh, indoor_rh,
+                wind_speed, internal_loads["infiltration"].get("height", 3.0),
+                internal_loads["infiltration"].get("crack_length", 20.0)
             )
             loads["infiltration_sensible"] = infiltration_loads["sensible"]
             loads["infiltration_latent"] = infiltration_loads["latent"]
-        
-        # Calculate ventilation loads
-        if ventilation:
+
+        if internal_loads.get("ventilation"):
             ventilation_loads = self.calculate_ventilation_heating_load(
-                flow_rate=ventilation.get("flow_rate", 0.1),
-                outdoor_temp=outdoor_temp,
-                indoor_temp=indoor_temp,
-                outdoor_rh=outdoor_rh,
-                indoor_rh=indoor_rh
+                internal_loads["ventilation"].get("flow_rate", 0.1),
+                outdoor_temp, indoor_temp, outdoor_rh, indoor_rh
             )
             loads["ventilation_sensible"] = ventilation_loads["sensible"]
             loads["ventilation_latent"] = ventilation_loads["latent"]
-        
-        # Calculate internal gains offset
+
+        people = internal_loads.get("people", {})
+        lights = internal_loads.get("lights", {})
+        equipment = internal_loads.get("equipment", {})
         people_load = people.get("number", 0) * people.get("sensible_gain", 70.0)
         lights_load = lights.get("power", 0) * lights.get("use_factor", 0.8)
         equipment_load = equipment.get("power", 0) * equipment.get("use_factor", 0.7)
-        
+
         schedule = None
         operating_hours = internal_loads.get("operating_hours", "8:00-18:00")
         if operating_hours:
             start_hour = int(operating_hours.split(":")[0])
             end_hour = int(operating_hours.split("-")[1].split(":")[0])
             schedule = [1.0 if start_hour <= h % 24 < end_hour else 0.5 for h in range(24)]
-        
+
         loads["internal_gains_offset"] = self.calculate_internal_gains_offset(
-            people_load=people_load,
-            lights_load=lights_load,
-            equipment_load=equipment_load,
-            usage_factor=internal_loads.get("usage_factor", 0.7),
-            hour=12,  # Assume peak load at noon
-            schedule=schedule
-        )
-        
-        # Calculate subtotal
-        loads["subtotal"] = (
-            loads["walls"] +
-            loads["roofs"] +
-            loads["floors"] +
-            loads["windows"] +
-            loads["doors"] +
-            loads["infiltration_sensible"] +
-            loads["infiltration_latent"] +
-            loads["ventilation_sensible"] +
-            loads["ventilation_latent"]
+            people_load, lights_load, equipment_load,
+            internal_loads.get("usage_factor", 0.7), hour=12, schedule=schedule
         )
-        
-        # Apply internal gains offset and prevent negative loads
-        loads["total"] = max(0, loads["subtotal"] - loads["internal_gains_offset"])
-        
-        # Apply safety factor
-        loads["total"] *= safety_factor
-        
+
+        loads["subtotal"] = sum(v for k, v in loads.items() if k not in ["internal_gains_offset", "subtotal", "safety_factor", "total"])
+        loads["total"] = max(0, loads["subtotal"] - loads["internal_gains_offset"]) * safety_factor / 1000  # kW
+
         return loads
-    
+
     def calculate_heating_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
-        """
-        Summarize heating loads for reporting.
-        
-        Args:
-            design_loads: Dictionary with design heating loads
-            
-        Returns:
-            Summary dictionary with key load components
-        """
-        summary = {
+        """Summarize heating loads for reporting."""
+        return {
             "walls": design_loads.get("walls", 0),
             "roofs": design_loads.get("roofs", 0),
             "floors": design_loads.get("floors", 0),
@@ -468,108 +341,103 @@ class HeatingLoadCalculator:
             "internal_gains_offset": design_loads.get("internal_gains_offset", 0),
             "subtotal": design_loads.get("subtotal", 0),
             "safety_factor": design_loads.get("safety_factor", 1.15),
-            "total": design_loads.get("total", 0)
+            "total": design_loads.get("total", 0) * 1000  # W
         }
-        return summary
-    
+
     def calculate_monthly_heating_loads(self, building_components: Dict[str, List[Any]], 
-                                      monthly_temps: Dict[str, float], ground_temps: Dict[str, float],
-                                      indoor_conditions: Dict[str, Any], internal_loads: Dict[str, Any],
-                                      building_volume: float = 300.0) -> Dict[str, float]:
-        """
-        Calculate monthly heating loads using monthly average temperatures.
-        
-        Args:
-            building_components: Dictionary with lists of building components
-            monthly_temps: Dictionary with monthly outdoor temperatures (°C)
-            ground_temps: Dictionary with monthly ground temperatures (°C)
-            indoor_conditions: Dictionary with indoor conditions
-            internal_loads: Dictionary with internal loads
-            building_volume: Building volume in m³ (default: 300 m³)
-            
-        Returns:
-            Dictionary with monthly heating loads in W
-        """
+                                       monthly_temps: Dict[str, float], ground_temps: Dict[str, float],
+                                       indoor_conditions: Dict[str, Any], internal_loads: Dict[str, Any],
+                                       building_volume: float = 300.0) -> Dict[str, float]:
+        """Calculate monthly heating loads."""
         monthly_loads = {}
         indoor_temp = indoor_conditions.get("temperature", 21.0)
         indoor_rh = indoor_conditions.get("relative_humidity", 40.0)
-        
+
         for month, outdoor_temp in monthly_temps.items():
-            ground_temp = ground_temps.get(month, outdoor_temp)  # Fallback to outdoor temp if ground temp missing
+            ground_temp = ground_temps.get(month, outdoor_temp)
             outdoor_conditions = {
                 "design_temperature": outdoor_temp,
-                "design_relative_humidity": 80.0,  # Assume constant for simplicity
+                "design_relative_humidity": 80.0,
                 "ground_temperature": ground_temp,
                 "wind_speed": 4.0
             }
-            
-            # Skip if no heating is needed
             if outdoor_temp >= indoor_temp:
                 monthly_loads[month] = 0.0
                 continue
-            
             loads = self.calculate_design_heating_load(
-                building_components=building_components,
-                outdoor_conditions=outdoor_conditions,
-                indoor_conditions=indoor_conditions,
-                internal_loads=internal_loads,
-                building_volume=building_volume,
-                safety_factor=1.0  # No safety factor for monthly loads
+                building_components, outdoor_conditions, indoor_conditions,
+                internal_loads, building_volume, safety_factor=1.0
             )
-            monthly_loads[month] = max(0, loads["total"])
-        
+            monthly_loads[month] = loads["total"] * 1000  # W
         return monthly_loads
-    
+
     def calculate_heating_degree_days(self, monthly_temps: Dict[str, float], base_temp: float = 18.3) -> float:
-        """
-        Calculate annual heating degree days.
-        
-        Args:
-            monthly_temps: Dictionary with monthly outdoor temperatures (°C)
-            base_temp: Base temperature for degree days (°C, default: 18.3°C)
-            
-        Returns:
-            Total heating degree days
-        """
-        hdd = 0.0
+        """Calculate annual heating degree days."""
         days_per_month = {
             "Jan": 31, "Feb": 28, "Mar": 31, "Apr": 30, "May": 31, "Jun": 30,
             "Jul": 31, "Aug": 31, "Sep": 30, "Oct": 31, "Nov": 30, "Dec": 31
         }
-        
+        hdd = 0.0
         for month, temp in monthly_temps.items():
             if temp < base_temp:
                 hdd += (base_temp - temp) * days_per_month.get(month, 30)
-        
         return hdd
-    
+
     def calculate_annual_heating_energy(self, monthly_loads: Dict[str, float], 
                                        operating_hours: str = "8:00-18:00") -> float:
-        """
-        Calculate annual heating energy consumption.
-        
-        Args:
-            monthly_loads: Dictionary with monthly heating loads in W
-            operating_hours: Operating hours (e.g., "8:00-18:00")
-            
-        Returns:
-            Annual heating energy in kWh
-        """
-        hours_per_day = 10.0  # Default 10 hours
+        """Calculate annual heating energy in kWh."""
+        hours_per_day = 10.0
         if operating_hours:
             start_hour = int(operating_hours.split(":")[0])
             end_hour = int(operating_hours.split("-")[1].split(":")[0])
             hours_per_day = end_hour - start_hour
-        
         days_per_month = {
             "Jan": 31, "Feb": 28, "Mar": 31, "Apr": 30, "May": 31, "Jun": 30,
             "Jul": 31, "Aug": 31, "Sep": 30, "Oct": 31, "Nov": 30, "Dec": 31
         }
-        
         total_energy = 0.0
         for month, load in monthly_loads.items():
             hours = hours_per_day * days_per_month.get(month, 30)
-            energy = load * hours / 1000  # Convert W to kW
+            energy = load * hours / 1000 / 1000  # W to kWh
             total_energy += energy
-        
-        return total_energy
+        return total_energy
+
+# --- Example Execution ---
+if __name__ == "__main__":
+    """Example with Geelong debug inputs."""
+    calculator = HeatingLoadCalculator()
+    components = {
+        "walls": [Wall(id="w1", name="Wall 1", component_type=ComponentType.WALL, u_value=0.5, area=120, orientation=Orientation.NOT_APPLICABLE, wall_type="Brick", wall_group="A", absorptivity=0.6, shading_coefficient=1.0, infiltration_rate_cfm=0)],
+        "roofs": [Roof(id="r1", name="Roof 1", component_type=ComponentType.ROOF, u_value=0.3, area=100, orientation=Orientation.HORIZONTAL, roof_type="Concrete", roof_group="A", slope="Flat", absorptivity=0.6)],
+        "floors": [Floor(id="f1", name="Main Floor", component_type=ComponentType.FLOOR, u_value=0.4, area=100, orientation=Orientation.NOT_APPLICABLE, floor_type="Concrete", ground_contact=True, ground_temperature_c=16.0, perimeter=40.0, insulated=True)],
+        "windows": [Window(id="win1", name="Window 1", component_type=ComponentType.WINDOW, u_value=2.0, area=1, orientation=Orientation.NOT_APPLICABLE, shgc=0.7, shading_device="None", shading_coefficient=1.0, frame_type="Aluminum", frame_percentage=20, infiltration_rate_cfm=0)],
+        "doors": [Door(id="d1", name="Door 1", component_type=ComponentType.DOOR, u_value=2.0, area=1, orientation=Orientation.NOT_APPLICABLE, door_type="Solid Wood", infiltration_rate_cfm=0)]
+    }
+    outdoor_conditions = {
+        "design_temperature": 17.5,
+        "design_relative_humidity": 81.3,
+        "ground_temperature": 16.0,
+        "wind_speed": 4.0
+    }
+    indoor_conditions = {
+        "temperature": 21.0,
+        "relative_humidity": 40.0
+    }
+    internal_loads = {
+        "people": {"number": 1, "sensible_gain": 70.0},
+        "lights": {"power": 200.0, "use_factor": 0.8},
+        "equipment": {"power": 100.0, "use_factor": 0.7},
+        "infiltration": {"height": 3.0, "crack_length": 20.0},
+        "ventilation": {"flow_rate": 0.115},
+        "operating_hours": "8:00-18:00",
+        "usage_factor": 0.7
+    }
+    result = calculator.calculate_design_heating_load(components, outdoor_conditions, indoor_conditions, internal_loads, building_volume=300.0)
+    print(f"Total Heating Load: {result['total']:.2f} kW")
+    print(f"Summary: {calculator.calculate_heating_load_summary(result)}")
+    monthly_temps = {"Jul": 17.5}
+    ground_temps = {"Jul": 16.0}
+    monthly_result = calculator.calculate_monthly_heating_loads(components, monthly_temps, ground_temps, indoor_conditions, internal_loads)
+    print(f"Monthly Loads: {monthly_result}")
+    annual_energy = calculator.calculate_annual_heating_energy(monthly_result)
+    print(f"Annual Energy: {annual_energy:.2f} kWh")