Upload 14 files

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[theme]
+primaryColor = "#1E88E5"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F0F2F6"
+textColor = "#262730"
+font = "sans serif"

README.md

@@ -1,13 +1,66 @@
 ---
-title: HVAC
-emoji: 🏃
-colorFrom: red
-colorTo: purple
+title: HVAC Load Calculator
+emoji: 🔥❄️
+colorFrom: blue
+colorTo: indigo
 sdk: streamlit
-sdk_version: 1.43.2
+sdk_version: 1.32.0
 app_file: app.py
 pinned: false
-short_description: HVAC tool
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# HVAC Load Calculator
+
+A modern web tool for calculating HVAC cooling and heating loads based on the ASHRAE method.
+
+## Features
+
+- **Separate Calculators**: Independent cooling and heating load calculators
+- **Step-by-Step Input Forms**: Guided process with validation
+- **Reference Data**: Comprehensive material properties and location data
+- **Visual Results**: Charts and tables for load components
+- **Smart Validation**: Proceed with warnings rather than blocking progress
+- **Downloadable Data**: Export results for student assignments
+- **ASHRAE Method**: Implementation based on industry-standard calculation methods
+- **Extensible Design**: Framework for adding other calculation methods or locations
+
+## How to Use
+
+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
+
+## Cooling Load Calculator
+
+The cooling load calculator helps determine the amount of heat that needs to be removed from a space to maintain comfort conditions. It accounts for:
+
+- Conduction through building envelope
+- Solar radiation through windows
+- Internal heat gains (people, equipment, lighting)
+- Infiltration and ventilation
+
+## Heating Load Calculator
+
+The heating load calculator helps determine the amount of heat that needs to be added to a space to maintain comfort conditions. It accounts for:
+
+- Conduction through building envelope
+- Infiltration and ventilation
+- Annual heating energy requirements based on heating degree days
+
+## Technical Details
+
+- Built with Python and Streamlit
+- Modular design for extensibility
+- Comprehensive reference data based on ASHRAE standards
+- Visualization using Plotly
+- Data export in CSV and JSON formats
+
+## Educational Purpose
+
+This tool is designed for educational purposes to help students understand the factors that influence HVAC load calculations. It provides a practical way to apply theoretical knowledge and see how different building parameters affect heating and cooling requirements.
+
+## Acknowledgements
+
+Based on ASHRAE calculation methods for heating and cooling loads.

app.py

@@ -0,0 +1,160 @@
+"""
+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
+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"
+)
+
+# Define main function
+def main():
+    """Main function for the HVAC Load Calculator web application."""
+    
+    # Add custom CSS
+    st.markdown("""
+    <style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #1E88E5;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .sub-header {
+        font-size: 1.5rem;
+        color: #424242;
+        margin-bottom: 1rem;
+    }
+    .info-box {
+        background-color: #E3F2FD;
+        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)
+    
+    # Navigation options
+    page = st.sidebar.radio(
+        "Select Calculator",
+        ["Home", "Cooling Load Calculator", "Heating Load Calculator"]
+    )
+    
+    # Display selected page
+    if page == "Home":
+        display_home_page()
+    elif page == "Cooling Load Calculator":
+        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()
+
+
+# Run the application
+if __name__ == "__main__":
+    main()

application_design.md

@@ -0,0 +1,153 @@
+# HVAC Load Calculator Web Application Design
+
+## Overview
+This document outlines the structure and user flow for the HVAC Load Calculator web application. The application will be built using Python and deployed on Hugging Face Spaces, providing a user-friendly interface for calculating cooling and heating loads based on the ASHRAE method.
+
+## Application Structure
+
+### 1. Core Components
+- **Backend Calculation Modules**
+  - `cooling_load.py`: Implements ASHRAE cooling load calculations
+  - `heating_load.py`: Implements ASHRAE heating load calculations
+  - `reference_data.py`: Contains material properties, climate data, and other reference information
+
+- **Web Interface**
+  - `app.py`: Main Streamlit application entry point
+  - `pages/`: Directory containing individual calculator pages
+    - `cooling_calculator.py`: Cooling load calculator interface
+    - `heating_calculator.py`: Heating load calculator interface
+    - `about.py`: Information about the application and calculation methods
+  
+- **Utilities**
+  - `utils/`: Directory containing utility functions
+    - `validation.py`: Input validation functions
+    - `visualization.py`: Chart and table generation functions
+    - `export.py`: Data export functionality
+
+### 2. Data Flow
+```
+User Input → Validation → Calculation → Results Visualization → Data Export
+```
+
+## User Flow
+
+### Home Page
+- Introduction to the application
+- Selection between cooling and heating load calculators
+- Information about ASHRAE calculation methods
+- Links to reference materials
+
+### Cooling Load Calculator
+1. **Building Information**
+   - Building location
+   - Indoor and outdoor design temperatures
+   - Building dimensions and volume
+
+2. **Building Envelope**
+   - Wall areas and construction types
+   - Roof/ceiling areas and construction types
+   - Floor areas and construction types
+
+3. **Windows and Doors**
+   - Window areas by orientation
+   - Glass types and shading information
+   - Door areas and types
+
+4. **Internal Loads**
+   - Number of occupants
+   - Lighting information
+   - Equipment and appliances
+
+5. **Ventilation and Infiltration**
+   - Air changes per hour
+   - Ventilation requirements
+
+6. **Results**
+   - Breakdown of cooling loads by component
+   - Total sensible and latent cooling loads
+   - Visualizations (charts and tables)
+   - Equipment sizing recommendations
+   - Option to download input and result data
+
+### Heating Load Calculator
+1. **Building Information**
+   - Building location
+   - Indoor and outdoor design temperatures
+   - Building dimensions and volume
+
+2. **Building Envelope**
+   - Wall areas and construction types
+   - Roof/ceiling areas and construction types
+   - Floor areas and construction types
+
+3. **Windows and Doors**
+   - Window areas by orientation
+   - Glass types
+   - Door areas and types
+
+4. **Ventilation and Infiltration**
+   - Air changes per hour
+   - Ventilation requirements
+
+5. **Occupancy Information**
+   - Occupancy type and schedule
+   - Heating degree days information
+
+6. **Results**
+   - Breakdown of heating loads by component
+   - Total peak heating load
+   - Annual heating energy requirement
+   - Visualizations (charts and tables)
+   - Equipment sizing recommendations
+   - Option to download input and result data
+
+## User Interface Design
+
+### General Principles
+- Clean, modern interface with clear navigation
+- Step-by-step input forms with progress indicators
+- Immediate feedback on inputs with validation warnings
+- Informative tooltips and help text for technical terms
+- Responsive design for different screen sizes
+
+### Input Forms
+- Grouped by logical sections
+- Clear labels and units
+- Default values where appropriate
+- Input validation with warning messages
+- Option to proceed with warnings rather than blocking progress
+- Reference data selection for materials and locations
+
+### Results Display
+- Clear summary of key results
+- Detailed breakdown of load components
+- Visual representations (charts and graphs)
+- Tabular data for detailed analysis
+- Equipment sizing recommendations
+- Export options for reports and assignments
+
+## Validation System
+- Input validation for required fields
+- Range checking for numerical inputs
+- Logical validation between related inputs
+- Warning system that allows proceeding with caution
+- Clear error messages with suggestions for correction
+
+## Data Export Functionality
+- Export input data in JSON format
+- Export results in CSV format
+- Generate PDF reports with inputs and results
+- Save charts and visualizations as images
+
+## Extensibility Features
+- Modular code structure for easy addition of new calculation methods
+- Configuration-based reference data for easy updates
+- Pluggable visualization components
+- Separation of UI and calculation logic
+
+## Technology Stack
+- **Backend**: Python
+- **Web Framework**: Streamlit
+- **Data Processing**: Pandas, NumPy
+- **Visualization**: Plotly, Matplotlib
+- **Deployment**: Hugging Face Spaces

calculation_methods.py

@@ -0,0 +1,446 @@
+"""
+Calculation Method Interface for HVAC Load Calculator
+
+This module defines the interface for calculation methods in the HVAC Load Calculator.
+It provides a base class that all calculation methods should inherit from.
+"""
+
+from abc import ABC, abstractmethod
+
+
+class CalculationMethod(ABC):
+    """
+    Abstract base class for HVAC load calculation methods.
+    
+    All calculation methods should inherit from this class and implement
+    the required methods.
+    """
+    
+    @property
+    @abstractmethod
+    def name(self):
+        """
+        Get the name of the calculation method.
+        
+        Returns:
+            str: Name of the calculation method
+        """
+        pass
+    
+    @property
+    @abstractmethod
+    def description(self):
+        """
+        Get the description of the calculation method.
+        
+        Returns:
+            str: Description of the calculation method
+        """
+        pass
+    
+    @property
+    @abstractmethod
+    def version(self):
+        """
+        Get the version of the calculation method.
+        
+        Returns:
+            str: Version of the calculation method
+        """
+        pass
+    
+    @abstractmethod
+    def calculate(self, input_data):
+        """
+        Perform the calculation.
+        
+        Args:
+            input_data (dict): Input data for the calculation
+            
+        Returns:
+            dict: Calculation results
+        """
+        pass
+    
+    @abstractmethod
+    def get_input_schema(self):
+        """
+        Get the input schema for the calculation method.
+        
+        Returns:
+            dict: JSON schema for input validation
+        """
+        pass
+    
+    @abstractmethod
+    def get_output_schema(self):
+        """
+        Get the output schema for the calculation method.
+        
+        Returns:
+            dict: JSON schema for output validation
+        """
+        pass
+
+
+class ASHRAECoolingMethod(CalculationMethod):
+    """
+    ASHRAE method for cooling load calculation.
+    """
+    
+    @property
+    def name(self):
+        return "ASHRAE Cooling Load Method"
+    
+    @property
+    def description(self):
+        return "Calculates cooling loads using the ASHRAE method for residential buildings."
+    
+    @property
+    def version(self):
+        return "1.0"
+    
+    def calculate(self, input_data):
+        """
+        Calculate cooling load using the ASHRAE method.
+        
+        Args:
+            input_data (dict): Input data for the calculation
+            
+        Returns:
+            dict: Calculation results
+        """
+        from cooling_load import CoolingLoadCalculator
+        
+        calculator = CoolingLoadCalculator()
+        
+        # Extract input data
+        building_components = input_data.get('building_components', [])
+        windows = input_data.get('windows', [])
+        infiltration = input_data.get('infiltration', {})
+        internal_gains = input_data.get('internal_gains', {})
+        
+        # Perform calculation
+        results = calculator.calculate_total_cooling_load(
+            building_components=building_components,
+            windows=windows,
+            infiltration=infiltration,
+            internal_gains=internal_gains
+        )
+        
+        return results
+    
+    def get_input_schema(self):
+        """
+        Get the input schema for the ASHRAE cooling load method.
+        
+        Returns:
+            dict: JSON schema for input validation
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "building_components": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "area": {"type": "number", "minimum": 0},
+                            "u_value": {"type": "number", "minimum": 0},
+                            "temp_diff": {"type": "number"}
+                        },
+                        "required": ["area", "u_value", "temp_diff"]
+                    }
+                },
+                "windows": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "area": {"type": "number", "minimum": 0},
+                            "u_value": {"type": "number", "minimum": 0},
+                            "orientation": {"type": "string", "enum": ["north", "east", "south", "west", "horizontal"]},
+                            "glass_type": {"type": "string"},
+                            "shading": {"type": "string"},
+                            "shade_factor": {"type": "number", "minimum": 0, "maximum": 1},
+                            "temp_diff": {"type": "number"}
+                        },
+                        "required": ["area", "u_value", "orientation", "temp_diff"]
+                    }
+                },
+                "infiltration": {
+                    "type": "object",
+                    "properties": {
+                        "volume": {"type": "number", "minimum": 0},
+                        "air_changes": {"type": "number", "minimum": 0},
+                        "temp_diff": {"type": "number"}
+                    },
+                    "required": ["volume", "air_changes", "temp_diff"]
+                },
+                "internal_gains": {
+                    "type": "object",
+                    "properties": {
+                        "num_people": {"type": "integer", "minimum": 0},
+                        "has_kitchen": {"type": "boolean"},
+                        "equipment_watts": {"type": "number", "minimum": 0}
+                    },
+                    "required": ["num_people"]
+                }
+            },
+            "required": ["building_components", "infiltration", "internal_gains"]
+        }
+    
+    def get_output_schema(self):
+        """
+        Get the output schema for the ASHRAE cooling load method.
+        
+        Returns:
+            dict: JSON schema for output validation
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "conduction_gain": {"type": "number"},
+                "window_conduction_gain": {"type": "number"},
+                "window_solar_gain": {"type": "number"},
+                "infiltration_gain": {"type": "number"},
+                "internal_gain": {"type": "number"},
+                "sensible_load": {"type": "number"},
+                "latent_load": {"type": "number"},
+                "total_load": {"type": "number"}
+            },
+            "required": ["sensible_load", "latent_load", "total_load"]
+        }
+
+
+class ASHRAEHeatingMethod(CalculationMethod):
+    """
+    ASHRAE method for heating load calculation.
+    """
+    
+    @property
+    def name(self):
+        return "ASHRAE Heating Load Method"
+    
+    @property
+    def description(self):
+        return "Calculates heating loads using the ASHRAE method for residential buildings."
+    
+    @property
+    def version(self):
+        return "1.0"
+    
+    def calculate(self, input_data):
+        """
+        Calculate heating load using the ASHRAE method.
+        
+        Args:
+            input_data (dict): Input data for the calculation
+            
+        Returns:
+            dict: Calculation results
+        """
+        from heating_load import HeatingLoadCalculator
+        
+        calculator = HeatingLoadCalculator()
+        
+        # Extract input data
+        building_components = input_data.get('building_components', [])
+        infiltration = input_data.get('infiltration', {})
+        
+        # Perform calculation
+        results = calculator.calculate_total_heating_load(
+            building_components=building_components,
+            infiltration=infiltration
+        )
+        
+        # Calculate annual heating requirement if location and occupancy data are provided
+        if 'location' in input_data and 'occupancy_type' in input_data:
+            location = input_data.get('location')
+            occupancy_type = input_data.get('occupancy_type')
+            base_temp = input_data.get('base_temp', 18)
+            
+            annual_results = calculator.calculate_annual_heating_requirement(
+                results['total_load'],
+                location,
+                occupancy_type,
+                base_temp
+            )
+            
+            # Combine results
+            results.update(annual_results)
+        
+        return results
+    
+    def get_input_schema(self):
+        """
+        Get the input schema for the ASHRAE heating load method.
+        
+        Returns:
+            dict: JSON schema for input validation
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "building_components": {
+                    "type": "array",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "name": {"type": "string"},
+                            "area": {"type": "number", "minimum": 0},
+                            "u_value": {"type": "number", "minimum": 0},
+                            "temp_diff": {"type": "number", "minimum": 0}
+                        },
+                        "required": ["area", "u_value", "temp_diff"]
+                    }
+                },
+                "infiltration": {
+                    "type": "object",
+                    "properties": {
+                        "volume": {"type": "number", "minimum": 0},
+                        "air_changes": {"type": "number", "minimum": 0},
+                        "temp_diff": {"type": "number", "minimum": 0}
+                    },
+                    "required": ["volume", "air_changes", "temp_diff"]
+                },
+                "location": {"type": "string"},
+                "occupancy_type": {"type": "string"},
+                "base_temp": {"type": "number"}
+            },
+            "required": ["building_components", "infiltration"]
+        }
+    
+    def get_output_schema(self):
+        """
+        Get the output schema for the ASHRAE heating load method.
+        
+        Returns:
+            dict: JSON schema for output validation
+        """
+        return {
+            "type": "object",
+            "properties": {
+                "component_losses": {
+                    "type": "object",
+                    "additionalProperties": {"type": "number"}
+                },
+                "total_conduction_loss": {"type": "number"},
+                "infiltration_loss": {"type": "number"},
+                "total_load": {"type": "number"},
+                "heating_degree_days": {"type": "number"},
+                "correction_factor": {"type": "number"},
+                "annual_energy_kwh": {"type": "number"},
+                "annual_energy_mj": {"type": "number"}
+            },
+            "required": ["total_load"]
+        }
+
+
+class CalculationMethodRegistry:
+    """
+    Registry for calculation methods.
+    
+    This class maintains a registry of available calculation methods
+    and provides methods to access them.
+    """
+    
+    def __init__(self):
+        """Initialize the registry."""
+        self._methods = {}
+    
+    def register_method(self, method_id, method_class):
+        """
+        Register a calculation method.
+        
+        Args:
+            method_id (str): Unique identifier for the method
+            method_class (type): Class implementing the CalculationMethod interface
+            
+        Returns:
+            bool: True if registration was successful, False otherwise
+        """
+        if method_id in self._methods:
+            return False
+        
+        if not issubclass(method_class, CalculationMethod):
+            return False
+        
+        self._methods[method_id] = method_class
+        return True
+    
+    def get_method(self, method_id):
+        """
+        Get a calculation method by ID.
+        
+        Args:
+            method_id (str): Unique identifier for the method
+            
+        Returns:
+            CalculationMethod: Instance of the calculation method, or None if not found
+        """
+        if method_id not in self._methods:
+            return None
+        
+        return self._methods[method_id]()
+    
+    def get_available_methods(self):
+        """
+        Get a list of available calculation methods.
+        
+        Returns:
+            list: List of dictionaries with method information
+        """
+        methods = []
+        for method_id, method_class in self._methods.items():
+            method = method_class()
+            methods.append({
+                'id': method_id,
+                'name': method.name,
+                'description': method.description,
+                'version': method.version
+            })
+        
+        return methods
+
+
+# Create a global registry instance
+registry = CalculationMethodRegistry()
+
+# Register the built-in calculation methods
+registry.register_method('ashrae_cooling', ASHRAECoolingMethod)
+registry.register_method('ashrae_heating', ASHRAEHeatingMethod)
+
+
+# Example of how to add a new calculation method
+"""
+class CustomCoolingMethod(CalculationMethod):
+    @property
+    def name(self):
+        return "Custom Cooling Method"
+    
+    @property
+    def description(self):
+        return "A custom method for calculating cooling loads."
+    
+    @property
+    def version(self):
+        return "1.0"
+    
+    def calculate(self, input_data):
+        # Custom calculation logic
+        pass
+    
+    def get_input_schema(self):
+        # Custom input schema
+        pass
+    
+    def get_output_schema(self):
+        # Custom output schema
+        pass
+
+# Register the custom method
+registry.register_method('custom_cooling', CustomCoolingMethod)
+"""

cooling_load.py

@@ -0,0 +1,237 @@
+"""
+ASHRAE Cooling Load Calculation Module
+
+This module implements the ASHRAE method for calculating cooling loads in residential buildings.
+It calculates the sensible cooling load and then applies a factor of 1.3 to account for latent load.
+"""
+
+import numpy as np
+import pandas as pd
+
+
+class CoolingLoadCalculator:
+    """
+    A class to calculate cooling loads using the ASHRAE method.
+    """
+
+    def __init__(self):
+        """Initialize the cooling load calculator with default values."""
+        # Default values for internal heat gains (W)
+        self.heat_gain_per_person = 75
+        self.heat_gain_kitchen = 1000
+        
+        # Specific heat capacity of air × density of air
+        self.air_heat_factor = 0.33
+
+    def calculate_conduction_heat_gain(self, area, u_value, temp_diff):
+        """
+        Calculate conduction heat gain through building components.
+        
+        Args:
+            area (float): Area of the building component in m²
+            u_value (float): U-value of the component in W/m²°C
+            temp_diff (float): Temperature difference (outside - inside) in °C
+            
+        Returns:
+            float: Heat gain in Watts
+        """
+        return area * u_value * temp_diff
+
+    def calculate_solar_heat_gain(self, area, shgf, shade_factor=1.0):
+        """
+        Calculate solar heat gain through glazing.
+        
+        Args:
+            area (float): Area of the glazing in m²
+            shgf (float): Solar Heat Gain Factor based on orientation and climate
+            shade_factor (float): Factor to account for shading (1.0 = no shade, 0.0 = full shade)
+            
+        Returns:
+            float: Heat gain in Watts
+        """
+        return area * shgf * shade_factor
+
+    def calculate_infiltration_heat_gain(self, volume, air_changes, temp_diff):
+        """
+        Calculate heat gain due to infiltration and ventilation.
+        
+        Args:
+            volume (float): Volume of the space in m³
+            air_changes (float): Number of air changes per hour
+            temp_diff (float): Temperature difference (outside - inside) in °C
+            
+        Returns:
+            float: Heat gain in Watts
+        """
+        return self.air_heat_factor * volume * air_changes * temp_diff
+
+    def calculate_internal_heat_gain(self, num_people, has_kitchen=False, equipment_watts=0):
+        """
+        Calculate internal heat gain from people, kitchen, and equipment.
+        
+        Args:
+            num_people (int): Number of occupants
+            has_kitchen (bool): Whether the space includes a kitchen
+            equipment_watts (float): Additional equipment heat gain in Watts
+            
+        Returns:
+            float: Heat gain in Watts
+        """
+        people_gain = num_people * self.heat_gain_per_person
+        kitchen_gain = self.heat_gain_kitchen if has_kitchen else 0
+        return people_gain + kitchen_gain + equipment_watts
+
+    def get_solar_heat_gain_factor(self, orientation, glass_type, daily_range, latitude='medium'):
+        """
+        Get the Solar Heat Gain Factor based on orientation, glass type, and climate.
+        
+        Args:
+            orientation (str): Window orientation ('north', 'east', 'south', 'west')
+            glass_type (str): Type of glass ('single', 'double', 'low_e')
+            daily_range (str): Daily temperature range ('low', 'medium', 'high')
+            latitude (str): Latitude category ('low', 'medium', 'high')
+            
+        Returns:
+            float: Solar Heat Gain Factor in W/m²
+        """
+        # This is a simplified version - in a real implementation, this would use lookup tables
+        # based on the ASHRAE data
+        
+        # Base values for single glass at medium latitude
+        base_values = {
+            'north': 200,
+            'east': 550,
+            'south': 350,
+            'west': 550,
+            'horizontal': 650
+        }
+        
+        # Adjustments for glass type
+        glass_factors = {
+            'single': 1.0,
+            'double': 0.85,
+            'low_e': 0.65
+        }
+        
+        # Adjustments for latitude
+        latitude_factors = {
+            'low': 1.1,    # Closer to equator
+            'medium': 1.0,  # Mid latitudes
+            'high': 0.9     # Closer to poles
+        }
+        
+        # Adjustments for daily temperature range
+        range_factors = {
+            'low': 0.95,    # Less than 8.5°C
+            'medium': 1.0,  # Between 8.5°C and 14°C
+            'high': 1.05    # Over 14°C
+        }
+        
+        # Calculate the adjusted SHGF
+        base_value = base_values.get(orientation.lower(), 350)  # Default to south if not found
+        glass_factor = glass_factors.get(glass_type.lower(), 1.0)
+        latitude_factor = latitude_factors.get(latitude.lower(), 1.0)
+        range_factor = range_factors.get(daily_range.lower(), 1.0)
+        
+        return base_value * glass_factor * latitude_factor * range_factor
+
+    def calculate_total_cooling_load(self, building_components, windows, infiltration, internal_gains):
+        """
+        Calculate the total cooling load including latent load.
+        
+        Args:
+            building_components (list): List of dicts with 'area', 'u_value', and 'temp_diff' for each component
+            windows (list): List of dicts with 'area', 'orientation', 'glass_type', 'shading', etc.
+            infiltration (dict): Dict with 'volume', 'air_changes', and 'temp_diff'
+            internal_gains (dict): Dict with 'num_people', 'has_kitchen', and 'equipment_watts'
+            
+        Returns:
+            dict: Dictionary with sensible load, latent load, and total cooling load in Watts
+        """
+        # Calculate conduction heat gain through building components
+        conduction_gain = sum(
+            self.calculate_conduction_heat_gain(comp['area'], comp['u_value'], comp['temp_diff'])
+            for comp in building_components
+        )
+        
+        # Calculate solar and conduction heat gain through windows
+        window_conduction_gain = 0
+        window_solar_gain = 0
+        
+        for window in windows:
+            # Conduction through glass
+            window_conduction_gain += self.calculate_conduction_heat_gain(
+                window['area'], window['u_value'], window['temp_diff']
+            )
+            
+            # Solar radiation through glass
+            shgf = self.get_solar_heat_gain_factor(
+                window['orientation'], 
+                window['glass_type'],
+                window.get('daily_range', 'medium'),
+                window.get('latitude', 'medium')
+            )
+            
+            shading_value = window.get('shading', 0.0)
+            if shading_value == 'none' or shading_value == '':
+                shading_value = 0.0
+            shade_factor = 1.0 - float(shading_value)
+            window_solar_gain += self.calculate_solar_heat_gain(window['area'], shgf, shade_factor)
+        
+        # Calculate infiltration heat gain
+        infiltration_gain = self.calculate_infiltration_heat_gain(
+            infiltration['volume'], infiltration['air_changes'], infiltration['temp_diff']
+        )
+        
+        # Calculate internal heat gain
+        internal_gain = self.calculate_internal_heat_gain(
+            internal_gains['num_people'],
+            internal_gains.get('has_kitchen', False),
+            internal_gains.get('equipment_watts', 0)
+        )
+        
+        # Calculate sensible cooling load
+        sensible_load = conduction_gain + window_conduction_gain + window_solar_gain + infiltration_gain + internal_gain
+        
+        # Calculate total cooling load (including latent load)
+        latent_load = sensible_load * 0.3  # 30% of sensible load for latent load
+        total_load = sensible_load * 1.3   # Factor of 1.3 to account for latent load
+        
+        return {
+            'conduction_gain': conduction_gain,
+            'window_conduction_gain': window_conduction_gain,
+            'window_solar_gain': window_solar_gain,
+            'infiltration_gain': infiltration_gain,
+            'internal_gain': internal_gain,
+            'sensible_load': sensible_load,
+            'latent_load': latent_load,
+            'total_load': total_load
+        }
+
+
+# Example usage
+if __name__ == "__main__":
+    calculator = CoolingLoadCalculator()
+    
+    # Example data for a simple room
+    building_components = [
+        {'area': 20, 'u_value': 0.6, 'temp_diff': 11},  # Floor
+        {'area': 50, 'u_value': 1.88, 'temp_diff': 11},  # Walls
+        {'area': 20, 'u_value': 0.46, 'temp_diff': 11}   # Ceiling
+    ]
+    
+    windows = [
+        {'area': 4, 'orientation': 'north', 'glass_type': 'single', 'u_value': 5.8, 'temp_diff': 11, 'shading': 0.5},
+        {'area': 4, 'orientation': 'east', 'glass_type': 'single', 'u_value': 5.8, 'temp_diff': 11, 'shading': 0.0},
+        {'area': 4, 'orientation': 'west', 'glass_type': 'single', 'u_value': 5.8, 'temp_diff': 11, 'shading': 0.0}
+    ]
+    
+    infiltration = {'volume': 60, 'air_changes': 0.5, 'temp_diff': 11}
+    
+    internal_gains = {'num_people': 4, 'has_kitchen': True, 'equipment_watts': 500}
+    
+    result = calculator.calculate_total_cooling_load(building_components, windows, infiltration, internal_gains)
+    
+    print("Cooling Load Calculation Results:")
+    for key, value in result.items():
+        print(f"{key}: {value:.2f} W")

heating_load.py

@@ -0,0 +1,246 @@
+"""
+ASHRAE Heating Load Calculation Module
+
+This module implements the ASHRAE method for calculating heating loads in residential buildings.
+It calculates the heat loss from the building envelope and unwanted ventilation/infiltration.
+"""
+
+import numpy as np
+import pandas as pd
+
+
+class HeatingLoadCalculator:
+    """
+    A class to calculate heating loads using the ASHRAE method.
+    """
+
+    def __init__(self):
+        """Initialize the heating load calculator with default values."""
+        # Specific heat capacity of air × density of air
+        self.air_heat_factor = 0.33
+
+    def calculate_conduction_heat_loss(self, area, u_value, temp_diff):
+        """
+        Calculate conduction heat loss through building components.
+        
+        Args:
+            area (float): Area of the building component in m²
+            u_value (float): U-value of the component in W/m²°C
+            temp_diff (float): Temperature difference (inside - outside) in °C
+            
+        Returns:
+            float: Heat loss in Watts
+        """
+        return area * u_value * temp_diff
+
+    def calculate_infiltration_heat_loss(self, volume, air_changes, temp_diff):
+        """
+        Calculate heat loss due to infiltration and ventilation.
+        
+        Args:
+            volume (float): Volume of the space in m³
+            air_changes (float): Number of air changes per hour
+            temp_diff (float): Temperature difference (inside - outside) in °C
+            
+        Returns:
+            float: Heat loss in Watts
+        """
+        return self.air_heat_factor * volume * air_changes * temp_diff
+
+    def calculate_annual_heating_energy(self, total_heat_loss, heating_degree_days, correction_factor=1.0):
+        """
+        Calculate annual heating energy requirement using heating degree days.
+        
+        Args:
+            total_heat_loss (float): Total heat loss in Watts
+            heating_degree_days (float): Number of heating degree days
+            correction_factor (float): Correction factor for occupancy
+            
+        Returns:
+            float: Annual heating energy in kWh
+        """
+        # Convert W to kW
+        heat_loss_kw = total_heat_loss / 1000
+        
+        # Calculate annual heating energy (kWh)
+        # 24 hours in a day
+        annual_energy = heat_loss_kw * 24 * heating_degree_days * correction_factor
+        
+        return annual_energy
+
+    def get_outdoor_design_temperature(self, location):
+        """
+        Get the outdoor design temperature for a location.
+        
+        Args:
+            location (str): Location name
+            
+        Returns:
+            float: Outdoor design temperature in °C
+        """
+        # This is a simplified version - in a real implementation, this would use lookup tables
+        # based on the AIRAH Design Data Manual
+        
+        # Example data for Australian locations
+        temperatures = {
+            'sydney': 7.0,
+            'melbourne': 4.0,
+            'brisbane': 9.0,
+            'perth': 7.0,
+            'adelaide': 5.0,
+            'hobart': 2.0,
+            'darwin': 15.0,
+            'canberra': -1.0,
+            'mildura': 4.5
+        }
+        
+        return temperatures.get(location.lower(), 5.0)  # Default to 5°C if location not found
+
+    def get_heating_degree_days(self, location, base_temp=18):
+        """
+        Get the heating degree days for a location.
+        
+        Args:
+            location (str): Location name
+            base_temp (int): Base temperature for HDD calculation (default: 18°C)
+            
+        Returns:
+            float: Heating degree days
+        """
+        # This is a simplified version - in a real implementation, this would use lookup tables
+        # or API data from Bureau of Meteorology
+        
+        # Example data for Australian locations with base temperature of 18°C
+        hdd_data = {
+            'sydney': 740,
+            'melbourne': 1400,
+            'brisbane': 320,
+            'perth': 760,
+            'adelaide': 1100,
+            'hobart': 1800,
+            'darwin': 0,
+            'canberra': 2000,
+            'mildura': 1200
+        }
+        
+        return hdd_data.get(location.lower(), 1000)  # Default to 1000 if location not found
+
+    def get_occupancy_correction_factor(self, occupancy_type):
+        """
+        Get the correction factor for occupancy type.
+        
+        Args:
+            occupancy_type (str): Type of occupancy
+            
+        Returns:
+            float: Correction factor
+        """
+        # Correction factors based on occupancy patterns
+        factors = {
+            'continuous': 1.0,      # Continuously heated
+            'intermittent': 0.8,    # Heated during occupied hours
+            'night_setback': 0.9,   # Temperature setback at night
+            'weekend_off': 0.85,    # Heating off during weekends
+            'vacation_home': 0.6    # Occasionally occupied
+        }
+        
+        return factors.get(occupancy_type.lower(), 1.0)  # Default to continuous if not found
+
+    def calculate_total_heating_load(self, building_components, infiltration):
+        """
+        Calculate the total peak heating load.
+        
+        Args:
+            building_components (list): List of dicts with 'area', 'u_value', and 'temp_diff' for each component
+            infiltration (dict): Dict with 'volume', 'air_changes', and 'temp_diff'
+            
+        Returns:
+            dict: Dictionary with component heat losses and total heating load in Watts
+        """
+        # Calculate conduction heat loss through building components
+        component_losses = {}
+        total_conduction_loss = 0
+        
+        for comp in building_components:
+            name = comp.get('name', f"Component {len(component_losses) + 1}")
+            loss = self.calculate_conduction_heat_loss(comp['area'], comp['u_value'], comp['temp_diff'])
+            component_losses[name] = loss
+            total_conduction_loss += loss
+        
+        # Calculate infiltration heat loss
+        infiltration_loss = self.calculate_infiltration_heat_loss(
+            infiltration['volume'], infiltration['air_changes'], infiltration['temp_diff']
+        )
+        
+        # Calculate total heating load
+        total_load = total_conduction_loss + infiltration_loss
+        
+        return {
+            'component_losses': component_losses,
+            'total_conduction_loss': total_conduction_loss,
+            'infiltration_loss': infiltration_loss,
+            'total_load': total_load
+        }
+
+    def calculate_annual_heating_requirement(self, total_load, location, occupancy_type='continuous', base_temp=18):
+        """
+        Calculate the annual heating energy requirement.
+        
+        Args:
+            total_load (float): Total heating load in Watts
+            location (str): Location name
+            occupancy_type (str): Type of occupancy
+            base_temp (int): Base temperature for HDD calculation
+            
+        Returns:
+            dict: Dictionary with annual heating energy in kWh and related factors
+        """
+        # Get heating degree days for the location
+        hdd = self.get_heating_degree_days(location, base_temp)
+        
+        # Get correction factor for occupancy
+        correction_factor = self.get_occupancy_correction_factor(occupancy_type)
+        
+        # Calculate annual heating energy
+        annual_energy = self.calculate_annual_heating_energy(total_load, hdd, correction_factor)
+        
+        return {
+            'heating_degree_days': hdd,
+            'correction_factor': correction_factor,
+            'annual_energy_kwh': annual_energy,
+            'annual_energy_mj': annual_energy * 3.6  # Convert kWh to MJ
+        }
+
+
+# Example usage
+if __name__ == "__main__":
+    calculator = HeatingLoadCalculator()
+    
+    # Example data for a simple room in Mildura
+    building_components = [
+        {'name': 'Floor', 'area': 50, 'u_value': 1.47, 'temp_diff': 16.5},  # Concrete slab
+        {'name': 'Walls', 'area': 80, 'u_value': 1.5, 'temp_diff': 16.5},   # External walls
+        {'name': 'Ceiling', 'area': 50, 'u_value': 0.9, 'temp_diff': 16.5}, # Ceiling
+        {'name': 'Windows', 'area': 8, 'u_value': 5.8, 'temp_diff': 16.5}   # Windows
+    ]
+    
+    infiltration = {'volume': 125, 'air_changes': 0.5, 'temp_diff': 16.5}
+    
+    # Calculate peak heating load
+    result = calculator.calculate_total_heating_load(building_components, infiltration)
+    
+    print("Heating Load Calculation Results:")
+    for key, value in result.items():
+        if key == 'component_losses':
+            print("Component Losses:")
+            for comp, loss in value.items():
+                print(f"  {comp}: {loss:.2f} W")
+        else:
+            print(f"{key}: {value:.2f} W")
+    
+    # Calculate annual heating requirement
+    annual_result = calculator.calculate_annual_heating_requirement(result['total_load'], 'mildura')
+    
+    print("\nAnnual Heating Requirement:")
+    for key, value in annual_result.items():
+        print(f"{key}: {value:.2f}")

pages/cooling_calculator.py

@@ -0,0 +1,1636 @@
+"""
+Cooling Load Calculator Page
+
+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.
+"""
+
+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
+
+
+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
+        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=18.0,
+            max_value=30.0,
+            step=0.5,
+            help="Recommended indoor design temperature for cooling is 24°C"
+        )
+    
+    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"
+        )
+        
+        # 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=25.0,
+            max_value=45.0,
+            step=0.5,
+            help=f"Default value is based on selected location ({location_data['name']})"
+        )
+        
+        # Daily temperature range
+        daily_range_options = {
+            "low": "Low (< 8.5°C)",
+            "medium": "Medium (8.5-14°C)",
+            "high": "High (> 14°C)"
+        }
+        daily_range = st.selectbox(
+            "Daily Temperature Range",
+            options=list(daily_range_options.keys()),
+            format_func=lambda x: daily_range_options[x],
+            index=list(daily_range_options.keys()).index(st.session_state.cooling_form_data['building_info'].get('daily_range', location_data['daily_temp_range'])),
+            help="Daily temperature range affects solar heat gain calculations"
+        )
+    
+    # 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"
+        )
+    
+    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"
+        )
+    
+    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"
+        )
+    
+    # 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,
+        'daily_range': daily_range,
+        '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="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()}
+    
+    # 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, "Unknown"))
+        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 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")
+        wall_material = st.selectbox(
+            "Wall Material",
+            options=list(wall_material_options.keys()),
+            format_func=lambda x: wall_material_options[x],
+            key="new_wall_material"
+        )
+        
+        # Get material properties
+        material_data = ref_data.get_material_by_type("walls", wall_material)
+        u_value = material_data['u_value']
+        
+    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"
+        )
+        
+        st.write(f"Material U-Value: {u_value} W/m²°C")
+        st.write(f"Heat Transfer: {u_value * wall_area * temp_diff:.2f} W")
+    
+    # Add wall button
+    if st.button("Add Wall"):
+        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()}
+    
+    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
+        )
+        
+        # Get material properties
+        material_data = ref_data.get_material_by_type("roofs", roof_material)
+        roof_u_value = material_data['u_value']
+        
+    with col2:
+        roof_area = st.number_input(
+            "Roof Area (m²)",
+            value=float(st.session_state.cooling_form_data['building_envelope'].get('roof', {}).get('area', default_roof_area)),
+            min_value=0.1,
+            step=0.1
+        )
+        
+        st.write(f"Material U-Value: {roof_u_value} W/m²°C")
+        st.write(f"Heat Transfer: {roof_u_value * roof_area * temp_diff:.2f} W")
+    
+    # Save roof data
+    st.session_state.cooling_form_data['building_envelope']['roof'] = {
+        'material_id': roof_material,
+        'area': roof_area,
+        'u_value': roof_u_value,
+        'temp_diff': temp_diff
+    }
+    
+    # Floor section
+    st.write("### Floor")
+    
+    # Get floor material options from reference data
+    floor_material_options = {mat_id: mat_data['name'] for mat_id, mat_data in ref_data.materials['floors'].items()}
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        floor_material = st.selectbox(
+            "Floor Material",
+            options=list(floor_material_options.keys()),
+            format_func=lambda x: floor_material_options[x],
+            index=list(floor_material_options.keys()).index(st.session_state.cooling_form_data['building_envelope'].get('floor', {}).get('material_id', 'concrete_slab_ground')) if st.session_state.cooling_form_data['building_envelope'].get('floor', {}).get('material_id') in floor_material_options else 0
+        )
+        
+        # Get material properties
+        material_data = ref_data.get_material_by_type("floors", floor_material)
+        floor_u_value = material_data['u_value']
+        
+    with col2:
+        floor_area = st.number_input(
+            "Floor Area (m²)",
+            value=float(st.session_state.cooling_form_data['building_envelope'].get('floor', {}).get('area', default_floor_area)),
+            min_value=0.1,
+            step=0.1
+        )
+        
+        st.write(f"Material U-Value: {floor_u_value} W/m²°C")
+        st.write(f"Heat Transfer: {floor_u_value * floor_area * temp_diff:.2f} W")
+    
+    # Save floor data
+    st.session_state.cooling_form_data['building_envelope']['floor'] = {
+        'material_id': floor_material,
+        'area': floor_area,
+        'u_value': floor_u_value,
+        'temp_diff': temp_diff
+    }
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if walls are defined
+    if not st.session_state.cooling_form_data['building_envelope']['walls']:
+        warnings.append(ValidationWarning(
+            "No walls defined",
+            "Add at least one wall to continue",
+            is_critical=True
+        ))
+    
+    # Check if total wall area is reasonable
+    total_wall_area = sum(wall['area'] for wall in st.session_state.cooling_form_data['building_envelope']['walls'])
+    expected_wall_area = 2 * (length + width) * height
+    
+    if total_wall_area < expected_wall_area * 0.8 or total_wall_area > expected_wall_area * 1.2:
+        warnings.append(ValidationWarning(
+            "Unusual wall area",
+            f"Total wall area ({total_wall_area:.2f} m²) differs significantly from the expected area ({expected_wall_area:.2f} m²) based on building dimensions"
+        ))
+    
+    # Check if roof area matches floor area
+    if abs(roof_area - floor_area) > 1.0:
+        warnings.append(ValidationWarning(
+            "Roof area doesn't match floor area",
+            "For a simple building, roof area should approximately match floor area"
+        ))
+    
+    # Save warnings to session state
+    st.session_state.cooling_warnings['building_envelope'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.cooling_completed['building_envelope'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Building Information", key="building_envelope_prev")
+        if prev_button:
+            st.session_state.cooling_active_tab = "building_info"
+            st.experimental_rerun()
+    
+    with col2:
+        next_button = st.button("Next: Windows & Doors →", key="building_envelope_next")
+        if next_button:
+            st.session_state.cooling_active_tab = "windows"
+            st.experimental_rerun()
+
+
+def windows_form(ref_data):
+    """
+    Form for windows and doors information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Windows & Doors")
+    st.write("Enter information about windows and doors.")
+    
+    # Get temperature difference from building info
+    temp_diff = st.session_state.cooling_form_data['building_info'].get('temp_diff', 11.0)
+    daily_range = st.session_state.cooling_form_data['building_info'].get('daily_range', 'medium')
+    
+    # Initialize windows data if not already in session state
+    if 'windows' not in st.session_state.cooling_form_data['windows']:
+        st.session_state.cooling_form_data['windows']['windows'] = []
+    
+    if 'doors' not in st.session_state.cooling_form_data['windows']:
+        st.session_state.cooling_form_data['windows']['doors'] = []
+    
+    # Windows section
+    st.write("### Windows")
+    
+    # Get glass type options from reference data
+    glass_type_options = {glass_id: glass_data['name'] for glass_id, glass_data in ref_data.glass_types.items()}
+    
+    # Get shading options from reference data
+    shading_options = {shade_id: shade_data['name'] for shade_id, shade_data in ref_data.shading_factors.items()}
+    
+    # Display existing window entries
+    if st.session_state.cooling_form_data['windows']['windows']:
+        st.write("Current windows:")
+        windows_df = pd.DataFrame(st.session_state.cooling_form_data['windows']['windows'])
+        windows_df['Glass Type'] = windows_df['glass_type'].map(lambda x: glass_type_options.get(x, "Unknown"))
+        windows_df['Shading'] = windows_df['shading'].map(lambda x: shading_options.get(x, "Unknown"))
+        windows_df = windows_df[['name', 'orientation', 'Glass Type', 'Shading', 'area', 'u_value']]
+        windows_df.columns = ['Name', 'Orientation', 'Glass Type', 'Shading', 'Area (m²)', 'U-Value (W/m²°C)']
+        st.dataframe(windows_df)
+    
+    # Add new window form
+    st.write("Add a new window:")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        window_name = st.text_input("Window Name", value="", key="new_window_name")
+        
+        orientation = st.selectbox(
+            "Orientation",
+            options=["north", "east", "south", "west", "horizontal"],
+            key="new_window_orientation"
+        )
+        
+        glass_type = st.selectbox(
+            "Glass Type",
+            options=list(glass_type_options.keys()),
+            format_func=lambda x: glass_type_options[x],
+            key="new_window_glass_type"
+        )
+        
+        # Get glass properties
+        glass_data = ref_data.get_glass_type(glass_type)
+        window_u_value = glass_data['u_value']
+        
+    with col2:
+        window_area = st.number_input(
+            "Window Area (m²)",
+            value=2.0,
+            min_value=0.1,
+            step=0.1,
+            key="new_window_area"
+        )
+        
+        shading = st.selectbox(
+            "Shading",
+            options=list(shading_options.keys()),
+            format_func=lambda x: shading_options[x],
+            key="new_window_shading"
+        )
+        
+        # Get shading factor
+        shading_data = ref_data.get_shading_factor(shading)
+        shade_factor = shading_data['factor']
+        
+        st.write(f"Glass U-Value: {window_u_value} W/m²°C")
+        st.write(f"Conduction Heat Transfer: {window_u_value * window_area * temp_diff:.2f} W")
+    
+    # Add window button
+    if st.button("Add Window"):
+        # Calculate solar heat gain factor
+        calculator = CoolingLoadCalculator()
+        shgf = calculator.get_solar_heat_gain_factor(
+            orientation=orientation,
+            glass_type=glass_type,
+            daily_range=daily_range
+        )
+        
+        new_window = {
+            'name': window_name if window_name else f"Window {len(st.session_state.cooling_form_data['windows']['windows']) + 1}",
+            'orientation': orientation,
+            'glass_type': glass_type,
+            'shading': shading,
+            'area': window_area,
+            'u_value': window_u_value,
+            'shgf': shgf,
+            'shade_factor': shade_factor,
+            'temp_diff': temp_diff
+        }
+        st.session_state.cooling_form_data['windows']['windows'].append(new_window)
+        st.experimental_rerun()
+    
+    # Doors section
+    st.write("### Doors")
+    
+    # Display existing door entries
+    if st.session_state.cooling_form_data['windows']['doors']:
+        st.write("Current doors:")
+        doors_df = pd.DataFrame(st.session_state.cooling_form_data['windows']['doors'])
+        doors_df = doors_df[['name', 'type', 'area', 'u_value']]
+        doors_df.columns = ['Name', 'Type', 'Area (m²)', 'U-Value (W/m²°C)']
+        st.dataframe(doors_df)
+    
+    # Add new door form
+    st.write("Add a new door:")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        door_name = st.text_input("Door Name", value="", key="new_door_name")
+        
+        door_type = st.selectbox(
+            "Door Type",
+            options=["Solid wood", "Hollow core", "Glass", "Insulated"],
+            key="new_door_type"
+        )
+        
+        # Set U-value based on door type
+        door_u_values = {
+            "Solid wood": 2.0,
+            "Hollow core": 2.5,
+            "Glass": 5.0,
+            "Insulated": 1.2
+        }
+        door_u_value = door_u_values[door_type]
+        
+    with col2:
+        door_area = st.number_input(
+            "Door Area (m²)",
+            value=2.0,
+            min_value=0.1,
+            step=0.1,
+            key="new_door_area"
+        )
+        
+        st.write(f"Door U-Value: {door_u_value} W/m²°C")
+        st.write(f"Heat Transfer: {door_u_value * door_area * temp_diff:.2f} W")
+    
+    # Add door button
+    if st.button("Add Door"):
+        new_door = {
+            'name': door_name if door_name else f"Door {len(st.session_state.cooling_form_data['windows']['doors']) + 1}",
+            'type': door_type,
+            'area': door_area,
+            'u_value': door_u_value,
+            'temp_diff': temp_diff
+        }
+        st.session_state.cooling_form_data['windows']['doors'].append(new_door)
+        st.experimental_rerun()
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if windows are defined
+    if not st.session_state.cooling_form_data['windows']['windows']:
+        warnings.append(ValidationWarning(
+            "No windows defined",
+            "Add at least one window to continue"
+        ))
+    
+    # Check window-to-wall ratio
+    if st.session_state.cooling_form_data['windows']['windows']:
+        total_window_area = sum(window['area'] for window in st.session_state.cooling_form_data['windows']['windows'])
+        total_wall_area = sum(wall['area'] for wall in st.session_state.cooling_form_data['building_envelope']['walls'])
+        window_wall_ratio = total_window_area / total_wall_area if total_wall_area > 0 else 0
+        
+        if window_wall_ratio > 0.6:
+            warnings.append(ValidationWarning(
+                "High window-to-wall ratio",
+                f"Window-to-wall ratio is {window_wall_ratio:.2f}, which is unusually high. Typical ratios are 0.2-0.4."
+            ))
+    
+    # Save warnings to session state
+    st.session_state.cooling_warnings['windows'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.cooling_completed['windows'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Building Envelope", key="windows_prev")
+        if prev_button:
+            st.session_state.cooling_active_tab = "building_envelope"
+            st.experimental_rerun()
+    
+    with col2:
+        next_button = st.button("Next: Internal Loads →", key="windows_next")
+        if next_button:
+            st.session_state.cooling_active_tab = "internal_loads"
+            st.experimental_rerun()
+
+
+def internal_loads_form(ref_data):
+    """
+    Form for internal loads information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Internal Loads")
+    st.write("Enter information about occupants, lighting, and equipment.")
+    
+    # Initialize internal loads data if not already in session state
+    if 'occupants' not in st.session_state.cooling_form_data['internal_loads']:
+        st.session_state.cooling_form_data['internal_loads']['occupants'] = {
+            'count': 4,
+            'activity_level': 'seated_resting'
+        }
+    
+    if 'lighting' not in st.session_state.cooling_form_data['internal_loads']:
+        st.session_state.cooling_form_data['internal_loads']['lighting'] = {
+            'type': 'led',
+            'power_density': 5.0  # W/m²
+        }
+    
+    if 'appliances' not in st.session_state.cooling_form_data['internal_loads']:
+        st.session_state.cooling_form_data['internal_loads']['appliances'] = {
+            'kitchen': True,
+            'living_room': True,
+            'bedroom': True,
+            'office': False
+        }
+    
+    # Occupants section
+    st.write("### Occupants")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        occupant_count = st.number_input(
+            "Number of Occupants",
+            value=int(st.session_state.cooling_form_data['internal_loads']['occupants'].get('count', 4)),
+            min_value=1,
+            step=1
+        )
+    
+    with col2:
+        # Get activity level options from reference data
+        activity_options = {act_id: act_data['name'] for act_id, act_data in ref_data.internal_loads['people'].items()}
+        
+        activity_level = st.selectbox(
+            "Activity Level",
+            options=list(activity_options.keys()),
+            format_func=lambda x: activity_options[x],
+            index=list(activity_options.keys()).index(st.session_state.cooling_form_data['internal_loads']['occupants'].get('activity_level', 'seated_resting')) if st.session_state.cooling_form_data['internal_loads']['occupants'].get('activity_level') in activity_options else 0
+        )
+    
+    # Get heat gain per person
+    activity_data = ref_data.get_internal_load('people', activity_level)
+    sensible_heat_pp = activity_data['sensible_heat']
+    latent_heat_pp = activity_data['latent_heat']
+    total_heat_pp = sensible_heat_pp + latent_heat_pp
+    
+    st.write(f"Heat gain per person: {total_heat_pp} W ({sensible_heat_pp} W sensible + {latent_heat_pp} W latent)")
+    st.write(f"Total occupant heat gain: {total_heat_pp * occupant_count} W")
+    
+    # Save occupants data
+    st.session_state.cooling_form_data['internal_loads']['occupants'] = {
+        'count': occupant_count,
+        'activity_level': activity_level,
+        'sensible_heat_pp': sensible_heat_pp,
+        'latent_heat_pp': latent_heat_pp,
+        'total_heat_gain': total_heat_pp * occupant_count
+    }
+    
+    # Lighting section
+    st.write("### Lighting")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Get lighting type options from reference data
+        lighting_options = {light_id: light_data['name'] for light_id, light_data in ref_data.internal_loads['lighting'].items()}
+        
+        lighting_type = st.selectbox(
+            "Lighting Type",
+            options=list(lighting_options.keys()),
+            format_func=lambda x: lighting_options[x],
+            index=list(lighting_options.keys()).index(st.session_state.cooling_form_data['internal_loads']['lighting'].get('type', 'led')) if st.session_state.cooling_form_data['internal_loads']['lighting'].get('type') in lighting_options else 0
+        )
+    
+    with col2:
+        lighting_power_density = st.number_input(
+            "Lighting Power Density (W/m²)",
+            value=float(st.session_state.cooling_form_data['internal_loads']['lighting'].get('power_density', 5.0)),
+            min_value=1.0,
+            max_value=20.0,
+            step=0.5,
+            help="Typical values: Residential 5-10 W/m², Office 10-15 W/m²"
+        )
+    
+    # Get lighting heat factor
+    lighting_data = ref_data.get_internal_load('lighting', lighting_type)
+    lighting_heat_factor = lighting_data['heat_factor']
+    
+    # Calculate lighting heat gain
+    floor_area = st.session_state.cooling_form_data['building_info'].get('floor_area', 80.0)
+    lighting_heat_gain = lighting_power_density * floor_area * lighting_heat_factor
+    
+    st.write(f"Lighting heat factor: {lighting_heat_factor}")
+    st.write(f"Total lighting heat gain: {lighting_heat_gain:.2f} W")
+    
+    # Save lighting data
+    st.session_state.cooling_form_data['internal_loads']['lighting'] = {
+        'type': lighting_type,
+        'power_density': lighting_power_density,
+        'heat_factor': lighting_heat_factor,
+        'total_heat_gain': lighting_heat_gain
+    }
+    
+    # Appliances section
+    st.write("### Appliances")
+    
+    # Get appliance options from reference data
+    appliance_options = {app_id: app_data for app_id, app_data in ref_data.internal_loads['appliances'].items()}
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        has_kitchen = st.checkbox(
+            "Kitchen Appliances",
+            value=st.session_state.cooling_form_data['internal_loads']['appliances'].get('kitchen', True),
+            help=f"Heat gain: {appliance_options['kitchen']['heat_gain']} W"
+        )
+        
+        has_living_room = st.checkbox(
+            "Living Room Appliances",
+            value=st.session_state.cooling_form_data['internal_loads']['appliances'].get('living_room', True),
+            help=f"Heat gain: {appliance_options['living_room']['heat_gain']} W"
+        )
+    
+    with col2:
+        has_bedroom = st.checkbox(
+            "Bedroom Appliances",
+            value=st.session_state.cooling_form_data['internal_loads']['appliances'].get('bedroom', True),
+            help=f"Heat gain: {appliance_options['bedroom']['heat_gain']} W"
+        )
+        
+        has_office = st.checkbox(
+            "Home Office Equipment",
+            value=st.session_state.cooling_form_data['internal_loads']['appliances'].get('office', False),
+            help=f"Heat gain: {appliance_options['office']['heat_gain']} W"
+        )
+    
+    # Calculate appliance heat gain
+    appliance_heat_gain = 0
+    if has_kitchen:
+        appliance_heat_gain += appliance_options['kitchen']['heat_gain']
+    if has_living_room:
+        appliance_heat_gain += appliance_options['living_room']['heat_gain']
+    if has_bedroom:
+        appliance_heat_gain += appliance_options['bedroom']['heat_gain']
+    if has_office:
+        appliance_heat_gain += appliance_options['office']['heat_gain']
+    
+    st.write(f"Total appliance heat gain: {appliance_heat_gain} W")
+    
+    # Save appliances data
+    st.session_state.cooling_form_data['internal_loads']['appliances'] = {
+        'kitchen': has_kitchen,
+        'living_room': has_living_room,
+        'bedroom': has_bedroom,
+        'office': has_office,
+        'total_heat_gain': appliance_heat_gain
+    }
+    
+    # Calculate total internal heat gain
+    total_internal_gain = (
+        st.session_state.cooling_form_data['internal_loads']['occupants']['total_heat_gain'] +
+        st.session_state.cooling_form_data['internal_loads']['lighting']['total_heat_gain'] +
+        st.session_state.cooling_form_data['internal_loads']['appliances']['total_heat_gain']
+    )
+    
+    st.info(f"Total Internal Heat Gain: {total_internal_gain:.2f} W")
+    
+    # Save total internal gain
+    st.session_state.cooling_form_data['internal_loads']['total_internal_gain'] = total_internal_gain
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if occupant count is reasonable for the floor area
+    floor_area = st.session_state.cooling_form_data['building_info'].get('floor_area', 80.0)
+    area_per_person = floor_area / occupant_count if occupant_count > 0 else float('inf')
+    
+    if area_per_person < 10:
+        warnings.append(ValidationWarning(
+            "High occupant density",
+            f"Area per person ({area_per_person:.2f} m²) is low. Typical residential values are 20-30 m² per person."
+        ))
+    
+    # Check if lighting power density is reasonable
+    if lighting_power_density > 15:
+        warnings.append(ValidationWarning(
+            "High lighting power density",
+            "Lighting power density exceeds 15 W/m², which is high for residential buildings."
+        ))
+    
+    # Save warnings to session state
+    st.session_state.cooling_warnings['internal_loads'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.cooling_completed['internal_loads'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Windows & Doors", key="internal_loads_prev")
+        if prev_button:
+            st.session_state.cooling_active_tab = "windows"
+            st.experimental_rerun()
+    
+    with col2:
+        next_button = st.button("Next: Ventilation →", key="internal_loads_next")
+        if next_button:
+            st.session_state.cooling_active_tab = "ventilation"
+            st.experimental_rerun()
+
+
+def ventilation_form(ref_data):
+    """
+    Form for ventilation and infiltration information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Ventilation & Infiltration")
+    st.write("Enter information about ventilation and infiltration rates.")
+    
+    # Get building info
+    building_info = st.session_state.cooling_form_data['building_info']
+    volume = building_info.get('volume', 216.0)
+    temp_diff = building_info.get('temp_diff', 11.0)
+    
+    # Initialize ventilation data if not already in session state
+    if 'infiltration' not in st.session_state.cooling_form_data['ventilation']:
+        st.session_state.cooling_form_data['ventilation']['infiltration'] = {
+            'air_changes': 0.5
+        }
+    
+    if 'ventilation' not in st.session_state.cooling_form_data['ventilation']:
+        st.session_state.cooling_form_data['ventilation']['ventilation'] = {
+            'type': 'natural',
+            'air_changes': 0.0
+        }
+    
+    # Infiltration section
+    st.write("### Infiltration")
+    st.write("Infiltration is the unintended air leakage through the building envelope.")
+    
+    infiltration_ach = st.slider(
+        "Infiltration Rate (air changes per hour)",
+        value=float(st.session_state.cooling_form_data['ventilation']['infiltration'].get('air_changes', 0.5)),
+        min_value=0.1,
+        max_value=2.0,
+        step=0.1,
+        help="Typical values: 0.5 ACH for modern construction, 1.0 ACH for average construction, 1.5+ ACH for older buildings"
+    )
+    
+    # Calculate infiltration heat gain
+    infiltration_heat_gain = 0.33 * volume * infiltration_ach * temp_diff
+    
+    st.write(f"Infiltration heat gain: {infiltration_heat_gain:.2f} W")
+    
+    # Save infiltration data
+    st.session_state.cooling_form_data['ventilation']['infiltration'] = {
+        'air_changes': infiltration_ach,
+        'volume': volume,
+        'temp_diff': temp_diff,
+        'heat_gain': infiltration_heat_gain
+    }
+    
+    # Ventilation section
+    st.write("### Ventilation")
+    st.write("Ventilation is the intentional introduction of outside air into the building.")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        ventilation_type = st.selectbox(
+            "Ventilation Type",
+            options=["natural", "mechanical", "mixed"],
+            format_func=lambda x: x.capitalize(),
+            index=["natural", "mechanical", "mixed"].index(st.session_state.cooling_form_data['ventilation']['ventilation'].get('type', 'natural'))
+        )
+    
+    with col2:
+        ventilation_ach = st.number_input(
+            "Ventilation Rate (air changes per hour)",
+            value=float(st.session_state.cooling_form_data['ventilation']['ventilation'].get('air_changes', 0.0)),
+            min_value=0.0,
+            max_value=5.0,
+            step=0.1,
+            help="Typical values: 0.35-1.0 ACH for residential buildings"
+        )
+    
+    # Calculate ventilation heat gain
+    ventilation_heat_gain = 0.33 * volume * ventilation_ach * temp_diff
+    
+    st.write(f"Ventilation heat gain: {ventilation_heat_gain:.2f} W")
+    
+    # Save ventilation data
+    st.session_state.cooling_form_data['ventilation']['ventilation'] = {
+        'type': ventilation_type,
+        'air_changes': ventilation_ach,
+        'volume': volume,
+        'temp_diff': temp_diff,
+        'heat_gain': ventilation_heat_gain
+    }
+    
+    # Calculate total ventilation and infiltration heat gain
+    total_ventilation_gain = infiltration_heat_gain + ventilation_heat_gain
+    
+    st.info(f"Total Ventilation & Infiltration Heat Gain: {total_ventilation_gain:.2f} W")
+    
+    # Save total ventilation gain
+    st.session_state.cooling_form_data['ventilation']['total_gain'] = total_ventilation_gain
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if infiltration rate is reasonable
+    if infiltration_ach < 0.3:
+        warnings.append(ValidationWarning(
+            "Low infiltration rate",
+            "Infiltration rate below 0.3 ACH is unusually low for most buildings."
+        ))
+    elif infiltration_ach > 1.5:
+        warnings.append(ValidationWarning(
+            "High infiltration rate",
+            "Infiltration rate above 1.5 ACH indicates a leaky building envelope."
+        ))
+    
+    # Check if ventilation rate is reasonable
+    if ventilation_ach > 0 and ventilation_ach < 0.35:
+        warnings.append(ValidationWarning(
+            "Low ventilation rate",
+            "Ventilation rate below 0.35 ACH may not provide adequate fresh air."
+        ))
+    elif ventilation_ach > 2.0:
+        warnings.append(ValidationWarning(
+            "High ventilation rate",
+            "Ventilation rate above 2.0 ACH is unusually high for residential buildings."
+        ))
+    
+    # Save warnings to session state
+    st.session_state.cooling_warnings['ventilation'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.cooling_completed['ventilation'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Internal Loads", key="ventilation_prev")
+        if prev_button:
+            st.session_state.cooling_active_tab = "internal_loads"
+            st.experimental_rerun()
+    
+    with col2:
+        calculate_button = st.button("Calculate Results →", key="ventilation_calculate")
+        if calculate_button:
+            # Calculate cooling load
+            calculate_cooling_load()
+            st.session_state.cooling_active_tab = "results"
+            st.experimental_rerun()
+
+
+def calculate_cooling_load():
+    """Calculate cooling load based on input data."""
+    # Create calculator instance
+    calculator = CoolingLoadCalculator()
+    
+    # Get form data
+    form_data = st.session_state.cooling_form_data
+    
+    # Prepare building components for calculation
+    building_components = []
+    
+    # Add walls
+    for wall in form_data['building_envelope'].get('walls', []):
+        building_components.append({
+            'name': wall['name'],
+            'area': wall['area'],
+            'u_value': wall['u_value'],
+            'temp_diff': wall['temp_diff']
+        })
+    
+    # Add roof
+    roof = form_data['building_envelope'].get('roof', {})
+    if roof:
+        building_components.append({
+            'name': 'Roof',
+            'area': roof['area'],
+            'u_value': roof['u_value'],
+            'temp_diff': roof['temp_diff']
+        })
+    
+    # Add floor
+    floor = form_data['building_envelope'].get('floor', {})
+    if floor:
+        building_components.append({
+            'name': 'Floor',
+            'area': floor['area'],
+            'u_value': floor['u_value'],
+            'temp_diff': floor['temp_diff']
+        })
+    
+    # Prepare windows for calculation
+    windows = []
+    for window in form_data['windows'].get('windows', []):
+        windows.append({
+            'name': window['name'],
+            'area': window['area'],
+            'u_value': window['u_value'],
+            'orientation': window['orientation'],
+            'glass_type': window['glass_type'],
+            'shading': window['shading'],
+            'shgf': window['shgf'],
+            'shade_factor': 1.0 - window['shade_factor'],
+            'temp_diff': window['temp_diff']
+        })
+    
+    # Add doors to building components
+    for door in form_data['windows'].get('doors', []):
+        building_components.append({
+            'name': door['name'],
+            'area': door['area'],
+            'u_value': door['u_value'],
+            'temp_diff': door['temp_diff']
+        })
+    
+    # Prepare infiltration data
+    infiltration = form_data['ventilation'].get('infiltration', {})
+    ventilation = form_data['ventilation'].get('ventilation', {})
+    
+    infiltration_data = {
+        'volume': infiltration.get('volume', 0),
+        'air_changes': infiltration.get('air_changes', 0) + ventilation.get('air_changes', 0),
+        'temp_diff': infiltration.get('temp_diff', 0)
+    }
+    
+    # Prepare internal gains data
+    internal_gains = {
+        'num_people': form_data['internal_loads'].get('occupants', {}).get('count', 0),
+        'has_kitchen': form_data['internal_loads'].get('appliances', {}).get('kitchen', False),
+        'equipment_watts': (
+            form_data['internal_loads'].get('lighting', {}).get('total_heat_gain', 0) +
+            form_data['internal_loads'].get('appliances', {}).get('total_heat_gain', 0) -
+            (1000 if form_data['internal_loads'].get('appliances', {}).get('kitchen', False) else 0)  # Subtract kitchen heat gain if included
+        )
+    }
+    
+    # Calculate cooling load
+    results = calculator.calculate_total_cooling_load(
+        building_components=building_components,
+        windows=windows,
+        infiltration=infiltration_data,
+        internal_gains=internal_gains
+    )
+    
+    # Save results to session state
+    st.session_state.cooling_results = results
+    
+    # Add timestamp
+    st.session_state.cooling_results['timestamp'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # Add building info
+    st.session_state.cooling_results['building_info'] = form_data['building_info']
+    
+    return results
+
+
+def results_page():
+    """Display calculation results."""
+    st.subheader("Cooling Load Calculation Results")
+    
+    # Check if results are available
+    if not st.session_state.cooling_results:
+        st.warning("No calculation results available. Please complete the input forms and calculate results.")
+        return
+    
+    # Get results
+    results = st.session_state.cooling_results
+    
+    # Display summary
+    st.write("### Summary")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric("Sensible Cooling Load", f"{results['sensible_load']:.2f} W")
+        st.metric("Total Cooling Load", f"{results['total_load']:.2f} W")
+        
+        # Convert to kW
+        total_load_kw = results['total_load'] / 1000
+        st.metric("Total Cooling Load", f"{total_load_kw:.2f} kW")
+    
+    with col2:
+        st.metric("Latent Cooling Load", f"{results['latent_load']:.2f} W")
+        
+        # Calculate cooling load per area
+        floor_area = results['building_info'].get('floor_area', 80.0)
+        cooling_load_per_area = results['total_load'] / floor_area
+        st.metric("Cooling Load per Area", f"{cooling_load_per_area:.2f} W/m²")
+        
+        # Equipment sizing recommendation
+        # Add 10% safety factor
+        recommended_size = total_load_kw * 1.1
+        st.metric("Recommended Equipment Size", f"{recommended_size:.2f} kW")
+    
+    # Display load breakdown
+    st.write("### Load Breakdown")
+    
+    # Prepare data for pie chart
+    load_components = {
+        'Conduction (Opaque Surfaces)': results['conduction_gain'],
+        'Conduction (Windows)': results['window_conduction_gain'],
+        'Solar Radiation (Windows)': results['window_solar_gain'],
+        'Infiltration & Ventilation': results['infiltration_gain'],
+        'Internal Gains': results['internal_gain']
+    }
+    
+    # Create pie chart
+    fig = px.pie(
+        values=list(load_components.values()),
+        names=list(load_components.keys()),
+        title="Cooling Load Components",
+        color_discrete_sequence=px.colors.qualitative.Set2
+    )
+    
+    st.plotly_chart(fig)
+    
+    # Display load components in a table
+    load_df = pd.DataFrame({
+        'Component': list(load_components.keys()),
+        'Load (W)': list(load_components.values()),
+        'Percentage (%)': [value / results['sensible_load'] * 100 for value in load_components.values()]
+    })
+    
+    st.dataframe(load_df.style.format({
+        'Load (W)': '{:.2f}',
+        'Percentage (%)': '{:.2f}'
+    }))
+    
+    # Display detailed results
+    st.write("### Detailed Results")
+    
+    # Create tabs for different result sections
+    tabs = st.tabs([
+        "Building Envelope", 
+        "Windows & Doors", 
+        "Internal Loads", 
+        "Ventilation"
+    ])
+    
+    with tabs[0]:
+        st.subheader("Building Envelope Heat Gains")
+        
+        # Get building components
+        building_components = []
+        
+        # Add walls
+        for wall in st.session_state.cooling_form_data['building_envelope'].get('walls', []):
+            building_components.append({
+                'Component': wall['name'],
+                'Area (m²)': wall['area'],
+                'U-Value (W/m²°C)': wall['u_value'],
+                'Temperature Difference (°C)': wall['temp_diff'],
+                'Heat Gain (W)': wall['area'] * wall['u_value'] * wall['temp_diff']
+            })
+        
+        # Add roof
+        roof = st.session_state.cooling_form_data['building_envelope'].get('roof', {})
+        if roof:
+            building_components.append({
+                'Component': 'Roof',
+                'Area (m²)': roof['area'],
+                'U-Value (W/m²°C)': roof['u_value'],
+                'Temperature Difference (°C)': roof['temp_diff'],
+                'Heat Gain (W)': roof['area'] * roof['u_value'] * roof['temp_diff']
+            })
+        
+        # Add floor
+        floor = st.session_state.cooling_form_data['building_envelope'].get('floor', {})
+        if floor:
+            building_components.append({
+                'Component': 'Floor',
+                'Area (m²)': floor['area'],
+                'U-Value (W/m²°C)': floor['u_value'],
+                'Temperature Difference (°C)': floor['temp_diff'],
+                'Heat Gain (W)': floor['area'] * floor['u_value'] * floor['temp_diff']
+            })
+        
+        # Create dataframe
+        envelope_df = pd.DataFrame(building_components)
+        
+        # Display table
+        st.dataframe(envelope_df.style.format({
+            'Area (m²)': '{:.2f}',
+            'U-Value (W/m²°C)': '{:.2f}',
+            'Temperature Difference (°C)': '{:.2f}',
+            'Heat Gain (W)': '{:.2f}'
+        }))
+        
+        # Create bar chart
+        fig = px.bar(
+            envelope_df,
+            x='Component',
+            y='Heat Gain (W)',
+            title="Heat Gain by Building Component",
+            color='Component',
+            color_discrete_sequence=px.colors.qualitative.Set3
+        )
+        
+        st.plotly_chart(fig)
+    
+    with tabs[1]:
+        st.subheader("Windows & Doors Heat Gains")
+        
+        # Windows section
+        st.write("#### Windows")
+        
+        # Get windows
+        windows_data = []
+        for window in st.session_state.cooling_form_data['windows'].get('windows', []):
+            windows_data.append({
+                'Component': window['name'],
+                'Orientation': window['orientation'].capitalize(),
+                'Area (m²)': window['area'],
+                'U-Value (W/m²°C)': window['u_value'],
+                'Temperature Difference (°C)': window['temp_diff'],
+                'Conduction Heat Gain (W)': window['area'] * window['u_value'] * window['temp_diff'],
+                'Solar Heat Gain Factor (W/m²)': window['shgf'],
+                'Shading Factor': 1.0 - window['shade_factor'],
+                'Solar Heat Gain (W)': window['area'] * window['shgf'] * (1.0 - window['shade_factor']),
+                'Total Heat Gain (W)': (window['area'] * window['u_value'] * window['temp_diff']) + 
+                                      (window['area'] * window['shgf'] * (1.0 - window['shade_factor']))
+            })
+        
+        if windows_data:
+            # Create dataframe
+            windows_df = pd.DataFrame(windows_data)
+            
+            # Display table
+            st.dataframe(windows_df.style.format({
+                'Area (m²)': '{:.2f}',
+                'U-Value (W/m²°C)': '{:.2f}',
+                'Temperature Difference (°C)': '{:.2f}',
+                'Conduction Heat Gain (W)': '{:.2f}',
+                'Solar Heat Gain Factor (W/m²)': '{:.2f}',
+                'Shading Factor': '{:.2f}',
+                'Solar Heat Gain (W)': '{:.2f}',
+                'Total Heat Gain (W)': '{:.2f}'
+            }))
+            
+            # Create grouped bar chart
+            fig = go.Figure()
+            
+            fig.add_trace(go.Bar(
+                x=windows_df['Component'],
+                y=windows_df['Conduction Heat Gain (W)'],
+                name='Conduction Heat Gain',
+                marker_color='indianred'
+            ))
+            
+            fig.add_trace(go.Bar(
+                x=windows_df['Component'],
+                y=windows_df['Solar Heat Gain (W)'],
+                name='Solar Heat Gain',
+                marker_color='lightsalmon'
+            ))
+            
+            fig.update_layout(
+                title="Window Heat Gains",
+                xaxis_title="Window",
+                yaxis_title="Heat Gain (W)",
+                barmode='stack'
+            )
+            
+            st.plotly_chart(fig)
+        else:
+            st.write("No windows defined.")
+        
+        # Doors section
+        st.write("#### Doors")
+        
+        # Get doors
+        doors_data = []
+        for door in st.session_state.cooling_form_data['windows'].get('doors', []):
+            doors_data.append({
+                'Component': door['name'],
+                'Type': door['type'],
+                'Area (m²)': door['area'],
+                'U-Value (W/m²°C)': door['u_value'],
+                'Temperature Difference (°C)': door['temp_diff'],
+                'Heat Gain (W)': door['area'] * door['u_value'] * door['temp_diff']
+            })
+        
+        if doors_data:
+            # Create dataframe
+            doors_df = pd.DataFrame(doors_data)
+            
+            # Display table
+            st.dataframe(doors_df.style.format({
+                'Area (m²)': '{:.2f}',
+                'U-Value (W/m²°C)': '{:.2f}',
+                'Temperature Difference (°C)': '{:.2f}',
+                'Heat Gain (W)': '{:.2f}'
+            }))
+            
+            # Create bar chart
+            fig = px.bar(
+                doors_df,
+                x='Component',
+                y='Heat Gain (W)',
+                title="Door Heat Gains",
+                color='Type',
+                color_discrete_sequence=px.colors.qualitative.Pastel
+            )
+            
+            st.plotly_chart(fig)
+        else:
+            st.write("No doors defined.")
+    
+    with tabs[2]:
+        st.subheader("Internal Heat Gains")
+        
+        # Get internal loads data
+        internal_loads = st.session_state.cooling_form_data['internal_loads']
+        
+        # Create dataframe
+        internal_loads_data = [
+            {
+                'Source': 'Occupants',
+                'Details': f"{internal_loads['occupants']['count']} people",
+                'Heat Gain (W)': internal_loads['occupants']['total_heat_gain']
+            },
+            {
+                'Source': 'Lighting',
+                'Details': f"{internal_loads['lighting']['type']} lighting",
+                'Heat Gain (W)': internal_loads['lighting']['total_heat_gain']
+            },
+            {
+                'Source': 'Appliances',
+                'Details': ', '.join([k for k, v in internal_loads['appliances'].items() if v and k != 'total_heat_gain']),
+                'Heat Gain (W)': internal_loads['appliances']['total_heat_gain']
+            }
+        ]
+        
+        internal_loads_df = pd.DataFrame(internal_loads_data)
+        
+        # Display table
+        st.dataframe(internal_loads_df.style.format({
+            'Heat Gain (W)': '{:.2f}'
+        }))
+        
+        # Create bar chart
+        fig = px.bar(
+            internal_loads_df,
+            x='Source',
+            y='Heat Gain (W)',
+            title="Internal Heat Gains",
+            color='Source',
+            color_discrete_sequence=px.colors.qualitative.Pastel1
+        )
+        
+        st.plotly_chart(fig)
+    
+    with tabs[3]:
+        st.subheader("Ventilation & Infiltration Heat Gains")
+        
+        # Get ventilation data
+        ventilation_data = st.session_state.cooling_form_data['ventilation']
+        
+        # Create dataframe
+        ventilation_df = pd.DataFrame([
+            {
+                'Source': 'Infiltration',
+                'Air Changes per Hour': ventilation_data['infiltration']['air_changes'],
+                'Volume (m³)': ventilation_data['infiltration']['volume'],
+                'Temperature Difference (°C)': ventilation_data['infiltration']['temp_diff'],
+                'Heat Gain (W)': ventilation_data['infiltration']['heat_gain']
+            },
+            {
+                'Source': 'Ventilation',
+                'Air Changes per Hour': ventilation_data['ventilation']['air_changes'],
+                'Volume (m³)': ventilation_data['ventilation']['volume'],
+                'Temperature Difference (°C)': ventilation_data['ventilation']['temp_diff'],
+                'Heat Gain (W)': ventilation_data['ventilation']['heat_gain']
+            }
+        ])
+        
+        # Display table
+        st.dataframe(ventilation_df.style.format({
+            'Air Changes per Hour': '{:.2f}',
+            'Volume (m³)': '{:.2f}',
+            'Temperature Difference (°C)': '{:.2f}',
+            'Heat Gain (W)': '{:.2f}'
+        }))
+        
+        # Create bar chart
+        fig = px.bar(
+            ventilation_df,
+            x='Source',
+            y='Heat Gain (W)',
+            title="Ventilation & Infiltration Heat Gains",
+            color='Source',
+            color_discrete_sequence=px.colors.qualitative.Pastel2
+        )
+        
+        st.plotly_chart(fig)
+    
+    # Export options
+    st.write("### Export Options")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Export Results as CSV"):
+            # Create a CSV file with results
+            csv_data = export_data(st.session_state.cooling_form_data, st.session_state.cooling_results, format='csv')
+            
+            # Provide download link
+            st.download_button(
+                label="Download CSV",
+                data=csv_data,
+                file_name=f"cooling_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                mime="text/csv"
+            )
+    
+    with col2:
+        if st.button("Export Results as JSON"):
+            # Create a JSON file with results
+            json_data = export_data(st.session_state.cooling_form_data, st.session_state.cooling_results, format='json')
+            
+            # Provide download link
+            st.download_button(
+                label="Download JSON",
+                data=json_data,
+                file_name=f"cooling_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                mime="application/json"
+            )
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Ventilation", key="results_prev")
+        if prev_button:
+            st.session_state.cooling_active_tab = "ventilation"
+            st.experimental_rerun()
+    
+    with col2:
+        recalculate_button = st.button("Recalculate", key="results_recalculate")
+        if recalculate_button:
+            # Recalculate cooling load
+            calculate_cooling_load()
+            st.experimental_rerun()
+
+
+def cooling_calculator():
+    """Main function for the cooling load calculator page."""
+    st.title("Cooling Load Calculator")
+    
+    # Initialize reference data
+    ref_data = ReferenceData()
+    
+    # Initialize session state
+    load_session_state()
+    
+    # Initialize active tab if not already set
+    if 'cooling_active_tab' not in st.session_state:
+        st.session_state.cooling_active_tab = "building_info"
+    
+    # Create tabs for different steps
+    tabs = st.tabs([
+        "1. Building Information", 
+        "2. Building Envelope", 
+        "3. Windows & Doors", 
+        "4. Internal Loads", 
+        "5. Ventilation", 
+        "6. Results"
+    ])
+    
+    # Display the active tab
+    with tabs[0]:
+        if st.session_state.cooling_active_tab == "building_info":
+            building_info_form(ref_data)
+    
+    with tabs[1]:
+        if st.session_state.cooling_active_tab == "building_envelope":
+            building_envelope_form(ref_data)
+    
+    with tabs[2]:
+        if st.session_state.cooling_active_tab == "windows":
+            windows_form(ref_data)
+    
+    with tabs[3]:
+        if st.session_state.cooling_active_tab == "internal_loads":
+            internal_loads_form(ref_data)
+    
+    with tabs[4]:
+        if st.session_state.cooling_active_tab == "ventilation":
+            ventilation_form(ref_data)
+    
+    with tabs[5]:
+        if st.session_state.cooling_active_tab == "results":
+            results_page()
+
+
+if __name__ == "__main__":
+    cooling_calculator()

pages/heating_calculator.py

@@ -0,0 +1,1435 @@
+"""
+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': []
+        }
+    
+    # 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,
+            'occupancy': False
+        }
+    
+    # Initialize session state for calculation results
+    if 'heating_results' not in st.session_state:
+        st.session_state.heating_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.heating_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.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"
+        )
+        
+        # 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 for living areas and 17°C for bedrooms"
+        )
+    
+    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"
+        )
+        
+        # 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=-10.0,
+            max_value=15.0,
+            step=0.5,
+            help=f"Default value is based on selected location ({location_data['name']})"
+        )
+    
+    # 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"
+        )
+    
+    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"
+        )
+    
+    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"
+        )
+    
+    # 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', 16.5)
+    
+    # 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()}
+    
+    # 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, "Unknown"))
+        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 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
+        material_data = ref_data.get_material_by_type("walls", wall_material)
+        u_value = material_data['u_value']
+        
+    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"Material U-Value: {u_value} W/m²°C")
+        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()}
+    
+    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
+        )
+        
+        # Get material properties
+        material_data = ref_data.get_material_by_type("roofs", roof_material)
+        roof_u_value = material_data['u_value']
+        
+    with col2:
+        roof_area = st.number_input(
+            "Roof Area (m²)",
+            value=float(st.session_state.heating_form_data['building_envelope'].get('roof', {}).get('area', default_roof_area)),
+            min_value=0.1,
+            step=0.1,
+            key="roof_area_heating"
+        )
+        
+        st.write(f"Material U-Value: {roof_u_value} W/m²°C")
+        st.write(f"Heat Loss: {roof_u_value * roof_area * temp_diff:.2f} W")
+    
+    # Save roof data
+    st.session_state.heating_form_data['building_envelope']['roof'] = {
+        'material_id': roof_material,
+        'area': roof_area,
+        'u_value': roof_u_value,
+        'temp_diff': temp_diff
+    }
+    
+    # Floor section
+    st.write("### Floor")
+    
+    # Get floor material options from reference data
+    floor_material_options = {mat_id: mat_data['name'] for mat_id, mat_data in ref_data.materials['floors'].items()}
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        floor_material = st.selectbox(
+            "Floor Material",
+            options=list(floor_material_options.keys()),
+            format_func=lambda x: floor_material_options[x],
+            index=list(floor_material_options.keys()).index(st.session_state.heating_form_data['building_envelope'].get('floor', {}).get('material_id', 'concrete_slab_ground')) if st.session_state.heating_form_data['building_envelope'].get('floor', {}).get('material_id') in floor_material_options else 0
+        )
+        
+        # Get material properties
+        material_data = ref_data.get_material_by_type("floors", floor_material)
+        floor_u_value = material_data['u_value']
+        
+    with col2:
+        floor_area = st.number_input(
+            "Floor Area (m²)",
+            value=float(st.session_state.heating_form_data['building_envelope'].get('floor', {}).get('area', default_floor_area)),
+            min_value=0.1,
+            step=0.1,
+            key="floor_area_heating"
+        )
+        
+        st.write(f"Material U-Value: {floor_u_value} W/m²°C")
+        st.write(f"Heat Loss: {floor_u_value * floor_area * temp_diff:.2f} W")
+    
+    # Save floor data
+    st.session_state.heating_form_data['building_envelope']['floor'] = {
+        'material_id': floor_material,
+        'area': floor_area,
+        'u_value': floor_u_value,
+        'temp_diff': temp_diff
+    }
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if walls are defined
+    if not st.session_state.heating_form_data['building_envelope']['walls']:
+        warnings.append(ValidationWarning(
+            "No walls defined",
+            "Add at least one wall to continue",
+            is_critical=True
+        ))
+    
+    # Check if total wall area is reasonable
+    total_wall_area = sum(wall['area'] for wall in st.session_state.heating_form_data['building_envelope']['walls'])
+    expected_wall_area = 2 * (length + width) * height
+    
+    if total_wall_area < expected_wall_area * 0.8 or total_wall_area > expected_wall_area * 1.2:
+        warnings.append(ValidationWarning(
+            "Unusual wall area",
+            f"Total wall area ({total_wall_area:.2f} m²) differs significantly from the expected area ({expected_wall_area:.2f} m²) based on building dimensions"
+        ))
+    
+    # Check if roof area matches floor area
+    if abs(roof_area - floor_area) > 1.0:
+        warnings.append(ValidationWarning(
+            "Roof area doesn't match floor area",
+            "For a simple building, roof area should approximately match floor area"
+        ))
+    
+    # Save warnings to session state
+    st.session_state.heating_warnings['building_envelope'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.heating_completed['building_envelope'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Building Information", key="heating_building_envelope_prev")
+        if prev_button:
+            st.session_state.heating_active_tab = "building_info"
+            st.experimental_rerun()
+    
+    with col2:
+        next_button = st.button("Next: Windows & Doors →", key="heating_building_envelope_next")
+        if next_button:
+            st.session_state.heating_active_tab = "windows"
+            st.experimental_rerun()
+
+
+def windows_form(ref_data):
+    """
+    Form for windows and doors information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Windows & Doors")
+    st.write("Enter information about windows and doors.")
+    
+    # Get temperature difference from building info
+    temp_diff = st.session_state.heating_form_data['building_info'].get('temp_diff', 16.5)
+    
+    # Initialize windows data if not already in session state
+    if 'windows' not in st.session_state.heating_form_data['windows']:
+        st.session_state.heating_form_data['windows']['windows'] = []
+    
+    if 'doors' not in st.session_state.heating_form_data['windows']:
+        st.session_state.heating_form_data['windows']['doors'] = []
+    
+    # Windows section
+    st.write("### Windows")
+    
+    # Get glass type options from reference data
+    glass_type_options = {glass_id: glass_data['name'] for glass_id, glass_data in ref_data.glass_types.items()}
+    
+    # Display existing window entries
+    if st.session_state.heating_form_data['windows']['windows']:
+        st.write("Current windows:")
+        windows_df = pd.DataFrame(st.session_state.heating_form_data['windows']['windows'])
+        windows_df['Glass Type'] = windows_df['glass_type'].map(lambda x: glass_type_options.get(x, "Unknown"))
+        windows_df = windows_df[['name', 'orientation', 'Glass Type', 'area', 'u_value']]
+        windows_df.columns = ['Name', 'Orientation', 'Glass Type', 'Area (m²)', 'U-Value (W/m²°C)']
+        st.dataframe(windows_df)
+    
+    # Add new window form
+    st.write("Add a new window:")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        window_name = st.text_input("Window Name", value="", key="new_window_name_heating")
+        
+        orientation = st.selectbox(
+            "Orientation",
+            options=["north", "east", "south", "west", "horizontal"],
+            key="new_window_orientation_heating"
+        )
+        
+        glass_type = st.selectbox(
+            "Glass Type",
+            options=list(glass_type_options.keys()),
+            format_func=lambda x: glass_type_options[x],
+            key="new_window_glass_type_heating"
+        )
+        
+        # Get glass properties
+        glass_data = ref_data.get_glass_type(glass_type)
+        window_u_value = glass_data['u_value']
+        
+    with col2:
+        window_area = st.number_input(
+            "Window Area (m²)",
+            value=2.0,
+            min_value=0.1,
+            step=0.1,
+            key="new_window_area_heating"
+        )
+        
+        st.write(f"Glass U-Value: {window_u_value} W/m²°C")
+        st.write(f"Heat Loss: {window_u_value * window_area * temp_diff:.2f} W")
+    
+    # Add window button
+    if st.button("Add Window", key="add_window_heating"):
+        new_window = {
+            'name': window_name if window_name else f"Window {len(st.session_state.heating_form_data['windows']['windows']) + 1}",
+            'orientation': orientation,
+            'glass_type': glass_type,
+            'area': window_area,
+            'u_value': window_u_value,
+            'temp_diff': temp_diff
+        }
+        st.session_state.heating_form_data['windows']['windows'].append(new_window)
+        st.experimental_rerun()
+    
+    # Doors section
+    st.write("### Doors")
+    
+    # Display existing door entries
+    if st.session_state.heating_form_data['windows']['doors']:
+        st.write("Current doors:")
+        doors_df = pd.DataFrame(st.session_state.heating_form_data['windows']['doors'])
+        doors_df = doors_df[['name', 'type', 'area', 'u_value']]
+        doors_df.columns = ['Name', 'Type', 'Area (m²)', 'U-Value (W/m²°C)']
+        st.dataframe(doors_df)
+    
+    # Add new door form
+    st.write("Add a new door:")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        door_name = st.text_input("Door Name", value="", key="new_door_name_heating")
+        
+        door_type = st.selectbox(
+            "Door Type",
+            options=["Solid wood", "Hollow core", "Glass", "Insulated"],
+            key="new_door_type_heating"
+        )
+        
+        # Set U-value based on door type
+        door_u_values = {
+            "Solid wood": 2.0,
+            "Hollow core": 2.5,
+            "Glass": 5.0,
+            "Insulated": 1.2
+        }
+        door_u_value = door_u_values[door_type]
+        
+    with col2:
+        door_area = st.number_input(
+            "Door Area (m²)",
+            value=2.0,
+            min_value=0.1,
+            step=0.1,
+            key="new_door_area_heating"
+        )
+        
+        st.write(f"Door U-Value: {door_u_value} W/m²°C")
+        st.write(f"Heat Loss: {door_u_value * door_area * temp_diff:.2f} W")
+    
+    # Add door button
+    if st.button("Add Door", key="add_door_heating"):
+        new_door = {
+            'name': door_name if door_name else f"Door {len(st.session_state.heating_form_data['windows']['doors']) + 1}",
+            'type': door_type,
+            'area': door_area,
+            'u_value': door_u_value,
+            'temp_diff': temp_diff
+        }
+        st.session_state.heating_form_data['windows']['doors'].append(new_door)
+        st.experimental_rerun()
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if windows are defined
+    if not st.session_state.heating_form_data['windows']['windows']:
+        warnings.append(ValidationWarning(
+            "No windows defined",
+            "Add at least one window to continue"
+        ))
+    
+    # Check window-to-wall ratio
+    if st.session_state.heating_form_data['windows']['windows']:
+        total_window_area = sum(window['area'] for window in st.session_state.heating_form_data['windows']['windows'])
+        total_wall_area = sum(wall['area'] for wall in st.session_state.heating_form_data['building_envelope']['walls'])
+        window_wall_ratio = total_window_area / total_wall_area if total_wall_area > 0 else 0
+        
+        if window_wall_ratio > 0.6:
+            warnings.append(ValidationWarning(
+                "High window-to-wall ratio",
+                f"Window-to-wall ratio is {window_wall_ratio:.2f}, which is unusually high. Typical ratios are 0.2-0.4."
+            ))
+    
+    # Save warnings to session state
+    st.session_state.heating_warnings['windows'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.heating_completed['windows'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Building Envelope", key="heating_windows_prev")
+        if prev_button:
+            st.session_state.heating_active_tab = "building_envelope"
+            st.experimental_rerun()
+    
+    with col2:
+        next_button = st.button("Next: Ventilation →", key="heating_windows_next")
+        if next_button:
+            st.session_state.heating_active_tab = "ventilation"
+            st.experimental_rerun()
+
+
+def ventilation_form(ref_data):
+    """
+    Form for ventilation and infiltration information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Ventilation & Infiltration")
+    st.write("Enter information about ventilation and infiltration rates.")
+    
+    # Get building info
+    building_info = st.session_state.heating_form_data['building_info']
+    volume = building_info.get('volume', 216.0)
+    temp_diff = building_info.get('temp_diff', 16.5)
+    
+    # Initialize ventilation data if not already in session state
+    if 'infiltration' not in st.session_state.heating_form_data['ventilation']:
+        st.session_state.heating_form_data['ventilation']['infiltration'] = {
+            'air_changes': 0.5
+        }
+    
+    if 'ventilation' not in st.session_state.heating_form_data['ventilation']:
+        st.session_state.heating_form_data['ventilation']['ventilation'] = {
+            'type': 'natural',
+            'air_changes': 0.0
+        }
+    
+    # Infiltration section
+    st.write("### Infiltration")
+    st.write("Infiltration is the unintended air leakage through the building envelope.")
+    
+    infiltration_ach = st.slider(
+        "Infiltration Rate (air changes per hour)",
+        value=float(st.session_state.heating_form_data['ventilation']['infiltration'].get('air_changes', 0.5)),
+        min_value=0.1,
+        max_value=2.0,
+        step=0.1,
+        help="Typical values: 0.5 ACH for modern construction, 1.0 ACH for average construction, 1.5+ ACH for older buildings",
+        key="infiltration_ach_heating"
+    )
+    
+    # Calculate infiltration heat loss
+    infiltration_heat_loss = 0.33 * volume * infiltration_ach * temp_diff
+    
+    st.write(f"Infiltration heat loss: {infiltration_heat_loss:.2f} W")
+    
+    # Save infiltration data
+    st.session_state.heating_form_data['ventilation']['infiltration'] = {
+        'air_changes': infiltration_ach,
+        'volume': volume,
+        'temp_diff': temp_diff,
+        'heat_loss': infiltration_heat_loss
+    }
+    
+    # Ventilation section
+    st.write("### Ventilation")
+    st.write("Ventilation is the intentional introduction of outside air into the building.")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        ventilation_type = st.selectbox(
+            "Ventilation Type",
+            options=["natural", "mechanical", "mixed"],
+            format_func=lambda x: x.capitalize(),
+            index=["natural", "mechanical", "mixed"].index(st.session_state.heating_form_data['ventilation']['ventilation'].get('type', 'natural')),
+            key="ventilation_type_heating"
+        )
+    
+    with col2:
+        ventilation_ach = st.number_input(
+            "Ventilation Rate (air changes per hour)",
+            value=float(st.session_state.heating_form_data['ventilation']['ventilation'].get('air_changes', 0.0)),
+            min_value=0.0,
+            max_value=5.0,
+            step=0.1,
+            help="Typical values: 0.35-1.0 ACH for residential buildings",
+            key="ventilation_ach_heating"
+        )
+    
+    # Calculate ventilation heat loss
+    ventilation_heat_loss = 0.33 * volume * ventilation_ach * temp_diff
+    
+    st.write(f"Ventilation heat loss: {ventilation_heat_loss:.2f} W")
+    
+    # Save ventilation data
+    st.session_state.heating_form_data['ventilation']['ventilation'] = {
+        'type': ventilation_type,
+        'air_changes': ventilation_ach,
+        'volume': volume,
+        'temp_diff': temp_diff,
+        'heat_loss': ventilation_heat_loss
+    }
+    
+    # Calculate total ventilation and infiltration heat loss
+    total_ventilation_loss = infiltration_heat_loss + ventilation_heat_loss
+    
+    st.info(f"Total Ventilation & Infiltration Heat Loss: {total_ventilation_loss:.2f} W")
+    
+    # Save total ventilation loss
+    st.session_state.heating_form_data['ventilation']['total_loss'] = total_ventilation_loss
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if infiltration rate is reasonable
+    if infiltration_ach < 0.3:
+        warnings.append(ValidationWarning(
+            "Low infiltration rate",
+            "Infiltration rate below 0.3 ACH is unusually low for most buildings."
+        ))
+    elif infiltration_ach > 1.5:
+        warnings.append(ValidationWarning(
+            "High infiltration rate",
+            "Infiltration rate above 1.5 ACH indicates a leaky building envelope."
+        ))
+    
+    # Check if ventilation rate is reasonable
+    if ventilation_ach > 0 and ventilation_ach < 0.35:
+        warnings.append(ValidationWarning(
+            "Low ventilation rate",
+            "Ventilation rate below 0.35 ACH may not provide adequate fresh air."
+        ))
+    elif ventilation_ach > 2.0:
+        warnings.append(ValidationWarning(
+            "High ventilation rate",
+            "Ventilation rate above 2.0 ACH is unusually high for residential buildings."
+        ))
+    
+    # Save warnings to session state
+    st.session_state.heating_warnings['ventilation'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.heating_completed['ventilation'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Windows & Doors", key="heating_ventilation_prev")
+        if prev_button:
+            st.session_state.heating_active_tab = "windows"
+            st.experimental_rerun()
+    
+    with col2:
+        next_button = st.button("Next: Occupancy →", key="heating_ventilation_next")
+        if next_button:
+            st.session_state.heating_active_tab = "occupancy"
+            st.experimental_rerun()
+
+
+def occupancy_form(ref_data):
+    """
+    Form for occupancy information.
+    
+    Args:
+        ref_data: Reference data object
+    """
+    st.subheader("Occupancy Information")
+    st.write("Enter information about occupancy patterns and heating degree days.")
+    
+    # Get location from building info
+    location = st.session_state.heating_form_data['building_info'].get('location', 'sydney')
+    location_name = st.session_state.heating_form_data['building_info'].get('location_name', 'Sydney')
+    
+    # Initialize occupancy data if not already in session state
+    if 'occupancy_type' not in st.session_state.heating_form_data['occupancy']:
+        st.session_state.heating_form_data['occupancy']['occupancy_type'] = 'continuous'
+    
+    if 'heating_degree_days' not in st.session_state.heating_form_data['occupancy']:
+        # Get default HDD from reference data
+        calculator = HeatingLoadCalculator()
+        default_hdd = calculator.get_heating_degree_days(location)
+        st.session_state.heating_form_data['occupancy']['heating_degree_days'] = default_hdd
+    
+    # Occupancy section
+    st.write("### Occupancy Pattern")
+    
+    # Get occupancy options from reference data
+    occupancy_options = {occ_id: occ_data['name'] for occ_id, occ_data in ref_data.occupancy_factors.items()}
+    
+    occupancy_type = st.selectbox(
+        "Occupancy Type",
+        options=list(occupancy_options.keys()),
+        format_func=lambda x: occupancy_options[x],
+        index=list(occupancy_options.keys()).index(st.session_state.heating_form_data['occupancy'].get('occupancy_type', 'continuous')) if st.session_state.heating_form_data['occupancy'].get('occupancy_type') in occupancy_options else 0,
+        help="Select the occupancy pattern that best describes how the building is used"
+    )
+    
+    # Get occupancy factor
+    occupancy_data = ref_data.get_occupancy_factor(occupancy_type)
+    occupancy_factor = occupancy_data['factor']
+    
+    st.write(f"Occupancy correction factor: {occupancy_factor}")
+    st.write(f"Description: {occupancy_data['description']}")
+    
+    # Save occupancy data
+    st.session_state.heating_form_data['occupancy']['occupancy_type'] = occupancy_type
+    st.session_state.heating_form_data['occupancy']['occupancy_factor'] = occupancy_factor
+    
+    # Heating degree days section
+    st.write("### Heating Degree Days")
+    st.write("Heating degree days are used to estimate annual heating energy requirements.")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        base_temp = st.selectbox(
+            "Base Temperature",
+            options=[18, 15.5, 12],
+            index=[18, 15.5, 12].index(st.session_state.heating_form_data['occupancy'].get('base_temp', 18)) if st.session_state.heating_form_data['occupancy'].get('base_temp') in [18, 15.5, 12] else 0,
+            help="Base temperature for heating degree days calculation"
+        )
+    
+    with col2:
+        # Get default HDD from reference data
+        calculator = HeatingLoadCalculator()
+        default_hdd = calculator.get_heating_degree_days(location, base_temp)
+        
+        heating_degree_days = st.number_input(
+            "Heating Degree Days",
+            value=float(st.session_state.heating_form_data['occupancy'].get('heating_degree_days', default_hdd)),
+            min_value=0.0,
+            step=10.0,
+            help=f"Default value for {location_name} at base {base_temp}°C: {default_hdd}"
+        )
+    
+    st.write(f"Heating degree days represent the sum of daily temperature differences between the base temperature and the average daily temperature when it falls below the base temperature.")
+    
+    # Save heating degree days data
+    st.session_state.heating_form_data['occupancy']['base_temp'] = base_temp
+    st.session_state.heating_form_data['occupancy']['heating_degree_days'] = heating_degree_days
+    
+    # Validate inputs
+    warnings = []
+    
+    # Check if heating degree days are reasonable
+    if heating_degree_days == 0:
+        warnings.append(ValidationWarning(
+            "Zero heating degree days",
+            "With zero heating degree days, annual heating energy will be zero."
+        ))
+    elif heating_degree_days < 100 and base_temp == 18:
+        warnings.append(ValidationWarning(
+            "Very low heating degree days",
+            f"Heating degree days below 100 at base {base_temp}°C is unusually low for most locations."
+        ))
+    elif heating_degree_days > 3000:
+        warnings.append(ValidationWarning(
+            "Very high heating degree days",
+            "Heating degree days above 3000 is unusually high for most locations."
+        ))
+    
+    # Save warnings to session state
+    st.session_state.heating_warnings['occupancy'] = 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}")
+    
+    # Mark this step as completed if there are no critical warnings
+    st.session_state.heating_completed['occupancy'] = not any(w.is_critical for w in warnings)
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Ventilation", key="heating_occupancy_prev")
+        if prev_button:
+            st.session_state.heating_active_tab = "ventilation"
+            st.experimental_rerun()
+    
+    with col2:
+        calculate_button = st.button("Calculate Results →", key="heating_occupancy_calculate")
+        if calculate_button:
+            # Calculate heating load
+            calculate_heating_load()
+            st.session_state.heating_active_tab = "results"
+            st.experimental_rerun()
+
+
+def calculate_heating_load():
+    """Calculate heating load based on input data."""
+    # Create calculator instance
+    calculator = HeatingLoadCalculator()
+    
+    # Get form data
+    form_data = st.session_state.heating_form_data
+    
+    # Prepare building components for calculation
+    building_components = []
+    
+    # Add walls
+    for wall in form_data['building_envelope'].get('walls', []):
+        building_components.append({
+            'name': wall['name'],
+            'area': wall['area'],
+            'u_value': wall['u_value'],
+            'temp_diff': wall['temp_diff']
+        })
+    
+    # Add roof
+    roof = form_data['building_envelope'].get('roof', {})
+    if roof:
+        building_components.append({
+            'name': 'Roof',
+            'area': roof['area'],
+            'u_value': roof['u_value'],
+            'temp_diff': roof['temp_diff']
+        })
+    
+    # Add floor
+    floor = form_data['building_envelope'].get('floor', {})
+    if floor:
+        building_components.append({
+            'name': 'Floor',
+            'area': floor['area'],
+            'u_value': floor['u_value'],
+            'temp_diff': floor['temp_diff']
+        })
+    
+    # Add windows
+    for window in form_data['windows'].get('windows', []):
+        building_components.append({
+            'name': window['name'],
+            'area': window['area'],
+            'u_value': window['u_value'],
+            'temp_diff': window['temp_diff']
+        })
+    
+    # Add doors
+    for door in form_data['windows'].get('doors', []):
+        building_components.append({
+            'name': door['name'],
+            'area': door['area'],
+            'u_value': door['u_value'],
+            'temp_diff': door['temp_diff']
+        })
+    
+    # Prepare infiltration data
+    infiltration = form_data['ventilation'].get('infiltration', {})
+    ventilation = form_data['ventilation'].get('ventilation', {})
+    
+    infiltration_data = {
+        'volume': infiltration.get('volume', 0),
+        'air_changes': infiltration.get('air_changes', 0) + ventilation.get('air_changes', 0),
+        'temp_diff': infiltration.get('temp_diff', 0)
+    }
+    
+    # Calculate heating load
+    results = calculator.calculate_total_heating_load(
+        building_components=building_components,
+        infiltration=infiltration_data
+    )
+    
+    # Calculate annual heating requirement
+    location = form_data['building_info'].get('location', 'sydney')
+    occupancy_type = form_data['occupancy'].get('occupancy_type', 'continuous')
+    base_temp = form_data['occupancy'].get('base_temp', 18)
+    
+    annual_results = calculator.calculate_annual_heating_requirement(
+        results['total_load'],
+        location,
+        occupancy_type,
+        base_temp
+    )
+    
+    # Combine results
+    combined_results = {**results, **annual_results}
+    
+    # Save results to session state
+    st.session_state.heating_results = combined_results
+    
+    # Add timestamp
+    st.session_state.heating_results['timestamp'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    # Add building info
+    st.session_state.heating_results['building_info'] = form_data['building_info']
+    
+    return combined_results
+
+
+def results_page():
+    """Display calculation results."""
+    st.subheader("Heating Load Calculation Results")
+    
+    # Check if results are available
+    if not st.session_state.heating_results:
+        st.warning("No calculation results available. Please complete the input forms and calculate results.")
+        return
+    
+    # Get results
+    results = st.session_state.heating_results
+    
+    # Display summary
+    st.write("### Summary")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.metric("Total Heating Load", f"{results['total_load']:.2f} W")
+        
+        # Convert to kW
+        total_load_kw = results['total_load'] / 1000
+        st.metric("Total Heating Load", f"{total_load_kw:.2f} kW")
+        
+        # Annual heating energy
+        st.metric("Annual Heating Energy", f"{results['annual_energy_kwh']:.2f} kWh")
+    
+    with col2:
+        # Calculate heating load per area
+        floor_area = results['building_info'].get('floor_area', 80.0)
+        heating_load_per_area = results['total_load'] / floor_area
+        st.metric("Heating Load per Area", f"{heating_load_per_area:.2f} W/m²")
+        
+        # Annual heating energy per area
+        annual_energy_per_area = results['annual_energy_kwh'] / floor_area
+        st.metric("Annual Heating Energy per Area", f"{annual_energy_per_area:.2f} kWh/m²")
+        
+        # Equipment sizing recommendation
+        # Add 10% safety factor
+        recommended_size = total_load_kw * 1.1
+        st.metric("Recommended Equipment Size", f"{recommended_size:.2f} kW")
+    
+    # Display load breakdown
+    st.write("### Load Breakdown")
+    
+    # Prepare data for pie chart
+    component_losses = results['component_losses']
+    
+    # Create pie chart for component losses
+    fig = px.pie(
+        values=list(component_losses.values()),
+        names=list(component_losses.keys()),
+        title="Heating Load Components",
+        color_discrete_sequence=px.colors.qualitative.Set2
+    )
+    
+    st.plotly_chart(fig)
+    
+    # Display load components in a table
+    load_components = {
+        'Conduction (Building Envelope)': results['total_conduction_loss'] - results.get('infiltration_loss', 0),
+        'Infiltration & Ventilation': results.get('infiltration_loss', 0)
+    }
+    
+    load_df = pd.DataFrame({
+        'Component': list(load_components.keys()),
+        'Load (W)': list(load_components.values()),
+        'Percentage (%)': [value / results['total_load'] * 100 for value in load_components.values()]
+    })
+    
+    st.dataframe(load_df.style.format({
+        'Load (W)': '{:.2f}',
+        'Percentage (%)': '{:.2f}'
+    }))
+    
+    # Display detailed results
+    st.write("### Detailed Results")
+    
+    # Create tabs for different result sections
+    tabs = st.tabs([
+        "Building Components", 
+        "Ventilation", 
+        "Annual Energy"
+    ])
+    
+    with tabs[0]:
+        st.subheader("Building Component Heat Losses")
+        
+        # Create dataframe from component losses
+        components_data = []
+        for name, loss in component_losses.items():
+            # Find the component in the original data to get area and U-value
+            component = None
+            for comp in st.session_state.heating_form_data['building_envelope'].get('walls', []):
+                if comp['name'] == name:
+                    component = comp
+                    break
+            
+            if name == 'Roof':
+                component = st.session_state.heating_form_data['building_envelope'].get('roof', {})
+            elif name == 'Floor':
+                component = st.session_state.heating_form_data['building_envelope'].get('floor', {})
+            
+            # Check windows and doors
+            if not component:
+                for window in st.session_state.heating_form_data['windows'].get('windows', []):
+                    if window['name'] == name:
+                        component = window
+                        break
+            
+            if not component:
+                for door in st.session_state.heating_form_data['windows'].get('doors', []):
+                    if door['name'] == name:
+                        component = door
+                        break
+            
+            if component:
+                components_data.append({
+                    'Component': name,
+                    'Area (m²)': component.get('area', 0),
+                    'U-Value (W/m²°C)': component.get('u_value', 0),
+                    'Temperature Difference (°C)': component.get('temp_diff', 0),
+                    'Heat Loss (W)': loss
+                })
+            else:
+                components_data.append({
+                    'Component': name,
+                    'Area (m²)': 0,
+                    'U-Value (W/m²°C)': 0,
+                    'Temperature Difference (°C)': 0,
+                    'Heat Loss (W)': loss
+                })
+        
+        # Create dataframe
+        components_df = pd.DataFrame(components_data)
+        
+        # Display table
+        st.dataframe(components_df.style.format({
+            'Area (m²)': '{:.2f}',
+            'U-Value (W/m²°C)': '{:.2f}',
+            'Temperature Difference (°C)': '{:.2f}',
+            'Heat Loss (W)': '{:.2f}'
+        }))
+        
+        # Create bar chart
+        fig = px.bar(
+            components_df,
+            x='Component',
+            y='Heat Loss (W)',
+            title="Heat Loss by Building Component",
+            color='Component',
+            color_discrete_sequence=px.colors.qualitative.Set3
+        )
+        
+        st.plotly_chart(fig)
+    
+    with tabs[1]:
+        st.subheader("Ventilation & Infiltration Heat Losses")
+        
+        # Get ventilation data
+        ventilation_data = st.session_state.heating_form_data['ventilation']
+        
+        # Create dataframe
+        ventilation_df = pd.DataFrame([
+            {
+                'Source': 'Infiltration',
+                'Air Changes per Hour': ventilation_data['infiltration']['air_changes'],
+                'Volume (m³)': ventilation_data['infiltration']['volume'],
+                'Temperature Difference (°C)': ventilation_data['infiltration']['temp_diff'],
+                'Heat Loss (W)': ventilation_data['infiltration']['heat_loss']
+            },
+            {
+                'Source': 'Ventilation',
+                'Air Changes per Hour': ventilation_data['ventilation']['air_changes'],
+                'Volume (m³)': ventilation_data['ventilation']['volume'],
+                'Temperature Difference (°C)': ventilation_data['ventilation']['temp_diff'],
+                'Heat Loss (W)': ventilation_data['ventilation']['heat_loss']
+            }
+        ])
+        
+        # Display table
+        st.dataframe(ventilation_df.style.format({
+            'Air Changes per Hour': '{:.2f}',
+            'Volume (m³)': '{:.2f}',
+            'Temperature Difference (°C)': '{:.2f}',
+            'Heat Loss (W)': '{:.2f}'
+        }))
+        
+        # Create bar chart
+        fig = px.bar(
+            ventilation_df,
+            x='Source',
+            y='Heat Loss (W)',
+            title="Ventilation & Infiltration Heat Losses",
+            color='Source',
+            color_discrete_sequence=px.colors.qualitative.Pastel2
+        )
+        
+        st.plotly_chart(fig)
+    
+    with tabs[2]:
+        st.subheader("Annual Heating Energy")
+        
+        # Get occupancy data
+        occupancy_data = st.session_state.heating_form_data['occupancy']
+        
+        # Create dataframe
+        annual_data = pd.DataFrame([
+            {
+                'Parameter': 'Heating Degree Days',
+                'Value': results['heating_degree_days'],
+                'Unit': 'HDD'
+            },
+            {
+                'Parameter': 'Base Temperature',
+                'Value': occupancy_data['base_temp'],
+                'Unit': '°C'
+            },
+            {
+                'Parameter': 'Occupancy Type',
+                'Value': occupancy_data['occupancy_type'].capitalize(),
+                'Unit': ''
+            },
+            {
+                'Parameter': 'Correction Factor',
+                'Value': results['correction_factor'],
+                'Unit': ''
+            },
+            {
+                'Parameter': 'Annual Heating Energy',
+                'Value': results['annual_energy_kwh'],
+                'Unit': 'kWh'
+            },
+            {
+                'Parameter': 'Annual Heating Energy',
+                'Value': results['annual_energy_mj'],
+                'Unit': 'MJ'
+            }
+        ])
+        
+        # Display table
+        st.dataframe(annual_data.style.format({
+            'Value': lambda x: f"{x:.2f}" if isinstance(x, (int, float)) else str(x)
+        }))
+        
+        # Create bar chart for monthly distribution (estimated)
+        # This is a simplified distribution based on heating degree days
+        months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+        
+        # Get location
+        location = st.session_state.heating_form_data['building_info'].get('location', 'sydney')
+        
+        # Simplified monthly distribution factors based on hemisphere
+        # Southern hemisphere: winter is June-August
+        # Northern hemisphere: winter is December-February
+        southern_hemisphere = ['sydney', 'melbourne', 'brisbane', 'perth', 'adelaide', 'hobart', 'darwin', 'canberra', 'mildura']
+        
+        if location.lower() in southern_hemisphere:
+            # Southern hemisphere distribution
+            monthly_factors = [0.02, 0.01, 0.03, 0.08, 0.12, 0.16, 0.18, 0.16, 0.12, 0.08, 0.03, 0.01]
+        else:
+            # Northern hemisphere distribution
+            monthly_factors = [0.18, 0.16, 0.12, 0.08, 0.03, 0.01, 0.01, 0.01, 0.03, 0.08, 0.12, 0.17]
+        
+        # Calculate monthly energy
+        monthly_energy = [results['annual_energy_kwh'] * factor for factor in monthly_factors]
+        
+        # Create dataframe
+        monthly_df = pd.DataFrame({
+            'Month': months,
+            'Energy (kWh)': monthly_energy
+        })
+        
+        # Create bar chart
+        fig = px.bar(
+            monthly_df,
+            x='Month',
+            y='Energy (kWh)',
+            title="Estimated Monthly Heating Energy Distribution",
+            color_discrete_sequence=['indianred']
+        )
+        
+        st.plotly_chart(fig)
+    
+    # Export options
+    st.write("### Export Options")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        if st.button("Export Results as CSV", key="export_csv_heating"):
+            # Create a CSV file with results
+            csv_data = export_data(st.session_state.heating_form_data, st.session_state.heating_results, format='csv')
+            
+            # Provide download link
+            st.download_button(
+                label="Download CSV",
+                data=csv_data,
+                file_name=f"heating_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
+                mime="text/csv"
+            )
+    
+    with col2:
+        if st.button("Export Results as JSON", key="export_json_heating"):
+            # Create a JSON file with results
+            json_data = export_data(st.session_state.heating_form_data, st.session_state.heating_results, format='json')
+            
+            # Provide download link
+            st.download_button(
+                label="Download JSON",
+                data=json_data,
+                file_name=f"heating_load_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                mime="application/json"
+            )
+    
+    # Navigation buttons
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        prev_button = st.button("← Back: Occupancy", key="heating_results_prev")
+        if prev_button:
+            st.session_state.heating_active_tab = "occupancy"
+            st.experimental_rerun()
+    
+    with col2:
+        recalculate_button = st.button("Recalculate", key="heating_results_recalculate")
+        if recalculate_button:
+            # Recalculate heating load
+            calculate_heating_load()
+            st.experimental_rerun()
+
+
+def heating_calculator():
+    """Main function for the heating load calculator page."""
+    st.title("Heating Load Calculator")
+    
+    # Initialize reference data
+    ref_data = ReferenceData()
+    
+    # Initialize session state
+    load_session_state()
+    
+    # Initialize active tab if not already set
+    if 'heating_active_tab' not in st.session_state:
+        st.session_state.heating_active_tab = "building_info"
+    
+    # Create tabs for different steps
+    tabs = st.tabs([
+        "1. Building Information", 
+        "2. Building Envelope", 
+        "3. Windows & Doors", 
+        "4. Ventilation", 
+        "5. Occupancy", 
+        "6. Results"
+    ])
+    
+    # Display the active tab
+    with tabs[0]:
+        if st.session_state.heating_active_tab == "building_info":
+            building_info_form(ref_data)
+    
+    with tabs[1]:
+        if st.session_state.heating_active_tab == "building_envelope":
+            building_envelope_form(ref_data)
+    
+    with tabs[2]:
+        if st.session_state.heating_active_tab == "windows":
+            windows_form(ref_data)
+    
+    with tabs[3]:
+        if st.session_state.heating_active_tab == "ventilation":
+            ventilation_form(ref_data)
+    
+    with tabs[4]:
+        if st.session_state.heating_active_tab == "occupancy":
+            occupancy_form(ref_data)
+    
+    with tabs[5]:
+        if st.session_state.heating_active_tab == "results":
+            results_page()
+
+
+if __name__ == "__main__":
+    heating_calculator()

reference_data.py

@@ -0,0 +1,616 @@
+"""
+Reference Data Module for HVAC Load Calculator
+
+This module provides reference data for materials, locations, and other parameters
+needed for HVAC load calculations.
+"""
+
+import pandas as pd
+import json
+from pathlib import Path
+
+
+class ReferenceData:
+    """
+    A class to manage reference data for HVAC load calculations.
+    """
+
+    def __init__(self):
+        """Initialize the reference data."""
+        self.materials = self._load_materials()
+        self.locations = self._load_locations()
+        self.glass_types = self._load_glass_types()
+        self.shading_factors = self._load_shading_factors()
+        self.internal_loads = self._load_internal_loads()
+        self.occupancy_factors = self._load_occupancy_factors()
+
+    def _load_materials(self):
+        """
+        Load building material properties.
+        
+        Returns:
+            dict: Dictionary of material properties
+        """
+        # This would typically load from a JSON or CSV file
+        # For now, we'll define it directly
+        
+        materials = {
+            "walls": {
+                "brick_veneer": {
+                    "name": "Brick veneer with insulation",
+                    "u_value": 0.5,  # W/m²°C
+                    "r_value": 2.0,  # m²°C/W
+                    "description": "Brick veneer with timber frame and insulation"
+                },
+                "double_brick": {
+                    "name": "Double brick",
+                    "u_value": 1.88,  # W/m²°C
+                    "r_value": 0.53,  # m²°C/W
+                    "description": "Double brick wall without insulation"
+                },
+                "double_brick_insulated": {
+                    "name": "Double brick with insulation",
+                    "u_value": 0.6,  # W/m²°C
+                    "r_value": 1.67,  # m²°C/W
+                    "description": "Double brick wall with insulation"
+                },
+                "timber_frame": {
+                    "name": "Timber frame",
+                    "u_value": 0.8,  # W/m²°C
+                    "r_value": 1.25,  # m²°C/W
+                    "description": "Timber frame wall with insulation"
+                },
+                "concrete_block": {
+                    "name": "Concrete block",
+                    "u_value": 2.3,  # W/m²°C
+                    "r_value": 0.43,  # m²°C/W
+                    "description": "Concrete block wall without insulation"
+                },
+                "concrete_block_insulated": {
+                    "name": "Concrete block with insulation",
+                    "u_value": 0.7,  # W/m²°C
+                    "r_value": 1.43,  # m²°C/W
+                    "description": "Concrete block wall with insulation"
+                }
+            },
+            "roofs": {
+                "metal_deck_insulated": {
+                    "name": "Metal deck with insulation",
+                    "u_value": 0.46,  # W/m²°C
+                    "r_value": 2.17,  # m²°C/W
+                    "description": "Metal deck roof with insulation and plasterboard ceiling"
+                },
+                "metal_deck_uninsulated": {
+                    "name": "Metal deck without insulation",
+                    "u_value": 2.2,  # W/m²°C
+                    "r_value": 0.45,  # m²°C/W
+                    "description": "Metal deck roof without insulation"
+                },
+                "concrete_slab_roof": {
+                    "name": "Concrete slab roof",
+                    "u_value": 3.1,  # W/m²°C
+                    "r_value": 0.32,  # m²°C/W
+                    "description": "Concrete slab roof without insulation"
+                },
+                "concrete_slab_insulated": {
+                    "name": "Concrete slab roof with insulation",
+                    "u_value": 0.5,  # W/m²°C
+                    "r_value": 2.0,  # m²°C/W
+                    "description": "Concrete slab roof with insulation"
+                },
+                "tiled_roof_insulated": {
+                    "name": "Tiled roof with insulation",
+                    "u_value": 0.4,  # W/m²°C
+                    "r_value": 2.5,  # m²°C/W
+                    "description": "Tiled roof with insulation and plasterboard ceiling"
+                },
+                "tiled_roof_uninsulated": {
+                    "name": "Tiled roof without insulation",
+                    "u_value": 2.0,  # W/m²°C
+                    "r_value": 0.5,  # m²°C/W
+                    "description": "Tiled roof without insulation"
+                }
+            },
+            "floors": {
+                "concrete_slab_ground": {
+                    "name": "Concrete slab on ground",
+                    "u_value": 0.6,  # W/m²°C
+                    "r_value": 1.67,  # m²°C/W
+                    "description": "Concrete slab directly on ground"
+                },
+                "concrete_slab_insulated": {
+                    "name": "Concrete slab with insulation",
+                    "u_value": 0.3,  # W/m²°C
+                    "r_value": 3.33,  # m²°C/W
+                    "description": "Concrete slab with insulation"
+                },
+                "suspended_timber": {
+                    "name": "Suspended timber floor",
+                    "u_value": 1.5,  # W/m²°C
+                    "r_value": 0.67,  # m²°C/W
+                    "description": "Suspended timber floor without insulation"
+                },
+                "suspended_timber_insulated": {
+                    "name": "Suspended timber floor with insulation",
+                    "u_value": 0.4,  # W/m²°C
+                    "r_value": 2.5,  # m²°C/W
+                    "description": "Suspended timber floor with insulation"
+                }
+            }
+        }
+        
+        return materials
+
+    def _load_locations(self):
+        """
+        Load climate data for different locations.
+        
+        Returns:
+            dict: Dictionary of location climate data
+        """
+        # This would typically load from a JSON or CSV file
+        # For now, we'll define it directly
+        
+        locations = {
+            "sydney": {
+                "name": "Sydney",
+                "state": "NSW",
+                "summer_design_temp": 32.0,  # °C
+                "winter_design_temp": 7.0,   # °C
+                "daily_temp_range": "medium",  # 8.5-14°C
+                "heating_degree_days": 740,   # Base 18°C
+                "cooling_degree_days": 350,   # Base 18°C
+                "latitude": -33.87,
+                "longitude": 151.21
+            },
+            "melbourne": {
+                "name": "Melbourne",
+                "state": "VIC",
+                "summer_design_temp": 35.0,  # °C
+                "winter_design_temp": 4.0,   # °C
+                "daily_temp_range": "medium",  # 8.5-14°C
+                "heating_degree_days": 1400,  # Base 18°C
+                "cooling_degree_days": 200,   # Base 18°C
+                "latitude": -37.81,
+                "longitude": 144.96
+            },
+            "brisbane": {
+                "name": "Brisbane",
+                "state": "QLD",
+                "summer_design_temp": 32.0,  # °C
+                "winter_design_temp": 9.0,   # °C
+                "daily_temp_range": "medium",  # 8.5-14°C
+                "heating_degree_days": 320,   # Base 18°C
+                "cooling_degree_days": 750,   # Base 18°C
+                "latitude": -27.47,
+                "longitude": 153.03
+            },
+            "perth": {
+                "name": "Perth",
+                "state": "WA",
+                "summer_design_temp": 37.0,  # °C
+                "winter_design_temp": 7.0,   # °C
+                "daily_temp_range": "high",   # >14°C
+                "heating_degree_days": 760,   # Base 18°C
+                "cooling_degree_days": 600,   # Base 18°C
+                "latitude": -31.95,
+                "longitude": 115.86
+            },
+            "adelaide": {
+                "name": "Adelaide",
+                "state": "SA",
+                "summer_design_temp": 38.0,  # °C
+                "winter_design_temp": 5.0,   # °C
+                "daily_temp_range": "high",   # >14°C
+                "heating_degree_days": 1100,  # Base 18°C
+                "cooling_degree_days": 500,   # Base 18°C
+                "latitude": -34.93,
+                "longitude": 138.60
+            },
+            "hobart": {
+                "name": "Hobart",
+                "state": "TAS",
+                "summer_design_temp": 28.0,  # °C
+                "winter_design_temp": 2.0,   # °C
+                "daily_temp_range": "medium",  # 8.5-14°C
+                "heating_degree_days": 1800,  # Base 18°C
+                "cooling_degree_days": 50,    # Base 18°C
+                "latitude": -42.88,
+                "longitude": 147.33
+            },
+            "darwin": {
+                "name": "Darwin",
+                "state": "NT",
+                "summer_design_temp": 34.0,  # °C
+                "winter_design_temp": 15.0,  # °C
+                "daily_temp_range": "low",    # <8.5°C
+                "heating_degree_days": 0,     # Base 18°C
+                "cooling_degree_days": 3500,  # Base 18°C
+                "latitude": -12.46,
+                "longitude": 130.84
+            },
+            "canberra": {
+                "name": "Canberra",
+                "state": "ACT",
+                "summer_design_temp": 35.0,  # °C
+                "winter_design_temp": -1.0,  # °C
+                "daily_temp_range": "high",   # >14°C
+                "heating_degree_days": 2000,  # Base 18°C
+                "cooling_degree_days": 150,   # Base 18°C
+                "latitude": -35.28,
+                "longitude": 149.13
+            },
+            "mildura": {
+                "name": "Mildura",
+                "state": "VIC",
+                "summer_design_temp": 38.0,  # °C
+                "winter_design_temp": 4.5,   # °C
+                "daily_temp_range": "high",   # >14°C
+                "heating_degree_days": 1200,  # Base 18°C
+                "cooling_degree_days": 700,   # Base 18°C
+                "latitude": -34.21,
+                "longitude": 142.14
+            }
+        }
+        
+        return locations
+
+    def _load_glass_types(self):
+        """
+        Load glass type properties.
+        
+        Returns:
+            dict: Dictionary of glass type properties
+        """
+        # This would typically load from a JSON or CSV file
+        # For now, we'll define it directly
+        
+        glass_types = {
+            "single": {
+                "name": "Single glazing",
+                "u_value": 5.8,  # W/m²°C
+                "shgc": 0.85,    # Solar Heat Gain Coefficient
+                "description": "Standard single glazed window"
+            },
+            "double": {
+                "name": "Double glazing",
+                "u_value": 2.9,  # W/m²°C
+                "shgc": 0.75,    # Solar Heat Gain Coefficient
+                "description": "Standard double glazed window"
+            },
+            "low_e": {
+                "name": "Low-E double glazing",
+                "u_value": 1.8,  # W/m²°C
+                "shgc": 0.65,    # Solar Heat Gain Coefficient
+                "description": "Double glazed window with low-emissivity coating"
+            },
+            "triple": {
+                "name": "Triple glazing",
+                "u_value": 1.2,  # W/m²°C
+                "shgc": 0.6,     # Solar Heat Gain Coefficient
+                "description": "Triple glazed window"
+            },
+            "tinted": {
+                "name": "Tinted single glazing",
+                "u_value": 5.8,  # W/m²°C
+                "shgc": 0.65,    # Solar Heat Gain Coefficient
+                "description": "Single glazed window with tinting"
+            },
+            "tinted_double": {
+                "name": "Tinted double glazing",
+                "u_value": 2.9,  # W/m²°C
+                "shgc": 0.55,    # Solar Heat Gain Coefficient
+                "description": "Double glazed window with tinting"
+            }
+        }
+        
+        return glass_types
+
+    def _load_shading_factors(self):
+        """
+        Load shading factors for different shading devices.
+        
+        Returns:
+            dict: Dictionary of shading factors
+        """
+        # This would typically load from a JSON or CSV file
+        # For now, we'll define it directly
+        
+        shading_factors = {
+            "none": {
+                "name": "No shading",
+                "factor": 0.0,
+                "description": "No shading devices"
+            },
+            "internal_blinds": {
+                "name": "Internal venetian blinds",
+                "factor": 0.4,
+                "description": "Internal venetian blinds"
+            },
+            "internal_drapes": {
+                "name": "Internal drapes",
+                "factor": 0.3,
+                "description": "Internal drapes or curtains"
+            },
+            "external_awning": {
+                "name": "External awning",
+                "factor": 0.7,
+                "description": "External awning"
+            },
+            "external_shutters": {
+                "name": "External shutters",
+                "factor": 0.8,
+                "description": "External shutters"
+            },
+            "eaves": {
+                "name": "Eaves or overhang",
+                "factor": 0.5,
+                "description": "Eaves or overhang"
+            },
+            "pergola": {
+                "name": "Pergola with vegetation",
+                "factor": 0.6,
+                "description": "Pergola with vegetation"
+            }
+        }
+        
+        return shading_factors
+
+    def _load_internal_loads(self):
+        """
+        Load internal load data.
+        
+        Returns:
+            dict: Dictionary of internal load data
+        """
+        # This would typically load from a JSON or CSV file
+        # For now, we'll define it directly
+        
+        internal_loads = {
+            "people": {
+                "seated_resting": {
+                    "name": "Seated, resting",
+                    "sensible_heat": 75,  # W per person
+                    "latent_heat": 30     # W per person
+                },
+                "seated_light_work": {
+                    "name": "Seated, light work",
+                    "sensible_heat": 85,  # W per person
+                    "latent_heat": 40     # W per person
+                },
+                "standing_light_work": {
+                    "name": "Standing, light work",
+                    "sensible_heat": 90,  # W per person
+                    "latent_heat": 50     # W per person
+                },
+                "light_activity": {
+                    "name": "Light activity",
+                    "sensible_heat": 100,  # W per person
+                    "latent_heat": 60      # W per person
+                },
+                "medium_activity": {
+                    "name": "Medium activity",
+                    "sensible_heat": 120,  # W per person
+                    "latent_heat": 80      # W per person
+                }
+            },
+            "lighting": {
+                "incandescent": {
+                    "name": "Incandescent",
+                    "heat_factor": 1.0  # 100% of wattage becomes heat
+                },
+                "fluorescent": {
+                    "name": "Fluorescent",
+                    "heat_factor": 1.2  # 120% of wattage becomes heat (includes ballast)
+                },
+                "led": {
+                    "name": "LED",
+                    "heat_factor": 0.8  # 80% of wattage becomes heat
+                }
+            },
+            "appliances": {
+                "kitchen": {
+                    "name": "Kitchen",
+                    "heat_gain": 1000  # W
+                },
+                "living_room": {
+                    "name": "Living room",
+                    "heat_gain": 300   # W
+                },
+                "bedroom": {
+                    "name": "Bedroom",
+                    "heat_gain": 150   # W
+                },
+                "office": {
+                    "name": "Home office",
+                    "heat_gain": 450   # W
+                }
+            }
+        }
+        
+        return internal_loads
+
+    def _load_occupancy_factors(self):
+        """
+        Load occupancy correction factors.
+        
+        Returns:
+            dict: Dictionary of occupancy correction factors
+        """
+        # This would typically load from a JSON or CSV file
+        # For now, we'll define it directly
+        
+        occupancy_factors = {
+            "continuous": {
+                "name": "Continuous",
+                "factor": 1.0,
+                "description": "Continuously heated"
+            },
+            "intermittent": {
+                "name": "Intermittent",
+                "factor": 0.8,
+                "description": "Heated during occupied hours"
+            },
+            "night_setback": {
+                "name": "Night setback",
+                "factor": 0.9,
+                "description": "Temperature setback at night"
+            },
+            "weekend_off": {
+                "name": "Weekend off",
+                "factor": 0.85,
+                "description": "Heating off during weekends"
+            },
+            "vacation_home": {
+                "name": "Vacation home",
+                "factor": 0.6,
+                "description": "Occasionally occupied"
+            }
+        }
+        
+        return occupancy_factors
+
+    def get_material_by_type(self, material_type, material_id):
+        """
+        Get material properties by type and ID.
+        
+        Args:
+            material_type (str): Type of material ('walls', 'roofs', 'floors')
+            material_id (str): ID of the material
+            
+        Returns:
+            dict: Material properties
+        """
+        if material_type in self.materials and material_id in self.materials[material_type]:
+            return self.materials[material_type][material_id]
+        return None
+
+    def get_location_data(self, location_id):
+        """
+        Get climate data for a location.
+        
+        Args:
+            location_id (str): ID of the location
+            
+        Returns:
+            dict: Location climate data
+        """
+        if location_id in self.locations:
+            return self.locations[location_id]
+        return None
+
+    def get_glass_type(self, glass_id):
+        """
+        Get glass type properties.
+        
+        Args:
+            glass_id (str): ID of the glass type
+            
+        Returns:
+            dict: Glass type properties
+        """
+        if glass_id in self.glass_types:
+            return self.glass_types[glass_id]
+        return None
+
+    def get_shading_factor(self, shading_id):
+        """
+        Get shading factor.
+        
+        Args:
+            shading_id (str): ID of the shading type
+            
+        Returns:
+            dict: Shading factor data
+        """
+        if shading_id in self.shading_factors:
+            return self.shading_factors[shading_id]
+        return None
+
+    def get_internal_load(self, load_type, load_id):
+        """
+        Get internal load data.
+        
+        Args:
+            load_type (str): Type of internal load ('people', 'lighting', 'appliances')
+            load_id (str): ID of the internal load
+            
+        Returns:
+            dict: Internal load data
+        """
+        if load_type in self.internal_loads and load_id in self.internal_loads[load_type]:
+            return self.internal_loads[load_type][load_id]
+        return None
+
+    def get_occupancy_factor(self, occupancy_id):
+        """
+        Get occupancy correction factor.
+        
+        Args:
+            occupancy_id (str): ID of the occupancy type
+            
+        Returns:
+            dict: Occupancy correction factor data
+        """
+        if occupancy_id in self.occupancy_factors:
+            return self.occupancy_factors[occupancy_id]
+        return None
+
+    def export_to_json(self, output_dir):
+        """
+        Export all reference data to JSON files.
+        
+        Args:
+            output_dir (str): Directory to save JSON files
+            
+        Returns:
+            bool: True if successful, False otherwise
+        """
+        try:
+            output_path = Path(output_dir)
+            output_path.mkdir(parents=True, exist_ok=True)
+            
+            # Export materials
+            with open(output_path / "materials.json", "w") as f:
+                json.dump(self.materials, f, indent=2)
+            
+            # Export locations
+            with open(output_path / "locations.json", "w") as f:
+                json.dump(self.locations, f, indent=2)
+            
+            # Export glass types
+            with open(output_path / "glass_types.json", "w") as f:
+                json.dump(self.glass_types, f, indent=2)
+            
+            # Export shading factors
+            with open(output_path / "shading_factors.json", "w") as f:
+                json.dump(self.shading_factors, f, indent=2)
+            
+            # Export internal loads
+            with open(output_path / "internal_loads.json", "w") as f:
+                json.dump(self.internal_loads, f, indent=2)
+            
+            # Export occupancy factors
+            with open(output_path / "occupancy_factors.json", "w") as f:
+                json.dump(self.occupancy_factors, f, indent=2)
+            
+            return True
+        except Exception as e:
+            print(f"Error exporting reference data: {e}")
+            return False
+
+
+# Example usage
+if __name__ == "__main__":
+    ref_data = ReferenceData()
+    
+    # Example: Get wall material properties
+    brick_veneer = ref_data.get_material_by_type("walls", "brick_veneer")
+    print("Brick Veneer Wall Properties:", brick_veneer)
+    
+    # Example: Get location climate data
+    sydney_data = ref_data.get_location_data("sydney")
+    print("Sydney Climate Data:", sydney_data)
+    
+    # Example: Export all data to JSON
+    ref_data.export_to_json("reference_data")

requirements.txt

@@ -0,0 +1,4 @@
+pandas==2.0.0
+streamlit==1.32.0
+plotly==5.18.0
+numpy==1.24.3

runtime.txt

@@ -0,0 +1,2 @@
+[build]
+python_version = "3.10"

utils/export.py

@@ -0,0 +1,196 @@
+"""
+Export utilities for HVAC Load Calculator
+
+This module provides functions for exporting data from the HVAC Load Calculator.
+"""
+
+import json
+import csv
+import io
+import pandas as pd
+from datetime import datetime
+
+
+def export_data(form_data, results, format='json'):
+    """
+    Export form data and calculation results.
+    
+    Args:
+        form_data (dict): Form input data
+        results (dict): Calculation results
+        format (str): Export format ('json' or 'csv')
+        
+    Returns:
+        str: Exported data as string
+    """
+    if format == 'json':
+        return export_as_json(form_data, results)
+    elif format == 'csv':
+        return export_as_csv(form_data, results)
+    else:
+        raise ValueError(f"Unsupported export format: {format}")
+
+
+def export_as_json(form_data, results):
+    """
+    Export data as JSON.
+    
+    Args:
+        form_data (dict): Form input data
+        results (dict): Calculation results
+        
+    Returns:
+        str: JSON string
+    """
+    # Combine form data and results
+    export_data = {
+        'form_data': form_data,
+        'results': results,
+        'export_timestamp': datetime.now().isoformat()
+    }
+    
+    # Convert to JSON string
+    return json.dumps(export_data, indent=2)
+
+
+def export_as_csv(form_data, results):
+    """
+    Export data as CSV.
+    
+    Args:
+        form_data (dict): Form input data
+        results (dict): Calculation results
+        
+    Returns:
+        str: CSV string
+    """
+    # Create a buffer for CSV data
+    output = io.StringIO()
+    writer = csv.writer(output)
+    
+    # Write header
+    writer.writerow(['HVAC Load Calculator Results', datetime.now().isoformat()])
+    writer.writerow([])
+    
+    # Write building information
+    writer.writerow(['Building Information'])
+    building_info = form_data.get('building_info', {})
+    for key, value in building_info.items():
+        writer.writerow([key, value])
+    writer.writerow([])
+    
+    # Write calculation results
+    writer.writerow(['Calculation Results'])
+    for key, value in results.items():
+        if key not in ['building_info', 'timestamp'] and not isinstance(value, dict):
+            writer.writerow([key, value])
+    writer.writerow([])
+    
+    # Write load components
+    writer.writerow(['Load Components'])
+    writer.writerow(['Component', 'Load (W)', 'Percentage (%)'])
+    
+    # Calculate percentages
+    sensible_load = results.get('sensible_load', 1)  # Avoid division by zero
+    
+    components = {
+        'Conduction (Opaque Surfaces)': results.get('conduction_gain', 0),
+        'Conduction (Windows)': results.get('window_conduction_gain', 0),
+        'Solar Radiation (Windows)': results.get('window_solar_gain', 0),
+        'Infiltration & Ventilation': results.get('infiltration_gain', 0),
+        'Internal Gains': results.get('internal_gain', 0)
+    }
+    
+    for component, load in components.items():
+        percentage = (load / sensible_load) * 100 if sensible_load > 0 else 0
+        writer.writerow([component, f"{load:.2f}", f"{percentage:.2f}"])
+    
+    # Get CSV content
+    return output.getvalue()
+
+
+def generate_report(form_data, results, calculation_type='cooling'):
+    """
+    Generate a formatted report of calculation results.
+    
+    Args:
+        form_data (dict): Form input data
+        results (dict): Calculation results
+        calculation_type (str): Type of calculation ('cooling' or 'heating')
+        
+    Returns:
+        str: Formatted report as HTML
+    """
+    # Create a DataFrame for the report
+    report_data = []
+    
+    # Add building information
+    building_info = form_data.get('building_info', {})
+    report_data.append({
+        'Section': 'Building Information',
+        'Item': 'Building Name',
+        'Value': building_info.get('building_name', 'N/A')
+    })
+    report_data.append({
+        'Section': 'Building Information',
+        'Item': 'Location',
+        'Value': building_info.get('location_name', 'N/A')
+    })
+    report_data.append({
+        'Section': 'Building Information',
+        'Item': 'Floor Area',
+        'Value': f"{building_info.get('floor_area', 0):.2f} m²"
+    })
+    report_data.append({
+        'Section': 'Building Information',
+        'Item': 'Volume',
+        'Value': f"{building_info.get('volume', 0):.2f} m³"
+    })
+    
+    # Add calculation results
+    if calculation_type == 'cooling':
+        report_data.append({
+            'Section': 'Results',
+            'Item': 'Sensible Cooling Load',
+            'Value': f"{results.get('sensible_load', 0):.2f} W"
+        })
+        report_data.append({
+            'Section': 'Results',
+            'Item': 'Latent Cooling Load',
+            'Value': f"{results.get('latent_load', 0):.2f} W"
+        })
+        report_data.append({
+            'Section': 'Results',
+            'Item': 'Total Cooling Load',
+            'Value': f"{results.get('total_load', 0):.2f} W"
+        })
+        report_data.append({
+            'Section': 'Results',
+            'Item': 'Cooling Load per Area',
+            'Value': f"{results.get('total_load', 0) / building_info.get('floor_area', 1):.2f} W/m²"
+        })
+    else:  # heating
+        report_data.append({
+            'Section': 'Results',
+            'Item': 'Total Heating Load',
+            'Value': f"{results.get('total_load', 0):.2f} W"
+        })
+        report_data.append({
+            'Section': 'Results',
+            'Item': 'Heating Load per Area',
+            'Value': f"{results.get('total_load', 0) / building_info.get('floor_area', 1):.2f} W/m²"
+        })
+        if 'annual_energy_kwh' in results:
+            report_data.append({
+                'Section': 'Results',
+                'Item': 'Annual Heating Energy',
+                'Value': f"{results.get('annual_energy_kwh', 0):.2f} kWh"
+            })
+    
+    # Create DataFrame
+    df = pd.DataFrame(report_data)
+    
+    # Convert to HTML
+    html = df.to_html(index=False)
+    
+    return html

utils/validation.py

@@ -0,0 +1,93 @@
+"""
+Validation utilities for HVAC Load Calculator
+
+This module provides validation functions for input data in the HVAC Load Calculator.
+"""
+
+class ValidationWarning:
+    """
+    A class to represent validation warnings.
+    """
+    
+    def __init__(self, message, suggestion, is_critical=False):
+        """
+        Initialize a validation warning.
+        
+        Args:
+            message (str): Warning message
+            suggestion (str): Suggestion for fixing the warning
+            is_critical (bool): Whether the warning is critical (prevents proceeding)
+        """
+        self.message = message
+        self.suggestion = suggestion
+        self.is_critical = is_critical
+
+
+def validate_input(input_value, validation_type, min_value=None, max_value=None, required=False):
+    """
+    Validate an input value.
+    
+    Args:
+        input_value: Value to validate
+        validation_type (str): Type of validation ('number', 'text', etc.)
+        min_value: Minimum allowed value (for numeric inputs)
+        max_value: Maximum allowed value (for numeric inputs)
+        required (bool): Whether the input is required
+        
+    Returns:
+        tuple: (is_valid, warnings)
+    """
+    warnings = []
+    is_valid = True
+    
+    # Check if required
+    if required and (input_value is None or input_value == "" or (isinstance(input_value, (int, float)) and input_value == 0)):
+        warnings.append(ValidationWarning(
+            "Required field is empty",
+            "Please provide a value for this field",
+            is_critical=True
+        ))
+        is_valid = False
+    
+    # Skip further validation if value is empty and not required
+    if input_value is None or input_value == "":
+        return is_valid, warnings
+    
+    # Validate based on type
+    if validation_type == 'number':
+        try:
+            # Convert to float if it's a string
+            if isinstance(input_value, str):
+                input_value = float(input_value)
+            
+            # Check min value
+            if min_value is not None and input_value < min_value:
+                warnings.append(ValidationWarning(
+                    f"Value is below minimum ({min_value})",
+                    f"Please enter a value greater than or equal to {min_value}",
+                    is_critical=True
+                ))
+                is_valid = False
+            
+            # Check max value
+            if max_value is not None and input_value > max_value:
+                warnings.append(ValidationWarning(
+                    f"Value exceeds maximum ({max_value})",
+                    f"Please enter a value less than or equal to {max_value}",
+                    is_critical=True
+                ))
+                is_valid = False
+        
+        except ValueError:
+            warnings.append(ValidationWarning(
+                "Invalid number format",
+                "Please enter a valid number",
+                is_critical=True
+            ))
+            is_valid = False
+    
+    elif validation_type == 'text':
+        # Add text validation if needed
+        pass
+    
+    return is_valid, warnings