Update app/hvac_loads.py

app/hvac_loads.py

@@ -21,12 +21,16 @@ from utils.solar import SolarCalculations  # Import SolarCalculations for SHGC d
 from app.m_c_data import SAMPLE_MATERIALS, SAMPLE_FENESTRATIONS, DEFAULT_MATERIAL_PROPERTIES, DEFAULT_WINDOW_PROPERTIES
 import plotly.express as px
 import uuid
+import psychrolib
 run_id = str(uuid.uuid4())
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
+# Initialize psychrolib for SI units
+psychrolib.SetUnitSystem(psychrolib.SI)
+
 class AdaptiveComfortModel:
     @staticmethod
     def compute_daily_mean_temperatures(hourly_data: List[Dict]) -> List[Tuple[Tuple[int, int], float]]:
@@ -461,9 +465,34 @@ class TFMCalculations:
             logger.error(f"Error calculating internal load for hour {hour}: {str(e)}")
             return 0.0
 
+    @staticmethod
+    def calculate_enthalpy(temp_C: float, RH_percent: float, pressure_kPa: float = 101.325) -> float:
+        """Calculate air enthalpy (kJ/kg) using psychrometric properties."""
+        try:
+            # Clamp inputs to valid ranges
+            temp_C = max(-50.0, min(60.0, temp_C))
+            RH_percent = max(0.0, min(100.0, RH_percent))
+            pressure_kPa = max(50.0, min(120.0, pressure_kPa))
+            
+            # Convert pressure to Pa for psychrolib
+            pressure_Pa = pressure_kPa * 1000.0
+            
+            # Calculate humidity ratio (kg/kg)
+            W = psychrolib.GetHumRatioFromRelHum(temp_C, RH_percent / 100.0, pressure_Pa)
+            
+            # Calculate enthalpy (kJ/kg)
+            h = psychrolib.GetMoistAirEnthalpy(temp_C, W)
+            h = h / 1000.0  # Convert J/kg to kJ/kg
+            
+            logger.debug(f"Enthalpy calculated: temp={temp_C:.2f}°C, RH={RH_percent:.2f}%, pressure={pressure_kPa:.2f} kPa, h={h:.2f} kJ/kg")
+            return h
+        except Exception as e:
+            logger.error(f"Error calculating enthalpy: {str(e)}. Using default 50 kJ/kg.")
+            return 50.0  # Default enthalpy for 25°C, 50% RH
+
     @staticmethod
     def calculate_ventilation_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, hour: int, mode: str = "none") -> tuple[float, float]:
-        """Calculate ventilation load for heating and cooling in kW based on mode."""
+        """Calculate ventilation load (sensible and latent) for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
         delta_t = outdoor_temp - indoor_temp
@@ -475,8 +504,13 @@ class TFMCalculations:
         total_cooling_load = 0.0
         total_heating_load = 0.0
         air_density = 1.2  # kg/m³
-        specific_heat = 1000  # J/kg·K
+        specific_heat = 1.006  # kJ/kg·K
         is_weekend = False  # Simplified; determine from date in practice
+        climate_data = st.session_state.project_data.get("climate_data", {})
+        outdoor_rh = climate_data.get("hourly_data", [{}])[hour % 24].get("relative_humidity", 50.0)
+        indoor_rh = building_info.get("summer_indoor_design_rh" if mode == "cooling" else "winter_indoor_design_rh", 50.0)
+        altitude = climate_data.get("location", {}).get("elevation", 0.0)
+        pressure_kPa = 101.325 * (1 - 2.25577e-5 * altitude) ** 5.25588
 
         try:
             for system in internal_loads.get("ventilation", []):
@@ -485,36 +519,45 @@ class TFMCalculations:
                 system_type = system.get("system_type", "AirChanges/Hour")
                 system_area = system.get("area", area)
                 ventilation_flow = 0.0
+                fan_power = 0.0
 
                 if system_type == "AirChanges/Hour":
                     design_flow_rate = system.get("design_flow_rate", 1.0)  # L/s·m²
-                    ventilation_flow = design_flow_rate * system_area / 1000  # Convert L/s to m³/s
+                    ventilation_flow = min(max(design_flow_rate * system_area / 1000, 0.0), system_area * 0.05)  # m³/s, capped at 50 L/s·m²
                     if system.get("ventilation_type", "Natural") == "Mechanical":
                         fan_power = (system.get("fan_pressure_rise", 200.0) * ventilation_flow) / system.get("fan_efficiency", 0.7) / 1000  # kW
-                        total_cooling_load += fan_power * fraction
-                        logger.debug(f"Ventilation '{system.get('name', 'unknown')}': fan_power={fan_power:.3f} kW, fraction={fraction:.2f}")
-
                 elif system_type == "Wind and Stack Open Area":
                     opening_effectiveness = system.get("opening_effectiveness", 50.0) / 100
-                    # Assume simplified flow based on area and effectiveness
                     ventilation_flow = 0.001 * system_area * opening_effectiveness  # m³/s (placeholder)
-                
                 elif system_type in ["Balanced Flow", "Heat Recovery"]:
                     design_flow_rate = system.get("design_flow_rate", 1.0)  # L/s·m²
-                    ventilation_flow = design_flow_rate * system_area / 1000  # Convert L/s to m³/s
+                    ventilation_flow = min(max(design_flow_rate * system_area / 1000, 0.0), system_area * 0.05)  # m³/s
                     fan_power = (system.get("fan_pressure_rise", 200.0) * ventilation_flow) / system.get("fan_efficiency", 0.7) / 1000  # kW
-                    total_cooling_load += fan_power * fraction
                     if system_type == "Heat Recovery":
                         sensible_eff = system.get("sensible_effectiveness", 0.5)
                         delta_t = delta_t * (1 - sensible_eff)
-                        logger.debug(f"Heat Recovery '{system.get('name', 'unknown')}': sensible_eff={sensible_eff:.2f}, adjusted_delta_t={delta_t:.2f}")
 
-                load = ventilation_flow * air_density * specific_heat * delta_t * fraction / 1000  # kW
-                cooling_load = load if mode == "cooling" else 0
-                heating_load = -load if mode == "heating" else 0
+                # Calculate enthalpies
+                h_out = TFMCalculations.calculate_enthalpy(outdoor_temp, outdoor_rh, pressure_kPa)
+                h_in = TFMCalculations.calculate_enthalpy(indoor_temp, indoor_rh, pressure_kPa)
+
+                # Total load (kW)
+                total_load = ventilation_flow * air_density * (h_out - h_in) * fraction / 1000
+                # Sensible load (kW)
+                sensible_load = ventilation_flow * air_density * specific_heat * delta_t * fraction / 1000
+                # Latent load (kW)
+                latent_load = total_load - sensible_load
+
+                # Assign loads based on mode
+                cooling_load = (sensible_load + latent_load + fan_power) if mode == "cooling" and total_load > 0 else 0
+                heating_load = -(sensible_load + latent_load) if mode == "heating" and total_load < 0 else 0
                 total_cooling_load += cooling_load
                 total_heating_load += heating_load
-                logger.debug(f"Ventilation '{system.get('name', 'unknown')}': flow={ventilation_flow:.4f} m³/s, fraction={fraction:.2f}, cooling={cooling_load:.3f} kW, heating={heating_load:.3f} kW")
+
+                # Store sensible and latent components for UI
+                system["sensible_load"] = sensible_load
+                system["latent_load"] = latent_load
+                logger.debug(f"Ventilation '{system.get('name', 'unknown')}': flow={ventilation_flow:.4f} m³/s, fraction={fraction:.2f}, sensible={sensible_load:.3f} kW, latent={latent_load:.3f} kW, cooling={cooling_load:.3f} kW, heating={heating_load:.3f} kW")
 
             logger.info(f"Total ventilation load for hour {hour}: cooling={total_cooling_load:.3f} kW, heating={total_heating_load:.3f} kW")
             return total_cooling_load, total_heating_load
@@ -525,7 +568,7 @@ class TFMCalculations:
 
     @staticmethod
     def calculate_infiltration_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, hour: int, mode: str = "none") -> tuple[float, float]:
-        """Calculate infiltration load for heating and cooling in kW based on mode."""
+        """Calculate infiltration load (sensible and latent) for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
         delta_t = outdoor_temp - indoor_temp
@@ -537,10 +580,16 @@ class TFMCalculations:
         total_cooling_load = 0.0
         total_heating_load = 0.0
         air_density = 1.2  # kg/m³
-        specific_heat = 1000  # J/kg·K
+        specific_heat = 1.006  # kJ/kg·K
         building_height = building_info.get("building_height", 3.0)
         volume = area * building_height
         is_weekend = False  # Simplified; determine from date in practice
+        climate_data = st.session_state.project_data.get("climate_data", {})
+        wind_speed = climate_data.get("hourly_data", [{}])[hour % 24].get("wind_speed", 4.0)
+        outdoor_rh = climate_data.get("hourly_data", [{}])[hour % 24].get("relative_humidity", 50.0)
+        indoor_rh = building_info.get("summer_indoor_design_rh" if mode == "cooling" else "winter_indoor_design_rh", 50.0)
+        altitude = climate_data.get("location", {}).get("elevation", 0.0)
+        pressure_kPa = 101.325 * (1 - 2.25577e-5 * altitude) ** 5.25588
 
         try:
             for system in internal_loads.get("infiltration", []):
@@ -552,36 +601,50 @@ class TFMCalculations:
 
                 if system_type == "AirChanges/Hour":
                     ach = system.get("design_flow_rate", 0.3)
-                    infiltration_flow = ach * system_area * building_height / 3600  # m³/s
-                
+                    Q = ach * volume / 3600  # m³/s
+                    wind_coeff = 0.23  # LBL model coefficient
+                    ela = Q / (wind_coeff * max(wind_speed, 0.1) ** 2) if wind_speed > 0 else 0.0001 * system_area
+                    infiltration_flow = wind_coeff * ela * (wind_speed ** 2) * fraction
                 elif system_type == "Effective Leakage Area":
-                    ela = system.get("effective_air_leakage_area", 100.0) / 10000  # Convert cm² to m²
+                    ela = system.get("effective_air_leakage_area", 100.0) / 10000  # cm² to m²
                     stack_coeff = system.get("stack_coefficient", 0.0001)
                     wind_coeff = system.get("wind_coefficient", 0.0001)
                     delta_t_abs = abs(delta_t)
-                    wind_speed = 4.0  # m/s, assumed
                     Q_stack = stack_coeff * ela * (delta_t_abs ** 0.5)
                     Q_wind = wind_coeff * ela * (wind_speed ** 2)
-                    infiltration_flow = (Q_stack ** 2 + Q_wind ** 2) ** 0.5  # m³/s
-                
+                    infiltration_flow = ((Q_stack ** 2 + Q_wind ** 2) ** 0.5) * fraction
                 elif system_type == "Flow Coefficient":
-                    c = system.get("flow_coefficient", 0.0001)  # m³/s·Paⁿ
+                    c = system.get("flow_coefficient", 0.0001)
                     n = system.get("pressure_exponent", 0.6)
                     stack_coeff = system.get("stack_coefficient", 0.0001)
                     wind_coeff = system.get("wind_coefficient", 0.0001)
                     delta_t_abs = abs(delta_t)
-                    wind_speed = 4.0  # m/s, assumed
                     delta_p_stack = stack_coeff * delta_t_abs
                     delta_p_wind = wind_coeff * (wind_speed ** 2)
                     delta_p = (delta_p_stack ** 2 + delta_p_wind ** 2) ** 0.5
-                    infiltration_flow = c * (delta_p ** n) * system_area
-
-                load = infiltration_flow * air_density * specific_heat * delta_t * fraction / 1000  # kW
-                cooling_load = load if mode == "cooling" else 0
-                heating_load = -load if mode == "heating" else 0
+                    infiltration_flow = c * (delta_p ** n) * system_area * fraction
+
+                # Calculate enthalpies
+                h_out = TFMCalculations.calculate_enthalpy(outdoor_temp, outdoor_rh, pressure_kPa)
+                h_in = TFMCalculations.calculate_enthalpy(indoor_temp, indoor_rh, pressure_kPa)
+
+                # Total load (kW)
+                total_load = air_density * infiltration_flow * (h_out - h_in) / 1000
+                # Sensible load (kW)
+                sensible_load = air_density * infiltration_flow * specific_heat * delta_t / 1000
+                # Latent load (kW)
+                latent_load = total_load - sensible_load
+
+                # Assign loads based on mode
+                cooling_load = (sensible_load + latent_load) if mode == "cooling" and total_load > 0 else 0
+                heating_load = -(sensible_load + latent_load) if mode == "heating" and total_load < 0 else 0
                 total_cooling_load += cooling_load
                 total_heating_load += heating_load
-                logger.debug(f"Infiltration '{system.get('name', 'unknown')}': flow={infiltration_flow:.4f} m³/s, fraction={fraction:.2f}, cooling={cooling_load:.3f} kW, heating={heating_load:.3f} kW")
+
+                # Store sensible and latent components for UI
+                system["sensible_load"] = sensible_load
+                system["latent_load"] = latent_load
+                logger.debug(f"Infiltration '{system.get('name', 'unknown')}': flow={infiltration_flow:.4f} m³/s, fraction={fraction:.2f}, sensible={sensible_load:.3f} kW, latent={latent_load:.3f} kW, cooling={cooling_load:.3f} kW, heating={heating_load:.3f} kW")
 
             logger.info(f"Total infiltration load for hour {hour}: cooling={total_cooling_load:.3f} kW, heating={total_heating_load:.3f} kW")
             return total_cooling_load, total_heating_load
@@ -898,8 +961,21 @@ def display_hvac_results_ui(loads: List[Dict[str, Any]], run_id: str = "default"
         if peak_cooling:
             st.write(f"**Peak Cooling Load**: {peak_cooling['total_cooling']:.2f} kW")
             st.write(f"Occurred on: {peak_cooling['month']}/{peak_cooling['day']} at {peak_cooling['hour']}:00")
+            # Add ventilation and infiltration sensible/latent metrics
+            vent_sensible = sum(system.get("sensible_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("ventilation", []))
+            vent_latent = sum(system.get("latent_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("ventilation", []))
+            inf_sensible = sum(system.get("sensible_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("infiltration", []))
+            inf_latent = sum(system.get("latent_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("infiltration", []))
+            st.metric("Ventilation Sensible Cooling", f"{vent_sensible:.2f} kW")
+            st.metric("Ventilation Latent Cooling", f"{vent_latent:.2f} kW")
+            st.metric("Infiltration Sensible Cooling", f"{inf_sensible:.2f} kW")
+            st.metric("Infiltration Latent Cooling", f"{inf_latent:.2f} kW")
         else:
             st.write("**Peak Cooling Load**: 0.00 kW")
+            st.metric("Ventilation Sensible Cooling", "0.00 kW")
+            st.metric("Ventilation Latent Cooling", "0.00 kW")
+            st.metric("Infiltration Sensible Cooling", "0.00 kW")
+            st.metric("Infiltration Latent Cooling", "0.00 kW")
     
     with col2:
         st.subheader("Heating Equipment Sizing")
@@ -1394,18 +1470,20 @@ def display_hvac_loads_page():
 
                         # Store breakdown
                         cooling_breakdown = {
-                            "conduction": sum(load["conduction_cooling"] for load in cooling_loads),
-                            "solar": sum(load["solar"] for load in cooling_loads if load["total_cooling"] > 0),
-                            "internal": sum(load["internal"] for load in cooling_loads if load["total_cooling"] > 0),
-                            "ventilation": sum(load["ventilation_cooling"] for load in cooling_loads),
-                            "infiltration": sum(load["infiltration_cooling"] for load in cooling_loads)
+                            "Conduction": sum(load["conduction_cooling"] for load in cooling_loads),
+                            "Solar Gains": sum(load["solar"] for load in cooling_loads),
+                            "Internal": sum(load["internal"] for load in cooling_loads),
+                            "Ventilation Sensible": sum(system.get("sensible_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("ventilation", [])),
+                            "Ventilation Latent": sum(system.get("latent_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("ventilation", [])),
+                            "Infiltration Sensible": sum(system.get("sensible_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("infiltration", [])),
+                            "Infiltration Latent": sum(system.get("latent_load", 0.0) for system in st.session_state.project_data["internal_loads"].get("infiltration", []))
                         }
                         heating_breakdown = {
                             "conduction": sum(load["conduction_heating"] for load in heating_loads),
                             "ventilation": sum(load["ventilation_heating"] for load in heating_loads),
                             "infiltration": sum(load["infiltration_heating"] for load in heating_loads)
                         }
-                        st.session_state.project_data["hvac_loads"]["cooling"]["breakdown"] = cooling_breakdown
+                        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_component"] = cooling_breakdown
                         st.session_state.project_data["hvac_loads"]["heating"]["breakdown"] = heating_breakdown
 
                         # Display Results UI with unique run_id