Update app/main.py

app/main.py

@@ -1,5 +1,6 @@
 """
 HVAC Calculator Code Documentation
+Updated 2025-04-27: Enhanced climate ID generation, input validation, debug mode, and error handling.
 """
 
 import streamlit as st
@@ -83,6 +84,9 @@ class HVACCalculator:
         if 'climate_data' not in st.session_state:
             st.session_state.climate_data = {}
         
+        if 'debug_mode' not in st.session_state:
+            st.session_state.debug_mode = False
+        
         # Initialize modules
         self.building_info_form = BuildingInfoForm()
         self.component_selection = ComponentSelectionInterface()
@@ -153,6 +157,35 @@ class HVACCalculator:
         elif page == "Export Data":
             self.data_export.display()
     
+    def generate_climate_id(self, country: str, city: str) -> str:
+        """Generate a climate ID from country and city names."""
+        try:
+            country = country.strip().title()
+            city = city.strip().title()
+            if len(country) < 2 or len(city) < 3:
+                raise ValueError("Country and city names must be at least 2 and 3 characters long, respectively.")
+            return f"{country[:2].upper()}-{city[:3].upper()}"
+        except Exception as e:
+            raise ValueError(f"Invalid country or city name: {str(e)}")
+    
+    def validate_calculation_inputs(self) -> Tuple[bool, str]:
+        """Validate inputs for cooling and heating calculations."""
+        building_info = st.session_state.get('building_info', {})
+        components = st.session_state.get('components', {})
+        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 st.session_state.get('climate_data'):
+            return False, "Climate data is missing."
+        for component_type in ['walls', 'roofs', 'windows', 'doors', 'floors']:
+            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}"
+        return True, "Inputs valid."
+    
     def validate_internal_load(self, load_type: str, new_load: Dict) -> Tuple[bool, str]:
         """Validate if a new internal load is unique and within limits."""
         loads = st.session_state.internal_loads.get(load_type, [])
@@ -384,39 +417,30 @@ class HVACCalculator:
         Returns: (success, message, results)
         """
         try:
+            # Validate inputs
+            valid, message = self.validate_calculation_inputs()
+            if not valid:
+                return False, message, {}
+            
             # Gather inputs
             building_components = st.session_state.get('components', {})
             internal_loads = st.session_state.get('internal_loads', {})
             building_info = st.session_state.get('building_info', {})
             
-            # Validate inputs
-            if not building_info.get('floor_area'):
-                return False, "Floor area is missing in building information.", {}
-            if not building_components.get('walls') and not building_components.get('roofs') and not building_components.get('windows'):
-                return False, "No building components defined. Please add walls, roofs, or windows.", {}
-            
             # Check climate data
             if "climate_data" not in st.session_state or not st.session_state["climate_data"]:
                 return False, "Please enter climate data in the 'Climate Data' page.", {}
             
-            # Extract climate data using ClimateData.get_location_by_id
+            # Extract climate data
             country = building_info.get('country', '').strip().title()
             city = building_info.get('city', '').strip().title()
             if not country or not city:
                 return False, "Country and city must be set in Building Information.", {}
-            climate_id = f"{country[:2].upper()}-{city[:3].upper()}"
-            
-            # Debug
-            st.write("Debug: Climate Data Retrieval", {
-                'climate_id': climate_id,
-                'building_info': building_info,
-                'session_state_climate_data': st.session_state.get('climate_data', 'Not set'),
-                'climate_locations': list(self.climate_data.locations.keys())
-            })
-            
+            climate_id = self.generate_climate_id(country, city)
             location = self.climate_data.get_location_by_id(climate_id, st.session_state)
             if not location:
-                return False, f"No climate data found for {climate_id}. Please provide valid climate data.", {}
+                available_locations = list(self.climate_data.locations.keys())[:5]
+                return False, f"No climate data for {climate_id}. Available locations: {', '.join(available_locations)}...", {}
             
             # Validate climate data
             if not all(k in location for k in ['summer_design_temp_db', 'summer_design_temp_wb', 'monthly_temps', 'latitude']):
@@ -429,7 +453,7 @@ class HVACCalculator:
                 'ground_temperature': location['monthly_temps'].get('Jul', 20.0),
                 'month': 'Jul',
                 'latitude': f"{location['latitude']}N" if location['latitude'] >= 0 else f"{abs(location['latitude'])}S",
-                'wind_speed': 4.0,  # Default as not provided in climate data
+                'wind_speed': building_info.get('wind_speed', 4.0),
                 'day_of_year': 204  # Approx. July 23
             }
             indoor_conditions = {
@@ -437,19 +461,19 @@ class HVACCalculator:
                 'relative_humidity': building_info.get('indoor_rh', 50.0)
             }
             
-            # Debug: Log inputs
-            st.write("Debug: Cooling Input State", {
-                'climate_id': climate_id,
-                'outdoor_conditions': outdoor_conditions,
-                'indoor_conditions': indoor_conditions,
-                'components': {k: len(v) for k, v in building_components.items()},
-                'internal_loads': {
-                    'people': len(internal_loads.get('people', [])),
-                    'lighting': len(internal_loads.get('lighting', [])),
-                    'equipment': len(internal_loads.get('equipment', []))
-                },
-                'building_info': building_info
-            })
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Cooling Input State", {
+                    'climate_id': climate_id,
+                    'outdoor_conditions': outdoor_conditions,
+                    'indoor_conditions': indoor_conditions,
+                    'components': {k: len(v) for k, v in building_components.items()},
+                    'internal_loads': {
+                        'people': len(internal_loads.get('people', [])),
+                        'lighting': len(internal_loads.get('lighting', [])),
+                        'equipment': len(internal_loads.get('equipment', []))
+                    },
+                    'building_info': building_info
+                })
             
             # Format internal loads
             formatted_internal_loads = {
@@ -616,9 +640,10 @@ class HVACCalculator:
                     'shading_device': window.shading_device,
                     'shading_coefficient': window.shading_coefficient,
                     'scl': self.cooling_calculator.ashrae_tables.get_scl(
-                        window.orientation.value,
-                        design_loads['design_hour'],
-                        scl_latitude
+                        latitude=scl_latitude,
+                        month=outdoor_conditions['month'].upper(),
+                        orientation=window.orientation.value,
+                        hour=design_loads['design_hour']
                     ),
                     'load': load_dict['total'] / 1000
                 })
@@ -666,23 +691,31 @@ class HVACCalculator:
                         'quantity': load.get('num_people', load.get('power', 1)),
                         'heat_gain': load_dict.get('sensible', load_dict['total']),
                         'clf': self.cooling_calculator.ashrae_tables.get_clf_people(
-                            design_loads['design_hour'],
-                            f"{load['hours_in_operation']}h"
+                            zone_type='A',
+                            hours_occupied=f"{load['hours_in_operation']}h",
+                            hour=design_loads['design_hour']
                         ) if load_type == 'people' else 1.0,
                         'load': load_dict['total'] / 1000
                     })
             
-            # Debug: Log results
-            st.write("Debug: Cooling Results", {
-                'total_load': results.get('total_load', 'N/A'),
-                'component_loads': results.get('component_loads', 'N/A'),
-                'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
-            })
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Cooling Results", {
+                    'total_load': results.get('total_load', 'N/A'),
+                    'component_loads': results.get('component_loads', 'N/A'),
+                    'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
+                })
             
             return True, "Cooling calculation completed.", results
+        
+        except ValueError as ve:
+            st.error(f"Input error in cooling calculation: {str(ve)}")
+            return False, f"Input error: {str(ve)}", {}
+        except KeyError as ke:
+            st.error(f"Missing data in cooling calculation: {str(ke)}")
+            return False, f"Missing data: {str(ke)}", {}
         except Exception as e:
-            st.error(f"Cooling calculation error: {str(e)}")
-            return False, f"Cooling calculation error: {str(e)}", {}
+            st.error(f"Unexpected error in cooling calculation: {str(e)}")
+            return False, f"Unexpected error: {str(e)}", {}
     
     def calculate_heating(self) -> Tuple[bool, str, Dict]:
         """
@@ -690,39 +723,30 @@ class HVACCalculator:
         Returns: (success, message, results)
         """
         try:
+            # Validate inputs
+            valid, message = self.validate_calculation_inputs()
+            if not valid:
+                return False, message, {}
+            
             # Gather inputs
             building_components = st.session_state.get('components', {})
             internal_loads = st.session_state.get('internal_loads', {})
             building_info = st.session_state.get('building_info', {})
             
-            # Validate inputs
-            if not building_info.get('floor_area'):
-                return False, "Floor area is missing in building information.", {}
-            if not building_components.get('walls') and not building_components.get('roofs') and not building_components.get('windows'):
-                return False, "No building components defined. Please add walls, roofs, or windows.", {}
-            
             # Check climate data
             if "climate_data" not in st.session_state or not st.session_state["climate_data"]:
                 return False, "Please enter climate data in the 'Climate Data' page.", {}
             
-            # Extract climate data using ClimateData.get_location_by_id
+            # Extract climate data
             country = building_info.get('country', '').strip().title()
             city = building_info.get('city', '').strip().title()
             if not country or not city:
                 return False, "Country and city must be set in Building Information.", {}
-            climate_id = f"{country[:2].upper()}-{city[:3].upper()}"
-            
-            # Debug
-            st.write("Debug: Climate Data Retrieval", {
-                'climate_id': climate_id,
-                'building_info': building_info,
-                'session_state_climate_data': st.session_state.get('climate_data', 'Not set'),
-                'climate_locations': list(self.climate_data.locations.keys())
-            })
-            
+            climate_id = self.generate_climate_id(country, city)
             location = self.climate_data.get_location_by_id(climate_id, st.session_state)
             if not location:
-                return False, f"No climate data found for {climate_id}. Please provide valid climate data.", {}
+                available_locations = list(self.climate_data.locations.keys())[:5]
+                return False, f"No climate data for {climate_id}. Available locations: {', '.join(available_locations)}...", {}
             
             # Validate climate data
             if not all(k in location for k in ['winter_design_temp', 'monthly_temps', 'monthly_humidity']):
@@ -733,26 +757,26 @@ class HVACCalculator:
                 'design_temperature': location['winter_design_temp'],
                 'design_relative_humidity': location['monthly_humidity'].get('Jan', 80.0),
                 'ground_temperature': location['monthly_temps'].get('Jan', 10.0),
-                'wind_speed': 4.0  # Default as not provided in climate data
+                'wind_speed': building_info.get('wind_speed', 4.0)
             }
             indoor_conditions = {
                 'temperature': building_info.get('indoor_temp', 21.0),
                 'relative_humidity': building_info.get('indoor_rh', 40.0)
             }
             
-            # Debug: Log inputs
-            st.write("Debug: Heating Input State", {
-                'climate_id': climate_id,
-                'outdoor_conditions': outdoor_conditions,
-                'indoor_conditions': indoor_conditions,
-                'components': {k: len(v) for k, v in building_components.items()},
-                'internal_loads': {
-                    'people': len(internal_loads.get('people', [])),
-                    'lighting': len(internal_loads.get('lighting', [])),
-                    'equipment': len(internal_loads.get('equipment', []))
-                },
-                'building_info': building_info
-            })
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Heating Input State", {
+                    'climate_id': climate_id,
+                    'outdoor_conditions': outdoor_conditions,
+                    'indoor_conditions': indoor_conditions,
+                    'components': {k: len(v) for k, v in building_components.items()},
+                    'internal_loads': {
+                        'people': len(internal_loads.get('people', [])),
+                        'lighting': len(internal_loads.get('lighting', [])),
+                        'equipment': len(internal_loads.get('equipment', []))
+                    },
+                    'building_info': building_info
+                })
             
             # Format internal loads
             formatted_internal_loads = {
@@ -910,17 +934,24 @@ class HVACCalculator:
                     'load': load / 1000
                 })
             
-            # Debug: Log results
-            st.write("Debug: Heating Results", {
-                'total_load': results.get('total_load', 'N/A'),
-                'component_loads': results.get('component_loads', 'N/A'),
-                'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
-            })
+            if st.session_state.get('debug_mode', False):
+                st.write("Debug: Heating Results", {
+                    'total_load': results.get('total_load', 'N/A'),
+                    'component_loads': results.get('component_loads', 'N/A'),
+                    'detailed_loads': {k: len(v) if isinstance(v, list) else v for k, v in results.get('detailed_loads', {}).items()}
+                })
             
             return True, "Heating calculation completed.", results
+        
+        except ValueError as ve:
+            st.error(f"Input error in heating calculation: {str(ve)}")
+            return False, f"Input error: {str(ve)}", {}
+        except KeyError as ke:
+            st.error(f"Missing data in heating calculation: {str(ke)}")
+            return False, f"Missing data: {str(ke)}", {}
         except Exception as e:
-            st.error(f"Heating calculation error: {str(e)}")
-            return False, f"Heating calculation error: {str(e)}", {}
+            st.error(f"Unexpected error in heating calculation: {str(e)}")
+            return False, f"Unexpected error: {str(e)}", {}
     
     def display_calculation_results(self):
         st.title("Calculation Results")
@@ -929,27 +960,28 @@ class HVACCalculator:
         with col1:
             calculate_button = st.button("Calculate Loads")
         with col2:
-            debug = st.checkbox("Debug Mode", value=True)  # Enable by default for now
+            st.session_state.debug_mode = st.checkbox("Debug Mode", value=st.session_state.get('debug_mode', False))
             
         if calculate_button:
             # Reset results
             st.session_state.calculation_results = {'cooling': {}, 'heating': {}}
             
-            # Calculate cooling load
-            cooling_success, cooling_message, cooling_results = self.calculate_cooling()
-            if cooling_success:
-                st.session_state.calculation_results['cooling'] = cooling_results
-                st.success(cooling_message)
-            else:
-                st.error(cooling_message)
-            
-            # Calculate heating load
-            heating_success, heating_message, heating_results = self.calculate_heating()
-            if heating_success:
-                st.session_state.calculation_results['heating'] = heating_results
-                st.success(heating_message)
-            else:
-                st.error(heating_message)
+            with st.spinner("Calculating loads..."):
+                # Calculate cooling load
+                cooling_success, cooling_message, cooling_results = self.calculate_cooling()
+                if cooling_success:
+                    st.session_state.calculation_results['cooling'] = cooling_results
+                    st.success(cooling_message)
+                else:
+                    st.error(cooling_message)
+                
+                # Calculate heating load
+                heating_success, heating_message, heating_results = self.calculate_heating()
+                if heating_success:
+                    st.session_state.calculation_results['heating'] = heating_results
+                    st.success(heating_message)
+                else:
+                    st.error(heating_message)
         
         # Display results
         self.results_display.display_results(st.session_state)