Update data/calculation.py

data/calculation.py

@@ -14,8 +14,8 @@ from data.internal_loads import PEOPLE_ACTIVITY_LEVELS, DIVERSITY_FACTORS, LIGHT
 from datetime import datetime
 from collections import defaultdict
 import logging
-from utils.ctf_calculations import CTFCalculator, ComponentType, CTFCoefficients
-from utils.solar import SolarCalculations
+import streamlit as st
+import plotly.graph_objects as go
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -34,16 +34,7 @@ class TFMCalculations:
         if mode == "heating" and delta_t >= 0:
             return 0, 0
 
-        # For windows and skylights, use U-value directly (CTF coefficients are zero)
-        if component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
-            load = component.u_value * component.area * delta_t
-            cooling_load = load / 1000 if mode == "cooling" else 0
-            heating_load = -load / 1000 if mode == "heating" else 0
-            logger.info(f"Conduction load for {component.component_type} {getattr(component, 'id', 'unknown_component')} "
-                        f"at hour {hour}: cooling={cooling_load:.2f} kW, heating={heating_load:.2f} kW (U={component.u_value}, A={component.area}, ΔT={delta_t:.2f})")
-            return cooling_load, heating_load
-
-        # For other components, use CTFCalculator
+        # Get CTF coefficients using CTFCalculator
         ctf = CTFCalculator.calculate_ctf_coefficients(component)
         
         # Initialize history terms (simplified: assume steady-state history for demonstration)
@@ -55,8 +46,6 @@ class TFMCalculations:
             # Note: F terms require flux history, omitted here for simplicity
         cooling_load = load / 1000 if mode == "cooling" else 0
         heating_load = -load / 1000 if mode == "heating" else 0
-        logger.info(f"Conduction load for {component.component_type} {getattr(component, 'id', 'unknown_component')} "
-                    f"at hour {hour}: cooling={cooling_load:.2f} kW, heating={heating_load:.2f} kW (CTF Y[0]={ctf.Y[0] if ctf.Y else 0})")
         return cooling_load, heating_load
 
     @staticmethod
@@ -210,70 +199,30 @@ class TFMCalculations:
         operating_periods = hvac_settings.get("operating_hours", [{"start": 8, "end": 18}])
         area = building_info.get("floor_area", 100.0)
         
-        # Validate inputs
-        if not filtered_data:
-            logger.warning("No filtered hourly data available. Returning empty loads.")
-            return []
-        
-        required_fields = ["global_horizontal_radiation", "dry_bulb", "month", "day", "hour"]
-        for data in filtered_data:
-            missing = [field for field in required_fields if field not in data]
-            if missing:
-                logger.warning(f"Missing fields {missing} in hourly data for {data.get('month')}/{data.get('day')}/{data.get('hour')}")
-        
-        # Validate fenestration components
-        fenestration_count = 0
-        for comp_type in ['windows', 'skylights']:
-            comp_list = components.get(comp_type, [])
-            fenestration_count += len(comp_list)
-            for comp in comp_list:
-                comp_id = getattr(comp, 'id', 'unknown_component')
-                if not hasattr(comp, 'area') or comp.area <= 0:
-                    logger.warning(f"Component {comp_id} ({comp_type}) has invalid area: {getattr(comp, 'area', 'None')}")
-                if not hasattr(comp, 'shgc') or comp.shgc <= 0:
-                    logger.warning(f"Component {comp_id} ({comp_type}) has invalid SHGC: {getattr(comp, 'shgc', 'None')}")
-                if not hasattr(comp, 'u_value') or comp.u_value <= 0:
-                    logger.warning(f"Component {comp_id} ({comp_type}) has invalid U-value: {getattr(comp, 'u_value', 'None')}")
-                if not hasattr(comp, 'facade') or comp.facade not in ['A', 'B', 'C', 'D']:
-                    logger.warning(f"Component {comp_id} ({comp_type}) has invalid facade: {getattr(comp, 'facade', 'None')}")
-                if not hasattr(comp, 'id') or not comp.id:
-                    logger.warning(f"Component {comp_type} missing id. Assigning temporary id.")
-                    comp.id = f"{comp_type}_{id(comp)}"
-        logger.info(f"Number of fenestration components (windows/skylights): {fenestration_count}")
-        if fenestration_count == 0:
-            logger.warning("No windows or skylights defined. Solar load will be 0.")
-
-        # Validate building_info
-        climate_data = building_info.get("climate_data", {})
-        for field in ["latitude", "longitude", "timezone"]:
-            if field not in climate_data:
-                logger.warning(f"Missing {field} in building_info.climate_data. Using default 0.0.")
-                climate_data[field] = 0.0
-        if "ground_reflectivity" not in building_info:
-            logger.warning("Missing ground_reflectivity in building_info. Using default 0.2.")
-            building_info["ground_reflectivity"] = 0.2
-
-        # Pre-calculate CTF coefficients for non-fenestration components
-        for comp_type, comp_list in components.items():
-            if comp_type in ['windows', 'skylights']:
-                continue
+        # Pre-calculate CTF coefficients for all components using CTFCalculator
+        for comp_list in components.values():
             for comp in comp_list:
                 comp.ctf = CTFCalculator.calculate_ctf_coefficients(comp)
 
         # Calculate solar parameters
+        climate_data = building_info.get("climate_data", {})
+        ground_reflectivity = building_info.get("ground_reflectivity", 0.2)
         solar_results = SolarCalculations.calculate_solar_parameters(
             hourly_data=filtered_data,
             latitude=climate_data.get("latitude", 0.0),
             longitude=climate_data.get("longitude", 0.0),
             timezone=climate_data.get("timezone", 0.0),
-            ground_reflectivity=building_info.get("ground_reflectivity", 0.2),
+            ground_reflectivity=ground_reflectivity,
             components=components
         )
 
         # Create a dictionary for quick lookup of solar results by hour
         solar_results_by_hour = {(res["month"], res["day"], res["hour"]): res for res in solar_results}
-        if not solar_results:
-            logger.warning("No solar results returned. Check GHI > 0 and component data.")
+
+        # Log presence of fenestration components
+        fenestration_count = sum(len(comp_list) for comp_type, comp_list in components.items() 
+                                if comp_type in ['windows', 'skylights'])
+        logger.info(f"Number of fenestration components (windows/skylights): {fenestration_count}")
 
         for hour_data in filtered_data:
             hour = hour_data["hour"]
@@ -292,43 +241,40 @@ class TFMCalculations:
                     break
             # Determine mode based on temperature threshold (18°C)
             mode = "none" if abs(outdoor_temp - 18) < 0.01 else "cooling" if outdoor_temp > 18 else "heating"
-            solar_key = (hour_data["month"], hour_data["day"], hour)
-            solar_result_hour = solar_results_by_hour.get(solar_key, {})
-            if is_operating:
+            if is_operating and mode == "cooling":
                 for comp_type, comp_list in components.items():
                     for comp in comp_list:
                         # Get solar result for this component and hour
-                        comp_id = getattr(comp, 'id', 'unknown_component')
-                        solar_result = next((res for res in solar_result_hour.get("component_results", []) 
-                                             if res["component_id"] == comp_id), None)
+                        solar_key = (hour_data["month"], hour_data["day"], hour)
+                        solar_result = next((res for res in solar_results_by_hour.get(solar_key, {}).get("component_results", []) 
+                                             if res["component_id"] == getattr(comp, 'id', 'unknown_component')), None)
                         sol_air_temp = solar_result.get("sol_air_temp") if solar_result else None
-                        # Calculate conduction load
-                        if mode == "cooling":
-                            cool_load, _ = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, sol_air_temp, mode="cooling")
-                            conduction_cooling += cool_load
-                        elif mode == "heating":
-                            _, heat_load = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, sol_air_temp, mode="heating")
-                            conduction_heating += heat_load
-                        # Add solar heat gain for windows and skylights if available
+                        cool_load, _ = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, sol_air_temp, mode="cooling")
+                        conduction_cooling += cool_load
                         if solar_result and comp.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
                             solar_heat_gain = solar_result.get("solar_heat_gain", 0)
-                            if solar_heat_gain > 0:
-                                solar += solar_heat_gain
-                                logger.info(f"Adding solar heat gain for component {comp_id} "
-                                            f"at {hour_data['month']}/{hour_data['day']}/{hour}: {solar_heat_gain:.2f} kW")
-                            else:
-                                logger.info(f"No solar heat gain for component {comp_id} "
-                                            f"at {hour_data['month']}/{hour_data['day']}/{hour}")
+                            solar += solar_heat_gain
+                            logger.info(f"Adding solar heat gain for component {getattr(comp, 'id', 'unknown_component')} "
+                                        f"at {hour_data['month']}/{hour_data['day']}/{hour}: {solar_heat_gain:.2f} kW")
                 logger.info(f"Total solar load for {hour_data['month']}/{hour_data['day']}/{hour}: {solar:.2f} kW")
                 internal = TFMCalculations.calculate_internal_load(internal_loads, hour, max([p["end"] - p["start"] for p in operating_periods]), area)
-                if mode == "cooling":
-                    ventilation_cooling, _ = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
-                    infiltration_cooling, _ = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
-                elif mode == "heating":
-                    _, ventilation_heating = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
-                    _, infiltration_heating = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
-            else:  # not is_operating
-                internal = 0  # No internal loads when outside operating hours
+                ventilation_cooling, _ = TFMCalculations.calculate_ventilation_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
+                infiltration_cooling, _ = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="cooling")
+            elif is_operating and mode == "heating":
+                for comp_type, comp_list in components.items():
+                    for comp in comp_list:
+                        # Get solar result for this component and hour
+                        solar_key = (hour_data["month"], hour_data["day"], hour)
+                        solar_result = next((res for res in solar_results_by_hour.get(solar_key, {}).get("component_results", []) 
+                                             if res["component_id"] == getattr(comp, 'id', 'unknown_component')), None)
+                        sol_air_temp = solar_result.get("sol_air_temp") if solar_result else None
+                        _, heat_load = TFMCalculations.calculate_conduction_load(comp, outdoor_temp, indoor_temp, hour, sol_air_temp, mode="heating")
+                        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, mode="heating")
+                _, infiltration_heating = TFMCalculations.calculate_infiltration_load(internal_loads, outdoor_temp, indoor_temp, area, building_info, mode="heating")
+            else:  # mode == "none" or not is_operating
+                internal = 0  # No internal loads when no heating or cooling is needed or outside operating hours
             # Calculate total loads, subtracting internal load for heating
             total_cooling = conduction_cooling + solar + internal + ventilation_cooling + infiltration_cooling
             total_heating = max(conduction_heating + ventilation_heating + infiltration_heating - internal, 0)
@@ -372,4 +318,95 @@ class TFMCalculations:
                     load["total_cooling"] = 0
                     load["total_heating"] = 0  # Zero both totals, keep components
                 final_loads.append(load)
-        return final_loads
+        return final_loads
+
+    @staticmethod
+    def display_results(loads: List[Dict]):
+        """Display simulation results including equipment sizing, load breakdown, monthly loads, and summary table."""
+        df = pd.DataFrame(loads)
+        if df.empty:
+            st.error("No load calculations available.")
+            return
+
+        # Equipment Sizing
+        st.subheader("Equipment Sizing")
+        peak_cooling_load = df["total_cooling"].max() if "total_cooling" in df else 0.0
+        peak_heating_load = df["total_heating"].max() if "total_heating" in df else 0.0
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("Cooling Equipment Size", f"{peak_cooling_load:.2f} kW", help="Peak hourly cooling load")
+        with col2:
+            st.metric("Heating Equipment Size", f"{peak_heating_load:.2f} kW", help="Peak hourly heating load")
+
+        # Pie Charts for Load Breakdown
+        st.subheader("Load Breakdown")
+        cooling_totals = {
+            "Conduction": df["conduction_cooling"].sum(),
+            "Solar": df["solar"].sum(),
+            "Internal": df["internal"].sum(),
+            "Ventilation": df["ventilation_cooling"].sum(),
+            "Infiltration": df["infiltration_cooling"].sum()
+        }
+        heating_totals = {
+            "Conduction": df["conduction_heating"].sum(),
+            "Ventilation": df["ventilation_heating"].sum(),
+            "Infiltration": df["infiltration_heating"].sum()
+        }
+        col1, col2 = st.columns(2)
+        with col1:
+            fig_cooling = go.Figure(data=[
+                go.Pie(labels=list(cooling_totals.keys()), values=list(cooling_totals.values()))
+            ])
+            fig_cooling.update_layout(title="Cooling Load Breakdown (kWh)", width=400, height=400)
+            st.plotly_chart(fig_cooling, use_container_width=True)
+        with col2:
+            fig_heating = go.Figure(data=[
+                go.Pie(labels=list(heating_totals.keys()), values=list(heating_totals.values()))
+            ])
+            fig_heating.update_layout(title="Heating Load Breakdown (kWh)", width=400, height=400)
+            st.plotly_chart(fig_heating, use_container_width=True)
+
+        # Monthly Loads Bar Chart
+        st.subheader("Monthly Heating and Cooling Loads")
+        df["month_name"] = df["month"].map({
+            1: "Jan", 2: "Feb", 3: "Mar", 4: "Apr", 5: "May", 6: "Jun",
+            7: "Jul", 8: "Aug", 9: "Sep", 10: "Oct", 11: "Nov", 12: "Dec"
+        })
+        monthly_loads = df.groupby("month_name")[["total_cooling", "total_heating"]].sum().reindex(
+            ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        )
+        fig_monthly = go.Figure(data=[
+            go.Bar(name="Cooling Load (kWh)", x=monthly_loads.index, y=monthly_loads["total_cooling"]),
+            go.Bar(name="Heating Load (kWh)", x=monthly_loads.index, y=monthly_loads["total_heating"])
+        ])
+        fig_monthly.update_layout(
+            title="Monthly Heating and Cooling Loads",
+            xaxis_title="Month",
+            yaxis_title="Load (kWh)",
+            barmode="group",
+            width=800,
+            height=400
+        )
+        st.plotly_chart(fig_monthly, use_container_width=True)
+
+        # Detailed Load Summary Table
+        st.subheader("Load Summary")
+        summary_row = {
+            "hour": "Total",
+            "month_name": "",
+            "conduction_cooling": df["conduction_cooling"].sum(),
+            "conduction_heating": df["conduction_heating"].sum(),
+            "solar": df["solar"].sum(),
+            "internal": df["internal"].sum(),
+            "ventilation_cooling": df["ventilation_cooling"].sum(),
+            "ventilation_heating": df["ventilation_heating"].sum(),
+            "infiltration_cooling": df["infiltration_cooling"].sum(),
+            "infiltration_heating": df["infiltration_heating"].sum(),
+            "total_cooling": df["total_cooling"].sum(),
+            "total_heating": df["total_heating"].sum()
+        }
+        display_df = df[["hour", "month_name", "conduction_cooling", "conduction_heating", "solar",
+                         "internal", "ventilation_cooling", "ventilation_heating",
+                         "infiltration_cooling", "infiltration_heating", "total_cooling", "total_heating"]]
+        display_df = pd.concat([display_df, pd.DataFrame([summary_row])], ignore_index=True)
+        st.dataframe(display_df.rename(columns={"month_name": "Month"}), use_container_width=True)