Update utils/heating_load.py

utils/heating_load.py

@@ -2,6 +2,7 @@
 Heating load calculation module for HVAC Load Calculator.
 This module implements enhanced steady-state methods with thermal mass effects,
 pressure-driven infiltration, and schedule-based internal gains.
+Updated 2025-04-28: Added F-factor for floor losses, ground temperature validation, and negative load prevention.
 """
 
 from typing import Dict, List, Any, Optional, Tuple
@@ -20,7 +21,6 @@ from utils.heat_transfer import HeatTransferCalculations
 # Define paths
 DATA_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 
-
 class HeatingLoadCalculator:
     """Class for calculating heating loads using enhanced steady-state methods."""
     
@@ -29,7 +29,7 @@ class HeatingLoadCalculator:
         self.heat_transfer = HeatTransferCalculations()
         self.psychrometrics = Psychrometrics()
     
-    def validate_inputs(self, temp: float, rh: float, area: float, u_value: float) -> None:
+    def validate_inputs(self, temp: float, rh: float, area: float, u_value: float, ground_temp: Optional[float] = None) -> None:
         """
         Validate input parameters for calculations.
         
@@ -38,6 +38,7 @@ class HeatingLoadCalculator:
             rh: Relative humidity in %
             area: Area in m²
             u_value: U-value in W/(m²·K)
+            ground_temp: Ground temperature in °C (optional)
             
         Raises:
             ValueError: If inputs are out of acceptable ranges
@@ -50,6 +51,8 @@ class HeatingLoadCalculator:
             raise ValueError(f"Area {area}m² cannot be negative")
         if u_value < 0:
             raise ValueError(f"U-value {u_value} W/(m²·K) cannot be negative")
+        if ground_temp is not None and not -10 <= ground_temp <= 40:
+            raise ValueError(f"Ground temperature {ground_temp}°C is outside valid range (-10 to 40°C)")
     
     def calculate_wall_heating_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float) -> float:
         """
@@ -107,7 +110,7 @@ class HeatingLoadCalculator:
     
     def calculate_floor_heating_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
         """
-        Calculate heating load through a floor with thermal mass effects.
+        Calculate heating load through a floor with thermal mass effects and perimeter losses.
         
         Args:
             floor: Floor object
@@ -117,18 +120,30 @@ class HeatingLoadCalculator:
         Returns:
             Heating load in W
         """
-        self.validate_inputs(ground_temp, 80.0, floor.area, floor.u_value)
+        self.validate_inputs(ground_temp, 80.0, floor.area, floor.u_value, ground_temp=ground_temp)
         
-        u_value = floor.u_value
-        area = floor.area
+        heating_load = 0.0
         delta_t = indoor_temp - ground_temp
         
-        # Apply thermal mass effect
+        # Area-based conduction
+        u_value = floor.u_value
+        area = floor.area
         thermal_mass = getattr(floor, "thermal_mass", 150000)  # J/K, default
         time_constant = getattr(floor, "time_constant", 2.5)  # hours, default
         lag_factor = self.heat_transfer.thermal_lag_factor(thermal_mass, time_constant, 1.0)
+        conduction_load = u_value * area * delta_t * lag_factor
         
-        heating_load = u_value * area * delta_t * lag_factor
+        heating_load += conduction_load
+        
+        # NEW: Perimeter losses (F-factor method, ASHRAE Fundamentals Chapter 18)
+        if getattr(floor, 'ground_contact', False):
+            perimeter = getattr(floor, 'perimeter', 0.0)
+            if perimeter < 0:
+                raise ValueError(f"Perimeter for floor {floor.name} cannot be negative")
+            if perimeter > 0:
+                f_factor = 0.73  # W/(m·K) for uninsulated slab-on-grade (Table 18.3)
+                perimeter_load = f_factor * perimeter * delta_t
+                heating_load += perimeter_load
         
         return max(0, heating_load)
     
@@ -363,6 +378,7 @@ class HeatingLoadCalculator:
         for door in doors:
             loads["doors"] += self.calculate_door_heating_load(door, outdoor_temp, indoor_temp)
         
+        # Calculate infiltration loads
         if infiltration:
             infiltration_loads = self.calculate_infiltration_heating_load(
                 building_volume=building_volume,
@@ -377,10 +393,10 @@ class HeatingLoadCalculator:
             loads["infiltration_sensible"] = infiltration_loads["sensible"]
             loads["infiltration_latent"] = infiltration_loads["latent"]
         
+        # Calculate ventilation loads
         if ventilation:
-            flow_rate = ventilation.get("flow_rate", 0.0)
             ventilation_loads = self.calculate_ventilation_heating_load(
-                flow_rate=flow_rate,
+                flow_rate=ventilation.get("flow_rate", 0.1),
                 outdoor_temp=outdoor_temp,
                 indoor_temp=indoor_temp,
                 outdoor_rh=outdoor_rh,
@@ -389,262 +405,171 @@ class HeatingLoadCalculator:
             loads["ventilation_sensible"] = ventilation_loads["sensible"]
             loads["ventilation_latent"] = ventilation_loads["latent"]
         
-        people_load = people.get("number", 0) * people.get("sensible_gain", 70)
-        lights_load = lights.get("power", 0) * lights.get("use_factor", 1.0)
-        equipment_load = equipment.get("power", 0) * equipment.get("use_factor", 1.0)
+        # Calculate internal gains offset
+        people_load = people.get("number", 0) * people.get("sensible_gain", 70.0)
+        lights_load = lights.get("power", 0) * lights.get("use_factor", 0.8)
+        equipment_load = equipment.get("power", 0) * equipment.get("use_factor", 0.7)
+        
+        schedule = None
+        operating_hours = internal_loads.get("operating_hours", "8:00-18:00")
+        if operating_hours:
+            start_hour = int(operating_hours.split(":")[0])
+            end_hour = int(operating_hours.split("-")[1].split(":")[0])
+            schedule = [1.0 if start_hour <= h % 24 < end_hour else 0.5 for h in range(24)]
+        
         loads["internal_gains_offset"] = self.calculate_internal_gains_offset(
             people_load=people_load,
             lights_load=lights_load,
             equipment_load=equipment_load,
             usage_factor=internal_loads.get("usage_factor", 0.7),
-            hour=0,
-            schedule=internal_loads.get("gains_schedule", None)
+            hour=12,  # Assume peak load at noon
+            schedule=schedule
         )
         
+        # Calculate subtotal
         loads["subtotal"] = (
-            loads["walls"] + loads["roofs"] + loads["floors"] +
-            loads["windows"] + loads["doors"] +
-            loads["infiltration_sensible"] + loads["infiltration_latent"] +
-            loads["ventilation_sensible"] + loads["ventilation_latent"] -
-            loads["internal_gains_offset"]
+            loads["walls"] +
+            loads["roofs"] +
+            loads["floors"] +
+            loads["windows"] +
+            loads["doors"] +
+            loads["infiltration_sensible"] +
+            loads["infiltration_latent"] +
+            loads["ventilation_sensible"] +
+            loads["ventilation_latent"]
         )
-        loads["total"] = loads["subtotal"] * safety_factor
+        
+        # Apply internal gains offset and prevent negative loads
+        loads["total"] = max(0, loads["subtotal"] - loads["internal_gains_offset"])
+        
+        # Apply safety factor
+        loads["total"] *= safety_factor
         
         return loads
     
     def calculate_heating_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
         """
-        Calculate heating load summary.
+        Summarize heating loads for reporting.
         
         Args:
             design_loads: Dictionary with design heating loads
             
         Returns:
-            Dictionary with heating load summary
+            Summary dictionary with key load components
         """
-        envelope_loads = sum([
-            design_loads["walls"], design_loads["roofs"], design_loads["floors"],
-            design_loads["windows"], design_loads["doors"]
-        ])
-        ventilation_loads = design_loads["ventilation_sensible"] + design_loads["ventilation_latent"]
-        infiltration_loads = design_loads["infiltration_sensible"] + design_loads["infiltration_latent"]
-        
-        return {
-            "envelope_loads": envelope_loads,
-            "ventilation_loads": ventilation_loads,
-            "infiltration_loads": infiltration_loads,
-            "internal_gains_offset": design_loads["internal_gains_offset"],
-            "subtotal": design_loads["subtotal"],
-            "safety_factor": design_loads["safety_factor"],
-            "total": design_loads["total"]
+        summary = {
+            "walls": design_loads.get("walls", 0),
+            "roofs": design_loads.get("roofs", 0),
+            "floors": design_loads.get("floors", 0),
+            "windows": design_loads.get("windows", 0),
+            "doors": design_loads.get("doors", 0),
+            "infiltration": design_loads.get("infiltration_sensible", 0) + design_loads.get("infiltration_latent", 0),
+            "ventilation": design_loads.get("ventilation_sensible", 0) + design_loads.get("ventilation_latent", 0),
+            "internal_gains_offset": design_loads.get("internal_gains_offset", 0),
+            "subtotal": design_loads.get("subtotal", 0),
+            "safety_factor": design_loads.get("safety_factor", 1.15),
+            "total": design_loads.get("total", 0)
         }
+        return summary
     
-    def calculate_monthly_heating_loads(self, design_loads: Dict[str, float], 
-                                      monthly_temps: Dict[str, float],
-                                      design_temp: float, indoor_temp: float) -> Dict[str, float]:
+    def calculate_monthly_heating_loads(self, building_components: Dict[str, List[Any]], 
+                                      monthly_temps: Dict[str, float], ground_temps: Dict[str, float],
+                                      indoor_conditions: Dict[str, Any], internal_loads: Dict[str, Any],
+                                      building_volume: float = 300.0) -> Dict[str, float]:
         """
-        Calculate monthly heating loads based on design load and monthly temperatures.
+        Calculate monthly heating loads using monthly average temperatures.
         
         Args:
-            design_loads: Dictionary with design heating loads
-            monthly_temps: Dictionary with monthly average temperatures
-            design_temp: Design outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
+            building_components: Dictionary with lists of building components
+            monthly_temps: Dictionary with monthly outdoor temperatures (°C)
+            ground_temps: Dictionary with monthly ground temperatures (°C)
+            indoor_conditions: Dictionary with indoor conditions
+            internal_loads: Dictionary with internal loads
+            building_volume: Building volume in m³ (default: 300 m³)
             
         Returns:
-            Dictionary with monthly heating loads
+            Dictionary with monthly heating loads in W
         """
-        design_delta_t = indoor_temp - design_temp
         monthly_loads = {}
+        indoor_temp = indoor_conditions.get("temperature", 21.0)
+        indoor_rh = indoor_conditions.get("relative_humidity", 40.0)
         
-        for month, temp in monthly_temps.items():
-            delta_t = indoor_temp - temp
-            if delta_t <= 0:
-                monthly_loads[month] = 0
+        for month, outdoor_temp in monthly_temps.items():
+            ground_temp = ground_temps.get(month, outdoor_temp)  # Fallback to outdoor temp if ground temp missing
+            outdoor_conditions = {
+                "design_temperature": outdoor_temp,
+                "design_relative_humidity": 80.0,  # Assume constant for simplicity
+                "ground_temperature": ground_temp,
+                "wind_speed": 4.0
+            }
+            
+            # Skip if no heating is needed
+            if outdoor_temp >= indoor_temp:
+                monthly_loads[month] = 0.0
                 continue
-            load_ratio = delta_t / design_delta_t
-            monthly_loads[month] = design_loads["total"] * load_ratio
+            
+            loads = self.calculate_design_heating_load(
+                building_components=building_components,
+                outdoor_conditions=outdoor_conditions,
+                indoor_conditions=indoor_conditions,
+                internal_loads=internal_loads,
+                building_volume=building_volume,
+                safety_factor=1.0  # No safety factor for monthly loads
+            )
+            monthly_loads[month] = max(0, loads["total"])
         
         return monthly_loads
     
-    def calculate_heating_degree_days(self, monthly_temps: Dict[str, float], 
-                                    base_temp: float = 18.0) -> Dict[str, float]:
+    def calculate_heating_degree_days(self, monthly_temps: Dict[str, float], base_temp: float = 18.3) -> float:
         """
-        Calculate heating degree days for each month with precise days.
+        Calculate annual heating degree days.
         
         Args:
-            monthly_temps: Dictionary with monthly average temperatures
-            base_temp: Base temperature for degree days in °C (default: 18°C)
+            monthly_temps: Dictionary with monthly outdoor temperatures (°C)
+            base_temp: Base temperature for degree days (°C, default: 18.3°C)
             
         Returns:
-            Dictionary with monthly heating degree days
+            Total heating degree days
         """
+        hdd = 0.0
         days_per_month = {
             "Jan": 31, "Feb": 28, "Mar": 31, "Apr": 30, "May": 31, "Jun": 30,
             "Jul": 31, "Aug": 31, "Sep": 30, "Oct": 31, "Nov": 30, "Dec": 31
         }
-        monthly_hdds = {}
         
         for month, temp in monthly_temps.items():
-            daily_hdd = max(0, base_temp - temp)
-            monthly_hdds[month] = daily_hdd * days_per_month[month]
+            if temp < base_temp:
+                hdd += (base_temp - temp) * days_per_month.get(month, 30)
         
-        return monthly_hdds
+        return hdd
     
     def calculate_annual_heating_energy(self, monthly_loads: Dict[str, float], 
-                                      heating_system_efficiency: float = 0.8) -> Dict[str, float]:
+                                       operating_hours: str = "8:00-18:00") -> float:
         """
-        Calculate annual heating energy consumption with precise days.
+        Calculate annual heating energy consumption.
         
         Args:
             monthly_loads: Dictionary with monthly heating loads in W
-            heating_system_efficiency: Heating system efficiency (0-1)
+            operating_hours: Operating hours (e.g., "8:00-18:00")
             
         Returns:
-            Dictionary with monthly and annual heating energy in kWh
+            Annual heating energy in kWh
         """
+        hours_per_day = 10.0  # Default 10 hours
+        if operating_hours:
+            start_hour = int(operating_hours.split(":")[0])
+            end_hour = int(operating_hours.split("-")[1].split(":")[0])
+            hours_per_day = end_hour - start_hour
+        
         days_per_month = {
             "Jan": 31, "Feb": 28, "Mar": 31, "Apr": 30, "May": 31, "Jun": 30,
             "Jul": 31, "Aug": 31, "Sep": 30, "Oct": 31, "Nov": 30, "Dec": 31
         }
-        monthly_energy = {}
-        annual_energy = 0
         
+        total_energy = 0.0
         for month, load in monthly_loads.items():
-            hours_in_month = 24 * days_per_month[month]
-            energy = load * hours_in_month / 1000 / heating_system_efficiency
-            monthly_energy[month] = energy
-            annual_energy += energy
+            hours = hours_per_day * days_per_month.get(month, 30)
+            energy = load * hours / 1000  # Convert W to kW
+            total_energy += energy
         
-        monthly_energy["annual"] = annual_energy
-        return monthly_energy
-
-
-# Create a singleton instance
-heating_load_calculator = HeatingLoadCalculator()
-
-# Example usage
-if __name__ == "__main__":
-    from data.building_components import Wall, Roof, Window, Door, Orientation, ComponentType
-    
-    wall = Wall(
-        id="wall1",
-        name="Exterior Wall",
-        component_type=ComponentType.WALL,
-        u_value=0.5,
-        area=20.0,
-        orientation=Orientation.NORTH,
-        wall_type="Brick",
-        wall_group="B",
-        thermal_mass=100000,
-        time_constant=2.0
-    )
-    roof = Roof(
-        id="roof1",
-        name="Flat Roof",
-        component_type=ComponentType.ROOF,
-        u_value=0.3,
-        area=50.0,
-        orientation=Orientation.HORIZONTAL,
-        roof_type="Concrete",
-        roof_group="C",
-        thermal_mass=200000,
-        time_constant=3.0
-    )
-    window = Window(
-        id="window1",
-        name="North Window",
-        component_type=ComponentType.WINDOW,
-        u_value=2.8,
-        area=5.0,
-        orientation=Orientation.NORTH,
-        shgc=0.7,
-        vt=0.8,
-        window_type="Double Glazed",
-        glazing_layers=2,
-        gas_fill="Air",
-        low_e_coating=False
-    )
-    
-    building_components = {
-        "walls": [wall],
-        "roofs": [roof],
-        "windows": [window],
-        "doors": [],
-        "floors": []
-    }
-    
-    outdoor_conditions = {
-        "design_temperature": -10.0,
-        "design_relative_humidity": 80.0,
-        "ground_temperature": 10.0,
-        "wind_speed": 4.0
-    }
-    indoor_conditions = {
-        "temperature": 21.0,
-        "relative_humidity": 40.0
-    }
-    
-    gains_schedule = [0.2] * 8 + [0.8] * 8 + [0.4] * 8  # 8h low, 8h high, 8h medium
-    internal_loads = {
-        "people": {
-            "number": 3,
-            "sensible_gain": 70
-        },
-        "lights": {
-            "power": 500.0,
-            "use_factor": 0.9
-        },
-        "equipment": {
-            "power": 1000.0,
-            "use_factor": 0.7
-        },
-        "infiltration": {
-            "height": 3.0,
-            "crack_length": 10.0
-        },
-        "ventilation": {
-            "flow_rate": 0.1
-        },
-        "usage_factor": 0.7,
-        "gains_schedule": gains_schedule
-    }
-    
-    design_loads = heating_load_calculator.calculate_design_heating_load(
-        building_components=building_components,
-        outdoor_conditions=outdoor_conditions,
-        indoor_conditions=indoor_conditions,
-        internal_loads=internal_loads,
-        building_volume=300.0
-    )
-    summary = heating_load_calculator.calculate_heating_load_summary(design_loads)
-    
-    monthly_temps = {
-        "Jan": -5.0, "Feb": -3.0, "Mar": 2.0, "Apr": 8.0, "May": 14.0,
-        "Jun": 18.0, "Jul": 21.0, "Aug": 20.0, "Sep": 16.0, "Oct": 10.0,
-        "Nov": 4.0, "Dec": -2.0
-    }
-    
-    monthly_loads = heating_load_calculator.calculate_monthly_heating_loads(
-        design_loads=design_loads,
-        monthly_temps=monthly_temps,
-        design_temp=outdoor_conditions["design_temperature"],
-        indoor_temp=indoor_conditions["temperature"]
-    )
-    hdds = heating_load_calculator.calculate_heating_degree_days(monthly_temps)
-    energy = heating_load_calculator.calculate_annual_heating_energy(monthly_loads)
-    
-    print("Heating Load Summary:")
-    for key, value in summary.items():
-        print(f"{key.replace('_', ' ').title()}: {value:.2f} W")
-    
-    print("\nMonthly Heating Loads:")
-    for month, load in monthly_loads.items():
-        print(f"{month}: {load:.2f} W")
-    
-    print("\nHeating Degree Days:")
-    for month, hdd in hdds.items():
-        print(f"{month}: {hdd:.2f} HDD")
-    
-    print("\nAnnual Heating Energy:")
-    print(f"Total: {energy['annual']:.2f} kWh")
+        return total_energy