Upload 4 files

app/data_export.py

@@ -13,33 +13,11 @@ import base64
 import io
 from datetime import datetime
 import xlsxwriter
-import logging
 
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
 class DataExport:
     """Class for data export functionality."""
     
-    def __init__(self):
-        """Initialize DataExport."""
-        logger.info("Initializing DataExport")
-    
-    def display(self, session_state: Dict[str, Any]) -> None:
-        """
-        Display the export interface in Streamlit.
-        
-        Args:
-            session_state: Streamlit session state containing calculation results
-        """
-        try:
-            logger.info("Displaying export interface")
-            self.display_export_interface(session_state)
-        except Exception as e:
-            logger.error(f"Error in display method: {str(e)}")
-            st.error(f"Failed to display export interface: {str(e)}")
-
     @staticmethod
     def export_to_csv(data: Dict[str, Any], file_path: str = None) -> Optional[str]:
         """
@@ -68,8 +46,7 @@ class DataExport:
             return csv_data
         
         except Exception as e:
-            logger.error(f"Error exporting to CSV: {str(e)}")
-            st.error(f"Error exporting to CSV: {str(e)}")
+            st.error(f"Error exporting to CSV: {e}")
             return None
     
     @staticmethod
@@ -116,8 +93,7 @@ class DataExport:
             return None
         
         except Exception as e:
-            logger.error(f"Error exporting to Excel: {str(e)}")
-            st.error(f"Error exporting to Excel: {str(e)}")
+            st.error(f"Error exporting to Excel: {e}")
             return None
     
     @staticmethod
@@ -146,8 +122,7 @@ class DataExport:
             return json_data
         
         except Exception as e:
-            logger.error(f"Error exporting scenario to JSON: {str(e)}")
-            st.error(f"Error exporting scenario to JSON: {str(e)}")
+            st.error(f"Error exporting scenario to JSON: {e}")
             return None
     
     @staticmethod
@@ -164,18 +139,13 @@ class DataExport:
         Returns:
             HTML string with download link
         """
-        try:
-            if isinstance(data, str):
-                b64 = base64.b64encode(data.encode()).decode()
-            else:
-                b64 = base64.b64encode(data).decode()
-            
-            href = f'<a href="data:{mime_type};base64,{b64}" download="{filename}">{text}</a>'
-            return href
-        except Exception as e:
-            logger.error(f"Error generating download link: {str(e)}")
-            st.error(f"Error generating download link: {str(e)}")
-            return ""
+        if isinstance(data, str):
+            b64 = base64.b64encode(data.encode()).decode()
+        else:
+            b64 = base64.b64encode(data).decode()
+        
+        href = f'<a href="data:{mime_type};base64,{b64}" download="{filename}">{text}</a>'
+        return href
     
     @staticmethod
     def create_cooling_load_dataframes(results: Dict[str, Any]) -> Dict[str, pd.DataFrame]:
@@ -188,175 +158,170 @@ class DataExport:
         Returns:
             Dictionary with DataFrames for Excel export
         """
-        try:
-            dataframes = {}
-            
-            # Create summary DataFrame
-            summary_data = {
-                "Metric": [
-                    "Total Cooling Load",
-                    "Sensible Cooling Load",
-                    "Latent Cooling Load",
-                    "Cooling Load per Area"
-                ],
-                "Value": [
-                    results["cooling"]["total_load"],
-                    results["cooling"]["sensible_load"],
-                    results["cooling"]["latent_load"],
-                    results["cooling"]["load_per_area"]
-                ],
-                "Unit": [
-                    "kW",
-                    "kW",
-                    "kW",
-                    "W/m²"
-                ]
-            }
-            
-            dataframes["Cooling Summary"] = pd.DataFrame(summary_data)
-            
-            # Create component breakdown DataFrame
-            component_data = {
-                "Component": [
-                    "Walls",
-                    "Roof",
-                    "Windows",
-                    "Doors",
-                    "People",
-                    "Lighting",
-                    "Equipment",
-                    "Infiltration",
-                    "Ventilation"
-                ],
-                "Load (kW)": [
-                    results["cooling"]["component_loads"]["walls"],
-                    results["cooling"]["component_loads"]["roof"],
-                    results["cooling"]["component_loads"]["windows"],
-                    results["cooling"]["component_loads"]["doors"],
-                    results["cooling"]["component_loads"]["people"],
-                    results["cooling"]["component_loads"]["lighting"],
-                    results["cooling"]["component_loads"]["equipment"],
-                    results["cooling"]["component_loads"]["infiltration"],
-                    results["cooling"]["component_loads"]["ventilation"]
-                ],
-                "Percentage (%)": [
-                    results["cooling"]["component_loads"]["walls"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["roof"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["windows"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["doors"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["people"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["lighting"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["equipment"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["infiltration"] / results["cooling"]["total_load"] * 100,
-                    results["cooling"]["component_loads"]["ventilation"] / results["cooling"]["total_load"] * 100
-                ]
-            }
-            
-            dataframes["Cooling Components"] = pd.DataFrame(component_data)
-            
-            # Create detailed loads DataFrames
-            
-            # Walls
-            wall_data = []
-            for wall in results["cooling"]["detailed_loads"]["walls"]:
-                wall_data.append({
-                    "Name": wall["name"],
-                    "Orientation": wall["orientation"],
-                    "Area (m²)": wall["area"],
-                    "U-Value (W/m²·K)": wall["u_value"],
-                    "CLTD (°C)": wall["cltd"],
-                    "Load (kW)": wall["load"]
-                })
-            
-            if wall_data:
-                dataframes["Cooling Walls"] = pd.DataFrame(wall_data)
-            
-            # Roofs
-            roof_data = []
-            for roof in results["cooling"]["detailed_loads"]["roofs"]:
-                roof_data.append({
-                    "Name": roof["name"],
-                    "Orientation": roof["orientation"],
-                    "Area (m²)": roof["area"],
-                    "U-Value (W/m²·K)": wall["u_value"],
-                    "CLTD (°C)": roof["cltd"],
-                    "Load (kW)": roof["load"]
-                })
-            
-            if roof_data:
-                dataframes["Cooling Roofs"] = pd.DataFrame(roof_data)
-            
-            # Windows
-            window_data = []
-            for window in results["cooling"]["detailed_loads"]["windows"]:
-                window_data.append({
-                    "Name": window["name"],
-                    "Orientation": wall["orientation"],
-                    "Area (m²)": wall["area"],
-                    "U-Value (W/m²·K)": wall["u_value"],
-                    "SHGC": window["shgc"],
-                    "SCL (W/m²)": window["scl"],
-                    "Load (kW)": window["load"]
-                })
-            
-            if window_data:
-                dataframes["Cooling Windows"] = pd.DataFrame(window_data)
-            
-            # Doors
-            door_data = []
-            for door in results["cooling"]["detailed_loads"]["doors"]:
-                door_data.append({
-                    "Name": door["name"],
-                    "Orientation": door["orientation"],
-                    "Area (m²)": door["area"],
-                    "U-Value (W/m²·K)": door["u_value"],
-                    "CLTD (°C)": door["cltd"],
-                    "Load (kW)": door["load"]
-                })
-            
-            if door_data:
-                dataframes["Cooling Doors"] = pd.DataFrame(door_data)
-            
-            # Internal loads
-            internal_data = []
-            for internal_load in results["cooling"]["detailed_loads"]["internal"]:
-                internal_data.append({
-                    "Type": internal_load["type"],
-                    "Name": internal_load["name"],
-                    "Quantity": internal_load["quantity"],
-                    "Heat Gain (W)": internal_load["heat_gain"],
-                    "CLF": internal_load["clf"],
-                    "Load (kW)": internal_load["load"]
-                })
-            
-            if internal_data:
-                dataframes["Cooling Internal Loads"] = pd.DataFrame(internal_data)
-            
-            # Infiltration and ventilation
-            air_data = [
-                {
-                    "Type": "Infiltration",
-                    "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["infiltration"]["air_flow"],
-                    "Sensible Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["sensible_load"],
-                    "Latent Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["latent_load"],
-                    "Total Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["total_load"]
-                },
-                {
-                    "Type": "Ventilation",
-                    "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["ventilation"]["air_flow"],
-                    "Sensible Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["sensible_load"],
-                    "Latent Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["latent_load"],
-                    "Total Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["total_load"]
-                }
+        dataframes = {}
+        
+        # Create summary DataFrame
+        summary_data = {
+            "Metric": [
+                "Total Cooling Load",
+                "Sensible Cooling Load",
+                "Latent Cooling Load",
+                "Cooling Load per Area"
+            ],
+            "Value": [
+                results["cooling"]["total_load"],
+                results["cooling"]["sensible_load"],
+                results["cooling"]["latent_load"],
+                results["cooling"]["load_per_area"]
+            ],
+            "Unit": [
+                "kW",
+                "kW",
+                "kW",
+                "W/m²"
             ]
-            
-            dataframes["Cooling Air Exchange"] = pd.DataFrame(air_data)
-            
-            return dataframes
-        except Exception as e:
-            logger.error(f"Error creating cooling load dataframes: {str(e)}")
-            st.error(f"Error creating cooling load dataframes: {str(e)}")
-            return {}
+        }
+        
+        dataframes["Cooling Summary"] = pd.DataFrame(summary_data)
+        
+        # Create component breakdown DataFrame
+        component_data = {
+            "Component": [
+                "Walls",
+                "Roof",
+                "Windows",
+                "Doors",
+                "People",
+                "Lighting",
+                "Equipment",
+                "Infiltration",
+                "Ventilation"
+            ],
+            "Load (kW)": [
+                results["cooling"]["component_loads"]["walls"],
+                results["cooling"]["component_loads"]["roof"],
+                results["cooling"]["component_loads"]["windows"],
+                results["cooling"]["component_loads"]["doors"],
+                results["cooling"]["component_loads"]["people"],
+                results["cooling"]["component_loads"]["lighting"],
+                results["cooling"]["component_loads"]["equipment"],
+                results["cooling"]["component_loads"]["infiltration"],
+                results["cooling"]["component_loads"]["ventilation"]
+            ],
+            "Percentage (%)": [
+                results["cooling"]["component_loads"]["walls"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["roof"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["windows"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["doors"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["people"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["lighting"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["equipment"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["infiltration"] / results["cooling"]["total_load"] * 100,
+                results["cooling"]["component_loads"]["ventilation"] / results["cooling"]["total_load"] * 100
+            ]
+        }
+        
+        dataframes["Cooling Components"] = pd.DataFrame(component_data)
+        
+        # Create detailed loads DataFrames
+        
+        # Walls
+        wall_data = []
+        for wall in results["cooling"]["detailed_loads"]["walls"]:
+            wall_data.append({
+                "Name": wall["name"],
+                "Orientation": wall["orientation"],
+                "Area (m²)": wall["area"],
+                "U-Value (W/m²·K)": wall["u_value"],
+                "CLTD (°C)": wall["cltd"],
+                "Load (kW)": wall["load"]
+            })
+        
+        if wall_data:
+            dataframes["Cooling Walls"] = pd.DataFrame(wall_data)
+        
+        # Roofs
+        roof_data = []
+        for roof in results["cooling"]["detailed_loads"]["roofs"]:
+            roof_data.append({
+                "Name": roof["name"],
+                "Orientation": roof["orientation"],
+                "Area (m²)": roof["area"],
+                "U-Value (W/m²·K)": roof["u_value"],
+                "CLTD (°C)": roof["cltd"],
+                "Load (kW)": roof["load"]
+            })
+        
+        if roof_data:
+            dataframes["Cooling Roofs"] = pd.DataFrame(roof_data)
+        
+        # Windows
+        window_data = []
+        for window in results["cooling"]["detailed_loads"]["windows"]:
+            window_data.append({
+                "Name": window["name"],
+                "Orientation": window["orientation"],
+                "Area (m²)": window["area"],
+                "U-Value (W/m²·K)": window["u_value"],
+                "SHGC": window["shgc"],
+                "SCL (W/m²)": window["scl"],
+                "Load (kW)": window["load"]
+            })
+        
+        if window_data:
+            dataframes["Cooling Windows"] = pd.DataFrame(window_data)
+        
+        # Doors
+        door_data = []
+        for door in results["cooling"]["detailed_loads"]["doors"]:
+            door_data.append({
+                "Name": door["name"],
+                "Orientation": door["orientation"],
+                "Area (m²)": door["area"],
+                "U-Value (W/m²·K)": door["u_value"],
+                "CLTD (°C)": door["cltd"],
+                "Load (kW)": door["load"]
+            })
+        
+        if door_data:
+            dataframes["Cooling Doors"] = pd.DataFrame(door_data)
+        
+        # Internal loads
+        internal_data = []
+        for internal_load in results["cooling"]["detailed_loads"]["internal"]:
+            internal_data.append({
+                "Type": internal_load["type"],
+                "Name": internal_load["name"],
+                "Quantity": internal_load["quantity"],
+                "Heat Gain (W)": internal_load["heat_gain"],
+                "CLF": internal_load["clf"],
+                "Load (kW)": internal_load["load"]
+            })
+        
+        if internal_data:
+            dataframes["Cooling Internal Loads"] = pd.DataFrame(internal_data)
+        
+        # Infiltration and ventilation
+        air_data = [
+            {
+                "Type": "Infiltration",
+                "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["infiltration"]["air_flow"],
+                "Sensible Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["sensible_load"],
+                "Latent Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["latent_load"],
+                "Total Load (kW)": results["cooling"]["detailed_loads"]["infiltration"]["total_load"]
+            },
+            {
+                "Type": "Ventilation",
+                "Air Flow (m³/s)": results["cooling"]["detailed_loads"]["ventilation"]["air_flow"],
+                "Sensible Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["sensible_load"],
+                "Latent Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["latent_load"],
+                "Total Load (kW)": results["cooling"]["detailed_loads"]["ventilation"]["total_load"]
+            }
+        ]
+        
+        dataframes["Cooling Air Exchange"] = pd.DataFrame(air_data)
+        
+        return dataframes
     
     @staticmethod
     def create_heating_load_dataframes(results: Dict[str, Any]) -> Dict[str, pd.DataFrame]:
@@ -369,165 +334,160 @@ class DataExport:
         Returns:
             Dictionary with DataFrames for Excel export
         """
-        try:
-            dataframes = {}
-            
-            # Create summary DataFrame
-            summary_data = {
-                "Metric": [
-                    "Total Heating Load",
-                    "Heating Load per Area",
-                    "Design Heat Loss",
-                    "Safety Factor"
-                ],
-                "Value": [
-                    results["heating"]["total_load"],
-                    results["heating"]["load_per_area"],
-                    results["heating"]["design_heat_loss"],
-                    results["heating"]["safety_factor"]
-                ],
-                "Unit": [
-                    "kW",
-                    "W/m²",
-                    "kW",
-                    "%"
-                ]
-            }
-            
-            dataframes["Heating Summary"] = pd.DataFrame(summary_data)
-            
-            # Create component breakdown DataFrame
-            component_data = {
-                "Component": [
-                    "Walls",
-                    "Roof",
-                    "Floor",
-                    "Windows",
-                    "Doors",
-                    "Infiltration",
-                    "Ventilation"
-                ],
-                "Load (kW)": [
-                    results["heating"]["component_loads"]["walls"],
-                    results["heating"]["component_loads"]["roof"],
-                    results["heating"]["component_loads"]["floor"],
-                    results["heating"]["component_loads"]["windows"],
-                    results["heating"]["component_loads"]["doors"],
-                    results["heating"]["component_loads"]["infiltration"],
-                    results["heating"]["component_loads"]["ventilation"]
-                ],
-                "Percentage (%)": [
-                    results["heating"]["component_loads"]["walls"] / results["heating"]["total_load"] * 100,
-                    results["heating"]["component_loads"]["roof"] / results["heating"]["total_load"] * 100,
-                    results["heating"]["component_loads"]["floor"] / results["heating"]["total_load"] * 100,
-                    results["heating"]["component_loads"]["windows"] / results["heating"]["total_load"] * 100,
-                    results["heating"]["component_loads"]["doors"] / results["heating"]["total_load"] * 100,
-                    results["heating"]["component_loads"]["infiltration"] / results["heating"]["total_load"] * 100,
-                    results["heating"]["component_loads"]["ventilation"] / results["heating"]["total_load"] * 100
-                ]
-            }
-            
-            dataframes["Heating Components"] = pd.DataFrame(component_data)
-            
-            # Create detailed loads DataFrames
-            
-            # Walls
-            wall_data = []
-            for wall in results["heating"]["detailed_loads"]["walls"]:
-                wall_data.append({
-                    "Name": wall["name"],
-                    "Orientation": wall["orientation"],
-                    "Area (m²)": wall["area"],
-                    "U-Value (W/m²·K)": wall["u_value"],
-                    "Temperature Difference (°C)": wall["delta_t"],
-                    "Load (kW)": wall["load"]
-                })
-            
-            if wall_data:
-                dataframes["Heating Walls"] = pd.DataFrame(wall_data)
-            
-            # Roofs
-            roof_data = []
-            for roof in results["heating"]["detailed_loads"]["roofs"]:
-                roof_data.append({
-                    "Name": roof["name"],
-                    "Orientation": roof["orientation"],
-                    "Area (m²)": roof["area"],
-                    "U-Value (W/m²·K)": roof["u_value"],
-                    "Temperature Difference (°C)": roof["delta_t"],
-                    "Load (kW)": roof["load"]
-                })
-            
-            if roof_data:
-                dataframes["Heating Roofs"] = pd.DataFrame(roof_data)
-            
-            # Floors
-            floor_data = []
-            for floor in results["heating"]["detailed_loads"]["floors"]:
-                floor_data.append({
-                    "Name": floor["name"],
-                    "Area (m²)": floor["area"],
-                    "U-Value (W/m²·K)": floor["u_value"],
-                    "Temperature Difference (°C)": floor["delta_t"],
-                    "Load (kW)": floor["load"]
-                })
-            
-            if floor_data:
-                dataframes["Heating Floors"] = pd.DataFrame(floor_data)
-            
-            # Windows
-            window_data = []
-            for window in results["heating"]["detailed_loads"]["windows"]:
-                window_data.append({
-                    "Name": window["name"],
-                    "Orientation": window["orientation"],
-                    "Area (m²)": window["area"],
-                    "U-Value (W/m²·K)": window["u_value"],
-                    "Temperature Difference (°C)": window["delta_t"],
-                    "Load (kW)": window["load"]
-                })
-            
-            if window_data:
-                dataframes["Heating Windows"] = pd.DataFrame(window_data)
-            
-            # Doors
-            door_data = []
-            for door in results["heating"]["detailed_loads"]["doors"]:
-                door_data.append({
-                    "Name": door["name"],
-                    "Orientation": door["orientation"],
-                    "Area (m²)": door["area"],
-                    "U-Value (W/m²·K)": door["u_value"],
-                    "Temperature Difference (°C)": door["delta_t"],
-                    "Load (kW)": door["load"]
-                })
-            
-            if door_data:
-                dataframes["Heating Doors"] = pd.DataFrame(door_data)
-            
-            # Infiltration and ventilation
-            air_data = [
-                {
-                    "Type": "Infiltration",
-                    "Air Flow (m³/s)": results["heating"]["detailed_loads"]["infiltration"]["air_flow"],
-                    "Temperature Difference (°C)": results["heating"]["detailed_loads"]["infiltration"]["delta_t"],
-                    "Load (kW)": results["heating"]["detailed_loads"]["infiltration"]["load"]
-                },
-                {
-                    "Type": "Ventilation",
-                    "Air Flow (m³/s)": results["heating"]["detailed_loads"]["ventilation"]["air_flow"],
-                    "Temperature Difference (°C)": results["heating"]["detailed_loads"]["ventilation"]["delta_t"],
-                    "Load (kW)": results["heating"]["detailed_loads"]["ventilation"]["load"]
-                }
+        dataframes = {}
+        
+        # Create summary DataFrame
+        summary_data = {
+            "Metric": [
+                "Total Heating Load",
+                "Heating Load per Area",
+                "Design Heat Loss",
+                "Safety Factor"
+            ],
+            "Value": [
+                results["heating"]["total_load"],
+                results["heating"]["load_per_area"],
+                results["heating"]["design_heat_loss"],
+                results["heating"]["safety_factor"]
+            ],
+            "Unit": [
+                "kW",
+                "W/m²",
+                "kW",
+                "%"
             ]
-            
-            dataframes["Heating Air Exchange"] = pd.DataFrame(air_data)
-            
-            return dataframes
-        except Exception as e:
-            logger.error(f"Error creating heating load dataframes: {str(e)}")
-            st.error(f"Error creating heating load dataframes: {str(e)}")
-            return {}
+        }
+        
+        dataframes["Heating Summary"] = pd.DataFrame(summary_data)
+        
+        # Create component breakdown DataFrame
+        component_data = {
+            "Component": [
+                "Walls",
+                "Roof",
+                "Floor",
+                "Windows",
+                "Doors",
+                "Infiltration",
+                "Ventilation"
+            ],
+            "Load (kW)": [
+                results["heating"]["component_loads"]["walls"],
+                results["heating"]["component_loads"]["roof"],
+                results["heating"]["component_loads"]["floor"],
+                results["heating"]["component_loads"]["windows"],
+                results["heating"]["component_loads"]["doors"],
+                results["heating"]["component_loads"]["infiltration"],
+                results["heating"]["component_loads"]["ventilation"]
+            ],
+            "Percentage (%)": [
+                results["heating"]["component_loads"]["walls"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["roof"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["floor"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["windows"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["doors"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["infiltration"] / results["heating"]["total_load"] * 100,
+                results["heating"]["component_loads"]["ventilation"] / results["heating"]["total_load"] * 100
+            ]
+        }
+        
+        dataframes["Heating Components"] = pd.DataFrame(component_data)
+        
+        # Create detailed loads DataFrames
+        
+        # Walls
+        wall_data = []
+        for wall in results["heating"]["detailed_loads"]["walls"]:
+            wall_data.append({
+                "Name": wall["name"],
+                "Orientation": wall["orientation"],
+                "Area (m²)": wall["area"],
+                "U-Value (W/m²·K)": wall["u_value"],
+                "Temperature Difference (°C)": wall["delta_t"],
+                "Load (kW)": wall["load"]
+            })
+        
+        if wall_data:
+            dataframes["Heating Walls"] = pd.DataFrame(wall_data)
+        
+        # Roofs
+        roof_data = []
+        for roof in results["heating"]["detailed_loads"]["roofs"]:
+            roof_data.append({
+                "Name": roof["name"],
+                "Orientation": roof["orientation"],
+                "Area (m²)": roof["area"],
+                "U-Value (W/m²·K)": roof["u_value"],
+                "Temperature Difference (°C)": roof["delta_t"],
+                "Load (kW)": roof["load"]
+            })
+        
+        if roof_data:
+            dataframes["Heating Roofs"] = pd.DataFrame(roof_data)
+        
+        # Floors
+        floor_data = []
+        for floor in results["heating"]["detailed_loads"]["floors"]:
+            floor_data.append({
+                "Name": floor["name"],
+                "Area (m²)": floor["area"],
+                "U-Value (W/m²·K)": floor["u_value"],
+                "Temperature Difference (°C)": floor["delta_t"],
+                "Load (kW)": floor["load"]
+            })
+        
+        if floor_data:
+            dataframes["Heating Floors"] = pd.DataFrame(floor_data)
+        
+        # Windows
+        window_data = []
+        for window in results["heating"]["detailed_loads"]["windows"]:
+            window_data.append({
+                "Name": window["name"],
+                "Orientation": window["orientation"],
+                "Area (m²)": window["area"],
+                "U-Value (W/m²·K)": window["u_value"],
+                "Temperature Difference (°C)": window["delta_t"],
+                "Load (kW)": window["load"]
+            })
+        
+        if window_data:
+            dataframes["Heating Windows"] = pd.DataFrame(window_data)
+        
+        # Doors
+        door_data = []
+        for door in results["heating"]["detailed_loads"]["doors"]:
+            door_data.append({
+                "Name": door["name"],
+                "Orientation": door["orientation"],
+                "Area (m²)": door["area"],
+                "U-Value (W/m²·K)": door["u_value"],
+                "Temperature Difference (°C)": door["delta_t"],
+                "Load (kW)": door["load"]
+            })
+        
+        if door_data:
+            dataframes["Heating Doors"] = pd.DataFrame(door_data)
+        
+        # Infiltration and ventilation
+        air_data = [
+            {
+                "Type": "Infiltration",
+                "Air Flow (m³/s)": results["heating"]["detailed_loads"]["infiltration"]["air_flow"],
+                "Temperature Difference (°C)": results["heating"]["detailed_loads"]["infiltration"]["delta_t"],
+                "Load (kW)": results["heating"]["detailed_loads"]["infiltration"]["load"]
+            },
+            {
+                "Type": "Ventilation",
+                "Air Flow (m³/s)": results["heating"]["detailed_loads"]["ventilation"]["air_flow"],
+                "Temperature Difference (°C)": results["heating"]["detailed_loads"]["ventilation"]["delta_t"],
+                "Load (kW)": results["heating"]["detailed_loads"]["ventilation"]["load"]
+            }
+        ]
+        
+        dataframes["Heating Air Exchange"] = pd.DataFrame(air_data)
+        
+        return dataframes
     
     @staticmethod
     def display_export_interface(session_state: Dict[str, Any]) -> None:
@@ -537,28 +497,24 @@ class DataExport:
         Args:
             session_state: Streamlit session state containing calculation results
         """
-        try:
-            st.header("Export Results")
-            
-            # Check if calculations have been performed
-            if "calculation_results" not in session_state or not session_state["calculation_results"]:
-                st.warning("No calculation results available. Please run calculations first.")
-                return
-            
-            # Create tabs for different export options
-            tab1, tab2, tab3 = st.tabs(["CSV Export", "Excel Export", "Scenario Export"])
-            
-            with tab1:
-                DataExport._display_csv_export(session_state)
-            
-            with tab2:
-                DataExport._display_excel_export(session_state)
-            
-            with tab3:
-                DataExport._display_scenario_export(session_state)
-        except Exception as e:
-            logger.error(f"Error displaying export interface: {str(e)}")
-            st.error(f"Error displaying export interface: {str(e)}")
+        st.header("Export Results")
+        
+        # Check if calculations have been performed
+        if "calculation_results" not in session_state or not session_state["calculation_results"]:
+            st.warning("No calculation results available. Please run calculations first.")
+            return
+        
+        # Create tabs for different export options
+        tab1, tab2, tab3 = st.tabs(["CSV Export", "Excel Export", "Scenario Export"])
+        
+        with tab1:
+            DataExport._display_csv_export(session_state)
+        
+        with tab2:
+            DataExport._display_excel_export(session_state)
+        
+        with tab3:
+            DataExport._display_scenario_export(session_state)
     
     @staticmethod
     def _display_csv_export(session_state: Dict[str, Any]) -> None:
@@ -568,49 +524,45 @@ class DataExport:
         Args:
             session_state: Streamlit session state containing calculation results
         """
-        try:
-            st.subheader("CSV Export")
-            
-            # Get results
-            results = session_state["calculation_results"]
-            
-            # Create tabs for cooling and heating loads
-            tab1, tab2 = st.tabs(["Cooling Load CSV", "Heating Load CSV"])
-            
-            with tab1:
-                # Create cooling load DataFrames
-                cooling_dfs = DataExport.create_cooling_load_dataframes(results)
+        st.subheader("CSV Export")
+        
+        # Get results
+        results = session_state["calculation_results"]
+        
+        # Create tabs for cooling and heating loads
+        tab1, tab2 = st.tabs(["Cooling Load CSV", "Heating Load CSV"])
+        
+        with tab1:
+            # Create cooling load DataFrames
+            cooling_dfs = DataExport.create_cooling_load_dataframes(results)
+            
+            # Display and export each DataFrame
+            for sheet_name, df in cooling_dfs.items():
+                st.write(f"### {sheet_name}")
+                st.dataframe(df)
                 
-                # Display and export each DataFrame
-                for sheet_name, df in cooling_dfs.items():
-                    st.write(f"### {sheet_name}")
-                    st.dataframe(df)
-                    
-                    # Add download button
-                    csv_data = DataExport.export_to_csv(df)
-                    if csv_data:
-                        filename = f"{sheet_name.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-                        download_link = DataExport.get_download_link(csv_data, filename, f"Download {sheet_name} CSV")
-                        st.markdown(download_link, unsafe_allow_html=True)
-            
-            with tab2:
-                # Create heating load DataFrames
-                heating_dfs = DataExport.create_heating_load_dataframes(results)
+                # Add download button
+                csv_data = DataExport.export_to_csv(df)
+                if csv_data:
+                    filename = f"{sheet_name.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+                    download_link = DataExport.get_download_link(csv_data, filename, f"Download {sheet_name} CSV")
+                    st.markdown(download_link, unsafe_allow_html=True)
+        
+        with tab2:
+            # Create heating load DataFrames
+            heating_dfs = DataExport.create_heating_load_dataframes(results)
+            
+            # Display and export each DataFrame
+            for sheet_name, df in heating_dfs.items():
+                st.write(f"### {sheet_name}")
+                st.dataframe(df)
                 
-                # Display and export each DataFrame
-                for sheet_name, df in heating_dfs.items():
-                    st.write(f"### {sheet_name}")
-                    st.dataframe(df)
-                    
-                    # Add download button
-                    csv_data = DataExport.export_to_csv(df)
-                    if csv_data:
-                        filename = f"{sheet_name.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
-                        download_link = DataExport.get_download_link(csv_data, filename, f"Download {sheet_name} CSV")
-                        st.markdown(download_link, unsafe_allow_html=True)
-        except Exception as e:
-            logger.error(f"Error in CSV export interface: {str(e)}")
-            st.error(f"Error in CSV export interface: {str(e)}")
+                # Add download button
+                csv_data = DataExport.export_to_csv(df)
+                if csv_data:
+                    filename = f"{sheet_name.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+                    download_link = DataExport.get_download_link(csv_data, filename, f"Download {sheet_name} CSV")
+                    st.markdown(download_link, unsafe_allow_html=True)
     
     @staticmethod
     def _display_excel_export(session_state: Dict[str, Any]) -> None:
@@ -620,113 +572,109 @@ class DataExport:
         Args:
             session_state: Streamlit session state containing calculation results
         """
-        try:
-            st.subheader("Excel Export")
-            
-            # Get results
-            results = session_state["calculation_results"]
-            
-            # Create tabs for cooling, heating, and combined loads
-            tab1, tab2, tab3 = st.tabs(["Cooling Load Excel", "Heating Load Excel", "Combined Excel"])
-            
-            with tab1:
-                # Create cooling load DataFrames
-                cooling_dfs = DataExport.create_cooling_load_dataframes(results)
-                
-                # Add download button
-                excel_data = DataExport.export_to_excel(cooling_dfs)
-                if excel_data:
-                    filename = f"cooling_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
-                    download_link = DataExport.get_download_link(
-                        excel_data,
-                        filename,
-                        "Download Cooling Load Excel",
-                        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-                    )
-                    st.markdown(download_link, unsafe_allow_html=True)
-                
-                # Display preview
-                st.write("### Excel Preview")
-                st.write("The Excel file will contain the following sheets:")
-                for sheet_name in cooling_dfs.keys():
-                    st.write(f"- {sheet_name}")
-            
-            with tab2:
-                # Create heating load DataFrames
-                heating_dfs = DataExport.create_heating_load_dataframes(results)
-                
-                # Add download button
-                excel_data = DataExport.export_to_excel(heating_dfs)
-                if excel_data:
-                    filename = f"heating_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
-                    download_link = DataExport.get_download_link(
-                        excel_data,
-                        filename,
-                        "Download Heating Load Excel",
-                        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-                    )
-                    st.markdown(download_link, unsafe_allow_html=True)
-                
-                # Display preview
-                st.write("### redeemed Excel Preview")
-                st.write("The Excel file will contain the following sheets:")
-                for sheet_name in heating_dfs.keys():
-                    st.write(f"- {sheet_name}")
-            
-            with tab3:
-                # Create combined DataFrames
-                combined_dfs = {}
-                
-                # Add project information
-                if "building_info" in session_state:
-                    project_info = [
-                        {"Parameter": "Project Name", "Value": session_state["building_info"].get("project_name", "")},
-                        {"Parameter": "Building Name", "Value": session_state["building_info"].get("building_name", "")},
-                        {"Parameter": "Location", "Value": session_state["building_info"].get("location", "")},
-                        {"Parameter": "Climate Zone", "Value": session_state["building_info"].get("climate_zone", "")},
-                        {"Parameter": "Building Type", "Value": session_state["building_info"].get("building_type", "")},
-                        {"Parameter": "Floor Area", "Value": session_state["building_info"].get("floor_area", "")},
-                        {"Parameter": "Number of Floors", "Value": session_state["building_info"].get("num_floors", "")},
-                        {"Parameter": "Floor Height", "Value": session_state["building_info"].get("floor_height", "")},
-                        {"Parameter": "Orientation", "Value": session_state["building_info"].get("orientation", "")},
-                        {"Parameter": "Occupancy", "Value": session_state["building_info"].get("occupancy", "")},
-                        {"Parameter": "Operating Hours", "Value": session_state["building_info"].get("operating_hours", "")},
-                        {"Parameter": "Date", "Value": datetime.now().strftime("%Y-%m-%d")},
-                        {"Parameter": "Time", "Value": datetime.now().strftime("%H:%M:%S")}
-                    ]
-                    
-                    combined_dfs["Project Information"] = pd.DataFrame(project_info)
-                
-                # Add cooling load DataFrames
-                cooling_dfs = DataExport.create_cooling_load_dataframes(results)
-                for sheet_name, df in cooling_dfs.items():
-                    combined_dfs[sheet_name] = df
-                
-                # Add heating load DataFrames
-                heating_dfs = DataExport.create_heating_load_dataframes(results)
-                for sheet_name, df in heating_dfs.items():
-                    combined_dfs[sheet_name] = df
-                
-                # Add download button
-                excel_data = DataExport.export_to_excel(combined_dfs)
-                if excel_data:
-                    filename = f"hvac_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
-                    download_link = DataExport.get_download_link(
-                        excel_data,
-                        filename,
-                        "Download Combined Excel Report",
-                        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
-                    )
-                    st.markdown(download_link, unsafe_allow_html=True)
+        st.subheader("Excel Export")
+        
+        # Get results
+        results = session_state["calculation_results"]
+        
+        # Create tabs for cooling, heating, and combined loads
+        tab1, tab2, tab3 = st.tabs(["Cooling Load Excel", "Heating Load Excel", "Combined Excel"])
+        
+        with tab1:
+            # Create cooling load DataFrames
+            cooling_dfs = DataExport.create_cooling_load_dataframes(results)
+            
+            # Add download button
+            excel_data = DataExport.export_to_excel(cooling_dfs)
+            if excel_data:
+                filename = f"cooling_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+                download_link = DataExport.get_download_link(
+                    excel_data,
+                    filename,
+                    "Download Cooling Load Excel",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+            
+            # Display preview
+            st.write("### Excel Preview")
+            st.write("The Excel file will contain the following sheets:")
+            for sheet_name in cooling_dfs.keys():
+                st.write(f"- {sheet_name}")
+        
+        with tab2:
+            # Create heating load DataFrames
+            heating_dfs = DataExport.create_heating_load_dataframes(results)
+            
+            # Add download button
+            excel_data = DataExport.export_to_excel(heating_dfs)
+            if excel_data:
+                filename = f"heating_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+                download_link = DataExport.get_download_link(
+                    excel_data,
+                    filename,
+                    "Download Heating Load Excel",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+            
+            # Display preview
+            st.write("### Excel Preview")
+            st.write("The Excel file will contain the following sheets:")
+            for sheet_name in heating_dfs.keys():
+                st.write(f"- {sheet_name}")
+        
+        with tab3:
+            # Create combined DataFrames
+            combined_dfs = {}
+            
+            # Add project information
+            if "building_info" in session_state:
+                project_info = [
+                    {"Parameter": "Project Name", "Value": session_state["building_info"].get("project_name", "")},
+                    {"Parameter": "Building Name", "Value": session_state["building_info"].get("building_name", "")},
+                    {"Parameter": "Location", "Value": session_state["building_info"].get("location", "")},
+                    {"Parameter": "Climate Zone", "Value": session_state["building_info"].get("climate_zone", "")},
+                    {"Parameter": "Building Type", "Value": session_state["building_info"].get("building_type", "")},
+                    {"Parameter": "Floor Area", "Value": session_state["building_info"].get("floor_area", "")},
+                    {"Parameter": "Number of Floors", "Value": session_state["building_info"].get("num_floors", "")},
+                    {"Parameter": "Floor Height", "Value": session_state["building_info"].get("floor_height", "")},
+                    {"Parameter": "Orientation", "Value": session_state["building_info"].get("orientation", "")},
+                    {"Parameter": "Occupancy", "Value": session_state["building_info"].get("occupancy", "")},
+                    {"Parameter": "Operating Hours", "Value": session_state["building_info"].get("operating_hours", "")},
+                    {"Parameter": "Date", "Value": datetime.now().strftime("%Y-%m-%d")},
+                    {"Parameter": "Time", "Value": datetime.now().strftime("%H:%M:%S")}
+                ]
                 
-                # Display preview
-                st.write("### Excel Preview")
-                st.write("The Excel file will contain the following sheets:")
-                for sheet_name in combined_dfs.keys():
-                    st.write(f"- {sheet_name}")
-        except Exception as e:
-            logger.error(f"Error in Excel export interface: {str(e)}")
-            st.error(f"Error in Excel export interface: {str(e)}")
+                combined_dfs["Project Information"] = pd.DataFrame(project_info)
+            
+            # Add cooling load DataFrames
+            cooling_dfs = DataExport.create_cooling_load_dataframes(results)
+            for sheet_name, df in cooling_dfs.items():
+                combined_dfs[sheet_name] = df
+            
+            # Add heating load DataFrames
+            heating_dfs = DataExport.create_heating_load_dataframes(results)
+            for sheet_name, df in heating_dfs.items():
+                combined_dfs[sheet_name] = df
+            
+            # Add download button
+            excel_data = DataExport.export_to_excel(combined_dfs)
+            if excel_data:
+                filename = f"hvac_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
+                download_link = DataExport.get_download_link(
+                    excel_data,
+                    filename,
+                    "Download Combined Excel Report",
+                    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+            
+            # Display preview
+            st.write("### Excel Preview")
+            st.write("The Excel file will contain the following sheets:")
+            for sheet_name in combined_dfs.keys():
+                st.write(f"- {sheet_name}")
     
     @staticmethod
     def _display_scenario_export(session_state: Dict[str, Any]) -> None:
@@ -736,90 +684,90 @@ class DataExport:
         Args:
             session_state: Streamlit session state containing calculation results
         """
-        try:
-            st.subheader("Scenario Export")
+        st.subheader("Scenario Export")
+        
+        # Check if there are saved scenarios
+        if "saved_scenarios" not in session_state or not session_state["saved_scenarios"]:
+            st.info("No saved scenarios available for export. Save the current results as a scenario to enable export.")
             
-            # Check if there are saved scenarios
-            if "saved_scenarios" not in session_state or not session_state["saved_scenarios"]:
-                st.info("No saved scenarios available for export. Save the current results as a scenario to enable export.")
-                
-                # Add button to save current results as a scenario
-                scenario_name = st.text_input("Scenario Name", value="Baseline")
+            # Add button to save current results as a scenario
+            scenario_name = st.text_input("Scenario Name", value="Baseline")
+            
+            if st.button("Save Current Results as Scenario"):
+                if "saved_scenarios" not in session_state:
+                    session_state["saved_scenarios"] = {}
                 
-                if st.button("Save Current Results as Scenario"):
-                    if "saved_scenarios" not in session_state:
-                        session_state["saved_scenarios"] = {}
-                    
-                    # Save current results as a scenario
-                    session_state["saved_scenarios"][scenario_name] = {
-                        "results": session_state["calculation_results"],
-                        "building_info": session_state["building_info"],
-                        "components": session_state["components"],
-                        "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                    }
-                    
-                    st.success(f"Scenario '{scenario_name}' saved successfully!")
-                    st.experimental_rerun()
-            else:
-                # Display saved scenarios
-                st.write("### Saved Scenarios")
+                # Save current results as a scenario
+                session_state["saved_scenarios"][scenario_name] = {
+                    "results": session_state["calculation_results"],
+                    "building_info": session_state["building_info"],
+                    "components": session_state["components"],
+                    "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                }
                 
-                # Create selectbox for scenarios
-                scenario_names = list(session_state["saved_scenarios"].keys())
-                selected_scenario = st.selectbox("Select Scenario to Export", scenario_names)
+                st.success(f"Scenario '{scenario_name}' saved successfully!")
+                st.experimental_rerun()
+        else:
+            # Display saved scenarios
+            st.write("### Saved Scenarios")
+            
+            # Create selectbox for scenarios
+            scenario_names = list(session_state["saved_scenarios"].keys())
+            selected_scenario = st.selectbox("Select Scenario to Export", scenario_names)
+            
+            if selected_scenario:
+                # Get selected scenario
+                scenario = session_state["saved_scenarios"][selected_scenario]
                 
-                if selected_scenario:
-                    # Get selected scenario
-                    scenario = session_state["saved_scenarios"][selected_scenario]
-                    
-                    # Display scenario information
-                    st.write(f"**Scenario:** {selected_scenario}")
-                    st.write(f"**Timestamp:** {scenario['timestamp']}")
-                    
-                    # Add download button
-                    json_data = DataExport.export_scenario_to_json(scenario)
-                    if json_data:
-                        filename = f"{selected_scenario.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
-                        download_link = DataExport.get_download_link(
-                            json_data,
-                            filename,
-                            "Download Scenario JSON",
-                            "application/json"
-                        )
-                        st.markdown(download_link, unsafe_allow_html=True)
+                # Display scenario information
+                st.write(f"**Scenario:** {selected_scenario}")
+                st.write(f"**Timestamp:** {scenario['timestamp']}")
                 
-                # Add button to export all scenarios
-                if st.button("Export All Scenarios"):
-                    # Create a zip file in memory
-                    import zipfile
-                    from io import BytesIO
-                    
-                    zip_buffer = BytesIO()
-                    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-                        for scenario_name, scenario in session_state["saved_scenarios"].items():
-                            # Export scenario to JSON
-                            json_data = DataExport.export_scenario_to_json(scenario)
-                            if json_data:
-                                filename = f"{scenario_name.replace(' ', '_').lower()}.json"
-                                zip_file.writestr(filename, json_data)
-                    
-                    # Add download button for zip file
-                    zip_buffer.seek(0)
-                    zip_data = zip_buffer.getvalue()
-                    
-                    filename = f"all_scenarios_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+                # Add download button
+                json_data = DataExport.export_scenario_to_json(scenario)
+                if json_data:
+                    filename = f"{selected_scenario.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
                     download_link = DataExport.get_download_link(
-                        zip_data,
+                        json_data,
                         filename,
-                        "Download All Scenarios (ZIP)",
-                        "application/zip"
+                        "Download Scenario JSON",
+                        "application/json"
                     )
                     st.markdown(download_link, unsafe_allow_html=True)
-        except Exception as e:
-            logger.error(f"Error in scenario export interface: {str(e)}")
-            st.error(f"Error in scenario export interface: {str(e)}")
+            
+            # Add button to export all scenarios
+            if st.button("Export All Scenarios"):
+                # Create a zip file in memory
+                import zipfile
+                from io import BytesIO
+                
+                zip_buffer = BytesIO()
+                with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+                    for scenario_name, scenario in session_state["saved_scenarios"].items():
+                        # Export scenario to JSON
+                        json_data = DataExport.export_scenario_to_json(scenario)
+                        if json_data:
+                            filename = f"{scenario_name.replace(' ', '_').lower()}.json"
+                            zip_file.writestr(filename, json_data)
+                
+                # Add download button for zip file
+                zip_buffer.seek(0)
+                zip_data = zip_buffer.getvalue()
+                
+                filename = f"all_scenarios_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
+                download_link = DataExport.get_download_link(
+                    zip_data,
+                    filename,
+                    "Download All Scenarios (ZIP)",
+                    "application/zip"
+                )
+                st.markdown(download_link, unsafe_allow_html=True)
+
 
+# Create a singleton instance
+data_export = DataExport()
 
+# Example usage
 if __name__ == "__main__":
     import streamlit as st
     
@@ -918,6 +866,5 @@ if __name__ == "__main__":
             }
         }
     
-    # Create instance and display export interface
-    data_export = DataExport()
-    data_export.display(st.session_state)
+    # Display export interface
+    data_export.display_export_interface(st.session_state)

app/data_persistence.py

@@ -41,7 +41,6 @@ class DataPersistence:
                 "internal_loads": session_state.get("internal_loads", {}),
                 "calculation_settings": session_state.get("calculation_settings", {}),
                 "saved_scenarios": DataPersistence._serialize_scenarios(session_state.get("saved_scenarios", {})),
-                "climate_data": session_state.get("climate_data", {}),
                 "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
             }
             
@@ -83,21 +82,6 @@ class DataPersistence:
             if json_data:
                 project_data = json.loads(json_data)
                 
-                # Validate climate data latitude
-                if "climate_data" in project_data:
-                    valid_latitudes = [24, 32, 40, 48, 56]
-                    for location_id, location in project_data["climate_data"].items():
-                        if "latitude" in location:
-                            try:
-                                input_latitude = float(location["latitude"])
-                                nearest_latitude = min(valid_latitudes, key=lambda x: abs(x - input_latitude))
-                                if abs(input_latitude - nearest_latitude) > 0.1:  # Allow small float differences
-                                    st.warning(f"Latitude {input_latitude} for {location_id} is invalid for ASHRAE tables. Using nearest valid latitude: {nearest_latitude}.")
-                                    location["latitude"] = nearest_latitude
-                            except ValueError:
-                                st.error(f"Invalid latitude format for {location_id}: {location['latitude']}.")
-                                return None
-                
                 # Deserialize components
                 if "components" in project_data:
                     project_data["components"] = DataPersistence._deserialize_components(project_data["components"])
@@ -553,4 +537,4 @@ if __name__ == "__main__":
         }
     
     # Display project management interface
-    data_persistence.display_project_management(st.session_state)
+    data_persistence.display_project_management(st.session_state)

app/main.py

@@ -11,129 +11,111 @@ import json
 import pycountry
 import os
 import sys
-import logging
 from typing import Dict, List, Any, Optional, Tuple
-from uuid import uuid4
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
 # Import application modules
-try:
-    from app.building_info_form import BuildingInfoForm
-    from app.component_selection import ComponentSelectionInterface, Orientation, ComponentType, Wall, Roof, Floor, Window, Door
-    from app.results_display import ResultsDisplay
-    from app.data_validation import DataValidation
-    from app.data_persistence import DataPersistence
-    from app.data_export import DataExport
-except ImportError as e:
-    logger.error(f"Error importing application modules: {str(e)}")
-    raise
+from app.building_info_form import BuildingInfoForm
+from app.component_selection import ComponentSelectionInterface, Orientation, ComponentType, Wall, Roof, Floor, Window, Door
+from app.results_display import ResultsDisplay
+from app.data_validation import DataValidation
+from app.data_persistence import DataPersistence
+from app.data_export import DataExport
 
 # Import data modules
-try:
-    from data.reference_data import ReferenceData
-    from data.climate_data import ClimateData, ClimateLocation
-    from data.ashrae_tables import ASHRAETables
-    from data.building_components import Wall as WallModel, Roof as RoofModel
-except ImportError as e:
-    logger.error(f"Error importing data modules: {str(e)}")
-    raise
+from data.reference_data import ReferenceData
+from data.climate_data import ClimateData, ClimateLocation
+from data.ashrae_tables import ASHRAETables
+from data.building_components import Wall as WallModel, Roof as RoofModel
 
 # Import utility modules
-try:
-    from utils.u_value_calculator import UValueCalculator
-    from utils.shading_system import ShadingSystem
-    from utils.area_calculation_system import AreaCalculationSystem
-    from utils.psychrometrics import Psychrometrics
-    from utils.heat_transfer import HeatTransferCalculations
-    from utils.cooling_load import CoolingLoadCalculator
-    from utils.heating_load import HeatingLoadCalculator
-    from utils.component_visualization import ComponentVisualization
-    from utils.scenario_comparison import ScenarioComparisonVisualization
-    from utils.psychrometric_visualization import PsychrometricVisualization
-    from utils.time_based_visualization import TimeBasedVisualization
-except ImportError as e:
-    logger.error(f"Error importing utility modules: {str(e)}")
-    raise
-
+from utils.u_value_calculator import UValueCalculator
+from utils.shading_system import ShadingSystem
+from utils.area_calculation_system import AreaCalculationSystem
+from utils.psychrometrics import Psychrometrics
+from utils.heat_transfer import HeatTransferCalculations
+from utils.cooling_load import CoolingLoadCalculator
+from utils.heating_load import HeatingLoadCalculator
+from utils.component_visualization import ComponentVisualization
+from utils.scenario_comparison import ScenarioComparisonVisualization
+from utils.psychrometric_visualization import PsychrometricVisualization
+from utils.time_based_visualization import TimeBasedVisualization
 
 class HVACCalculator:
     def __init__(self):
-        try:
-            st.set_page_config(
-                page_title="HVAC Load Calculator",
-                page_icon="🌡️",
-                layout="wide",
-                initial_sidebar_state="expanded"
-            )
-
-            # Initialize session state
-            self._initialize_session_state()
-
-            # Initialize modules
-            self.building_info_form = BuildingInfoForm()
-            self.component_selection = ComponentSelectionInterface()
-            self.results_display = ResultsDisplay()
-            self.data_validation = DataValidation()
-            self.data_persistence = DataPersistence()
-            self.data_export = DataExport()
-            self.cooling_calculator = CoolingLoadCalculator()
-            self.heating_calculator = HeatingLoadCalculator()
-            self.reference_data = ReferenceData()
-
-            # Validate DataExport has display method
-            if not hasattr(self.data_export, 'display'):
-                logger.error("DataExport object missing 'display' method")
-                raise AttributeError("DataExport object missing 'display' method")
-
-            # Initialize climate data
-            self._initialize_climate_data()
-
-            self.setup_layout()
-        except Exception as e:
-            logger.error(f"Error initializing HVACCalculator: {str(e)}")
-            st.error(f"Failed to initialize application: {str(e)}")
-            raise
-
-    def _initialize_session_state(self):
-        """Initialize session state variables."""
-        defaults = {
-            'page': 'Building Information',
-            'building_info': {"project_name": ""},
-            'components': {'walls': [], 'roofs': [], 'floors': [], 'windows': [], 'doors': []},
-            'internal_loads': {'people': [], 'lighting': [], 'equipment': []},
-            'calculation_results': {'cooling': {}, 'heating': {}},
-            'saved_scenarios': {},
-            'climate_data': {},
-            'debug_mode': False
-        }
-        for key, value in defaults.items():
-            if key not in st.session_state:
-                st.session_state[key] = value
-
-    def _initialize_climate_data(self):
-        """Initialize climate data from JSON or default."""
+        st.set_page_config(
+            page_title="HVAC Load Calculator",
+            page_icon="🌡️",
+            layout="wide",
+            initial_sidebar_state="expanded"
+        )
+        
+        # Initialize session state
+        if 'page' not in st.session_state:
+            st.session_state.page = 'Building Information'
+        
+        if 'building_info' not in st.session_state:
+            st.session_state.building_info = {"project_name": ""}
+        
+        if 'components' not in st.session_state:
+            st.session_state.components = {
+                'walls': [],
+                'roofs': [],
+                'floors': [],
+                'windows': [],
+                'doors': []
+            }
+        
+        if 'internal_loads' not in st.session_state:
+            st.session_state.internal_loads = {
+                'people': [],
+                'lighting': [],
+                'equipment': []
+            }
+        
+        if 'calculation_results' not in st.session_state:
+            st.session_state.calculation_results = {
+                'cooling': {},
+                'heating': {}
+            }
+        
+        if 'saved_scenarios' not in st.session_state:
+            st.session_state.saved_scenarios = {}
+        
+        if 'climate_data' not in st.session_state:
+            st.session_state.climate_data = {}
+        
+        if 'debug_mode' not in st.session_state:
+            st.session_state.debug_mode = False
+        
+        # Initialize modules
+        self.building_info_form = BuildingInfoForm()
+        self.component_selection = ComponentSelectionInterface()
+        self.results_display = ResultsDisplay()
+        self.data_validation = DataValidation()
+        self.data_persistence = DataPersistence()
+        self.data_export = DataExport()
+        self.cooling_calculator = CoolingLoadCalculator()
+        self.heating_calculator = HeatingLoadCalculator()
+        
+        # Persist ClimateData in session_state
         if 'climate_data_obj' not in st.session_state:
             st.session_state.climate_data_obj = ClimateData()
         self.climate_data = st.session_state.climate_data_obj
-
+        
+        # Load default climate data if locations are empty
         try:
             if not self.climate_data.locations:
                 self.climate_data = ClimateData.from_json("/home/user/app/climate_data.json")
                 st.session_state.climate_data_obj = self.climate_data
         except FileNotFoundError:
             st.warning("Default climate data file not found. Please enter climate data manually.")
-        except Exception as e:
-            logger.error(f"Error loading climate data: {str(e)}")
-            st.error("Failed to initialize climate data.")
-
+        
+        self.setup_layout()
+    
     def setup_layout(self):
-        """Setup the application layout."""
         st.sidebar.title("HVAC Load Calculator")
         st.sidebar.markdown("---")
-
+        
         st.sidebar.subheader("Navigation")
         pages = [
             "Building Information",
@@ -143,294 +125,328 @@ class HVACCalculator:
             "Calculation Results",
             "Export Data"
         ]
-
+        
         selected_page = st.sidebar.radio("Go to", pages, index=pages.index(st.session_state.page))
+        
         if selected_page != st.session_state.page:
             st.session_state.page = selected_page
-
+        
         self.display_page(st.session_state.page)
-
+        
         st.sidebar.markdown("---")
         st.sidebar.info(
-            "HVAC Load Calculator v1.0.2\n\n"
+            "HVAC Load Calculator v1.0.1\n\n"
             "Based on ASHRAE steady-state calculation methods\n\n"
             "Developed by: Dr Majed Abuseif\n\n"
             "School of Architecture and Built Environment\n\n"
             "Deakin University\n\n"
             "© 2025"
         )
-
+    
     def display_page(self, page: str):
-        """Display the selected page."""
-        page_functions = {
-            "Building Information": self.building_info_form.display_building_info_form,
-            "Climate Data": self.climate_data.display_climate_input,
-            "Building Components": self.component_selection.display_component_selection,
-            "Internal Loads": self.display_internal_loads,
-            "Calculation Results": self.display_calculation_results,
-            "Export Data": lambda state: self._display_export_data(state)
-        }
-        try:
-            page_functions[page](st.session_state)
-        except AttributeError as e:
-            logger.error(f"Error displaying page {page}: {str(e)}")
-            st.error(f"Error displaying {page} page: {str(e)}")
-        except Exception as e:
-            logger.error(f"Unexpected error displaying page {page}: {str(e)}")
-            st.error(f"Unexpected error displaying {page} page: {str(e)}")
-
-    def _display_export_data(self, state):
-        """Wrapper for DataExport.display with error handling."""
-        try:
-            self.data_export.display(state)
-        except AttributeError as e:
-            logger.error(f"DataExport.display failed: {str(e)}")
-            st.error("Export Data functionality is unavailable. Please check DataExport implementation.")
-            st.write("Placeholder for Export Data page. Select export options below:")
-            st.button("Export to CSV (Not Implemented)")
-            st.button("Export to JSON (Not Implemented)")
-
+        if page == "Building Information":
+            self.building_info_form.display_building_info_form(st.session_state)
+        elif page == "Climate Data":
+            self.climate_data.display_climate_input(st.session_state)
+        elif page == "Building Components":
+            self.component_selection.display_component_selection(st.session_state)
+        elif page == "Internal Loads":
+            self.display_internal_loads()
+        elif page == "Calculation Results":
+            self.display_calculation_results()
+        elif page == "Export Data":
+            self.data_export.display()
+    
     def generate_climate_id(self, country: str, city: str) -> str:
         """Generate a climate ID from country and city names."""
         try:
             country = country.strip().title()
             city = city.strip().title()
             if len(country) < 2 or len(city) < 3:
-                raise ValueError("Country and city names must be at least 2 and 3 characters long.")
-            country_code = pycountry.countries.search_fuzzy(country)[0].alpha_2
-            return f"{country_code}-{city[:3].upper()}"
+                raise ValueError("Country and city names must be at least 2 and 3 characters long, respectively.")
+            return f"{country[:2].upper()}-{city[:3].upper()}"
         except Exception as e:
-            logger.error(f"Error generating climate ID: {str(e)}")
             raise ValueError(f"Invalid country or city name: {str(e)}")
-
+    
     def validate_calculation_inputs(self) -> Tuple[bool, str]:
         """Validate inputs for cooling and heating calculations."""
-        try:
-            building_info = st.session_state.get('building_info', {})
-            components = st.session_state.get('components', {})
-            climate_data = st.session_state.get('climate_data', {})
-
-            if not building_info.get('floor_area', 0) > 0:
-                return False, "Floor area must be positive."
-            if not any(components.get(key, []) for key in ['walls', 'roofs', 'windows']):
-                return False, "At least one wall, roof, or window must be defined."
-            if not climate_data:
-                return False, "Climate data is missing."
-
-            for component_type in ['walls', 'roofs', 'windows', 'doors', 'floors']:
-                for comp in components.get(component_type, []):
-                    if comp.area <= 0:
-                        return False, f"Invalid area for {component_type}: {comp.name}"
-                    if comp.u_value <= 0:
-                        return False, f"Invalid U-value for {component_type}: {comp.name}"
-
-            return True, "Inputs valid."
-        except Exception as e:
-            logger.error(f"Error validating inputs: {str(e)}")
-            return False, f"Validation error: {str(e)}"
-
+        building_info = st.session_state.get('building_info', {})
+        components = st.session_state.get('components', {})
+        if not building_info.get('floor_area', 0) > 0:
+            return False, "Floor area must be positive."
+        if not any(components.get(key, []) for key in ['walls', 'roofs', 'windows']):
+            return False, "At least one wall, roof, or window must be defined."
+        if not st.session_state.get('climate_data'):
+            return False, "Climate data is missing."
+        for component_type in ['walls', 'roofs', 'windows', 'doors', 'floors']:
+            for comp in components.get(component_type, []):
+                if comp.area <= 0:
+                    return False, f"Invalid area for {component_type}: {comp.name}"
+                if comp.u_value <= 0:
+                    return False, f"Invalid U-value for {component_type}: {comp.name}"
+        return True, "Inputs valid."
+    
     def validate_internal_load(self, load_type: str, new_load: Dict) -> Tuple[bool, str]:
         """Validate if a new internal load is unique and within limits."""
-        try:
-            loads = st.session_state.internal_loads.get(load_type, [])
-            max_loads = 50
-
-            if len(loads) >= max_loads:
-                return False, f"Maximum of {max_loads} {load_type} loads reached."
-
-            for existing_load in loads:
-                if load_type == 'people':
-                    if all(existing_load.get(k) == new_load.get(k) for k in ['name', 'num_people', 'activity_level', 'zone_type', 'hours_in_operation']):
-                        return False, f"Duplicate people load '{new_load['name']}' already exists."
-                elif load_type == 'lighting':
-                    if all(existing_load.get(k) == new_load.get(k) for k in ['name', 'type', 'power', 'usage_factor', 'zone_type', 'hours_in_operation']):
-                        return False, f"Duplicate lighting load '{new_load['name']}' already exists."
-                elif load_type == 'equipment':
-                    if all(existing_load.get(k) == new_load.get(k) for k in ['name', 'type', 'power', 'usage_factor', 'radiation_fraction', 'zone_type', 'hours_in_operation']):
-                        return False, f"Duplicate equipment load '{new_load['name']}' already exists."
-
-            return True, "Valid load."
-        except Exception as e:
-            logger.error(f"Error validating internal load: {str(e)}")
-            return False, f"Validation error: {str(e)}"
-
+        loads = st.session_state.internal_loads.get(load_type, [])
+        max_loads = 50
+        
+        if len(loads) >= max_loads:
+            return False, f"Maximum of {max_loads} {load_type} loads reached."
+        
+        # Check for duplicates based on key attributes
+        for existing_load in loads:
+            if load_type == 'people':
+                if (existing_load['name'] == new_load['name'] and
+                    existing_load['num_people'] == new_load['num_people'] and
+                    existing_load['activity_level'] == new_load['activity_level'] and
+                    existing_load['zone_type'] == new_load['zone_type'] and
+                    existing_load['hours_in_operation'] == new_load['hours_in_operation']):
+                    return False, f"Duplicate people load '{new_load['name']}' already exists."
+            elif load_type == 'lighting':
+                if (existing_load['name'] == new_load['name'] and
+                    existing_load['power'] == new_load['power'] and
+                    existing_load['usage_factor'] == new_load['usage_factor'] and
+                    existing_load['zone_type'] == new_load['zone_type'] and
+                    existing_load['hours_in_operation'] == new_load['hours_in_operation']):
+                    return False, f"Duplicate lighting load '{new_load['name']}' already exists."
+            elif load_type == 'equipment':
+                if (existing_load['name'] == new_load['name'] and
+                    existing_load['power'] == new_load['power'] and
+                    existing_load['usage_factor'] == new_load['usage_factor'] and
+                    existing_load['radiation_fraction'] == new_load['radiation_fraction'] and
+                    existing_load['zone_type'] == new_load['zone_type'] and
+                    existing_load['hours_in_operation'] == new_load['hours_in_operation']):
+                    return False, f"Duplicate equipment load '{new_load['name']}' already exists."
+        
+        return True, "Valid load."
+    
     def display_internal_loads(self):
-        """Display internal loads interface."""
         st.title("Internal Loads")
-
+        
+        # Reset button for all internal loads
         if st.button("Reset All Internal Loads"):
             st.session_state.internal_loads = {'people': [], 'lighting': [], 'equipment': []}
             st.success("All internal loads reset!")
             st.rerun()
-
+        
         tabs = st.tabs(["People", "Lighting", "Equipment"])
-
+        
         with tabs[0]:
-            self._display_people_loads()
-
+            st.subheader("People")
+            with st.form("people_form"):
+                num_people = st.number_input("Number of People", min_value=0, value=0, step=1)
+                activity_level = st.selectbox(
+                    "Activity Level",
+                    ["Seated/Resting", "Light Work", "Moderate Work", "Heavy Work"]
+                )
+                zone_type = st.selectbox("Zone Type", ["Office", "Classroom", "Retail", "Residential"])
+                hours_in_operation = st.number_input(
+                    "Hours in Operation",
+                    min_value=0.0,
+                    max_value=24.0,
+                    value=8.0,
+                    step=0.5
+                )
+                people_name = st.text_input("Name", value="Occupants")
+                
+                if st.form_submit_button("Add People Load"):
+                    people_load = {
+                        "id": f"people_{len(st.session_state.internal_loads['people'])}",
+                        "name": people_name,
+                        "num_people": num_people,
+                        "activity_level": activity_level,
+                        "zone_type": zone_type,
+                        "hours_in_operation": hours_in_operation
+                    }
+                    is_valid, message = self.validate_internal_load('people', people_load)
+                    if is_valid:
+                        st.session_state.internal_loads['people'].append(people_load)
+                        st.success("People load added!")
+                        st.rerun()
+                    else:
+                        st.error(message)
+            
+            if st.session_state.internal_loads['people']:
+                people_df = pd.DataFrame(st.session_state.internal_loads['people'])
+                st.dataframe(people_df, use_container_width=True)
+                
+                selected_people = st.multiselect(
+                    "Select People Loads to Delete",
+                    [load['id'] for load in st.session_state.internal_loads['people']]
+                )
+                if st.button("Delete Selected People Loads"):
+                    st.session_state.internal_loads['people'] = [
+                        load for load in st.session_state.internal_loads['people']
+                        if load['id'] not in selected_people
+                    ]
+                    st.success("Selected people loads deleted!")
+                    st.rerun()
+        
         with tabs[1]:
-            self._display_lighting_loads()
-
+            st.subheader("Lighting")
+            with st.form("lighting_form"):
+                power = st.number_input("Power (W)", min_value=0.0, value=1000.0, step=100.0)
+                usage_factor = st.number_input(
+                    "Usage Factor",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=0.8,
+                    step=0.1
+                )
+                zone_type = st.selectbox("Zone Type", ["Office", "Classroom", "Retail", "Residential"])
+                hours_in_operation = st.number_input(
+                    "Hours in Operation",
+                    min_value=0.0,
+                    max_value=24.0,
+                    value=8.0,
+                    step=0.5
+                )
+                lighting_name = st.text_input("Name", value="General Lighting")
+                
+                if st.form_submit_button("Add Lighting Load"):
+                    lighting_load = {
+                        "id": f"lighting_{len(st.session_state.internal_loads['lighting'])}",
+                        "name": lighting_name,
+                        "power": power,
+                        "usage_factor": usage_factor,
+                        "zone_type": zone_type,
+                        "hours_in_operation": hours_in_operation
+                    }
+                    is_valid, message = self.validate_internal_load('lighting', lighting_load)
+                    if is_valid:
+                        st.session_state.internal_loads['lighting'].append(lighting_load)
+                        st.success("Lighting load added!")
+                        st.rerun()
+                    else:
+                        st.error(message)
+            
+            if st.session_state.internal_loads['lighting']:
+                lighting_df = pd.DataFrame(st.session_state.internal_loads['lighting'])
+                st.dataframe(lighting_df, use_container_width=True)
+                
+                selected_lighting = st.multiselect(
+                    "Select Lighting Loads to Delete",
+                    [load['id'] for load in st.session_state.internal_loads['lighting']]
+                )
+                if st.button("Delete Selected Lighting Loads"):
+                    st.session_state.internal_loads['lighting'] = [
+                        load for load in st.session_state.internal_loads['lighting']
+                        if load['id'] not in selected_lighting
+                    ]
+                    st.success("Selected lighting loads deleted!")
+                    st.rerun()
+        
         with tabs[2]:
-            self._display_equipment_loads()
-
+            st.subheader("Equipment")
+            with st.form("equipment_form"):
+                power = st.number_input("Power (W)", min_value=0.0, value=500.0, step=100.0)
+                usage_factor = st.number_input(
+                    "Usage Factor",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=0.7,
+                    step=0.1
+                )
+                radiation_fraction = st.number_input(
+                    "Radiation Fraction",
+                    min_value=0.0,
+                    max_value=1.0,
+                    value=0.3,
+                    step=0.1
+                )
+                zone_type = st.selectbox("Zone Type", ["Office", "Classroom", "Retail", "Residential"])
+                hours_in_operation = st.number_input(
+                    "Hours in Operation",
+                    min_value=0.0,
+                    max_value=24.0,
+                    value=8.0,
+                    step=0.5
+                )
+                equipment_name = st.text_input("Name", value="Office Equipment")
+                
+                if st.form_submit_button("Add Equipment Load"):
+                    equipment_load = {
+                        "id": f"equipment_{len(st.session_state.internal_loads['equipment'])}",
+                        "name": equipment_name,
+                        "power": power,
+                        "usage_factor": usage_factor,
+                        "radiation_fraction": radiation_fraction,
+                        "zone_type": zone_type,
+                        "hours_in_operation": hours_in_operation
+                    }
+                    is_valid, message = self.validate_internal_load('equipment', equipment_load)
+                    if is_valid:
+                        st.session_state.internal_loads['equipment'].append(equipment_load)
+                        st.success("Equipment load added!")
+                        st.rerun()
+                    else:
+                        st.error(message)
+            
+            if st.session_state.internal_loads['equipment']:
+                equipment_df = pd.DataFrame(st.session_state.internal_loads['equipment'])
+                st.dataframe(equipment_df, use_container_width=True)
+                
+                selected_equipment = st.multiselect(
+                    "Select Equipment Loads to Delete",
+                    [load['id'] for load in st.session_state.internal_loads['equipment']]
+                )
+                if st.button("Delete Selected Equipment Loads"):
+                    st.session_state.internal_loads['equipment'] = [
+                        load for load in st.session_state.internal_loads['equipment']
+                        if load['id'] not in selected_equipment
+                    ]
+                    st.success("Selected equipment loads deleted!")
+                    st.rerun()
+        
         col1, col2 = st.columns(2)
         with col1:
-            st.button("Back to Building Components", on_click=lambda: setattr(st.session_state, "page", "Building Components"))
+            st.button(
+                "Back to Building Components",
+                on_click=lambda: setattr(st.session_state, "page", "Building Components")
+            )
         with col2:
-            st.button("Continue to Calculation Results", on_click=lambda: setattr(st.session_state, "page", "Calculation Results"))
-
-    def _display_people_loads(self):
-        """Display people loads form and table."""
-        st.subheader("People")
-        activity_levels = list(self.reference_data.internal_loads.get('occupancy', {}).keys())
-
-        with st.form("people_form"):
-            num_people = st.number_input("Number of People", min_value=0, value=0, step=1)
-            activity_level = st.selectbox("Activity Level", activity_levels if activity_levels else ["office_typing", "retail_sales"])
-            zone_type = st.selectbox("Zone Type", ["Office", "Classroom", "Retail", "Residential"])
-            hours_in_operation = st.number_input("Hours in Operation", min_value=0.0, max_value=24.0, value=8.0, step=0.5)
-            people_name = st.text_input("Name", value="Occupants")
-
-            if st.form_submit_button("Add People Load"):
-                people_load = {
-                    "id": f"people_{str(uuid4())}",
-                    "name": people_name,
-                    "num_people": num_people,
-                    "activity_level": activity_level,
-                    "zone_type": zone_type,
-                    "hours_in_operation": hours_in_operation
-                }
-                is_valid, message = self.validate_internal_load('people', people_load)
-                if is_valid:
-                    st.session_state.internal_loads['people'].append(people_load)
-                    st.success("People load added!")
-                    st.rerun()
-                else:
-                    st.error(message)
-
-        if st.session_state.internal_loads['people']:
-            people_df = pd.DataFrame(st.session_state.internal_loads['people'])
-            st.dataframe(people_df, use_container_width=True)
-
-            selected_people = st.multiselect("Select People Loads to Delete", [load['id'] for load in st.session_state.internal_loads['people']])
-            if st.button("Delete Selected People Loads"):
-                st.session_state.internal_loads['people'] = [load for load in st.session_state.internal_loads['people'] if load['id'] not in selected_people]
-                st.success("Selected people loads deleted!")
-                st.rerun()
-
-    def _display_lighting_loads(self):
-        """Display lighting loads form and table."""
-        st.subheader("Lighting")
-        lighting_types = list(self.reference_data.internal_loads.get('lighting', {}).keys())
-
-        with st.form("lighting_form"):
-            lighting_type = st.selectbox("Lighting Type", lighting_types if lighting_types else ["led_high_efficiency"])
-            power = st.number_input("Power (W)", min_value=0.0, value=1000.0, step=100.0)
-            usage_factor = st.number_input("Usage Factor", min_value=0.0, max_value=1.0, value=0.8, step=0.1)
-            zone_type = st.selectbox("Zone Type", ["Office", "Classroom", "Retail", "Residential"])
-            hours_in_operation = st.number_input("Hours in Operation", min_value=0.0, max_value=24.0, value=8.0, step=0.5)
-            lighting_name = st.text_input("Name", value="General Lighting")
-
-            if st.form_submit_button("Add Lighting Load"):
-                lighting_load = {
-                    "id": f"lighting_{str(uuid4())}",
-                    "name": lighting_name,
-                    "type": lighting_type,
-                    "power": power,
-                    "usage_factor": usage_factor,
-                    "zone_type": zone_type,
-                    "hours_in_operation": hours_in_operation
-                }
-                is_valid, message = self.validate_internal_load('lighting', lighting_load)
-                if is_valid:
-                    st.session_state.internal_loads['lighting'].append(lighting_load)
-                    st.success("Lighting load added!")
-                    st.rerun()
-                else:
-                    st.error(message)
-
-        if st.session_state.internal_loads['lighting']:
-            lighting_df = pd.DataFrame(st.session_state.internal_loads['lighting'])
-            st.dataframe(lighting_df, use_container_width=True)
-
-            selected_lighting = st.multiselect("Select Lighting Loads to Delete", [load['id'] for load in st.session_state.internal_loads['lighting']])
-            if st.button("Delete Selected Lighting Loads"):
-                st.session_state.internal_loads['lighting'] = [load for load in st.session_state.internal_loads['lighting'] if load['id'] not in selected_lighting]
-                st.success("Selected lighting loads deleted!")
-                st.rerun()
-
-    def _display_equipment_loads(self):
-        """Display equipment loads form and table."""
-        st.subheader("Equipment")
-        equipment_types = list(self.reference_data.internal_loads.get('equipment', {}).keys())
-
-        with st.form("equipment_form"):
-            equipment_type = st.selectbox("Equipment Type", equipment_types if equipment_types else ["computer_workstation"])
-            power = st.number_input("Power (W)", min_value=0.0, value=500.0, step=100.0)
-            usage_factor = st.number_input("Usage Factor", min_value=0.0, max_value=1.0, value=0.7, step=0.1)
-            radiation_fraction = st.number_input("Radiation Fraction", min_value=0.0, max_value=1.0, value=0.3, step=0.1)
-            zone_type = st.selectbox("Zone Type", ["Office", "Classroom", "Retail", "Residential"])
-            hours_in_operation = st.number_input("Hours in Operation", min_value=0.0, max_value=24.0, value=8.0, step=0.5)
-            equipment_name = st.text_input("Name", value="Office Equipment")
-
-            if st.form_submit_button("Add Equipment Load"):
-                equipment_load = {
-                    "id": f"equipment_{str(uuid4())}",
-                    "name": equipment_name,
-                    "type": equipment_type,
-                    "power": power,
-                    "usage_factor": usage_factor,
-                    "radiation_fraction": radiation_fraction,
-                    "zone_type": zone_type,
-                    "hours_in_operation": hours_in_operation
-                }
-                is_valid, message = self.validate_internal_load('equipment', equipment_load)
-                if is_valid:
-                    st.session_state.internal_loads['equipment'].append(equipment_load)
-                    st.success("Equipment load added!")
-                    st.rerun()
-                else:
-                    st.error(message)
-
-        if st.session_state.internal_loads['equipment']:
-            equipment_df = pd.DataFrame(st.session_state.internal_loads['equipment'])
-            st.dataframe(equipment_df, use_container_width=True)
-
-            selected_equipment = st.multiselect("Select Equipment Loads to Delete", [load['id'] for load in st.session_state.internal_loads['equipment']])
-            if st.button("Delete Selected Equipment Loads"):
-                st.session_state.internal_loads['equipment'] = [load for load in st.session_state.internal_loads['equipment'] if load['id'] not in selected_equipment]
-                st.success("Selected equipment loads deleted!")
-                st.rerun()
-
+            st.button(
+                "Continue to Calculation Results",
+                on_click=lambda: setattr(st.session_state, "page", "Calculation Results")
+            )
+    
     def calculate_cooling(self) -> Tuple[bool, str, Dict]:
         """
         Calculate cooling loads using CoolingLoadCalculator.
         Returns: (success, message, results)
         """
         try:
+            # Validate inputs
             valid, message = self.validate_calculation_inputs()
             if not valid:
                 return False, message, {}
-
+            
+            # Gather inputs
             building_components = st.session_state.get('components', {})
             internal_loads = st.session_state.get('internal_loads', {})
             building_info = st.session_state.get('building_info', {})
-
+            
+            # Check climate data
+            if "climate_data" not in st.session_state or not st.session_state["climate_data"]:
+                return False, "Please enter climate data in the 'Climate Data' page.", {}
+            
+            # Extract climate data
             country = building_info.get('country', '').strip().title()
             city = building_info.get('city', '').strip().title()
             if not country or not city:
                 return False, "Country and city must be set in Building Information.", {}
-
             climate_id = self.generate_climate_id(country, city)
             location = self.climate_data.get_location_by_id(climate_id, st.session_state)
             if not location:
                 available_locations = list(self.climate_data.locations.keys())[:5]
                 return False, f"No climate data for {climate_id}. Available locations: {', '.join(available_locations)}...", {}
-
+            
+            # Validate climate data
             if not all(k in location for k in ['summer_design_temp_db', 'summer_design_temp_wb', 'monthly_temps', 'latitude']):
                 return False, f"Invalid climate data for {climate_id}. Missing required fields.", {}
-
+            
+            # Format conditions
             outdoor_conditions = {
                 'temperature': location['summer_design_temp_db'],
                 'relative_humidity': location['monthly_humidity'].get('Jul', 50.0),
@@ -438,26 +454,46 @@ class HVACCalculator:
                 'month': 'Jul',
                 'latitude': f"{location['latitude']}N" if location['latitude'] >= 0 else f"{abs(location['latitude'])}S",
                 'wind_speed': building_info.get('wind_speed', 4.0),
-                'day_of_year': 204
+                'day_of_year': 204  # Approx. July 23
             }
             indoor_conditions = {
                 'temperature': building_info.get('indoor_temp', 24.0),
                 'relative_humidity': building_info.get('indoor_rh', 50.0)
             }
-
+            
             if st.session_state.get('debug_mode', False):
                 st.write("Debug: Cooling Input State", {
                     'climate_id': climate_id,
                     'outdoor_conditions': outdoor_conditions,
                     'indoor_conditions': indoor_conditions,
                     'components': {k: len(v) for k, v in building_components.items()},
-                    'internal_loads': {k: len(v) for k, v in internal_loads.items()}
+                    'internal_loads': {
+                        'people': len(internal_loads.get('people', [])),
+                        'lighting': len(internal_loads.get('lighting', [])),
+                        'equipment': len(internal_loads.get('equipment', []))
+                    },
+                    'building_info': building_info
                 })
-
+            
+            # Format internal loads
             formatted_internal_loads = {
-                'people': [],
-                'lights': [],
-                'equipment': [],
+                'people': {
+                    'number': sum(load['num_people'] for load in internal_loads.get('people', [])),
+                    'activity_level': internal_loads.get('people', [{}])[0].get('activity_level', 'Seated/Resting'),
+                    'operating_hours': f"{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)}:00-{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)+10}:00"
+                },
+                'lights': {
+                    'power': sum(load['power'] for load in internal_loads.get('lighting', [])),
+                    'use_factor': internal_loads.get('lighting', [{}])[0].get('usage_factor', 0.8),
+                    'special_allowance': 0.1,
+                    'hours_operation': f"{internal_loads.get('lighting', [{}])[0].get('hours_in_operation', 8)}h"
+                },
+                'equipment': {
+                    'power': sum(load['power'] for load in internal_loads.get('equipment', [])),
+                    'use_factor': internal_loads.get('equipment', [{}])[0].get('usage_factor', 0.7),
+                    'radiation_factor': internal_loads.get('equipment', [{}])[0].get('radiation_fraction', 0.3),
+                    'hours_operation': f"{internal_loads.get('equipment', [{}])[0].get('hours_in_operation', 8)}h"
+                },
                 'infiltration': {
                     'flow_rate': building_info.get('infiltration_rate', 0.05),
                     'height': building_info.get('building_height', 3.0),
@@ -468,36 +504,8 @@ class HVACCalculator:
                 },
                 'operating_hours': building_info.get('operating_hours', '8:00-18:00')
             }
-
-            for load in internal_loads.get('people', []):
-                ref_load = self.reference_data.get_internal_load('occupancy', load['activity_level'])
-                formatted_internal_loads['people'].append({
-                    'number': load['num_people'],
-                    'sensible_heat': ref_load.get('sensible_heat', 70) if ref_load else 70,
-                    'latent_heat': ref_load.get('latent_heat', 45) if ref_load else 45,
-                    'hours_operation': f"{load['hours_in_operation']}:00-{load['hours_in_operation']+10}:00"
-                })
-
-            for load in internal_loads.get('lighting', []):
-                ref_load = self.reference_data.get_internal_load('lighting', load['type'])
-                formatted_internal_loads['lights'].append({
-                    'power': load['power'],
-                    'use_factor': load['usage_factor'],
-                    'heat_to_space': ref_load.get('heat_to_space', 0.9) if ref_load else 0.9,
-                    'hours_operation': f"{load['hours_in_operation']}h"
-                })
-
-            for load in internal_loads.get('equipment', []):
-                ref_load = self.reference_data.get_internal_load('equipment', load['type'])
-                formatted_internal_loads['equipment'].append({
-                    'power': load['power'],
-                    'use_factor': load['usage_factor'],
-                    'radiation_factor': load['radiation_fraction'],
-                    'sensible_fraction': ref_load.get('sensible_fraction', 0.9) if ref_load else 0.9,
-                    'latent_fraction': ref_load.get('latent_fraction', 0.1) if ref_load else 0.1,
-                    'hours_operation': f"{load['hours_in_operation']}h"
-                })
-
+            
+            # Calculate hourly loads
             hourly_loads = self.cooling_calculator.calculate_hourly_cooling_loads(
                 building_components=building_components,
                 outdoor_conditions=outdoor_conditions,
@@ -506,16 +514,19 @@ class HVACCalculator:
                 building_volume=building_info.get('floor_area', 100.0) * building_info.get('building_height', 3.0)
             )
             if not hourly_loads:
-                return False, "Cooling hourly loads calculation failed.", {}
-
+                return False, "Cooling hourly loads calculation failed. Check input data.", {}
+            
+            # Get design loads
             design_loads = self.cooling_calculator.calculate_design_cooling_load(hourly_loads)
             if not design_loads:
-                return False, "Cooling design loads calculation failed.", {}
-
+                return False, "Cooling design loads calculation failed. Check input data.", {}
+            
+            # Get summary
             summary = self.cooling_calculator.calculate_cooling_load_summary(design_loads)
             if not summary:
-                return False, "Cooling load summary calculation failed.", {}
-
+                return False, "Cooling load summary calculation failed. Check input data.", {}
+            
+            # Format results for results_display.py
             floor_area = building_info.get('floor_area', 100.0) or 100.0
             results = {
                 'total_load': summary['total'] / 1000,  # kW
@@ -554,7 +565,7 @@ class HVACCalculator:
                 },
                 'building_info': building_info
             }
-
+            
             # Populate detailed loads
             for wall in building_components.get('walls', []):
                 load = self.cooling_calculator.calculate_wall_cooling_load(
@@ -582,7 +593,7 @@ class HVACCalculator:
                     ),
                     'load': load / 1000
                 })
-
+            
             for roof in building_components.get('roofs', []):
                 load = self.cooling_calculator.calculate_roof_cooling_load(
                     roof=roof,
@@ -608,7 +619,7 @@ class HVACCalculator:
                     ),
                     'load': load / 1000
                 })
-
+            
             for window in building_components.get('windows', []):
                 load_dict = self.cooling_calculator.calculate_window_cooling_load(
                     window=window,
@@ -636,7 +647,7 @@ class HVACCalculator:
                     ),
                     'load': load_dict['total'] / 1000
                 })
-
+            
             for door in building_components.get('doors', []):
                 load = self.cooling_calculator.calculate_door_cooling_load(
                     door=door,
@@ -651,18 +662,16 @@ class HVACCalculator:
                     'cltd': outdoor_conditions['temperature'] - indoor_conditions['temperature'],
                     'load': load / 1000
                 })
-
+            
             for load_type, key in [('people', 'people'), ('lighting', 'lights'), ('equipment', 'equipment')]:
                 for load in internal_loads.get(key, []):
                     if load_type == 'people':
-                        ref_load = self.reference_data.get_internal_load('occupancy', load['activity_level'])
                         load_dict = self.cooling_calculator.calculate_people_cooling_load(
                             num_people=load['num_people'],
                             activity_level=load['activity_level'],
                             hour=design_loads['design_hour']
                         )
                     elif load_type == 'lighting':
-                        ref_load = self.reference_data.get_internal_load('lighting', load['type'])
                         load_dict = {'total': self.cooling_calculator.calculate_lights_cooling_load(
                             power=load['power'],
                             use_factor=load['usage_factor'],
@@ -670,7 +679,6 @@ class HVACCalculator:
                             hour=design_loads['design_hour']
                         )}
                     else:
-                        ref_load = self.reference_data.get_internal_load('equipment', load['type'])
                         load_dict = self.cooling_calculator.calculate_equipment_cooling_load(
                             power=load['power'],
                             use_factor=load['usage_factor'],
@@ -689,54 +697,62 @@ class HVACCalculator:
                         ) if load_type == 'people' else 1.0,
                         'load': load_dict['total'] / 1000
                     })
-
+            
             if st.session_state.get('debug_mode', False):
                 st.write("Debug: Cooling Results", {
                     'total_load': results.get('total_load', 'N/A'),
                     'component_loads': results.get('component_loads', 'N/A'),
                     'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
                 })
-
+            
             return True, "Cooling calculation completed.", results
-
+        
         except ValueError as ve:
-            logger.error(f"Input error in cooling calculation: {str(ve)}")
+            st.error(f"Input error in cooling calculation: {str(ve)}")
             return False, f"Input error: {str(ve)}", {}
         except KeyError as ke:
-            logger.error(f"Missing data in cooling calculation: {str(ke)}")
+            st.error(f"Missing data in cooling calculation: {str(ke)}")
             return False, f"Missing data: {str(ke)}", {}
         except Exception as e:
-            logger.error(f"Unexpected error in cooling calculation: {str(e)}")
+            st.error(f"Unexpected error in cooling calculation: {str(e)}")
             return False, f"Unexpected error: {str(e)}", {}
-
+    
     def calculate_heating(self) -> Tuple[bool, str, Dict]:
         """
         Calculate heating loads using HeatingLoadCalculator.
         Returns: (success, message, results)
         """
         try:
+            # Validate inputs
             valid, message = self.validate_calculation_inputs()
             if not valid:
                 return False, message, {}
-
+            
+            # Gather inputs
             building_components = st.session_state.get('components', {})
             internal_loads = st.session_state.get('internal_loads', {})
             building_info = st.session_state.get('building_info', {})
-
+            
+            # Check climate data
+            if "climate_data" not in st.session_state or not st.session_state["climate_data"]:
+                return False, "Please enter climate data in the 'Climate Data' page.", {}
+            
+            # Extract climate data
             country = building_info.get('country', '').strip().title()
             city = building_info.get('city', '').strip().title()
             if not country or not city:
                 return False, "Country and city must be set in Building Information.", {}
-
             climate_id = self.generate_climate_id(country, city)
             location = self.climate_data.get_location_by_id(climate_id, st.session_state)
             if not location:
                 available_locations = list(self.climate_data.locations.keys())[:5]
                 return False, f"No climate data for {climate_id}. Available locations: {', '.join(available_locations)}...", {}
-
+            
+            # Validate climate data
             if not all(k in location for k in ['winter_design_temp', 'monthly_temps', 'monthly_humidity']):
                 return False, f"Invalid climate data for {climate_id}. Missing required fields.", {}
-
+            
+            # Format conditions
             outdoor_conditions = {
                 'design_temperature': location['winter_design_temp'],
                 'design_relative_humidity': location['monthly_humidity'].get('Jan', 80.0),
@@ -747,20 +763,38 @@ class HVACCalculator:
                 'temperature': building_info.get('indoor_temp', 21.0),
                 'relative_humidity': building_info.get('indoor_rh', 40.0)
             }
-
+            
             if st.session_state.get('debug_mode', False):
                 st.write("Debug: Heating Input State", {
                     'climate_id': climate_id,
                     'outdoor_conditions': outdoor_conditions,
                     'indoor_conditions': indoor_conditions,
                     'components': {k: len(v) for k, v in building_components.items()},
-                    'internal_loads': {k: len(v) for k, v in internal_loads.items()}
+                    'internal_loads': {
+                        'people': len(internal_loads.get('people', [])),
+                        'lighting': len(internal_loads.get('lighting', [])),
+                        'equipment': len(internal_loads.get('equipment', []))
+                    },
+                    'building_info': building_info
                 })
-
+            
+            # Format internal loads
             formatted_internal_loads = {
-                'people': [],
-                'lights': [],
-                'equipment': [],
+                'people': {
+                    'number': sum(load['num_people'] for load in internal_loads.get('people', [])),
+                    'sensible_gain': 70,
+                    'operating_hours': f"{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)}:00-{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)+10}:00"
+                },
+                'lights': {
+                    'power': sum(load['power'] for load in internal_loads.get('lighting', [])),
+                    'use_factor': internal_loads.get('lighting', [{}])[0].get('usage_factor', 0.8),
+                    'hours_operation': f"{internal_loads.get('lighting', [{}])[0].get('hours_in_operation', 8)}h"
+                },
+                'equipment': {
+                    'power': sum(load['power'] for load in internal_loads.get('equipment', [])),
+                    'use_factor': internal_loads.get('equipment', [{}])[0].get('usage_factor', 0.7),
+                    'hours_operation': f"{internal_loads.get('equipment', [{}])[0].get('hours_in_operation', 8)}h"
+                },
                 'infiltration': {
                     'flow_rate': building_info.get('infiltration_rate', 0.05),
                     'height': building_info.get('building_height', 3.0),
@@ -772,33 +806,8 @@ class HVACCalculator:
                 'usage_factor': 0.7,
                 'operating_hours': building_info.get('operating_hours', '8:00-18:00')
             }
-
-            for load in internal_loads.get('people', []):
-                ref_load = self.reference_data.get_internal_load('occupancy', load['activity_level'])
-                formatted_internal_loads['people'].append({
-                    'number': load['num_people'],
-                    'sensible_heat': ref_load.get('sensible_heat', 70) if ref_load else 70,
-                    'hours_operation': f"{load['hours_in_operation']}:00-{load['hours_in_operation']+10}:00"
-                })
-
-            for load in internal_loads.get('lighting', []):
-                ref_load = self.reference_data.get_internal_load('lighting', load['type'])
-                formatted_internal_loads['lights'].append({
-                    'power': load['power'],
-                    'use_factor': load['usage_factor'],
-                    'heat_to_space': ref_load.get('heat_to_space', 0.9) if ref_load else 0.9,
-                    'hours_operation': f"{load['hours_in_operation']}h"
-                })
-
-            for load in internal_loads.get('equipment', []):
-                ref_load = self.reference_data.get_internal_load('equipment', load['type'])
-                formatted_internal_loads['equipment'].append({
-                    'power': load['power'],
-                    'use_factor': load['usage_factor'],
-                    'sensible_fraction': ref_load.get('sensible_fraction', 0.9) if ref_load else 0.9,
-                    'hours_operation': f"{load['hours_in_operation']}h"
-                })
-
+            
+            # Calculate design loads
             design_loads = self.heating_calculator.calculate_design_heating_load(
                 building_components=building_components,
                 outdoor_conditions=outdoor_conditions,
@@ -806,12 +815,14 @@ class HVACCalculator:
                 internal_loads=formatted_internal_loads
             )
             if not design_loads:
-                return False, "Heating design loads calculation failed.", {}
-
+                return False, "Heating design loads calculation failed. Check input data.", {}
+            
+            # Get summary
             summary = self.heating_calculator.calculate_heating_load_summary(design_loads)
             if not summary:
-                return False, "Heating load summary calculation failed.", {}
-
+                return False, "Heating load summary calculation failed. Check input data.", {}
+            
+            # Format results
             floor_area = building_info.get('floor_area', 100.0) or 100.0
             results = {
                 'total_load': summary['total'] / 1000,  # kW
@@ -846,7 +857,8 @@ class HVACCalculator:
                 },
                 'building_info': building_info
             }
-
+            
+            # Populate detailed loads
             delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
             for wall in building_components.get('walls', []):
                 load = self.heating_calculator.calculate_wall_heating_load(
@@ -862,7 +874,7 @@ class HVACCalculator:
                     'delta_t': delta_t,
                     'load': load / 1000
                 })
-
+            
             for roof in building_components.get('roofs', []):
                 load = self.heating_calculator.calculate_roof_heating_load(
                     roof=roof,
@@ -877,7 +889,7 @@ class HVACCalculator:
                     'delta_t': delta_t,
                     'load': load / 1000
                 })
-
+            
             for floor in building_components.get('floors', []):
                 load = self.heating_calculator.calculate_floor_heating_load(
                     floor=floor,
@@ -891,7 +903,7 @@ class HVACCalculator:
                     'delta_t': indoor_conditions['temperature'] - outdoor_conditions['ground_temperature'],
                     'load': load / 1000
                 })
-
+            
             for window in building_components.get('windows', []):
                 load = self.heating_calculator.calculate_window_heating_load(
                     window=window,
@@ -906,7 +918,7 @@ class HVACCalculator:
                     'delta_t': delta_t,
                     'load': load / 1000
                 })
-
+            
             for door in building_components.get('doors', []):
                 load = self.heating_calculator.calculate_door_heating_load(
                     door=door,
@@ -921,66 +933,71 @@ class HVACCalculator:
                     'delta_t': delta_t,
                     'load': load / 1000
                 })
-
+            
             if st.session_state.get('debug_mode', False):
                 st.write("Debug: Heating Results", {
                     'total_load': results.get('total_load', 'N/A'),
                     'component_loads': results.get('component_loads', 'N/A'),
                     'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
                 })
-
+            
             return True, "Heating calculation completed.", results
-
+        
         except ValueError as ve:
-            logger.error(f"Input error in heating calculation: {str(ve)}")
+            st.error(f"Input error in heating calculation: {str(ve)}")
             return False, f"Input error: {str(ve)}", {}
         except KeyError as ke:
-            logger.error(f"Missing data in heating calculation: {str(ke)}")
+            st.error(f"Missing data in heating calculation: {str(ke)}")
             return False, f"Missing data: {str(ke)}", {}
         except Exception as e:
-            logger.error(f"Unexpected error in heating calculation: {str(e)}")
+            st.error(f"Unexpected error in heating calculation: {str(e)}")
             return False, f"Unexpected error: {str(e)}", {}
-
+    
     def display_calculation_results(self):
-        """Display calculation results interface."""
         st.title("Calculation Results")
-
+        
         col1, col2 = st.columns(2)
         with col1:
             calculate_button = st.button("Calculate Loads")
         with col2:
             st.session_state.debug_mode = st.checkbox("Debug Mode", value=st.session_state.get('debug_mode', False))
-
+            
         if calculate_button:
+            # Reset results
             st.session_state.calculation_results = {'cooling': {}, 'heating': {}}
-
+            
             with st.spinner("Calculating loads..."):
+                # Calculate cooling load
                 cooling_success, cooling_message, cooling_results = self.calculate_cooling()
                 if cooling_success:
                     st.session_state.calculation_results['cooling'] = cooling_results
                     st.success(cooling_message)
                 else:
                     st.error(cooling_message)
-
+                
+                # Calculate heating load
                 heating_success, heating_message, heating_results = self.calculate_heating()
                 if heating_success:
                     st.session_state.calculation_results['heating'] = heating_results
                     st.success(heating_message)
                 else:
                     st.error(heating_message)
-
+        
+        # Display results
         self.results_display.display_results(st.session_state)
-
+        
+        # Navigation
         col1, col2 = st.columns(2)
         with col1:
-            st.button("Back to Internal Loads", on_click=lambda: setattr(st.session_state, "page", "Internal Loads"))
+            st.button(
+                "Back to Internal Loads",
+                on_click=lambda: setattr(st.session_state, "page", "Internal Loads")
+            )
         with col2:
-            st.button("Continue to Export Data", on_click=lambda: setattr(st.session_state, "page", "Export Data"))
-
+            st.button(
+                "Continue to Export Data",
+                on_click=lambda: setattr(st.session_state, "page", "Export Data")
+            )
 
 if __name__ == "__main__":
-    try:
-        app = HVACCalculator()
-    except Exception as e:
-        logger.error(f"Error initializing HVACCalculator: {str(e)}")
-        st.error(f"Failed to initialize application: {str(e)}")
+    app = HVACCalculator()