Upload 6 files

app.py

@@ -1,47 +1,53 @@
-"""
-Main application file for HVAC Load Calculator
-
-This is the main entry point for the HVAC Load Calculator web application.
-It sets up the Streamlit interface and navigation between different pages.
-"""
-
 import streamlit as st
-import os
 import sys
+import os
 from pathlib import Path
 
 # Add the parent directory to sys.path to import modules
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 # Import pages
-from pages.cooling_calculator import cooling_calculator
-from pages.heating_calculator import heating_calculator
-
-# Set page configuration
-st.set_page_config(
-    page_title="HVAC Load Calculator",
-    page_icon="🔥❄️",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+from pages.cooling_calculator_enhanced import cooling_calculator
+from pages.heating_calculator_enhanced import heating_calculator
 
-# Define main function
 def main():
-    """Main function for the HVAC Load Calculator web application."""
+    """Main function for the HVAC Load Calculator application."""
+    # Set page config
+    st.set_page_config(
+        page_title="HVAC Load Calculator",
+        page_icon="🔥❄️",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
     
-    # Add custom CSS
+    # Custom CSS
     st.markdown("""
     <style>
-    .main-header {
-        font-size: 2.5rem;
+    .main .block-container {
+        padding-top: 2rem;
+        padding-bottom: 2rem;
+    }
+    h1, h2, h3 {
         color: #1E88E5;
-        text-align: center;
-        margin-bottom: 1rem;
     }
-    .sub-header {
-        font-size: 1.5rem;
-        color: #424242;
-        margin-bottom: 1rem;
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 2px;
+    }
+    .stTabs [data-baseweb="tab"] {
+        height: 50px;
+        white-space: pre-wrap;
+        background-color: #F0F2F6;
+        border-radius: 4px 4px 0 0;
+        gap: 1px;
+        padding-top: 10px;
+        padding-bottom: 10px;
+    }
+    .stTabs [aria-selected="true"] {
+        background-color: #1E88E5;
+        color: white;
+    }
+    .stButton>button {
+        width: 100%;
     }
     .info-box {
         background-color: #E3F2FD;
@@ -49,112 +55,33 @@ def main():
         border-radius: 0.5rem;
         margin-bottom: 1rem;
     }
+    .warning-box {
+        background-color: #FFEBEE;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+    }
+    .success-box {
+        background-color: #E8F5E9;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+    }
     </style>
     """, unsafe_allow_html=True)
     
-    # Sidebar navigation
-    st.sidebar.title("HVAC Load Calculator")
-    st.sidebar.image("https://img.icons8.com/fluency/96/air-conditioner.png", width=100)
+    # Application header
+    st.title("HVAC Load Calculator")
+    st.write("A comprehensive tool for calculating cooling and heating loads based on ASHRAE methods.")
     
-    # Navigation options
-    page = st.sidebar.radio(
-        "Select Calculator",
-        ["Home", "Cooling Load Calculator", "Heating Load Calculator"]
-    )
+    # Create tabs for cooling and heating calculators
+    tab1, tab2 = st.tabs(["Cooling Load Calculator", "Heating Load Calculator"])
     
-    # Display selected page
-    if page == "Home":
-        display_home_page()
-    elif page == "Cooling Load Calculator":
+    with tab1:
         cooling_calculator()
-    elif page == "Heating Load Calculator":
-        heating_calculator()
     
-    # Footer
-    st.sidebar.markdown("---")
-    st.sidebar.info(
-        "HVAC Load Calculator v1.0\n\n"
-        "Based on ASHRAE calculation methods\n\n"
-        "© 2025"
-    )
-
-
-def display_home_page():
-    """Display the home page."""
-    
-    st.markdown('<h1 class="main-header">HVAC Load Calculator</h1>', unsafe_allow_html=True)
-    st.markdown('<h2 class="sub-header">A Modern Tool for HVAC Design</h2>', unsafe_allow_html=True)
-    
-    # Introduction
-    st.markdown("""
-    <div class="info-box">
-    <p>Welcome to the HVAC Load Calculator! This tool helps you calculate cooling and heating loads for buildings
-    using the ASHRAE method. It's designed for educational purposes to help students understand the factors
-    that influence HVAC load calculations.</p>
-    </div>
-    """, unsafe_allow_html=True)
-    
-    # Features
-    st.markdown("### Features")
-    
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        st.markdown("""
-        #### Cooling Load Calculator
-        - Calculate sensible and latent cooling loads
-        - Account for conduction, solar radiation, infiltration, and internal gains
-        - Visualize load components with charts and tables
-        - Export results for assignments
-        """)
-    
-    with col2:
-        st.markdown("""
-        #### Heating Load Calculator
-        - Calculate peak heating loads
-        - Account for conduction, infiltration, and ventilation
-        - Estimate annual heating energy requirements
-        - Visualize load components with charts and tables
-        """)
-    
-    # How to use
-    st.markdown("### How to Use")
-    st.markdown("""
-    1. Select either the Cooling Load Calculator or Heating Load Calculator from the sidebar
-    2. Fill in the required information in each step
-    3. Review any warnings that appear (you can proceed with warnings)
-    4. Calculate results and analyze the output
-    5. Export results for your assignments
-    """)
-    
-    # Reference data
-    st.markdown("### Reference Data")
-    st.markdown("""
-    The calculator includes reference data for:
-    - Building materials (walls, roofs, floors)
-    - Glass types and shading coefficients
-    - Climate data for various locations
-    - Occupancy patterns and internal gains
-    
-    This data is based on ASHRAE standards and guidelines.
-    """)
-    
-    # Get started button
-    col1, col2, col3 = st.columns([1, 2, 1])
-    with col2:
-        st.markdown("### Get Started")
-        cooling_button = st.button("Go to Cooling Load Calculator")
-        heating_button = st.button("Go to Heating Load Calculator")
-    
-    if cooling_button:
-        st.session_state.page = "Cooling Load Calculator"
-        st.experimental_rerun()
-    
-    if heating_button:
-        st.session_state.page = "Heating Load Calculator"
-        st.experimental_rerun()
-
+    with tab2:
+        heating_calculator()
 
-# Run the application
 if __name__ == "__main__":
     main()

cooling_calculator.py

@@ -0,0 +1,50 @@
+        }
+    
+    # Initialize session state for form completion status
+    if 'cooling_completed' not in st.session_state:
+        st.session_state.cooling_completed = {
+            'building_info': False,
+            'building_envelope': False,
+            'windows': False,
+            'internal_loads': False,
+            'ventilation': False
+        }
+    
+    # Initialize session state for calculation results
+    if 'cooling_results' not in st.session_state:
+        st.session_state.cooling_results = None
+
+
+def building_info_form(ref_data):
+    """
+    Form for building information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Building Information")
+    st.write("Enter general building information, location, and design temperatures.")
+    
+    # Get location options from reference data
+    location_options = {loc_id: loc_data['name'] for loc_id, loc_data in ref_data.locations.items()}
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Building name
+        building_name = st.text_input(
+            "Building Name",
+            value=st.session_state.cooling_form_data['building_info'].get('building_name', ''),
+            help="Enter a name for this building or project"
+        )
+        
+        # Location selection
+        location = st.selectbox(
+            "Location",
+            options=list(location_options.keys()),
+            format_func=lambda x: location_options[x],
+            index=list(location_options.keys()).index(st.session_state.cooling_form_data['building_info'].get('location', 'sydney')) if st.session_state.cooling_form_data['building_info'].get('location') in location_options else 0,
+            help="Select the location of the building"
+        )
+        
+        # Get climate data for selected location

cooling_calculator_enhanced.py

@@ -0,0 +1,414 @@
+"""
+Cooling Load Calculator Page (Enhanced Version)
+
+This module implements the cooling load calculator interface for the HVAC Load Calculator web application.
+It provides a step-by-step form for inputting building information and calculates cooling loads
+using the ASHRAE method.
+
+Enhancements:
+- Improved navigation to allow editing previous stages
+- Added custom U-value input capability
+- Enhanced visualization components
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# Add the parent directory to sys.path to import modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import custom modules
+from cooling_load import CoolingLoadCalculator
+from reference_data import ReferenceData
+from utils.validation import validate_input, ValidationWarning
+from utils.export import export_data
+
+
+def load_session_state():
+    """Initialize or load session state variables."""
+    # Initialize session state for form data
+    if 'cooling_form_data' not in st.session_state:
+        st.session_state.cooling_form_data = {
+            'building_info': {},
+            'building_envelope': {},
+            'windows': {},
+            'internal_loads': {},
+            'ventilation': {},
+            'results': {}
+        }
+    
+    # Initialize session state for validation warnings
+    if 'cooling_warnings' not in st.session_state:
+        st.session_state.cooling_warnings = {
+            'building_info': [],
+            'building_envelope': [],
+            'windows': [],
+            'internal_loads': [],
+            'ventilation': []
+        }
+    
+    # Initialize session state for form completion status
+    if 'cooling_completed' not in st.session_state:
+        st.session_state.cooling_completed = {
+            'building_info': False,
+            'building_envelope': False,
+            'windows': False,
+            'internal_loads': False,
+            'ventilation': False
+        }
+    
+    # Initialize session state for calculation results
+    if 'cooling_results' not in st.session_state:
+        st.session_state.cooling_results = None
+    
+    # Initialize active tab if not already set
+    if 'cooling_active_tab' not in st.session_state:
+        st.session_state.cooling_active_tab = "building_info"
+
+
+def building_info_form(ref_data):
+    """
+    Form for building information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Building Information")
+    st.write("Enter general building information, location, and design temperatures.")
+    
+    # Get location options from reference data
+    location_options = {loc_id: loc_data['name'] for loc_id, loc_data in ref_data.locations.items()}
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Building name
+        building_name = st.text_input(
+            "Building Name",
+            value=st.session_state.cooling_form_data['building_info'].get('building_name', ''),
+            help="Enter a name for this building or project",
+            key="cooling_building_name"
+        )
+        
+        # Location selection
+        location = st.selectbox(
+            "Location",
+            options=list(location_options.keys()),
+            format_func=lambda x: location_options[x],
+            index=list(location_options.keys()).index(st.session_state.cooling_form_data['building_info'].get('location', 'sydney')) if st.session_state.cooling_form_data['building_info'].get('location') in location_options else 0,
+            help="Select the location of the building",
+            key="cooling_location"
+        )
+        
+        # Get climate data for selected location
+        location_data = ref_data.get_location_data(location)
+        
+        # Indoor design temperature
+        indoor_temp = st.number_input(
+            "Indoor Design Temperature (°C)",
+            value=float(st.session_state.cooling_form_data['building_info'].get('indoor_temp', 24.0)),
+            min_value=20.0,
+            max_value=30.0,
+            step=0.5,
+            help="Recommended indoor design temperature for cooling is 24°C",
+            key="cooling_indoor_temp"
+        )
+    
+    with col2:
+        # Building type
+        building_type = st.selectbox(
+            "Building Type",
+            options=["Residential", "Small Office", "Educational", "Other"],
+            index=["Residential", "Small Office", "Educational", "Other"].index(st.session_state.cooling_form_data['building_info'].get('building_type', 'Residential')),
+            help="Select the type of building",
+            key="cooling_building_type"
+        )
+        
+        # Outdoor design temperature (with default from location data)
+        outdoor_temp = st.number_input(
+            "Outdoor Design Temperature (°C)",
+            value=float(st.session_state.cooling_form_data['building_info'].get('outdoor_temp', location_data['summer_design_temp'])),
+            min_value=20.0,
+            max_value=45.0,
+            step=0.5,
+            help=f"Default value is based on selected location ({location_data['name']})",
+            key="cooling_outdoor_temp"
+        )
+    
+    # Building dimensions
+    st.subheader("Building Dimensions")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        length = st.number_input(
+            "Length (m)",
+            value=float(st.session_state.cooling_form_data['building_info'].get('length', 10.0)),
+            min_value=1.0,
+            step=0.1,
+            help="Building length in meters",
+            key="cooling_length"
+        )
+    
+    with col2:
+        width = st.number_input(
+            "Width (m)",
+            value=float(st.session_state.cooling_form_data['building_info'].get('width', 8.0)),
+            min_value=1.0,
+            step=0.1,
+            help="Building width in meters",
+            key="cooling_width"
+        )
+    
+    with col3:
+        height = st.number_input(
+            "Height (m)",
+            value=float(st.session_state.cooling_form_data['building_info'].get('height', 2.7)),
+            min_value=1.0,
+            step=0.1,
+            help="Floor-to-ceiling height in meters",
+            key="cooling_height"
+        )
+    
+    # Calculate floor area and volume
+    floor_area = length * width
+    volume = floor_area * height
+    
+    st.info(f"Floor Area: {floor_area:.2f} m² | Volume: {volume:.2f} m³")
+    
+    # Save form data to session state
+    form_data = {
+        'building_name': building_name,
+        'building_type': building_type,
+        'location': location,
+        'location_name': location_data['name'],
+        'indoor_temp': indoor_temp,
+        'outdoor_temp': outdoor_temp,
+        'length': length,
+        'width': width,
+        'height': height,
+        'floor_area': floor_area,
+        'volume': volume,
+        'temp_diff': outdoor_temp - indoor_temp
+    }
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if building name is provided
+    if not building_name:
+        warnings.append(ValidationWarning("Building name is empty", "Consider adding a building name for reference"))
+    
+    # Check if temperature difference is reasonable
+    if form_data['temp_diff'] <= 0:
+        warnings.append(ValidationWarning(
+            "Invalid temperature difference",
+            "Outdoor temperature should be higher than indoor temperature for cooling load calculation",
+            is_critical=True
+        ))
+    
+    # Check if dimensions are reasonable
+    if floor_area > 500:
+        warnings.append(ValidationWarning(
+            "Large floor area",
+            "Floor area exceeds 500 m², verify if this is correct for a residential building"
+        ))
+    
+    if height < 2.4 or height > 3.5:
+        warnings.append(ValidationWarning(
+            "Unusual ceiling height",
+            "Typical residential ceiling heights are between 2.4m and 3.5m"
+        ))
+    
+    # Save warnings to session state
+    st.session_state.cooling_warnings['building_info'] = warnings
+    
+    # Display warnings if any
+    if warnings:
+        st.warning("Please review the following warnings:")
+        for warning in warnings:
+            st.write(f"- {warning.message}" + (" (Critical)" if warning.is_critical else ""))
+            st.write(f"  Suggestion: {warning.suggestion}")
+    
+    # Save form data regardless of warnings
+    st.session_state.cooling_form_data['building_info'] = form_data
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.cooling_completed['building_info'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col2:
+        next_button = st.button("Next: Building Envelope →", key="cooling_building_info_next")
+        if next_button:
+            st.session_state.cooling_active_tab = "building_envelope"
+            st.experimental_rerun()
+
+
+def building_envelope_form(ref_data):
+    """
+    Form for building envelope information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Building Envelope")
+    st.write("Enter information about walls, roof, and floor construction.")
+    
+    # Get building dimensions from previous step
+    building_info = st.session_state.cooling_form_data['building_info']
+    length = building_info.get('length', 10.0)
+    width = building_info.get('width', 8.0)
+    height = building_info.get('height', 2.7)
+    temp_diff = building_info.get('temp_diff', 11.0)
+    
+    # Calculate default areas
+    default_wall_area = 2 * (length + width) * height
+    default_roof_area = length * width
+    default_floor_area = length * width
+    
+    # Initialize envelope data if not already in session state
+    if 'walls' not in st.session_state.cooling_form_data['building_envelope']:
+        st.session_state.cooling_form_data['building_envelope']['walls'] = []
+    
+    if 'roof' not in st.session_state.cooling_form_data['building_envelope']:
+        st.session_state.cooling_form_data['building_envelope']['roof'] = {}
+    
+    if 'floor' not in st.session_state.cooling_form_data['building_envelope']:
+        st.session_state.cooling_form_data['building_envelope']['floor'] = {}
+    
+    # Walls section
+    st.write("### Walls")
+    
+    # Get wall material options from reference data
+    wall_material_options = {mat_id: mat_data['name'] for mat_id, mat_data in ref_data.materials['walls'].items()}
+    wall_material_options['custom'] = "Custom U-value"
+    
+    # Display existing wall entries
+    if st.session_state.cooling_form_data['building_envelope']['walls']:
+        st.write("Current walls:")
+        walls_df = pd.DataFrame(st.session_state.cooling_form_data['building_envelope']['walls'])
+        walls_df['Material'] = walls_df['material_id'].map(lambda x: wall_material_options.get(x, "Custom"))
+        walls_df = walls_df[['name', 'Material', 'area', 'u_value']]
+        walls_df.columns = ['Name', 'Material', 'Area (m²)', 'U-Value (W/m²°C)']
+        st.dataframe(walls_df)
+        
+        # Add edit/delete buttons for existing walls
+        if st.button("Edit/Delete Walls", key="edit_walls_cooling"):
+            st.session_state.cooling_edit_walls = True
+        
+        if st.session_state.get('cooling_edit_walls', False):
+            st.write("Select a wall to edit or delete:")
+            for i, wall in enumerate(st.session_state.cooling_form_data['building_envelope']['walls']):
+                col1, col2 = st.columns([3, 1])
+                with col1:
+                    st.write(f"{wall['name']} - {wall_material_options.get(wall['material_id'], 'Custom')}, {wall['area']:.2f} m², U-value: {wall['u_value']:.2f}")
+                with col2:
+                    if st.button("Delete", key=f"delete_wall_{i}_cooling"):
+                        st.session_state.cooling_form_data['building_envelope']['walls'].pop(i)
+                        st.experimental_rerun()
+            
+            if st.button("Done Editing", key="done_editing_walls_cooling"):
+                st.session_state.cooling_edit_walls = False
+                st.experimental_rerun()
+    
+    # Add new wall form
+    st.write("Add a new wall:")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        wall_name = st.text_input("Wall Name", value="", key="new_wall_name_cooling")
+        wall_material = st.selectbox(
+            "Wall Material",
+            options=list(wall_material_options.keys()),
+            format_func=lambda x: wall_material_options[x],
+            key="new_wall_material_cooling"
+        )
+        
+        # Get material properties or allow custom U-value
+        if wall_material == 'custom':
+            u_value = st.number_input(
+                "Custom U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="new_wall_custom_u_value_cooling"
+            )
+            st.info("Typical U-values for walls range from 0.15 to 3.0 W/m²°C")
+        else:
+            material_data = ref_data.get_material_by_type("walls", wall_material)
+            u_value = material_data['u_value']
+            st.info(f"Material: {material_data['name']}, U-Value: {u_value} W/m²°C")
+        
+    with col2:
+        wall_area = st.number_input(
+            "Wall Area (m²)",
+            value=default_wall_area / 4,  # Default to 1/4 of total wall area as a starting point
+            min_value=0.1,
+            step=0.1,
+            key="new_wall_area_cooling"
+        )
+        
+        st.write(f"Heat Gain: {u_value * wall_area * temp_diff:.2f} W")
+    
+    # Add wall button
+    if st.button("Add Wall", key="add_wall_cooling"):
+        new_wall = {
+            'name': wall_name if wall_name else f"Wall {len(st.session_state.cooling_form_data['building_envelope']['walls']) + 1}",
+            'material_id': wall_material,
+            'area': wall_area,
+            'u_value': u_value,
+            'temp_diff': temp_diff
+        }
+        st.session_state.cooling_form_data['building_envelope']['walls'].append(new_wall)
+        st.experimental_rerun()
+    
+    # Roof section
+    st.write("### Roof")
+    
+    # Get roof material options from reference data
+    roof_material_options = {mat_id: mat_data['name'] for mat_id, mat_data in ref_data.materials['roofs'].items()}
+    roof_material_options['custom'] = "Custom U-value"
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        roof_material = st.selectbox(
+            "Roof Material",
+            options=list(roof_material_options.keys()),
+            format_func=lambda x: roof_material_options[x],
+            index=list(roof_material_options.keys()).index(st.session_state.cooling_form_data['building_envelope'].get('roof', {}).get('material_id', 'metal_deck_insulated')) if st.session_state.cooling_form_data['building_envelope'].get('roof', {}).get('material_id') in roof_material_options else 0,
+            key="roof_material_cooling"
+        )
+        
+        # Get material properties or allow custom U-value
+        if roof_material == 'custom':
+            roof_u_value = st.number_input(
+                "Custom U-Value (W/m²°C)",
+                value=float(st.session_state.cooling_form_data['building_envelope'].get('roof', {}).get('u_value', 0.5)),
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="roof_custom_u_value_cooling"
+            )
+            st.info("Typical U-values for roofs range from 0.15 to 2.0 W/m²°C")
+        else:
+            material_data = ref_data.get_material_by_type("roofs", roof_material)
+            roof_u_value = material_data['u_value']
+            st.info(f"Material: {material_data['name']}, U-Value: {roof_u_value} W/m²°C")
+        
+    with col2:
+        roof_area = st.number_input(
+            "Roof Area (m²)",
+            value=float(st.sess<response clipped><NOTE>To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with `grep -n` in order to find the line numbers of what you are looking for.</NOTE>

heating_calculator.py

@@ -0,0 +1,50 @@
+"""
+Heating Load Calculator Page
+
+This module implements the heating load calculator interface for the HVAC Load Calculator web application.
+It provides a step-by-step form for inputting building information and calculates heating loads
+using the ASHRAE method.
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# Add the parent directory to sys.path to import modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import custom modules
+from heating_load import HeatingLoadCalculator
+from reference_data import ReferenceData
+from utils.validation import validate_input, ValidationWarning
+from utils.export import export_data
+
+
+def load_session_state():
+    """Initialize or load session state variables."""
+    # Initialize session state for form data
+    if 'heating_form_data' not in st.session_state:
+        st.session_state.heating_form_data = {
+            'building_info': {},
+            'building_envelope': {},
+            'windows': {},
+            'ventilation': {},
+            'occupancy': {},
+            'results': {}
+        }
+    
+    # Initialize session state for validation warnings
+    if 'heating_warnings' not in st.session_state:
+        st.session_state.heating_warnings = {
+            'building_info': [],
+            'building_envelope': [],
+            'windows': [],
+            'ventilation': [],
+            'occupancy': []

heating_calculator_enhanced.py

@@ -0,0 +1,410 @@
+"""
+Heating Load Calculator Page (Enhanced Version)
+
+This module implements the heating load calculator interface for the HVAC Load Calculator web application.
+It provides a step-by-step form for inputting building information and calculates heating loads
+using the ASHRAE method.
+
+Enhancements:
+- Improved navigation to allow editing previous stages
+- Added custom U-value input capability
+- Included internal loads as heating contributors
+- Enhanced visualization components
+"""
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+# Add the parent directory to sys.path to import modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import custom modules
+from heating_load import HeatingLoadCalculator
+from reference_data import ReferenceData
+from utils.validation import validate_input, ValidationWarning
+from utils.export import export_data
+
+
+def load_session_state():
+    """Initialize or load session state variables."""
+    # Initialize session state for form data
+    if 'heating_form_data' not in st.session_state:
+        st.session_state.heating_form_data = {
+            'building_info': {},
+            'building_envelope': {},
+            'windows': {},
+            'ventilation': {},
+            'internal_loads': {},  # Added internal loads section
+            'results': {}
+        }
+    
+    # Initialize session state for validation warnings
+    if 'heating_warnings' not in st.session_state:
+        st.session_state.heating_warnings = {
+            'building_info': [],
+            'building_envelope': [],
+            'windows': [],
+            'ventilation': [],
+            'internal_loads': []  # Added internal loads section
+        }
+    
+    # Initialize session state for form completion status
+    if 'heating_completed' not in st.session_state:
+        st.session_state.heating_completed = {
+            'building_info': False,
+            'building_envelope': False,
+            'windows': False,
+            'ventilation': False,
+            'internal_loads': False  # Added internal loads section
+        }
+    
+    # Initialize session state for calculation results
+    if 'heating_results' not in st.session_state:
+        st.session_state.heating_results = None
+    
+    # Initialize active tab if not already set
+    if 'heating_active_tab' not in st.session_state:
+        st.session_state.heating_active_tab = "building_info"
+
+
+def building_info_form(ref_data):
+    """
+    Form for building information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Building Information")
+    st.write("Enter general building information, location, and design temperatures.")
+    
+    # Get location options from reference data
+    location_options = {loc_id: loc_data['name'] for loc_id, loc_data in ref_data.locations.items()}
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Building name
+        building_name = st.text_input(
+            "Building Name",
+            value=st.session_state.heating_form_data['building_info'].get('building_name', ''),
+            help="Enter a name for this building or project",
+            key="heating_building_name"
+        )
+        
+        # Location selection
+        location = st.selectbox(
+            "Location",
+            options=list(location_options.keys()),
+            format_func=lambda x: location_options[x],
+            index=list(location_options.keys()).index(st.session_state.heating_form_data['building_info'].get('location', 'sydney')) if st.session_state.heating_form_data['building_info'].get('location') in location_options else 0,
+            help="Select the location of the building",
+            key="heating_location"
+        )
+        
+        # Get climate data for selected location
+        location_data = ref_data.get_location_data(location)
+        
+        # Indoor design temperature
+        indoor_temp = st.number_input(
+            "Indoor Design Temperature (°C)",
+            value=float(st.session_state.heating_form_data['building_info'].get('indoor_temp', 21.0)),
+            min_value=15.0,
+            max_value=25.0,
+            step=0.5,
+            help="Recommended indoor design temperature for heating is 21°C",
+            key="heating_indoor_temp"
+        )
+    
+    with col2:
+        # Building type
+        building_type = st.selectbox(
+            "Building Type",
+            options=["Residential", "Small Office", "Educational", "Other"],
+            index=["Residential", "Small Office", "Educational", "Other"].index(st.session_state.heating_form_data['building_info'].get('building_type', 'Residential')),
+            help="Select the type of building",
+            key="heating_building_type"
+        )
+        
+        # Outdoor design temperature (with default from location data)
+        outdoor_temp = st.number_input(
+            "Outdoor Design Temperature (°C)",
+            value=float(st.session_state.heating_form_data['building_info'].get('outdoor_temp', location_data['winter_design_temp'])),
+            min_value=-20.0,
+            max_value=15.0,
+            step=0.5,
+            help=f"Default value is based on selected location ({location_data['name']})",
+            key="heating_outdoor_temp"
+        )
+    
+    # Building dimensions
+    st.subheader("Building Dimensions")
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        length = st.number_input(
+            "Length (m)",
+            value=float(st.session_state.heating_form_data['building_info'].get('length', 10.0)),
+            min_value=1.0,
+            step=0.1,
+            help="Building length in meters",
+            key="heating_length"
+        )
+    
+    with col2:
+        width = st.number_input(
+            "Width (m)",
+            value=float(st.session_state.heating_form_data['building_info'].get('width', 8.0)),
+            min_value=1.0,
+            step=0.1,
+            help="Building width in meters",
+            key="heating_width"
+        )
+    
+    with col3:
+        height = st.number_input(
+            "Height (m)",
+            value=float(st.session_state.heating_form_data['building_info'].get('height', 2.7)),
+            min_value=1.0,
+            step=0.1,
+            help="Floor-to-ceiling height in meters",
+            key="heating_height"
+        )
+    
+    # Calculate floor area and volume
+    floor_area = length * width
+    volume = floor_area * height
+    
+    st.info(f"Floor Area: {floor_area:.2f} m² | Volume: {volume:.2f} m³")
+    
+    # Save form data to session state
+    form_data = {
+        'building_name': building_name,
+        'building_type': building_type,
+        'location': location,
+        'location_name': location_data['name'],
+        'indoor_temp': indoor_temp,
+        'outdoor_temp': outdoor_temp,
+        'length': length,
+        'width': width,
+        'height': height,
+        'floor_area': floor_area,
+        'volume': volume,
+        'temp_diff': indoor_temp - outdoor_temp
+    }
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if building name is provided
+    if not building_name:
+        warnings.append(ValidationWarning("Building name is empty", "Consider adding a building name for reference"))
+    
+    # Check if temperature difference is reasonable
+    if form_data['temp_diff'] <= 0:
+        warnings.append(ValidationWarning(
+            "Invalid temperature difference",
+            "Indoor temperature should be higher than outdoor temperature for heating load calculation",
+            is_critical=True
+        ))
+    
+    # Check if dimensions are reasonable
+    if floor_area > 500:
+        warnings.append(ValidationWarning(
+            "Large floor area",
+            "Floor area exceeds 500 m², verify if this is correct for a residential building"
+        ))
+    
+    if height < 2.4 or height > 3.5:
+        warnings.append(ValidationWarning(
+            "Unusual ceiling height",
+            "Typical residential ceiling heights are between 2.4m and 3.5m"
+        ))
+    
+    # Save warnings to session state
+    st.session_state.heating_warnings['building_info'] = warnings
+    
+    # Display warnings if any
+    if warnings:
+        st.warning("Please review the following warnings:")
+        for warning in warnings:
+            st.write(f"- {warning.message}" + (" (Critical)" if warning.is_critical else ""))
+            st.write(f"  Suggestion: {warning.suggestion}")
+    
+    # Save form data regardless of warnings
+    st.session_state.heating_form_data['building_info'] = form_data
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.heating_completed['building_info'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col2:
+        next_button = st.button("Next: Building Envelope →", key="heating_building_info_next")
+        if next_button:
+            st.session_state.heating_active_tab = "building_envelope"
+            st.experimental_rerun()
+
+
+def building_envelope_form(ref_data):
+    """
+    Form for building envelope information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Building Envelope")
+    st.write("Enter information about walls, roof, and floor construction.")
+    
+    # Get building dimensions from previous step
+    building_info = st.session_state.heating_form_data['building_info']
+    length = building_info.get('length', 10.0)
+    width = building_info.get('width', 8.0)
+    height = building_info.get('height', 2.7)
+    temp_diff = building_info.get('temp_diff', 21.0)
+    
+    # Calculate default areas
+    default_wall_area = 2 * (length + width) * height
+    default_roof_area = length * width
+    default_floor_area = length * width
+    
+    # Initialize envelope data if not already in session state
+    if 'walls' not in st.session_state.heating_form_data['building_envelope']:
+        st.session_state.heating_form_data['building_envelope']['walls'] = []
+    
+    if 'roof' not in st.session_state.heating_form_data['building_envelope']:
+        st.session_state.heating_form_data['building_envelope']['roof'] = {}
+    
+    if 'floor' not in st.session_state.heating_form_data['building_envelope']:
+        st.session_state.heating_form_data['building_envelope']['floor'] = {}
+    
+    # Walls section
+    st.write("### Walls")
+    
+    # Get wall material options from reference data
+    wall_material_options = {mat_id: mat_data['name'] for mat_id, mat_data in ref_data.materials['walls'].items()}
+    wall_material_options['custom'] = "Custom U-value"
+    
+    # Display existing wall entries
+    if st.session_state.heating_form_data['building_envelope']['walls']:
+        st.write("Current walls:")
+        walls_df = pd.DataFrame(st.session_state.heating_form_data['building_envelope']['walls'])
+        walls_df['Material'] = walls_df['material_id'].map(lambda x: wall_material_options.get(x, "Custom"))
+        walls_df = walls_df[['name', 'Material', 'area', 'u_value']]
+        walls_df.columns = ['Name', 'Material', 'Area (m²)', 'U-Value (W/m²°C)']
+        st.dataframe(walls_df)
+        
+        # Add edit/delete buttons for existing walls
+        if st.button("Edit/Delete Walls", key="edit_walls_heating"):
+            st.session_state.heating_edit_walls = True
+        
+        if st.session_state.get('heating_edit_walls', False):
+            st.write("Select a wall to edit or delete:")
+            for i, wall in enumerate(st.session_state.heating_form_data['building_envelope']['walls']):
+                col1, col2 = st.columns([3, 1])
+                with col1:
+                    st.write(f"{wall['name']} - {wall_material_options.get(wall['material_id'], 'Custom')}, {wall['area']:.2f} m², U-value: {wall['u_value']:.2f}")
+                with col2:
+                    if st.button("Delete", key=f"delete_wall_{i}_heating"):
+                        st.session_state.heating_form_data['building_envelope']['walls'].pop(i)
+                        st.experimental_rerun()
+            
+            if st.button("Done Editing", key="done_editing_walls_heating"):
+                st.session_state.heating_edit_walls = False
+                st.experimental_rerun()
+    
+    # Add new wall form
+    st.write("Add a new wall:")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        wall_name = st.text_input("Wall Name", value="", key="new_wall_name_heating")
+        wall_material = st.selectbox(
+            "Wall Material",
+            options=list(wall_material_options.keys()),
+            format_func=lambda x: wall_material_options[x],
+            key="new_wall_material_heating"
+        )
+        
+        # Get material properties or allow custom U-value
+        if wall_material == 'custom':
+            u_value = st.number_input(
+                "Custom U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="new_wall_custom_u_value_heating"
+            )
+            st.info("Typical U-values for walls range from 0.15 to 3.0 W/m²°C")
+        else:
+            material_data = ref_data.get_material_by_type("walls", wall_material)
+            u_value = material_data['u_value']
+            st.info(f"Material: {material_data['name']}, U-Value: {u_value} W/m²°C")
+        
+    with col2:
+        wall_area = st.number_input(
+            "Wall Area (m²)",
+            value=default_wall_area / 4,  # Default to 1/4 of total wall area as a starting point
+            min_value=0.1,
+            step=0.1,
+            key="new_wall_area_heating"
+        )
+        
+        st.write(f"Heat Loss: {u_value * wall_area * temp_diff:.2f} W")
+    
+    # Add wall button
+    if st.button("Add Wall", key="add_wall_heating"):
+        new_wall = {
+            'name': wall_name if wall_name else f"Wall {len(st.session_state.heating_form_data['building_envelope']['walls']) + 1}",
+            'material_id': wall_material,
+            'area': wall_area,
+            'u_value': u_value,
+            'temp_diff': temp_diff
+        }
+        st.session_state.heating_form_data['building_envelope']['walls'].append(new_wall)
+        st.experimental_rerun()
+    
+    # Roof section
+    st.write("### Roof")
+    
+    # Get roof material options from reference data
+    roof_material_options = {mat_id: mat_data['name'] for mat_id, mat_data in ref_data.materials['roofs'].items()}
+    roof_material_options['custom'] = "Custom U-value"
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        roof_material = st.selectbox(
+            "Roof Material",
+            options=list(roof_material_options.keys()),
+            format_func=lambda x: roof_material_options[x],
+            index=list(roof_material_options.keys()).index(st.session_state.heating_form_data['building_envelope'].get('roof', {}).get('material_id', 'metal_deck_insulated')) if st.session_state.heating_form_data['building_envelope'].get('roof', {}).get('material_id') in roof_material_options else 0,
+            key="roof_material_heating"
+        )
+        
+        # Get material properties or allow custom U-value
+        if roof_material == 'custom':
+            roof_u_value = st.number_input(
+                "Custom U-Value (W/m²°C)",
+                value=float(st.session_state.heating_form_data['building_envelope'].get('roof', {}).get('u_value', 0.5)),
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="roof_custom_u_value_heating"
+            )
+            st.info("Typical U-values for roofs range from 0.15 to 2.0 W/m²°C")
+        else:
+            material_data = ref_data.get_material_by_type("roofs", roof_material)
+            roof_u_value = material_data['u_value']
+            st.info(f"Material: {material_data['name']}, U-Value:<response clipped><NOTE>To save on context only part of this file has been shown to you. You should retry this tool after you have searched inside the file with `grep -n` in order to find the line numbers of what you are looking for.</NOTE>

visualization.py

@@ -0,0 +1,512 @@
+"""
+Visualization utilities for HVAC Load Calculator
+
+This module provides enhanced visualization functions for creating interactive
+and informative charts for the HVAC Load Calculator application.
+"""
+
+import plotly.express as px
+import plotly.graph_objects as go
+import pandas as pd
+import numpy as np
+
+
+def create_load_breakdown_chart(load_components, title="Load Breakdown"):
+    """
+    Create an enhanced pie chart for load components breakdown.
+    
+    Args:
+        load_components (dict): Dictionary of load components and their values
+        title (str): Chart title
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive pie chart
+    """
+    # Remove zero values
+    load_components = {k: v for k, v in load_components.items() if v > 0}
+    
+    # Create figure
+    fig = go.Figure()
+    
+    # Add pie chart
+    fig.add_trace(go.Pie(
+        labels=list(load_components.keys()),
+        values=list(load_components.values()),
+        textinfo='label+percent',
+        insidetextorientation='radial',
+        marker=dict(
+            colors=px.colors.qualitative.Bold,
+            line=dict(color='white', width=2)
+        ),
+        pull=[0.05 if x == max(load_components.values()) else 0 for x in load_components.values()],
+        hovertemplate='<b>%{label}</b><br>%{value:.1f} W<br>%{percent}<extra></extra>'
+    ))
+    
+    # Update layout
+    fig.update_layout(
+        title={
+            'text': title,
+            'y': 0.95,
+            'x': 0.5,
+            'xanchor': 'center',
+            'yanchor': 'top',
+            'font': dict(size=20)
+        },
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=-0.2,
+            xanchor="center",
+            x=0.5,
+            font=dict(size=12)
+        ),
+        height=500,
+        margin=dict(t=80, b=80, l=40, r=40),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)'
+    )
+    
+    return fig
+
+
+def create_component_bar_chart(df, x_col, y_col, color_col=None, title="Component Breakdown"):
+    """
+    Create an enhanced bar chart for component breakdown.
+    
+    Args:
+        df (pd.DataFrame): DataFrame containing the data
+        x_col (str): Column name for x-axis
+        y_col (str): Column name for y-axis
+        color_col (str, optional): Column name for color grouping
+        title (str): Chart title
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive bar chart
+    """
+    # Create figure
+    if color_col:
+        fig = px.bar(
+            df,
+            x=x_col,
+            y=y_col,
+            color=color_col,
+            title=title,
+            color_discrete_sequence=px.colors.qualitative.Bold,
+            height=500,
+            text=y_col
+        )
+    else:
+        fig = px.bar(
+            df,
+            x=x_col,
+            y=y_col,
+            title=title,
+            color_discrete_sequence=px.colors.qualitative.Bold,
+            height=500,
+            text=y_col
+        )
+    
+    # Update layout
+    fig.update_layout(
+        xaxis_title=x_col,
+        yaxis_title=y_col,
+        legend_title=color_col if color_col else "",
+        font=dict(size=12),
+        xaxis={'categoryorder': 'total descending'},
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        hovermode="x unified"
+    )
+    
+    # Add data labels
+    fig.update_traces(
+        texttemplate='%{y:.1f}',
+        textposition='outside',
+        hovertemplate='<b>%{x}</b><br>%{y:.1f}<extra></extra>'
+    )
+    
+    # Add grid lines
+    fig.update_yaxes(
+        showgrid=True,
+        gridwidth=1,
+        gridcolor='rgba(211,211,211,0.3)'
+    )
+    
+    return fig
+
+
+def create_stacked_bar_chart(df, x_col, y_cols, names, title="Stacked Bar Chart"):
+    """
+    Create an enhanced stacked bar chart.
+    
+    Args:
+        df (pd.DataFrame): DataFrame containing the data
+        x_col (str): Column name for x-axis
+        y_cols (list): List of column names for y-axis values
+        names (list): List of names for each y-column
+        title (str): Chart title
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive stacked bar chart
+    """
+    # Create figure
+    fig = go.Figure()
+    
+    # Add bars for each y column
+    for i, y_col in enumerate(y_cols):
+        fig.add_trace(go.Bar(
+            x=df[x_col],
+            y=df[y_col],
+            name=names[i],
+            hovertemplate=f'<b>{names[i]}</b>: %{{y:.1f}}<extra></extra>'
+        ))
+    
+    # Update layout
+    fig.update_layout(
+        title=title,
+        xaxis_title=x_col,
+        yaxis_title="Value",
+        barmode='stack',
+        height=500,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="center",
+            x=0.5
+        ),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        hovermode="x unified"
+    )
+    
+    # Add grid lines
+    fig.update_yaxes(
+        showgrid=True,
+        gridwidth=1,
+        gridcolor='rgba(211,211,211,0.3)'
+    )
+    
+    return fig
+
+
+def create_grouped_bar_chart(df, x_col, y_cols, names, title="Grouped Bar Chart"):
+    """
+    Create an enhanced grouped bar chart.
+    
+    Args:
+        df (pd.DataFrame): DataFrame containing the data
+        x_col (str): Column name for x-axis
+        y_cols (list): List of column names for y-axis values
+        names (list): List of names for each y-column
+        title (str): Chart title
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive grouped bar chart
+    """
+    # Create figure
+    fig = go.Figure()
+    
+    # Add bars for each y column
+    for i, y_col in enumerate(y_cols):
+        fig.add_trace(go.Bar(
+            x=df[x_col],
+            y=df[y_col],
+            name=names[i],
+            hovertemplate=f'<b>{names[i]}</b>: %{{y:.1f}}<extra></extra>'
+        ))
+    
+    # Update layout
+    fig.update_layout(
+        title=title,
+        xaxis_title=x_col,
+        yaxis_title="Value",
+        barmode='group',
+        height=500,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="center",
+            x=0.5
+        ),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        hovermode="x unified"
+    )
+    
+    # Add grid lines
+    fig.update_yaxes(
+        showgrid=True,
+        gridwidth=1,
+        gridcolor='rgba(211,211,211,0.3)'
+    )
+    
+    return fig
+
+
+def create_heat_map_chart(df, x_col, y_col, z_col, title="Heat Map"):
+    """
+    Create an enhanced heat map chart.
+    
+    Args:
+        df (pd.DataFrame): DataFrame containing the data
+        x_col (str): Column name for x-axis
+        y_col (str): Column name for y-axis
+        z_col (str): Column name for z-axis (color)
+        title (str): Chart title
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive heat map chart
+    """
+    # Create figure
+    fig = px.density_heatmap(
+        df,
+        x=x_col,
+        y=y_col,
+        z=z_col,
+        title=title,
+        color_continuous_scale="Viridis",
+        height=500
+    )
+    
+    # Update layout
+    fig.update_layout(
+        xaxis_title=x_col,
+        yaxis_title=y_col,
+        font=dict(size=12),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)'
+    )
+    
+    return fig
+
+
+def create_line_chart(df, x_col, y_cols, names, title="Line Chart"):
+    """
+    Create an enhanced line chart.
+    
+    Args:
+        df (pd.DataFrame): DataFrame containing the data
+        x_col (str): Column name for x-axis
+        y_cols (list): List of column names for y-axis values
+        names (list): List of names for each y-column
+        title (str): Chart title
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive line chart
+    """
+    # Create figure
+    fig = go.Figure()
+    
+    # Add lines for each y column
+    for i, y_col in enumerate(y_cols):
+        fig.add_trace(go.Scatter(
+            x=df[x_col],
+            y=df[y_col],
+            mode='lines+markers',
+            name=names[i],
+            hovertemplate=f'<b>{names[i]}</b>: %{{y:.1f}}<extra></extra>'
+        ))
+    
+    # Update layout
+    fig.update_layout(
+        title=title,
+        xaxis_title=x_col,
+        yaxis_title="Value",
+        height=500,
+        legend=dict(
+            orientation="h",
+            yanchor="bottom",
+            y=1.02,
+            xanchor="center",
+            x=0.5
+        ),
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)',
+        hovermode="x unified"
+    )
+    
+    # Add grid lines
+    fig.update_yaxes(
+        showgrid=True,
+        gridwidth=1,
+        gridcolor='rgba(211,211,211,0.3)'
+    )
+    
+    fig.update_xaxes(
+        showgrid=True,
+        gridwidth=1,
+        gridcolor='rgba(211,211,211,0.3)'
+    )
+    
+    return fig
+
+
+def create_sankey_diagram(nodes, links, title="Energy Flow"):
+    """
+    Create a Sankey diagram for energy flow visualization.
+    
+    Args:
+        nodes (list): List of node labels
+        links (dict): Dictionary with source, target, and value lists
+        title (str): Chart title
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive Sankey diagram
+    """
+    # Create figure
+    fig = go.Figure(data=[go.Sankey(
+        node=dict(
+            pad=15,
+            thickness=20,
+            line=dict(color="black", width=0.5),
+            label=nodes,
+            color="blue"
+        ),
+        link=dict(
+            source=links['source'],
+            target=links['target'],
+            value=links['value'],
+            hovertemplate='%{source.label} → %{target.label}: %{value:.1f} W<extra></extra>'
+        )
+    )])
+    
+    # Update layout
+    fig.update_layout(
+        title=title,
+        font=dict(size=12),
+        height=600,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)'
+    )
+    
+    return fig
+
+
+def create_gauge_chart(value, min_val, max_val, title="Gauge", threshold_values=None, threshold_colors=None):
+    """
+    Create a gauge chart for displaying a value within a range.
+    
+    Args:
+        value (float): Value to display
+        min_val (float): Minimum value of the range
+        max_val (float): Maximum value of the range
+        title (str): Chart title
+        threshold_values (list, optional): List of threshold values
+        threshold_colors (list, optional): List of colors for each threshold
+        
+    Returns:
+        plotly.graph_objects.Figure: Interactive gauge chart
+    """
+    # Set default thresholds if not provided
+    if threshold_values is None:
+        threshold_values = [min_val, (min_val + max_val) / 2, max_val]
+    
+    if threshold_colors is None:
+        threshold_colors = ["green", "yellow", "red"]
+    
+    # Create figure
+    fig = go.Figure(go.Indicator(
+        mode="gauge+number",
+        value=value,
+        domain={'x': [0, 1], 'y': [0, 1]},
+        title={'text': title},
+        gauge={
+            'axis': {'range': [min_val, max_val]},
+            'bar': {'color': "darkblue"},
+            'steps': [
+                {'range': [threshold_values[i], threshold_values[i+1]], 'color': threshold_colors[i]} 
+                for i in range(len(threshold_values)-1)
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': value
+            }
+        }
+    ))
+    
+    # Update layout
+    fig.update_layout(
+        height=300,
+        paper_bgcolor='rgba(0,0,0,0)',
+        plot_bgcolor='rgba(0,0,0,0)'
+    )
+    
+    return fig
+
+
+def create_enhanced_results_visualization(results):
+    """
+    Create enhanced visualizations for HVAC load calculation results.
+    
+    Args:
+        results (dict): Dictionary containing calculation results
+        
+    Returns:
+        dict: Dictionary of plotly figures
+    """
+    figures = {}
+    
+    # Prepare data for load breakdown pie chart
+    load_components = {
+        'Walls': results.get('wall_loss', 0),
+        'Roof': results.get('roof_loss', 0),
+        'Floor': results.get('floor_loss', 0),
+        'Windows & Doors': results.get('window_loss', 0),
+        'Infiltration': results.get('infiltration_loss', 0),
+        'Ventilation': results.get('ventilation_loss', 0) - results.get('infiltration_loss', 0)
+    }
+    
+    # Create load breakdown pie chart
+    figures['load_breakdown'] = create_load_breakdown_chart(
+        load_components, 
+        title="Heating Load Components"
+    )
+    
+    # Create energy flow Sankey diagram
+    if 'internal_gain' in results and results['internal_gain'] > 0:
+        # Create nodes and links for Sankey diagram
+        nodes = [
+            "Walls", "Roof", "Floor", "Windows & Doors", 
+            "Infiltration", "Ventilation", "Internal Gains", 
+            "Total Heat Loss", "Net Heating Load"
+        ]
+        
+        links = {
+            'source': [0, 1, 2, 3, 4, 5, 7, 6],
+            'target': [7, 7, 7, 7, 7, 7, 8, 8],
+            'value': [
+                load_components['Walls'],
+                load_components['Roof'],
+                load_components['Floor'],
+                load_components['Windows & Doors'],
+                load_components['Infiltration'],
+                load_components['Ventilation'],
+                results['internal_gain'],
+                results['total_heat_loss']
+            ]
+        }
+        
+        figures['energy_flow'] = create_sankey_diagram(
+            nodes, 
+            links, 
+            title="Heating Energy Flow"
+        )
+    
+    # Create gauge chart for heating load per area
+    if 'net_heating_load' in results and 'building_info' in results:
+        floor_area = results['building_info'].get('floor_area', 80.0)
+        heating_load_per_area = results['net_heating_load'] / floor_area
+        
+        figures['load_per_area_gauge'] = create_gauge_chart(
+            heating_load_per_area,
+            0,
+            200,
+            title="Heating Load per Area (W/m²)",
+            threshold_values=[0, 50, 100, 150, 200],
+            threshold_colors=["green", "lightgreen", "yellow", "orange", "red"]
+        )
+    
+    return figures