Update utils/heating_load.py

utils/heating_load.py

@@ -1,6 +1,7 @@
 """
 Heating load calculation module for HVAC Load Calculator.
-This module implements steady-state methods for calculating heating loads.
+This module implements enhanced steady-state methods with thermal mass effects,
+pressure-driven infiltration, and schedule-based internal gains.
 """
 
 from typing import Dict, List, Any, Optional, Tuple
@@ -21,16 +22,38 @@ DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 
 class HeatingLoadCalculator:
-    """Class for calculating heating loads using steady-state methods."""
+    """Class for calculating heating loads using enhanced steady-state methods."""
     
     def __init__(self):
-        """Initialize heating load calculator."""
+        """Initialize heating load calculator with heat transfer and psychrometrics utilities."""
         self.heat_transfer = HeatTransferCalculations()
         self.psychrometrics = Psychrometrics()
     
+    def validate_inputs(self, temp: float, rh: float, area: float, u_value: float) -> 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)
+            
+        Raises:
+            ValueError: If inputs are out of acceptable ranges
+        """
+        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")
+    
     def calculate_wall_heating_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float) -> float:
         """
-        Calculate heating load through a wall using steady-state conduction.
+        Calculate heating load through a wall with thermal mass effects.
         
         Args:
             wall: Wall object
@@ -40,19 +63,24 @@ class HeatingLoadCalculator:
         Returns:
             Heating load in W
         """
-        # Get wall properties
+        self.validate_inputs(outdoor_temp, 80.0, wall.area, wall.u_value)
+        
         u_value = wall.u_value
         area = wall.area
-        
-        # Calculate heating load
         delta_t = indoor_temp - outdoor_temp
-        heating_load = u_value * area * delta_t
         
-        return heating_load
+        # 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
+        
+        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 using steady-state conduction.
+        Calculate heating load through a roof with thermal mass effects.
         
         Args:
             roof: Roof object
@@ -62,19 +90,24 @@ class HeatingLoadCalculator:
         Returns:
             Heating load in W
         """
-        # Get roof properties
+        self.validate_inputs(outdoor_temp, 80.0, roof.area, roof.u_value)
+        
         u_value = roof.u_value
         area = roof.area
-        
-        # Calculate heating load
         delta_t = indoor_temp - outdoor_temp
-        heating_load = u_value * area * delta_t
         
-        return heating_load
+        # 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
+        
+        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.
+        Calculate heating load through a floor with thermal mass effects.
         
         Args:
             floor: Floor object
@@ -84,15 +117,20 @@ class HeatingLoadCalculator:
         Returns:
             Heating load in W
         """
-        # Get floor properties
+        self.validate_inputs(ground_temp, 80.0, floor.area, floor.u_value)
+        
         u_value = floor.u_value
         area = floor.area
-        
-        # Calculate heating load
         delta_t = indoor_temp - ground_temp
-        heating_load = u_value * area * delta_t
         
-        return heating_load
+        # Apply thermal mass effect
+        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)
+        
+        heating_load = u_value * area * delta_t * lag_factor
+        
+        return max(0, heating_load)
     
     def calculate_window_heating_load(self, window: Window, outdoor_temp: float, indoor_temp: float) -> float:
         """
@@ -106,15 +144,14 @@ class HeatingLoadCalculator:
         Returns:
             Heating load in W
         """
-        # Get window properties
+        self.validate_inputs(outdoor_temp, 80.0, window.area, window.u_value)
+        
         u_value = window.u_value
         area = window.area
-        
-        # Calculate heating load
         delta_t = indoor_temp - outdoor_temp
         heating_load = u_value * area * delta_t
         
-        return heating_load
+        return max(0, heating_load)
     
     def calculate_door_heating_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
         """
@@ -128,31 +165,51 @@ class HeatingLoadCalculator:
         Returns:
             Heating load in W
         """
-        # Get door properties
+        self.validate_inputs(outdoor_temp, 80.0, door.area, door.u_value)
+        
         u_value = door.u_value
         area = door.area
-        
-        # Calculate heating load
         delta_t = indoor_temp - outdoor_temp
         heating_load = u_value * area * delta_t
         
-        return heating_load
+        return max(0, heating_load)
     
-    def calculate_infiltration_heating_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
-                                          outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+    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 infiltration.
+        Calculate sensible and latent heating loads due to pressure-driven infiltration.
         
         Args:
-            flow_rate: Infiltration flow rate in m³/s
+            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
         """
+        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
+        )
+        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,
@@ -163,23 +220,19 @@ class HeatingLoadCalculator:
         w_outdoor = self.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
         w_indoor = self.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
         
-        # Calculate latent heating load (only if indoor humidity is higher than outdoor)
+        # Calculate latent heating load
         delta_w = w_indoor - w_outdoor
-        if delta_w > 0:
-            latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
-                flow_rate=flow_rate,
-                delta_w=delta_w
-            )
-        else:
-            latent_load = 0
+        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+            flow_rate=flow_rate,
+            delta_w=delta_w
+        ) if delta_w > 0 else 0
         
-        # Calculate total heating load
         total_load = sensible_load + latent_load
         
         return {
-            "sensible": sensible_load,
-            "latent": latent_load,
-            "total": total_load
+            "sensible": max(0, sensible_load),
+            "latent": max(0, latent_load),
+            "total": max(0, total_load)
         }
     
     def calculate_ventilation_heating_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
@@ -197,79 +250,91 @@ class HeatingLoadCalculator:
         Returns:
             Dictionary with sensible, latent, and total heating loads in W
         """
-        # Ventilation load calculation is the same as infiltration
-        return self.calculate_infiltration_heating_load(
+        self.validate_inputs(outdoor_temp, outdoor_rh, 0.0, 0.0)
+        
+        sensible_load = self.heat_transfer.infiltration_heat_transfer(
             flow_rate=flow_rate,
-            outdoor_temp=outdoor_temp,
-            indoor_temp=indoor_temp,
-            outdoor_rh=outdoor_rh,
-            indoor_rh=indoor_rh
+            delta_t=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
+        
+        return {
+            "sensible": max(0, sensible_load),
+            "latent": max(0, latent_load),
+            "total": max(0, total_load)
+        }
     
     def calculate_internal_gains_offset(self, people_load: float, lights_load: float, 
-                                      equipment_load: float, usage_factor: float = 0.7) -> 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.
+        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
         """
-        # Calculate total internal gains
         total_gains = people_load + lights_load + equipment_load
-        
-        # Apply usage factor
-        offset = total_gains * usage_factor
-        
-        return offset
+        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)
     
     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.
+        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
         """
-        # Extract building components
         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", [])
         
-        # Extract outdoor conditions
         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)
         
-        # Extract indoor conditions
         indoor_temp = indoor_conditions.get("temperature", 21.0)
         indoor_rh = indoor_conditions.get("relative_humidity", 40.0)
         
-        # Extract internal loads
         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", {})
         
-        # Initialize loads
         loads = {
             "walls": 0,
             "roofs": 0,
@@ -286,65 +351,32 @@ class HeatingLoadCalculator:
             "total": 0
         }
         
-        # Calculate wall loads
+        # Calculate loads
         for wall in walls:
-            wall_load = self.calculate_wall_heating_load(
-                wall=wall,
-                outdoor_temp=outdoor_temp,
-                indoor_temp=indoor_temp
-            )
-            loads["walls"] += wall_load
-        
-        # Calculate roof loads
+            loads["walls"] += self.calculate_wall_heating_load(wall, outdoor_temp, indoor_temp)
         for roof in roofs:
-            roof_load = self.calculate_roof_heating_load(
-                roof=roof,
-                outdoor_temp=outdoor_temp,
-                indoor_temp=indoor_temp
-            )
-            loads["roofs"] += roof_load
-        
-        # Calculate floor loads
+            loads["roofs"] += self.calculate_roof_heating_load(roof, outdoor_temp, indoor_temp)
         for floor in floors:
-            floor_load = self.calculate_floor_heating_load(
-                floor=floor,
-                ground_temp=ground_temp,
-                indoor_temp=indoor_temp
-            )
-            loads["floors"] += floor_load
-        
-        # Calculate window loads
+            loads["floors"] += self.calculate_floor_heating_load(floor, ground_temp, indoor_temp)
         for window in windows:
-            window_load = self.calculate_window_heating_load(
-                window=window,
-                outdoor_temp=outdoor_temp,
-                indoor_temp=indoor_temp
-            )
-            loads["windows"] += window_load
-        
-        # Calculate door loads
+            loads["windows"] += self.calculate_window_heating_load(window, outdoor_temp, indoor_temp)
         for door in doors:
-            door_load = self.calculate_door_heating_load(
-                door=door,
-                outdoor_temp=outdoor_temp,
-                indoor_temp=indoor_temp
-            )
-            loads["doors"] += door_load
+            loads["doors"] += self.calculate_door_heating_load(door, outdoor_temp, indoor_temp)
         
-        # Calculate infiltration loads
         if infiltration:
-            flow_rate = infiltration.get("flow_rate", 0.0)
             infiltration_loads = self.calculate_infiltration_heating_load(
-                flow_rate=flow_rate,
+                building_volume=building_volume,
                 outdoor_temp=outdoor_temp,
                 indoor_temp=indoor_temp,
                 outdoor_rh=outdoor_rh,
-                indoor_rh=indoor_rh
+                indoor_rh=indoor_rh,
+                wind_speed=wind_speed,
+                height=infiltration.get("height", 3.0),
+                crack_length=infiltration.get("crack_length", 10.0)
             )
             loads["infiltration_sensible"] = infiltration_loads["sensible"]
             loads["infiltration_latent"] = infiltration_loads["latent"]
         
-        # Calculate ventilation loads
         if ventilation:
             flow_rate = ventilation.get("flow_rate", 0.0)
             ventilation_loads = self.calculate_ventilation_heating_load(
@@ -357,19 +389,18 @@ class HeatingLoadCalculator:
             loads["ventilation_sensible"] = ventilation_loads["sensible"]
             loads["ventilation_latent"] = ventilation_loads["latent"]
         
-        # Calculate internal gains offset
         people_load = people.get("number", 0) * people.get("sensible_gain", 70)
         lights_load = lights.get("power", 0) * lights.get("use_factor", 1.0)
         equipment_load = equipment.get("power", 0) * equipment.get("use_factor", 1.0)
-        
         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)
+            usage_factor=internal_loads.get("usage_factor", 0.7),
+            hour=0,
+            schedule=internal_loads.get("gains_schedule", None)
         )
         
-        # Calculate subtotal
         loads["subtotal"] = (
             loads["walls"] + loads["roofs"] + loads["floors"] +
             loads["windows"] + loads["doors"] +
@@ -377,8 +408,6 @@ class HeatingLoadCalculator:
             loads["ventilation_sensible"] + loads["ventilation_latent"] -
             loads["internal_gains_offset"]
         )
-        
-        # Apply safety factor
         loads["total"] = loads["subtotal"] * safety_factor
         
         return loads
@@ -393,18 +422,14 @@ class HeatingLoadCalculator:
         Returns:
             Dictionary with heating load summary
         """
-        # Calculate envelope loads
-        envelope_loads = (
-            design_loads["walls"] + design_loads["roofs"] + design_loads["floors"] +
-            design_loads["windows"] + design_loads["doors"]
-        )
-        
-        # Calculate ventilation and infiltration loads
+        envelope_loads = sum([
+            design_loads["walls"], design_loads["roofs"], design_loads["floors"],
+            design_loads["windows"], design_loads["doors"]
+        ])
         ventilation_loads = design_loads["ventilation_sensible"] + design_loads["ventilation_latent"]
         infiltration_loads = design_loads["infiltration_sensible"] + design_loads["infiltration_latent"]
         
-        # Create summary
-        summary = {
+        return {
             "envelope_loads": envelope_loads,
             "ventilation_loads": ventilation_loads,
             "infiltration_loads": infiltration_loads,
@@ -413,8 +438,6 @@ class HeatingLoadCalculator:
             "safety_factor": design_loads["safety_factor"],
             "total": design_loads["total"]
         }
-        
-        return summary
     
     def calculate_monthly_heating_loads(self, design_loads: Dict[str, float], 
                                       monthly_temps: Dict[str, float],
@@ -431,25 +454,15 @@ class HeatingLoadCalculator:
         Returns:
             Dictionary with monthly heating loads
         """
-        # Calculate design temperature difference
         design_delta_t = indoor_temp - design_temp
-        
-        # Calculate monthly loads
         monthly_loads = {}
         
         for month, temp in monthly_temps.items():
-            # Calculate temperature difference for this month
             delta_t = indoor_temp - temp
-            
-            # Skip months where outdoor temperature is higher than indoor
             if delta_t <= 0:
                 monthly_loads[month] = 0
                 continue
-            
-            # Calculate load ratio based on temperature difference
             load_ratio = delta_t / design_delta_t
-            
-            # Calculate monthly load
             monthly_loads[month] = design_loads["total"] * load_ratio
         
         return monthly_loads
@@ -457,7 +470,7 @@ class HeatingLoadCalculator:
     def calculate_heating_degree_days(self, monthly_temps: Dict[str, float], 
                                     base_temp: float = 18.0) -> Dict[str, float]:
         """
-        Calculate heating degree days for each month.
+        Calculate heating degree days for each month with precise days.
         
         Args:
             monthly_temps: Dictionary with monthly average temperatures
@@ -466,31 +479,22 @@ class HeatingLoadCalculator:
         Returns:
             Dictionary with monthly heating degree days
         """
-        # Calculate monthly 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
+        }
         monthly_hdds = {}
         
         for month, temp in monthly_temps.items():
-            # Calculate degree days
-            days_in_month = 30  # Approximate
-            if month in ["Apr", "Jun", "Sep", "Nov"]:
-                days_in_month = 30
-            elif month == "Feb":
-                days_in_month = 28  # Ignore leap years for simplicity
-            else:
-                days_in_month = 31
-            
-            # Calculate daily degree days
             daily_hdd = max(0, base_temp - temp)
-            
-            # Calculate monthly degree days
-            monthly_hdds[month] = daily_hdd * days_in_month
+            monthly_hdds[month] = daily_hdd * days_per_month[month]
         
         return monthly_hdds
     
     def calculate_annual_heating_energy(self, monthly_loads: Dict[str, float], 
                                       heating_system_efficiency: float = 0.8) -> Dict[str, float]:
         """
-        Calculate annual heating energy consumption.
+        Calculate annual heating energy consumption with precise days.
         
         Args:
             monthly_loads: Dictionary with monthly heating loads in W
@@ -499,32 +503,20 @@ class HeatingLoadCalculator:
         Returns:
             Dictionary with monthly and annual heating energy in kWh
         """
-        # Calculate monthly energy consumption
+        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
+        }
         monthly_energy = {}
         annual_energy = 0
         
         for month, load in monthly_loads.items():
-            # Calculate hours in month
-            hours_in_month = 24 * 30  # Approximate
-            if month in ["Apr", "Jun", "Sep", "Nov"]:
-                hours_in_month = 24 * 30
-            elif month == "Feb":
-                hours_in_month = 24 * 28  # Ignore leap years for simplicity
-            else:
-                hours_in_month = 24 * 31
-            
-            # Calculate energy in kWh
+            hours_in_month = 24 * days_per_month[month]
             energy = load * hours_in_month / 1000 / heating_system_efficiency
-            
-            # Store monthly energy
             monthly_energy[month] = energy
-            
-            # Add to annual total
             annual_energy += energy
         
-        # Add annual total to results
         monthly_energy["annual"] = annual_energy
-        
         return monthly_energy
 
 
@@ -533,10 +525,8 @@ heating_load_calculator = HeatingLoadCalculator()
 
 # Example usage
 if __name__ == "__main__":
-    # Create sample building components
     from data.building_components import Wall, Roof, Window, Door, Orientation, ComponentType
     
-    # Create a sample wall
     wall = Wall(
         id="wall1",
         name="Exterior Wall",
@@ -545,10 +535,10 @@ if __name__ == "__main__":
         area=20.0,
         orientation=Orientation.NORTH,
         wall_type="Brick",
-        wall_group="B"
+        wall_group="B",
+        thermal_mass=100000,
+        time_constant=2.0
     )
-    
-    # Create a sample roof
     roof = Roof(
         id="roof1",
         name="Flat Roof",
@@ -557,10 +547,10 @@ if __name__ == "__main__":
         area=50.0,
         orientation=Orientation.HORIZONTAL,
         roof_type="Concrete",
-        roof_group="C"
+        roof_group="C",
+        thermal_mass=200000,
+        time_constant=3.0
     )
-    
-    # Create a sample window
     window = Window(
         id="window1",
         name="North Window",
@@ -576,7 +566,6 @@ if __name__ == "__main__":
         low_e_coating=False
     )
     
-    # Define building components
     building_components = {
         "walls": [wall],
         "roofs": [roof],
@@ -585,19 +574,18 @@ if __name__ == "__main__":
         "floors": []
     }
     
-    # Define conditions
     outdoor_conditions = {
         "design_temperature": -10.0,
         "design_relative_humidity": 80.0,
-        "ground_temperature": 10.0
+        "ground_temperature": 10.0,
+        "wind_speed": 4.0
     }
-    
     indoor_conditions = {
         "temperature": 21.0,
         "relative_humidity": 40.0
     }
     
-    # Define internal loads
+    gains_schedule = [0.2] * 8 + [0.8] * 8 + [0.4] * 8  # 8h low, 8h high, 8h medium
     internal_loads = {
         "people": {
             "number": 3,
@@ -612,64 +600,43 @@ if __name__ == "__main__":
             "use_factor": 0.7
         },
         "infiltration": {
-            "flow_rate": 0.05
+            "height": 3.0,
+            "crack_length": 10.0
         },
         "ventilation": {
             "flow_rate": 0.1
         },
-        "usage_factor": 0.7
+        "usage_factor": 0.7,
+        "gains_schedule": gains_schedule
     }
     
-    # Calculate design heating load
     design_loads = heating_load_calculator.calculate_design_heating_load(
         building_components=building_components,
         outdoor_conditions=outdoor_conditions,
         indoor_conditions=indoor_conditions,
-        internal_loads=internal_loads
+        internal_loads=internal_loads,
+        building_volume=300.0
     )
-    
-    # Calculate heating load summary
     summary = heating_load_calculator.calculate_heating_load_summary(design_loads)
     
-    # Define monthly temperatures
     monthly_temps = {
-        "Jan": -5.0,
-        "Feb": -3.0,
-        "Mar": 2.0,
-        "Apr": 8.0,
-        "May": 14.0,
-        "Jun": 18.0,
-        "Jul": 21.0,
-        "Aug": 20.0,
-        "Sep": 16.0,
-        "Oct": 10.0,
-        "Nov": 4.0,
-        "Dec": -2.0
+        "Jan": -5.0, "Feb": -3.0, "Mar": 2.0, "Apr": 8.0, "May": 14.0,
+        "Jun": 18.0, "Jul": 21.0, "Aug": 20.0, "Sep": 16.0, "Oct": 10.0,
+        "Nov": 4.0, "Dec": -2.0
     }
     
-    # Calculate monthly heating loads
     monthly_loads = heating_load_calculator.calculate_monthly_heating_loads(
         design_loads=design_loads,
         monthly_temps=monthly_temps,
         design_temp=outdoor_conditions["design_temperature"],
         indoor_temp=indoor_conditions["temperature"]
     )
-    
-    # Calculate heating degree days
     hdds = heating_load_calculator.calculate_heating_degree_days(monthly_temps)
-    
-    # Calculate annual heating energy
     energy = heating_load_calculator.calculate_annual_heating_energy(monthly_loads)
     
-    # Print results
     print("Heating Load Summary:")
-    print(f"Envelope Loads: {summary['envelope_loads']:.2f} W")
-    print(f"Ventilation Loads: {summary['ventilation_loads']:.2f} W")
-    print(f"Infiltration Loads: {summary['infiltration_loads']:.2f} W")
-    print(f"Internal Gains Offset: {summary['internal_gains_offset']:.2f} W")
-    print(f"Subtotal: {summary['subtotal']:.2f} W")
-    print(f"Safety Factor: {summary['safety_factor']:.2f}")
-    print(f"Total: {summary['total']:.2f} W")
+    for key, value in summary.items():
+        print(f"{key.replace('_', ' ').title()}: {value:.2f} W")
     
     print("\nMonthly Heating Loads:")
     for month, load in monthly_loads.items():
@@ -680,4 +647,4 @@ if __name__ == "__main__":
         print(f"{month}: {hdd:.2f} HDD")
     
     print("\nAnnual Heating Energy:")
-    print(f"Total: {energy['annual']:.2f} kWh")
+    print(f"Total: {energy['annual']:.2f} kWh")