Update app/hvac_loads.py

app/hvac_loads.py

@@ -801,15 +801,7 @@ 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.
-    
-    Args:
-        data: Dictionary with keys as labels and values as magnitudes.
-        title: Title for the pie chart.
-    
-    Returns:
-        Plotly pie chart figure.
-    """
+    """Create a Plotly pie chart from a dictionary of values."""
     fig = px.pie(
         names=list(data.keys()),
         values=list(data.values()),
@@ -819,135 +811,41 @@ 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.
-    
-    Args:
-        loads: List of dictionaries containing HVAC load data.
-        run_id: Unique identifier for the simulation run to ensure unique widget keys.
-    """
+    """Display HVAC load results with enhanced UI elements in a two-column format."""
     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")
-        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")
+        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")
         else:
             st.write("**Peak Cooling Load**: 0.00 kW")
     
     with col2:
         st.subheader("Heating Equipment Sizing")
-        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")
+        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")
 
     # 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(
-        chart_data["monthly_df"],
+        monthly_df,
         x="month",
         y=["Cooling", "Heating"],
         barmode="group",
@@ -956,50 +854,87 @@ 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"] = chart_data["monthly_df"].to_dict()
+    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_pie = make_pie({k: v for k, v in chart_data["cooling_breakdown"].items() if v > 0}, "Cooling Load Components")
+        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")
         st.plotly_chart(cooling_pie)
-        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_component"] = chart_data["cooling_breakdown"]
+        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_component"] = cooling_breakdown
 
     with col4:
         st.subheader("Heating Load Breakdown")
-        heating_pie = make_pie({k: v for k, v in chart_data["heating_breakdown"].items() if v > 0}, "Heating Load Components")
+        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"] = chart_data["heating_breakdown"]
+        st.session_state.project_data["hvac_loads"]["heating"]["charts"]["pie_by_component"] = 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_pie = make_pie({k: v for k, v in chart_data["cooling_orientation_breakdown"].items() if v > 0}, "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")
         st.plotly_chart(orientation_pie)
-        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_orientation"] = chart_data["cooling_orientation_breakdown"]
+        st.session_state.project_data["hvac_loads"]["cooling"]["charts"]["pie_by_orientation"] = orientation_breakdown
 
     with col6:
         st.subheader("Heating Heat Gain by Orientation")
-        orientation_pie = make_pie(chart_data["heating_orientation_breakdown"], "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"] = chart_data["heating_orientation_breakdown"]
+        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")
-    table_df = compute_table_data(loads)
-    # Limit to first 100 rows to improve performance
-    st.dataframe(table_df.head(100))
+    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())
     
-    # 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}"
-    )
+    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")
 
 def display_hvac_loads_page():
     """
@@ -1011,6 +946,7 @@ 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
@@ -1021,6 +957,7 @@ 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.")
@@ -1036,7 +973,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", 0.0),
+            "Time Zone": climate_data.get("location", {}).get("timezone", "UTC"),
             "Ground Reflectivity": climate_data.get("ground_reflectivity", 0.2)
         }
         
@@ -1263,10 +1200,21 @@ 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 (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"]
+                        # 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 with unique run_id
                         display_hvac_results_ui(loads, run_id=run_id)