Update utils/cooling_load.py

utils/cooling_load.py

@@ -15,6 +15,235 @@ from utils.heat_transfer import HeatTransferCalculations
 from app.component_selection import Wall, Roof, Window, Door, Orientation
 
 
+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))
+    
+    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:
+            # 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=outdoor_conditions['month'],
+                        hour=hour,
+                        latitude=outdoor_conditions['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=outdoor_conditions['month'],
+                        hour=hour,
+                        latitude=outdoor_conditions['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=outdoor_conditions['month'],
+                        hour=hour,
+                        latitude=outdoor_conditions['latitude'],
+                        shading_coefficient=window.shading_coe »
+
+System: I'm sorry, but it looks like your message was cut off. You requested the fixed code for the error in `cooling_load (6).py` and asked where to add it. I understand you want the corrected `calculate_window_cooling_load` method to resolve the error:
+
+```
+Cooling calculation error: Error in calculate_hourly_cooling_loads: Error in calculate_window_cooling_load: ASHRAETables.get_scl() missing 1 required positional argument: 'month'
+```
+
+Since the response seems to have been truncated while generating the full `cooling_load.py` file, I’ll provide the fixed `calculate_window_cooling_load` method directly, along with clear instructions on where to add it in your `cooling_load (6).py` file. I’ll also include the entire corrected `cooling_load.py` file in an `<xaiArtifact>` tag, reusing the `artifact_id` (`0d3b96c4-a4cb-4e0c-bfb7-79b429ef727d`) as this is an update to the previously discussed code.
+
+---
+
+### Where to Add the Fixed Code
+
+You need to replace the `calculate_window_cooling_load` method in your `cooling_load (6).py` file with the corrected version. Here’s how to do it:
+
+1. **Locate the File**:
+   - Open the file named `cooling_load (6).py` (or whatever you’ve renamed it to, e.g., `cooling_load.py`).
+
+2. **Find the `calculate_window_cooling_load` Method**:
+   - Search for the method definition within the `CoolingLoadCalculator` class. It starts with:
+     ```python
+     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]:
+     ```
+   - The method is located after the `calculate_roof_cooling_load` method and before the `calculate_door_cooling_load` method in the class.
+
+3. **Replace the Method**:
+   - Delete the entire `calculate_window_cooling_load` method, from the `def` line to the end of its `return` statement (including the `try`/`except` block).
+   - Paste the corrected method (provided below) in its place.
+
+4. **Verify the Rest of the File**:
+   - The rest of `cooling_load (6).py` remains unchanged, as the error is specific to `calculate_window_cooling_load`. The provided fixed code only updates this method to ensure minimal disruption.
+
+---
+
+### Fixed `calculate_window_cooling_load` Method
+
+Here’s the corrected method, which:
+- Adds the `month` argument to the `self.ashrae_tables.get_scl` call.
+- Uses the validated `scl_latitude` (e.g., `24N`) without combining it with `month`.
+- Removes the unused `solar_altitude` reference.
+- Adds basic month validation to prevent invalid inputs.
+
+```python
+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 (e.g., 'Jan', 'Jul')
+        hour: Hour of the day
+        latitude: Latitude (e.g., '40N')
+        shading_coefficient: Shading coefficient for drapery
+        
+    Returns:
+        Dictionary with conduction and solar loads in Watts
+    """
+    try:
+        # Validate month
+        valid_months = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
+        month_upper = month.upper()
+        if month_upper not in valid_months:
+            raise ValueError(f"Invalid month: {month}. Must be one of {valid_months}")
+
+        # Conduction load
+        delta_t = outdoor_temp - indoor_temp
+        conduction_load = window.u_value * window.area * delta_t
+        
+        # Validate and map latitude for SCL
+        valid_latitudes = ['24N', '36N', '48N']
+        scl_latitude = latitude
+        if latitude not in valid_latitudes:
+            try:
+                lat_value = float(latitude[:-1])
+                differences = [abs(lat_value - float(lat[:-1])) for lat in valid_latitudes]
+                nearest_idx = differences.index(min(differences))
+                scl_latitude = valid_latitudes[nearest_idx]
+            except ValueError:
+                scl_latitude = '24N'  # Default to '24N' if parsing fails
+        
+        # Solar load
+        scl = self.ashrae_tables.get_scl(
+            month=month_upper,
+            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)
+        }
+    
+    except Exception as e:
+        raise Exception(f"Error in calculate_window_cooling_load: {str(e)}")
+```
+
+---
+
+### Full Corrected `cooling_load.py` File
+
+For completeness, here’s the entire `cooling_load.py` file with only the `calculate_window_cooling_load` method updated. This ensures you can replace the entire file if preferred, or just copy the method above.
+
+<xaiArtifact artifact_id="a9c0ef05-4c8d-498b-853d-fb082c9d1e68" artifact_version_id="b23f77d2-82d8-439f-b08d-81a26a0ed91b" 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: March 2025
+Version: 1.0.0
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import numpy as np
+from datetime import datetime
+from data.ashrae_tables import ASHRAETables
+from utils.heat_transfer import HeatTransferCalculations
+from app.component_selection import Wall, Roof, Window, Door, Orientation
+
+
 class CoolingLoadCalculator:
     """Class for cooling load calculations."""
     
@@ -392,7 +621,7 @@ class CoolingLoadCalculator:
             window: Window component
             outdoor_temp: Outdoor temperature (°C)
             indoor_temp: Indoor temperature (°C)
-            month: Design month
+            month: Design month (e.g., 'Jan', 'Jul')
             hour: Hour of the day
             latitude: Latitude (e.g., '40N')
             shading_coefficient: Shading coefficient for drapery
@@ -401,6 +630,12 @@ class CoolingLoadCalculator:
             Dictionary with conduction and solar loads in Watts
         """
         try:
+            # Validate month
+            valid_months = ['JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC']
+            month_upper = month.upper()
+            if month_upper not in valid_months:
+                raise ValueError(f"Invalid month: {month}. Must be one of {valid_months}")
+
             # Conduction load
             delta_t = outdoor_temp - indoor_temp
             conduction_load = window.u_value * window.area * delta_t
@@ -418,9 +653,8 @@ class CoolingLoadCalculator:
                     scl_latitude = '24N'  # Default to '24N' if parsing fails
             
             # Solar load
-            solar_altitude = self.heat_transfer.solar.solar_altitude
-            scl_latitude = f"{float(scl_latitude[:-1])}_{month.upper()}"
             scl = self.ashrae_tables.get_scl(
+                month=month_upper,
                 orientation=window.orientation.value,
                 hour=hour,
                 latitude=scl_latitude
@@ -692,4 +926,4 @@ if __name__ == "__main__":
         'month': 'Jul',
         'latitude': '24N',
         'wind_speed': 4
-    }    
+    }