Upload heating_load.py

utils/heating_load.py

@@ -1,7 +1,15 @@
 """
-Heating load calculation module for HVAC Load Calculator.
+Enhanced heating load calculation module for HVAC Load Calculator.
 Implements ASHRAE steady-state methods with simplified thermal lag for compatibility.
 Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
+
+ENHANCEMENTS:
+- Added support for equipment and internal loads as heating sources
+- Added support for custom U-values for materials
+- Improved integration with enhanced component selection features (crack dimensions, drapery inputs)
+- Ensured compatibility with winter design parameters from enhanced climate data
+- Added support for skylights in heating load calculations
+- Improved infiltration calculations using crack dimensions
 """
 
 from typing import Dict, List, Any, Optional, Tuple
@@ -20,7 +28,7 @@ from utils.psychrometrics import Psychrometrics
 from utils.heat_transfer import HeatTransferCalculations
 
 # Import data modules
-from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
+from app.component_selection import Wall, Roof, Floor, Window, Door, Orientation, ComponentType, Skylight
 
 
 class HeatingLoadCalculator:
@@ -91,6 +99,11 @@ class HeatingLoadCalculator:
         adjusted_delta_t = delta_t * lag_factor
         
         load = self.heat_transfer.conduction_heat_transfer(wall.u_value, wall.area, adjusted_delta_t)
+        
+        # ENHANCEMENT: Log detailed information in debug mode
+        if self.debug_mode:
+            logger.debug(f"Wall {wall.name} heating load: u_value={wall.u_value}, area={wall.area}, delta_t={adjusted_delta_t}, load={load:.2f} W")
+        
         return max(0, load)
 
     def calculate_roof_heating_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float) -> float:
@@ -114,6 +127,11 @@ class HeatingLoadCalculator:
         adjusted_delta_t = delta_t * lag_factor
         
         load = self.heat_transfer.conduction_heat_transfer(roof.u_value, roof.area, adjusted_delta_t)
+        
+        # ENHANCEMENT: Log detailed information in debug mode
+        if self.debug_mode:
+            logger.debug(f"Roof {roof.name} heating load: u_value={roof.u_value}, area={roof.area}, delta_t={adjusted_delta_t}, load={load:.2f} W")
+        
         return max(0, load)
 
     def calculate_floor_heating_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
@@ -133,10 +151,22 @@ class HeatingLoadCalculator:
         if delta_t <= 1:
             return 0.0
         
-        if floor.is_ground_contact:
+        # ENHANCEMENT: Check if floor has ground_contact attribute
+        is_ground_contact = floor.ground_contact if hasattr(floor, 'ground_contact') else False
+        
+        if is_ground_contact:
             # Dynamic F-factor based on insulation
-            f_factor = 0.3 if floor.insulated else 0.73  # W/m·K
-            load = f_factor * floor.perimeter_length * delta_t
+            # ENHANCEMENT: Check if floor has insulated attribute
+            is_insulated = floor.insulated if hasattr(floor, 'insulated') else False
+            f_factor = 0.3 if is_insulated else 0.73  # W/m·K
+            
+            # ENHANCEMENT: Check if floor has perimeter attribute
+            perimeter = floor.perimeter if hasattr(floor, 'perimeter') else (
+                floor.perimeter_length if hasattr(floor, 'perimeter_length') else 
+                math.sqrt(4 * floor.area)  # Estimate perimeter if not provided
+            )
+            
+            load = f_factor * perimeter * delta_t
         else:
             load = self.heat_transfer.conduction_heat_transfer(floor.u_value, floor.area, delta_t)
         
@@ -162,7 +192,32 @@ class HeatingLoadCalculator:
         if delta_t <= 1:
             return 0.0
         
-        load = self.heat_transfer.conduction_heat_transfer(window.u_value, window.area, delta_t)
+        # ENHANCEMENT: Adjust U-value if window has drapery
+        adjusted_u_value = window.u_value
+        if hasattr(window, 'has_drapery') and window.has_drapery:
+            # Simple U-value adjustment for drapery (typically reduces U-value by 10-20%)
+            drapery_reduction = 0.15  # 15% reduction as a default
+            
+            # More detailed adjustment if drapery properties are available
+            if hasattr(window, 'drapery_type'):
+                drapery_reductions = {
+                    'None': 0.0,
+                    'Sheer': 0.05,
+                    'Light': 0.10,
+                    'Medium': 0.15,
+                    'Heavy': 0.20,
+                    'Blackout': 0.25
+                }
+                drapery_reduction = drapery_reductions.get(window.drapery_type, 0.15)
+            
+            adjusted_u_value = window.u_value * (1 - drapery_reduction)
+        
+        load = self.heat_transfer.conduction_heat_transfer(adjusted_u_value, window.area, delta_t)
+        
+        # ENHANCEMENT: Log detailed information in debug mode
+        if self.debug_mode:
+            logger.debug(f"Window {window.name} heating load: u_value={adjusted_u_value}, area={window.area}, delta_t={delta_t}, load={load:.2f} W")
+        
         return max(0, load)
 
     def calculate_door_heating_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
@@ -182,7 +237,48 @@ class HeatingLoadCalculator:
         if delta_t <= 1:
             return 0.0
         
-        load = self.heat_transfer.conduction_heat_transfer(door.u_value, door.area, delta_t)
+        # ENHANCEMENT: Adjust U-value if door has weatherstripping
+        adjusted_u_value = door.u_value
+        if hasattr(door, 'has_weatherstripping') and door.has_weatherstripping:
+            # Simple U-value adjustment for weatherstripping (typically reduces U-value by 5-10%)
+            adjusted_u_value = door.u_value * 0.95  # 5% reduction
+        
+        load = self.heat_transfer.conduction_heat_transfer(adjusted_u_value, door.area, delta_t)
+        
+        # ENHANCEMENT: Log detailed information in debug mode
+        if self.debug_mode:
+            logger.debug(f"Door {wall.name} heating load: u_value={adjusted_u_value}, area={door.area}, delta_t={delta_t}, load={load:.2f} W")
+        
+        return max(0, load)
+    
+    # ENHANCEMENT: Added skylight heating load calculation
+    def calculate_skylight_heating_load(self, skylight: Skylight, outdoor_temp: float, indoor_temp: float) -> float:
+        """
+        Calculate heating load for a skylight.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
+        
+        Args:
+            skylight: Skylight component
+            outdoor_temp: Outdoor temperature in °C
+            indoor_temp: Indoor temperature in °C
+            
+        Returns:
+            Heating load in W
+        """
+        delta_t = indoor_temp - outdoor_temp
+        if delta_t <= 1:
+            return 0.0
+        
+        # Skylights typically have higher U-values due to their horizontal orientation
+        # Apply a 10% increase to account for this
+        adjusted_u_value = skylight.u_value * 1.1
+        
+        load = self.heat_transfer.conduction_heat_transfer(adjusted_u_value, skylight.area, delta_t)
+        
+        # Log detailed information in debug mode
+        if self.debug_mode:
+            logger.debug(f"Skylight {skylight.name} heating load: u_value={adjusted_u_value}, area={skylight.area}, delta_t={delta_t}, load={load:.2f} W")
+        
         return max(0, load)
 
     def calculate_infiltration_heating_load(self, indoor_conditions: Dict[str, float], 
@@ -217,9 +313,14 @@ class HeatingLoadCalculator:
         )
         total_pd = self.heat_transfer.combined_pressure_difference(wind_pd, stack_pd)
         
-        # Calculate infiltration flow rate
-        crack_length = infiltration.get('crack_length', 20.0)
-        flow_rate = self.heat_transfer.crack_method_infiltration(crack_length, 0.0002, total_pd)
+        # ENHANCEMENT: Use crack dimensions if available for more accurate infiltration calculation
+        if 'crack_length' in infiltration and 'crack_width' in infiltration:
+            crack_length = infiltration['crack_length']
+            crack_width = infiltration['crack_width'] / 1000.0  # Convert from mm to m
+            flow_rate = self.heat_transfer.crack_method_infiltration(crack_length, crack_width, total_pd)
+        else:
+            # Use provided flow rate or default
+            flow_rate = infiltration.get('flow_rate', 0.05)  # m³/s
         
         # Calculate humidity ratio difference
         w_indoor = self.psychrometrics.humidity_ratio(
@@ -307,16 +408,19 @@ class HeatingLoadCalculator:
         
         return max(0, sensible_load), max(0, latent_load)
 
-    def calculate_internal_gains(self, internal_loads: Dict[str, Any]) -> float:
+    # ENHANCEMENT: Modified to include equipment and internal loads as heating sources
+    def calculate_internal_gains(self, internal_loads: Dict[str, Any], include_as_heating_source: bool = True) -> float:
         """
         Calculate internal heat gains from people, lighting, and equipment.
         Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.4.
         
         Args:
             internal_loads: Internal loads (people, lights, equipment)
+            include_as_heating_source: Whether to include internal gains as heating sources (positive value)
+                                      or as load reductions (negative value)
             
         Returns:
-            Total internal gains in W
+            Total internal gains in W (positive if heating source, negative if load reduction)
         """
         total_gains = 0.0
         
@@ -336,13 +440,15 @@ class HeatingLoadCalculator:
         if equipment.get('power', 0) > 0:
             total_gains += equipment['power'] * equipment.get('use_factor', 0.7)
         
-        return max(0, total_gains)
+        # ENHANCEMENT: Return positive value if including as heating source, negative if reducing load
+        return total_gains if include_as_heating_source else -total_gains
 
     def calculate_design_heating_load(self, building_components: Dict[str, List[Any]], 
                                     outdoor_conditions: Dict[str, float], 
                                     indoor_conditions: Dict[str, float], 
                                     internal_loads: Dict[str, Any],
-                                    p_atm: float = 101325) -> Dict[str, float]:
+                                    p_atm: float = 101325,
+                                    include_internal_gains_as_heating_source: bool = False) -> Dict[str, float]:
         """
         Calculate design heating loads for all components.
         Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
@@ -353,6 +459,7 @@ class HeatingLoadCalculator:
             indoor_conditions: Indoor conditions (temperature, relative_humidity)
             internal_loads: Internal loads (people, lights, equipment, infiltration, ventilation)
             p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            include_internal_gains_as_heating_source: Whether to include internal gains as heating sources
             
         Returns:
             Dictionary of design loads in W
@@ -368,6 +475,7 @@ class HeatingLoadCalculator:
             'floors': 0.0,
             'windows': 0.0,
             'doors': 0.0,
+            'skylights': 0.0,  # ENHANCEMENT: Added skylights
             'infiltration_sensible': 0.0,
             'infiltration_latent': 0.0,
             'ventilation_sensible': 0.0,
@@ -391,6 +499,10 @@ class HeatingLoadCalculator:
         for door in building_components.get('doors', []):
             loads['doors'] += self.calculate_door_heating_load(door, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
         
+        # ENHANCEMENT: Added skylights
+        for skylight in building_components.get('skylights', []):
+            loads['skylights'] += self.calculate_skylight_heating_load(skylight, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
+        
         # Calculate infiltration and ventilation loads
         building_height = internal_loads.get('infiltration', {}).get('height', 3.0)
         infiltration_sensible, infiltration_latent = self.calculate_infiltration_heating_load(
@@ -405,8 +517,10 @@ class HeatingLoadCalculator:
         loads['ventilation_sensible'] = ventilation_sensible
         loads['ventilation_latent'] = ventilation_latent
         
-        # Calculate internal gains (negative for heating)
-        loads['internal_gains'] = -self.calculate_internal_gains(internal_loads)
+        # ENHANCEMENT: Calculate internal gains (positive or negative based on parameter)
+        loads['internal_gains'] = self.calculate_internal_gains(
+            internal_loads, include_as_heating_source=include_internal_gains_as_heating_source
+        )
         
         return loads
 
@@ -421,17 +535,26 @@ class HeatingLoadCalculator:
         Returns:
             Summary dictionary with total, subtotal, and safety factor
         """
+        # ENHANCEMENT: Include skylights in subtotal
         subtotal = sum(
             load for key, load in design_loads.items()
             if key not in ['internal_gains'] and load > 0
         )
         internal_gains = design_loads.get('internal_gains', 0)
         
-        total = max(0, subtotal + internal_gains) * self.safety_factor
+        # ENHANCEMENT: If internal gains are positive (heating source), add them to subtotal
+        # If negative (load reduction), subtract them from subtotal
+        if internal_gains >= 0:
+            adjusted_subtotal = subtotal + internal_gains
+        else:
+            adjusted_subtotal = subtotal + internal_gains  # internal_gains is negative, so this is subtraction
+        
+        total = max(0, adjusted_subtotal) * self.safety_factor
         
         return {
             'subtotal': subtotal,
             'internal_gains': internal_gains,
+            'adjusted_subtotal': adjusted_subtotal,
             'total': total,
             'safety_factor': self.safety_factor
         }
@@ -502,7 +625,8 @@ class HeatingLoadCalculator:
                                       indoor_conditions: Dict[str, float], 
                                       internal_loads: Dict[str, Any], 
                                       monthly_temps: Dict[str, float],
-                                      p_atm: float = 101325) -> Dict[str, float]:
+                                      p_atm: float = 101325,
+                                      include_internal_gains_as_heating_source: bool = False) -> Dict[str, float]:
         """
         Calculate monthly heating loads.
         Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
@@ -514,6 +638,7 @@ class HeatingLoadCalculator:
             internal_loads: Internal loads
             monthly_temps: Dictionary of monthly average temperatures
             p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            include_internal_gains_as_heating_source: Whether to include internal gains as heating sources
             
         Returns:
             Dictionary of monthly heating loads in kW
@@ -531,7 +656,8 @@ class HeatingLoadCalculator:
             
             try:
                 design_loads = self.calculate_design_heating_load(
-                    building_components, modified_outdoor, indoor_conditions, internal_loads, p_atm
+                    building_components, modified_outdoor, indoor_conditions, internal_loads, p_atm,
+                    include_internal_gains_as_heating_source
                 )
                 summary = self.calculate_heating_load_summary(design_loads)
                 monthly_loads[month] = summary['total'] / 1000  # kW
@@ -552,7 +678,8 @@ if __name__ == "__main__":
                         is_ground_contact=True, insulated=True, ground_temperature_c=10.0)],
         'windows': [Window(id="win1", name="South Window", area=10.0, u_value=2.8, orientation=Orientation.SOUTH, 
                           shgc=0.7, shading_coefficient=0.8)],
-        'doors': [Door(id="d1", name="Main Door", area=2.0, u_value=2.0, orientation=Orientation.NORTH)]
+        'doors': [Door(id="d1", name="Main Door", area=2.0, u_value=2.0, orientation=Orientation.NORTH)],
+        'skylights': [Skylight(id="s1", name="Main Skylight", area=5.0, u_value=3.0, orientation=Orientation.HORIZONTAL)]
     }
     
     outdoor_conditions = {
@@ -569,7 +696,7 @@ if __name__ == "__main__":
         'people': {'number': 10, 'sensible_gain': 70.0, 'operating_hours': '8:00-18:00'},
         'lights': {'power': 1000.0, 'use_factor': 0.8, 'hours_operation': '8h'},
         'equipment': {'power': 500.0, 'use_factor': 0.7, 'hours_operation': '8h'},
-        'infiltration': {'flow_rate': 0.05, 'height': 3.0, 'crack_length': 20.0},
+        'infiltration': {'flow_rate': 0.05, 'height': 3.0, 'crack_length': 20.0, 'crack_width': 2.0},
         'ventilation': {'flow_rate': 0.1},
         'operating_hours': '8:00-18:00'
     }
@@ -579,7 +706,10 @@ if __name__ == "__main__":
     }
     
     # Calculate design loads
-    design_loads = calculator.calculate_design_heating_load(components, outdoor_conditions, indoor_conditions, internal_loads)
+    design_loads = calculator.calculate_design_heating_load(
+        components, outdoor_conditions, indoor_conditions, internal_loads,
+        include_internal_gains_as_heating_source=True  # ENHANCEMENT: Include internal gains as heating sources
+    )
     summary = calculator.calculate_heating_load_summary(design_loads)
     
     # Log results
@@ -589,6 +719,7 @@ if __name__ == "__main__":
     logger.info(f"Floor Load: {design_loads['floors']:.2f} W")
     logger.info(f"Window Load: {design_loads['windows']:.2f} W")
     logger.info(f"Door Load: {design_loads['doors']:.2f} W")
+    logger.info(f"Skylight Load: {design_loads['skylights']:.2f} W")  # ENHANCEMENT: Added skylight load
     logger.info(f"Infiltration Sensible Load: {design_loads['infiltration_sensible']:.2f} W")
     logger.info(f"Infiltration Latent Load: {design_loads['infiltration_latent']:.2f} W")
     logger.info(f"Ventilation Sensible Load: {design_loads['ventilation_sensible']:.2f} W")
@@ -603,7 +734,8 @@ if __name__ == "__main__":
     
     # Calculate monthly loads
     monthly_loads = calculator.calculate_monthly_heating_loads(
-        components, outdoor_conditions, indoor_conditions, internal_loads, monthly_temps
+        components, outdoor_conditions, indoor_conditions, internal_loads, monthly_temps,
+        include_internal_gains_as_heating_source=True  # ENHANCEMENT: Include internal gains as heating sources
     )
     logger.info("Monthly Heating Loads (kW):")
     for month, load in monthly_loads.items():