Update utils/heating_load.py

utils/heating_load.py

@@ -1,443 +1,536 @@
 """
 Heating load calculation module for HVAC Load Calculator.
-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).
+Implements ASHRAE steady-state methods with thermal mass effects and annual energy calculations.
 """
 
-from typing import Dict, List, Any, Optional
+from typing import Dict, List, Any, Optional, Tuple
 import math
 import numpy as np
-from datetime import datetime, time
 from enum import Enum
+from dataclasses import dataclass
 
-# --- 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"
+# Import utility modules
+from utils.psychrometrics import Psychrometrics
+from utils.heat_transfer import HeatTransferCalculations
 
-class ComponentType(Enum):
-    """Represents types of building components."""
-    WALL = "Wall"
-    ROOF = "Roof"
-    FLOOR = "Floor"
-    WINDOW = "Window"
-    DOOR = "Door"
+# Import data modules (assumed to match embedded classes; replace with actual imports if provided)
+from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
 
-# --- 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 with enhanced steady-state methods."""
+    """Class for heating load calculations based on ASHRAE steady-state methods."""
     
     def __init__(self):
-        """Initialize with embedded utilities."""
-        self.heat_transfer = HeatTransferCalculations()
+        """Initialize heating load calculator with psychrometric and heat transfer calculations."""
         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."""
-        if not -50 <= temp <= 60:
-            raise ValueError(f"Temperature {temp}°C is outside valid range (-50 to 60°C)")
-        if not 0 <= rh <= 100:
-            raise ValueError(f"Relative humidity {rh}% is outside valid range (0 to 100%)")
-        if area < 0:
-            raise ValueError(f"Area {area}m² cannot be negative")
-        if u_value < 0:
-            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)")
+        self.heat_transfer = HeatTransferCalculations()
+        self.safety_factor = 1.15  # 15% safety factor for design loads
+
+    def validate_inputs(self, components: Dict[str, List[Any]], outdoor_temp: float, indoor_temp: float) -> None:
+        """
+        Validate input parameters for heating load calculations.
+        
+        Args:
+            components: Dictionary of building components
+            outdoor_temp: Outdoor design temperature in °C
+            indoor_temp: Indoor design temperature in °C
+            
+        Raises:
+            ValueError: If inputs are invalid
+        """
+        if not components:
+            raise ValueError("Building components dictionary cannot be empty")
+        for component_type, comp_list in components.items():
+            if not isinstance(comp_list, list):
+                raise ValueError(f"Components for {component_type} must be a list")
+            for comp in comp_list:
+                if not hasattr(comp, 'area') or comp.area <= 0:
+                    raise ValueError(f"Invalid area for {component_type}: {comp.name}")
+                if not hasattr(comp, 'u_value') or comp.u_value <= 0:
+                    raise ValueError(f"Invalid U-value for {component_type}: {comp.name}")
+        if not -50 <= outdoor_temp <= 60 or not -50 <= indoor_temp <= 60:
+            raise ValueError("Temperatures must be between -50°C and 60°C")
+        if indoor_temp - outdoor_temp < 1:
+            raise ValueError("Indoor temperature must be at least 1°C above outdoor temperature for heating")
 
     def calculate_wall_heating_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float) -> float:
-        """Calculate wall heating load with thermal mass effects."""
-        self.validate_inputs(outdoor_temp, 80.0, wall.area, wall.u_value)
+        """
+        Calculate heating load for a wall, including thermal lag effects.
+        
+        Args:
+            wall: Wall component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
         delta_t = indoor_temp - outdoor_temp
-        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)
+        if delta_t <= 1:
+            return 0.0  # Skip calculation for small temperature differences
+        
+        # Apply thermal lag factor
+        time_step = 1.0  # Hourly time step
+        lag_factor = self.heat_transfer.thermal_lag_factor(wall.thermal_mass, wall.time_constant, time_step)
+        adjusted_delta_t = delta_t * lag_factor
+        
+        load = self.heat_transfer.conduction_heat_transfer(wall.u_value, wall.area, adjusted_delta_t)
+        return max(0, load)
 
     def calculate_roof_heating_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float) -> float:
-        """Calculate roof heating load with thermal mass effects."""
-        self.validate_inputs(outdoor_temp, 80.0, roof.area, roof.u_value)
+        """
+        Calculate heating load for a roof, including thermal lag effects.
+        
+        Args:
+            roof: Roof component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
         delta_t = indoor_temp - outdoor_temp
-        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)
+        if delta_t <= 1:
+            return 0.0
+        
+        time_step = 1.0
+        lag_factor = self.heat_transfer.thermal_lag_factor(roof.thermal_mass, roof.time_constant, time_step)
+        adjusted_delta_t = delta_t * lag_factor
+        
+        load = self.heat_transfer.conduction_heat_transfer(roof.u_value, roof.area, adjusted_delta_t)
+        return max(0, load)
 
     def calculate_floor_heating_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
-        """Calculate floor heating load with perimeter losses and thermal mass."""
-        self.validate_inputs(ground_temp, 80.0, floor.area, floor.u_value, ground_temp)
+        """
+        Calculate heating load for a floor, using dynamic F-factor for ground contact.
+        
+        Args:
+            floor: Floor component
+            ground_temp: Ground temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
         delta_t = indoor_temp - ground_temp
-        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)
+        if delta_t <= 1:
+            return 0.0
+        
+        if floor.ground_contact:
+            # Dynamic F-factor based on insulation
+            f_factor = 0.3 if floor.insulated else 0.73  # W/m·K
+            load = f_factor * floor.perimeter * delta_t
+        else:
+            load = self.heat_transfer.conduction_heat_transfer(floor.u_value, floor.area, delta_t)
+        
+        if hasattr(st.session_state, 'debug_mode') and st.session_state.debug_mode:
+            print(f"Debug: Floor {floor.name} load: {load:.2f} W, Delta T: {delta_t:.2f}°C")
+        
+        return max(0, load)
 
     def calculate_window_heating_load(self, window: Window, outdoor_temp: float, indoor_temp: float) -> float:
-        """Calculate window heating load."""
-        self.validate_inputs(outdoor_temp, 80.0, window.area, window.u_value)
+        """
+        Calculate heating load for a window.
+        
+        Args:
+            window: Window component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
         delta_t = indoor_temp - outdoor_temp
-        return max(0, window.u_value * window.area * delta_t)
+        if delta_t <= 1:
+            return 0.0
+        
+        load = self.heat_transfer.conduction_heat_transfer(window.u_value, window.area, delta_t)
+        return max(0, load)
 
     def calculate_door_heating_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
-        """Calculate door heating load."""
-        self.validate_inputs(outdoor_temp, 80.0, door.area, door.u_value)
+        """
+        Calculate heating load for a door.
+        
+        Args:
+            door: Door component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
         delta_t = indoor_temp - outdoor_temp
-        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 = 20.0) -> Dict[str, float]:
-        """Calculate infiltration heating loads."""
-        self.validate_inputs(outdoor_temp, outdoor_rh, building_volume, 0.0)
-        wind_pd = self.heat_transfer.wind_pressure_difference(wind_speed, wind_coefficient=0.4)
-        stack_pd = self.heat_transfer.stack_pressure_difference(height, indoor_temp + 273.15, outdoor_temp + 273.15)
+        if delta_t <= 1:
+            return 0.0
+        
+        load = self.heat_transfer.conduction_heat_transfer(door.u_value, door.area, delta_t)
+        return max(0, load)
+
+    def calculate_infiltration_heating_load(self, indoor_conditions: Dict[str, float], 
+                                          outdoor_conditions: Dict[str, float], 
+                                          infiltration: Dict[str, float], 
+                                          building_height: float) -> Tuple[float, float]:
+        """
+        Calculate sensible and latent heating loads due to infiltration.
+        
+        Args:
+            indoor_conditions: Indoor conditions (temperature, relative_humidity)
+            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity, wind_speed)
+            infiltration: Infiltration parameters (flow_rate, crack_length, height)
+            building_height: Building height in m
+            
+        Returns:
+            Tuple of sensible and latent loads in W
+        """
+        delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
+        if delta_t <= 1:
+            return 0.0, 0.0
+        
+        # Calculate pressure differences
+        wind_pd = self.heat_transfer.wind_pressure_difference(outdoor_conditions['wind_speed'])
+        stack_pd = self.heat_transfer.stack_pressure_difference(
+            building_height, 
+            indoor_conditions['temperature'] + 273.15, 
+            outdoor_conditions['design_temperature'] + 273.15
+        )
         total_pd = self.heat_transfer.combined_pressure_difference(wind_pd, stack_pd)
-        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 infiltration flow rate
+        crack_length = infiltration.get('crack_length', 20.0)
+        flow_rate = self.heat_transfer.crack_method_infiltration(crack_length, 0.0002, total_pd)
+        
+        # Calculate humidity ratio difference
+        w_indoor = self.psychrometrics.humidity_ratio(
+            indoor_conditions['temperature'], 
+            indoor_conditions['relative_humidity']
+        )
+        w_outdoor = self.psychrometrics.humidity_ratio(
+            outdoor_conditions['design_temperature'], 
+            outdoor_conditions['design_relative_humidity']
+        )
         delta_w = max(0, w_indoor - w_outdoor)
+        
+        # Calculate sensible and latent loads
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(flow_rate, delta_t)
         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, 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 ventilation heating loads."""
-        self.validate_inputs(outdoor_temp, outdoor_rh, 0.0, 0.0)
-        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)
+        
+        if hasattr(st.session_state, 'debug_mode') and st.session_state.debug_mode:
+            print(f"Debug: Infiltration flow rate: {flow_rate:.6f} m³/s, Sensible load: {sensible_load:.2f} W, Latent load: {latent_load:.2f} W")
+        
+        return max(0, sensible_load), max(0, latent_load)
+
+    def calculate_ventilation_heating_load(self, ventilation: Dict[str, float], 
+                                         indoor_conditions: Dict[str, float], 
+                                         outdoor_conditions: Dict[str, float]) -> Tuple[float, float]:
+        """
+        Calculate sensible and latent heating loads due to ventilation.
+        
+        Args:
+            ventilation: Ventilation parameters (flow_rate)
+            indoor_conditions: Indoor conditions (temperature, relative_humidity)
+            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity)
+            
+        Returns:
+            Tuple of sensible and latent loads in W
+        """
+        delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
+        if delta_t <= 1:
+            return 0.0, 0.0
+        
+        flow_rate = ventilation['flow_rate']
+        
+        w_indoor = self.psychrometrics.humidity_ratio(
+            indoor_conditions['temperature'], 
+            indoor_conditions['relative_humidity']
+        )
+        w_outdoor = self.psychrometrics.humidity_ratio(
+            outdoor_conditions['design_temperature'], 
+            outdoor_conditions['design_relative_humidity']
+        )
         delta_w = max(0, w_indoor - w_outdoor)
+        
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(flow_rate, delta_t)
         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, 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 = 12, schedule: Optional[List[float]] = None) -> float:
-        """Calculate internal gains offset with schedule."""
-        total_gains = people_load + lights_load + equipment_load
-        schedule_factor = schedule[hour] if schedule and len(schedule) == 24 else 1.0
-        return max(0, total_gains * usage_factor * schedule_factor)
+        
+        return max(0, sensible_load), max(0, latent_load)
+
+    def calculate_internal_gains(self, internal_loads: Dict[str, Any]) -> float:
+        """
+        Calculate internal heat gains from people, lighting, and equipment.
+        
+        Args:
+            internal_loads: Internal loads (people, lights, equipment)
+            
+        Returns:
+            Total internal gains in W
+        """
+        total_gains = 0.0
+        
+        # People gains
+        people = internal_loads.get('people', {})
+        if people.get('number', 0) > 0:
+            sensible_gain = people.get('sensible_gain', 70.0)
+            total_gains += people['number'] * sensible_gain
+        
+        # Lighting gains
+        lights = internal_loads.get('lights', {})
+        if lights.get('power', 0) > 0:
+            total_gains += lights['power'] * lights.get('use_factor', 0.8)
+        
+        # Equipment gains
+        equipment = internal_loads.get('equipment', {})
+        if equipment.get('power', 0) > 0:
+            total_gains += equipment['power'] * equipment.get('use_factor', 0.7)
+        
+        return max(0, total_gains)
 
     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."""
-        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)
-
-        # 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
-            }
-
+                                    outdoor_conditions: Dict[str, float], 
+                                    indoor_conditions: Dict[str, float], 
+                                    internal_loads: Dict[str, Any]) -> Dict[str, float]:
+        """
+        Calculate design heating loads for all components.
+        
+        Args:
+            building_components: Dictionary of building components
+            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity, ground_temperature, wind_speed)
+            indoor_conditions: Indoor conditions (temperature, relative_humidity)
+            internal_loads: Internal loads (people, lights, equipment, infiltration, ventilation)
+            
+        Returns:
+            Dictionary of design loads in W
+        """
+        try:
+            self.validate_inputs(building_components, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        except ValueError as e:
+            raise ValueError(f"Input validation failed: {str(e)}")
+        
         loads = {
-            "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,
-            "ventilation_latent": 0,
-            "internal_gains_offset": 0,
-            "subtotal": 0,
-            "safety_factor": safety_factor,
-            "total": 0
+            'walls': 0.0,
+            'roofs': 0.0,
+            'floors': 0.0,
+            'windows': 0.0,
+            'doors': 0.0,
+            'infiltration_sensible': 0.0,
+            'infiltration_latent': 0.0,
+            'ventilation_sensible': 0.0,
+            'ventilation_latent': 0.0,
+            'internal_gains': 0.0
         }
-
-        if internal_loads.get("infiltration"):
-            infiltration_loads = self.calculate_infiltration_heating_load(
-                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"]
-
-        if internal_loads.get("ventilation"):
-            ventilation_loads = self.calculate_ventilation_heating_load(
-                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"]
-
-        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, lights_load, equipment_load,
-            internal_loads.get("usage_factor", 0.7), hour=12, schedule=schedule
+        
+        # Calculate envelope loads
+        for wall in building_components.get('walls', []):
+            loads['walls'] += self.calculate_wall_heating_load(wall, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        for roof in building_components.get('roofs', []):
+            loads['roofs'] += self.calculate_roof_heating_load(roof, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        for floor in building_components.get('floors', []):
+            loads['floors'] += self.calculate_floor_heating_load(floor, outdoor_conditions['ground_temperature'], indoor_conditions['temperature'])
+        
+        for window in building_components.get('windows', []):
+            loads['windows'] += self.calculate_window_heating_load(window, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        for door in building_components.get('doors', []):
+            loads['doors'] += self.calculate_door_heating_load(door, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
+        # Calculate infiltration and ventilation loads
+        building_height = internal_loads.get('infiltration', {}).get('height', 3.0)
+        infiltration_sensible, infiltration_latent = self.calculate_infiltration_heating_load(
+            indoor_conditions, outdoor_conditions, internal_loads.get('infiltration', {}), building_height
         )
-
-        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
-
+        loads['infiltration_sensible'] = infiltration_sensible
+        loads['infiltration_latent'] = infiltration_latent
+        
+        ventilation_sensible, ventilation_latent = self.calculate_ventilation_heating_load(
+            internal_loads.get('ventilation', {}), indoor_conditions, outdoor_conditions
+        )
+        loads['ventilation_sensible'] = ventilation_sensible
+        loads['ventilation_latent'] = ventilation_latent
+        
+        # Calculate internal gains (negative for heating)
+        loads['internal_gains'] = -self.calculate_internal_gains(internal_loads)
+        
         return loads
 
     def calculate_heating_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
-        """Summarize heating loads for reporting."""
+        """
+        Summarize heating loads with safety factor.
+        
+        Args:
+            design_loads: Dictionary of design loads in W
+            
+        Returns:
+            Summary dictionary with total, subtotal, and safety factor
+        """
+        subtotal = sum(
+            load for key, load in design_loads.items()
+            if key not in ['internal_gains'] and load > 0
+        )
+        internal_gains = design_loads.get('internal_gains', 0)
+        
+        total = max(0, subtotal + internal_gains) * self.safety_factor
+        
         return {
-            "walls": design_loads.get("walls", 0),
-            "roofs": design_loads.get("roofs", 0),
-            "floors": design_loads.get("floors", 0),
-            "windows": design_loads.get("windows", 0),
-            "doors": design_loads.get("doors", 0),
-            "infiltration": design_loads.get("infiltration_sensible", 0) + design_loads.get("infiltration_latent", 0),
-            "ventilation": design_loads.get("ventilation_sensible", 0) + design_loads.get("ventilation_latent", 0),
-            "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) * 1000  # W
+            'subtotal': subtotal,
+            'internal_gains': internal_gains,
+            'total': total,
+            'safety_factor': self.safety_factor
         }
 
-    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."""
-        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)
-            outdoor_conditions = {
-                "design_temperature": outdoor_temp,
-                "design_relative_humidity": 80.0,
-                "ground_temperature": ground_temp,
-                "wind_speed": 4.0
-            }
-            if outdoor_temp >= indoor_temp:
-                monthly_loads[month] = 0.0
-                continue
-            loads = self.calculate_design_heating_load(
-                building_components, outdoor_conditions, indoor_conditions,
-                internal_loads, building_volume, safety_factor=1.0
-            )
-            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."""
+    def calculate_heating_degree_days(self, base_temp: float, monthly_temps: Dict[str, float]) -> float:
+        """
+        Calculate heating degree days for a year.
+        
+        Args:
+            base_temp: Base temperature for HDD calculation in °C
+            monthly_temps: Dictionary of monthly average temperatures
+            
+        Returns:
+            Total heating degree days
+        """
+        hdd = 0.0
         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
+            '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)
+                hdd += (base_temp - temp) * days_per_month[month]
+        
         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 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
+    def calculate_annual_heating_energy(self, design_loads: Dict[str, float], 
+                                      monthly_temps: Dict[str, float], 
+                                      indoor_temp: float, 
+                                      operating_hours: str) -> float:
+        """
+        Calculate annual heating energy consumption.
+        
+        Args:
+            design_loads: Dictionary of design loads in W
+            monthly_temps: Dictionary of monthly average temperatures
+            indoor_temp: Indoor design temperature in °C
+            operating_hours: Operating hours (e.g., '8:00-18:00')
+            
+        Returns:
+            Annual heating energy in kWh
+        """
+        base_temp = indoor_temp
+        hdd = self.calculate_heating_degree_days(base_temp, monthly_temps)
+        
+        # Parse operating hours
+        start_hour, end_hour = map(lambda x: int(x.split(':')[0]), operating_hours.split('-'))
+        daily_hours = end_hour - start_hour
+        
+        # Calculate design condition degree days
+        design_temp = min(monthly_temps.values())
+        design_delta_t = indoor_temp - design_temp
+        if design_delta_t <= 1:
+            return 0.0
+        
+        total_load = self.calculate_heating_load_summary(design_loads)['total']
+        
+        # Scale load by HDD and operating hours
+        annual_energy = (total_load / design_delta_t) * hdd * (daily_hours / 24) / 1000  # kWh
+        
+        return max(0, annual_energy)
+
+    def calculate_monthly_heating_loads(self, building_components: Dict[str, List[Any]], 
+                                      outdoor_conditions: Dict[str, float], 
+                                      indoor_conditions: Dict[str, float], 
+                                      internal_loads: Dict[str, Any], 
+                                      monthly_temps: Dict[str, float]) -> Dict[str, float]:
+        """
+        Calculate monthly heating loads.
+        
+        Args:
+            building_components: Dictionary of building components
+            outdoor_conditions: Outdoor conditions
+            indoor_conditions: Indoor conditions
+            internal_loads: Internal loads
+            monthly_temps: Dictionary of monthly average temperatures
+            
+        Returns:
+            Dictionary of monthly heating loads in kW
+        """
+        monthly_loads = {}
         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
+            '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 / 1000  # W to kWh
-            total_energy += energy
-        return total_energy
+        
+        for month, temp in monthly_temps.items():
+            modified_outdoor = outdoor_conditions.copy()
+            modified_outdoor['design_temperature'] = temp
+            modified_outdoor['ground_temperature'] = temp
+            
+            try:
+                design_loads = self.calculate_design_heating_load(
+                    building_components, modified_outdoor, indoor_conditions, internal_loads
+                )
+                summary = self.calculate_heating_load_summary(design_loads)
+                monthly_loads[month] = summary['total'] / 1000  # kW
+            except ValueError:
+                monthly_loads[month] = 0.0  # Skip invalid months
+        
+        return monthly_loads
 
-# --- Example Execution ---
+# Example usage
 if __name__ == "__main__":
-    """Example with Geelong debug inputs."""
+    import streamlit as st
+    
     calculator = HeatingLoadCalculator()
+    
+    # Example building components
     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)]
+        'walls': [Wall(name="North Wall", area=20.0, u_value=0.5, orientation=Orientation.NORTH, thermal_mass=50000, time_constant=12.0)],
+        'roofs': [Roof(name="Main Roof", area=100.0, u_value=0.3, orientation=Orientation.HORIZONTAL, thermal_mass=60000, time_constant=15.0)],
+        'floors': [Floor(name="Ground Floor", area=100.0, u_value=0.4, perimeter=40.0, ground_contact=True, insulated=True, ground_temperature_c=10.0)],
+        'windows': [Window(name="South Window", area=10.0, u_value=2.8, orientation=Orientation.SOUTH, shgc=0.7, shading_coefficient=0.8)],
+        'doors': [Door(name="Main Door", area=2.0, u_value=2.0, orientation=Orientation.NORTH)]
     }
+    
     outdoor_conditions = {
-        "design_temperature": 17.5,
-        "design_relative_humidity": 81.3,
-        "ground_temperature": 16.0,
-        "wind_speed": 4.0
+        'design_temperature': -5.0,
+        'design_relative_humidity': 80.0,
+        'ground_temperature': 10.0,
+        'wind_speed': 4.0
     }
     indoor_conditions = {
-        "temperature": 21.0,
-        "relative_humidity": 40.0
+        '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
+        'people': {'number': 10, 'sensible_gain': 70.0, 'operating_hours': '8:00-18:00'},
+        'lights': {'power': 1000.0, 'use_factor': 0.8, 'hours_operation': '8h'},
+        'equipment': {'power': 500.0, 'use_factor': 0.7, 'hours_operation': '8h'},
+        'infiltration': {'flow_rate': 0.05, 'height': 3.0, 'crack_length': 20.0},
+        'ventilation': {'flow_rate': 0.1},
+        'operating_hours': '8:00-18:00'
+ Libre
     }
-    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")
+    
+    st.session_state.debug_mode = True
+    
+    design_loads = calculator.calculate_design_heating_load(components, outdoor_conditions, indoor_conditions, internal_loads)
+    summary = calculator.calculate_heating_load_summary(design_loads)
+    
+    print(f"Total Heating Load: {summary['total']:.2f} W")
+    print(f"Wall Load: {design_loads['walls']:.2f} W")
+    print(f"Roof Load: {design_loads['roofs']:.2f} W")
+    print(f"Floor Load: {design_loads['floors']:.2f} W")
+    print(f"Window Load: {design_loads['windows']:.2f] W")
+    print(f"Door Load: {design_loads['doors']:.2f} W")
+    print(f"Infiltration Load: {design_loads['infiltration_sensible'] + design_loads['infiltration_latent']:.2f} W")
+    print(f"Ventilation Load: {design_loads['ventilation_sensible'] + design_loads['ventilation_latent']:.2f} W")
+    
+    monthly_temps = {'Jan': -5.0, 'Feb': -3.0, 'Mar': 0.0, 'Apr': 5.0, 'May': 10.0, 'Jun': 15.0,
+                    'Jul': 18.0, 'Aug': 17.0, 'Sep': 12.0, 'Oct': 7.0, 'Nov': 2.0, 'Dec': -2.0}
+    
+    annual_energy = calculator.calculate_annual_heating_energy(design_loads, monthly_temps, indoor_conditions['temperature'], internal_loads['operating_hours'])
+    print(f"Annual Heating Energy: {annual_energy:.2f} kWh")
+    
+    monthly_loads = calculator.calculate_monthly_heating_loads(components, outdoor_conditions, indoor_conditions, internal_loads, monthly_temps)
+    for month, load in monthly_loads.items():
+        print(f"{month} Heating Load: {load:.2f} kW")