Update app/hvac_loads.py

app/hvac_loads.py

@@ -810,42 +810,53 @@ def make_pie(data: Dict[str, float], title: str) -> px.pie:
     return fig
 
 def display_hvac_results_ui(loads: List[Dict[str, Any]]):
-    """Display HVAC load results with enhanced UI elements."""
+    """Display HVAC load results with enhanced UI elements in a two-column format."""
     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
+    # First Row: Equipment Sizing (Two Columns)
     col1, col2 = st.columns(2)
     with col1:
-        st.subheader("Equipment Sizing")
+        st.subheader("Cooling 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")
+    
+    with col2:
+        st.subheader("Heating Equipment Sizing")
+        heating_loads = [load for load in loads if load["total_heating"] > 0]
+        peak_heating = max(heating_loads, key=lambda x: x["total_heating"]) if heating_loads else None
         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:
+    # Second Row: Monthly Loads Graph (Single Column)
+    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.bar(
+        monthly_df,
+        x="month",
+        y=["Cooling", "Heating"],
+        barmode="group",
+        title="Monthly Load Summary"
+    )
+    fig.update_xaxes(title="Month", tickvals=list(range(1, 13)))
+    fig.update_yaxes(title="Load (kW)")
+    st.plotly_chart(fig, use_container_width=True)
+    st.session_state.project_data["hvac_loads"]["monthly_summary"] = monthly_df.to_dict()
+
+    # Third Row: Load Breakdown (Two Columns)
+    col3, col4 = st.columns(2)
+    with col3:
         st.subheader("Cooling Load Breakdown")
         cooling_breakdown = {
             "Conduction": sum(load["conduction_cooling"] for load in cooling_loads),
@@ -854,18 +865,11 @@ def display_hvac_results_ui(loads: List[Dict[str, Any]]):
             "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:
+    with col4:
         st.subheader("Heating Load Breakdown")
         heating_breakdown = {
             "Conduction": sum(load["conduction_heating"] for load in heating_loads),
@@ -876,8 +880,10 @@ def display_hvac_results_ui(loads: List[Dict[str, Any]]):
         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")
+    # Fourth Row: Heat Gain by Orientation (Two Columns)
+    col5, col6 = st.columns(2)
+    with col5:
+        st.subheader("Cooling Heat Gain by Orientation")
         orientation_solar = defaultdict(float)
         orientation_conduction = defaultdict(float)
         for load in cooling_loads:
@@ -886,38 +892,71 @@ def display_hvac_results_ui(loads: List[Dict[str, Any]]):
             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")
+        orientation_pie = make_pie({k: v for k, v in orientation_breakdown.items() if v > 0}, "Cooling Heat Gain by Orientation")
         st.plotly_chart(orientation_pie)
         st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_orientation"] = orientation_breakdown
 
-    # Interactive Filtering
+    with col6:
+        st.subheader("Heating Heat Gain by Orientation")
+        orientation_conduction = defaultdict(float)
+        for load in heating_loads:
+            for key, value in load["conduction_by_orientation"].items():
+                orientation_conduction[key] += value
+        orientation_breakdown = {k: v for k, v in orientation_conduction.items() if v > 0}
+        orientation_pie = make_pie(orientation_breakdown, "Heating Heat Gain by Orientation")
+        st.plotly_chart(orientation_pie)
+        st.session_state.project_data["hvac_loads"]["heating"]["charts"]["pie_by_orientation"] = orientation_breakdown
+
+    # Fifth Row: Explore Hourly Loads (Single Column)
     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"
-    ]])
+    # Flatten orientation-based loads
+    unique_orientations = set()
+    for load in loads:
+        unique_orientations.update(load["solar_by_orientation"].keys())
+        unique_orientations.update(load["conduction_by_orientation"].keys())
+    
+    columns = [
+        "month", "day", "hour",
+        "total_cooling", "total_heating",
+        "conduction_cooling", "solar", "internal",
+        "ventilation_cooling", "infiltration_cooling",
+        "ventilation_heating", "infiltration_heating"
+    ]
+    for orient in sorted(unique_orientations):
+        df[f"solar_{orient}"] = df["solar_by_orientation"].apply(lambda x: x.get(orient, 0.0))
+        df[f"conduction_{orient}"] = df["conduction_by_orientation"].apply(lambda x: x.get(orient, 0.0))
+        columns.extend([f"solar_{orient}", f"conduction_{orient}"])
+    
+    st.dataframe(df[columns])
     
     # 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")
+    csv = df[columns].to_csv(index=False)
+    st.download_button("Download Hourly Summary as CSV", data=csv, file_name="hourly_loads.csv")
 
 def display_hvac_loads_page():
     """
     Display the HVAC Loads page in the Streamlit application.
-    Allows users to configure location, simulation period, indoor conditions,
-    calculates HVAC loads using TFMCalculations, and displays results.
+    Checks for existing results in session state before recalculating.
     """
     try:
         st.header("HVAC Loads")
         st.markdown("Configure and calculate HVAC loads for the building.")
 
+        # Check for existing results
+        if (st.session_state.project_data.get("hvac_loads", {}).get("cooling", {}).get("hourly") or
+            st.session_state.project_data.get("hvac_loads", {}).get("heating", {}).get("hourly")):
+            loads = []
+            cooling_loads = st.session_state.project_data["hvac_loads"]["cooling"].get("hourly", [])
+            heating_loads = st.session_state.project_data["hvac_loads"]["heating"].get("hourly", [])
+            loads.extend(cooling_loads)
+            loads.extend(heating_loads)
+            # Sort loads by month, day, hour to ensure consistent display
+            loads = sorted(loads, key=lambda x: (x["month"], x["day"], x["hour"]))
+            if loads:
+                st.info("Displaying previously calculated HVAC load results.")
+                display_hvac_results_ui(loads)
+
         # Location Information
         st.subheader("Location Information")
         climate_data = st.session_state.project_data["climate_data"]