Update utils/cooling_load.py

utils/cooling_load.py

@@ -1,906 +1,712 @@
 """
 Cooling load calculation module for HVAC Load Calculator.
-This module implements an enhanced CLTD/CLF method with dynamic heat transfer,
-detailed solar calculations, and pressure-driven infiltration.
+Based on ASHRAE steady-state calculation methods.
+
+Author: Dr Majed Abuseif
+Date: March 2025
+Version: 1.0.0
 """
 
 from typing import Dict, List, Any, Optional, Tuple
-import math
 import numpy as np
-import pandas as pd
-import os
-from datetime import datetime, timedelta
-from enum import Enum
-
-# Import data models and utilities
-from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+from datetime import datetime
 from data.ashrae_tables import ASHRAETables
-from utils.psychrometrics import Psychrometrics
 from utils.heat_transfer import HeatTransferCalculations
-
-# Define paths
-DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+from app.component_selection import Wall, Roof, Window, Door, Orientation
 
 
 class CoolingLoadCalculator:
-    """Class for calculating cooling loads using an enhanced CLTD/CLF method."""
+    """Class for cooling load calculations."""
     
     def __init__(self):
-        """Initialize cooling load calculator with heat transfer and psychrometrics utilities."""
-        self.heat_transfer = HeatTransferCalculations()
-        self.psychrometrics = Psychrometrics()
+        """Initialize cooling load calculator."""
         self.ashrae_tables = ASHRAETables()
+        self.heat_transfer = HeatTransferCalculations()
+        self.hours = list(range(1, 25))
     
-    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", day_of_year: int = 204,
-                                   wind_speed: float = 4.0) -> float:
+    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],
+        building_volume: float
+    ) -> Dict[str, Any]:
         """
-        Calculate cooling load through a wall using enhanced CLTD method with thermal mass.
+        Calculate hourly cooling loads for all components.
         
         Args:
-            wall: Wall object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            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)
+            building_components: Dictionary of building components
+            outdoor_conditions: Outdoor weather conditions
+            indoor_conditions: Indoor design conditions
+            internal_loads: Internal heat gains
+            building_volume: Building volume in cubic meters
             
         Returns:
-            Cooling load in W
+            Dictionary containing hourly cooling loads
         """
-        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)
+        hourly_loads = {
+            'walls': {h: 0.0 for h in self.hours},
+            'roofs': {h: 0.0 for h in self.hours},
+            'windows_conduction': {h: 0.0 for h in self.hours},
+            'windows_solar': {h: 0.0 for h in self.hours},
+            'doors': {h: 0.0 for h in self.hours},
+            'people_sensible': {h: 0.0 for h in self.hours},
+            'people_latent': {h: 0.0 for h in self.hours},
+            'lights': {h: 0.0 for h in self.hours},
+            'equipment_sensible': {h: 0.0 for h in self.hours},
+            'equipment_latent': {h: 0.0 for h in self.hours},
+            'infiltration_sensible': {h: 0.0 for h in self.hours},
+            'infiltration_latent': {h: 0.0 for h in self.hours},
+            'ventilation_sensible': {h: 0.0 for h in self.hours},
+            'ventilation_latent': {h: 0.0 for h in self.hours}
+        }
         
-        # 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
+        try:
+            # Calculate loads for walls
+            for wall in building_components.get('walls', []):
+                for hour in self.hours:
+                    load = self.calculate_wall_cooling_load(
+                        wall=wall,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        month=outdoor_conditions['month'],
+                        hour=hour,
+                        latitude=outdoor_conditions['latitude']
+                    )
+                    hourly_loads['walls'][hour] += load
+            
+            # Calculate loads for roofs
+            for roof in building_components.get('roofs', []):
+                for hour in self.hours:
+                    load = self.calculate_roof_cooling_load(
+                        roof=roof,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        month=outdoor_conditions['month'],
+                        hour=hour,
+                        latitude=outdoor_conditions['latitude']
+                    )
+                    hourly_loads['roofs'][hour] += load
+            
+            # Calculate loads for windows
+            for window in building_components.get('windows', []):
+                for hour in self.hours:
+                    load_dict = self.calculate_window_cooling_load(
+                        window=window,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        month=outdoor_conditions['month'],
+                        hour=hour,
+                        latitude=outdoor_conditions['latitude'],
+                        shading_coefficient=window.shading_coefficient
+                    )
+                    hourly_loads['windows_conduction'][hour] += load_dict['conduction']
+                    hourly_loads['windows_solar'][hour] += load_dict['solar']
+            
+            # Calculate loads for doors
+            for door in building_components.get('doors', []):
+                for hour in self.hours:
+                    load = self.calculate_door_cooling_load(
+                        door=door,
+                        outdoor_temp=outdoor_conditions['temperature'],
+                        indoor_temp=indoor_conditions['temperature']
+                    )
+                    hourly_loads['doors'][hour] += load
+            
+            # Calculate internal loads
+            for hour in self.hours:
+                # People loads
+                people_load = self.calculate_people_cooling_load(
+                    num_people=internal_loads['people']['number'],
+                    activity_level=internal_loads['people']['activity_level'],
+                    hour=hour
                 )
-            ),
-            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 with sol-air temperature
-        cltd = self.ashrae_tables.calculate_corrected_cltd_wall(
-            wall_group=wall_group,
-            orientation=orientation,
-            hour=hour,
-            color=color,
-            month=month,
-            latitude=latitude,
-            indoor_temp=indoor_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
+                hourly_loads['people_sensible'][hour] += people_load['sensible']
+                hourly_loads['people_latent'][hour] += people_load['latent']
+                
+                # Lighting loads
+                lights_load = self.calculate_lights_cooling_load(
+                    power=internal_loads['lights']['power'],
+                    use_factor=internal_loads['lights']['use_factor'],
+                    special_allowance=internal_loads['lights']['special_allowance'],
+                    hour=hour
+                )
+                hourly_loads['lights'][hour] += lights_load
+                
+                # Equipment loads
+                equipment_load = self.calculate_equipment_cooling_load(
+                    power=internal_loads['equipment']['power'],
+                    use_factor=internal_loads['equipment']['use_factor'],
+                    radiation_factor=internal_loads['equipment']['radiation_factor'],
+                    hour=hour
+                )
+                hourly_loads['equipment_sensible'][hour] += equipment_load['sensible']
+                hourly_loads['equipment_latent'][hour] += equipment_load['latent']
+                
+                # Infiltration loads
+                infiltration_load = self.calculate_infiltration_cooling_load(
+                    flow_rate=internal_loads['infiltration']['flow_rate'],
+                    building_volume=building_volume,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    outdoor_rh=outdoor_conditions['relative_humidity'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    indoor_rh=indoor_conditions['relative_humidity']
+                )
+                hourly_loads['infiltration_sensible'][hour] += infiltration_load['sensible']
+                hourly_loads['infiltration_latent'][hour] += infiltration_load['latent']
+                
+                # Ventilation loads
+                ventilation_load = self.calculate_ventilation_cooling_load(
+                    flow_rate=internal_loads['ventilation']['flow_rate'],
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    outdoor_rh=outdoor_conditions['relative_humidity'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    indoor_rh=indoor_conditions['relative_humidity']
+                )
+                hourly_loads['ventilation_sensible'][hour] += ventilation_load['sensible']
+                hourly_loads['ventilation_latent'][hour] += ventilation_load['latent']
         
-        # Calculate cooling load
-        cooling_load = u_value * area * cltd_adjusted
+            return hourly_loads
         
-        return max(0, cooling_load)
+        except Exception as e:
+            raise Exception(f"Error in calculate_hourly_cooling_loads: {str(e)}")
     
-    def calculate_roof_cooling_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float, 
-                                   month: str, hour: int, latitude: str = "40N",
-                                   color: str = "Dark", day_of_year: int = 204,
-                                   wind_speed: float = 4.0) -> float:
+    def calculate_design_cooling_load(self, hourly_loads: Dict[str, Any]) -> Dict[str, Any]:
         """
-        Calculate cooling load through a roof using enhanced CLTD method with thermal mass.
+        Calculate design cooling load based on peak hourly loads.
         
         Args:
-            roof: Roof object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            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)
+            hourly_loads: Dictionary of hourly cooling loads
             
         Returns:
-            Cooling load in W
+            Dictionary containing design cooling loads
         """
-        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(
-            roof_group=roof_group,
-            hour=hour,
-            color=color,
-            month=month,
-            latitude=latitude,
-            indoor_temp=indoor_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_adjusted
+        try:
+            design_loads = {}
+            total_loads = []
+            
+            for hour in self.hours:
+                total_load = sum([
+                    hourly_loads['walls'][hour],
+                    hourly_loads['roofs'][hour],
+                    hourly_loads['windows_conduction'][hour],
+                    hourly_loads['windows_solar'][hour],
+                    hourly_loads['doors'][hour],
+                    hourly_loads['people_sensible'][hour],
+                    hourly_loads['people_latent'][hour],
+                    hourly_loads['lights'][hour],
+                    hourly_loads['equipment_sensible'][hour],
+                    hourly_loads['equipment_latent'][hour],
+                    hourly_loads['infiltration_sensible'][hour],
+                    hourly_loads['infiltration_latent'][hour],
+                    hourly_loads['ventilation_sensible'][hour],
+                    hourly_loads['ventilation_latent'][hour]
+                ])
+                total_loads.append(total_load)
+            
+            design_hour = self.hours[np.argmax(total_loads)]
+            
+            design_loads = {
+                'design_hour': design_hour,
+                'walls': hourly_loads['walls'][design_hour],
+                'roofs': hourly_loads['roofs'][design_hour],
+                'windows_conduction': hourly_loads['windows_conduction'][design_hour],
+                'windows_solar': hourly_loads['windows_solar'][design_hour],
+                'doors': hourly_loads['doors'][design_hour],
+                'people_sensible': hourly_loads['people_sensible'][design_hour],
+                'people_latent': hourly_loads['people_latent'][design_hour],
+                'lights': hourly_loads['lights'][design_hour],
+                'equipment_sensible': hourly_loads['equipment_sensible'][design_hour],
+                'equipment_latent': hourly_loads['equipment_latent'][design_hour],
+                'infiltration_sensible': hourly_loads['infiltration_sensible'][design_hour],
+                'infiltration_latent': hourly_loads['infiltration_latent'][design_hour],
+                'ventilation_sensible': hourly_loads['ventilation_sensible'][design_hour],
+                'ventilation_latent': hourly_loads['ventilation_latent'][design_hour]
+            }
+            
+            return design_loads
         
-        return max(0, cooling_load)
+        except Exception as e:
+            raise Exception(f"Error in calculate_design_cooling_load: {str(e)}")
     
-    def calculate_window_cooling_load(self, window: Window, outdoor_temp: float, indoor_temp: float, 
-                                     month: str, hour: int, latitude: str = "40N",
-                                     shading_coefficient: float = 1.0, day_of_year: int = 204) -> Dict[str, float]:
+    def calculate_cooling_load_summary(self, design_loads: Dict[str, Any]) -> Dict[str, float]:
         """
-        Calculate cooling load through a window using dynamic solar calculations.
+        Calculate summary of cooling loads.
         
         Args:
-            window: Window object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            month: Month (Jan, Feb, ..., Dec)
-            hour: Hour of the day (0-23)
-            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)
+            design_loads: Dictionary of design cooling loads
             
         Returns:
-            Dictionary with conduction, solar, and total cooling loads in W
+            Dictionary containing cooling load summary
         """
-        self.validate_inputs(outdoor_temp, 50.0, window.area, window.u_value)
-        
-        # Get window properties
-        u_value = window.u_value
-        area = window.area
-        orientation = window.orientation.value
-        shgc = window.shgc
-        
-        # Calculate conduction cooling load
-        delta_t = outdoor_temp - indoor_temp
-        conduction_load = u_value * area * delta_t
-        
-        # 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
+        try:
+            total_sensible = (
+                design_loads['walls'] +
+                design_loads['roofs'] +
+                design_loads['windows_conduction'] +
+                design_loads['windows_solar'] +
+                design_loads['doors'] +
+                design_loads['people_sensible'] +
+                design_loads['lights'] +
+                design_loads['equipment_sensible'] +
+                design_loads['infiltration_sensible'] +
+                design_loads['ventilation_sensible']
+            )
+            
+            total_latent = (
+                design_loads['people_latent'] +
+                design_loads['equipment_latent'] +
+                design_loads['infiltration_latent'] +
+                design_loads['ventilation_latent']
+            )
+            
+            total = total_sensible + total_latent
+            
+            return {
+                'total_sensible': total_sensible,
+                'total_latent': total_latent,
+                'total': total
+            }
         
-        return {
-            "conduction": max(0, conduction_load),
-            "solar": max(0, solar_load),
-            "total": max(0, total_load)
-        }
+        except Exception as e:
+            raise Exception(f"Error in calculate_cooling_load_summary: {str(e)}")
     
-    def calculate_door_cooling_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
+    def calculate_wall_cooling_load(
+        self,
+        wall: Wall,
+        outdoor_temp: float,
+        indoor_temp: float,
+        month: str,
+        hour: int,
+        latitude: str
+    ) -> float:
         """
-        Calculate cooling load through a door using simple conduction.
+        Calculate cooling load for a wall.
         
         Args:
-            door: Door object
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
+            wall: Wall component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
+            month: Design month
+            hour: Hour of the day
+            latitude: Latitude (e.g., '40N')
             
         Returns:
-            Cooling load in W
+            Cooling load in Watts
         """
-        self.validate_inputs(outdoor_temp, 50.0, door.area, door.u_value)
-        
-        u_value = door.u_value
-        area = door.area
-        delta_t = outdoor_temp - indoor_temp
-        cooling_load = u_value * area * delta_t
+        try:
+            cltd = self.ashrae_tables.calculate_corrected_cltd_wall(
+                wall_group=wall.wall_group,
+                orientation=wall.orientation.value,
+                hour=hour,
+                color='Dark',
+                month=month,
+                latitude=latitude,
+                indoor_temp=indoor_temp,
+                outdoor_temp=outdoor_temp
+            )
+            
+            load = wall.u_value * wall.area * cltd
+            return max(load, 0.0)
         
-        return max(0, cooling_load)
+        except Exception as e:
+            raise Exception(f"Error in calculate_wall_cooling_load: {str(e)}")
     
-    def calculate_floor_cooling_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
+    def calculate_roof_cooling_load(
+        self,
+        roof: Roof,
+        outdoor_temp: float,
+        indoor_temp: float,
+        month: str,
+        hour: int,
+        latitude: str
+    ) -> float:
         """
-        Calculate cooling load through a floor.
+        Calculate cooling load for a roof.
         
         Args:
-            floor: Floor object
-            ground_temp: Ground or adjacent space temperature in °C
-            indoor_temp: Indoor temperature in °C
+            roof: Roof component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
+            month: Design month
+            hour: Hour of the day
+            latitude: Latitude (e.g., '40N')
             
         Returns:
-            Cooling load in W
+            Cooling load in Watts
         """
-        self.validate_inputs(ground_temp, 50.0, floor.area, floor.u_value)
-        
-        u_value = floor.u_value
-        area = floor.area
-        delta_t = ground_temp - indoor_temp
-        cooling_load = u_value * area * delta_t
+        try:
+            cltd = self.ashrae_tables.calculate_corrected_cltd_roof(
+                roof_group=roof.roof_group,
+                hour=hour,
+                color='Dark',
+                month=month,
+                latitude=latitude,
+                indoor_temp=indoor_temp,
+                outdoor_temp=outdoor_temp
+            )
+            
+            load = roof.u_value * roof.area * cltd
+            return max(load, 0.0)
         
-        return max(0, cooling_load)
+        except Exception as e:
+            raise Exception(f"Error in calculate_roof_cooling_load: {str(e)}")
     
-    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]:
+    def calculate_window_cooling_load(
+        self,
+        window: Window,
+        outdoor_temp: float,
+        indoor_temp: float,
+        month: str,
+        hour: int,
+        latitude: str,
+        shading_coefficient: float
+    ) -> Dict[str, float]:
         """
-        Calculate sensible and latent cooling loads due to pressure-driven infiltration.
+        Calculate cooling load for a window (conduction and solar).
         
         Args:
-            building_volume: Building volume in m³
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            outdoor_rh: Outdoor relative humidity in %
-            indoor_rh: Indoor relative humidity in %
-            wind_speed: Wind speed in m/s (default: 4.0 m/s)
-            height: Building height in m (default: 3.0 m)
-            crack_length: Total crack length in m (default: 10.0 m)
+            window: Window component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
+            month: Design month
+            hour: Hour of the day
+            latitude: Latitude (e.g., '40N')
+            shading_coefficient: Shading coefficient for drapery
             
         Returns:
-            Dictionary with sensible, latent, and total cooling loads in W
+            Dictionary with conduction and solar loads in Watts
         """
-        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,
-            delta_t=outdoor_temp - indoor_temp
-        )
-        
-        # Calculate humidity ratios
-        w_outdoor = self.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
-        w_indoor = self.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
-        
-        # Calculate latent cooling load
-        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
+        try:
+            # Conduction load
+            delta_t = outdoor_temp - indoor_temp
+            conduction_load = window.u_value * window.area * delta_t
+            
+            # Solar load
+            solar_altitude = self.heat_transfer.solar.solar_altitude
+            scl_latitude = f"{float(latitude[:-1])}_{month.upper()}"
+            scl = self.ashrae_tables.get_scl(
+                orientation=window.orientation.value,
+                hour=hour,
+                latitude=scl_latitude
+            )
+            
+            solar_load = window.area * window.shgc * scl * shading_coefficient
+            
+            return {
+                'conduction': max(conduction_load, 0.0),
+                'solar': max(solar_load, 0.0),
+                'total': max(conduction_load + solar_load, 0.0)
+            }
         
-        return {
-            "sensible": max(0, sensible_load),
-            "latent": max(0, latent_load),
-            "total": max(0, total_load)
-        }
+        except Exception as e:
+            raise Exception(f"Error in calculate_window_cooling_load: {str(e)}")
     
-    def calculate_ventilation_cooling_load(self, flow_rate: float, outdoor_temp: float, indoor_temp: float,
-                                          outdoor_rh: float, indoor_rh: float) -> Dict[str, float]:
+    def calculate_door_cooling_load(
+        self,
+        door: Door,
+        outdoor_temp: float,
+        indoor_temp: float
+    ) -> float:
         """
-        Calculate sensible and latent cooling loads due to ventilation.
+        Calculate cooling load for a door.
         
         Args:
-            flow_rate: Ventilation flow rate in m³/s
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            outdoor_rh: Outdoor relative humidity in %
-            indoor_rh: Indoor relative humidity in %
+            door: Door component
+            outdoor_temp: Outdoor temperature (°C)
+            indoor_temp: Indoor temperature (°C)
             
         Returns:
-            Dictionary with sensible, latent, and total cooling loads in W
+            Cooling load in Watts
         """
-        self.validate_inputs(outdoor_temp, outdoor_rh, 0.0, 0.0)
-        
-        sensible_load = self.heat_transfer.infiltration_heat_transfer(
-            flow_rate=flow_rate,
-            delta_t=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
+        try:
+            delta_t = outdoor_temp - indoor_temp
+            load = door.u_value * door.area * delta_t
+            return max(load, 0.0)
         
-        return {
-            "sensible": max(0, sensible_load),
-            "latent": max(0, latent_load),
-            "total": max(0, total_load)
-        }
+        except Exception as e:
+            raise Exception(f"Error in calculate_door_cooling_load: {str(e)}")
     
-    def calculate_people_cooling_load(self, num_people: int, activity_level: str, 
-                                    hour: int, occupancy_schedule: Optional[List[float]] = None) -> Dict[str, float]:
+    def calculate_people_cooling_load(
+        self,
+        num_people: int,
+        activity_level: str,
+        hour: int
+    ) -> Dict[str, float]:
         """
-        Calculate sensible and latent cooling loads due to people with schedule.
+        Calculate cooling load from people.
         
         Args:
             num_people: Number of people
-            activity_level: Activity level (Seated/Resting, Light work, Medium work, Heavy work)
-            hour: Hour of the day (0-23)
-            occupancy_schedule: List of 24 hourly occupancy factors (0-1, default: None)
+            activity_level: Activity level
+            hour: Hour of the day
             
         Returns:
-            Dictionary with sensible, latent, and total cooling loads in W
+            Dictionary with sensible and latent loads in Watts
         """
-        activity_gains = {
-            "Seated/Resting": {"sensible": 70, "latent": 45},
-            "Light work": {"sensible": 75, "latent": 55},
-            "Medium work": {"sensible": 85, "latent": 80},
-            "Heavy work": {"sensible": 95, "latent": 145}
-        }
-        
-        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"]
-        
-        # Apply occupancy schedule
-        occupancy_factor = 1.0
-        if occupancy_schedule and len(occupancy_schedule) == 24:
-            occupancy_factor = occupancy_schedule[hour]
-        
-        sensible_load = num_people * sensible_gain * occupancy_factor
-        latent_load = num_people * latent_gain * occupancy_factor
-        total_load = sensible_load + latent_load
+        try:
+            sensible_gain = {
+                'Seated/Resting': 70,
+                'Light Work': 100,
+                'Moderate Work': 150,
+                'Heavy Work': 200
+            }.get(activity_level, 70)
+            
+            latent_gain = {
+                'Seated/Resting': 45,
+                'Light Work': 75,
+                'Moderate Work': 120,
+                'Heavy Work': 180
+            }.get(activity_level, 45)
+            
+            clf = self.ashrae_tables.get_clf_people(hour, '8h')
+            
+            sensible_load = num_people * sensible_gain * clf
+            latent_load = num_people * latent_gain
+            
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0),
+                'total': max(sensible_load + latent_load, 0.0)
+            }
         
-        return {
-            "sensible": max(0, sensible_load),
-            "latent": max(0, latent_load),
-            "total": max(0, total_load)
-        }
+        except Exception as e:
+            raise Exception(f"Error in calculate_people_cooling_load: {str(e)}")
     
-    def calculate_lights_cooling_load(self, power: float, use_factor: float, 
-                                    special_allowance: float, hour: int,
-                                    lighting_schedule: Optional[List[float]] = None) -> float:
+    def calculate_lights_cooling_load(
+        self,
+        power: float,
+        use_factor: float,
+        special_allowance: float,
+        hour: int
+    ) -> float:
         """
-        Calculate cooling load due to lights with schedule.
+        Calculate cooling load from lighting.
         
         Args:
-            power: Installed lighting power in W
-            use_factor: Usage factor (0-1)
-            special_allowance: Special allowance factor for fixtures (0-1)
-            hour: Hour of the day (0-23)
-            lighting_schedule: List of 24 hourly lighting factors (0-1, default: None)
+            power: Lighting power (W)
+            use_factor: Usage factor
+            special_allowance: Special allowance factor
+            hour: Hour of the day
             
         Returns:
-            Cooling load in W
+            Cooling load in Watts
         """
-        schedule_factor = 1.0
-        if lighting_schedule and len(lighting_schedule) == 24:
-            schedule_factor = lighting_schedule[hour]
+        try:
+            clf = self.ashrae_tables.get_clf_lights(hour, '8h')
+            load = power * use_factor * special_allowance * clf
+            return max(load, 0.0)
         
-        cooling_load = power * use_factor * (1 + special_allowance) * schedule_factor
-        
-        return max(0, cooling_load)
+        except Exception as e:
+            raise Exception(f"Error in calculate_lights_cooling_load: {str(e)}")
     
-    def calculate_equipment_cooling_load(self, power: float, use_factor: float, 
-                                       radiation_factor: float, hour: int,
-                                       equipment_schedule: Optional[List[float]] = None) -> Dict[str, float]:
+    def calculate_equipment_cooling_load(
+        self,
+        power: float,
+        use_factor: float,
+        radiation_factor: float,
+        hour: int
+    ) -> Dict[str, float]:
         """
-        Calculate sensible and latent cooling loads due to equipment with schedule.
+        Calculate cooling load from equipment.
         
         Args:
-            power: Equipment power in W
-            use_factor: Usage factor (0-1)
-            radiation_factor: Radiation factor (0-1)
-            hour: Hour of the day (0-23)
-            equipment_schedule: List of 24 hourly equipment factors (0-1, default: None)
+            power: Equipment power (W)
+            use_factor: Usage factor
+            radiation_factor: Radiation factor
+            hour: Hour of the day
             
         Returns:
-            Dictionary with sensible, latent, and total cooling loads in W
+            Dictionary with sensible and latent loads in Watts
         """
-        schedule_factor = 1.0
-        if equipment_schedule and len(equipment_schedule) == 24:
-            schedule_factor = equipment_schedule[hour]
-        
-        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
+        try:
+            clf = self.ashrae_tables.get_clf_equipment(hour, '8h')
+            sensible_load = power * use_factor * radiation_factor * clf
+            latent_load = power * use_factor * (1 - radiation_factor)
+            
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0),
+                'total': max(sensible_load + latent_load, 0.0)
+            }
         
-        return {
-            "sensible": max(0, sensible_load),
-            "latent": max(0, latent_load),
-            "total": max(0, total_load)
-        }
+        except Exception as e:
+            raise Exception(f"Error in calculate_equipment_cooling_load: {str(e)}")
     
-    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],
-                                      building_volume: float = 300.0) -> Dict[int, Dict[str, float]]:
+    def calculate_infiltration_cooling_load(
+        self,
+        flow_rate: float,
+        building_volume: float,
+        outdoor_temp: float,
+        outdoor_rh: float,
+        indoor_temp: float,
+        indoor_rh: float
+    ) -> Dict[str, float]:
         """
-        Calculate hourly cooling loads for a building with enhanced calculations.
+        Calculate cooling load from infiltration.
         
         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³)
+            flow_rate: Infiltration flow rate (m³/s)
+            building_volume: Building volume (m³)
+            outdoor_temp: Outdoor temperature (°C)
+            outdoor_rh: Outdoor relative humidity (%)
+            indoor_temp: Indoor temperature (°C)
+            indoor_rh: Indoor relative humidity (%)
             
         Returns:
-            Dictionary with hourly cooling loads
+            Dictionary with sensible and latent loads in Watts
         """
-        # 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", [])
-        
-        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)
-        
-        indoor_temp = indoor_conditions.get("temperature", 24.0)
-        indoor_rh = indoor_conditions.get("relative_humidity", 50.0)
-        
-        people = internal_loads.get("people", {})
-        lights = internal_loads.get("lights", {})
-        equipment = internal_loads.get("equipment", {})
-        infiltration = internal_loads.get("infiltration", {})
-        ventilation = internal_loads.get("ventilation", {})
-        
-        # Initialize hourly loads
-        hourly_loads = {}
-        
-        for hour in range(24):
-            loads = {
-                "walls": 0,
-                "roofs": 0,
-                "floors": 0,
-                "windows_conduction": 0,
-                "windows_solar": 0,
-                "doors": 0,
-                "infiltration_sensible": 0,
-                "infiltration_latent": 0,
-                "ventilation_sensible": 0,
-                "ventilation_latent": 0,
-                "people_sensible": 0,
-                "people_latent": 0,
-                "lights": 0,
-                "equipment_sensible": 0,
-                "equipment_latent": 0,
-                "total_sensible": 0,
-                "total_latent": 0,
-                "total": 0
-            }
-            
-            # Wall loads
-            for wall in walls:
-                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",
-                    day_of_year=day_of_year,
-                    wind_speed=wind_speed
-                )
-            
-            # Roof loads
-            for roof in roofs:
-                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",
-                    day_of_year=day_of_year,
-                    wind_speed=wind_speed
-                )
-            
-            # Floor loads
-            for floor in floors:
-                loads["floors"] += self.calculate_floor_cooling_load(
-                    floor=floor,
-                    ground_temp=ground_temp,
-                    indoor_temp=indoor_temp
-                )
+        try:
+            air_changes_per_hour = (flow_rate * 3600) / building_volume
+            sensible_load = 1.2 * flow_rate * 1000 * (outdoor_temp - indoor_temp)
             
-            # Window loads
-            for window in windows:
-                window_loads = self.calculate_window_cooling_load(
-                    window=window,
-                    outdoor_temp=outdoor_temp,
-                    indoor_temp=indoor_temp,
-                    month=month,
-                    hour=hour,
-                    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"]
-            
-            # Door loads
-            for door in doors:
-                loads["doors"] += self.calculate_door_cooling_load(
-                    door=door,
-                    outdoor_temp=outdoor_temp,
-                    indoor_temp=indoor_temp
-                )
-            
-            # Infiltration loads
-            if infiltration:
-                infiltration_loads = self.calculate_infiltration_cooling_load(
-                    building_volume=building_volume,
-                    outdoor_temp=outdoor_temp,
-                    indoor_temp=indoor_temp,
-                    outdoor_rh=outdoor_rh,
-                    indoor_rh=indoor_rh,
-                    wind_speed=wind_speed,
-                    height=infiltration.get("height", 3.0),
-                    crack_length=infiltration.get("crack_length", 10.0)
-                )
-                loads["infiltration_sensible"] = infiltration_loads["sensible"]
-                loads["infiltration_latent"] = infiltration_loads["latent"]
-            
-            # Ventilation loads
-            if ventilation:
-                flow_rate = ventilation.get("flow_rate", 0.0)
-                ventilation_loads = self.calculate_ventilation_cooling_load(
-                    flow_rate=flow_rate,
-                    outdoor_temp=outdoor_temp,
-                    indoor_temp=indoor_temp,
-                    outdoor_rh=outdoor_rh,
-                    indoor_rh=indoor_rh
-                )
-                loads["ventilation_sensible"] = ventilation_loads["sensible"]
-                loads["ventilation_latent"] = ventilation_loads["latent"]
-            
-            # People loads
-            if people:
-                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"]
-            
-            # Lights loads
-            if lights:
-                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)
-                )
+            # Calculate humidity ratio difference
+            outdoor_w = self.heat_transfer.psychrometrics.calculate_humidity_ratio(outdoor_temp, outdoor_rh)
+            indoor_w = self.heat_transfer.psychrometrics.calculate_humidity_ratio(indoor_temp, indoor_rh)
+            latent_load = 2501 * flow_rate * 1000 * (outdoor_w - indoor_w)
             
-            # Equipment loads
-            if equipment:
-                equipment_loads = self.calculate_equipment_cooling_load(
-                    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 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"]
-            
-            hourly_loads[hour] = loads
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0),
+                'total': max(sensible_load + latent_load, 0.0)
+            }
         
-        return hourly_loads
+        except Exception as e:
+            raise Exception(f"Error in calculate_infiltration_cooling_load: {str(e)}")
     
-    def calculate_design_cooling_load(self, hourly_loads: Dict[int, Dict[str, float]]) -> Dict[str, float]:
+    def calculate_ventilation_cooling_load(
+        self,
+        flow_rate: float,
+        outdoor_temp: float,
+        outdoor_rh: float,
+        indoor_temp: float,
+        indoor_rh: float
+    ) -> Dict[str, float]:
         """
-        Calculate design cooling load based on hourly loads.
+        Calculate cooling load from ventilation.
         
         Args:
-            hourly_loads: Dictionary with hourly cooling loads
+            flow_rate: Ventilation flow rate (m³/s)
+            outdoor_temp: Outdoor temperature (°C)
+            outdoor_rh: Outdoor relative humidity (%)
+            indoor_temp: Indoor temperature (°C)
+            indoor_rh: Indoor relative humidity (%)
             
         Returns:
-            Dictionary with design cooling loads
-        """
-        max_hour = max(hourly_loads.keys(), key=lambda h: hourly_loads[h]["total"])
-        design_loads = hourly_loads[max_hour].copy()
-        design_loads["design_hour"] = max_hour
-        return design_loads
-    
-    def calculate_cooling_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
+            Dictionary with sensible and latent loads in Watts
         """
-        Calculate cooling load summary.
-        
-        Args:
-            design_loads: Dictionary with design cooling loads
+        try:
+            sensible_load = 1.2 * flow_rate * 1000 * (outdoor_temp - indoor_temp)
             
-        Returns:
-            Dictionary with cooling load summary
-        """
-        envelope_loads = sum([
-            design_loads["walls"], design_loads["roofs"], design_loads["floors"],
-            design_loads["windows_conduction"], design_loads["windows_solar"],
-            design_loads["doors"]
-        ])
-        ventilation_loads = design_loads["ventilation_sensible"] + design_loads["ventilation_latent"]
-        infiltration_loads = design_loads["infiltration_sensible"] + design_loads["infiltration_latent"]
-        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
+            # Calculate humidity ratio difference
+            outdoor_w = self.heat_transfer.psychrometrics.calculate_humidity_ratio(outdoor_temp, outdoor_rh)
+            indoor_w = self.heat_transfer.psychrometrics.calculate_humidity_ratio(indoor_temp, indoor_rh)
+            latent_load = 2501 * flow_rate * 1000 * (outdoor_w - indoor_w)
+            
+            return {
+                'sensible': max(sensible_load, 0.0),
+                'latent': max(latent_load, 0.0),
+                'total': max(sensible_load + latent_load, 0.0)
+            }
         
-        return {
-            "envelope_loads": envelope_loads,
-            "ventilation_loads": ventilation_loads,
-            "infiltration_loads": infiltration_loads,
-            "internal_loads": internal_loads,
-            "total_sensible": design_loads["total_sensible"],
-            "total_latent": design_loads["total_latent"],
-            "total": design_loads["total"],
-            "sensible_heat_ratio": shr,
-            "design_hour": design_loads["design_hour"]
-        }
-
+        except Exception as e:
+            raise Exception(f"Error in calculate_ventilation_cooling_load: {str(e)}")
 
-# Create a singleton instance
-cooling_load_calculator = CoolingLoadCalculator()
 
-# Example usage
 if __name__ == "__main__":
-    from data.building_components import Wall, Roof, Window, Door, Orientation, ComponentType
-    
-    # Sample building components
-    wall = Wall(
-        id="wall1",
-        name="Exterior Wall",
-        component_type=ComponentType.WALL,
-        u_value=0.5,
-        area=20.0,
-        orientation=Orientation.SOUTH,
-        wall_type="Brick",
-        wall_group="B",
-        thermal_mass=100000,
-        time_constant=2.0,
-        color="Dark"
-    )
-    roof = Roof(
-        id="roof1",
-        name="Flat Roof",
-        component_type=ComponentType.ROOF,
-        u_value=0.3,
-        area=50.0,
-        orientation=Orientation.HORIZONTAL,
-        roof_type="Concrete",
-        roof_group="C",
-        thermal_mass=200000,
-        time_constant=3.0,
-        color="Dark"
-    )
-    window = Window(
-        id="window1",
-        name="South Window",
-        component_type=ComponentType.WINDOW,
-        u_value=2.8,
-        area=5.0,
-        orientation=Orientation.SOUTH,
-        shgc=0.7,
-        vt=0.8,
-        window_type="Double Glazed",
-        glazing_layers=2,
-        gas_fill="Air",
-        low_e_coating=False,
-        shading_coefficient=1.0
-    )
+    # Example usage for testing
+    calculator = CoolingLoadCalculator()
     
+    # Dummy inputs
     building_components = {
-        "walls": [wall],
-        "roofs": [roof],
-        "windows": [window],
-        "doors": [],
-        "floors": []
+        'walls': [Wall(
+            name="North Wall",
+            orientation=Orientation.NORTH,
+            area=20.0,
+            u_value=0.5,
+            wall_group="A"
+        )],
+        'roofs': [Roof(
+            name="Main Roof",
+            orientation=Orientation.HORIZONTAL,
+            area=100.0,
+            u_value=0.3,
+            roof_group="1"
+        )],
+        'windows': [Window(
+            name="South Window",
+            orientation=Orientation.SOUTH,
+            area=10.0,
+            u_value=2.8,
+            shgc=0.7,
+            shading_device="Medium drapery",
+            shading_coefficient=0.8
+        )],
+        'doors': [Door(
+            name="Main Door",
+            orientation=Orientation.NORTH,
+            area=2.0,
+            u_value=2.0
+        )]
     }
     
-    # Define conditions
     outdoor_conditions = {
-        "temperature": 35.0,
-        "relative_humidity": 50.0,
-        "ground_temperature": 20.0,
-        "month": "Jul",
-        "latitude": "40N",
-        "wind_speed": 4.0,
-        "day_of_year": 204
+        'temperature': 35.0,
+        'relative_humidity': 50.0,
+        'ground_temperature': 20.0,
+        'month': 'Jul',
+        'latitude': '31.973N',
+        'wind_speed': 4.0,
+        'day_of_year': 204
     }
+    
     indoor_conditions = {
-        "temperature": 24.0,
-        "relative_humidity": 50.0
+        'temperature': 24.0,
+        'relative_humidity': 50.0
     }
     
-    # 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",
-            "occupancy_schedule": occupancy_schedule
+        'people': {
+            'number': 10,
+            'activity_level': 'Seated/Resting',
+            'operating_hours': '8:00-18:00'
         },
-        "lights": {
-            "power": 500.0,
-            "use_factor": 0.9,
-            "special_allowance": 0.1,
-            "lighting_schedule": lighting_schedule
+        'lights': {
+            'power': 1000.0,
+            'use_factor': 0.8,
+            'special_allowance': 0.1,
+            'hours_operation': '8h'
         },
-        "equipment": {
-            "power": 1000.0,
-            "use_factor": 0.7,
-            "radiation_factor": 0.7,
-            "equipment_schedule": equipment_schedule
+        'equipment': {
+            'power': 500.0,
+            'use_factor': 0.7,
+            'radiation_factor': 0.3,
+            'hours_operation': '8h'
         },
-        "infiltration": {
-            "height": 3.0,
-            "crack_length": 10.0
+        'infiltration': {
+            'flow_rate': 0.05,
+            'height': 3.0,
+            'crack_length': 10.0
         },
-        "ventilation": {
-            "flow_rate": 0.1
-        }
+        'ventilation': {
+            'flow_rate': 0.1
+        },
+        'operating_hours': '8:00-18:00'
     }
     
+    building_volume = 300.0
+    
     # Calculate loads
-    hourly_loads = cooling_load_calculator.calculate_hourly_cooling_loads(
+    hourly_loads = calculator.calculate_hourly_cooling_loads(
         building_components=building_components,
         outdoor_conditions=outdoor_conditions,
         indoor_conditions=indoor_conditions,
         internal_loads=internal_loads,
-        building_volume=300.0
+        building_volume=building_volume
     )
-    design_loads = cooling_load_calculator.calculate_design_cooling_load(hourly_loads)
-    summary = cooling_load_calculator.calculate_cooling_load_summary(design_loads)
     
-    # Print results
-    print("Cooling Load Summary:")
-    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}")
+    design_loads = calculator.calculate_design_cooling_load(hourly_loads)
+    summary = calculator.calculate_cooling_load_summary(design_loads)
+    
+    print("Cooling Load Summary:", summary)