Upload 13 files

cooling_load.py

@@ -36,6 +36,60 @@ class CoolingLoadCalculator:
             float: Heat gain in Watts
         """
         return area * u_value * temp_diff
+        
+    def calculate_wall_solar_heat_gain(self, area, u_value, orientation, daily_range='medium', latitude='medium'):
+        """
+        Calculate solar heat gain through walls based on orientation.
+        
+        Args:
+            area (float): Area of the wall in m²
+            u_value (float): U-value of the wall in W/m²°C
+            orientation (str): Wall orientation ('north', 'east', 'south', 'west')
+            daily_range (str): Daily temperature range ('low', 'medium', 'high')
+            latitude (str): Latitude category ('low', 'medium', 'high')
+            
+        Returns:
+            float: Heat gain in Watts
+        """
+        # Solar intensity factors based on orientation
+        # These are simplified factors for demonstration
+        orientation_factors = {
+            'north': 0.3,
+            'east': 0.7,
+            'south': 0.5,
+            'west': 0.8,
+            'horizontal': 1.0
+        }
+        
+        # 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
+        }
+        
+        # Base solar heat gain through walls (W/m²)
+        base_solar_gain = 15.0
+        
+        # Get factors
+        orientation_factor = orientation_factors.get(orientation.lower(), 0.5)  # Default to south if not found
+        latitude_factor = latitude_factors.get(latitude.lower(), 1.0)
+        range_factor = range_factors.get(daily_range.lower(), 1.0)
+        
+        # Calculate solar heat gain
+        solar_gain = area * base_solar_gain * orientation_factor * latitude_factor * range_factor
+        
+        # Factor in the U-value (walls with higher U-values transmit more solar heat)
+        u_value_factor = min(u_value / 0.5, 2.0)  # Normalize against a typical U-value of 0.5
+        
+        return solar_gain * u_value_factor
 
     def calculate_solar_heat_gain(self, area, shgf, shade_factor=1.0):
         """
@@ -140,7 +194,7 @@ class CoolingLoadCalculator:
         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
+            building_components (list): List of dicts with 'area', 'u_value', 'temp_diff', and 'orientation' 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'
@@ -149,10 +203,24 @@ class CoolingLoadCalculator:
             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
-        )
+        conduction_gain = 0
+        wall_solar_gain = 0
+        
+        for comp in building_components:
+            # Calculate conduction gain
+            conduction_gain += self.calculate_conduction_heat_gain(comp['area'], comp['u_value'], comp['temp_diff'])
+            
+            # Calculate solar gain for walls based on orientation
+            if 'orientation' in comp:
+                daily_range = comp.get('daily_range', 'medium')
+                latitude = comp.get('latitude', 'medium')
+                wall_solar_gain += self.calculate_wall_solar_heat_gain(
+                    comp['area'], 
+                    comp['u_value'], 
+                    comp['orientation'],
+                    daily_range,
+                    latitude
+                )
         
         # Calculate solar and conduction heat gain through windows
         window_conduction_gain = 0
@@ -191,7 +259,7 @@ class CoolingLoadCalculator:
         )
         
         # Calculate sensible cooling load
-        sensible_load = conduction_gain + window_conduction_gain + window_solar_gain + infiltration_gain + internal_gain
+        sensible_load = conduction_gain + window_conduction_gain + window_solar_gain + wall_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
@@ -201,6 +269,7 @@ class CoolingLoadCalculator:
             'conduction_gain': conduction_gain,
             'window_conduction_gain': window_conduction_gain,
             'window_solar_gain': window_solar_gain,
+            'wall_solar_gain': wall_solar_gain,
             'infiltration_gain': infiltration_gain,
             'internal_gain': internal_gain,
             'sensible_load': sensible_load,

heating_load.py

@@ -18,6 +18,10 @@ class HeatingLoadCalculator:
         """Initialize the heating load calculator with default values."""
         # Specific heat capacity of air × density of air
         self.air_heat_factor = 0.33
+        
+        # Default values for internal heat gains (W)
+        self.heat_gain_per_person = 75
+        self.heat_gain_kitchen = 1000
 
     def calculate_conduction_heat_loss(self, area, u_value, temp_diff):
         """
@@ -32,6 +36,61 @@ class HeatingLoadCalculator:
             float: Heat loss in Watts
         """
         return area * u_value * temp_diff
+        
+    def calculate_wall_solar_heat_gain(self, area, u_value, orientation, daily_range='medium', latitude='medium'):
+        """
+        Calculate solar heat gain through walls based on orientation.
+        
+        Args:
+            area (float): Area of the wall in m²
+            u_value (float): U-value of the wall in W/m²°C
+            orientation (str): Wall orientation ('north', 'east', 'south', 'west')
+            daily_range (str): Daily temperature range ('low', 'medium', 'high')
+            latitude (str): Latitude category ('low', 'medium', 'high')
+            
+        Returns:
+            float: Heat gain in Watts
+        """
+        # Solar intensity factors based on orientation - for heating, south-facing walls (northern hemisphere)
+        # or north-facing walls (southern hemisphere) receive more solar gain in winter
+        # These are simplified factors for demonstration
+        orientation_factors = {
+            'north': 0.6,  # Higher in southern hemisphere during winter
+            'east': 0.4,
+            'south': 0.2,  # Lower in southern hemisphere during winter
+            'west': 0.4,
+            'horizontal': 0.3
+        }
+        
+        # Adjustments for latitude
+        latitude_factors = {
+            'low': 0.9,    # Closer to equator - less winter sun angle
+            'medium': 1.0,  # Mid latitudes
+            'high': 1.1     # Closer to poles - more winter sun angle variation
+        }
+        
+        # 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
+        }
+        
+        # Base solar heat gain through walls (W/m²) - lower in winter
+        base_solar_gain = 10.0
+        
+        # Get factors
+        orientation_factor = orientation_factors.get(orientation.lower(), 0.5)  # Default to south if not found
+        latitude_factor = latitude_factors.get(latitude.lower(), 1.0)
+        range_factor = range_factors.get(daily_range.lower(), 1.0)
+        
+        # Calculate solar heat gain
+        solar_gain = area * base_solar_gain * orientation_factor * latitude_factor * range_factor
+        
+        # Factor in the U-value (walls with higher U-values transmit more solar heat)
+        u_value_factor = min(u_value / 0.5, 2.0)  # Normalize against a typical U-value of 0.5
+        
+        return solar_gain * u_value_factor
 
     def calculate_infiltration_heat_loss(self, volume, air_changes, temp_diff):
         """
@@ -46,6 +105,22 @@ class HeatingLoadCalculator:
             float: Heat loss 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 calculate_annual_heating_energy(self, total_heat_loss, heating_degree_days, correction_factor=1.0):
         """
@@ -146,13 +221,14 @@ class HeatingLoadCalculator:
         
         return factors.get(occupancy_type.lower(), 1.0)  # Default to continuous if not found
 
-    def calculate_total_heating_load(self, building_components, infiltration):
+    def calculate_total_heating_load(self, building_components, infiltration, internal_gains=None):
         """
         Calculate the total peak heating load.
         
         Args:
-            building_components (list): List of dicts with 'area', 'u_value', and 'temp_diff' for each component
+            building_components (list): List of dicts with 'area', 'u_value', 'temp_diff', and 'orientation' for each component
             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 component heat losses and total heating load in Watts
@@ -160,25 +236,50 @@ class HeatingLoadCalculator:
         # Calculate conduction heat loss through building components
         component_losses = {}
         total_conduction_loss = 0
+        wall_solar_gain = 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 solar gain for walls based on orientation
+            if 'orientation' in comp:
+                daily_range = comp.get('daily_range', 'medium')
+                latitude = comp.get('latitude', 'medium')
+                solar_gain = self.calculate_wall_solar_heat_gain(
+                    comp['area'], 
+                    comp['u_value'], 
+                    comp['orientation'],
+                    daily_range,
+                    latitude
+                )
+                wall_solar_gain += solar_gain
         
         # 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
+        # Calculate internal heat gain if provided
+        internal_gain = 0
+        if internal_gains:
+            internal_gain = self.calculate_internal_heat_gain(
+                internal_gains.get('num_people', 0),
+                internal_gains.get('has_kitchen', False),
+                internal_gains.get('equipment_watts', 0)
+            )
+        
+        # Calculate total heating load (subtract solar gain and internal gains as they reduce heating load)
+        total_load = total_conduction_loss + infiltration_loss - wall_solar_gain - internal_gain
         
         return {
             'component_losses': component_losses,
             'total_conduction_loss': total_conduction_loss,
             'infiltration_loss': infiltration_loss,
+            'wall_solar_gain': wall_solar_gain,
+            'internal_gain': internal_gain,
             'total_load': total_load
         }
 

pages/cooling_calculator.py

@@ -210,7 +210,7 @@ def building_info_form(ref_data):
         warnings.append(ValidationWarning(
             "Invalid temperature difference",
             "Outdoor temperature should be higher than indoor temperature for cooling load calculation",
-            is_critical=True
+            is_critical=False  # Changed to non-critical to allow proceeding with warnings
         ))
     
     # Check if dimensions are reasonable
@@ -289,14 +289,18 @@ def building_envelope_form(ref_data):
     
     # 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()}
+    # Add custom option
+    wall_material_options["custom_walls"] = "Custom Wall (User-defined)"
     
     # 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)']
+        # Add orientation column with default value if not present
+        walls_df['orientation'] = walls_df['orientation'].fillna('not specified')
+        walls_df = walls_df[['name', 'Material', 'area', 'u_value', 'orientation']]
+        walls_df.columns = ['Name', 'Material', 'Area (m²)', 'U-Value (W/m²°C)', 'Orientation']
         st.dataframe(walls_df)
     
     # Add new wall form
@@ -313,10 +317,39 @@ def building_envelope_form(ref_data):
             key="new_wall_material"
         )
         
+        # Add wall orientation selection
+        wall_orientation = st.selectbox(
+            "Wall Orientation",
+            options=["north", "east", "south", "west"],
+            key="new_wall_orientation"
+        )
+        
         # Get material properties
         material_data = ref_data.get_material_by_type("walls", wall_material)
         u_value = material_data['u_value']
         
+        # Add custom U-value input if custom material is selected
+        if wall_material == "custom_walls":
+            u_value = st.number_input(
+                "Custom U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="custom_wall_u_value"
+            )
+            
+            # Store custom material in session state
+            if "custom_materials" not in st.session_state:
+                st.session_state.custom_materials = {}
+            
+            st.session_state.custom_materials["walls"] = {
+                "name": "Custom Wall",
+                "u_value": u_value,
+                "r_value": 1.0 / u_value if u_value > 0 else 1.0,
+                "description": "Custom wall with user-defined properties"
+            }
+        
     with col2:
         wall_area = st.number_input(
             "Wall Area (m²)",
@@ -336,7 +369,8 @@ def building_envelope_form(ref_data):
             'material_id': wall_material,
             'area': wall_area,
             'u_value': u_value,
-            'temp_diff': temp_diff
+            'temp_diff': temp_diff,
+            'orientation': wall_orientation  # Add orientation to wall data
         }
         st.session_state.cooling_form_data['building_envelope']['walls'].append(new_wall)
         st.experimental_rerun()
@@ -346,6 +380,8 @@ def building_envelope_form(ref_data):
     
     # 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()}
+    # Add custom option
+    roof_material_options["custom_roofs"] = "Custom Roof (User-defined)"
     
     col1, col2 = st.columns(2)
     
@@ -361,6 +397,28 @@ def building_envelope_form(ref_data):
         material_data = ref_data.get_material_by_type("roofs", roof_material)
         roof_u_value = material_data['u_value']
         
+        # Add custom U-value input if custom material is selected
+        if roof_material == "custom_roofs":
+            roof_u_value = st.number_input(
+                "Custom Roof U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="custom_roof_u_value"
+            )
+            
+            # Store custom material in session state
+            if "custom_materials" not in st.session_state:
+                st.session_state.custom_materials = {}
+            
+            st.session_state.custom_materials["roofs"] = {
+                "name": "Custom Roof",
+                "u_value": roof_u_value,
+                "r_value": 1.0 / roof_u_value if roof_u_value > 0 else 1.0,
+                "description": "Custom roof with user-defined properties"
+            }
+        
     with col2:
         roof_area = st.number_input(
             "Roof Area (m²)",
@@ -385,6 +443,8 @@ def building_envelope_form(ref_data):
     
     # 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()}
+    # Add custom option
+    floor_material_options["custom_floors"] = "Custom Floor (User-defined)"
     
     col1, col2 = st.columns(2)
     
@@ -400,6 +460,28 @@ def building_envelope_form(ref_data):
         material_data = ref_data.get_material_by_type("floors", floor_material)
         floor_u_value = material_data['u_value']
         
+        # Add custom U-value input if custom material is selected
+        if floor_material == "custom_floors":
+            floor_u_value = st.number_input(
+                "Custom Floor U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="custom_floor_u_value"
+            )
+            
+            # Store custom material in session state
+            if "custom_materials" not in st.session_state:
+                st.session_state.custom_materials = {}
+            
+            st.session_state.custom_materials["floors"] = {
+                "name": "Custom Floor",
+                "u_value": floor_u_value,
+                "r_value": 1.0 / floor_u_value if floor_u_value > 0 else 1.0,
+                "description": "Custom floor with user-defined properties"
+            }
+        
     with col2:
         floor_area = st.number_input(
             "Floor Area (m²)",
@@ -427,7 +509,7 @@ def building_envelope_form(ref_data):
         warnings.append(ValidationWarning(
             "No walls defined",
             "Add at least one wall to continue",
-            is_critical=True
+            is_critical=False  # Changed to non-critical to allow proceeding with warnings
         ))
     
     # Check if total wall area is reasonable
@@ -1249,7 +1331,26 @@ def results_page():
         values=list(load_components.values()),
         names=list(load_components.keys()),
         title="Cooling Load Components",
-        color_discrete_sequence=px.colors.qualitative.Set2
+        color_discrete_sequence=px.colors.sequential.Turbo,
+        hole=0.4,  # Create a donut chart for better readability
+        labels={'label': 'Component', 'value': 'Heat Gain (W)'}
+    )
+    
+    # Improve layout and formatting
+    fig.update_traces(
+        textposition='inside',
+        textinfo='percent+label',
+        hoverinfo='label+percent+value',
+        marker=dict(line=dict(color='#FFFFFF', width=2))
+    )
+    
+    # Improve layout
+    fig.update_layout(
+        legend_title_text='Load Components',
+        font=dict(size=14),
+        title_font=dict(size=18),
+        title_x=0.5,  # Center the title
+        margin=dict(t=50, b=50, l=50, r=50)
     )
     
     st.plotly_chart(fig)
@@ -1261,10 +1362,13 @@ def results_page():
         'Percentage (%)': [value / results['sensible_load'] * 100 for value in load_components.values()]
     })
     
+    # Sort by load value for better readability
+    load_df = load_df.sort_values(by='Load (W)', ascending=False).reset_index(drop=True)
+    
     st.dataframe(load_df.style.format({
         'Load (W)': '{:.2f}',
         'Percentage (%)': '{:.2f}'
-    }))
+    }).background_gradient(cmap='Blues', subset=['Percentage (%)']))
     
     # Display detailed results
     st.write("### Detailed Results")
@@ -1384,21 +1488,38 @@ def results_page():
                 x=windows_df['Component'],
                 y=windows_df['Conduction Heat Gain (W)'],
                 name='Conduction Heat Gain',
-                marker_color='indianred'
+                marker_color='#1f77b4',
+                text=windows_df['Conduction Heat Gain (W)'].round(1),
+                textposition='auto',
+                hovertemplate='<b>%{x}</b><br>Conduction Heat Gain: %{y:.1f} W<extra></extra>'
             ))
             
             fig.add_trace(go.Bar(
                 x=windows_df['Component'],
                 y=windows_df['Solar Heat Gain (W)'],
                 name='Solar Heat Gain',
-                marker_color='lightsalmon'
+                marker_color='#ff7f0e',
+                text=windows_df['Solar Heat Gain (W)'].round(1),
+                textposition='auto',
+                hovertemplate='<b>%{x}</b><br>Solar Heat Gain: %{y:.1f} W<extra></extra>'
             ))
             
             fig.update_layout(
                 title="Window Heat Gains",
                 xaxis_title="Window",
                 yaxis_title="Heat Gain (W)",
-                barmode='stack'
+                barmode='stack',
+                font=dict(size=14),
+                title_font=dict(size=18),
+                title_x=0.5,  # Center the title
+                margin=dict(t=50, b=50, l=50, r=50),
+                legend=dict(
+                    orientation="h",
+                    yanchor="bottom",
+                    y=1.02,
+                    xanchor="right",
+                    x=1
+                )
             )
             
             st.plotly_chart(fig)
@@ -1606,6 +1727,42 @@ def cooling_calculator():
         "6. Results"
     ])
     
+    # Add direct navigation buttons at the top
+    st.write("### Navigation")
+    st.write("Click on any button below to navigate directly to that section:")
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        if st.button("1. Building Information", key="direct_nav_building_info"):
+            st.session_state.cooling_active_tab = "building_info"
+            st.experimental_rerun()
+        
+        if st.button("2. Building Envelope", key="direct_nav_building_envelope"):
+            st.session_state.cooling_active_tab = "building_envelope"
+            st.experimental_rerun()
+    
+    with col2:
+        if st.button("3. Windows & Doors", key="direct_nav_windows"):
+            st.session_state.cooling_active_tab = "windows"
+            st.experimental_rerun()
+        
+        if st.button("4. Internal Loads", key="direct_nav_internal_loads"):
+            st.session_state.cooling_active_tab = "internal_loads"
+            st.experimental_rerun()
+    
+    with col3:
+        if st.button("5. Ventilation", key="direct_nav_ventilation"):
+            st.session_state.cooling_active_tab = "ventilation"
+            st.experimental_rerun()
+        
+        if st.button("6. Results", key="direct_nav_results"):
+            # Only enable if all previous steps are completed
+            if all(st.session_state.cooling_completed.values()):
+                st.session_state.cooling_active_tab = "results"
+                st.experimental_rerun()
+            else:
+                st.warning("Please complete all previous steps before viewing results.")
+    
     # Display the active tab
     with tabs[0]:
         if st.session_state.cooling_active_tab == "building_info":

pages/heating_calculator.py

@@ -195,7 +195,7 @@ def building_info_form(ref_data):
         warnings.append(ValidationWarning(
             "Invalid temperature difference",
             "Indoor temperature should be higher than outdoor temperature for heating load calculation",
-            is_critical=True
+            is_critical=False  # Changed to non-critical to allow proceeding with warnings
         ))
     
     # Check if dimensions are reasonable
@@ -274,14 +274,18 @@ def building_envelope_form(ref_data):
     
     # 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()}
+    # Add custom option
+    wall_material_options["custom_walls"] = "Custom Wall (User-defined)"
     
     # 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)']
+        # Add orientation column with default value if not present
+        walls_df['orientation'] = walls_df['orientation'].fillna('not specified')
+        walls_df = walls_df[['name', 'Material', 'area', 'u_value', 'orientation']]
+        walls_df.columns = ['Name', 'Material', 'Area (m²)', 'U-Value (W/m²°C)', 'Orientation']
         st.dataframe(walls_df)
     
     # Add new wall form
@@ -298,10 +302,39 @@ def building_envelope_form(ref_data):
             key="new_wall_material_heating"
         )
         
+        # Add wall orientation selection
+        wall_orientation = st.selectbox(
+            "Wall Orientation",
+            options=["north", "east", "south", "west"],
+            key="new_wall_orientation_heating"
+        )
+        
         # Get material properties
         material_data = ref_data.get_material_by_type("walls", wall_material)
         u_value = material_data['u_value']
         
+        # Add custom U-value input if custom material is selected
+        if wall_material == "custom_walls":
+            u_value = st.number_input(
+                "Custom U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="custom_wall_u_value_heating"
+            )
+            
+            # Store custom material in session state
+            if "custom_materials" not in st.session_state:
+                st.session_state.custom_materials = {}
+            
+            st.session_state.custom_materials["walls"] = {
+                "name": "Custom Wall",
+                "u_value": u_value,
+                "r_value": 1.0 / u_value if u_value > 0 else 1.0,
+                "description": "Custom wall with user-defined properties"
+            }
+        
     with col2:
         wall_area = st.number_input(
             "Wall Area (m²)",
@@ -321,7 +354,8 @@ def building_envelope_form(ref_data):
             'material_id': wall_material,
             'area': wall_area,
             'u_value': u_value,
-            'temp_diff': temp_diff
+            'temp_diff': temp_diff,
+            'orientation': wall_orientation  # Add orientation to wall data
         }
         st.session_state.heating_form_data['building_envelope']['walls'].append(new_wall)
         st.experimental_rerun()
@@ -331,6 +365,8 @@ def building_envelope_form(ref_data):
     
     # 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()}
+    # Add custom option
+    roof_material_options["custom_roofs"] = "Custom Roof (User-defined)"
     
     col1, col2 = st.columns(2)
     
@@ -346,6 +382,28 @@ def building_envelope_form(ref_data):
         material_data = ref_data.get_material_by_type("roofs", roof_material)
         roof_u_value = material_data['u_value']
         
+        # Add custom U-value input if custom material is selected
+        if roof_material == "custom_roofs":
+            roof_u_value = st.number_input(
+                "Custom Roof U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="custom_roof_u_value_heating"
+            )
+            
+            # Store custom material in session state
+            if "custom_materials" not in st.session_state:
+                st.session_state.custom_materials = {}
+            
+            st.session_state.custom_materials["roofs"] = {
+                "name": "Custom Roof",
+                "u_value": roof_u_value,
+                "r_value": 1.0 / roof_u_value if roof_u_value > 0 else 1.0,
+                "description": "Custom roof with user-defined properties"
+            }
+        
     with col2:
         roof_area = st.number_input(
             "Roof Area (m²)",
@@ -371,6 +429,8 @@ def building_envelope_form(ref_data):
     
     # 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()}
+    # Add custom option
+    floor_material_options["custom_floors"] = "Custom Floor (User-defined)"
     
     col1, col2 = st.columns(2)
     
@@ -386,6 +446,28 @@ def building_envelope_form(ref_data):
         material_data = ref_data.get_material_by_type("floors", floor_material)
         floor_u_value = material_data['u_value']
         
+        # Add custom U-value input if custom material is selected
+        if floor_material == "custom_floors":
+            floor_u_value = st.number_input(
+                "Custom Floor U-Value (W/m²°C)",
+                value=1.0,
+                min_value=0.1,
+                max_value=5.0,
+                step=0.1,
+                key="custom_floor_u_value_heating"
+            )
+            
+            # Store custom material in session state
+            if "custom_materials" not in st.session_state:
+                st.session_state.custom_materials = {}
+            
+            st.session_state.custom_materials["floors"] = {
+                "name": "Custom Floor",
+                "u_value": floor_u_value,
+                "r_value": 1.0 / floor_u_value if floor_u_value > 0 else 1.0,
+                "description": "Custom floor with user-defined properties"
+            }
+        
     with col2:
         floor_area = st.number_input(
             "Floor Area (m²)",
@@ -414,7 +496,7 @@ def building_envelope_form(ref_data):
         warnings.append(ValidationWarning(
             "No walls defined",
             "Add at least one wall to continue",
-            is_critical=True
+            is_critical=False  # Changed to non-critical to allow proceeding with warnings
         ))
     
     # Check if total wall area is reasonable
@@ -684,6 +766,30 @@ def ventilation_form(ref_data):
             'air_changes': 0.0
         }
     
+    # Initialize internal loads data if not already in session state
+    if 'internal_loads' not in st.session_state.heating_form_data:
+        st.session_state.heating_form_data['internal_loads'] = {}
+    
+    if 'occupants' not in st.session_state.heating_form_data['internal_loads']:
+        st.session_state.heating_form_data['internal_loads']['occupants'] = {
+            'count': 4,
+            'activity_level': 'seated_resting'
+        }
+    
+    if 'lighting' not in st.session_state.heating_form_data['internal_loads']:
+        st.session_state.heating_form_data['internal_loads']['lighting'] = {
+            'type': 'led',
+            'power_density': 5.0  # W/m²
+        }
+    
+    if 'appliances' not in st.session_state.heating_form_data['internal_loads']:
+        st.session_state.heating_form_data['internal_loads']['appliances'] = {
+            'kitchen': True,
+            'living_room': True,
+            'bedroom': True,
+            'office': False
+        }
+    
     # Infiltration section
     st.write("### Infiltration")
     st.write("Infiltration is the unintended air leakage through the building envelope.")
@@ -715,6 +821,172 @@ def ventilation_form(ref_data):
     st.write("### Ventilation")
     st.write("Ventilation is the intentional introduction of outside air into the building.")
     
+    # Internal Loads section
+    st.write("### Internal Loads")
+    st.write("Internal loads are heat sources inside the building that reduce heating requirements.")
+    
+    # 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.heating_form_data['internal_loads']['occupants'].get('count', 4)),
+            min_value=1,
+            step=1,
+            key="occupant_count_heating"
+        )
+    
+    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.heating_form_data['internal_loads']['occupants'].get('activity_level', 'seated_resting')) if st.session_state.heating_form_data['internal_loads']['occupants'].get('activity_level') in activity_options else 0,
+            key="activity_level_heating"
+        )
+    
+    # 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.heating_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.heating_form_data['internal_loads']['lighting'].get('type', 'led')) if st.session_state.heating_form_data['internal_loads']['lighting'].get('type') in lighting_options else 0,
+            key="lighting_type_heating"
+        )
+    
+    with col2:
+        lighting_power_density = st.number_input(
+            "Lighting Power Density (W/m²)",
+            value=float(st.session_state.heating_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²",
+            key="lighting_power_density_heating"
+        )
+    
+    # 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.heating_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.heating_form_data['internal_loads']['lighting'] = {
+        'type': lighting_type,
+        'power_density': lighting_power_density,
+        'heat_factor': lighting_heat_factor,
+        'total_heat_gain': lighting_heat_gain
+    }
+    
+    # Equipment section
+    st.write("#### Equipment")
+    st.write("Select the equipment present in your space:")
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        has_kitchen = st.checkbox(
+            "Kitchen Appliances",
+            value=st.session_state.heating_form_data['internal_loads']['appliances'].get('kitchen', True),
+            help="Refrigerator, stove, microwave, etc.",
+            key="has_kitchen_heating"
+        )
+        
+        has_living_room = st.checkbox(
+            "Living Room Equipment",
+            value=st.session_state.heating_form_data['internal_loads']['appliances'].get('living_room', True),
+            help="TV, audio equipment, etc.",
+            key="has_living_room_heating"
+        )
+    
+    with col2:
+        has_bedroom = st.checkbox(
+            "Bedroom Equipment",
+            value=st.session_state.heating_form_data['internal_loads']['appliances'].get('bedroom', True),
+            help="TV, chargers, etc.",
+            key="has_bedroom_heating"
+        )
+        
+        has_office = st.checkbox(
+            "Office Equipment",
+            value=st.session_state.heating_form_data['internal_loads']['appliances'].get('office', False),
+            help="Computer, printer, etc.",
+            key="has_office_heating"
+        )
+    
+    # Calculate equipment heat gain
+    equipment_watts = 0
+    
+    if has_kitchen:
+        equipment_watts += 1000  # Kitchen appliances
+    if has_living_room:
+        equipment_watts += 300   # Living room equipment
+    if has_bedroom:
+        equipment_watts += 150   # Bedroom equipment
+    if has_office:
+        equipment_watts += 450   # Office equipment
+    
+    st.write(f"Total equipment heat gain: {equipment_watts} W")
+    
+    # Save appliances data
+    st.session_state.heating_form_data['internal_loads']['appliances'] = {
+        'kitchen': has_kitchen,
+        'living_room': has_living_room,
+        'bedroom': has_bedroom,
+        'office': has_office,
+        'total_heat_gain': equipment_watts
+    }
+    
+    # Calculate total internal heat gain
+    total_internal_gain = (
+        st.session_state.heating_form_data['internal_loads']['occupants']['total_heat_gain'] +
+        st.session_state.heating_form_data['internal_loads']['lighting']['total_heat_gain'] +
+        st.session_state.heating_form_data['internal_loads']['appliances']['total_heat_gain']
+    )
+    
+    st.write(f"Total internal heat gain: {total_internal_gain:.2f} W")
+    
+    # Save total internal gain
+    st.session_state.heating_form_data['internal_loads']['total_heat_gain'] = total_internal_gain
+    
     col1, col2 = st.columns(2)
     
     with col1:
@@ -1016,10 +1288,20 @@ def calculate_heating_load():
         'temp_diff': infiltration.get('temp_diff', 0)
     }
     
+    # Prepare internal loads data
+    internal_loads = None
+    if 'internal_loads' in form_data:
+        internal_loads = {
+            'num_people': form_data['internal_loads']['occupants'].get('count', 0),
+            'has_kitchen': form_data['internal_loads']['appliances'].get('kitchen', False),
+            'equipment_watts': form_data['internal_loads']['appliances'].get('total_heat_gain', 0)
+        }
+    
     # Calculate heating load
     results = calculator.calculate_total_heating_load(
         building_components=building_components,
-        infiltration=infiltration_data
+        infiltration=infiltration_data,
+        internal_gains=internal_loads
     )
     
     # Calculate annual heating requirement
@@ -1102,7 +1384,26 @@ def results_page():
         values=list(component_losses.values()),
         names=list(component_losses.keys()),
         title="Heating Load Components",
-        color_discrete_sequence=px.colors.qualitative.Set2
+        color_discrete_sequence=px.colors.sequential.Viridis,
+        hole=0.4,  # Create a donut chart for better readability
+        labels={'label': 'Component', 'value': 'Heat Loss (W)'}
+    )
+    
+    # Improve layout and formatting
+    fig.update_traces(
+        textposition='inside',
+        textinfo='percent+label',
+        hoverinfo='label+percent+value',
+        marker=dict(line=dict(color='#FFFFFF', width=2))
+    )
+    
+    # Improve layout
+    fig.update_layout(
+        legend_title_text='Building Components',
+        font=dict(size=14),
+        title_font=dict(size=18),
+        title_x=0.5,  # Center the title
+        margin=dict(t=50, b=50, l=50, r=50)
     )
     
     st.plotly_chart(fig)
@@ -1113,10 +1414,17 @@ def results_page():
         'Infiltration & Ventilation': results.get('infiltration_loss', 0)
     }
     
+    # Add internal gains and solar gains if available
+    if 'internal_gain' in results and results['internal_gain'] > 0:
+        load_components['Internal Gains (reduction)'] = -results['internal_gain']
+    
+    if 'wall_solar_gain' in results and results['wall_solar_gain'] > 0:
+        load_components['Solar Gains (reduction)'] = -results['wall_solar_gain']
+    
     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()]
+        'Percentage (%)': [abs(value) / results['total_load'] * 100 for value in load_components.values()]
     })
     
     st.dataframe(load_df.style.format({
@@ -1200,7 +1508,26 @@ def results_page():
             y='Heat Loss (W)',
             title="Heat Loss by Building Component",
             color='Component',
-            color_discrete_sequence=px.colors.qualitative.Set3
+            color_discrete_sequence=px.colors.sequential.Viridis,
+            text='Heat Loss (W)'
+        )
+        
+        # Improve layout and formatting
+        fig.update_traces(
+            texttemplate='%{text:.1f} W',
+            textposition='outside',
+            hovertemplate='<b>%{x}</b><br>Heat Loss: %{y:.1f} W<extra></extra>'
+        )
+        
+        # Improve layout
+        fig.update_layout(
+            xaxis_title="Building Component",
+            yaxis_title="Heat Loss (W)",
+            font=dict(size=14),
+            title_font=dict(size=18),
+            title_x=0.5,  # Center the title
+            margin=dict(t=50, b=50, l=50, r=50),
+            xaxis={'categoryorder':'total descending'}  # Sort by highest heat loss
         )
         
         st.plotly_chart(fig)
@@ -1244,7 +1571,28 @@ def results_page():
             y='Heat Loss (W)',
             title="Ventilation & Infiltration Heat Losses",
             color='Source',
-            color_discrete_sequence=px.colors.qualitative.Pastel2
+            color_discrete_sequence=px.colors.sequential.Plasma,
+            text='Heat Loss (W)'
+        )
+        
+        # Improve layout and formatting
+        fig.update_traces(
+            texttemplate='%{text:.1f} W',
+            textposition='outside',
+            hovertemplate='<b>%{x}</b><br>Heat Loss: %{y:.1f} W<br>Air Changes: %{customdata[0]:.2f} ACH<extra></extra>'
+        )
+        
+        # Add custom data for hover
+        fig.update_traces(customdata=ventilation_df[['Air Changes per Hour']])
+        
+        # Improve layout
+        fig.update_layout(
+            xaxis_title="Ventilation Source",
+            yaxis_title="Heat Loss (W)",
+            font=dict(size=14),
+            title_font=dict(size=18),
+            title_x=0.5,  # Center the title
+            margin=dict(t=50, b=50, l=50, r=50)
         )
         
         st.plotly_chart(fig)
@@ -1405,6 +1753,42 @@ def heating_calculator():
         "6. Results"
     ])
     
+    # Add direct navigation buttons at the top
+    st.write("### Navigation")
+    st.write("Click on any button below to navigate directly to that section:")
+    
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        if st.button("1. Building Information", key="direct_nav_heating_info"):
+            st.session_state.heating_active_tab = "building_info"
+            st.experimental_rerun()
+        
+        if st.button("2. Building Envelope", key="direct_nav_heating_envelope"):
+            st.session_state.heating_active_tab = "building_envelope"
+            st.experimental_rerun()
+    
+    with col2:
+        if st.button("3. Windows & Doors", key="direct_nav_heating_windows"):
+            st.session_state.heating_active_tab = "windows"
+            st.experimental_rerun()
+        
+        if st.button("4. Ventilation", key="direct_nav_heating_ventilation"):
+            st.session_state.heating_active_tab = "ventilation"
+            st.experimental_rerun()
+    
+    with col3:
+        if st.button("5. Occupancy", key="direct_nav_heating_occupancy"):
+            st.session_state.heating_active_tab = "occupancy"
+            st.experimental_rerun()
+        
+        if st.button("6. Results", key="direct_nav_heating_results"):
+            # Only enable if all previous steps are completed
+            if all(st.session_state.heating_completed.values()):
+                st.session_state.heating_active_tab = "results"
+                st.experimental_rerun()
+            else:
+                st.warning("Please complete all previous steps before viewing results.")
+    
     # Display the active tab
     with tabs[0]:
         if st.session_state.heating_active_tab == "building_info":

reference_data.py

@@ -481,6 +481,21 @@ class ReferenceData:
         Returns:
             dict: Material properties
         """
+        # Check if this is a custom material (custom_[type])
+        if material_id == f"custom_{material_type}":
+            # Return the custom material from session state if available
+            import streamlit as st
+            if "custom_materials" in st.session_state and material_type in st.session_state.custom_materials:
+                return st.session_state.custom_materials[material_type]
+            # Return a default custom material template if not in session state
+            return {
+                "name": f"Custom {material_type[:-1]}",  # Remove 's' from end
+                "u_value": 1.0,  # Default U-value
+                "r_value": 1.0,  # Default R-value
+                "description": f"Custom {material_type[:-1]} with user-defined properties"
+            }
+        
+        # Return predefined material
         if material_type in self.materials and material_id in self.materials[material_type]:
             return self.materials[material_type][material_id]
         return None

utils/validation.py

@@ -45,7 +45,7 @@ def validate_input(input_value, validation_type, min_value=None, max_value=None,
         warnings.append(ValidationWarning(
             "Required field is empty",
             "Please provide a value for this field",
-            is_critical=True
+            is_critical=True  # Keep required fields as critical
         ))
         is_valid = False
     
@@ -65,7 +65,7 @@ def validate_input(input_value, validation_type, min_value=None, max_value=None,
                 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_critical=False  # Changed to non-critical
                 ))
                 is_valid = False
             
@@ -74,7 +74,7 @@ def validate_input(input_value, validation_type, min_value=None, max_value=None,
                 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_critical=False  # Changed to non-critical
                 ))
                 is_valid = False
         
@@ -82,7 +82,7 @@ def validate_input(input_value, validation_type, min_value=None, max_value=None,
             warnings.append(ValidationWarning(
                 "Invalid number format",
                 "Please enter a valid number",
-                is_critical=True
+                is_critical=True  # Keep format validation as critical
             ))
             is_valid = False