Update utils/cooling_load.py

utils/cooling_load.py

@@ -3,10 +3,11 @@ Cooling load calculation module for HVAC Load Calculator.
 Based on ASHRAE steady-state calculation methods.
 
 Author: Dr Majed Abuseif
-Date: March 2025
-Version: 1.0.0
+Date: April 2025
+Version: 1.0.1
 """
 
+import streamlit as st
 from typing import Dict, List, Any, Optional, Tuple
 import numpy as np
 from datetime import datetime
@@ -53,7 +54,8 @@ class CoolingLoadCalculator:
                 parts = latitude.split('_')
                 if len(parts) > 1:
                     lat_part = parts[0]
-                    logger.warning(f"Detected concatenated input: {latitude}. Using latitude={lat_part}")
+                    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'
@@ -68,17 +70,20 @@ class CoolingLoadCalculator:
                     else:
                         return '48N'
                 except ValueError:
-                    logger.warning(f"Cannot parse latitude: {latitude}. Defaulting to '24N'")
+                    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:
-                logger.warning(f"Invalid latitude: {latitude}. Defaulting to '24N'")
+                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:
-            logger.error(f"Error validating latitude {latitude}: {str(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:
@@ -97,14 +102,38 @@ class CoolingLoadCalculator:
             
             month_upper = month.strip().upper()
             if month_upper not in self.valid_months:
-                logger.warning(f"Invalid month: {month}. Defaulting to 'JUL'")
+                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:
-            logger.error(f"Error validating month {month}: {str(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]],
@@ -147,7 +176,8 @@ class CoolingLoadCalculator:
             # Validate inputs
             latitude = self.validate_latitude(outdoor_conditions.get('latitude', '24N'))
             month = self.validate_month(outdoor_conditions.get('month', 'JUL'))
-            logger.debug(f"calculate_hourly_cooling_loads: latitude={latitude}, month={month}, outdoor_conditions={outdoor_conditions}")
+            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', []):
@@ -256,6 +286,8 @@ class CoolingLoadCalculator:
             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]:
@@ -314,6 +346,8 @@ class CoolingLoadCalculator:
             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]:
@@ -356,6 +390,8 @@ class CoolingLoadCalculator:
             }
         
         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(
@@ -384,7 +420,9 @@ class CoolingLoadCalculator:
         try:
             latitude = self.validate_latitude(latitude)
             month = self.validate_month(month)
-            logger.debug(f"calculate_wall_cooling_load: latitude={latitude}, month={month}, wall_group={wall.wall_group}, orientation={wall.orientation.value}")
+            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()
@@ -392,9 +430,11 @@ class CoolingLoadCalculator:
                 numeric_map = {'1': 'A', '2': 'B', '3': 'C', '4': 'D'}
                 if wall_group in numeric_map:
                     wall_group = numeric_map[wall_group]
-                    logger.info(f"Mapped wall_group {wall.wall_group} to {wall_group}")
+                    if st.session_state.get('debug_mode', False):
+                        logger.info(f"Mapped wall_group {wall.wall_group} to {wall_group}")
                 else:
-                    logger.warning(f"Invalid wall group: {wall_group}. Defaulting to 'A'")
+                    if st.session_state.get('debug_mode', False):
+                        logger.warning(f"Invalid wall group: {wall_group}. Defaulting to 'A'")
                     wall_group = 'A'
 
             try:
@@ -409,16 +449,19 @@ class CoolingLoadCalculator:
                     outdoor_temp=outdoor_temp
                 )
             except Exception as e:
-                logger.error(f"calculate_corrected_cltd_wall failed for wall_group={wall_group}: {str(e)}")
-                logger.warning("Using default CLTD=10.0°C")
-                cltd = 10.0
+                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
-            logger.debug(f"Wall load: u_value={wall.u_value}, area={wall.area}, cltd={cltd}, load={load}")
+            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:
-            logger.error(f"Error in calculate_wall_cooling_load: {str(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(
@@ -447,11 +490,14 @@ class CoolingLoadCalculator:
         try:
             latitude = self.validate_latitude(latitude)
             month = self.validate_month(month)
-            logger.debug(f"calculate_roof_cooling_load: latitude={latitude}, month={month}, roof_group={roof.roof_group}")
+            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:
-                logger.warning(f"Invalid roof group: {roof_group}. Defaulting to 'A'")
+                if st.session_state.get('debug_mode', False):
+                    logger.warning(f"Invalid roof group: {roof_group}. Defaulting to 'A'")
                 roof_group = 'A'
             
             try:
@@ -465,16 +511,19 @@ class CoolingLoadCalculator:
                     outdoor_temp=outdoor_temp
                 )
             except Exception as e:
-                logger.error(f"calculate_corrected_cltd_roof failed for roof_group={roof_group}: {str(e)}")
-                logger.warning("Using default CLTD=10.0°C")
-                cltd = 10.0
+                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
-            logger.debug(f"Roof load: u_value={roof.u_value}, area={roof.area}, cltd={cltd}, load={load}")
+            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:
-            logger.error(f"Error in calculate_roof_cooling_load: {str(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(
@@ -494,74 +543,55 @@ class CoolingLoadCalculator:
             window: Window component
             outdoor_temp: Outdoor temperature (°C)
             indoor_temp: Indoor temperature (°C)
-            month: Design month (e.g., 'Jan', 'Jul')
+            month: Design month
             hour: Hour of the day
-            latitude: Latitude (e.g., '24N', '36N', '48N')
-            shading_coefficient: Shading coefficient for drapery
+            latitude: Latitude (e.g., '24N')
+            shading_coefficient: Shading coefficient
             
         Returns:
-            Dictionary with conduction and solar loads in Watts
+            Dictionary with conduction, solar, and total loads in Watts
         """
         try:
-            scl_latitude = self.validate_latitude(latitude)
-            month_upper = self.validate_month(month)
-            logger.debug(f"calculate_window_cooling_load: latitude={latitude} -> {scl_latitude}, month={month} -> {month_upper}, orientation={window.orientation.value}")
+            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
-            delta_t = outdoor_temp - indoor_temp
-            conduction_load = window.u_value * window.area * delta_t
-            
+            cltd = outdoor_temp - indoor_temp  # Simplified for windows
+            conduction_load = window.u_value * window.area * cltd
+
             # Solar load
-            logger.debug(f"Calling get_scl with month={month_upper}, orientation={window.orientation.value}, hour={hour}, latitude={scl_latitude}")
-            
-            month_formats = [
-                (month_upper, "uppercase"),
-                (month_upper.capitalize(), "capitalized"),
-                (str({'JAN': 1, 'FEB': 2, 'MAR': 3, 'APR': 4, 'MAY': 5, 'JUN': 6,
-                      'JUL': 7, 'AUG': 8, 'SEP': 9, 'OCT': 10, 'NOV': 11, 'DEC': 12}[month_upper]), "numeric")
-            ]
-            
-            scl = None
-            for month_value, format_name in month_formats:
-                try:
-                    logger.debug(f"Trying get_scl with month format '{format_name}': month={month_value}, latitude={scl_latitude}")
-                    scl = self.ashrae_tables.get_scl(
-                        latitude=scl_latitude,
-                        month=month_value,
-                        orientation=window.orientation.value,
-                        hour=hour
-                    )
-                    logger.debug(f"Success with month format '{format_name}'")
-                    break
-                except Exception as e:
-                    logger.warning(f"get_scl failed with month format '{format_name}': {str(e)}")
-                    continue
-            
-            if scl is None:
-                logger.warning(f"All month formats failed. Retrying with fallback latitude='24N', month='JUL'")
-                try:
-                    scl = self.ashrae_tables.get_scl(
-                        latitude='24N',
-                        month='JUL',
-                        orientation=window.orientation.value,
-                        hour=hour
-                    )
-                except Exception as e:
-                    logger.error(f"Fallback get_scl failed: {str(e)}")
+            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  # Conservative fallback
-            
-            solar_load = window.area * window.shgc * scl * shading_coefficient
-            
-            logger.debug(f"Window load: conduction={conduction_load}, solar={solar_load}")
+                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(conduction_load + solar_load, 0.0)
+                'total': max(total_load, 0.0)
             }
         
         except Exception as e:
-            logger.error(f"Error in calculate_window_cooling_load: {str(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(
@@ -582,13 +612,18 @@ class CoolingLoadCalculator:
             Cooling load in Watts
         """
         try:
-            delta_t = outdoor_temp - indoor_temp
-            load = door.u_value * door.area * delta_t
-            logger.debug(f"Door load: u_value={door.u_value}, area={door.area}, delta_t={delta_t}, load={load}")
+            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:
-            logger.error(f"Error in calculate_door_cooling_load: {str(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(
@@ -602,52 +637,55 @@ class CoolingLoadCalculator:
         
         Args:
             num_people: Number of people
-            activity_level: Activity level
+            activity_level: Activity level ('Seated/Resting', 'Light Work', etc.)
             hour: Hour of the day
             
         Returns:
             Dictionary with sensible and latent loads in Watts
         """
         try:
-            valid_activities = ['Seated/Resting', 'Light Work', 'Moderate Work', 'Heavy Work']
-            if activity_level not in valid_activities:
-                logger.warning(f"Invalid activity_level: {activity_level}. Defaulting to 'Seated/Resting'")
-                activity_level = 'Seated/Resting'
-            
-            sensible_gain = {
-                'Seated/Resting': 70,
-                'Light Work': 100,
-                'Moderate Work': 150,
-                'Heavy Work': 200
-            }[activity_level]
-            
-            latent_gain = {
-                'Seated/Resting': 45,
-                'Light Work': 75,
-                'Moderate Work': 120,
-                'Heavy Work': 180
-            }[activity_level]
-            
-            logger.debug(f"Calling get_clf_people with zone_type='A', hours_occupied='6h', hour={hour}")
+            hour = self.validate_hour(hour)
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"calculate_people_cooling_load: num_people={num_people}, activity_level={activity_level}, hour={hour}")
+
+            # Sensible and latent heat gains per person (W)
+            heat_gains = {
+                'Seated/Resting': {'sensible': 70, 'latent': 45},
+                'Light Work': {'sensible': 85, 'latent': 65},
+                'Moderate Work': {'sensible': 100, 'latent': 100},
+                'Heavy Work': {'sensible': 145, 'latent': 170}
+            }
+
+            gains = heat_gains.get(activity_level, heat_gains['Seated/Resting'])
+            if activity_level not in heat_gains:
+                if st.session_state.get('debug_mode', False):
+                    logger.warning(f"Invalid activity_level: {activity_level}. Defaulting to 'Seated/Resting'")
+
             try:
-                clf = self.ashrae_tables.get_clf_people('A', '6h', hour)
+                clf = self.ashrae_tables.get_clf_people(
+                    zone_type='A',
+                    hours_occupied='8h',
+                    hour=hour
+                )
             except Exception as e:
-                logger.error(f"get_clf_people('A', '6h', {hour}) failed: {str(e)}")
-                logger.warning("Using default CLF=1.0 for people")
-                clf = 1.0
-            
-            sensible_load = num_people * sensible_gain * clf
-            latent_load = num_people * latent_gain
-            
-            logger.debug(f"People load: num_people={num_people}, sensible={sensible_load}, latent={latent_load}")
+                if st.session_state.get('debug_mode', False):
+                    logger.error(f"get_clf_people failed: {str(e)}")
+                    logger.warning("Using default CLF=0.5")
+                clf = 0.5
+
+            sensible_load = num_people * gains['sensible'] * clf
+            latent_load = num_people * gains['latent']  # Latent load typically not adjusted by CLF
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"People load: sensible={sensible_load}, latent={latent_load}, clf={clf}")
+
             return {
                 'sensible': max(sensible_load, 0.0),
-                'latent': max(latent_load, 0.0),
-                'total': max(sensible_load + latent_load, 0.0)
+                'latent': max(latent_load, 0.0)
             }
         
         except Exception as e:
-            logger.error(f"Error in calculate_people_cooling_load: {str(e)}")
+            if st.session_state.get('debug_mode', False):
+                logger.error(f"Error in calculate_people_cooling_load: {str(e)}")
             raise Exception(f"Error in calculate_people_cooling_load: {str(e)}")
     
     def calculate_lights_cooling_load(
@@ -661,8 +699,8 @@ class CoolingLoadCalculator:
         Calculate cooling load from lighting.
         
         Args:
-            power: Lighting power (W)
-            use_factor: Usage factor
+            power: Total lighting power (W)
+            use_factor: Usage factor (0.0 to 1.0)
             special_allowance: Special allowance factor
             hour: Hour of the day
             
@@ -670,19 +708,30 @@ class CoolingLoadCalculator:
             Cooling load in Watts
         """
         try:
-            logger.debug(f"Calling get_clf_lights with zone_type='A', hours_on='8h', hour={hour}")
+            hour = self.validate_hour(hour)
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"calculate_lights_cooling_load: power={power}, use_factor={use_factor}, special_allowance={special_allowance}, hour={hour}")
+
             try:
-                clf = self.ashrae_tables.get_clf_lights('A', '8h', hour)
+                clf = self.ashrae_tables.get_clf_lights(
+                    zone_type='A',
+                    hours_occupied='8h',
+                    hour=hour
+                )
             except Exception as e:
-                logger.error(f"get_clf_lights('A', '8h', {hour}) failed: {str(e)}")
-                logger.warning("Using default CLF=1.0 for lights")
-                clf = 1.0
+                if st.session_state.get('debug_mode', False):
+                    logger.error(f"get_clf_lights failed: {str(e)}")
+                    logger.warning("Using default CLF=0.8")
+                clf = 0.8
+
             load = power * use_factor * special_allowance * clf
-            logger.debug(f"Lights load: power={power}, use_factor={use_factor}, special_allowance={special_allowance}, clf={clf}, load={load}")
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"Lights load: clf={clf}, load={load}")
             return max(load, 0.0)
         
         except Exception as e:
-            logger.error(f"Error in calculate_lights_cooling_load: {str(e)}")
+            if st.session_state.get('debug_mode', False):
+                logger.error(f"Error in calculate_lights_cooling_load: {str(e)}")
             raise Exception(f"Error in calculate_lights_cooling_load: {str(e)}")
     
     def calculate_equipment_cooling_load(
@@ -696,34 +745,44 @@ class CoolingLoadCalculator:
         Calculate cooling load from equipment.
         
         Args:
-            power: Equipment power (W)
-            use_factor: Usage factor
-            radiation_factor: Radiation factor
+            power: Total equipment power (W)
+            use_factor: Usage factor (0.0 to 1.0)
+            radiation_factor: Radiation factor (0.0 to 1.0)
             hour: Hour of the day
             
         Returns:
             Dictionary with sensible and latent loads in Watts
         """
         try:
-            logger.debug(f"Calling get_clf_equipment with zone_type='A', hours_operated='6h', hour={hour}")
+            hour = self.validate_hour(hour)
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"calculate_equipment_cooling_load: power={power}, use_factor={use_factor}, radiation_factor={radiation_factor}, hour={hour}")
+
             try:
-                clf = self.ashrae_tables.get_clf_equipment('A', '6h', hour)
+                clf = self.ashrae_tables.get_clf_equipment(
+                    zone_type='A',
+                    hours_occupied='8h',
+                    hour=hour
+                )
             except Exception as e:
-                logger.error(f"get_clf_equipment('A', '6h', {hour}) failed: {str(e)}")
-                logger.warning("Using default CLF=1.0 for equipment")
-                clf = 1.0
+                if st.session_state.get('debug_mode', False):
+                    logger.error(f"get_clf_equipment failed: {str(e)}")
+                    logger.warning("Using default CLF=0.7")
+                clf = 0.7
+
             sensible_load = power * use_factor * radiation_factor * clf
-            latent_load = power * use_factor * (1 - radiation_factor)
-            
-            logger.debug(f"Equipment load: power={power}, use_factor={use_factor}, radiation_factor={radiation_factor}, clf={clf}, sensible={sensible_load}, latent={latent_load}")
+            latent_load = power * use_factor * (1 - radiation_factor)  # Assume non-radiative is latent
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"Equipment load: sensible={sensible_load}, latent={latent_load}, clf={clf}")
+
             return {
                 'sensible': max(sensible_load, 0.0),
-                'latent': max(latent_load, 0.0),
-                'total': max(sensible_load + latent_load, 0.0)
+                'latent': max(latent_load, 0.0)
             }
         
         except Exception as e:
-            logger.error(f"Error in calculate_equipment_cooling_load: {str(e)}")
+            if st.session_state.get('debug_mode', False):
+                logger.error(f"Error in calculate_equipment_cooling_load: {str(e)}")
             raise Exception(f"Error in calculate_equipment_cooling_load: {str(e)}")
     
     def calculate_infiltration_cooling_load(
@@ -750,42 +809,35 @@ class CoolingLoadCalculator:
             Dictionary with sensible and latent loads in Watts
         """
         try:
-            if flow_rate < 0 or building_volume <= 0:
-                logger.warning(f"Invalid inputs: flow_rate={flow_rate}, building_volume={building_volume}. Returning zero loads")
-                return {'sensible': 0.0, 'latent': 0.0, 'total': 0.0}
-            
-            air_changes_per_hour = (flow_rate * 3600) / building_volume
-            sensible_load = 1.2 * flow_rate * 1000 * (outdoor_temp - indoor_temp)
-            
-            logger.debug(f"Calculating outdoor humidity ratio: temp={outdoor_temp}°C, rh={outdoor_rh}%")
-            try:
-                outdoor_rh = min(max(outdoor_rh, 0), 100)
-                outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
-            except Exception as e:
-                logger.error(f"Failed to calculate outdoor humidity ratio: {str(e)}")
-                logger.warning("Using default humidity ratio=0.0 for outdoor air")
-                outdoor_w = 0.0
-            
-            logger.debug(f"Calculating indoor humidity ratio: temp={indoor_temp}°C, rh={indoor_rh}%")
-            try:
-                indoor_rh = min(max(indoor_rh, 0), 100)
-                indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
-            except Exception as e:
-                logger.error(f"Failed to calculate indoor humidity ratio: {str(e)}")
-                logger.warning("Using default humidity ratio=0.0 for indoor air")
-                indoor_w = 0.0
-            
-            latent_load = 2501 * flow_rate * 1000 * (outdoor_w - indoor_w)
-            
-            logger.debug(f"Infiltration load: sensible={sensible_load}, latent={latent_load}")
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"calculate_infiltration_cooling_load: flow_rate={flow_rate}, building_volume={building_volume}, outdoor_temp={outdoor_temp}, indoor_temp={indoor_temp}")
+
+            # Calculate air changes per hour (ACH)
+            ach = (flow_rate * 3600) / building_volume if building_volume > 0 else 0.5
+            if ach < 0:
+                if st.session_state.get('debug_mode', False):
+                    logger.warning(f"Invalid ACH: {ach}. Defaulting to 0.5")
+                ach = 0.5
+
+            # Sensible load: Q = 1.2 * flow_rate * (Tout - Tin)
+            sensible_load = 1.2 * flow_rate * (outdoor_temp - indoor_temp)
+
+            # Latent load using simplified psychrometrics
+            outdoor_w = self.heat_transfer.calculate_humidity_ratio(outdoor_temp, outdoor_rh)
+            indoor_w = self.heat_transfer.calculate_humidity_ratio(indoor_temp, indoor_rh)
+            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):
+                logger.debug(f"Infiltration load: sensible={sensible_load}, latent={latent_load}, ach={ach}")
+
             return {
                 'sensible': max(sensible_load, 0.0),
-                'latent': max(latent_load, 0.0),
-                'total': max(sensible_load + latent_load, 0.0)
+                'latent': max(latent_load, 0.0)
             }
         
         except Exception as e:
-            logger.error(f"Error in calculate_infiltration_cooling_load: {str(e)}")
+            if st.session_state.get('debug_mode', False):
+                logger.error(f"Error in calculate_infiltration_cooling_load: {str(e)}")
             raise Exception(f"Error in calculate_infiltration_cooling_load: {str(e)}")
     
     def calculate_ventilation_cooling_load(
@@ -810,123 +862,26 @@ class CoolingLoadCalculator:
             Dictionary with sensible and latent loads in Watts
         """
         try:
-            if flow_rate < 0:
-                logger.warning(f"Invalid flow_rate={flow_rate}. Returning zero loads")
-                return {'sensible': 0.0, 'latent': 0.0, 'total': 0.0}
-            
-            sensible_load = 1.2 * flow_rate * 1000 * (outdoor_temp - indoor_temp)
-            
-            logger.debug(f"Calculating outdoor humidity ratio: temp={outdoor_temp}°C, rh={outdoor_rh}%")
-            try:
-                outdoor_rh = min(max(outdoor_rh, 0), 100)
-                outdoor_w = self.heat_transfer.psychrometrics.humidity_ratio(outdoor_temp, outdoor_rh)
-            except Exception as e:
-                logger.error(f"Failed to calculate outdoor humidity ratio: {str(e)}")
-                logger.warning("Using default humidity ratio=0.0 for outdoor air")
-                outdoor_w = 0.0
-            
-            logger.debug(f"Calculating indoor humidity ratio: temp={indoor_temp}°C, rh={indoor_rh}%")
-            try:
-                indoor_rh = min(max(indoor_rh, 0), 100)
-                indoor_w = self.heat_transfer.psychrometrics.humidity_ratio(indoor_temp, indoor_rh)
-            except Exception as e:
-                logger.error(f"Failed to calculate indoor humidity ratio: {str(e)}")
-                logger.warning("Using default humidity ratio=0.0 for indoor air")
-                indoor_w = 0.0
-            
-            latent_load = 2501 * flow_rate * 1000 * (outdoor_w - indoor_w)
-            
-            logger.debug(f"Ventilation load: sensible={sensible_load}, latent={latent_load}")
+            if st.session_state.get('debug_mode', False):
+                logger.debug(f"calculate_ventilation_cooling_load: flow_rate={flow_rate}, outdoor_temp={outdoor_temp}, indoor_temp={indoor_temp}")
+
+            # Sensible load: Q = 1.2 * flow_rate * (Tout - Tin)
+            sensible_load = 1.2 * flow_rate * (outdoor_temp - indoor_temp)
+
+            # Latent load using simplified psychrometrics
+            outdoor_w = self.heat_transfer.calculate_humidity_ratio(outdoor_temp, outdoor_rh)
+            indoor_w = self.heat_transfer.calculate_humidity_ratio(indoor_temp, indoor_rh)
+            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):
+                logger.debug(f"Ventilation load: sensible={sensible_load}, latent={latent_load}")
+
             return {
                 'sensible': max(sensible_load, 0.0),
-                'latent': max(latent_load, 0.0),
-                'total': max(sensible_load + latent_load, 0.0)
+                'latent': max(latent_load, 0.0)
             }
         
         except Exception as e:
-            logger.error(f"Error in calculate_ventilation_cooling_load: {str(e)}")
-            raise Exception(f"Error in calculate_ventilation_cooling_load: {str(e)}")
-
-
-if __name__ == "__main__":
-    calculator = CoolingLoadCalculator()
-    
-    building_components = {
-        'walls': [Wall(
-            name="North Wall",
-            orientation=Orientation.NORTH,
-            area=20.0,
-            u_value=0.5,
-            wall_group="1"
-        )],
-        'roofs': [Roof(
-            name="Main Roof",
-            orientation=Orientation.HORIZONTAL,
-            area=100.0,
-            u_value=0.3,
-            roof_group="A"
-        )],
-        'windows': [Window(
-            name="North Window",
-            orientation=Orientation.NORTH,
-            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
-        )]
-    }
-    
-    outdoor_conditions = {
-        'temperature': 35.0,
-        'relative_humidity': 50.0,
-        'ground_temperature': 20.0,
-        'month': 'Jul',
-        'latitude': '24N',
-        'wind_speed': 4
-    }
-
-    indoor_conditions = {
-        'temperature': 24.0,
-        'relative_humidity': 50.0
-    }
-
-    internal_loads = {
-        'people': {'number': 10, 'activity_level': 'Seated/Resting'},
-        'lights': {'power': 1000, 'use_factor': 0.8, 'special_allowance': 1.0},
-        'equipment': {'power': 500, 'use_factor': 0.7, 'radiation_factor': 0.5},
-        'infiltration': {'flow_rate': 0.01},
-        'ventilation': {'flow_rate': 0.02}
-    }
-
-    building_volume = 300.0
-
-    test_cases = [
-        {'latitude': '24N', 'month': 'Jul', 'wall_group': 'A'},
-        {'latitude': '36N', 'month': 'Jul', 'wall_group': 'B'},
-        {'latitude': '48N', 'month': 'Jan', 'wall_group': '1'},
-        {'latitude': '24N_JUL', 'month': 'Jul', 'wall_group': 'invalid'},
-        {'latitude': 'invalid', 'month': 'invalid', 'wall_group': '2'}
-    ]
-
-    for case in test_cases:
-        outdoor_conditions['latitude'] = case['latitude']
-        outdoor_conditions['month'] = case['month']
-        building_components['walls'][0].wall_group = case['wall_group']
-        try:
-            hourly_loads = calculator.calculate_hourly_cooling_loads(
-                building_components,
-                outdoor_conditions,
-                indoor_conditions,
-                internal_loads,
-                building_volume
-            )
-            print(f"Success for latitude={case['latitude']}, month={case['month']}, wall_group={case['wall_group']}: Hourly Loads calculated")
-        except Exception as e:
-            print(f"Error for latitude={case['latitude']}, month={case['month']}, wall_group={case['wall_group']}: {str(e)}")
+            if st.session_state.get('debug_mode', False):
+                logger.error(f"Error in calculate_ventilation_cooling_load: {str(e)}")
+            raise Exception(f"Error in calculate_ventilation_cooling_load: {str(e)}")