Upload 4 files

app/main.py

@@ -1,720 +1,15 @@
-"""
-HVAC Calculator Code Documentation
-
-This module contains the main Streamlit application for the HVAC Calculator.
-It provides a comprehensive interface for calculating heating and cooling loads
-using ASHRAE methods.
-
-Author: Manus AI
-Date: March 2025
-Version: 1.0.0
-"""
-
 import streamlit as st
 import pandas as pd
 import numpy as np
-import plotly.graph_objects as go
-import plotly.express as px
-import matplotlib.pyplot as plt
-import json
 import os
 import sys
-from typing import Dict, List, Any, Optional, Tuple
-
-# Import application modules
-from app.building_info_form import BuildingInfoForm
-from app.component_selection_redesign import ComponentSelectionRedesigned
-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
-from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
-from data.reference_data import ReferenceData
-from data.climate_data import ClimateData
-from data.ashrae_tables import ASHRAETables
-
-# Import utility modules
-from utils.component_library import ComponentLibrary
-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 HeatTransfer
-from utils.cooling_load import CoolingLoad
-from utils.heating_load import HeatingLoad
-from utils.component_visualization import ComponentVisualization
-from utils.scenario_comparison import ScenarioComparison
-from utils.psychrometric_visualization import PsychrometricVisualization
-from utils.time_based_visualization import TimeBasedVisualization
-
 
-class HVACCalculator:
-    """Main HVAC Calculator application class."""
-    
-    def __init__(self):
-        """Initialize the HVAC Calculator application."""
-        # Set page configuration
-        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 application modules
-        self._initialize_modules()
-        
-        # Setup application layout
-        self.setup_layout()
-    
-    def _initialize_session_state(self):
-        """Initialize Streamlit session state variables."""
-        # Initialize page navigation
-        if "page" not in st.session_state:
-            st.session_state.page = "building_info"
-        
-        # Initialize calculation results
-        if "calculation_results" not in st.session_state:
-            st.session_state.calculation_results = {
-                "cooling_load": {},
-                "heating_load": {},
-                "psychrometrics": {}
-            }
-            
-        # Initialize calculation trigger
-        if "should_run_calculations" not in st.session_state:
-            st.session_state.should_run_calculations = False
-    
-    def _initialize_modules(self):
-        """Initialize application modules."""
-        # Application modules
-        self.building_info_form = BuildingInfoForm()
-        self.component_selection = ComponentSelectionRedesigned()
-        self.results_display = ResultsDisplay()
-        self.data_validation = DataValidation()
-        self.data_persistence = DataPersistence()
-        self.data_export = DataExport()
-        
-        # Data modules
-        self.reference_data = ReferenceData()
-        self.climate_data = ClimateData()
-        self.ashrae_tables = ASHRAETables()
-        
-        # Utility modules
-        self.component_library = ComponentLibrary()
-        self.u_value_calculator = UValueCalculator()
-        self.shading_system = ShadingSystem()
-        self.area_calculation_system = AreaCalculationSystem()
-        self.psychrometrics = Psychrometrics()
-        self.heat_transfer = HeatTransfer()
-        self.cooling_load = CoolingLoad()
-        self.heating_load = HeatingLoad()
-        self.component_visualization = ComponentVisualization()
-        self.scenario_comparison = ScenarioComparison()
-        self.psychrometric_visualization = PsychrometricVisualization()
-        self.time_based_visualization = TimeBasedVisualization()
-    
-    def setup_layout(self):
-        """Setup the application layout."""
-        # Display header
-        st.title("HVAC Load Calculator")
-        st.markdown("A comprehensive tool for calculating heating and cooling loads using ASHRAE methods.")
-        
-        # Setup sidebar
-        self.setup_sidebar()
-        
-        # Run calculations when triggered
-        if st.session_state.should_run_calculations:
-            self.run_calculations()
-            # Reset the flag after running calculations
-            st.session_state.should_run_calculations = False
-        
-        # Display current page
-        self.display_page(st.session_state.page)
-    
-    def setup_sidebar(self):
-        """Setup the application sidebar."""
-        with st.sidebar:
-            st.header("Navigation")
-            
-            # Navigation buttons
-            if st.button("Building Information", key="nav_building_info"):
-                st.session_state.page = "building_info"
-            
-            if st.button("Building Components", key="nav_components"):
-                st.session_state.page = "components"
-            
-            if st.button("Internal Loads", key="nav_internal_loads"):
-                st.session_state.page = "internal_loads"
-            
-            if st.button("Calculation Results", key="nav_results"):
-                st.session_state.page = "results"
-            
-            if st.button("Export Data", key="nav_export"):
-                st.session_state.page = "export"
-            
-            st.markdown("---")
-            
-            # Run calculations button - using a callback function
-            def on_run_calculations_click():
-                st.session_state.should_run_calculations = True
-                
-            st.button("Run Calculations", key="run_calc_button", on_click=on_run_calculations_click)
-            
-            st.markdown("---")
-            
-            # Display application info
-            st.subheader("About")
-            st.write("HVAC Load Calculator v1.0.0")
-            st.write("© 2025 Manus AI")
-    
-    def display_page(self, page: str):
-        """
-        Display the selected page.
-        
-        Args:
-            page: Page to display
-        """
-        if page == "building_info":
-            self.building_info_form.display()
-        elif page == "components":
-            self.component_selection.display()
-        elif page == "internal_loads":
-            self.display_internal_loads()
-        elif page == "results":
-            self.results_display.display()
-        elif page == "export":
-            self.data_export.display()
-    
-    def display_internal_loads(self):
-        """Display internal loads interface."""
-        st.header("Internal Loads")
-        
-        # Initialize internal loads in session state if not exists
-        if "internal_loads" not in st.session_state:
-            st.session_state.internal_loads = {
-                "people": [],
-                "lighting": [],
-                "equipment": []
-            }
-        
-        # Create tabs for different internal load types
-        tab1, tab2, tab3 = st.tabs(["People", "Lighting", "Equipment"])
-        
-        with tab1:
-            st.subheader("People")
-            
-            # Display existing people loads
-            if st.session_state.internal_loads["people"]:
-                st.write("Existing People Loads:")
-                
-                # Create a table of existing people loads
-                people_data = []
-                for i, load in enumerate(st.session_state.internal_loads["people"]):
-                    people_data.append({
-                        "ID": i + 1,
-                        "Zone": load.get("zone", "Main Zone"),
-                        "Number of People": load.get("count", 0),
-                        "Activity Level": load.get("activity", "Seated, light work"),
-                        "Sensible Heat (W/person)": load.get("sensible_heat", 70),
-                        "Latent Heat (W/person)": load.get("latent_heat", 45),
-                        "Schedule": load.get("schedule", "8 AM - 6 PM")
-                    })
-                
-                people_df = pd.DataFrame(people_data)
-                st.dataframe(people_df)
-                
-                # Add edit and delete buttons for people loads
-                col1, col2 = st.columns(2)
-                with col1:
-                    people_to_edit = st.selectbox(
-                        "Select people load to edit:",
-                        options=range(1, len(st.session_state.internal_loads["people"]) + 1),
-                        format_func=lambda x: f"People Load #{x}: {st.session_state.internal_loads['people'][x-1].get('zone', 'Main Zone')}"
-                    )
-                
-                with col2:
-                    edit_col, delete_col = st.columns(2)
-                    with edit_col:
-                        if st.button("Edit People Load", key="edit_people"):
-                            st.session_state.people_to_edit = people_to_edit - 1
-                    
-                    with delete_col:
-                        if st.button("Delete People Load", key="delete_people"):
-                            st.session_state.internal_loads["people"].pop(people_to_edit - 1)
-            
-            # Add new people load form
-            st.write("Add New People Load:")
-            
-            # Check if we're editing an existing people load
-            editing_people = "people_to_edit" in st.session_state
-            people_to_edit = st.session_state.get("people_to_edit", None)
-            
-            # Get the people load to edit if we're editing
-            people_load = None
-            if editing_people and people_to_edit is not None:
-                people_load = st.session_state.internal_loads["people"][people_to_edit]
-            
-            # People load form
-            with st.form(key="people_form"):
-                # Zone name
-                zone_name = st.text_input(
-                    "Zone Name:",
-                    value=people_load.get("zone", "Main Zone") if people_load else "Main Zone"
-                )
-                
-                # Number of people
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    people_count = st.number_input(
-                        "Number of People:",
-                        min_value=1.0,
-                        max_value=1000.0,
-                        value=float(people_load.get("count", 1)) if people_load else 1.0,
-                        step=1.0
-                    )
-                
-                with col2:
-                    activity_options = [
-                        "Seated, resting",
-                        "Seated, light work",
-                        "Seated, moderate work",
-                        "Standing, light work",
-                        "Standing, moderate work",
-                        "Walking, light work",
-                        "Walking, moderate work",
-                        "Heavy work"
-                    ]
-                    
-                    activity = st.selectbox(
-                        "Activity Level:",
-                        options=activity_options,
-                        index=activity_options.index(people_load.get("activity", "Seated, light work")) if people_load and people_load.get("activity") in activity_options else 1
-                    )
-                
-                # Heat gains
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    sensible_heat = st.number_input(
-                        "Sensible Heat (W/person):",
-                        min_value=0.0,
-                        max_value=500.0,
-                        value=float(people_load.get("sensible_heat", 70)) if people_load else 70.0,
-                        step=5.0
-                    )
-                
-                with col2:
-                    latent_heat = st.number_input(
-                        "Latent Heat (W/person):",
-                        min_value=0.0,
-                        max_value=500.0,
-                        value=float(people_load.get("latent_heat", 45)) if people_load else 45.0,
-                        step=5.0
-                    )
-                
-                # Schedule
-                schedule = st.text_input(
-                    "Schedule (e.g., 8 AM - 6 PM):",
-                    value=people_load.get("schedule", "8 AM - 6 PM") if people_load else "8 AM - 6 PM"
-                )
-                
-                # Submit button
-                submit_label = "Update People Load" if editing_people else "Add People Load"
-                submit = st.form_submit_button(submit_label)
-                
-                if submit:
-                    # Create or update people load
-                    new_people_load = {
-                        "zone": zone_name,
-                        "count": int(people_count),
-                        "activity": activity,
-                        "sensible_heat": float(sensible_heat),
-                        "latent_heat": float(latent_heat),
-                        "schedule": schedule,
-                        "total_sensible": int(people_count) * float(sensible_heat),
-                        "total_latent": int(people_count) * float(latent_heat)
-                    }
-                    
-                    # Add or update people load in session state
-                    if editing_people:
-                        st.session_state.internal_loads["people"][people_to_edit] = new_people_load
-                        del st.session_state.people_to_edit
-                    else:
-                        st.session_state.internal_loads["people"].append(new_people_load)
-        
-        with tab2:
-            st.subheader("Lighting")
-            
-            # Display existing lighting loads
-            if st.session_state.internal_loads["lighting"]:
-                st.write("Existing Lighting Loads:")
-                
-                # Create a table of existing lighting loads
-                lighting_data = []
-                for i, load in enumerate(st.session_state.internal_loads["lighting"]):
-                    lighting_data.append({
-                        "ID": i + 1,
-                        "Zone": load.get("zone", "Main Zone"),
-                        "Type": load.get("type", "Fluorescent"),
-                        "Power (W)": load.get("power", 0),
-                        "Power Density (W/m²)": load.get("power_density", 0),
-                        "Area (m²)": load.get("area", 0),
-                        "Schedule": load.get("schedule", "8 AM - 6 PM")
-                    })
-                
-                lighting_df = pd.DataFrame(lighting_data)
-                st.dataframe(lighting_df)
-                
-                # Add edit and delete buttons for lighting loads
-                col1, col2 = st.columns(2)
-                with col1:
-                    lighting_to_edit = st.selectbox(
-                        "Select lighting load to edit:",
-                        options=range(1, len(st.session_state.internal_loads["lighting"]) + 1),
-                        format_func=lambda x: f"Lighting Load #{x}: {st.session_state.internal_loads['lighting'][x-1].get('zone', 'Main Zone')}"
-                    )
-                
-                with col2:
-                    edit_col, delete_col = st.columns(2)
-                    with edit_col:
-                        if st.button("Edit Lighting Load", key="edit_lighting"):
-                            st.session_state.lighting_to_edit = lighting_to_edit - 1
-                    
-                    with delete_col:
-                        if st.button("Delete Lighting Load", key="delete_lighting"):
-                            st.session_state.internal_loads["lighting"].pop(lighting_to_edit - 1)
-            
-            # Add new lighting load form
-            st.write("Add New Lighting Load:")
-            
-            # Check if we're editing an existing lighting load
-            editing_lighting = "lighting_to_edit" in st.session_state
-            lighting_to_edit = st.session_state.get("lighting_to_edit", None)
-            
-            # Get the lighting load to edit if we're editing
-            lighting_load = None
-            if editing_lighting and lighting_to_edit is not None:
-                lighting_load = st.session_state.internal_loads["lighting"][lighting_to_edit]
-            
-            # Lighting load form
-            with st.form(key="lighting_form"):
-                # Zone name
-                zone_name = st.text_input(
-                    "Zone Name:",
-                    value=lighting_load.get("zone", "Main Zone") if lighting_load else "Main Zone",
-                    key="lighting_zone"
-                )
-                
-                # Lighting type
-                lighting_types = ["Incandescent", "Fluorescent", "LED", "Halogen", "Other"]
-                lighting_type = st.selectbox(
-                    "Lighting Type:",
-                    options=lighting_types,
-                    index=lighting_types.index(lighting_load.get("type", "Fluorescent")) if lighting_load and lighting_load.get("type") in lighting_types else 1
-                )
-                
-                # Input method selection
-                input_method = st.radio(
-                    "Input Method:",
-                    options=["Total Power", "Power Density"],
-                    index=0 if not lighting_load or "power" in lighting_load else 1
-                )
-                
-                if input_method == "Total Power":
-                    # Total power input
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        power = st.number_input(
-                            "Total Power (W):",
-                            min_value=0.0,
-                            max_value=100000.0,
-                            value=float(lighting_load.get("power", 0)) if lighting_load else 0.0,
-                            step=10.0
-                        )
-                    
-                    with col2:
-                        area = st.number_input(
-                            "Area (m²):",
-                            min_value=0.0,
-                            max_value=10000.0,
-                            value=float(lighting_load.get("area", 0)) if lighting_load else 0.0,
-                            step=1.0
-                        )
-                    
-                    # Calculate power density
-                    if area > 0:
-                        power_density = power / area
-                    else:
-                        power_density = 0.0
-                    
-                    st.write(f"Power Density: {power_density:.2f} W/m²")
-                else:
-                    # Power density input
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        power_density = st.number_input(
-                            "Power Density (W/m²):",
-                            min_value=0.0,
-                            max_value=100.0,
-                            value=float(lighting_load.get("power_density", 0)) if lighting_load else 0.0,
-                            step=0.1
-                        )
-                    
-                    with col2:
-                        area = st.number_input(
-                            "Area (m²):",
-                            min_value=0.0,
-                            max_value=10000.0,
-                            value=float(lighting_load.get("area", 0)) if lighting_load else 0.0,
-                            step=1.0
-                        )
-                    
-                    # Calculate total power
-                    power = power_density * area
-                    st.write(f"Total Power: {power:.2f} W")
-                
-                # Schedule
-                schedule = st.text_input(
-                    "Schedule (e.g., 8 AM - 6 PM):",
-                    value=lighting_load.get("schedule", "8 AM - 6 PM") if lighting_load else "8 AM - 6 PM",
-                    key="lighting_schedule"
-                )
-                
-                # Submit button
-                submit_label = "Update Lighting Load" if editing_lighting else "Add Lighting Load"
-                submit = st.form_submit_button(submit_label)
-                
-                if submit:
-                    # Create or update lighting load
-                    new_lighting_load = {
-                        "zone": zone_name,
-                        "type": lighting_type,
-                        "power": float(power),
-                        "power_density": float(power_density),
-                        "area": float(area),
-                        "schedule": schedule
-                    }
-                    
-                    # Add or update lighting load in session state
-                    if editing_lighting:
-                        st.session_state.internal_loads["lighting"][lighting_to_edit] = new_lighting_load
-                        del st.session_state.lighting_to_edit
-                    else:
-                        st.session_state.internal_loads["lighting"].append(new_lighting_load)
-        
-        with tab3:
-            st.subheader("Equipment")
-            
-            # Display existing equipment loads
-            if st.session_state.internal_loads["equipment"]:
-                st.write("Existing Equipment Loads:")
-                
-                # Create a table of existing equipment loads
-                equipment_data = []
-                for i, load in enumerate(st.session_state.internal_loads["equipment"]):
-                    equipment_data.append({
-                        "ID": i + 1,
-                        "Zone": load.get("zone", "Main Zone"),
-                        "Type": load.get("type", "Office Equipment"),
-                        "Sensible Heat (W)": load.get("sensible_heat", 0),
-                        "Latent Heat (W)": load.get("latent_heat", 0),
-                        "Schedule": load.get("schedule", "8 AM - 6 PM")
-                    })
-                
-                equipment_df = pd.DataFrame(equipment_data)
-                st.dataframe(equipment_df)
-                
-                # Add edit and delete buttons for equipment loads
-                col1, col2 = st.columns(2)
-                with col1:
-                    equipment_to_edit = st.selectbox(
-                        "Select equipment load to edit:",
-                        options=range(1, len(st.session_state.internal_loads["equipment"]) + 1),
-                        format_func=lambda x: f"Equipment Load #{x}: {st.session_state.internal_loads['equipment'][x-1].get('zone', 'Main Zone')}"
-                    )
-                
-                with col2:
-                    edit_col, delete_col = st.columns(2)
-                    with edit_col:
-                        if st.button("Edit Equipment Load", key="edit_equipment"):
-                            st.session_state.equipment_to_edit = equipment_to_edit - 1
-                    
-                    with delete_col:
-                        if st.button("Delete Equipment Load", key="delete_equipment"):
-                            st.session_state.internal_loads["equipment"].pop(equipment_to_edit - 1)
-            
-            # Add new equipment load form
-            st.write("Add New Equipment Load:")
-            
-            # Check if we're editing an existing equipment load
-            editing_equipment = "equipment_to_edit" in st.session_state
-            equipment_to_edit = st.session_state.get("equipment_to_edit", None)
-            
-            # Get the equipment load to edit if we're editing
-            equipment_load = None
-            if editing_equipment and equipment_to_edit is not None:
-                equipment_load = st.session_state.internal_loads["equipment"][equipment_to_edit]
-            
-            # Equipment load form
-            with st.form(key="equipment_form"):
-                # Zone name
-                zone_name = st.text_input(
-                    "Zone Name:",
-                    value=equipment_load.get("zone", "Main Zone") if equipment_load else "Main Zone",
-                    key="equipment_zone"
-                )
-                
-                # Equipment type
-                equipment_types = ["Office Equipment", "Kitchen Equipment", "Medical Equipment", "Industrial Equipment", "Other"]
-                equipment_type = st.selectbox(
-                    "Equipment Type:",
-                    options=equipment_types,
-                    index=equipment_types.index(equipment_load.get("type", "Office Equipment")) if equipment_load and equipment_load.get("type") in equipment_types else 0
-                )
-                
-                # Heat gains
-                col1, col2 = st.columns(2)
-                
-                with col1:
-                    sensible_heat = st.number_input(
-                        "Sensible Heat (W):",
-                        min_value=0.0,
-                        max_value=100000.0,
-                        value=float(equipment_load.get("sensible_heat", 0)) if equipment_load else 0.0,
-                        step=10.0
-                    )
-                
-                with col2:
-                    latent_heat = st.number_input(
-                        "Latent Heat (W):",
-                        min_value=0.0,
-                        max_value=100000.0,
-                        value=float(equipment_load.get("latent_heat", 0)) if equipment_load else 0.0,
-                        step=10.0
-                    )
-                
-                # Schedule
-                schedule = st.text_input(
-                    "Schedule (e.g., 8 AM - 6 PM):",
-                    value=equipment_load.get("schedule", "8 AM - 6 PM") if equipment_load else "8 AM - 6 PM",
-                    key="equipment_schedule"
-                )
-                
-                # Submit button
-                submit_label = "Update Equipment Load" if editing_equipment else "Add Equipment Load"
-                submit = st.form_submit_button(submit_label)
-                
-                if submit:
-                    # Create or update equipment load
-                    new_equipment_load = {
-                        "zone": zone_name,
-                        "type": equipment_type,
-                        "sensible_heat": float(sensible_heat),
-                        "latent_heat": float(latent_heat),
-                        "schedule": schedule
-                    }
-                    
-                    # Add or update equipment load in session state
-                    if editing_equipment:
-                        st.session_state.internal_loads["equipment"][equipment_to_edit] = new_equipment_load
-                        del st.session_state.equipment_to_edit
-                    else:
-                        st.session_state.internal_loads["equipment"].append(new_equipment_load)
-    
-    def run_calculations(self):
-        """Run HVAC load calculations."""
-        # Validate inputs before running calculations
-        if not self.data_validation.validate_calculation_inputs(st.session_state):
-            st.error("Please fill in all required information before running calculations.")
-            return
-        
-        # Get input data from session state
-        building_info = st.session_state.building_info
-        components = st.session_state.components
-        internal_loads = st.session_state.internal_loads
-        
-        # Get climate data
-        climate_data = {
-            "location": building_info.get("location", ""),
-            "outdoor_temp": building_info.get("summer_outdoor_temp", 35.0),
-            "outdoor_humidity": building_info.get("summer_outdoor_humidity", 50.0),
-            "indoor_temp": building_info.get("summer_indoor_temp", 24.0),
-            "indoor_humidity": building_info.get("summer_indoor_humidity", 50.0),
-            "daily_range": building_info.get("daily_temp_range", 8.0),
-            "latitude": building_info.get("latitude", "40N"),
-            "month": building_info.get("design_month", 7),
-            "hour": building_info.get("design_hour", 15)
-        }
-        
-        # Calculate cooling load
-        cooling_results = self.cooling_load.calculate_total_cooling_load(
-            walls=components.get("walls", []),
-            roofs=components.get("roofs", []),
-            floors=components.get("floors", []),
-            windows=components.get("windows", []),
-            doors=components.get("doors", []),
-            people=internal_loads.get("people", []),
-            lighting=internal_loads.get("lighting", []),
-            equipment=internal_loads.get("equipment", []),
-            infiltration_rate=building_info.get("infiltration_rate", 0.5),
-            floor_area=building_info.get("floor_area", 100.0),
-            climate_data=climate_data
-        )
-        
-        # Get heating climate data
-        heating_outdoor_conditions = {
-            "temperature": building_info.get("winter_outdoor_temp", -10.0),
-            "humidity": building_info.get("winter_outdoor_humidity", 80.0)
-        }
-        
-        heating_indoor_conditions = {
-            "temperature": building_info.get("winter_indoor_temp", 21.0),
-            "humidity": building_info.get("winter_indoor_humidity", 30.0)
-        }
-        
-        # Calculate heating load
-        heating_results = self.heating_load.calculate_design_heating_load(
-            walls=components.get("walls", []),
-            roofs=components.get("roofs", []),
-            floors=components.get("floors", []),
-            windows=components.get("windows", []),
-            doors=components.get("doors", []),
-            infiltration_rate=building_info.get("infiltration_rate", 0.5),
-            floor_area=building_info.get("floor_area", 100.0),
-            outdoor_conditions=heating_outdoor_conditions,
-            indoor_conditions=heating_indoor_conditions,
-            safety_factor=building_info.get("heating_safety_factor", 10.0)
-        )
-        
-        # Calculate psychrometric properties
-        psychrometric_results = self.psychrometrics.calculate_psychrometric_properties(
-            outdoor_temp=climate_data["outdoor_temp"],
-            outdoor_humidity=climate_data["outdoor_humidity"],
-            indoor_temp=climate_data["indoor_temp"],
-            indoor_humidity=climate_data["indoor_humidity"]
-        )
-        
-        # Store results in session state
-        st.session_state.calculation_results = {
-            "cooling_load": cooling_results,
-            "heating_load": heating_results,
-            "psychrometrics": psychrometric_results
-        }
-        
-        # Navigate to results page
-        st.session_state.page = "results"
-        st.success("Calculations completed successfully!")
+# Add parent directory to path to import modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 
+# Import the main application
+from hvac_calculator_file_upload import HVACCalculatorFileUpload
 
 # Run the application
 if __name__ == "__main__":
-    app = HVACCalculator()
+    app = HVACCalculatorFileUpload()

data/ashrae_tables.py

@@ -1,453 +1,48 @@
 """
-ASHRAE tables module for HVAC Load Calculator.
-This module implements CLTD, SCL, CLF tables and interpolation functions for load calculations.
-"""
-
-from typing import Dict, List, Any, Optional, Tuple
-import pandas as pd
-import numpy as np
-import os
-import json
-from enum import Enum
-
-# Define paths
-DATA_DIR = os.path.dirname(os.path.abspath(__file__))
-
-
-class WallGroup(Enum):
-    """Enumeration for ASHRAE wall groups."""
-    A = "A"  # Light construction
-    B = "B"
-    C = "C"
-    D = "D"
-    E = "E"
-    F = "F"
-    G = "G"
-    H = "H"  # Heavy construction
-    CUSTOM = "Custom"  # Added for custom wall types
-
-
-class RoofGroup(Enum):
-    """Enumeration for ASHRAE roof groups."""
-    A = "A"  # Light construction
-    B = "B"
-    C = "C"
-    D = "D"
-    E = "E"
-    F = "F"
-    G = "G"  # Heavy construction
-    CUSTOM = "Custom"  # Added for custom roof types
-
-
-class Orientation(Enum):
-    """Enumeration for building component orientations."""
-    N = "North"
-    NE = "Northeast"
-    E = "East"
-    SE = "Southeast"
-    S = "South"
-    SW = "Southwest"
-    W = "West"
-    NW = "Northwest"
-    HOR = "Horizontal"  # For roofs and floors
+ASHRAETables class for the file upload version
 
+This file contains a minimal implementation of the ASHRAETables class
+needed for the HVAC Calculator File Upload application to work.
+"""
 
 class ASHRAETables:
-    """Class for ASHRAE tables and interpolation functions."""
+    """Simplified ASHRAETables class for the file upload version."""
     
     def __init__(self):
-        """Initialize ASHRAE tables."""
-        # Create default CLTD tables for walls with hardcoded values
-        # These are simplified default values that will be used when CSV files are not available
-        
-        # Create a default DataFrame for wall CLTD values
-        # Columns are orientations, rows are hours (0-23)
-        default_wall_cltd = pd.DataFrame({
-            "N": [2, 1, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9, 10, 10, 9, 8, 6, 5, 4, 4, 3, 2],
-            "NE": [2, 1, 0, 0, 0, 2, 5, 8, 10, 11, 10, 9, 8, 8, 7, 7, 6, 5, 5, 4, 3, 3, 2, 2],
-            "E": [3, 2, 1, 0, 0, 1, 3, 7, 11, 14, 16, 16, 15, 14, 12, 10, 8, 7, 6, 5, 5, 4, 4, 3],
-            "SE": [3, 2, 1, 0, 0, 0, 1, 4, 7, 10, 13, 15, 16, 16, 15, 13, 10, 8, 7, 6, 5, 4, 4, 3],
-            "S": [3, 2, 1, 0, 0, 0, 0, 1, 2, 4, 6, 9, 12, 14, 15, 15, 14, 12, 9, 7, 6, 5, 4, 3],
-            "SW": [3, 2, 1, 0, 0, 0, 0, 1, 2, 3, 4, 6, 8, 11, 14, 16, 17, 16, 14, 11, 8, 6, 5, 4],
-            "W": [3, 2, 1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 8, 10, 13, 15, 16, 15, 13, 10, 7, 5, 4],
-            "NW": [2, 1, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 12, 10, 8, 6, 4, 3]
-        }, index=range(24))
-        
-        # Create a default DataFrame for roof CLTD values
-        # Column is HOR (horizontal), rows are hours (0-23)
-        default_roof_cltd = pd.DataFrame({
-            "HOR": [3, 2, 1, 0, 0, 0, 1, 3, 6, 9, 13, 16, 19, 21, 22, 21, 19, 16, 13, 10, 8, 6, 5, 4]
-        }, index=range(24))
-        
-        # Initialize CLTD tables for walls with default values
-        self.cltd_wall = {
-            "A": default_wall_cltd.copy(),
-            "B": default_wall_cltd.copy(),
-            "C": default_wall_cltd.copy(),
-            "D": default_wall_cltd.copy(),
-            "E": default_wall_cltd.copy(),
-            "F": default_wall_cltd.copy(),
-            "G": default_wall_cltd.copy(),
-            "H": default_wall_cltd.copy()
-        }
-        
-        # Initialize CLTD tables for roofs with default values
-        self.cltd_roof = {
-            "A": default_roof_cltd.copy(),
-            "B": default_roof_cltd.copy(),
-            "C": default_roof_cltd.copy(),
-            "D": default_roof_cltd.copy(),
-            "E": default_roof_cltd.copy(),
-            "F": default_roof_cltd.copy(),
-            "G": default_roof_cltd.copy()
-        }
-        
-        # Create default SCL table for glass
-        # Columns are orientations, rows are latitudes
-        self.scl_glass = pd.DataFrame({
-            "N": [40, 45, 50, 55, 60],
-            "NE": [80, 85, 90, 95, 100],
-            "E": [120, 125, 130, 135, 140],
-            "SE": [110, 115, 120, 125, 130],
-            "S": [95, 100, 105, 110, 115],
-            "SW": [110, 115, 120, 125, 130],
-            "W": [120, 125, 130, 135, 140],
-            "NW": [80, 85, 90, 95, 100],
-            "HOR": [160, 170, 180, 190, 200]
-        }, index=["24N", "32N", "40N", "48N", "56N"])
-        
-        # Create default CLF tables for internal loads
-        # Columns are zone types, rows are hours (0-23)
-        default_clf = pd.DataFrame({
-            "A": [0.08, 0.06, 0.04, 0.02, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01, 0.01],
-            "B": [0.15, 0.11, 0.08, 0.06, 0.04, 0.03, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
-            "C": [0.24, 0.18, 0.14, 0.11, 0.08, 0.06, 0.05, 0.04, 0.03, 0.03, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02],
-            "D": [0.40, 0.30, 0.23, 0.17, 0.13, 0.10, 0.08, 0.06, 0.05, 0.04, 0.03, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02, 0.02]
-        }, index=range(24))
-        
-        self.clf_people = default_clf.copy()
-        self.clf_lighting = default_clf.copy()
-        self.clf_equipment = default_clf.copy()
-        
-        # Load correction factors
-        self.color_correction = {
-            "Dark": 0,
-            "Medium": -2,
-            "Light": -4
-        }
-        
-        self.month_correction = {
-            1: -8,  # January
-            2: -7,  # February
-            3: -5,  # March
-            4: -2,  # April
-            5: 1,   # May
-            6: 3,   # June
-            7: 4,   # July
-            8: 3,   # August
-            9: 1,   # September
-            10: -2, # October
-            11: -5, # November
-            12: -7  # December
-        }
-        
-        self.latitude_correction = {
-            "24N": {
-                1: -3, 2: -3, 3: -2, 4: 0, 5: 2, 6: 3, 7: 3, 8: 2, 9: 0, 10: -2, 11: -3, 12: -3
-            },
-            "32N": {
-                1: -2, 2: -2, 3: -1, 4: 0, 5: 1, 6: 2, 7: 2, 8: 1, 9: 0, 10: -1, 11: -2, 12: -2
-            },
-            "40N": {
-                1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0
-            },
-            "48N": {
-                1: 2, 2: 2, 3: 1, 4: 0, 5: -1, 6: -2, 7: -2, 8: -1, 9: 0, 10: 1, 11: 2, 12: 2
-            },
-            "56N": {
-                1: 3, 2: 3, 3: 2, 4: 0, 5: -2, 6: -3, 7: -3, 8: -2, 9: 0, 10: 2, 11: 3, 12: 3
-            }
-        }
-    
-    def get_color_correction(self, color: str) -> float:
-        """
-        Get color correction factor.
-        
-        Args:
-            color: Color of the surface (Dark, Medium, Light)
-            
-        Returns:
-            Color correction factor
-        """
-        return self.color_correction.get(color, 0)
+        """Initialize the ASHRAETables class."""
+        pass
     
-    def get_month_correction(self, month: int) -> float:
-        """
-        Get month correction factor.
-        
-        Args:
-            month: Month (1-12)
-            
-        Returns:
-            Month correction factor
-        """
-        return self.month_correction.get(month, 0)
-    
-    def get_latitude_correction(self, latitude: str, month: int) -> float:
-        """
-        Get latitude correction factor.
-        
-        Args:
-            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
-            month: Month (1-12)
-            
-        Returns:
-            Latitude correction factor
-        """
-        if latitude in self.latitude_correction:
-            return self.latitude_correction[latitude].get(month, 0)
+    def get_cltd_wall(self, wall_group, orientation, hour):
+        """Placeholder for the actual CLTD wall method."""
+        # This method is not actually used in the file upload version
         return 0
     
-    def get_cltd_wall(self, wall_group: str, orientation: str, hour: int) -> float:
-        """
-        Get CLTD value for a wall.
-        
-        Args:
-            wall_group: Wall group (A-H)
-            orientation: Wall orientation (N, NE, E, SE, S, SW, W, NW)
-            hour: Hour of the day (0-23)
-            
-        Returns:
-            CLTD value for the specified wall and hour
-        """
-        # Handle custom wall group by using group D (medium construction) as default
-        if wall_group not in self.cltd_wall:
-            if wall_group == "Custom":
-                wall_group = "D"  # Use group D (medium construction) for custom walls
-            else:
-                raise ValueError(f"Invalid wall group: {wall_group}")
-        
-        # Convert orientation to abbreviation if needed
-        orientation_map = {
-            "North": "N", "Northeast": "NE", "East": "E", "Southeast": "SE",
-            "South": "S", "Southwest": "SW", "West": "W", "Northwest": "NW"
-        }
-        orientation_abbr = orientation_map.get(orientation, orientation)
-        
-        if orientation_abbr not in self.cltd_wall[wall_group].columns:
-            raise ValueError(f"Invalid orientation: {orientation}")
-        
-        if hour < 0 or hour > 23:
-            raise ValueError(f"Invalid hour: {hour}")
-        
-        # Get CLTD value
-        return self.cltd_wall[wall_group].loc[hour, orientation_abbr]
-    
-    def get_cltd_roof(self, roof_group: str, hour: int) -> float:
-        """
-        Get CLTD value for a roof.
-        
-        Args:
-            roof_group: Roof group (A-G)
-            hour: Hour of the day (0-23)
-            
-        Returns:
-            CLTD value for the specified roof and hour
-        """
-        # Handle custom roof group by using group C (medium construction) as default
-        if roof_group not in self.cltd_roof:
-            if roof_group == "Custom":
-                roof_group = "C"  # Use group C (medium construction) for custom roofs
-            else:
-                raise ValueError(f"Invalid roof group: {roof_group}")
-        
-        if hour < 0 or hour > 23:
-            raise ValueError(f"Invalid hour: {hour}")
-        
-        # Get CLTD value
-        return self.cltd_roof[roof_group].loc[hour, "HOR"]
-    
-    def get_scl_glass(self, orientation: str, latitude: str, month: int) -> float:
-        """
-        Get SCL value for glass.
-        
-        Args:
-            orientation: Glass orientation (N, NE, E, SE, S, SW, W, NW, HOR)
-            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
-            month: Month (1-12)
-            
-        Returns:
-            SCL value for the specified glass
-        """
-        # Validate inputs
-        if orientation not in self.scl_glass.columns:
-            raise ValueError(f"Invalid orientation: {orientation}")
-        
-        if latitude not in self.scl_glass.index:
-            # Default to 40N if latitude not found
-            latitude = "40N"
-        
-        # Get SCL value
-        scl = self.scl_glass.loc[latitude, orientation]
-        
-        # Apply month correction
-        month_correction = self.get_month_correction(month)
-        
-        return scl + month_correction
-    
-    def get_scl(self, orientation: str, hour: int, latitude: str, month: int = 7) -> float:
-        """
-        Get SCL value for glass (compatibility method).
-        
-        Args:
-            orientation: Glass orientation (N, NE, E, SE, S, SW, W, NW, HOR)
-            hour: Hour of the day (0-23) - not used in this implementation
-            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
-            month: Month (1-12), defaults to July (7)
-            
-        Returns:
-            SCL value for the specified glass
-        """
-        # This is a compatibility method that calls get_scl_glass
-        # The hour parameter is ignored as SCL values are daily maximums
-        return self.get_scl_glass(orientation, latitude, month)
-    
-    def get_clf_people(self, hour: int, zone_type: str) -> float:
-        """
-        Get CLF value for people.
-        
-        Args:
-            hour: Hour of the day (0-23)
-            zone_type: Zone type (A-D)
-            
-        Returns:
-            CLF value for people at the specified hour and zone type
-        """
-        # Validate inputs
-        if zone_type not in self.clf_people.columns:
-            # Default to zone type B if not found
-            zone_type = "B"
-        
-        if hour < 0 or hour > 23:
-            raise ValueError(f"Invalid hour: {hour}")
-        
-        # Get CLF value
-        return self.clf_people.loc[hour, zone_type]
+    def get_cltd_roof(self, roof_group, hour):
+        """Placeholder for the actual CLTD roof method."""
+        # This method is not actually used in the file upload version
+        return 0
     
-    def get_clf_lighting(self, hour: int, zone_type: str) -> float:
-        """
-        Get CLF value for lighting.
-        
-        Args:
-            hour: Hour of the day (0-23)
-            zone_type: Zone type (A-D)
-            
-        Returns:
-            CLF value for lighting at the specified hour and zone type
-        """
-        # Validate inputs
-        if zone_type not in self.clf_lighting.columns:
-            # Default to zone type B if not found
-            zone_type = "B"
-        
-        if hour < 0 or hour > 23:
-            raise ValueError(f"Invalid hour: {hour}")
-        
-        # Get CLF value
-        return self.clf_lighting.loc[hour, zone_type]
+    def get_scl_glass(self, orientation, hour, latitude):
+        """Placeholder for the actual SCL glass method."""
+        # This method is not actually used in the file upload version
+        return 0
     
-    def get_clf_equipment(self, hour: int, zone_type: str) -> float:
-        """
-        Get CLF value for equipment.
-        
-        Args:
-            hour: Hour of the day (0-23)
-            zone_type: Zone type (A-D)
-            
-        Returns:
-            CLF value for equipment at the specified hour and zone type
-        """
-        # Validate inputs
-        if zone_type not in self.clf_equipment.columns:
-            # Default to zone type B if not found
-            zone_type = "B"
-        
-        if hour < 0 or hour > 23:
-            raise ValueError(f"Invalid hour: {hour}")
-        
-        # Get CLF value
-        return self.clf_equipment.loc[hour, zone_type]
+    def get_scl(self, orientation, hour, latitude):
+        """Placeholder for the actual SCL method."""
+        # This method is not actually used in the file upload version
+        return 0
     
-    def calculate_corrected_cltd_wall(self, wall_group: str, orientation: str, hour: int, 
-                                    color: str, month: int, latitude: str,
-                                    indoor_temp: float, outdoor_temp: float) -> float:
-        """
-        Calculate corrected CLTD value for a wall.
-        
-        Args:
-            wall_group: Wall group (A-H)
-            orientation: Wall orientation (N, NE, E, SE, S, SW, W, NW)
-            hour: Hour of the day (0-23)
-            color: Color of the wall (Dark, Medium, Light)
-            month: Month (1-12)
-            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
-            indoor_temp: Indoor design temperature (°C)
-            outdoor_temp: Outdoor design temperature (°C)
-            
-        Returns:
-            Corrected CLTD value for the specified wall and hour
-        """
-        # Get base CLTD value
-        cltd = self.get_cltd_wall(wall_group, orientation, hour)
-        
-        # Apply corrections
-        color_correction = self.get_color_correction(color)
-        month_correction = self.get_month_correction(month)
-        latitude_correction = self.get_latitude_correction(latitude, month)
-        
-        # Temperature correction
-        temp_correction = (indoor_temp - 25.5) + (outdoor_temp - 35.0)
-        
-        # Calculate corrected CLTD
-        corrected_cltd = cltd + color_correction + month_correction + latitude_correction + temp_correction
-        
-        # Ensure CLTD is not negative
-        return max(0, corrected_cltd)
+    def calculate_corrected_cltd_wall(self, wall_group, orientation, hour, 
+                                     outdoor_temp, indoor_temp, latitude, month):
+        """Placeholder for the actual corrected CLTD wall method."""
+        # This method is not actually used in the file upload version
+        return 0
     
-    def calculate_corrected_cltd_roof(self, roof_group: str, hour: int, 
-                                    color: str, month: int, latitude: str,
-                                    indoor_temp: float, outdoor_temp: float) -> float:
-        """
-        Calculate corrected CLTD value for a roof.
-        
-        Args:
-            roof_group: Roof group (A-G)
-            hour: Hour of the day (0-23)
-            color: Color of the roof (Dark, Medium, Light)
-            month: Month (1-12)
-            latitude: Latitude (24N, 32N, 40N, 48N, 56N)
-            indoor_temp: Indoor design temperature (°C)
-            outdoor_temp: Outdoor design temperature (°C)
-            
-        Returns:
-            Corrected CLTD value for the specified roof and hour
-        """
-        # Get base CLTD value
-        cltd = self.get_cltd_roof(roof_group, hour)
-        
-        # Apply corrections
-        color_correction = self.get_color_correction(color)
-        month_correction = self.get_month_correction(month)
-        latitude_correction = self.get_latitude_correction(latitude, month)
-        
-        # Temperature correction
-        temp_correction = (indoor_temp - 25.5) + (outdoor_temp - 35.0)
-        
-        # Calculate corrected CLTD
-        corrected_cltd = cltd + color_correction + month_correction + latitude_correction + temp_correction
-        
-        # Ensure CLTD is not negative
-        return max(0, corrected_cltd)
+    def calculate_corrected_cltd_roof(self, roof_group, hour, 
+                                     outdoor_temp, indoor_temp, latitude, month):
+        """Placeholder for the actual corrected CLTD roof method."""
+        # This method is not actually used in the file upload version
+        return 0
 
-# Create an instance of ASHRAETables for other modules to import
+# Create an instance for other modules to import
 ashrae_tables = ASHRAETables()

hvac_calculator_file_upload.py

@@ -0,0 +1,1062 @@
+"""
+HVAC Calculator with File Upload Interface
+
+This module contains a simplified Streamlit application for the HVAC Calculator
+that uses an Excel file upload approach instead of manual data entry.
+
+Author: Manus AI
+Date: March 2025
+Version: 2.0.0
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+import matplotlib.pyplot as plt
+import io
+import os
+import sys
+from typing import Dict, List, Any, Optional, Tuple
+
+# Import utility modules
+from utils.cooling_load import CoolingLoad
+from utils.heating_load import HeatingLoad
+from utils.psychrometrics import Psychrometrics
+from utils.psychrometric_visualization import PsychrometricVisualization
+from data.ashrae_tables import ASHRAETables
+
+class HVACCalculatorFileUpload:
+    """HVAC Calculator application with file upload interface."""
+    
+    def __init__(self):
+        """Initialize the HVAC Calculator application."""
+        # Set page configuration
+        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 utility modules
+        self._initialize_modules()
+        
+        # Setup application layout
+        self.setup_layout()
+    
+    def _initialize_session_state(self):
+        """Initialize Streamlit session state variables."""
+        # Initialize page navigation
+        if "page" not in st.session_state:
+            st.session_state.page = "upload"
+        
+        # Initialize data storage
+        if "uploaded_data" not in st.session_state:
+            st.session_state.uploaded_data = None
+            
+        # Initialize calculation results
+        if "calculation_results" not in st.session_state:
+            st.session_state.calculation_results = {
+                "cooling_load": {},
+                "heating_load": {},
+                "psychrometrics": {}
+            }
+    
+    def _initialize_modules(self):
+        """Initialize utility modules."""
+        self.cooling_load = CoolingLoad()
+        self.heating_load = HeatingLoad()
+        self.psychrometrics = Psychrometrics()
+        self.psychrometric_visualization = PsychrometricVisualization()
+        self.ashrae_tables = ASHRAETables()
+    
+    def setup_layout(self):
+        """Setup the application layout."""
+        # Display header
+        st.title("HVAC Load Calculator")
+        st.markdown("A simplified tool for calculating heating and cooling loads using ASHRAE methods.")
+        
+        # Setup sidebar
+        self.setup_sidebar()
+        
+        # Display current page
+        if st.session_state.page == "upload":
+            self.display_upload_page()
+        elif st.session_state.page == "results":
+            self.display_results_page()
+        elif st.session_state.page == "data":
+            self.display_data_page()
+    
+    def setup_sidebar(self):
+        """Setup the application sidebar."""
+        with st.sidebar:
+            st.header("Navigation")
+            
+            # Navigation buttons
+            if st.button("Upload Data", key="nav_upload"):
+                st.session_state.page = "upload"
+            
+            if st.button("View Results", key="nav_results"):
+                if st.session_state.uploaded_data is None:
+                    st.error("Please upload data first.")
+                else:
+                    st.session_state.page = "results"
+            
+            if st.button("View Uploaded Data", key="nav_data"):
+                if st.session_state.uploaded_data is None:
+                    st.error("Please upload data first.")
+                else:
+                    st.session_state.page = "data"
+            
+            st.markdown("---")
+            
+            # Run calculations button
+            if st.button("Run Calculations", key="run_calculations"):
+                if st.session_state.uploaded_data is None:
+                    st.error("Please upload data first.")
+                else:
+                    self.run_calculations()
+            
+            st.markdown("---")
+            
+            # Download template button
+            if st.download_button(
+                label="Download Template",
+                data=open("hvac_calculator_template.xlsx", "rb").read(),
+                file_name="hvac_calculator_template.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+            ):
+                st.success("Template downloaded successfully!")
+            
+            st.markdown("---")
+            
+            # Display application info
+            st.subheader("About")
+            st.write("HVAC Load Calculator v2.0.0")
+            st.write("© 2025 Manus AI")
+    
+    def display_upload_page(self):
+        """Display the file upload interface."""
+        st.header("Upload Data")
+        
+        st.write("""
+        Please upload your HVAC data using the Excel template. If you don't have the template,
+        you can download it using the 'Download Template' button in the sidebar.
+        """)
+        
+        uploaded_file = st.file_uploader(
+            "Upload your Excel file:",
+            type=["xlsx"],
+            help="Upload the filled HVAC calculator template Excel file."
+        )
+        
+        if uploaded_file is not None:
+            try:
+                # Process the uploaded file
+                data = self.process_uploaded_file(uploaded_file)
+                
+                # Store the processed data in session state
+                st.session_state.uploaded_data = data
+                
+                # Display success message
+                st.success("File uploaded and processed successfully!")
+                
+                # Add a button to view the data
+                if st.button("View Uploaded Data"):
+                    st.session_state.page = "data"
+                
+                # Add a button to run calculations
+                if st.button("Run Calculations Now"):
+                    self.run_calculations()
+                    st.session_state.page = "results"
+                
+            except Exception as e:
+                st.error(f"Error processing the uploaded file: {str(e)}")
+                st.error("Please make sure you're using the correct template format.")
+    
+    def process_uploaded_file(self, uploaded_file) -> Dict[str, Any]:
+        """
+        Process the uploaded Excel file and extract the data.
+        
+        Args:
+            uploaded_file: The uploaded Excel file
+            
+        Returns:
+            Dictionary containing the extracted data
+        """
+        # Read the Excel file
+        xls = pd.ExcelFile(uploaded_file)
+        
+        # Initialize data dictionary
+        data = {
+            "building_info": {},
+            "components": {
+                "walls": [],
+                "windows": [],
+                "doors": [],
+                "roofs": [],
+                "floors": []
+            },
+            "internal_loads": {
+                "people": [],
+                "lighting": [],
+                "equipment": []
+            }
+        }
+        
+        # Process Building Information sheet
+        building_info_df = pd.read_excel(xls, "Building Information", header=0)
+        for _, row in building_info_df.iterrows():
+            param = row["Parameter*"]
+            value = row["Value*"]
+            if pd.notna(param) and pd.notna(value):
+                # Convert parameter name to snake_case for consistency
+                param_key = param.lower().replace(" ", "_")
+                data["building_info"][param_key] = value
+        
+        # Process Walls sheet
+        walls_df = pd.read_excel(xls, "Walls", header=0)
+        for _, row in walls_df.iterrows():
+            if pd.notna(row["Wall Name*"]) and pd.notna(row["Orientation*"]):
+                wall = {
+                    "name": row["Wall Name*"],
+                    "orientation": row["Orientation*"],
+                    "height": row["Height (m)*"],
+                    "width": row["Width (m)*"],
+                    "area": row["Area (m²"] if pd.notna(row["Area (m²"]) else row["Height (m)*"] * row["Width (m)*"],
+                    "u_value": row["U-Value (W/m²K)*"],
+                    "wall_group": row["Wall Group*"],
+                    "notes": row["Notes"] if pd.notna(row["Notes"]) else ""
+                }
+                data["components"]["walls"].append(wall)
+        
+        # Process Windows sheet
+        windows_df = pd.read_excel(xls, "Windows", header=0)
+        for _, row in windows_df.iterrows():
+            if pd.notna(row["Window Name*"]) and pd.notna(row["Orientation*"]):
+                has_shading = row["Has Shading"] == "Yes" if pd.notna(row["Has Shading"]) else False
+                window = {
+                    "name": row["Window Name*"],
+                    "orientation": row["Orientation*"],
+                    "height": row["Height (m)*"],
+                    "width": row["Width (m)*"],
+                    "area": row["Area (m²"] if pd.notna(row["Area (m²"]) else row["Height (m)*"] * row["Width (m)*"],
+                    "u_value": row["U-Value (W/m²K)*"],
+                    "shgc": row["SHGC*"],
+                    "has_shading": has_shading,
+                    "shading_type": row["Shading Type"] if has_shading and pd.notna(row["Shading Type"]) else None,
+                    "shading_coefficient": row["Shading Coefficient"] if has_shading and pd.notna(row["Shading Coefficient"]) else 1.0,
+                    "notes": row["Notes"] if pd.notna(row["Notes"]) else ""
+                }
+                data["components"]["windows"].append(window)
+        
+        # Process Doors sheet
+        doors_df = pd.read_excel(xls, "Doors", header=0)
+        for _, row in doors_df.iterrows():
+            if pd.notna(row["Door Name*"]) and pd.notna(row["Orientation*"]):
+                door = {
+                    "name": row["Door Name*"],
+                    "orientation": row["Orientation*"],
+                    "height": row["Height (m)*"],
+                    "width": row["Width (m)*"],
+                    "area": row["Area (m²"] if pd.notna(row["Area (m²"]) else row["Height (m)*"] * row["Width (m)*"],
+                    "u_value": row["U-Value (W/m²K)*"],
+                    "notes": row["Notes"] if pd.notna(row["Notes"]) else ""
+                }
+                data["components"]["doors"].append(door)
+        
+        # Process Roof and Floor sheet
+        roof_floor_df = pd.read_excel(xls, "Roof and Floor", header=0)
+        for _, row in roof_floor_df.iterrows():
+            if pd.notna(row["Component*"]) and pd.notna(row["Area (m²)*"]):
+                component = {
+                    "name": row["Component*"],
+                    "area": row["Area (m²)*"],
+                    "u_value": row["U-Value (W/m²K)*"],
+                    "group": row["Group*"] if row["Component*"] == "Roof" else None,
+                    "notes": row["Notes"] if pd.notna(row["Notes"]) else ""
+                }
+                
+                if row["Component*"] == "Roof":
+                    data["components"]["roofs"].append(component)
+                elif row["Component*"] == "Floor":
+                    data["components"]["floors"].append(component)
+        
+        # Process Internal Loads sheet
+        internal_loads_df = pd.read_excel(xls, "Internal Loads", header=None)
+        
+        # Find the sections for people, lighting, and equipment
+        people_start = internal_loads_df[internal_loads_df[0] == "People Loads"].index[0]
+        lighting_start = internal_loads_df[internal_loads_df[0] == "Lighting Loads"].index[0]
+        equipment_start = internal_loads_df[internal_loads_df[0] == "Equipment Loads"].index[0]
+        
+        # Process People Loads
+        people_df = pd.read_excel(xls, "Internal Loads", header=people_start+1, nrows=lighting_start-people_start-3)
+        for _, row in people_df.iterrows():
+            if pd.notna(row["Zone Name*"]) and pd.notna(row["Number of People*"]):
+                people_load = {
+                    "zone": row["Zone Name*"],
+                    "count": row["Number of People*"],
+                    "activity": row["Activity Level*"],
+                    "sensible_heat": row["Sensible Heat (W/person)*"],
+                    "latent_heat": row["Latent Heat (W/person)*"],
+                    "schedule": row["Schedule*"],
+                    "notes": row["Notes"] if pd.notna(row["Notes"]) else "",
+                    "total_sensible": row["Number of People*"] * row["Sensible Heat (W/person)*"],
+                    "total_latent": row["Number of People*"] * row["Latent Heat (W/person)*"]
+                }
+                data["internal_loads"]["people"].append(people_load)
+        
+        # Process Lighting Loads
+        lighting_df = pd.read_excel(xls, "Internal Loads", header=lighting_start+1, nrows=equipment_start-lighting_start-3)
+        for _, row in lighting_df.iterrows():
+            if pd.notna(row["Zone Name*"]) and pd.notna(row["Total Power (W)*"]):
+                power_density = row["Power Density (W/m²)"] if pd.notna(row["Power Density (W/m²)"]) else row["Total Power (W)*"] / row["Area (m²)*"]
+                lighting_load = {
+                    "zone": row["Zone Name*"],
+                    "type": row["Lighting Type*"],
+                    "power": row["Total Power (W)*"],
+                    "area": row["Area (m²)*"],
+                    "power_density": power_density,
+                    "schedule": row["Schedule*"],
+                    "notes": row["Notes"] if pd.notna(row["Notes"]) else ""
+                }
+                data["internal_loads"]["lighting"].append(lighting_load)
+        
+        # Process Equipment Loads
+        equipment_df = pd.read_excel(xls, "Internal Loads", header=equipment_start+1)
+        for _, row in equipment_df.iterrows():
+            if pd.notna(row["Zone Name*"]) and pd.notna(row["Sensible Heat (W)*"]):
+                equipment_load = {
+                    "zone": row["Zone Name*"],
+                    "type": row["Equipment Type*"],
+                    "sensible_heat": row["Sensible Heat (W)*"],
+                    "latent_heat": row["Latent Heat (W)*"],
+                    "schedule": row["Schedule*"],
+                    "notes": row["Notes"] if pd.notna(row["Notes"]) else ""
+                }
+                data["internal_loads"]["equipment"].append(equipment_load)
+        
+        return data
+    
+    def display_data_page(self):
+        """Display the uploaded data."""
+        if st.session_state.uploaded_data is None:
+            st.error("No data has been uploaded. Please upload data first.")
+            return
+        
+        st.header("Uploaded Data")
+        
+        # Create tabs for different data sections
+        tabs = st.tabs([
+            "Building Info", "Walls", "Windows", "Doors", 
+            "Roof & Floor", "People", "Lighting", "Equipment"
+        ])
+        
+        # Display Building Information
+        with tabs[0]:
+            st.subheader("Building Information")
+            building_info = st.session_state.uploaded_data["building_info"]
+            building_info_df = pd.DataFrame({
+                "Parameter": building_info.keys(),
+                "Value": building_info.values()
+            })
+            st.dataframe(building_info_df, use_container_width=True)
+        
+        # Display Walls
+        with tabs[1]:
+            st.subheader("Walls")
+            walls = st.session_state.uploaded_data["components"]["walls"]
+            if walls:
+                walls_df = pd.DataFrame(walls)
+                st.dataframe(walls_df, use_container_width=True)
+            else:
+                st.info("No wall data available.")
+        
+        # Display Windows
+        with tabs[2]:
+            st.subheader("Windows")
+            windows = st.session_state.uploaded_data["components"]["windows"]
+            if windows:
+                windows_df = pd.DataFrame(windows)
+                st.dataframe(windows_df, use_container_width=True)
+            else:
+                st.info("No window data available.")
+        
+        # Display Doors
+        with tabs[3]:
+            st.subheader("Doors")
+            doors = st.session_state.uploaded_data["components"]["doors"]
+            if doors:
+                doors_df = pd.DataFrame(doors)
+                st.dataframe(doors_df, use_container_width=True)
+            else:
+                st.info("No door data available.")
+        
+        # Display Roof and Floor
+        with tabs[4]:
+            st.subheader("Roof and Floor")
+            roofs = st.session_state.uploaded_data["components"]["roofs"]
+            floors = st.session_state.uploaded_data["components"]["floors"]
+            
+            if roofs:
+                st.write("Roof Components:")
+                roofs_df = pd.DataFrame(roofs)
+                st.dataframe(roofs_df, use_container_width=True)
+            else:
+                st.info("No roof data available.")
+            
+            if floors:
+                st.write("Floor Components:")
+                floors_df = pd.DataFrame(floors)
+                st.dataframe(floors_df, use_container_width=True)
+            else:
+                st.info("No floor data available.")
+        
+        # Display People Loads
+        with tabs[5]:
+            st.subheader("People Loads")
+            people = st.session_state.uploaded_data["internal_loads"]["people"]
+            if people:
+                people_df = pd.DataFrame(people)
+                st.dataframe(people_df, use_container_width=True)
+            else:
+                st.info("No people load data available.")
+        
+        # Display Lighting Loads
+        with tabs[6]:
+            st.subheader("Lighting Loads")
+            lighting = st.session_state.uploaded_data["internal_loads"]["lighting"]
+            if lighting:
+                lighting_df = pd.DataFrame(lighting)
+                st.dataframe(lighting_df, use_container_width=True)
+            else:
+                st.info("No lighting load data available.")
+        
+        # Display Equipment Loads
+        with tabs[7]:
+            st.subheader("Equipment Loads")
+            equipment = st.session_state.uploaded_data["internal_loads"]["equipment"]
+            if equipment:
+                equipment_df = pd.DataFrame(equipment)
+                st.dataframe(equipment_df, use_container_width=True)
+            else:
+                st.info("No equipment load data available.")
+    
+    def display_results_page(self):
+        """Display the calculation results."""
+        if st.session_state.uploaded_data is None:
+            st.error("No data has been uploaded. Please upload data first.")
+            return
+        
+        if not st.session_state.calculation_results["cooling_load"]:
+            st.warning("Calculations have not been run yet. Please run calculations first.")
+            if st.button("Run Calculations Now"):
+                self.run_calculations()
+            return
+        
+        st.header("Calculation Results")
+        
+        # Create tabs for different result sections
+        tabs = st.tabs([
+            "Cooling Load", "Heating Load", "Psychrometric Analysis", "Load Breakdown"
+        ])
+        
+        # Display Cooling Load Results
+        with tabs[0]:
+            st.subheader("Cooling Load Results")
+            
+            cooling_results = st.session_state.calculation_results["cooling_load"]
+            
+            # Display total cooling load
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                st.metric(
+                    label="Total Cooling Load",
+                    value=f"{cooling_results.get('total_load', 0):.2f} kW"
+                )
+            
+            with col2:
+                st.metric(
+                    label="Sensible Cooling Load",
+                    value=f"{cooling_results.get('sensible_load', 0):.2f} kW"
+                )
+            
+            with col3:
+                st.metric(
+                    label="Latent Cooling Load",
+                    value=f"{cooling_results.get('latent_load', 0):.2f} kW"
+                )
+            
+            # Display cooling load per area
+            st.metric(
+                label="Cooling Load per Area",
+                value=f"{cooling_results.get('load_per_area', 0):.2f} W/m²"
+            )
+            
+            # Display cooling load breakdown
+            if "component_loads" in cooling_results:
+                st.subheader("Cooling Load Breakdown")
+                
+                component_loads = cooling_results["component_loads"]
+                
+                # Create a DataFrame for the component loads
+                load_data = []
+                for component, load in component_loads.items():
+                    load_data.append({
+                        "Component": component.capitalize(),
+                        "Load (kW)": load,
+                        "Percentage": load / cooling_results["total_load"] * 100 if cooling_results["total_load"] > 0 else 0
+                    })
+                
+                load_df = pd.DataFrame(load_data)
+                
+                # Display the load breakdown table
+                st.dataframe(load_df, use_container_width=True)
+                
+                # Create a pie chart for the load breakdown
+                fig = px.pie(
+                    load_df,
+                    values="Load (kW)",
+                    names="Component",
+                    title="Cooling Load Distribution"
+                )
+                st.plotly_chart(fig, use_container_width=True)
+        
+        # Display Heating Load Results
+        with tabs[1]:
+            st.subheader("Heating Load Results")
+            
+            heating_results = st.session_state.calculation_results["heating_load"]
+            
+            # Display total heating load
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric(
+                    label="Total Heating Load",
+                    value=f"{heating_results.get('total_load', 0):.2f} kW"
+                )
+            
+            with col2:
+                st.metric(
+                    label="Heating Load per Area",
+                    value=f"{heating_results.get('load_per_area', 0):.2f} W/m²"
+                )
+            
+            # Display design heat loss
+            col1, col2 = st.columns(2)
+            with col1:
+                st.metric(
+                    label="Design Heat Loss",
+                    value=f"{heating_results.get('design_heat_loss', 0):.2f} kW"
+                )
+            
+            with col2:
+                st.metric(
+                    label="Safety Factor",
+                    value=f"{heating_results.get('safety_factor', 0):.2f} %"
+                )
+            
+            # Display heating load breakdown
+            if "component_loads" in heating_results:
+                st.subheader("Heating Load Breakdown")
+                
+                component_loads = heating_results["component_loads"]
+                
+                # Create a DataFrame for the component loads
+                load_data = []
+                for component, load in component_loads.items():
+                    load_data.append({
+                        "Component": component.capitalize(),
+                        "Load (kW)": load,
+                        "Percentage": load / heating_results["total_load"] * 100 if heating_results["total_load"] > 0 else 0
+                    })
+                
+                load_df = pd.DataFrame(load_data)
+                
+                # Display the load breakdown table
+                st.dataframe(load_df, use_container_width=True)
+                
+                # Create a pie chart for the load breakdown
+                fig = px.pie(
+                    load_df,
+                    values="Load (kW)",
+                    names="Component",
+                    title="Heating Load Distribution"
+                )
+                st.plotly_chart(fig, use_container_width=True)
+        
+        # Display Psychrometric Analysis
+        with tabs[2]:
+            st.subheader("Psychrometric Analysis")
+            
+            psychrometric_results = st.session_state.calculation_results["psychrometrics"]
+            
+            # Display psychrometric properties
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                st.subheader("Outdoor Conditions")
+                outdoor = psychrometric_results.get("outdoor", {})
+                
+                st.metric(
+                    label="Dry Bulb Temperature",
+                    value=f"{outdoor.get('dry_bulb', 0):.1f} °C"
+                )
+                
+                st.metric(
+                    label="Relative Humidity",
+                    value=f"{outdoor.get('relative_humidity', 0):.1f} %"
+                )
+                
+                st.metric(
+                    label="Humidity Ratio",
+                    value=f"{outdoor.get('humidity_ratio', 0):.4f} kg/kg"
+                )
+                
+                st.metric(
+                    label="Enthalpy",
+                    value=f"{outdoor.get('enthalpy', 0):.1f} kJ/kg"
+                )
+            
+            with col2:
+                st.subheader("Indoor Conditions")
+                indoor = psychrometric_results.get("indoor", {})
+                
+                st.metric(
+                    label="Dry Bulb Temperature",
+                    value=f"{indoor.get('dry_bulb', 0):.1f} °C"
+                )
+                
+                st.metric(
+                    label="Relative Humidity",
+                    value=f"{indoor.get('relative_humidity', 0):.1f} %"
+                )
+                
+                st.metric(
+                    label="Humidity Ratio",
+                    value=f"{indoor.get('humidity_ratio', 0):.4f} kg/kg"
+                )
+                
+                st.metric(
+                    label="Enthalpy",
+                    value=f"{indoor.get('enthalpy', 0):.1f} kJ/kg"
+                )
+            
+            # Display psychrometric chart
+            st.subheader("Psychrometric Chart")
+            
+            # Create a placeholder for the psychrometric chart
+            # In a real implementation, this would use the PsychrometricVisualization class
+            st.info("Psychrometric chart visualization would be displayed here.")
+        
+        # Display Load Breakdown
+        with tabs[3]:
+            st.subheader("Load Breakdown by Component")
+            
+            cooling_results = st.session_state.calculation_results["cooling_load"]
+            heating_results = st.session_state.calculation_results["heating_load"]
+            
+            # Create a DataFrame for the component loads
+            if "component_loads" in cooling_results and "component_loads" in heating_results:
+                cooling_loads = cooling_results["component_loads"]
+                heating_loads = heating_results["component_loads"]
+                
+                # Combine the component loads
+                components = set(list(cooling_loads.keys()) + list(heating_loads.keys()))
+                
+                load_data = []
+                for component in components:
+                    load_data.append({
+                        "Component": component.capitalize(),
+                        "Cooling Load (kW)": cooling_loads.get(component, 0),
+                        "Heating Load (kW)": heating_loads.get(component, 0)
+                    })
+                
+                load_df = pd.DataFrame(load_data)
+                
+                # Display the load breakdown table
+                st.dataframe(load_df, use_container_width=True)
+                
+                # Create a bar chart for the load comparison
+                fig = px.bar(
+                    load_df,
+                    x="Component",
+                    y=["Cooling Load (kW)", "Heating Load (kW)"],
+                    title="Cooling and Heating Load Comparison",
+                    barmode="group"
+                )
+                st.plotly_chart(fig, use_container_width=True)
+    
+    def run_calculations(self):
+        """Run HVAC load calculations based on the uploaded data."""
+        if st.session_state.uploaded_data is None:
+            st.error("No data has been uploaded. Please upload data first.")
+            return
+        
+        try:
+            # Get input data from uploaded data
+            data = st.session_state.uploaded_data
+            building_info = data["building_info"]
+            components = data["components"]
+            internal_loads = data["internal_loads"]
+            
+            # Get climate data
+            climate_data = {
+                "location": building_info.get("location", ""),
+                "outdoor_temp": building_info.get("summer_outdoor_temperature", 35.0),
+                "outdoor_humidity": building_info.get("summer_outdoor_humidity", 50.0),
+                "indoor_temp": building_info.get("summer_indoor_temperature", 24.0),
+                "indoor_humidity": building_info.get("summer_indoor_humidity", 50.0),
+                "daily_range": building_info.get("daily_temperature_range", 8.0),
+                "latitude": building_info.get("latitude", "40N"),
+                "month": building_info.get("design_month", 7),
+                "hour": building_info.get("design_hour", 15)
+            }
+            
+            # Calculate cooling load
+            cooling_results = self.calculate_cooling_load(
+                components=components,
+                internal_loads=internal_loads,
+                building_info=building_info,
+                climate_data=climate_data
+            )
+            
+            # Get heating climate data
+            heating_outdoor_conditions = {
+                "temperature": building_info.get("winter_outdoor_temperature", -10.0),
+                "humidity": building_info.get("winter_outdoor_humidity", 80.0)
+            }
+            
+            heating_indoor_conditions = {
+                "temperature": building_info.get("winter_indoor_temperature", 21.0),
+                "humidity": building_info.get("winter_indoor_humidity", 30.0)
+            }
+            
+            # Calculate heating load
+            heating_results = self.calculate_heating_load(
+                components=components,
+                building_info=building_info,
+                outdoor_conditions=heating_outdoor_conditions,
+                indoor_conditions=heating_indoor_conditions
+            )
+            
+            # Calculate psychrometric properties
+            psychrometric_results = self.calculate_psychrometric_properties(
+                outdoor_temp=climate_data["outdoor_temp"],
+                outdoor_humidity=climate_data["outdoor_humidity"],
+                indoor_temp=climate_data["indoor_temp"],
+                indoor_humidity=climate_data["indoor_humidity"]
+            )
+            
+            # Store results in session state
+            st.session_state.calculation_results = {
+                "cooling_load": cooling_results,
+                "heating_load": heating_results,
+                "psychrometrics": psychrometric_results
+            }
+            
+            # Navigate to results page
+            st.session_state.page = "results"
+            st.success("Calculations completed successfully!")
+            
+        except Exception as e:
+            st.error(f"Error running calculations: {str(e)}")
+            st.error("Please check your input data and try again.")
+    
+    def calculate_cooling_load(self, components, internal_loads, building_info, climate_data):
+        """
+        Calculate cooling load based on the uploaded data.
+        
+        This is a simplified version that mimics the actual calculation logic.
+        In a real implementation, this would use the CoolingLoad class.
+        
+        Args:
+            components: Dictionary of building components
+            internal_loads: Dictionary of internal loads
+            building_info: Dictionary of building information
+            climate_data: Dictionary of climate data
+            
+        Returns:
+            Dictionary containing cooling load results
+        """
+        # Initialize component loads
+        component_loads = {
+            "walls": 0,
+            "windows": 0,
+            "doors": 0,
+            "roof": 0,
+            "floor": 0,
+            "people": 0,
+            "lighting": 0,
+            "equipment": 0,
+            "infiltration": 0
+        }
+        
+        # Calculate wall loads
+        for wall in components["walls"]:
+            # Simplified calculation: U-value * Area * Temperature difference
+            temp_diff = climate_data["outdoor_temp"] - climate_data["indoor_temp"]
+            wall_load = wall["u_value"] * wall["area"] * temp_diff / 1000  # Convert to kW
+            component_loads["walls"] += wall_load
+        
+        # Calculate window loads
+        for window in components["windows"]:
+            # Conduction load
+            temp_diff = climate_data["outdoor_temp"] - climate_data["indoor_temp"]
+            window_cond_load = window["u_value"] * window["area"] * temp_diff / 1000
+            
+            # Solar load (simplified)
+            solar_factor = 200  # W/m² (simplified solar radiation)
+            shading_coef = window["shading_coefficient"] if window["has_shading"] else 1.0
+            window_solar_load = window["area"] * window["shgc"] * solar_factor * shading_coef / 1000
+            
+            component_loads["windows"] += window_cond_load + window_solar_load
+        
+        # Calculate door loads
+        for door in components["doors"]:
+            temp_diff = climate_data["outdoor_temp"] - climate_data["indoor_temp"]
+            door_load = door["u_value"] * door["area"] * temp_diff / 1000
+            component_loads["doors"] += door_load
+        
+        # Calculate roof load
+        for roof in components["roofs"]:
+            # Simplified calculation with solar factor
+            temp_diff = (climate_data["outdoor_temp"] + 15) - climate_data["indoor_temp"]  # Add 15°C for solar effect
+            roof_load = roof["u_value"] * roof["area"] * temp_diff / 1000
+            component_loads["roof"] += roof_load
+        
+        # Calculate floor load
+        for floor in components["floors"]:
+            # Simplified calculation
+            temp_diff = climate_data["outdoor_temp"] - climate_data["indoor_temp"]
+            floor_load = floor["u_value"] * floor["area"] * temp_diff * 0.5 / 1000  # 50% of full temp diff
+            component_loads["floor"] += floor_load
+        
+        # Calculate people loads
+        for people in internal_loads["people"]:
+            sensible_load = people["total_sensible"] / 1000  # Convert to kW
+            latent_load = people["total_latent"] / 1000  # Convert to kW
+            component_loads["people"] += sensible_load + latent_load
+        
+        # Calculate lighting loads
+        for lighting in internal_loads["lighting"]:
+            lighting_load = lighting["power"] / 1000  # Convert to kW
+            component_loads["lighting"] += lighting_load
+        
+        # Calculate equipment loads
+        for equipment in internal_loads["equipment"]:
+            sensible_load = equipment["sensible_heat"] / 1000  # Convert to kW
+            latent_load = equipment["latent_heat"] / 1000  # Convert to kW
+            component_loads["equipment"] += sensible_load + latent_load
+        
+        # Calculate infiltration load
+        floor_area = building_info.get("floor_area", 100.0)
+        building_height = building_info.get("building_height", 3.0)
+        infiltration_rate = building_info.get("infiltration_rate", 0.5)
+        volume = floor_area * building_height
+        
+        # Sensible infiltration load
+        air_density = 1.2  # kg/m³
+        specific_heat = 1.005  # kJ/kg·K
+        temp_diff = climate_data["outdoor_temp"] - climate_data["indoor_temp"]
+        sensible_inf = volume * infiltration_rate * air_density * specific_heat * temp_diff / 3600
+        
+        # Latent infiltration load (simplified)
+        latent_heat = 2450  # kJ/kg
+        humidity_diff = 0.005  # kg/kg (simplified)
+        latent_inf = volume * infiltration_rate * air_density * latent_heat * humidity_diff / 3600
+        
+        component_loads["infiltration"] = sensible_inf + latent_inf
+        
+        # Calculate total loads
+        sensible_load = (
+            component_loads["walls"] + 
+            component_loads["windows"] + 
+            component_loads["doors"] + 
+            component_loads["roof"] + 
+            component_loads["floor"] + 
+            component_loads["people"] * 0.7 +  # Assume 70% of people load is sensible
+            component_loads["lighting"] + 
+            component_loads["equipment"] * 0.9 +  # Assume 90% of equipment load is sensible
+            sensible_inf
+        )
+        
+        latent_load = (
+            component_loads["people"] * 0.3 +  # Assume 30% of people load is latent
+            component_loads["equipment"] * 0.1 +  # Assume 10% of equipment load is latent
+            latent_inf
+        )
+        
+        total_load = sensible_load + latent_load
+        
+        # Apply safety factor
+        safety_factor = building_info.get("cooling_safety_factor", 10.0) / 100
+        total_load_with_safety = total_load * (1 + safety_factor)
+        
+        # Calculate load per area
+        load_per_area = total_load_with_safety * 1000 / floor_area  # W/m²
+        
+        # Return results
+        return {
+            "total_load": total_load_with_safety,
+            "sensible_load": sensible_load * (1 + safety_factor),
+            "latent_load": latent_load * (1 + safety_factor),
+            "load_per_area": load_per_area,
+            "component_loads": component_loads
+        }
+    
+    def calculate_heating_load(self, components, building_info, outdoor_conditions, indoor_conditions):
+        """
+        Calculate heating load based on the uploaded data.
+        
+        This is a simplified version that mimics the actual calculation logic.
+        In a real implementation, this would use the HeatingLoad class.
+        
+        Args:
+            components: Dictionary of building components
+            building_info: Dictionary of building information
+            outdoor_conditions: Dictionary of outdoor conditions
+            indoor_conditions: Dictionary of indoor conditions
+            
+        Returns:
+            Dictionary containing heating load results
+        """
+        # Initialize component loads
+        component_loads = {
+            "walls": 0,
+            "windows": 0,
+            "doors": 0,
+            "roof": 0,
+            "floor": 0,
+            "infiltration": 0
+        }
+        
+        # Calculate temperature difference
+        temp_diff = indoor_conditions["temperature"] - outdoor_conditions["temperature"]
+        
+        # Calculate wall loads
+        for wall in components["walls"]:
+            wall_load = wall["u_value"] * wall["area"] * temp_diff / 1000  # Convert to kW
+            component_loads["walls"] += wall_load
+        
+        # Calculate window loads
+        for window in components["windows"]:
+            window_load = window["u_value"] * window["area"] * temp_diff / 1000
+            component_loads["windows"] += window_load
+        
+        # Calculate door loads
+        for door in components["doors"]:
+            door_load = door["u_value"] * door["area"] * temp_diff / 1000
+            component_loads["doors"] += door_load
+        
+        # Calculate roof load
+        for roof in components["roofs"]:
+            roof_load = roof["u_value"] * roof["area"] * temp_diff / 1000
+            component_loads["roof"] += roof_load
+        
+        # Calculate floor load
+        for floor in components["floors"]:
+            floor_load = floor["u_value"] * floor["area"] * temp_diff * 0.5 / 1000  # 50% of full temp diff
+            component_loads["floor"] += floor_load
+        
+        # Calculate infiltration load
+        floor_area = building_info.get("floor_area", 100.0)
+        building_height = building_info.get("building_height", 3.0)
+        infiltration_rate = building_info.get("infiltration_rate", 0.5)
+        volume = floor_area * building_height
+        
+        # Sensible infiltration load
+        air_density = 1.2  # kg/m³
+        specific_heat = 1.005  # kJ/kg·K
+        infiltration_load = volume * infiltration_rate * air_density * specific_heat * temp_diff / 3600
+        component_loads["infiltration"] = infiltration_load
+        
+        # Calculate total load
+        total_load = sum(component_loads.values())
+        
+        # Apply safety factor
+        safety_factor = building_info.get("heating_safety_factor", 10.0) / 100
+        total_load_with_safety = total_load * (1 + safety_factor)
+        
+        # Calculate load per area
+        load_per_area = total_load_with_safety * 1000 / floor_area  # W/m²
+        
+        # Return results
+        return {
+            "total_load": total_load_with_safety,
+            "load_per_area": load_per_area,
+            "design_heat_loss": total_load,
+            "safety_factor": building_info.get("heating_safety_factor", 10.0),
+            "component_loads": component_loads
+        }
+    
+    def calculate_psychrometric_properties(self, outdoor_temp, outdoor_humidity, indoor_temp, indoor_humidity):
+        """
+        Calculate psychrometric properties.
+        
+        This is a simplified version that mimics the actual calculation logic.
+        In a real implementation, this would use the Psychrometrics class.
+        
+        Args:
+            outdoor_temp: Outdoor dry bulb temperature (°C)
+            outdoor_humidity: Outdoor relative humidity (%)
+            indoor_temp: Indoor dry bulb temperature (°C)
+            indoor_humidity: Indoor relative humidity (%)
+            
+        Returns:
+            Dictionary containing psychrometric properties
+        """
+        # Simplified psychrometric calculations
+        
+        # Function to calculate humidity ratio
+        def calculate_humidity_ratio(temp, rh):
+            # Simplified calculation
+            # Saturation pressure (kPa)
+            p_sat = 0.611 * np.exp(17.27 * temp / (temp + 237.3))
+            # Partial pressure of water vapor (kPa)
+            p_w = p_sat * rh / 100
+            # Humidity ratio (kg/kg)
+            w = 0.622 * p_w / (101.325 - p_w)
+            return w
+        
+        # Function to calculate enthalpy
+        def calculate_enthalpy(temp, w):
+            # Simplified calculation
+            # Enthalpy (kJ/kg)
+            h = 1.005 * temp + w * (2501 + 1.86 * temp)
+            return h
+        
+        # Calculate outdoor properties
+        outdoor_w = calculate_humidity_ratio(outdoor_temp, outdoor_humidity)
+        outdoor_h = calculate_enthalpy(outdoor_temp, outdoor_w)
+        
+        # Calculate indoor properties
+        indoor_w = calculate_humidity_ratio(indoor_temp, indoor_humidity)
+        indoor_h = calculate_enthalpy(indoor_temp, indoor_w)
+        
+        # Return results
+        return {
+            "outdoor": {
+                "dry_bulb": outdoor_temp,
+                "relative_humidity": outdoor_humidity,
+                "humidity_ratio": outdoor_w,
+                "enthalpy": outdoor_h
+            },
+            "indoor": {
+                "dry_bulb": indoor_temp,
+                "relative_humidity": indoor_humidity,
+                "humidity_ratio": indoor_w,
+                "enthalpy": indoor_h
+            }
+        }
+
+
+# Run the application
+if __name__ == "__main__":
+    app = HVACCalculatorFileUpload()

utils/utility_modules.py

@@ -0,0 +1,58 @@
+"""
+Minimal utility modules for HVAC Calculator File Upload version
+
+This file contains minimal implementations of the utility classes needed
+for the HVAC Calculator File Upload application to work.
+"""
+
+class CoolingLoad:
+    """Simplified CoolingLoad class for the file upload version."""
+    
+    def __init__(self):
+        """Initialize the CoolingLoad class."""
+        pass
+    
+    def calculate_total_cooling_load(self, **kwargs):
+        """Placeholder for the actual cooling load calculation method."""
+        # This method is not actually used in the file upload version
+        # The calculation is done directly in the HVACCalculatorFileUpload class
+        return {}
+
+class HeatingLoad:
+    """Simplified HeatingLoad class for the file upload version."""
+    
+    def __init__(self):
+        """Initialize the HeatingLoad class."""
+        pass
+    
+    def calculate_design_heating_load(self, **kwargs):
+        """Placeholder for the actual heating load calculation method."""
+        # This method is not actually used in the file upload version
+        # The calculation is done directly in the HVACCalculatorFileUpload class
+        return {}
+
+class Psychrometrics:
+    """Simplified Psychrometrics class for the file upload version."""
+    
+    def __init__(self):
+        """Initialize the Psychrometrics class."""
+        pass
+    
+    def calculate_properties(self, **kwargs):
+        """Placeholder for the actual psychrometric properties calculation method."""
+        # This method is not actually used in the file upload version
+        # The calculation is done directly in the HVACCalculatorFileUpload class
+        return {}
+
+class PsychrometricVisualization:
+    """Simplified PsychrometricVisualization class for the file upload version."""
+    
+    def __init__(self):
+        """Initialize the PsychrometricVisualization class."""
+        pass
+    
+    def display_psychrometric_chart(self, **kwargs):
+        """Placeholder for the actual psychrometric chart display method."""
+        # This method is not actually used in the file upload version
+        # The visualization is done directly in the HVACCalculatorFileUpload class
+        pass