Update app/hvac_loads.py

app/hvac_loads.py

@@ -801,7 +801,15 @@ class TFMCalculations:
         return final_loads
 
 def make_pie(data: Dict[str, float], title: str) -> px.pie:
-    """Create a Plotly pie chart from a dictionary of values."""
+    """Create a Plotly pie chart from a dictionary of values.
+    
+    Args:
+        data: Dictionary with keys as labels and values as magnitudes.
+        title: Title for the pie chart.
+    
+    Returns:
+        Plotly pie chart figure.
+    """
     fig = px.pie(
         names=list(data.keys()),
         values=list(data.values()),
@@ -811,41 +819,135 @@ def make_pie(data: Dict[str, float], title: str) -> px.pie:
     fig.update_traces(textinfo='percent+label', hoverinfo='label+percent+value')
     return fig
 
+@st.cache_data
+def compute_chart_data(_loads: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Compute and cache chart and breakdown data to avoid recalculation.
+    
+    Args:
+        _loads: List of dictionaries containing HVAC load data.
+    
+    Returns:
+        Dictionary containing precomputed data for charts and breakdowns.
+    """
+    cooling_loads = [load for load in _loads if load["total_cooling"] > 0]
+    heating_loads = [load for load in _loads if load["total_heating"] > 0]
+    
+    # Monthly summary
+    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"})
+    
+    # Cooling 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)
+    }
+    
+    # Heating 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)
+    }
+    
+    # Orientation breakdowns
+    orientation_solar = defaultdict(float)
+    orientation_conduction_cooling = defaultdict(float)
+    orientation_conduction_heating = 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_cooling[key] += value
+    for load in heating_loads:
+        for key, value in load["conduction_by_orientation"].items():
+            orientation_conduction_heating[key] += value
+    cooling_orientation_breakdown = {k: orientation_solar[k] + orientation_conduction_cooling[k] for k in set(orientation_solar) | set(orientation_conduction_cooling)}
+    heating_orientation_breakdown = {k: v for k, v in orientation_conduction_heating.items() if v > 0}
+    
+    # Peak loads
+    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
+    
+    return {
+        "monthly_df": monthly_df,
+        "cooling_breakdown": cooling_breakdown,
+        "heating_breakdown": heating_breakdown,
+        "cooling_orientation_breakdown": cooling_orientation_breakdown,
+        "heating_orientation_breakdown": heating_orientation_breakdown,
+        "peak_cooling": peak_cooling,
+        "peak_heating": peak_heating
+    }
+
+@st.cache_data
+def compute_table_data(_loads: List[Dict[str, Any]]) -> pd.DataFrame:
+    """Compute and cache DataFrame for hourly loads table.
+    
+    Args:
+        _loads: List of dictionaries containing HVAC load data.
+    
+    Returns:
+        Pandas DataFrame with hourly load data and orientation columns.
+    """
+    df = pd.DataFrame(_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}"])
+    
+    return df[columns]
+
 def display_hvac_results_ui(loads: List[Dict[str, Any]], run_id: str = "default"):
-    """Display HVAC load results with enhanced UI elements in a two-column format."""
+    """Display HVAC load results with enhanced UI elements in a two-column format.
+    
+    Args:
+        loads: List of dictionaries containing HVAC load data.
+        run_id: Unique identifier for the simulation run to ensure unique widget keys.
+    """
     st.subheader("HVAC Load Results")
     
+    # Compute cached data
+    chart_data = compute_chart_data(loads)
+    
     # First Row: Equipment Sizing (Two Columns)
     col1, col2 = st.columns(2)
     with col1:
         st.subheader("Cooling Equipment Sizing")
-        cooling_loads = [load for load in loads if load["total_cooling"] > 0]
-        peak_cooling = max(cooling_loads, key=lambda x: x["total_cooling"]) if cooling_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")
+        if chart_data["peak_cooling"]:
+            st.write(f"**Peak Cooling Load**: {chart_data['peak_cooling']['total_cooling']:.2f} kW")
+            st.write(f"Occurred on: {chart_data['peak_cooling']['month']}/{chart_data['peak_cooling']['day']} at {chart_data['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")
+        if chart_data["peak_heating"]:
+            st.write(f"**Peak Heating Load**: {chart_data['peak_heating']['total_heating']:.2f} kW")
+            st.write(f"Occurred on: {chart_data['peak_heating']['month']}/{chart_data['peak_heating']['day']} at {chart_data['peak_cooling']['hour']}:00")
         else:
             st.write("**Peak Heating Load**: 0.00 kW")
 
     # 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,
+        chart_data["monthly_df"],
         x="month",
         y=["Cooling", "Heating"],
         barmode="group",
@@ -854,87 +956,50 @@ def display_hvac_results_ui(loads: List[Dict[str, Any]], run_id: str = "default"
     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()
+    st.session_state.project_data["hvac_loads"]["monthly_summary"] = chart_data["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),
-            "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)
-        }
-        cooling_pie = make_pie({k: v for k, v in cooling_breakdown.items() if v > 0}, "Cooling Load Components")
+        cooling_pie = make_pie({k: v for k, v in chart_data["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
+        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_component"] = chart_data["cooling_breakdown"]
 
     with col4:
         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")
+        heating_pie = make_pie({k: v for k, v in chart_data["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
+        st.session_state.project_data["hvac_loads"]["heating"]["charts"]["pie_by_component"] = chart_data["heating_breakdown"]
 
     # 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:
-            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 Heat Gain by Orientation")
+        orientation_pie = make_pie({k: v for k, v in chart_data["cooling_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
+        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_orientation"] = chart_data["cooling_orientation_breakdown"]
 
     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")
+        orientation_pie = make_pie(chart_data["heating_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
+        st.session_state.project_data["hvac_loads"]["heating"]["charts"]["pie_by_orientation"] = chart_data["heating_orientation_breakdown"]
 
     # Fifth Row: Explore Hourly Loads (Single Column)
     st.subheader("Explore Hourly Loads")
-    df = pd.DataFrame(loads)
-    # 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())
+    table_df = compute_table_data(loads)
+    # Limit to first 100 rows to improve performance
+    st.dataframe(table_df.head(100))
     
-    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 = df[columns].to_csv(index=False)
-    st.download_button("Download Hourly Summary as CSV", data=csv, file_name="hourly_loads.csv")
+    # CSV Export with unique key
+    csv = table_df.to_csv(index=False)
+    st.download_button(
+        label="Download Hourly Summary as CSV",
+        data=csv,
+        file_name="hourly_loads.csv",
+        key=f"download_hvac_loads_{run_id}"
+    )
 
 def display_hvac_loads_page():
     """
@@ -946,7 +1011,6 @@ def display_hvac_loads_page():
         st.markdown("Configure and calculate HVAC loads for the building.")
 
         # Generate a unique run ID for this session
-        import uuid
         run_id = str(uuid.uuid4())
 
         # Check for existing results
@@ -957,7 +1021,6 @@ def display_hvac_loads_page():
             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.")
@@ -973,7 +1036,7 @@ def display_hvac_loads_page():
             "Latitude": climate_data.get("location", {}).get("latitude", 0.0),
             "Longitude": climate_data.get("location", {}).get("longitude", 0.0),
             "Elevation": climate_data.get("location", {}).get("elevation", 0.0),
-            "Time Zone": climate_data.get("location", {}).get("timezone", "UTC"),
+            "Time Zone": climate_data.get("location", {}).get("timezone", 0.0),
             "Ground Reflectivity": climate_data.get("ground_reflectivity", 0.2)
         }
         
@@ -1200,21 +1263,10 @@ def display_hvac_loads_page():
                         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
+                        # Store breakdown (cached function handles this, but store for consistency)
+                        chart_data = compute_chart_data(loads)
+                        st.session_state.project_data["hvac_loads"]["cooling"]["breakdown"] = chart_data["cooling_breakdown"]
+                        st.session_state.project_data["hvac_loads"]["heating"]["breakdown"] = chart_data["heating_breakdown"]
 
                         # Display Results UI with unique run_id
                         display_hvac_results_ui(loads, run_id=run_id)