Update app/hvac_loads.py

app/hvac_loads.py

@@ -671,134 +671,208 @@ class TFMCalculations:
             temp = adaptive_setpoints.get(key, 24.0) if adaptive_setpoints else 24.0
             return {"temperature": temp, "rh": 50.0}
 
-    @staticmethod
-    def calculate_tfm_loads(components: Dict, hourly_data: List[Dict], indoor_conditions: Dict, internal_loads: Dict, building_info: Dict, sim_period: Dict, hvac_settings: Dict) -> List[Dict]:
-        """Calculate TFM loads for heating and cooling with user-defined filters and temperature threshold."""
-        # Access climate_data for ground temperatures
-        climate_data = st.session_state.project_data["climate_data"]
-        ground_temperatures = climate_data.get("ground_temperatures", {})
-        logger.debug(f"Ground temperatures available: {ground_temperatures.keys()}")
-        
-        filtered_data = TFMCalculations.filter_hourly_data(hourly_data, sim_period, climate_data)
-        temp_loads = []
-        building_orientation = building_info.get("orientation_angle", 0.0)
-        operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
-        area = building_info.get("floor_area", 100.0)
+@staticmethod
+def calculate_tfm_loads(components: Dict, hourly_data: List[Dict], indoor_conditions: Dict, internal_loads: Dict, building_info: Dict, sim_period: Dict, hvac_settings: Dict) -> List[Dict]:
+    """Calculate TFM loads for heating and cooling with user-defined filters and temperature threshold."""
+    # Access climate_data for ground temperatures
+    climate_data = st.session_state.project_data["climate_data"]
+    ground_temperatures = climate_data.get("ground_temperatures", {})
+    logger.debug(f"Ground temperatures available: {ground_temperatures.keys()}")
+    
+    filtered_data = TFMCalculations.filter_hourly_data(hourly_data, sim_period, climate_data)
+    temp_loads = []
+    building_orientation = building_info.get("orientation_angle", 0.0)
+    operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
+    area = building_info.get("floor_area", 100.0)
+    
+    if "material_library" not in st.session_state:
+        from app.materials_library import MaterialLibrary
+        st.session_state.material_library = MaterialLibrary()
+        logger.info("Initialized MaterialLibrary in session_state for solar calculations")
+
+    if indoor_conditions["type"] == "ASHRAE 55 Adaptive Comfort":
+        acceptability = indoor_conditions.get("adaptive_acceptability", "90")
+        adaptive_setpoints = AdaptiveComfortModel.generate_adaptive_setpoints(hourly_data, acceptability)
+    else:
+        adaptive_setpoints = None
+
+    for comp_list in components.values():
+        for comp in comp_list:
+            comp['ctf'] = CTFCalculator.calculate_ctf_coefficients(comp)
+            logger.debug(f"Stored CTF coefficients for component {comp.get('name', 'Unknown')}")
+
+    # Cache total surface area for opaque components (walls, roofs, floors)
+    total_surface_area = 0.0
+    opaque_components = []
+    for comp_list in components.values():
+        for comp in comp_list:
+            comp_type = TFMCalculations.get_component_type(comp)
+            if comp_type in [ComponentType.WALL, ComponentType.ROOF, ComponentType.FLOOR]:
+                comp_area = comp.get('area', 0.0)
+                if comp_area > 0:
+                    total_surface_area += comp_area
+                    opaque_components.append(comp)
+    logger.debug(f"Total surface area for opaque components: {total_surface_area:.2f} m²")
+
+    for hour_data in filtered_data:
+        hour = hour_data["hour"]
+        outdoor_temp = hour_data["dry_bulb"]
+        month = hour_data["month"]
+        day = hour_data["day"]
+        # For future enhancement: Retrieve ground temperature for the current month
+        ground_temp = ground_temperatures.get("0.5", [20.0]*12)[month-1] if ground_temperatures else 20.0
+        logger.debug(f"Ground temperature for month {month}: {ground_temp:.1f}°C")
         
-        if "material_library" not in st.session_state:
-            from app.materials_library import MaterialLibrary
-            st.session_state.material_library = MaterialLibrary()
-            logger.info("Initialized MaterialLibrary in session_state for solar calculations")
-
-        if indoor_conditions["type"] == "ASHRAE 55 Adaptive Comfort":
-            acceptability = indoor_conditions.get("adaptive_acceptability", "90")
-            adaptive_setpoints = AdaptiveComfortModel.generate_adaptive_setpoints(hourly_data, acceptability)
+        indoor_cond = TFMCalculations.get_indoor_conditions(indoor_conditions, hour, outdoor_temp, month, day, adaptive_setpoints)
+        indoor_temp = indoor_cond["temperature"]
+        conduction_cooling = conduction_heating = solar = internal = ventilation_cooling = ventilation_heating = infiltration_cooling = infiltration_heating = 0
+        solar_by_orientation = defaultdict(float)
+        conduction_by_orientation = defaultdict(float)
+        is_operating = False
+        for period in operating_periods:
+            start_hour = period.get("start", 8)
+            end_hour = period.get("end", 18)
+            if start_hour <= hour % 24 <= end_hour:
+                is_operating = True
+                break
+        mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
+
+        # Calculate radiant loads from internal sources
+        total_radiant_load = 0.0
+        internal_loads_conditions = st.session_state.project_data.get("internal_loads_conditions", {
+            "air_velocity": 0.1,
+            "lighting_convective_fraction": 0.5,
+            "lighting_radiative_fraction": 0.5,
+            "equipment_convective_fraction": 0.5,
+            "equipment_radiative_fraction": 0.5
+        })
+        is_weekend = False  # Simplified; determine from date in practice
+
+        # People radiant load
+        air_velocity = internal_loads_conditions.get("air_velocity", 0.1)
+        if air_velocity < 0.0 or air_velocity > 2.0:
+            logger.warning(f"Air velocity {air_velocity} out of range [0.0, 2.0] for hour {hour}. Clamping to nearest bound.")
+            air_velocity = max(0.0, min(2.0, air_velocity))
+        people_convective_fraction = min(max(0.5 + 0.31 * air_velocity, 0.0), 1.0)
+        people_radiative_fraction = 1.0 - people_convective_fraction
+        for group in internal_loads.get("people", []):
+            schedule_name = group.get("schedule", "Continuous")
+            fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+            sensible = group.get("total_sensible_heat", 0.0)
+            radiant_load = sensible * people_radiative_fraction * fraction / 1000  # kW, exclude latent heat
+            total_radiant_load += radiant_load
+            logger.debug(f"People group '{group.get('name', 'unknown')}': sensible={sensible:.2f} W, radiative_fraction={people_radiative_fraction:.2f}, fraction={fraction:.2f}, radiant_load={radiant_load:.3f} kW")
+
+        # Lighting radiant load
+        lighting_radiative_fraction = internal_loads_conditions.get("lighting_radiative_fraction", 0.5)
+        for light in internal_loads.get("lighting", []):
+            schedule_name = light.get("schedule", "Continuous")
+            fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+            total_power = light.get("total_power", 0.0)
+            radiant_load = total_power * lighting_radiative_fraction * fraction / 1000  # kW
+            total_radiant_load += radiant_load
+            logger.debug(f"Lighting system '{light.get('name', 'unknown')}': total_power={total_power:.2f} W, radiative_fraction={lighting_radiative_fraction:.2f}, fraction={fraction:.2f}, radiant_load={radiant_load:.3f} kW")
+
+        # Equipment radiant load
+        equipment_radiative_fraction = internal_loads_conditions.get("equipment_radiative_fraction", 0.5)
+        for equip in internal_loads.get("equipment", []):
+            schedule_name = equip.get("schedule", "Continuous")
+            fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+            sensible = equip.get("total_sensible_power", 0.0)
+            radiant_load = sensible * equipment_radiative_fraction * fraction / 1000  # kW, exclude latent heat
+            total_radiant_load += radiant_load
+            logger.debug(f"Equipment '{equip.get('name', 'unknown')}': sensible={sensible:.2f} W, radiative_fraction={equipment_radiative_fraction:.2f}, fraction={fraction:.2f}, radiant_load={radiant_load:.3f} kW")
+
+        logger.debug(f"Total radiant load for hour {hour}: {total_radiant_load:.3f} kW")
+
+        # Distribute radiant load to opaque surfaces
+        if total_surface_area > 0:
+            for comp in opaque_components:
+                comp_area = comp.get('area', 0.0)
+                comp['radiant_load'] = total_radiant_load * (comp_area / total_surface_area)
+                logger.debug(f"Component '{comp.get('name', 'Unknown')}': area={comp_area:.2f} m², radiant_load={comp['radiant_load']:.3f} kW")
         else:
-            adaptive_setpoints = None
-
-        for comp_list in components.values():
-            for comp in comp_list:
-                comp['ctf'] = CTFCalculator.calculate_ctf_coefficients(comp)
-                logger.debug(f"Stored CTF coefficients for component {comp.get('name', 'Unknown')}")
-
-        for hour_data in filtered_data:
-            hour = hour_data["hour"]
-            outdoor_temp = hour_data["dry_bulb"]
-            month = hour_data["month"]
-            day = hour_data["day"]
-            # For future enhancement: Retrieve ground temperature for the current month
-            ground_temp = ground_temperatures.get("0.5", [20.0]*12)[month-1] if ground_temperatures else 20.0
-            logger.debug(f"Ground temperature for month {month}: {ground_temp:.1f}°C")
+            logger.warning(f"No valid surface area for hour {hour}. Skipping radiant load distribution.")
+            for comp in opaque_components:
+                comp['radiant_load'] = 0.0
+
+        if is_operating and mode == "cooling":
+            for comp_list in components.values():
+                for comp in comp_list:
+                    cool_load, _ = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="cooling")
+                    component_solar_load = TFMCalculations.calculate_solar_load(comp, hour_data, hour, building_orientation, mode="cooling")
+                    orientation = classify_azimuth(comp.get("surface_azimuth", 0))
+                    element = TFMCalculations.get_component_type(comp).name
+                    key = orientation if element in ["WALL", "WINDOW"] else element
+                    conduction_by_orientation[key] += cool_load
+                    solar_by_orientation[key] += component_solar_load
+                    conduction_cooling += cool_load
+                    solar += component_solar_load
+                    logger.info(f"Component {comp.get('name', 'Unknown')} ({TFMCalculations.get_component_type(comp).value}) solar load: {component_solar_load:.3f} kW, accumulated solar: {solar:.3f} kW")
             
-            indoor_cond = TFMCalculations.get_indoor_conditions(indoor_conditions, hour, outdoor_temp, month, day, adaptive_setpoints)
-            indoor_temp = indoor_cond["temperature"]
-            conduction_cooling = conduction_heating = solar = internal = ventilation_cooling = ventilation_heating = infiltration_cooling = infiltration_heating = 0
-            solar_by_orientation = defaultdict(float)
-            conduction_by_orientation = defaultdict(float)
-            is_operating = False
-            for period in operating_periods:
-                start_hour = period.get("start", 8)
-                end_hour = period.get("end", 18)
-                if start_hour <= hour % 24 <= end_hour:
-                    is_operating = True
-                    break
-            mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
-            if is_operating and mode == "cooling":
-                for comp_list in components.values():
-                    for comp in comp_list:
-                        cool_load, _ = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="cooling")
-                        component_solar_load = TFMCalculations.calculate_solar_load(comp, hour_data, hour, building_orientation, mode="cooling")
-                        orientation = classify_azimuth(comp.get("surface_azimuth", 0))
-                        element = TFMCalculations.get_component_type(comp).name
-                        key = orientation if element in ["WALL", "WINDOW"] else element
-                        conduction_by_orientation[key] += cool_load
-                        solar_by_orientation[key] += component_solar_load
-                        conduction_cooling += cool_load
-                        solar += component_solar_load
-                        logger.info(f"Component {comp.get('name', 'Unknown')} ({TFMCalculations.get_component_type(comp).value}) solar load: {component_solar_load:.3f} kW, accumulated solar: {solar:.3f} kW")
-                
-                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
-                ventilation_cooling, _ = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="cooling")
-                infiltration_cooling, _ = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="cooling")
-            elif is_operating and mode == "heating":
-                for comp_list in components.values():
-                    for comp in comp_list:
-                        _, heat_load = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="heating")
-                        orientation = classify_azimuth(comp.get("surface_azimuth", 0))
-                        element = TFMCalculations.get_component_type(comp).name
-                        key = orientation if element in ["WALL", "WINDOW"] else element
-                        conduction_by_orientation[key] += heat_load
-                        conduction_heating += heat_load
-                internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
-                _, ventilation_heating = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="heating")
-                _, infiltration_heating = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="heating")
+            internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
+            ventilation_cooling, _ = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="cooling")
+            infiltration_cooling, _ = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="cooling")
+        elif is_operating and mode == "heating":
+            for comp_list in components.values():
+                for comp in comp_list:
+                    _, heat_load = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, mode="heating")
+                    orientation = classify_azimuth(comp.get("surface_azimuth", 0))
+                    element = TFMCalculations.get_component_type(comp).name
+                    key = orientation if element in ["WALL", "WINDOW"] else element
+                    conduction_by_orientation[key] += heat_load
+                    conduction_heating += heat_load
+            internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
+            _, ventilation_heating = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="heating")
+            _, infiltration_heating = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, hour, mode="heating")
+        else:
+            internal = 0
+        
+        logger.info(f"Hour {hour} total loads - conduction: {conduction_cooling:.3f} kW, solar: {solar:.3f} kW, internal: {internal:.3f} kW")
+        
+        total_cooling = conduction_cooling + solar + internal + ventilation_cooling + infiltration_cooling
+        total_heating = max(conduction_heating + ventilation_heating + infiltration_heating - internal, 0)
+        if mode == "cooling":
+            total_heating = 0
+        elif mode == "heating":
+            total_cooling = 0
+        temp_loads.append({
+            "hour": hour,
+            "month": month,
+            "day": day,
+            "conduction_cooling": conduction_cooling,
+            "conduction_heating": conduction_heating,
+            "solar": solar,
+            "internal": internal,
+            "ventilation_cooling": ventilation_cooling,
+            "ventilation_heating": ventilation_heating,
+            "infiltration_cooling": infiltration_cooling,
+            "infiltration_heating": infiltration_heating,
+            "total_cooling": total_cooling,
+            "total_heating": total_heating,
+            "ground_temperature": ground_temp,
+            "solar_by_orientation": dict(solar_by_orientation),
+            "conduction_by_orientation": dict(conduction_by_orientation)
+        })
+
+    loads_by_day = defaultdict(list)
+    for load in temp_loads:
+        day_key = (load["month"], load["day"])
+        loads_by_day[day_key].append(load)
+    final_loads = []
+    for day_key, day_loads in loads_by_day.items():
+        cooling_hours = sum(1 for load in day_loads if load["total_cooling"] > 0)
+        heating_hours = sum(1 for load in day_loads if load["total_heating"] > 0)
+        for load in day_loads:
+            if cooling_hours > heating_hours:
+                load["total_heating"] = 0
+            elif heating_hours > cooling_hours:
+                load["total_cooling"] = 0
             else:
-                internal = 0
-            
-            logger.info(f"Hour {hour} total loads - conduction: {conduction_cooling:.3f} kW, solar: {solar:.3f} kW, internal: {internal:.3f} kW")
-            
-            total_cooling = conduction_cooling + solar + internal + ventilation_cooling + infiltration_cooling
-            total_heating = max(conduction_heating + ventilation_heating + infiltration_heating - internal, 0)
-            if mode == "cooling":
-                total_heating = 0
-            elif mode == "heating":
-                total_cooling = 0
-            temp_loads.append({
-                "hour": hour,
-                "month": month,
-                "day": day,
-                "conduction_cooling": conduction_cooling,
-                "conduction_heating": conduction_heating,
-                "solar": solar,
-                "internal": internal,
-                "ventilation_cooling": ventilation_cooling,
-                "ventilation_heating": ventilation_heating,
-                "infiltration_cooling": infiltration_cooling,
-                "infiltration_heating": infiltration_heating,
-                "total_cooling": total_cooling,
-                "total_heating": total_heating,
-                "ground_temperature": ground_temp,
-                "solar_by_orientation": dict(solar_by_orientation),
-                "conduction_by_orientation": dict(conduction_by_orientation)
-            })
-        loads_by_day = defaultdict(list)
-        for load in temp_loads:
-            day_key = (load["month"], load["day"])
-            loads_by_day[day_key].append(load)
-        final_loads = []
-        for day_key, day_loads in loads_by_day.items():
-            cooling_hours = sum(1 for load in day_loads if load["total_cooling"] > 0)
-            heating_hours = sum(1 for load in day_loads if load["total_heating"] > 0)
-            for load in day_loads:
-                if cooling_hours > heating_hours:
-                    load["total_heating"] = 0
-                elif heating_hours > cooling_hours:
-                    load["total_cooling"] = 0
-                else:
-                    load["total_cooling"] = 0
-                    load["total_heating"] = 0
-                final_loads.append(load)
-        return final_loads
+                load["total_cooling"] = 0
+                load["total_heating"] = 0
+            final_loads.append(load)
+    return final_loads
 
 def make_pie(data: Dict[str, float], title: str) -> px.pie:
     """Create a Plotly pie chart from a dictionary of values."""