Update utils/cooling_load.py

utils/cooling_load.py

@@ -1,6 +1,7 @@
 """
 Cooling load calculation module for HVAC Load Calculator.
-This module implements the CLTD/CLF method for calculating cooling loads.
+This module implements an enhanced CLTD/CLF method with dynamic heat transfer,
+detailed solar calculations, and pressure-driven infiltration.
 """
 
 from typing import Dict, List, Any, Optional, Tuple
@@ -22,39 +23,98 @@ DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
 
 class CoolingLoadCalculator:
-    """Class for calculating cooling loads using the CLTD/CLF method."""
+    """Class for calculating cooling loads using an enhanced CLTD/CLF method."""
     
     def __init__(self):
-        """Initialize cooling load calculator."""
+        """Initialize cooling load calculator with heat transfer and psychrometrics utilities."""
         self.heat_transfer = HeatTransferCalculations()
         self.psychrometrics = Psychrometrics()
         self.ashrae_tables = ASHRAETables()
     
+    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_cooling_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float, 
                                    month: str, hour: int, latitude: str = "40N",
-                                   color: str = "Dark") -> float:
+                                   color: str = "Dark", day_of_year: int = 204,
+                                   wind_speed: float = 4.0) -> float:
         """
-        Calculate cooling load through a wall using the CLTD method.
+        Calculate cooling load through a wall using enhanced CLTD method with thermal mass.
         
         Args:
             wall: Wall object
             outdoor_temp: Outdoor temperature in °C
             indoor_temp: Indoor temperature in °C
-            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            month: Month (Jan, Feb, ..., Dec)
             hour: Hour of the day (0-23)
             latitude: Latitude (24N, 32N, 40N, 48N, 56N)
             color: Surface color (Dark, Medium, Light)
+            day_of_year: Day of year (1-365, default: 204 for mid-July)
+            wind_speed: Wind speed in m/s (default: 4.0 m/s)
             
         Returns:
             Cooling load in W
         """
+        self.validate_inputs(outdoor_temp, 50.0, wall.area, wall.u_value)
+        
         # Get wall properties
         u_value = wall.u_value
         area = wall.area
         orientation = wall.orientation.value
         wall_group = wall.wall_group
+        surface_absorptivity = {"Dark": 0.9, "Medium": 0.6, "Light": 0.3}.get(color, 0.9)
+        
+        # Calculate sol-air temperature
+        latitude_deg = float(latitude[:-1]) if latitude.endswith("N") else -float(latitude[:-1])
+        solar_altitude = self.heat_transfer.solar_altitude(
+            latitude=latitude_deg,
+            declination=self.heat_transfer.solar_declination(day_of_year),
+            hour_angle=self.heat_transfer.solar_hour_angle(hour)
+        )
+        dni = self.heat_transfer.direct_normal_irradiance(solar_altitude)
+        dhi = self.heat_transfer.diffuse_horizontal_irradiance(dni, solar_altitude)
+        irradiance = self.heat_transfer.irradiance_on_surface(
+            dni, dhi, 
+            incident_angle=self.heat_transfer.incident_angle(
+                surface_tilt=90,  # Vertical wall
+                surface_azimuth={"NORTH": 0, "EAST": 90, "SOUTH": 180, "WEST": 270}.get(orientation, 180),
+                solar_altitude=solar_altitude,
+                solar_azimuth=self.heat_transfer.solar_azimuth(
+                    latitude_deg, 
+                    self.heat_transfer.solar_declination(day_of_year), 
+                    self.heat_transfer.solar_hour_angle(hour), 
+                    solar_altitude
+                )
+            ),
+            surface_tilt=90
+        )
+        sol_air_temp = self.heat_transfer.sol_air_temperature(
+            outdoor_temp=outdoor_temp,
+            solar_irradiance=irradiance,
+            surface_absorptivity=surface_absorptivity,
+            surface_resistance=0.04  # Typical for wind-exposed surface
+        )
         
-        # Calculate corrected CLTD
+        # Calculate corrected CLTD with sol-air temperature
         cltd = self.ashrae_tables.calculate_corrected_cltd_wall(
             wall_group=wall_group,
             orientation=orientation,
@@ -63,36 +123,79 @@ class CoolingLoadCalculator:
             month=month,
             latitude=latitude,
             indoor_temp=indoor_temp,
-            outdoor_temp=outdoor_temp
+            outdoor_temp=sol_air_temp  # Use sol-air temperature
         )
         
+        # Apply thermal mass effect
+        thermal_mass = getattr(wall, "thermal_mass", 100000)  # J/K, default value
+        time_constant = getattr(wall, "time_constant", 2.0)  # hours, default
+        lag_factor = self.heat_transfer.thermal_lag_factor(thermal_mass, time_constant, 1.0)
+        cltd_adjusted = cltd * lag_factor
+        
         # Calculate cooling load
-        cooling_load = u_value * area * cltd
+        cooling_load = u_value * area * cltd_adjusted
         
-        return cooling_load
+        return max(0, cooling_load)
     
     def calculate_roof_cooling_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float, 
                                    month: str, hour: int, latitude: str = "40N",
-                                   color: str = "Dark") -> float:
+                                   color: str = "Dark", day_of_year: int = 204,
+                                   wind_speed: float = 4.0) -> float:
         """
-        Calculate cooling load through a roof using the CLTD method.
+        Calculate cooling load through a roof using enhanced CLTD method with thermal mass.
         
         Args:
             roof: Roof object
             outdoor_temp: Outdoor temperature in °C
             indoor_temp: Indoor temperature in °C
-            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            month: Month (Jan, Feb, ..., Dec)
             hour: Hour of the day (0-23)
             latitude: Latitude (24N, 32N, 40N, 48N, 56N)
             color: Surface color (Dark, Medium, Light)
+            day_of_year: Day of year (1-365, default: 204 for mid-July)
+            wind_speed: Wind speed in m/s (default: 4.0 m/s)
             
         Returns:
             Cooling load in W
         """
+        self.validate_inputs(outdoor_temp, 50.0, roof.area, roof.u_value)
+        
         # Get roof properties
         u_value = roof.u_value
         area = roof.area
         roof_group = roof.roof_group
+        surface_absorptivity = {"Dark": 0.9, "Medium": 0.6, "Light": 0.3}.get(color, 0.9)
+        
+        # Calculate sol-air temperature
+        latitude_deg = float(latitude[:-1]) if latitude.endswith("N") else -float(latitude[:-1])
+        solar_altitude = self.heat_transfer.solar_altitude(
+            latitude=latitude_deg,
+            declination=self.heat_transfer.solar_declination(day_of_year),
+            hour_angle=self.heat_transfer.solar_hour_angle(hour)
+        )
+        dni = self.heat_transfer.direct_normal_irradiance(solar_altitude)
+        dhi = self.heat_transfer.diffuse_horizontal_irradiance(dni, solar_altitude)
+        irradiance = self.heat_transfer.irradiance_on_surface(
+            dni, dhi,
+            incident_angle=self.heat_transfer.incident_angle(
+                surface_tilt=0,  # Horizontal roof
+                surface_azimuth=0,
+                solar_altitude=solar_altitude,
+                solar_azimuth=self.heat_transfer.solar_azimuth(
+                    latitude_deg, 
+                    self.heat_transfer.solar_declination(day_of_year), 
+                    self.heat_transfer.solar_hour_angle(hour), 
+                    solar_altitude
+                )
+            ),
+            surface_tilt=0
+        )
+        sol_air_temp = self.heat_transfer.sol_air_temperature(
+            outdoor_temp=outdoor_temp,
+            solar_irradiance=irradiance,
+            surface_absorptivity=surface_absorptivity,
+            surface_resistance=0.04
+        )
         
         # Calculate corrected CLTD
         cltd = self.ashrae_tables.calculate_corrected_cltd_roof(
@@ -102,32 +205,41 @@ class CoolingLoadCalculator:
             month=month,
             latitude=latitude,
             indoor_temp=indoor_temp,
-            outdoor_temp=outdoor_temp
+            outdoor_temp=sol_air_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)
+        cltd_adjusted = cltd * lag_factor
+        
         # Calculate cooling load
-        cooling_load = u_value * area * cltd
+        cooling_load = u_value * area * cltd_adjusted
         
-        return cooling_load
+        return max(0, cooling_load)
     
     def calculate_window_cooling_load(self, window: Window, outdoor_temp: float, indoor_temp: float, 
-                                     month: str, hour: int, latitude: str = "40N_JUL",
-                                     shading_coefficient: float = 1.0) -> Dict[str, float]:
+                                     month: str, hour: int, latitude: str = "40N",
+                                     shading_coefficient: float = 1.0, day_of_year: int = 204) -> Dict[str, float]:
         """
-        Calculate cooling load through a window using the CLTD/SCL method.
+        Calculate cooling load through a window using dynamic solar calculations.
         
         Args:
             window: Window object
             outdoor_temp: Outdoor temperature in °C
             indoor_temp: Indoor temperature in °C
-            month: Month (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec)
+            month: Month (Jan, Feb, ..., Dec)
             hour: Hour of the day (0-23)
-            latitude: Latitude and month key (default: "40N_JUL")
+            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
             shading_coefficient: Shading coefficient (0-1)
+            day_of_year: Day of year (1-365, default: 204 for mid-July)
             
         Returns:
             Dictionary with conduction, solar, and total cooling loads in W
         """
+        self.validate_inputs(outdoor_temp, 50.0, window.area, window.u_value)
+        
         # Get window properties
         u_value = window.u_value
         area = window.area
@@ -138,17 +250,42 @@ class CoolingLoadCalculator:
         delta_t = outdoor_temp - indoor_temp
         conduction_load = u_value * area * delta_t
         
-        # Calculate solar cooling load
-        scl = self.ashrae_tables.get_scl(orientation, hour, latitude)
-        solar_load = area * shgc * shading_coefficient * scl
+        # Calculate solar cooling load dynamically
+        latitude_deg = float(latitude[:-1]) if latitude.endswith("N") else -float(latitude[:-1])
+        solar_altitude = self.heat_transfer.solar_altitude(
+            latitude=latitude_deg,
+            declination=self.heat_transfer.solar_declination(day_of_year),
+            hour_angle=self.heat_transfer.solar_hour_angle(hour)
+        )
+        solar_azimuth = self.heat_transfer.solar_azimuth(
+            latitude=latitude_deg,
+            declination=self.heat_transfer.solar_declination(day_of_year),
+            hour_angle=self.heat_transfer.solar_hour_angle(hour),
+            altitude=solar_altitude
+        )
+        incident_angle = self.heat_transfer.incident_angle(
+            surface_tilt=90,  # Vertical window
+            surface_azimuth={"NORTH": 0, "EAST": 90, "SOUTH": 180, "WEST": 270}.get(orientation, 180),
+            solar_altitude=solar_altitude,
+            solar_azimuth=solar_azimuth
+        )
+        dni = self.heat_transfer.direct_normal_irradiance(solar_altitude)
+        dhi = self.heat_transfer.diffuse_horizontal_irradiance(dni, solar_altitude)
+        irradiance = self.heat_transfer.irradiance_on_surface(dni, dhi, incident_angle, surface_tilt=90)
+        solar_load = self.heat_transfer.solar_heat_gain(
+            irradiance=irradiance,
+            area=area,
+            shgc=shgc,
+            shading_coefficient=shading_coefficient
+        )
         
         # Calculate total cooling load
         total_load = conduction_load + solar_load
         
         return {
-            "conduction": conduction_load,
-            "solar": solar_load,
-            "total": total_load
+            "conduction": max(0, conduction_load),
+            "solar": max(0, solar_load),
+            "total": max(0, total_load)
         }
     
     def calculate_door_cooling_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
@@ -163,15 +300,14 @@ class CoolingLoadCalculator:
         Returns:
             Cooling load in W
         """
-        # Get door properties
+        self.validate_inputs(outdoor_temp, 50.0, door.area, door.u_value)
+        
         u_value = door.u_value
         area = door.area
-        
-        # Calculate cooling load
         delta_t = outdoor_temp - indoor_temp
         cooling_load = u_value * area * delta_t
         
-        return cooling_load
+        return max(0, cooling_load)
     
     def calculate_floor_cooling_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
         """
@@ -185,32 +321,51 @@ class CoolingLoadCalculator:
         Returns:
             Cooling load in W
         """
-        # Get floor properties
+        self.validate_inputs(ground_temp, 50.0, floor.area, floor.u_value)
+        
         u_value = floor.u_value
         area = floor.area
-        
-        # Calculate cooling load
         delta_t = ground_temp - indoor_temp
         cooling_load = u_value * area * delta_t
         
-        # Return positive value for heat gain, zero for heat loss
         return max(0, cooling_load)
     
-    def calculate_infiltration_cooling_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
-                                          outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+    def calculate_infiltration_cooling_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 cooling loads due to infiltration.
+        Calculate sensible and latent cooling 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 cooling 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 cooling load
         sensible_load = self.heat_transfer.infiltration_heat_transfer(
             flow_rate=flow_rate,
@@ -227,17 +382,16 @@ class CoolingLoadCalculator:
             delta_w=w_outdoor - w_indoor
         )
         
-        # Calculate total cooling 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_cooling_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
-                                         outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+                                          outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
         """
         Calculate sensible and latent cooling loads due to ventilation.
         
@@ -251,30 +405,40 @@ class CoolingLoadCalculator:
         Returns:
             Dictionary with sensible, latent, and total cooling loads in W
         """
-        # Ventilation load calculation is the same as infiltration
-        return self.calculate_infiltration_cooling_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=outdoor_temp - indoor_temp
         )
+        w_outdoor = self.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
+        w_indoor = self.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
+        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(
+            flow_rate=flow_rate,
+            delta_w=w_outdoor - w_indoor
+        )
+        total_load = sensible_load + latent_load
+        
+        return {
+            "sensible": max(0, sensible_load),
+            "latent": max(0, latent_load),
+            "total": max(0, total_load)
+        }
     
     def calculate_people_cooling_load(self, num_people: int, activity_level: str, 
-                                    hours_occupancy: str, hour: int) -> Dict[str, float]:
+                                    hour: int, occupancy_schedule: Optional[List[float]] = None) -> Dict[str, float]:
         """
-        Calculate sensible and latent cooling loads due to people.
+        Calculate sensible and latent cooling loads due to people with schedule.
         
         Args:
             num_people: Number of people
             activity_level: Activity level (Seated/Resting, Light work, Medium work, Heavy work)
-            hours_occupancy: Hours of occupancy (8h, 10h, 12h, 14h, 16h, 18h, 24h)
             hour: Hour of the day (0-23)
+            occupancy_schedule: List of 24 hourly occupancy factors (0-1, default: None)
             
         Returns:
             Dictionary with sensible, latent, and total cooling loads in W
         """
-        # Define heat gains for different activity levels
         activity_gains = {
             "Seated/Resting": {"sensible": 70, "latent": 45},
             "Light work": {"sensible": 75, "latent": 55},
@@ -282,132 +446,127 @@ class CoolingLoadCalculator:
             "Heavy work": {"sensible": 95, "latent": 145}
         }
         
-        # Get heat gains for the specified activity level
         if activity_level not in activity_gains:
             raise ValueError(f"Invalid activity level: {activity_level}")
         
         sensible_gain = activity_gains[activity_level]["sensible"]
         latent_gain = activity_gains[activity_level]["latent"]
         
-        # Get CLF for the specified hour and occupancy
-        clf = self.ashrae_tables.get_clf_people(hour, hours_occupancy)
+        # Apply occupancy schedule
+        occupancy_factor = 1.0
+        if occupancy_schedule and len(occupancy_schedule) == 24:
+            occupancy_factor = occupancy_schedule[hour]
         
-        # Calculate cooling loads
-        sensible_load = num_people * sensible_gain * clf
-        latent_load = num_people * latent_gain  # Latent load is not affected by CLF
+        sensible_load = num_people * sensible_gain * occupancy_factor
+        latent_load = num_people * latent_gain * occupancy_factor
         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_lights_cooling_load(self, power: float, use_factor: float, 
-                                    special_allowance: float, hours_operation: str, 
-                                    hour: int) -> float:
+                                    special_allowance: float, hour: int,
+                                    lighting_schedule: Optional[List[float]] = None) -> float:
         """
-        Calculate cooling load due to lights.
+        Calculate cooling load due to lights with schedule.
         
         Args:
             power: Installed lighting power in W
             use_factor: Usage factor (0-1)
             special_allowance: Special allowance factor for fixtures (0-1)
-            hours_operation: Hours of operation (8h, 10h, 12h, 14h, 16h, 18h, 24h)
             hour: Hour of the day (0-23)
+            lighting_schedule: List of 24 hourly lighting factors (0-1, default: None)
             
         Returns:
             Cooling load in W
         """
-        # Get CLF for the specified hour and operation
-        clf = self.ashrae_tables.get_clf_lights(hour, hours_operation)
+        schedule_factor = 1.0
+        if lighting_schedule and len(lighting_schedule) == 24:
+            schedule_factor = lighting_schedule[hour]
         
-        # Calculate cooling load
-        cooling_load = power * use_factor * (1 + special_allowance) * clf
+        cooling_load = power * use_factor * (1 + special_allowance) * schedule_factor
         
-        return cooling_load
+        return max(0, cooling_load)
     
     def calculate_equipment_cooling_load(self, power: float, use_factor: float, 
-                                       radiation_factor: float, hours_operation: str, 
-                                       hour: int) -> Dict[str, float]:
+                                       radiation_factor: float, hour: int,
+                                       equipment_schedule: Optional[List[float]] = None) -> Dict[str, float]:
         """
-        Calculate sensible and latent cooling loads due to equipment.
+        Calculate sensible and latent cooling loads due to equipment with schedule.
         
         Args:
             power: Equipment power in W
             use_factor: Usage factor (0-1)
             radiation_factor: Radiation factor (0-1)
-            hours_operation: Hours of operation (8h, 10h, 12h, 14h, 16h, 18h, 24h)
             hour: Hour of the day (0-23)
+            equipment_schedule: List of 24 hourly equipment factors (0-1, default: None)
             
         Returns:
             Dictionary with sensible, latent, and total cooling loads in W
         """
-        # Get CLF for the specified hour and operation
-        clf = self.ashrae_tables.get_clf_equipment(hour, hours_operation)
-        
-        # Calculate sensible cooling load
-        sensible_load = power * use_factor * radiation_factor * clf
-        
-        # Calculate latent cooling load (if any)
-        latent_load = power * use_factor * (1 - radiation_factor)
+        schedule_factor = 1.0
+        if equipment_schedule and len(equipment_schedule) == 24:
+            schedule_factor = equipment_schedule[hour]
         
-        # Calculate total cooling load
+        sensible_load = power * use_factor * radiation_factor * schedule_factor
+        latent_load = power * use_factor * (1 - radiation_factor) * schedule_factor
         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_hourly_cooling_loads(self, building_components: Dict[str, List[Any]], 
                                       outdoor_conditions: Dict[str, Any],
                                       indoor_conditions: Dict[str, Any],
-                                      internal_loads: Dict[str, Any]) -> Dict[int, Dict[str, float]]:
+                                      internal_loads: Dict[str, Any],
+                                      building_volume: float = 300.0) -> Dict[int, Dict[str, float]]:
         """
-        Calculate hourly cooling loads for a building.
+        Calculate hourly cooling loads 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³)
             
         Returns:
             Dictionary with hourly cooling loads
         """
-        # Extract building components
+        # Extract inputs
         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("temperature", 35.0)
         outdoor_rh = outdoor_conditions.get("relative_humidity", 50.0)
         ground_temp = outdoor_conditions.get("ground_temperature", 20.0)
         month = outdoor_conditions.get("month", "Jul")
         latitude = outdoor_conditions.get("latitude", "40N")
+        wind_speed = outdoor_conditions.get("wind_speed", 4.0)
+        day_of_year = outdoor_conditions.get("day_of_year", 204)
         
-        # Extract indoor conditions
         indoor_temp = indoor_conditions.get("temperature", 24.0)
         indoor_rh = indoor_conditions.get("relative_humidity", 50.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 hourly cooling loads
+        # Initialize hourly loads
         hourly_loads = {}
         
-        # Calculate cooling loads for each hour
         for hour in range(24):
-            # Initialize loads for this hour
             loads = {
                 "walls": 0,
                 "roofs": 0,
@@ -429,42 +588,43 @@ class CoolingLoadCalculator:
                 "total": 0
             }
             
-            # Calculate wall loads
+            # Wall loads
             for wall in walls:
-                wall_load = self.calculate_wall_cooling_load(
+                loads["walls"] += self.calculate_wall_cooling_load(
                     wall=wall,
                     outdoor_temp=outdoor_temp,
                     indoor_temp=indoor_temp,
                     month=month,
                     hour=hour,
                     latitude=latitude,
-                    color=wall.color if hasattr(wall, "color") else "Dark"
+                    color=wall.color if hasattr(wall, "color") else "Dark",
+                    day_of_year=day_of_year,
+                    wind_speed=wind_speed
                 )
-                loads["walls"] += wall_load
             
-            # Calculate roof loads
+            # Roof loads
             for roof in roofs:
-                roof_load = self.calculate_roof_cooling_load(
+                loads["roofs"] += self.calculate_roof_cooling_load(
                     roof=roof,
                     outdoor_temp=outdoor_temp,
                     indoor_temp=indoor_temp,
                     month=month,
                     hour=hour,
                     latitude=latitude,
-                    color=roof.color if hasattr(roof, "color") else "Dark"
+                    color=roof.color if hasattr(roof, "color") else "Dark",
+                    day_of_year=day_of_year,
+                    wind_speed=wind_speed
                 )
-                loads["roofs"] += roof_load
             
-            # Calculate floor loads
+            # Floor loads
             for floor in floors:
-                floor_load = self.calculate_floor_cooling_load(
+                loads["floors"] += self.calculate_floor_cooling_load(
                     floor=floor,
                     ground_temp=ground_temp,
                     indoor_temp=indoor_temp
                 )
-                loads["floors"] += floor_load
             
-            # Calculate window loads
+            # Window loads
             for window in windows:
                 window_loads = self.calculate_window_cooling_load(
                     window=window,
@@ -472,35 +632,37 @@ class CoolingLoadCalculator:
                     indoor_temp=indoor_temp,
                     month=month,
                     hour=hour,
-                    latitude=f"{latitude}_{month.upper()}",
-                    shading_coefficient=window.shading_coefficient if hasattr(window, "shading_coefficient") else 1.0
+                    latitude=latitude,
+                    shading_coefficient=window.shading_coefficient if hasattr(window, "shading_coefficient") else 1.0,
+                    day_of_year=day_of_year
                 )
                 loads["windows_conduction"] += window_loads["conduction"]
                 loads["windows_solar"] += window_loads["solar"]
             
-            # Calculate door loads
+            # Door loads
             for door in doors:
-                door_load = self.calculate_door_cooling_load(
+                loads["doors"] += self.calculate_door_cooling_load(
                     door=door,
                     outdoor_temp=outdoor_temp,
                     indoor_temp=indoor_temp
                 )
-                loads["doors"] += door_load
             
-            # Calculate infiltration loads
+            # Infiltration loads
             if infiltration:
-                flow_rate = infiltration.get("flow_rate", 0.0)
                 infiltration_loads = self.calculate_infiltration_cooling_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
+            # Ventilation loads
             if ventilation:
                 flow_rate = ventilation.get("flow_rate", 0.0)
                 ventilation_loads = self.calculate_ventilation_cooling_load(
@@ -513,71 +675,56 @@ class CoolingLoadCalculator:
                 loads["ventilation_sensible"] = ventilation_loads["sensible"]
                 loads["ventilation_latent"] = ventilation_loads["latent"]
             
-            # Calculate people loads
+            # People loads
             if people:
-                num_people = people.get("number", 0)
-                activity_level = people.get("activity_level", "Seated/Resting")
-                hours_occupancy = people.get("hours_occupancy", "8h")
-                
-                people_loads = self.calculate_people_cooling_load(
-                    num_people=num_people,
-                    activity_level=activity_level,
-                    hours_occupancy=hours_occupancy,
-                    hour=hour
-                )
-                loads["people_sensible"] = people_loads["sensible"]
-                loads["people_latent"] = people_loads["latent"]
+                loads["people_sensible"], loads["people_latent"] = self.calculate_people_cooling_load(
+                    num_people=people.get("number", 0),
+                    activity_level=people.get("activity_level", "Seated/Resting"),
+                    hour=hour,
+                    occupancy_schedule=people.get("occupancy_schedule", None)
+                )["sensible"], self.calculate_people_cooling_load(
+                    num_people=people.get("number", 0),
+                    activity_level=people.get("activity_level", "Seated/Resting"),
+                    hour=hour,
+                    occupancy_schedule=people.get("occupancy_schedule", None)
+                )["latent"]
             
-            # Calculate lights loads
+            # Lights loads
             if lights:
-                power = lights.get("power", 0.0)
-                use_factor = lights.get("use_factor", 1.0)
-                special_allowance = lights.get("special_allowance", 0.0)
-                hours_operation = lights.get("hours_operation", "8h")
-                
-                lights_load = self.calculate_lights_cooling_load(
-                    power=power,
-                    use_factor=use_factor,
-                    special_allowance=special_allowance,
-                    hours_operation=hours_operation,
-                    hour=hour
+                loads["lights"] = self.calculate_lights_cooling_load(
+                    power=lights.get("power", 0.0),
+                    use_factor=lights.get("use_factor", 1.0),
+                    special_allowance=lights.get("special_allowance", 0.0),
+                    hour=hour,
+                    lighting_schedule=lights.get("lighting_schedule", None)
                 )
-                loads["lights"] = lights_load
             
-            # Calculate equipment loads
+            # Equipment loads
             if equipment:
-                power = equipment.get("power", 0.0)
-                use_factor = equipment.get("use_factor", 1.0)
-                radiation_factor = equipment.get("radiation_factor", 0.7)
-                hours_operation = equipment.get("hours_operation", "8h")
-                
                 equipment_loads = self.calculate_equipment_cooling_load(
-                    power=power,
-                    use_factor=use_factor,
-                    radiation_factor=radiation_factor,
-                    hours_operation=hours_operation,
-                    hour=hour
+                    power=equipment.get("power", 0.0),
+                    use_factor=equipment.get("use_factor", 1.0),
+                    radiation_factor=equipment.get("radiation_factor", 0.7),
+                    hour=hour,
+                    equipment_schedule=equipment.get("equipment_schedule", None)
                 )
                 loads["equipment_sensible"] = equipment_loads["sensible"]
                 loads["equipment_latent"] = equipment_loads["latent"]
             
-            # Calculate total loads
-            loads["total_sensible"] = (
-                loads["walls"] + loads["roofs"] + loads["floors"] +
-                loads["windows_conduction"] + loads["windows_solar"] +
-                loads["doors"] + loads["infiltration_sensible"] +
-                loads["ventilation_sensible"] + loads["people_sensible"] +
-                loads["lights"] + loads["equipment_sensible"]
-            )
-            
-            loads["total_latent"] = (
-                loads["infiltration_latent"] + loads["ventilation_latent"] +
-                loads["people_latent"] + loads["equipment_latent"]
-            )
-            
+            # Calculate totals
+            loads["total_sensible"] = sum([
+                loads["walls"], loads["roofs"], loads["floors"],
+                loads["windows_conduction"], loads["windows_solar"],
+                loads["doors"], loads["infiltration_sensible"],
+                loads["ventilation_sensible"], loads["people_sensible"],
+                loads["lights"], loads["equipment_sensible"]
+            ])
+            loads["total_latent"] = sum([
+                loads["infiltration_latent"], loads["ventilation_latent"],
+                loads["people_latent"], loads["equipment_latent"]
+            ])
             loads["total"] = loads["total_sensible"] + loads["total_latent"]
             
-            # Store loads for this hour
             hourly_loads[hour] = loads
         
         return hourly_loads
@@ -592,15 +739,9 @@ class CoolingLoadCalculator:
         Returns:
             Dictionary with design cooling loads
         """
-        # Find hour with maximum total load
         max_hour = max(hourly_loads.keys(), key=lambda h: hourly_loads[h]["total"])
-        
-        # Get loads for the design hour
         design_loads = hourly_loads[max_hour].copy()
-        
-        # Add design hour information
         design_loads["design_hour"] = max_hour
-        
         return design_loads
     
     def calculate_cooling_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
@@ -613,28 +754,21 @@ class CoolingLoadCalculator:
         Returns:
             Dictionary with cooling load summary
         """
-        # Calculate envelope loads
-        envelope_loads = (
-            design_loads["walls"] + design_loads["roofs"] + design_loads["floors"] +
-            design_loads["windows_conduction"] + design_loads["windows_solar"] +
+        envelope_loads = sum([
+            design_loads["walls"], design_loads["roofs"], design_loads["floors"],
+            design_loads["windows_conduction"], design_loads["windows_solar"],
             design_loads["doors"]
-        )
-        
-        # Calculate ventilation and infiltration loads
+        ])
         ventilation_loads = design_loads["ventilation_sensible"] + design_loads["ventilation_latent"]
         infiltration_loads = design_loads["infiltration_sensible"] + design_loads["infiltration_latent"]
-        
-        # Calculate internal loads
-        internal_loads = (
-            design_loads["people_sensible"] + design_loads["people_latent"] +
-            design_loads["lights"] + design_loads["equipment_sensible"] + design_loads["equipment_latent"]
-        )
-        
-        # Calculate sensible heat ratio
+        internal_loads = sum([
+            design_loads["people_sensible"], design_loads["people_latent"],
+            design_loads["lights"], design_loads["equipment_sensible"],
+            design_loads["equipment_latent"]
+        ])
         shr = design_loads["total_sensible"] / design_loads["total"] if design_loads["total"] > 0 else 1.0
         
-        # Create summary
-        summary = {
+        return {
             "envelope_loads": envelope_loads,
             "ventilation_loads": ventilation_loads,
             "infiltration_loads": infiltration_loads,
@@ -645,8 +779,6 @@ class CoolingLoadCalculator:
             "sensible_heat_ratio": shr,
             "design_hour": design_loads["design_hour"]
         }
-        
-        return summary
 
 
 # Create a singleton instance
@@ -654,10 +786,9 @@ cooling_load_calculator = CoolingLoadCalculator()
 
 # Example usage
 if __name__ == "__main__":
-    # Create sample building components
     from data.building_components import Wall, Roof, Window, Door, Orientation, ComponentType
     
-    # Create a sample wall
+    # Sample building components
     wall = Wall(
         id="wall1",
         name="Exterior Wall",
@@ -666,10 +797,11 @@ if __name__ == "__main__":
         area=20.0,
         orientation=Orientation.SOUTH,
         wall_type="Brick",
-        wall_group="B"
+        wall_group="B",
+        thermal_mass=100000,
+        time_constant=2.0,
+        color="Dark"
     )
-    
-    # Create a sample roof
     roof = Roof(
         id="roof1",
         name="Flat Roof",
@@ -678,10 +810,11 @@ 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,
+        color="Dark"
     )
-    
-    # Create a sample window
     window = Window(
         id="window1",
         name="South Window",
@@ -694,10 +827,10 @@ if __name__ == "__main__":
         window_type="Double Glazed",
         glazing_layers=2,
         gas_fill="Air",
-        low_e_coating=False
+        low_e_coating=False,
+        shading_coefficient=1.0
     )
     
-    # Define building components
     building_components = {
         "walls": [wall],
         "roofs": [roof],
@@ -712,63 +845,62 @@ if __name__ == "__main__":
         "relative_humidity": 50.0,
         "ground_temperature": 20.0,
         "month": "Jul",
-        "latitude": "40N"
+        "latitude": "40N",
+        "wind_speed": 4.0,
+        "day_of_year": 204
     }
-    
     indoor_conditions = {
         "temperature": 24.0,
         "relative_humidity": 50.0
     }
     
-    # Define internal loads
+    # Define internal loads with schedules
+    occupancy_schedule = [0.0] * 8 + [1.0] * 8 + [0.5] * 8  # 8h off, 8h full, 8h half
+    lighting_schedule = [0.1] * 8 + [0.9] * 8 + [0.5] * 8
+    equipment_schedule = [0.2] * 8 + [0.8] * 8 + [0.4] * 8
+    
     internal_loads = {
         "people": {
             "number": 3,
             "activity_level": "Seated/Resting",
-            "hours_occupancy": "8h"
+            "occupancy_schedule": occupancy_schedule
         },
         "lights": {
             "power": 500.0,
             "use_factor": 0.9,
             "special_allowance": 0.1,
-            "hours_operation": "8h"
+            "lighting_schedule": lighting_schedule
         },
         "equipment": {
             "power": 1000.0,
             "use_factor": 0.7,
             "radiation_factor": 0.7,
-            "hours_operation": "8h"
+            "equipment_schedule": equipment_schedule
         },
         "infiltration": {
-            "flow_rate": 0.05
+            "height": 3.0,
+            "crack_length": 10.0
         },
         "ventilation": {
             "flow_rate": 0.1
         }
     }
     
-    # Calculate hourly cooling loads
+    # Calculate loads
     hourly_loads = cooling_load_calculator.calculate_hourly_cooling_loads(
         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 design cooling load
     design_loads = cooling_load_calculator.calculate_design_cooling_load(hourly_loads)
-    
-    # Calculate cooling load summary
     summary = cooling_load_calculator.calculate_cooling_load_summary(design_loads)
     
     # Print results
     print("Cooling 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 Loads: {summary['internal_loads']:.2f} W")
-    print(f"Total Sensible: {summary['total_sensible']:.2f} W")
-    print(f"Total Latent: {summary['total_latent']:.2f} W")
-    print(f"Total: {summary['total']:.2f} W")
-    print(f"Sensible Heat Ratio: {summary['sensible_heat_ratio']:.2f}")
-    print(f"Design Hour: {summary['design_hour']}")
+    for key, value in summary.items():
+        if isinstance(value, float):
+            print(f"{key.replace('_', ' ').title()}: {value:.2f} W")
+        else:
+            print(f"{key.replace('_', ' ').title()}: {value}")