Update app/hvac_loads.py

app/hvac_loads.py

@@ -19,6 +19,7 @@ import math
 from utils.ctf_calculations import CTFCalculator, ComponentType, CTFCoefficients
 from utils.solar import SolarCalculations  # Import SolarCalculations for SHGC data
 from app.m_c_data import SAMPLE_MATERIALS, SAMPLE_FENESTRATIONS, DEFAULT_MATERIAL_PROPERTIES, DEFAULT_WINDOW_PROPERTIES
+import plotly.express as px
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -68,6 +69,27 @@ class AdaptiveComfortModel:
             setpoints[key] = (t_min + t_max) / 2
         return setpoints
 
+def classify_azimuth(azimuth: float) -> str:
+    """Classify azimuth angle into cardinal directions."""
+    azimuth = azimuth % 360
+    if 337.5 <= azimuth or azimuth < 22.5:
+        return "N"
+    elif 22.5 <= azimuth < 67.5:
+        return "NE"
+    elif 67.5 <= azimuth < 112.5:
+        return "E"
+    elif 112.5 <= azimuth < 157.5:
+        return "SE"
+    elif 157.5 <= azimuth < 202.5:
+        return "S"
+    elif 202.5 <= azimuth < 247.5:
+        return "SW"
+    elif 247.5 <= azimuth < 292.5:
+        return "W"
+    elif 292.5 <= azimuth < 337.5:
+        return "NW"
+    return "N"
+
 class TFMCalculations:
     @staticmethod
     def get_component_type(component: Dict[str, Any]) -> ComponentType:
@@ -689,6 +711,8 @@ class TFMCalculations:
             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)
@@ -701,8 +725,13 @@ class TFMCalculations:
                 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")
-                        conduction_cooling += cool_load
                         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")
                 
@@ -713,6 +742,10 @@ class TFMCalculations:
                 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")
@@ -742,7 +775,9 @@ class TFMCalculations:
                 "infiltration_heating": infiltration_heating,
                 "total_cooling": total_cooling,
                 "total_heating": total_heating,
-                "ground_temperature": ground_temp  # Included for future enhancement
+                "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:
@@ -763,6 +798,116 @@ class TFMCalculations:
                 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."""
+    fig = px.pie(
+        names=list(data.keys()),
+        values=list(data.values()),
+        title=title,
+        hole=0.4
+    )
+    fig.update_traces(textinfo='percent+label', hoverinfo='label+percent+value')
+    return fig
+
+def display_hvac_results_ui(loads: List[Dict[str, Any]]):
+    """Display HVAC load results with enhanced UI elements."""
+    st.subheader("HVAC Load Results")
+    
+    # Monthly Load Graph
+    st.subheader("Monthly Heating and Cooling Load")
+    monthly_df = pd.DataFrame(loads).groupby("month").agg({
+        "total_cooling": "sum",
+        "total_heating": "sum"
+    }).reset_index()
+    monthly_df = monthly_df.rename(columns={"total_cooling": "Cooling", "total_heating": "Heating"})
+    fig = px.line(monthly_df, x="month", y=["Cooling", "Heating"], markers=True, title="Monthly Load Summary")
+    fig.update_xaxes(title="Month", tickvals=list(range(1, 13)))
+    fig.update_yaxes(title="Load (kW)")
+    st.plotly_chart(fig)
+    st.session_state.project_data["hvac_loads"]["monthly_summary"] = monthly_df.to_dict()
+
+    # Two-Column Layout for Equipment Sizing and Pie Charts
+    col1, col2 = st.columns(2)
+    with col1:
+        st.subheader("Equipment Sizing")
+        cooling_loads = [load for load in loads if load["total_cooling"] > 0]
+        heating_loads = [load for load in loads if load["total_heating"] > 0]
+        peak_cooling = max(cooling_loads, key=lambda x: x["total_cooling"]) if cooling_loads else None
+        peak_heating = max(heating_loads, key=lambda x: x["total_heating"]) if heating_loads else None
+        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")
+        else:
+            st.write("**Peak Cooling Load**: 0.00 kW")
+        if peak_heating:
+            st.write(f"**Peak Heating Load**: {peak_heating['total_heating']:.2f} kW")
+            st.write(f"Occurred on: {peak_heating['month']}/{peak_heating['day']} at {peak_heating['hour']}:00")
+        else:
+            st.write("**Peak Heating Load**: 0.00 kW")
+
+    with col2:
+        st.subheader("Cooling Load Breakdown")
+        cooling_breakdown = {
+            "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": sum(load["ventilation_cooling"] for load in cooling_loads),
+            "Infiltration": sum(load["infiltration_cooling"] for load in cooling_loads)
+        }
+        st.markdown("**Conduction**", help="Heat transfer through building envelope materials.")
+        st.markdown("**Solar Gains**", help="Radiative heat gains from sun through surfaces and windows.")
+        st.markdown("**Ventilation**", help="Loads due to outdoor air entering through ventilation systems.")
+        st.markdown("**Infiltration**", help="Loads due to unintended air leakage through the building envelope.")
+        st.markdown("**Internal**", help="Heat gains from occupants, lighting, and equipment inside the building.")
+        cooling_pie = make_pie({k: v for k, v in cooling_breakdown.items() if v > 0}, "Cooling Load Components")
+        st.plotly_chart(cooling_pie)
+        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_component"] = cooling_breakdown
+
+    # Second Row for Heating and Orientation Breakdown
+    col3, col4 = st.columns(2)
+    with col3:
+        st.subheader("Heating Load Breakdown")
+        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)
+        }
+        heating_pie = make_pie({k: v for k, v in heating_breakdown.items() if v > 0}, "Heating Load Components")
+        st.plotly_chart(heating_pie)
+        st.session_state.project_data["hvac_loads"]["heating"]["charts"]["pie_by_component"] = heating_breakdown
+
+    with col4:
+        st.subheader("Cooling Load by Orientation")
+        orientation_solar = defaultdict(float)
+        orientation_conduction = defaultdict(float)
+        for load in cooling_loads:
+            for key, value in load["solar_by_orientation"].items():
+                orientation_solar[key] += value
+            for key, value in load["conduction_by_orientation"].items():
+                orientation_conduction[key] += value
+        orientation_breakdown = {k: orientation_solar[k] + orientation_conduction[k] for k in set(orientation_solar) | set(orientation_conduction)}
+        orientation_pie = make_pie({k: v for k, v in orientation_breakdown.items() if v > 0}, "Cooling Load by Orientation/Component")
+        st.plotly_chart(orientation_pie)
+        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_orientation"] = orientation_breakdown
+
+    # Interactive Filtering
+    st.subheader("Explore Hourly Loads")
+    df = pd.DataFrame(loads)
+    col5, col6 = st.columns(2)
+    with col5:
+        selected_month = st.selectbox("Select Month", sorted(df["month"].unique()), key="filter_month")
+    with col6:
+        selected_day = st.selectbox("Select Day", sorted(df[df["month"] == selected_month]["day"].unique()), key="filter_day")
+    filtered_df = df[(df["month"] == selected_month) & (df["day"] == selected_day)]
+    st.dataframe(filtered_df[[
+        "hour", "total_cooling", "total_heating", "conduction_cooling", "solar", "internal",
+        "ventilation_cooling", "infiltration_cooling", "ventilation_heating", "infiltration_heating"
+    ]])
+    
+    # CSV Export
+    csv = filtered_df.to_csv(index=False)
+    st.download_button("Download Hourly Summary as CSV", data=csv, file_name=f"hourly_loads_{selected_month}_{selected_day}.csv")
+
 def display_hvac_loads_page():
     """
     Display the HVAC Loads page in the Streamlit application.
@@ -966,93 +1111,65 @@ def display_hvac_loads_page():
         # Calculate HVAC Loads
         if st.button("Calculate HVAC Loads"):
             try:
-                components = st.session_state.project_data["components"]
-                hourly_data = st.session_state.project_data["climate_data"]["hourly_data"]
-                indoor_conditions = st.session_state.project_data["indoor_conditions"]
-                internal_loads = st.session_state.project_data["internal_loads"]
-                building_info = st.session_state.project_data["building_info"]
-                sim_period = st.session_state.project_data["sim_period"]
-                hvac_settings = st.session_state.project_data["hvac_settings"]
-
-                if not hourly_data:
-                    st.error("No climate data available. Please configure climate data first.")
-                    logger.error("HVAC calculation failed: No climate data available")
-                    return
-                elif not any(comp_list for comp_list in components.values()):
-                    st.error("No building components defined. Please configure components first.")
-                    logger.error("HVAC calculation failed: No building components defined")
-                    return
-                else:
-                    loads = TFMCalculations.calculate_tfm_loads(
-                        components=components,
-                        hourly_data=hourly_data,
-                        indoor_conditions=indoor_conditions,
-                        internal_loads=internal_loads,
-                        building_info=building_info,
-                        sim_period=sim_period,
-                        hvac_settings=hvac_settings
-                    )
-
-                    # Update session state with results
-                    cooling_loads = [load for load in loads if load["total_cooling"] > 0]
-                    heating_loads = [load for load in loads if load["total_heating"] > 0]
-                    st.session_state.project_data["hvac_loads"]["cooling"]["hourly"] = cooling_loads
-                    st.session_state.project_data["hvac_loads"]["heating"]["hourly"] = heating_loads
-                    st.session_state.project_data["hvac_loads"]["cooling"]["peak"] = max([load["total_cooling"] for load in cooling_loads], default=0)
-                    st.session_state.project_data["hvac_loads"]["heating"]["peak"] = max([load["total_heating"] for load in heating_loads], default=0)
-
-                    # 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)
-                    }
-                    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"]["heating"]["breakdown"] = heating_breakdown
-
-                    # Display Results
-                    st.subheader("HVAC Load Results")
-                    st.write(f"Peak Cooling Load: {st.session_state.project_data['hvac_loads']['cooling']['peak']:.2f} kW")
-                    st.write(f"Peak Heating Load: {st.session_state.project_data['hvac_loads']['heating']['peak']:.2f} kW")
-
-                    # Display Breakdown
-                    st.subheader("Cooling Load Breakdown")
-                    for key, value in cooling_breakdown.items():
-                        st.write(f"{key.capitalize()}: {value:.2f} kW")
-                    st.subheader("Heating Load Breakdown")
-                    for key, value in heating_breakdown.items():
-                        st.write(f"{key.capitalize()}: {value:.2f} kW")
-
-                    # Optional: Display Hourly Loads Table in Debug Mode
-                    if st.session_state.debug_mode:
-                        st.subheader("Hourly Loads (Debug Mode)")
-                        hourly_df = []
-                        for load in loads:
-                            hourly_df.append({
-                                "Month": load["month"],
-                                "Day": load["day"],
-                                "Hour": load["hour"],
-                                "Total Cooling (kW)": load["total_cooling"],
-                                "Total Heating (kW)": load["total_heating"],
-                                "Conduction Cooling (kW)": load["conduction_cooling"],
-                                "Solar (kW)": load["solar"],
-                                "Internal (kW)": load["internal"],
-                                "Ventilation Cooling (kW)": load["ventilation_cooling"],
-                                "Infiltration Cooling (kW)": load["infiltration_cooling"],
-                                "Ventilation Heating (kW)": load["ventilation_heating"],
-                                "Infiltration Heating (kW)": load["infiltration_heating"]
-                            })
-                        st.dataframe(hourly_df)
-
-                    st.success("HVAC loads calculated successfully.")
-                    logger.info("HVAC loads calculated and stored in session state")
+                with st.spinner("Running simulation... this may take up to a minute depending on data size."):
+                    components = st.session_state.project_data["components"]
+                    hourly_data = st.session_state.project_data["climate_data"]["hourly_data"]
+                    indoor_conditions = st.session_state.project_data["indoor_conditions"]
+                    internal_loads = st.session_state.project_data["internal_loads"]
+                    building_info = st.session_state.project_data["building_info"]
+                    sim_period = st.session_state.project_data["sim_period"]
+                    hvac_settings = st.session_state.project_data["hvac_settings"]
+
+                    if not hourly_data:
+                        st.error("No climate data available. Please configure climate data first.")
+                        logger.error("HVAC calculation failed: No climate data available")
+                        return
+                    elif not any(comp_list for comp_list in components.values()):
+                        st.error("No building components defined. Please configure components first.")
+                        logger.error("HVAC calculation failed: No building components defined")
+                        return
+                    else:
+                        loads = TFMCalculations.calculate_tfm_loads(
+                            components=components,
+                            hourly_data=hourly_data,
+                            indoor_conditions=indoor_conditions,
+                            internal_loads=internal_loads,
+                            building_info=building_info,
+                            sim_period=sim_period,
+                            hvac_settings=hvac_settings
+                        )
+
+                        # Update session state with results
+                        cooling_loads = [load for load in loads if load["total_cooling"] > 0]
+                        heating_loads = [load for load in loads if load["total_heating"] > 0]
+                        st.session_state.project_data["hvac_loads"]["cooling"]["hourly"] = cooling_loads
+                        st.session_state.project_data["hvac_loads"]["heating"]["hourly"] = heating_loads
+                        st.session_state.project_data["hvac_loads"]["cooling"]["peak"] = max([load["total_cooling"] for load in cooling_loads], default=0)
+                        st.session_state.project_data["hvac_loads"]["heating"]["peak"] = max([load["total_heating"] for load in heating_loads], default=0)
+                        st.session_state.project_data["hvac_loads"]["cooling"]["charts"] = {}
+                        st.session_state.project_data["hvac_loads"]["heating"]["charts"] = {}
+
+                        # 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)
+                        }
+                        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"]["heating"]["breakdown"] = heating_breakdown
+
+                        # Display Results UI
+                        display_hvac_results_ui(loads)
+
+                        st.success("HVAC loads calculated successfully.")
+                        logger.info("HVAC loads calculated and stored in session state")
 
             except Exception as e:
                 st.error(f"Error calculating HVAC loads: {str(e)}")