Update utils/cooling_load.py

utils/cooling_load.py

@@ -29,24 +29,76 @@ class CoolingLoadCalculator:
         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 = [str(i) for i in range(1, 41)]  # ASHRAE wall groups 1-40
+        self.valid_roof_groups = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
     
-    def validate_latitude(self, latitude: str) -> str:
-        """Validate and return a valid latitude."""
-        if not isinstance(latitude, str) or '_' in latitude:
-            logger.warning(f"Invalid latitude format: {latitude}. Defaulting to '24N'")
-            return '24N'
-        if latitude not in self.valid_latitudes:
-            logger.warning(f"Latitude {latitude} not in {self.valid_latitudes}. Defaulting to '24N'")
+    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)
+            
+            # Remove whitespace and convert to uppercase
+            latitude = latitude.strip().upper()
+            
+            # Handle formats like '31.973N', '1_31.973N'
+            if '_' in latitude or '.' in latitude:
+                # Extract numeric part
+                num_part = ''.join(c for c in latitude if c.isdigit() or c == '.')
+                try:
+                    lat_val = float(num_part)
+                    # Map to closest valid latitude
+                    if lat_val <= 30:
+                        return '24N'
+                    elif lat_val <= 42:
+                        return '36N'
+                    else:
+                        return '48N'
+                except ValueError:
+                    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'")
+                return '24N'
+            
+            return latitude
+        
+        except Exception as e:
+            logger.error(f"Error validating latitude {latitude}: {str(e)}")
             return '24N'
-        return latitude
     
-    def validate_month(self, month: str) -> str:
-        """Validate and return a valid month in uppercase."""
-        month_upper = month.upper()
-        if month_upper not in self.valid_months:
-            logger.warning(f"Invalid month: {month}. Defaulting to 'JUL'")
+    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:
+                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)}")
             return 'JUL'
-        return month_upper
     
     def calculate_hourly_cooling_loads(
         self,
@@ -327,10 +379,16 @@ class CoolingLoadCalculator:
         try:
             latitude = self.validate_latitude(latitude)
             month = self.validate_month(month)
-            logger.debug(f"calculate_wall_cooling_load: latitude={latitude}, month={month}")
+            logger.debug(f"calculate_wall_cooling_load: latitude={latitude}, month={month}, wall_group={wall.wall_group}, orientation={wall.orientation.value}")
+
+            # Validate wall_group
+            wall_group = str(wall.wall_group)
+            if wall_group not in self.valid_wall_groups:
+                logger.warning(f"Invalid wall group: {wall_group}. Defaulting to '1'")
+                wall_group = '1'
 
             cltd = self.ashrae_tables.calculate_corrected_cltd_wall(
-                wall_group=wall.wall_group,
+                wall_group=wall_group,
                 orientation=wall.orientation.value,
                 hour=hour,
                 color='Dark',
@@ -341,9 +399,11 @@ class CoolingLoadCalculator:
             )
             
             load = wall.u_value * wall.area * cltd
+            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)}")
             raise Exception(f"Error in calculate_wall_cooling_load: {str(e)}")
     
     def calculate_roof_cooling_load(
@@ -370,19 +430,15 @@ class CoolingLoadCalculator:
             Cooling load in Watts
         """
         try:
-            # Validate inputs
             latitude = self.validate_latitude(latitude)
             month = self.validate_month(month)
-            logger.debug(f"calculate_roof_cooling_load: latitude={latitude}, month={month}")
+            logger.debug(f"calculate_roof_cooling_load: latitude={latitude}, month={month}, roof_group={roof.roof_group}")
 
             # Validate and map roof_group
-            valid_roof_groups = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
-            roof_group = roof.roof_group
-            if roof_group not in valid_roof_groups:
-                if roof_group == '1':  # Map invalid '1' to 'A'
-                    roof_group = 'A'
-                else:
-                    raise ValueError(f"Invalid roof group: {roof_group}. Must be one of {valid_roof_groups}")
+            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'")
+                roof_group = 'A'
             
             cltd = self.ashrae_tables.calculate_corrected_cltd_roof(
                 roof_group=roof_group,
@@ -395,9 +451,11 @@ class CoolingLoadCalculator:
             )
             
             load = roof.u_value * roof.area * cltd
+            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)}")
             raise Exception(f"Error in calculate_roof_cooling_load: {str(e)}")
     
     def calculate_window_cooling_load(
@@ -426,10 +484,9 @@ class CoolingLoadCalculator:
             Dictionary with conduction and solar loads in Watts
         """
         try:
-            # Validate inputs
             scl_latitude = self.validate_latitude(latitude)
             month_upper = self.validate_month(month)
-            logger.debug(f"calculate_window_cooling_load: latitude={scl_latitude}, month={month_upper}")
+            logger.debug(f"calculate_window_cooling_load: latitude={scl_latitude}, month={month_upper}, orientation={window.orientation.value}")
 
             # Conduction load
             delta_t = outdoor_temp - indoor_temp
@@ -474,6 +531,7 @@ class CoolingLoadCalculator:
             
             solar_load = window.area * window.shgc * scl * shading_coefficient
             
+            logger.debug(f"Window load: conduction={conduction_load}, solar={solar_load}")
             return {
                 'conduction': max(conduction_load, 0.0),
                 'solar': max(solar_load, 0.0),
@@ -481,6 +539,7 @@ class CoolingLoadCalculator:
             }
         
         except Exception as e:
+            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(
@@ -503,9 +562,11 @@ class CoolingLoadCalculator:
         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}")
             return max(load, 0.0)
         
         except Exception as e:
+            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(
@@ -526,19 +587,24 @@ class CoolingLoadCalculator:
             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
-            }.get(activity_level, 70)
+            }[activity_level]
             
             latent_gain = {
                 'Seated/Resting': 45,
                 'Light Work': 75,
                 'Moderate Work': 120,
                 'Heavy Work': 180
-            }.get(activity_level, 45)
+            }[activity_level]
             
             logger.debug(f"Calling get_clf_people with zone_type='A', hours_occupied='6h', hour={hour}")
             try:
@@ -551,6 +617,7 @@ class CoolingLoadCalculator:
             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}")
             return {
                 'sensible': max(sensible_load, 0.0),
                 'latent': max(latent_load, 0.0),
@@ -558,6 +625,7 @@ class CoolingLoadCalculator:
             }
         
         except Exception as e:
+            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(
@@ -588,9 +656,11 @@ class CoolingLoadCalculator:
                 logger.warning("Using default CLF=1.0 for lights")
                 clf = 1.0
             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}")
             return max(load, 0.0)
         
         except Exception as e:
+            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(
@@ -623,6 +693,7 @@ class CoolingLoadCalculator:
             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}")
             return {
                 'sensible': max(sensible_load, 0.0),
                 'latent': max(latent_load, 0.0),
@@ -630,6 +701,7 @@ class CoolingLoadCalculator:
             }
         
         except Exception as e:
+            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(
@@ -656,12 +728,17 @@ 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)
             
             # Calculate humidity ratio difference
             logger.debug(f"Calculating outdoor humidity ratio: temp={outdoor_temp}°C, rh={outdoor_rh}%")
             try:
+                outdoor_rh = min(max(outdoor_rh, 0), 100)  # Clamp RH to 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)}")
@@ -670,6 +747,7 @@ class CoolingLoadCalculator:
             
             logger.debug(f"Calculating indoor humidity ratio: temp={indoor_temp}°C, rh={indoor_rh}%")
             try:
+                indoor_rh = min(max(indoor_rh, 0), 100)  # Clamp RH to 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)}")
@@ -678,6 +756,7 @@ class CoolingLoadCalculator:
             
             latent_load = 2501 * flow_rate * 1000 * (outdoor_w - indoor_w)
             
+            logger.debug(f"Infiltration load: sensible={sensible_load}, latent={latent_load}")
             return {
                 'sensible': max(sensible_load, 0.0),
                 'latent': max(latent_load, 0.0),
@@ -685,6 +764,7 @@ class CoolingLoadCalculator:
             }
         
         except Exception as e:
+            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(
@@ -709,11 +789,16 @@ 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)
             
             # Calculate humidity ratio difference
             logger.debug(f"Calculating outdoor humidity ratio: temp={outdoor_temp}°C, rh={outdoor_rh}%")
             try:
+                outdoor_rh = min(max(outdoor_rh, 0), 100)  # Clamp RH to 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)}")
@@ -722,6 +807,7 @@ class CoolingLoadCalculator:
             
             logger.debug(f"Calculating indoor humidity ratio: temp={indoor_temp}°C, rh={indoor_rh}%")
             try:
+                indoor_rh = min(max(indoor_rh, 0), 100)  # Clamp RH to 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)}")
@@ -730,6 +816,7 @@ class CoolingLoadCalculator:
             
             latent_load = 2501 * flow_rate * 1000 * (outdoor_w - indoor_w)
             
+            logger.debug(f"Ventilation load: sensible={sensible_load}, latent={latent_load}")
             return {
                 'sensible': max(sensible_load, 0.0),
                 'latent': max(latent_load, 0.0),
@@ -737,6 +824,7 @@ class CoolingLoadCalculator:
             }
         
         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)}")
 
 
@@ -751,7 +839,7 @@ if __name__ == "__main__":
             orientation=Orientation.NORTH,
             area=20.0,
             u_value=0.5,
-            wall_group="A"
+            wall_group="1"
         )],
         'roofs': [Roof(
             name="Main Roof",
@@ -806,6 +894,7 @@ if __name__ == "__main__":
         {'latitude': '24N', 'month': 'Jul'},
         {'latitude': '36N', 'month': 'Jul'},
         {'latitude': '48N', 'month': 'Jan'},
+        {'latitude': '1_31.973N', 'month': 'Jul'},  # Test invalid latitude
         {'latitude': 'invalid', 'month': 'invalid'}  # Test invalid inputs
     ]