Update utils/cooling_load.py

utils/cooling_load.py

@@ -4,675 +4,7 @@ Based on ASHRAE steady-state calculation methods.
 
 Author: Dr Majed Abuseif
 Date: April 2025
-Version: 1.0.2
-"""
-
-import streamlit as st
-from typing import Dict, List, Any, Optional, Tuple
-import numpy as np
-from datetime import datetime
-import logging
-from data.ashrae_tables import ASHRAETables
-from utils.heat_transfer import HeatTransferCalculations
-from app.component_selection import Wall, Roof, Window, Door, Orientation
-
-# Set up logging
-logging.basicConfig(level=logging.DEBUG)
-logger = logging.getLogger(__name__)
-
-class CoolingLoadCalculator:
-    """Class for cooling load calculations."""
-    
-    def __init__(self):
-        """Initialize cooling load calculator."""
-        self.ashrae_tables = ASHRAETables()
-        self.heat_transfer = HeatTransferCalculations()
-        self.hours = list(range(24))
-        self.valid_latitudes = ['24N', '36N', '48N']
-        self.valid_months = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
-        self.valid_wall_groups = ['A', 'B', 'C', 'D']
-        self.valid_roof_groups = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
-    
-    def validate_latitude(self, latitude: Any) -> str:
-        """
-        Validate and normalize latitude input.
-        
-        Args:
-            latitude: Latitude input (str, float, or other)
-            
-        Returns:
-            Valid latitude string ('24N', '36N', or '48N')
-        """
-        try:
-            if not isinstance(latitude, str):
-                latitude = str(latitude)
-            
-            latitude = latitude.strip().upper()
-            
-            # Handle concatenated formats like '24N_JUL'
-            if '_' in latitude:
-                parts = latitude.split('_')
-                if len(parts) > 1:
-                    lat_part = parts[0]
-                    if st.session_state.get('debug_mode', False):
-                        logger.warning(f"Detected concatenated input: {latitude}. Using latitude={lat_part}")
-                    latitude = lat_part
-            
-            # Handle formats like '31.973N', '1_31.973N'
-            if '.' in latitude or any(c.isdigit() for c in latitude):
-                num_part = ''.join(c for c in latitude if c.isdigit() or c == '.')
-                try:
-                    lat_val = float(num_part)
-                    if lat_val <= 30:
-                        return '24N'
-                    elif lat_val <= 42:
-                        return '36N'
-                    else:
-                        return '48N'
-                except ValueError:
-                    if st.session_state.get('debug_mode', False):
-                        logger.warning(f"Cannot parse latitude: {latitude}. Defaulting to '24N'")
-                    return '24N'
-            
-            if latitude not in self.valid_latitudes:
-                if st.session_state.get('debug_mode', False):
-                    logger.warning(f"Invalid latitude: {latitude}. Defaulting to '24N'")
-                return '24N'
-            
-            return latitude
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error validating latitude {latitude}: {str(e)}")
-            return '24N'
-    
-    def validate_month(self, month: Any) -> str:
-        """
-        Validate and normalize month input.
-        
-        Args:
-            month: Month input (str or other)
-            
-        Returns:
-            Valid month string in uppercase
-        """
-        try:
-            if not isinstance(month, str):
-                month = str(month)
-            
-            month_upper = month.strip().upper()
-            if month_upper not in self.valid_months:
-                if st.session_state.get('debug_mode', False):
-                    logger.warning(f"Invalid month: {month}. Defaulting to 'JUL'")
-                return 'JUL'
-            return month_upper
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error validating month {month}: {str(e)}")
-            return 'JUL'
-    
-    def validate_hour(self, hour: Any) -> int:
-        """
-        Validate and normalize hour input.
-        
-        Args:
-            hour: Hour input (int, float, or other)
-            
-        Returns:
-            Valid hour integer (0-23)
-        """
-        try:
-            hour = int(float(str(hour)))
-            if not 0 <= hour <= 23:
-                if st.session_state.get('debug_mode', False):
-                    logger.warning(f"Invalid hour: {hour}. Defaulting to 15")
-                return 15
-            return hour
-        except (ValueError, TypeError):
-            if st.session_state.get('debug_mode', False):
-                logger.warning(f"Invalid hour format: {hour}. Defaulting to 15")
-            return 15
-    
-    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 hourly cooling loads for all components.
-        
-        Args:
-            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:
-            Dictionary containing hourly cooling loads
-        """
-        hourly_loads = {
-            'walls': {h: 0.0 for h in range(1, 25)},
-            'roofs': {h: 0.0 for h in range(1, 25)},
-            'windows_conduction': {h: 0.0 for h in range(1, 25)},
-            'windows_solar': {h: 0.0 for h in range(1, 25)},
-            'doors': {h: 0.0 for h in range(1, 25)},
-            'people_sensible': {h: 0.0 for h in range(1, 25)},
-            'people_latent': {h: 0.0 for h in range(1, 25)},
-            'lights': {h: 0.0 for h in range(1, 25)},
-            'equipment_sensible': {h: 0.0 for h in range(1, 25)},
-            'equipment_latent': {h: 0.0 for h in range(1, 25)},
-            'infiltration_sensible': {h: 0.0 for h in range(1, 25)},
-            'infiltration_latent': {h: 0.0 for h in range(1, 25)},
-            'ventilation_sensible': {h: 0.0 for h in range(1, 25)},
-            'ventilation_latent': {h: 0.0 for h in range(1, 25)}
-        }
-        
-        try:
-            # Validate inputs
-            latitude = self.validate_latitude(outdoor_conditions.get('latitude', '24N'))
-            month = self.validate_month(outdoor_conditions.get('month', 'JUL'))
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"calculate_hourly_cooling_loads: latitude={latitude}, month={month}, outdoor_conditions={outdoor_conditions}")
-
-            # Calculate loads for walls
-            for wall in building_components.get('walls', []):
-                for hour in range(24):
-                    load = self.calculate_wall_cooling_load(
-                        wall=wall,
-                        outdoor_temp=outdoor_conditions['temperature'],
-                        indoor_temp=indoor_conditions['temperature'],
-                        month=month,
-                        hour=hour,
-                        latitude=latitude
-                    )
-                    hourly_loads['walls'][hour + 1] += load
-            
-            # Calculate loads for roofs
-            for roof in building_components.get('roofs', []):
-                for hour in range(24):
-                    load = self.calculate_roof_cooling_load(
-                        roof=roof,
-                        outdoor_temp=outdoor_conditions['temperature'],
-                        indoor_temp=indoor_conditions['temperature'],
-                        month=month,
-                        hour=hour,
-                        latitude=latitude
-                    )
-                    hourly_loads['roofs'][hour + 1] += load
-            
-            # Calculate loads for windows
-            for window in building_components.get('windows', []):
-                for hour in range(24):
-                    load_dict = self.calculate_window_cooling_load(
-                        window=window,
-                        outdoor_temp=outdoor_conditions['temperature'],
-                        indoor_temp=indoor_conditions['temperature'],
-                        month=month,
-                        hour=hour,
-                        latitude=latitude,
-                        shading_coefficient=window.shading_coefficient
-                    )
-                    hourly_loads['windows_conduction'][hour + 1] += load_dict['conduction']
-                    hourly_loads['windows_solar'][hour + 1] += load_dict['solar']
-            
-            # Calculate loads for doors
-            for door in building_components.get('doors', []):
-                for hour in range(24):
-                    load = self.calculate_door_cooling_load(
-                        door=door,
-                        outdoor_temp=outdoor_conditions['temperature'],
-                        indoor_temp=indoor_conditions['temperature']
-                    )
-                    hourly_loads['doors'][hour + 1] += load
-            
-            # Calculate internal loads
-            for hour in range(24):
-                # People loads
-                people_load = self.calculate_people_cooling_load(
-                    num_people=internal_loads['people']['number'],
-                    activity_level=internal_loads['people']['activity_level'],
-                    hour=hour
-                )
-                hourly_loads['people_sensible'][hour + 1] += people_load['sensible']
-                hourly_loads['people_latent'][hour + 1] += 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 + 1] += 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 + 1] += equipment_load['sensible']
-                hourly_loads['equipment_latent'][hour + 1] += 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 + 1] += infiltration_load['sensible']
-                hourly_loads['infiltration_latent'][hour + 1] += 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 + 1] += ventilation_load['sensible']
-                hourly_loads['ventilation_latent'][hour + 1] += ventilation_load['latent']
-        
-            return hourly_loads
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error in calculate_hourly_cooling_loads: {str(e)}")
-            raise Exception(f"Error in calculate_hourly_cooling_loads: {str(e)}")
-    
-    def calculate_design_cooling_load(self, hourly_loads: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Calculate design cooling load based on peak hourly loads.
-        
-        Args:
-            hourly_loads: Dictionary of hourly cooling loads
-            
-        Returns:
-            Dictionary containing design cooling loads
-        """
-        try:
-            design_loads = {}
-            total_loads = []
-            
-            for hour in range(1, 25):
-                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 = range(1, 25)[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
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error in calculate_design_cooling_load: {str(e)}")
-            raise Exception(f"Error in calculate_design_cooling_load: {str(e)}")
-    
-    def calculate_cooling_load_summary(self, design_loads: Dict[str, Any]) -> Dict[str, float]:
-        """
-        Calculate summary of cooling loads.
-        
-        Args:
-            design_loads: Dictionary of design cooling loads
-            
-        Returns:
-            Dictionary containing cooling load summary
-        """
-        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
-            }
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error in calculate_cooling_load_summary: {str(e)}")
-            raise Exception(f"Error in calculate_cooling_load_summary: {str(e)}")
-    
-    def calculate_wall_cooling_load(
-        self,
-        wall: Wall,
-        outdoor_temp: float,
-        indoor_temp: float,
-        month: str,
-        hour: int,
-        latitude: str
-    ) -> float:
-        """
-        Calculate cooling load for a wall.
-        
-        Args:
-            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., '24N')
-            
-        Returns:
-            Cooling load in Watts
-        """
-        try:
-            latitude = self.validate_latitude(latitude)
-            month = self.validate_month(month)
-            hour = self.validate_hour(hour)
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"calculate_wall_cooling_load: latitude={latitude}, month={month}, hour={hour}, wall_group={wall.wall_group}, orientation={wall.orientation.value}")
-
-            # Validate wall_group
-            wall_group = str(wall.wall_group).upper()
-            if wall_group not in self.valid_wall_groups:
-                numeric_map = {'1': 'A', '2': 'B', '3': 'C', '4': 'D'}
-                if wall_group in numeric_map:
-                    wall_group = numeric_map[wall_group]
-                    if st.session_state.get('debug_mode', False):
-                        logger.info(f"Mapped wall_group {wall.wall_group} to {wall_group}")
-                else:
-                    if st.session_state.get('debug_mode', False):
-                        logger.warning(f"Invalid wall group: {wall_group}. Defaulting to 'A'")
-                    wall_group = 'A'
-
-            try:
-                cltd = self.ashrae_tables.calculate_corrected_cltd_wall(
-                    wall_group=wall_group,
-                    orientation=wall.orientation.value,
-                    hour=hour,
-                    color='Dark',
-                    month=month,
-                    latitude=latitude,
-                    indoor_temp=indoor_temp,
-                    outdoor_temp=outdoor_temp
-                )
-            except Exception as e:
-                if st.session_state.get('debug_mode', False):
-                    logger.error(f"calculate_corrected_cltd_wall failed for wall_group={wall_group}: {str(e)}")
-                    logger.warning("Using default CLTD=8.0°C")
-                cltd = 8.0
-            
-            load = wall.u_value * wall.area * cltd
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"Wall load: u_value={wall.u_value}, area={wall.area}, cltd={cltd}, load={load}")
-            return max(load, 0.0)
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error in calculate_wall_cooling_load: {str(e)}")
-            raise Exception(f"Error in calculate_wall_cooling_load: {str(e)}")
-    
-    def calculate_roof_cooling_load(
-        self,
-        roof: Roof,
-        outdoor_temp: float,
-        indoor_temp: float,
-        month: str,
-        hour: int,
-        latitude: str
-    ) -> float:
-        """
-        Calculate cooling load for a roof.
-        
-        Args:
-            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., '24N')
-            
-        Returns:
-            Cooling load in Watts
-        """
-        try:
-            latitude = self.validate_latitude(latitude)
-            month = self.validate_month(month)
-            hour = self.validate_hour(hour)
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"calculate_roof_cooling_load: latitude={latitude}, month={month}, hour={hour}, roof_group={roof.roof_group}")
-
-            roof_group = str(roof.roof_group).upper()
-            if roof_group not in self.valid_roof_groups:
-                if st.session_state.get('debug_mode', False):
-                    logger.warning(f"Invalid roof group: {roof_group}. Defaulting to 'A'")
-                roof_group = 'A'
-            
-            try:
-                cltd = self.ashrae_tables.calculate_corrected_cltd_roof(
-                    roof_group=roof_group,
-                    hour=hour,
-                    color='Dark',
-                    month=month,
-                    latitude=latitude,
-                    indoor_temp=indoor_temp,
-                    outdoor_temp=outdoor_temp
-                )
-            except Exception as e:
-                if st.session_state.get('debug_mode', False):
-                    logger.error(f"calculate_corrected_cltd_roof failed for roof_group={roof_group}: {str(e)}")
-                    logger.warning("Using default CLTD=8.0°C")
-                cltd = 8.0
-            
-            load = roof.u_value * roof.area * cltd
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"Roof load: u_value={roof.u_value}, area={roof.area}, cltd={cltd}, load={load}")
-            return max(load, 0.0)
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error in calculate_roof_cooling_load: {str(e)}")
-            raise Exception(f"Error in calculate_roof_cooling_load: {str(e)}")
-    
-    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 cooling load for a window (conduction and solar).
-        
-        Args:
-            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., '24N')
-            shading_coefficient: Shading coefficient
-            
-        Returns:
-            Dictionary with conduction, solar, and total loads in Watts
-        """
-        try:
-            latitude = self.validate_latitude(latitude)
-            month = self.validate_month(month)
-            hour = self.validate_hour(hour)
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"calculate_window_cooling_load: latitude={latitude}, month={month}, hour={hour}, orientation={window.orientation.value}")
-
-            # Conduction load
-            cltd = outdoor_temp - indoor_temp  # Simplified for windows
-            conduction_load = window.u_value * window.area * cltd
-
-            # Solar load
-            scl_latitude = f"{latitude}_{month}"
-            try:
-                scl = self.ashrae_tables.get_scl(
-                    latitude=scl_latitude,
-                    month=month,
-                    orientation=window.orientation.value,
-                    hour=hour
-                )
-            except Exception as e:
-                if st.session_state.get('debug_mode', False):
-                    logger.error(f"get_scl failed for latitude={scl_latitude}, month={month}, orientation={window.orientation.value}: {str(e)}")
-                    logger.warning("Using default SCL=100 W/m²")
-                scl = 100.0
-
-            solar_load = window.area * window.shgc * shading_coefficient * scl
-
-            total_load = conduction_load + solar_load
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"Window load: conduction={conduction_load}, solar={solar_load}, total={total_load}")
-
-            return {
-                'conduction': max(conduction_load, 0.0),
-                'solar': max(solar_load, 0.0),
-                'total': max(total_load, 0.0)
-            }
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error in calculate_window_cooling_load: {str(e)}")
-            raise Exception(f"Error in calculate_window_cooling_load: {str(e)}")
-    
-    def calculate_door_cooling_load(
-        self,
-        door: Door,
-        outdoor_temp: float,
-        indoor_temp: float
-    ) -> float:
-        """
-        Calculate cooling load for a door.
-        
-        Args:
-            door: Door component
-            outdoor_temp: Outdoor temperature (°C)
-            indoor_temp: Indoor temperature (°C)
-            
-        Returns:
-            Cooling load in Watts
-        """
-        try:
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"calculate_door_cooling_load: u_value={door.u_value}, area={door.area}")
-
-            cltd = outdoor_temp - indoor_temp
-            load = door.u_value * door.area * cltd
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"Door load: cltd={cltd}, load={load}")
-            return max(load, 0.0)
-        
-        except Exception as e:
-            if st.session_state.get('debug_mode', False):
-                logger.error(f"Error in calculate_door_cooling_load: {str(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
-    ) -> Dict[str, float]:
-        """
-        Calculate cooling load from people.
-        
-        Args:
-            num_people: Number of people
-            activity_level: Activity level ('Seated/Resting', 'Light Work', etc.)
-            hour: Hour of the day
-            
-        Returns:
-            Dictionary with sensible and latent loads in Watts
-        """
-        try:
-            hour = self.validate_hour(hour)
-            if st.session_state.get('debug_mode', False):
-                logger.debug(f"calculate_people_cooling_load
-
-System: You are Grok 3 built by xAI.
-
-The current date is April 27, 2025.
-
-Thank you for providing the `heat_transfer.py` file and the updated `cooling_load.py`. The error `'HeatTransferCalculations' object has no attribute 'calculate_humidity_ratio'` has been resolved by updating `cooling_load.py` to use `self.heat_transfer.psychrometrics.humidity_ratio` instead of `self.heat_transfer.calculate_humidity_ratio`, as the `Psychrometrics` class in `utils.psychrometrics` handles humidity ratio calculations. Below, I’ll provide the complete, corrected `cooling_load.py` to ensure all functionality is preserved and the error is fixed.
-
-### Analysis Recap
-- **Error Cause**: `cooling_load.py` incorrectly called `self.heat_transfer.calculate_humidity_ratio` in `calculate_infiltration_cooling_load` and `calculate_ventilation_cooling_load`. The `HeatTransferCalculations` class (in `heat_transfer.py`) delegates psychrometric calculations to `self.psychrometrics.humidity_ratio`.
-- **Fix**: Replace the incorrect method calls with `self.heat_transfer.psychrometrics.humidity_ratio`.
-- **Additional Checks**:
-  - The previous response included a temporary `calculate_humidity_ratio` method in `cooling_load.py`, which is no longer needed and has been removed.
-  - All other methods, validations, and logging remain unchanged to maintain compatibility with `main.py`, `ashrae_tables.py`, and `heat_transfer.py`.
-  - The artifact ID (`c47f4e86-6a73-4d0d-a7c2-2656f6dc55a2`) is retained as this is an update to the same file.
-
-### Updated `cooling_load.py`
-The updated file corrects the method calls in `calculate_infiltration_cooling_load` and `calculate_ventilation_cooling_load`, removes the unnecessary `calculate_humidity_ratio` method, and ensures all other functionality (e.g., wall, roof, window calculations, debug logging with `st.session_state.debug_mode`) is intact. The version is incremented to 1.0.3 to reflect the fix.
-
-<xaiArtifact artifact_id="c47f4e86-6a73-4d0d-a7c2-2656f6dc55a2" artifact_version_id="430e5082-16c0-4456-a8c3-b766fb73f165" title="cooling_load.py" contentType="text/python">
-"""
-Cooling load calculation module for HVAC Load Calculator.
-Based on ASHRAE steady-state calculation methods.
-
-Author: Dr Majed Abuseif
-Date: April 2025
-Version: 1.0.3
+Version: 1.0.4
 """
 
 import streamlit as st
@@ -1491,8 +823,14 @@ class CoolingLoadCalculator:
             sensible_load = 1.2 * flow_rate * (outdoor_temp - indoor_temp)
 
             # Latent load using psychrometrics
-            outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
-            indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
+            try:
+                outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
+                indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
+            except Exception as e:
+                if st.session_state.get('debug_mode', False):
+                    logger.error(f"humidity_ratio failed: {str(e)}")
+                    logger.warning("Using default humidity ratio=0.01 kg/kg")
+                outdoor_w = indoor_w = 0.01
             latent_load = 1.2 * flow_rate * 2500 * (outdoor_w - indoor_w)  # 2500 kJ/kg for latent heat
 
             if st.session_state.get('debug_mode', False):
@@ -1537,8 +875,14 @@ class CoolingLoadCalculator:
             sensible_load = 1.2 * flow_rate * (outdoor_temp - indoor_temp)
 
             # Latent load using psychrometrics
-            outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
-            indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
+            try:
+                outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
+                indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
+            except Exception as e:
+                if st.session_state.get('debug_mode', False):
+                    logger.error(f"humidity_ratio failed: {str(e)}")
+                    logger.warning("Using default humidity ratio=0.01 kg/kg")
+                outdoor_w = indoor_w = 0.01
             latent_load = 1.2 * flow_rate * 2500 * (outdoor_w - indoor_w)  # 2500 kJ/kg for latent heat
 
             if st.session_state.get('debug_mode', False):