Upload main.py

app/main.py

@@ -1,7 +1,7 @@
 """
 HVAC Calculator Code Documentation
-Updated 2025-04-27: Enhanced climate ID generation, input validation, debug mode, and error handling.
-Updated 2025-04-28: Added activity-level-based internal gains, ground temperature validation, ASHRAE 62.1 ventilation rates, negative load prevention, and improved usability.
+Updated 2025-05-02: Integrated skylights, surface color, glazing type, frame type, and drapery adjustments from main_new.py.
+Updated 2025-05-02: Enhanced per Plan.txt to include winter design temperature, humidity, building height, ventilation rate, internal load enhancements, and calculation parameters.
 """
 
 import streamlit as st
@@ -13,10 +13,11 @@ import pycountry
 import os
 import sys
 from typing import Dict, List, Any, Optional, Tuple
+import uuid
 
 # Import application modules
 from app.building_info_form import BuildingInfoForm
-from app.component_selection import ComponentSelectionInterface, Orientation, ComponentType, Wall, Roof, Floor, Window, Door
+from app.component_selection import ComponentSelectionInterface, Orientation, ComponentType, Wall, Roof, Floor, Window, Door, Skylight, SurfaceColor, GlazingType, FrameType
 from app.results_display import ResultsDisplay
 from app.data_validation import DataValidation
 from app.data_persistence import DataPersistence
@@ -26,7 +27,7 @@ from app.data_export import DataExport
 from data.reference_data import ReferenceData
 from data.climate_data import ClimateData, ClimateLocation
 from data.ashrae_tables import ASHRAETables
-from data.building_components import Wall as WallModel, Roof as RoofModel
+from data.building_components import Wall as WallModel, Roof as RoofModel, Skylight as SkylightModel
 
 # Import utility modules
 from utils.u_value_calculator import UValueCalculator
@@ -40,6 +41,7 @@ from utils.component_visualization import ComponentVisualization
 from utils.scenario_comparison import ScenarioComparisonVisualization
 from utils.psychrometric_visualization import PsychrometricVisualization
 from utils.time_based_visualization import TimeBasedVisualization
+from utils.drapery import DraperySystem  # NEW: Drapery adjustments
 
 # NEW: ASHRAE 62.1 Ventilation Rates (Table 6.1)
 VENTILATION_RATES = {
@@ -72,7 +74,8 @@ class HVACCalculator:
                 'roofs': [],
                 'floors': [],
                 'windows': [],
-                'doors': []
+                'doors': [],
+                'skylights': []  # NEW: Added skylights
             }
         
         if 'internal_loads' not in st.session_state:
@@ -106,6 +109,7 @@ class HVACCalculator:
         self.data_export = DataExport()
         self.cooling_calculator = CoolingLoadCalculator()
         self.heating_calculator = HeatingLoadCalculator()
+        self.drapery_system = DraperySystem()  # NEW: Drapery system
         
         # Persist ClimateData in session_state
         if 'climate_data_obj' not in st.session_state:
@@ -145,7 +149,7 @@ class HVACCalculator:
         
         st.sidebar.markdown("---")
         st.sidebar.info(
-            "HVAC Load Calculator v1.0.1\n\n"
+            "HVAC Load Calculator v1.0.2\n\n"
             "Based on ASHRAE steady-state calculation methods\n\n"
             "Developed by: Dr Majed Abuseif\n\n"
             "School of Architecture and Built Environment\n\n"
@@ -187,36 +191,53 @@ class HVACCalculator:
         # Check building info
         if not building_info.get('floor_area', 0) > 0:
             return False, "Floor area must be positive."
-        if not any(components.get(key, []) for key in ['walls', 'roofs', 'windows']):
-            return False, "At least one wall, roof, or window must be defined."
+        if not any(components.get(key, []) for key in ['walls', 'roofs', 'windows', 'skylights']):
+            return False, "At least one wall, roof, window, or skylight must be defined."
         
-        # NEW: Validate climate data using climate_data.py
+        # Validate climate data using climate_data.py
         if not climate_data:
             return False, "Climate data is missing."
         if not self.climate_data.validate_climate_data(climate_data):
             return False, "Invalid climate data format or values."
         
         # Validate components
-        for component_type in ['walls', 'roofs', 'windows', 'doors', 'floors']:
+        for component_type in ['walls', 'roofs', 'windows', 'doors', 'floors', 'skylights']:
             for comp in components.get(component_type, []):
                 if comp.area <= 0:
                     return False, f"Invalid area for {component_type}: {comp.name}"
                 if comp.u_value <= 0:
                     return False, f"Invalid U-value for {component_type}: {comp.name}"
-                # NEW: Validate ground temperature for floors
+                # Validate ground temperature for floors
                 if component_type == 'floors' and getattr(comp, 'ground_contact', False):
                     if not -10 <= comp.ground_temperature_c <= 40:
                         return False, f"Ground temperature for {comp.name} must be between -10°C and 40°C"
-                    # NEW: Validate perimeter
                     if getattr(comp, 'perimeter', 0) < 0:
                         return False, f"Perimeter for {comp.name} cannot be negative"
+                # NEW: Validate enhanced window/skylight properties
+                if component_type in ['windows', 'skylights']:
+                    if getattr(comp, 'shgc', 0) <= 0:
+                        return False, f"Invalid SHGC for {component_type}: {comp.name}"
+                    if getattr(comp, 'glazing_type', None) is None:
+                        return False, f"Glazing type missing for {component_type}: {comp.name}"
+                    if getattr(comp, 'frame_type', None) is None:
+                        return False, f"Frame type missing for {component_type}: {comp.name}"
         
-        # NEW: Validate ventilation rate
+        # Validate ventilation rate
         if building_info.get('ventilation_rate', 0) < 0:
             return False, "Ventilation rate cannot be negative"
         if building_info.get('zone_type', '') == 'Custom' and building_info.get('ventilation_rate', 0) == 0:
             return False, "Custom ventilation rate must be specified"
         
+        # NEW: Validate new inputs from Plan.txt
+        if not -50 <= building_info.get('winter_temp', -10) <= 20:
+            return False, "Winter design temperature must be -50 to 20°C"
+        if not 0 <= building_info.get('outdoor_rh', 50) <= 100:
+            return False, "Outdoor relative humidity must be 0-100%"
+        if not 0 <= building_info.get('indoor_rh', 50) <= 100:
+            return False, "Indoor relative humidity must be 0-100%"
+        if not 0 <= building_info.get('building_height', 3) <= 100:
+            return False, "Building height must be 0-100m"
+        
         return True, "Inputs valid."
     
     def validate_internal_load(self, load_type: str, new_load: Dict) -> Tuple[bool, str]:
@@ -227,14 +248,14 @@ class HVACCalculator:
         if len(loads) >= max_loads:
             return False, f"Maximum of {max_loads} {load_type} loads reached."
         
-        # Check for duplicates based on key attributes
         for existing_load in loads:
             if load_type == 'people':
                 if (existing_load['name'] == new_load['name'] and
                     existing_load['num_people'] == new_load['num_people'] and
                     existing_load['activity_level'] == new_load['activity_level'] and
                     existing_load['zone_type'] == new_load['zone_type'] and
-                    existing_load['hours_in_operation'] == new_load['hours_in_operation']):
+                    existing_load['hours_in_operation'] == new_load['hours_in_operation'] and
+                    existing_load['latent_gain'] == new_load['latent_gain']):  # NEW: Added latent_gain
                     return False, f"Duplicate people load '{new_load['name']}' already exists."
             elif load_type == 'lighting':
                 if (existing_load['name'] == new_load['name'] and
@@ -257,13 +278,12 @@ class HVACCalculator:
     def display_internal_loads(self):
         st.title("Internal Loads")
         
-        # Reset button for all internal loads
         if st.button("Reset All Internal Loads"):
             st.session_state.internal_loads = {'people': [], 'lighting': [], 'equipment': []}
             st.success("All internal loads reset!")
             st.rerun()
         
-        tabs = st.tabs(["People", "Lighting", "Equipment", "Ventilation"])  # NEW: Added Ventilation tab
+        tabs = st.tabs(["People", "Lighting", "Equipment", "Ventilation"])
         
         with tabs[0]:
             st.subheader("People")
@@ -282,16 +302,21 @@ class HVACCalculator:
                 )
                 zone_type = st.selectbox(
                     "Zone Type",
-                    ["Office", "Classroom", "Retail", "Residential"],
-                    help="Select zone type for occupancy characteristics"
+                    ["A", "B", "C", "D"],  # NEW: Updated per Plan.txt
+                    help="Select zone type for CLF accuracy per ASHRAE"
+                )
+                hours_in_operation = st.selectbox(
+                    "Hours Occupied",  # NEW: Updated label per Plan.txt
+                    ["2h", "4h", "6h"],  # NEW: Updated options per Plan.txt
+                    help="Select hours of occupancy for CLF calculations"
                 )
-                hours_in_operation = st.number_input(
-                    "Hours in Operation",
+                latent_gain = st.number_input(  # NEW: Added per Plan.txt
+                    "Latent Gain per Person (Btu/h)",
                     min_value=0.0,
-                    max_value=24.0,
-                    value=8.0,
-                    step=0.5,
-                    help="Daily hours of occupancy"
+                    max_value=500.0,
+                    value=200.0,
+                    step=10.0,
+                    help="Latent heat gain per person per ASHRAE"
                 )
                 people_name = st.text_input("Name", value="Occupants")
                 
@@ -302,7 +327,8 @@ class HVACCalculator:
                         "num_people": num_people,
                         "activity_level": activity_level,
                         "zone_type": zone_type,
-                        "hours_in_operation": hours_in_operation
+                        "hours_in_operation": hours_in_operation,
+                        "latent_gain": latent_gain  # NEW: Added per Plan.txt
                     }
                     is_valid, message = self.validate_internal_load('people', people_load)
                     if is_valid:
@@ -348,16 +374,13 @@ class HVACCalculator:
                 )
                 zone_type = st.selectbox(
                     "Zone Type",
-                    ["Office", "Classroom", "Retail", "Residential"],
-                    help="Select zone type for lighting characteristics"
+                    ["A", "B", "C", "D"],  # NEW: Updated per Plan.txt
+                    help="Select zone type for CLF accuracy per ASHRAE"
                 )
-                hours_in_operation = st.number_input(
-                    "Hours in Operation",
-                    min_value=0.0,
-                    max_value=24.0,
-                    value=8.0,
-                    step=0.5,
-                    help="Daily hours of lighting operation"
+                hours_in_operation = st.selectbox(
+                    "Hours On",  # NEW: Updated label per Plan.txt
+                    ["8h", "10h", "12h"],  # NEW: Updated options per Plan.txt
+                    help="Select hours of lighting operation for CLF calculations"
                 )
                 lighting_name = st.text_input("Name", value="General Lighting")
                 
@@ -422,16 +445,13 @@ class HVACCalculator:
                 )
                 zone_type = st.selectbox(
                     "Zone Type",
-                    ["Office", "Classroom", "Retail", "Residential"],
-                    help="Select zone type for equipment characteristics"
+                    ["A", "B", "C", "D"],  # NEW: Updated per Plan.txt
+                    help="Select zone type for CLF accuracy per ASHRAE"
                 )
-                hours_in_operation = st.number_input(
-                    "Hours in Operation",
-                    min_value=0.0,
-                    max_value=24.0,
-                    value=8.0,
-                    step=0.5,
-                    help="Daily hours of equipment operation"
+                hours_in_operation = st.selectbox(
+                    "Hours Operated",  # NEW: Updated label per Plan.txt
+                    ["2h", "4h", "6h"],  # NEW: Updated options per Plan.txt
+                    help="Select hours of equipment operation for CLF calculations"
                 )
                 equipment_name = st.text_input("Name", value="Office Equipment")
                 
@@ -469,7 +489,7 @@ class HVACCalculator:
                     st.success("Selected equipment loads deleted!")
                     st.rerun()
         
-        with tabs[3]:  # NEW: Ventilation tab
+        with tabs[3]:
             st.subheader("Ventilation Requirements (ASHRAE 62.1)")
             with st.form("ventilation_form"):
                 col1, col2 = st.columns(2)
@@ -500,26 +520,43 @@ class HVACCalculator:
                             step=0.1,
                             help="Custom ventilation rate per floor area (ASHRAE 62.1)"
                         )
+                        ventilation_rate = st.number_input(  # NEW: Added per Plan.txt
+                            "Ventilation Rate (m³/s)",
+                            min_value=0.0,
+                            max_value=10.0,
+                            value=0.0,
+                            step=0.1,
+                            help="Total ventilation rate for custom zone type"
+                        )
                     else:
                         people_rate = VENTILATION_RATES[zone_type]["people_rate"]
                         area_rate = VENTILATION_RATES[zone_type]["area_rate"]
                         st.write(f"People Rate: {people_rate} L/s/person (ASHRAE 62.1)")
                         st.write(f"Area Rate: {area_rate} L/s/m² (ASHRAE 62.1)")
+                        ventilation_rate = st.number_input(  # NEW: Added per Plan.txt
+                            "Ventilation Rate (m³/s)",
+                            min_value=0.0,
+                            max_value=10.0,
+                            value=0.0,
+                            step=0.1,
+                            help="Total ventilation rate (override ASHRAE defaults if needed)"
+                        )
                 
                 if st.form_submit_button("Save Ventilation Settings"):
                     total_people = sum(load['num_people'] for load in st.session_state.internal_loads.get('people', []))
                     floor_area = st.session_state.building_info.get('floor_area', 100.0)
-                    ventilation_rate = (
+                    calculated_rate = (
                         (total_people * people_rate + floor_area * area_rate) / 1000  # Convert L/s to m³/s
                     )
+                    final_rate = ventilation_rate if ventilation_rate > 0 else calculated_rate
                     if ventilation_method == 'Demand-Controlled':
-                        ventilation_rate *= 0.75  # Reduce by 25% for DCV
+                        final_rate *= 0.75  # Reduce by 25% for DCV
                     st.session_state.building_info.update({
                         'zone_type': zone_type,
                         'ventilation_method': ventilation_method,
-                        'ventilation_rate': ventilation_rate
+                        'ventilation_rate': final_rate
                     })
-                    st.success(f"Ventilation settings saved! Total rate: {ventilation_rate:.3f} m³/s")
+                    st.success(f"Ventilation settings saved! Total rate: {final_rate:.3f} m³/s")
         
         col1, col2 = st.columns(2)
         with col1:
@@ -568,19 +605,25 @@ class HVACCalculator:
             if not all(k in location for k in ['summer_design_temp_db', 'summer_design_temp_wb', 'monthly_temps', 'latitude']):
                 return False, f"Invalid climate data for {climate_id}. Missing required fields.", {}
             
+            # NEW: Month-to-day mapping per Plan.txt
+            month_to_day = {
+                "Jan": 15, "Feb": 45, "Mar": 74, "Apr": 105, "May": 135, "Jun": 166,
+                "Jul": 196, "Aug": 227, "Sep": 258, "Oct": 288, "Nov": 319, "Dec": 350
+            }
+            
             # Format conditions
             outdoor_conditions = {
                 'temperature': location['summer_design_temp_db'],
-                'relative_humidity': location['monthly_humidity'].get('Jul', 50.0),
+                'relative_humidity': building_info.get('outdoor_rh', location['monthly_humidity'].get('Jul', 50.0)),  # NEW: Use UI input
                 'ground_temperature': location['monthly_temps'].get('Jul', 20.0),
                 'month': 'Jul',
-                'latitude': location['latitude'],  # Pass raw latitude value, validation will happen in cooling_load.py
-                'wind_speed': building_info.get('wind_speed', 4.0),
-                'day_of_year': 204  # Approx. July 23
+                'latitude': location['latitude'],
+                'wind_speed': building_info.get('wind_speed', 4.0),  # NEW: Use UI input
+                'day_of_year': month_to_day.get('Jul', 182)  # NEW: Derive from month
             }
             indoor_conditions = {
                 'temperature': building_info.get('indoor_temp', 24.0),
-                'relative_humidity': building_info.get('indoor_rh', 50.0)
+                'relative_humidity': building_info.get('indoor_rh', 50.0)  # NEW: Use UI input
             }
             
             if st.session_state.get('debug_mode', False):
@@ -602,27 +645,31 @@ class HVACCalculator:
                 'people': {
                     'number': sum(load['num_people'] for load in internal_loads.get('people', [])),
                     'activity_level': internal_loads.get('people', [{}])[0].get('activity_level', 'Seated/Resting'),
-                    'operating_hours': f"{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)}:00-{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)+10}:00"
+                    'operating_hours': internal_loads.get('people', [{}])[0].get('hours_in_operation', '8h'),  # NEW: Use updated hours
+                    'zone_type': internal_loads.get('people', [{}])[0].get('zone_type', 'A'),  # NEW: Use updated zone type
+                    'latent_gain': internal_loads.get('people', [{}])[0].get('latent_gain', 200.0)  # NEW: Added latent gain
                 },
                 'lights': {
                     'power': sum(load['power'] for load in internal_loads.get('lighting', [])),
                     'use_factor': internal_loads.get('lighting', [{}])[0].get('usage_factor', 0.8),
                     'special_allowance': 0.1,
-                    'hours_operation': f"{internal_loads.get('lighting', [{}])[0].get('hours_in_operation', 8)}h"
+                    'hours_operation': internal_loads.get('lighting', [{}])[0].get('hours_in_operation', '8h'),  # NEW: Use updated hours
+                    'zone_type': internal_loads.get('lighting', [{}])[0].get('zone_type', 'A')  # NEW: Use updated zone type
                 },
                 'equipment': {
                     'power': sum(load['power'] for load in internal_loads.get('equipment', [])),
                     'use_factor': internal_loads.get('equipment', [{}])[0].get('usage_factor', 0.7),
                     'radiation_factor': internal_loads.get('equipment', [{}])[0].get('radiation_fraction', 0.3),
-                    'hours_operation': f"{internal_loads.get('equipment', [{}])[0].get('hours_in_operation', 8)}h"
+                    'hours_operation': internal_loads.get('equipment', [{}])[0].get('hours_in_operation', '8h'),  # NEW: Use updated hours
+                    'zone_type': internal_loads.get('equipment', [{}])[0].get('zone_type', 'A')  # NEW: Use updated zone type
                 },
                 'infiltration': {
                     'flow_rate': building_info.get('infiltration_rate', 0.05),
-                    'height': building_info.get('building_height', 3.0),
+                    'height': building_info.get('building_height', 3.0),  # NEW: Use UI input
                     'crack_length': building_info.get('crack_length', 10.0)
                 },
                 'ventilation': {
-                    'flow_rate': building_info.get('ventilation_rate', 0.1)
+                    'flow_rate': building_info.get('ventilation_rate', 0.1)  # NEW: Use UI input
                 },
                 'operating_hours': building_info.get('operating_hours', '8:00-18:00')
             }
@@ -650,15 +697,13 @@ class HVACCalculator:
             
             # Ensure summary has all required keys
             if 'total' not in summary:
-                # Calculate total if missing
                 if 'total_sensible' in summary and 'total_latent' in summary:
                     summary['total'] = summary['total_sensible'] + summary['total_latent']
                 else:
-                    # Fallback to sum of design loads if needed
                     total_load = sum(value for key, value in design_loads.items() if key != 'design_hour')
                     summary = {
-                        'total_sensible': total_load * 0.7,  # Approximate sensible ratio
-                        'total_latent': total_load * 0.3,    # Approximate latent ratio
+                        'total_sensible': total_load * 0.7,
+                        'total_latent': total_load * 0.3,
                         'total': total_load
                     }
             
@@ -674,6 +719,7 @@ class HVACCalculator:
                     'roof': design_loads['roofs'] / 1000,
                     'windows': (design_loads['windows_conduction'] + design_loads['windows_solar']) / 1000,
                     'doors': design_loads['doors'] / 1000,
+                    'skylights': design_loads.get('skylights', 0) / 1000,  # NEW: Skylights
                     'people': (design_loads['people_sensible'] + design_loads['people_latent']) / 1000,
                     'lighting': design_loads['lights'] / 1000,
                     'equipment': (design_loads['equipment_sensible'] + design_loads['equipment_latent']) / 1000,
@@ -685,6 +731,7 @@ class HVACCalculator:
                     'roofs': [],
                     'windows': [],
                     'doors': [],
+                    'skylights': [],  # NEW: Skylights
                     'internal': [],
                     'infiltration': {
                         'air_flow': formatted_internal_loads['infiltration']['flow_rate'],
@@ -710,18 +757,20 @@ class HVACCalculator:
                     indoor_temp=indoor_conditions['temperature'],
                     month=outdoor_conditions['month'],
                     hour=design_loads['design_hour'],
-                    latitude=outdoor_conditions['latitude']
+                    latitude=outdoor_conditions['latitude'],
+                    surface_color=wall.surface_color  # NEW: Surface color
                 )
                 results['detailed_loads']['walls'].append({
                     'name': wall.name,
                     'orientation': wall.orientation.value,
                     'area': wall.area,
                     'u_value': wall.u_value,
+                    'surface_color': wall.surface_color,  # NEW: Surface color
                     'cltd': self.cooling_calculator.ashrae_tables.calculate_corrected_cltd_wall(
                         wall_group=wall.wall_group,
                         orientation=wall.orientation.value,
                         hour=design_loads['design_hour'],
-                        color='Dark',
+                        color=wall.surface_color,  # NEW: Use surface color
                         month=outdoor_conditions['month'],
                         latitude=outdoor_conditions['latitude'],
                         indoor_temp=indoor_conditions['temperature'],
@@ -737,17 +786,19 @@ class HVACCalculator:
                     indoor_temp=indoor_conditions['temperature'],
                     month=outdoor_conditions['month'],
                     hour=design_loads['design_hour'],
-                    latitude=outdoor_conditions['latitude']
+                    latitude=outdoor_conditions['latitude'],
+                    surface_color=roof.surface_color  # NEW: Surface color
                 )
                 results['detailed_loads']['roofs'].append({
                     'name': roof.name,
                     'orientation': roof.orientation.value,
                     'area': roof.area,
                     'u_value': roof.u_value,
+                    'surface_color': roof.surface_color,  # NEW: Surface color
                     'cltd': self.cooling_calculator.ashrae_tables.calculate_corrected_cltd_roof(
                         roof_group=roof.roof_group,
                         hour=design_loads['design_hour'],
-                        color='Dark',
+                        color=roof.surface_color,  # NEW: Use surface color
                         month=outdoor_conditions['month'],
                         latitude=outdoor_conditions['latitude'],
                         indoor_temp=indoor_conditions['temperature'],
@@ -757,6 +808,12 @@ class HVACCalculator:
                 })
             
             for window in building_components.get('windows', []):
+                # NEW: Apply drapery adjustment
+                adjusted_shgc = self.drapery_system.adjust_shgc(
+                    base_shgc=window.shgc,
+                    glazing_type=window.glazing_type,
+                    drapery_type=window.drapery_type if hasattr(window, 'drapery_type') else None
+                )
                 load_dict = self.cooling_calculator.calculate_window_cooling_load(
                     window=window,
                     outdoor_temp=outdoor_conditions['temperature'],
@@ -764,22 +821,27 @@ class HVACCalculator:
                     month=outdoor_conditions['month'],
                     hour=design_loads['design_hour'],
                     latitude=outdoor_conditions['latitude'],
-                    shading_coefficient=window.shading_coefficient
+                    shading_coefficient=window.shading_coefficient,
+                    adjusted_shgc=adjusted_shgc,  # NEW: Adjusted SHGC
+                    glazing_type=window.glazing_type,  # NEW: Glazing type
+                    frame_type=window.frame_type  # NEW: Frame type
                 )
-                # Ensure load_dict has a 'total' key
                 if 'total' not in load_dict:
                     if 'conduction' in load_dict and 'solar' in load_dict:
                         load_dict['total'] = load_dict['conduction'] + load_dict['solar']
                     else:
                         load_dict['total'] = window.u_value * window.area * (outdoor_conditions['temperature'] - indoor_conditions['temperature'])
                 
-                # Pass latitude directly to get_scl method which has its own validation
                 results['detailed_loads']['windows'].append({
                     'name': window.name,
                     'orientation': window.orientation.value,
                     'area': window.area,
                     'u_value': window.u_value,
                     'shgc': window.shgc,
+                    'adjusted_shgc': adjusted_shgc,  # NEW: Adjusted SHGC
+                    'glazing_type': window.glazing_type,  # NEW: Glazing type
+                    'frame_type': window.frame_type,  # NEW: Frame type
+                    'drapery_type': window.drapery_type if hasattr(window, 'drapery_type') else 'None',  # NEW: Drapery
                     'shading_device': window.shading_device,
                     'shading_coefficient': window.shading_coefficient,
                     'scl': self.cooling_calculator.ashrae_tables.get_scl(
@@ -806,15 +868,59 @@ class HVACCalculator:
                     'load': load / 1000
                 })
             
+            # NEW: Skylights
+            for skylight in building_components.get('skylights', []):
+                adjusted_shgc = self.drapery_system.adjust_shgc(
+                    base_shgc=skylight.shgc,
+                    glazing_type=skylight.glazing_type,
+                    drapery_type=skylight.drapery_type if hasattr(skylight, 'drapery_type') else None
+                )
+                load_dict = self.cooling_calculator.calculate_skylight_cooling_load(
+                    skylight=skylight,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    month=outdoor_conditions['month'],
+                    hour=design_loads['design_hour'],
+                    latitude=outdoor_conditions['latitude'],
+                    shading_coefficient=skylight.shading_coefficient,
+                    adjusted_shgc=adjusted_shgc,
+                    glazing_type=skylight.glazing_type,
+                    frame_type=skylight.frame_type
+                )
+                if 'total' not in load_dict:
+                    if 'conduction' in load_dict and 'solar' in load_dict:
+                        load_dict['total'] = load_dict['conduction'] + load_dict['solar']
+                    else:
+                        load_dict['total'] = skylight.u_value * skylight.area * (outdoor_conditions['temperature'] - indoor_conditions['temperature'])
+                
+                results['detailed_loads']['skylights'].append({
+                    'name': skylight.name,
+                    'area': skylight.area,
+                    'u_value': skylight.u_value,
+                    'shgc': skylight.shgc,
+                    'adjusted_shgc': adjusted_shgc,
+                    'glazing_type': skylight.glazing_type,
+                    'frame_type': skylight.frame_type,
+                    'drapery_type': skylight.drapery_type if hasattr(skylight, 'drapery_type') else 'None',
+                    'shading_coefficient': skylight.shading_coefficient,
+                    'scl': self.cooling_calculator.ashrae_tables.get_scl(
+                        latitude=outdoor_conditions['latitude'],
+                        month=outdoor_conditions['month'].title(),
+                        orientation='Horizontal',  # Skylights are horizontal
+                        hour=design_loads['design_hour']
+                    ),
+                    'load': load_dict['total'] / 1000
+                })
+            
             for load_type, key in [('people', 'people'), ('lighting', 'lights'), ('equipment', 'equipment')]:
                 for load in internal_loads.get(key, []):
                     if load_type == 'people':
                         load_dict = self.cooling_calculator.calculate_people_cooling_load(
                             num_people=load['num_people'],
                             activity_level=load['activity_level'],
-                            hour=design_loads['design_hour']
+                            hour=design_loads['design_hour'],
+                            latent_gain=load.get('latent_gain', 200.0)  # NEW: Pass latent gain
                         )
-                        # Ensure load_dict has a 'total' key
                         if 'total' not in load_dict and ('sensible' in load_dict or 'latent' in load_dict):
                             load_dict['total'] = load_dict.get('sensible', 0) + load_dict.get('latent', 0)
                     elif load_type == 'lighting':
@@ -832,7 +938,6 @@ class HVACCalculator:
                             radiation_factor=load['radiation_fraction'],
                             hour=design_loads['design_hour']
                         )
-                        # Ensure load_dict has a 'total' key
                         if 'total' not in load_dict and ('sensible' in load_dict or 'latent' in load_dict):
                             load_dict['total'] = load_dict.get('sensible', 0) + load_dict.get('latent', 0)
                     results['detailed_loads']['internal'].append({
@@ -841,8 +946,8 @@ class HVACCalculator:
                         'quantity': load.get('num_people', load.get('power', 1)),
                         'heat_gain': load_dict.get('sensible', load_dict.get('total', 0)),
                         'clf': self.cooling_calculator.ashrae_tables.get_clf_people(
-                            zone_type='A',
-                            hours_occupied='6h',  # Using valid '6h' instead of dynamic value that might not exist
+                            zone_type=load.get('zone_type', 'A'),
+                            hours_occupied=load.get('hours_in_operation', '6h'),
                             hour=design_loads['design_hour']
                         ) if load_type == 'people' else 1.0,
                         'load': load_dict.get('total', 0) / 1000
@@ -902,7 +1007,7 @@ class HVACCalculator:
             if not all(k in location for k in ['winter_design_temp', 'monthly_temps', 'monthly_humidity']):
                 return False, f"Invalid climate data for {climate_id}. Missing required fields.", {}
             
-            # NEW: Calculate ground temperature from floors or fallback to climate data
+            # Calculate ground temperature
             ground_contact_floors = [f for f in building_components.get('floors', []) if getattr(f, 'ground_contact', False)]
             ground_temperature = (
                 sum(f.ground_temperature_c for f in ground_contact_floors) / len(ground_contact_floors)
@@ -912,9 +1017,9 @@ class HVACCalculator:
             if not -10 <= ground_temperature <= 40:
                 return False, f"Invalid ground temperature: {ground_temperature}°C", {}
             
-            # NEW: Skip heating calculation if outdoor temp exceeds indoor temp
+            # Skip heating calculation if outdoor temp exceeds indoor temp
             indoor_temp = building_info.get('indoor_temp', 21.0)
-            outdoor_temp = location['winter_design_temp']
+            outdoor_temp = building_info.get('winter_temp', location['winter_design_temp'])  # NEW: Use UI input if available
             if outdoor_temp >= indoor_temp:
                 results = {
                     'total_load': 0.0,
@@ -927,6 +1032,7 @@ class HVACCalculator:
                         'floor': 0.0,
                         'windows': 0.0,
                         'doors': 0.0,
+                        'skylights': 0.0,  # NEW: Skylights
                         'infiltration': 0.0,
                         'ventilation': 0.0
                     },
@@ -936,6 +1042,7 @@ class HVACCalculator:
                         'floors': [],
                         'windows': [],
                         'doors': [],
+                        'skylights': [],  # NEW: Skylights
                         'infiltration': {'air_flow': 0.0, 'delta_t': 0.0, 'load': 0.0},
                         'ventilation': {'air_flow': 0.0, 'delta_t': 0.0, 'load': 0.0}
                     },
@@ -945,14 +1052,14 @@ class HVACCalculator:
             
             # Format conditions
             outdoor_conditions = {
-                'design_temperature': location['winter_design_temp'],
-                'design_relative_humidity': location['monthly_humidity'].get('Jan', 80.0),
+                'design_temperature': outdoor_temp,  # NEW: Use UI input
+                'design_relative_humidity': building_info.get('outdoor_rh', location['monthly_humidity'].get('Jan', 80.0)),  # NEW: Use UI input
                 'ground_temperature': ground_temperature,
-                'wind_speed': building_info.get('wind_speed', 4.0)
+                'wind_speed': building_info.get('wind_speed', 4.0)  # NEW: Use UI input
             }
             indoor_conditions = {
                 'temperature': indoor_temp,
-                'relative_humidity': building_info.get('indoor_rh', 40.0)
+                'relative_humidity': building_info.get('indoor_rh', 40.0)  # NEW: Use UI input
             }
             
             if st.session_state.get('debug_mode', False):
@@ -969,7 +1076,7 @@ class HVACCalculator:
                     'building_info': building_info
                 })
             
-            # NEW: Activity-level-based sensible gains
+            # Activity-level-based sensible gains
             ACTIVITY_GAINS = {
                 'Seated/Resting': 70.0,  # W/person
                 'Light Work': 85.0,
@@ -985,25 +1092,29 @@ class HVACCalculator:
                         internal_loads.get('people', [{}])[0].get('activity_level', 'Seated/Resting'),
                         70.0
                     ),
-                    'operating_hours': f"{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)}:00-{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)+10}:00"
+                    'latent_gain': internal_loads.get('people', [{}])[0].get('latent_gain', 200.0),  # NEW: Added latent gain
+                    'operating_hours': internal_loads.get('people', [{}])[0].get('hours_in_operation', '8h'),  # NEW: Use updated hours
+                    'zone_type': internal_loads.get('people', [{}])[0].get('zone_type', 'A')  # NEW: Use updated zone type
                 },
                 'lights': {
                     'power': sum(load['power'] for load in internal_loads.get('lighting', [])),
                     'use_factor': internal_loads.get('lighting', [{}])[0].get('usage_factor', 0.8),
-                    'hours_operation': f"{internal_loads.get('lighting', [{}])[0].get('hours_in_operation', 8)}h"
+                    'hours_operation': internal_loads.get('lighting', [{}])[0].get('hours_in_operation', '8h'),  # NEW: Use updated hours
+                    'zone_type': internal_loads.get('lighting', [{}])[0].get('zone_type', 'A')  # NEW: Use updated zone type
                 },
                 'equipment': {
                     'power': sum(load['power'] for load in internal_loads.get('equipment', [])),
                     'use_factor': internal_loads.get('equipment', [{}])[0].get('usage_factor', 0.7),
-                    'hours_operation': f"{internal_loads.get('equipment', [{}])[0].get('hours_in_operation', 8)}h"
+                    'hours_operation': internal_loads.get('equipment', [{}])[0].get('hours_in_operation', '8h'),  # NEW: Use updated hours
+                    'zone_type': internal_loads.get('equipment', [{}])[0].get('zone_type', 'A')  # NEW: Use updated zone type
                 },
                 'infiltration': {
                     'flow_rate': building_info.get('infiltration_rate', 0.05),
-                    'height': building_info.get('building_height', 3.0),
+                    'height': building_info.get('building_height', 3.0),  # NEW: Use UI input
                     'crack_length': building_info.get('crack_length', 10.0)
                 },
                 'ventilation': {
-                    'flow_rate': building_info.get('ventilation_rate', 0.1)
+                    'flow_rate': building_info.get('ventilation_rate', 0.1)  # NEW: Use UI input
                 },
                 'usage_factor': 0.7,
                 'operating_hours': building_info.get('operating_hours', '8:00-18:00')
@@ -1037,6 +1148,7 @@ class HVACCalculator:
                     'floor': design_loads['floors'] / 1000,
                     'windows': design_loads['windows'] / 1000,
                     'doors': design_loads['doors'] / 1000,
+                    'skylights': design_loads.get('skylights', 0) / 1000,  # NEW: Skylights
                     'infiltration': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000,
                     'ventilation': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
                 },
@@ -1046,6 +1158,7 @@ class HVACCalculator:
                     'floors': [],
                     'windows': [],
                     'doors': [],
+                    'skylights': [],  # NEW: Skylights
                     'infiltration': {
                         'air_flow': formatted_internal_loads['infiltration']['flow_rate'],
                         'delta_t': indoor_conditions['temperature'] - outdoor_conditions['design_temperature'],
@@ -1073,6 +1186,7 @@ class HVACCalculator:
                     'orientation': wall.orientation.value,
                     'area': wall.area,
                     'u_value': wall.u_value,
+                    'surface_color': wall.surface_color,  # NEW: Surface color
                     'delta_t': delta_t,
                     'load': load / 1000
                 })
@@ -1088,6 +1202,7 @@ class HVACCalculator:
                     'orientation': roof.orientation.value,
                     'area': roof.area,
                     'u_value': roof.u_value,
+                    'surface_color': roof.surface_color,  # NEW: Surface color
                     'delta_t': delta_t,
                     'load': load / 1000
                 })
@@ -1101,7 +1216,7 @@ class HVACCalculator:
                 results['detailed_loads']['floors'].append({
                     'name': floor.name,
                     'area': floor.area,
-                    'u_value': floor.u_value,
+                    'u_value': floor.area,
                     'delta_t': indoor_conditions['temperature'] - outdoor_conditions['ground_temperature'],
                     'load': load / 1000
                 })
@@ -1110,13 +1225,16 @@ class HVACCalculator:
                 load = self.heating_calculator.calculate_window_heating_load(
                     window=window,
                     outdoor_temp=outdoor_conditions['design_temperature'],
-                    indoor_temp=indoor_conditions['temperature']
+                    indoor_temp=indoor_conditions['temperature'],
+                    frame_type=window.frame_type  # NEW: Frame type
                 )
                 results['detailed_loads']['windows'].append({
                     'name': window.name,
                     'orientation': window.orientation.value,
                     'area': window.area,
                     'u_value': window.u_value,
+                    'glazing_type': window.glazing_type,  # NEW: Glazing type
+                    'frame_type': window.frame_type,  # NEW: Frame type
                     'delta_t': delta_t,
                     'load': load / 1000
                 })
@@ -1136,6 +1254,24 @@ class HVACCalculator:
                     'load': load / 1000
                 })
             
+            # NEW: Skylights
+            for skylight in building_components.get('skylights', []):
+                load = self.heating_calculator.calculate_skylight_heating_load(
+                    skylight=skylight,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    frame_type=skylight.frame_type
+                )
+                results['detailed_loads']['skylights'].append({
+                    'name': skylight.name,
+                    'area': skylight.area,
+                    'u_value': skylight.u_value,
+                    'glazing_type': skylight.glazing_type,
+                    'frame_type': skylight.frame_type,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
             if st.session_state.get('debug_mode', False):
                 st.write("Debug: Heating Results", {
                     'total_load': results.get('total_load', 'N/A'),