Update app/main.py

app/main.py

@@ -25,8 +25,6 @@ from data.reference_data import ReferenceData
 from data.climate_data import ClimateData
 from data.ashrae_tables import ASHRAETables
 from data.building_components import Wall as WallModel, Roof as RoofModel
-from data.cooling_load_updated import CoolingLoadCalculator
-from data.heating_load_updated import HeatingLoadCalculator
 
 # Import utility modules
 from utils.u_value_calculator import UValueCalculator
@@ -34,6 +32,8 @@ from utils.shading_system import ShadingSystem
 from utils.area_calculation_system import AreaCalculationSystem
 from utils.psychrometrics import Psychrometrics
 from utils.heat_transfer import HeatTransferCalculations
+from utils.cooling_load import CoolingLoadCalculator
+from utils.heating_load import HeatingLoadCalculator
 from utils.component_visualization import ComponentVisualization
 from utils.scenario_comparison import ScenarioComparisonVisualization
 from utils.psychrometric_visualization import PsychrometricVisualization
@@ -169,42 +169,229 @@ class HVACCalculator:
                     'summer_outdoor_rh': 50.0,
                     'ground_temperature': 20.0,
                     'design_month': 'Jul',
-                    'latitude': '40N',
-                    'daily_range_c': 11.0
+                    'latitude': '40N'
                 }
                 st.warning("No climate data provided. Using default values.")
             
-            # Format climate data for calculator
-            climate_conditions = {
-                'outdoor_temp_c': climate_data.get('summer_outdoor_db', 35.0),
-                'indoor_temp_c': building_info.get('indoor_temp', 24.0),
-                'latitude': float(climate_data.get('latitude', '40N').replace('N', '')),
-                'daily_range_c': climate_data.get('daily_range_c', 11.0)
+            # Default conditions
+            outdoor_conditions = {
+                'temperature': climate_data.get('summer_outdoor_db', 35.0),
+                'relative_humidity': climate_data.get('summer_outdoor_rh', 50.0),
+                'ground_temperature': climate_data.get('ground_temperature', 20.0),
+                'month': climate_data.get('design_month', 'Jul'),
+                'latitude': climate_data.get('latitude', '40N')
+            }
+            indoor_conditions = {
+                'temperature': building_info.get('indoor_temp', 24.0),
+                'relative_humidity': building_info.get('indoor_rh', 50.0)
             }
             
-            # Format internal loads (simplified for cooling_load_updated.py)
+            # Format internal loads
             formatted_internal_loads = {
-                'people': sum(load['num_people'] for load in internal_loads.get('people', [])) * 100,  # W/person
-                'lighting': sum(load['power'] * load['usage_factor'] for load in internal_loads.get('lighting', [])),  # W
-                'equipment': sum(load['power'] * load['usage_factor'] for load in internal_loads.get('equipment', [])),  # W
-                'infiltration': building_info.get('infiltration_rate', 0.05) * building_info.get('floor_area', 100.0),  # m³/s
-                'ventilation': building_info.get('ventilation_rate', 0.1) * building_info.get('floor_area', 100.0)  # m³/s
+                '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'),
+                    'hours_occupancy': f"{internal_loads.get('people', [{}])[0].get('hours_in_operation', 8)}h"
+                },
+                '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"
+                },
+                '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"
+                },
+                'infiltration': {'flow_rate': building_info.get('infiltration_rate', 0.05)},
+                'ventilation': {'flow_rate': building_info.get('ventilation_rate', 0.1)}
             }
             
-            # Initialize calculator and calculate
-            calculator = CoolingLoadCalculator()
-            cooling_loads = calculator.calculate_cooling_load(building_info, building_components, climate_conditions, formatted_internal_loads)
+            # Calculate hourly loads
+            hourly_loads = self.cooling_calculator.calculate_hourly_cooling_loads(
+                building_components=building_components,
+                outdoor_conditions=outdoor_conditions,
+                indoor_conditions=indoor_conditions,
+                internal_loads=formatted_internal_loads
+            )
+            
+            # Get design loads
+            design_loads = self.cooling_calculator.calculate_design_cooling_load(hourly_loads)
+            
+            # Get summary
+            summary = self.cooling_calculator.calculate_cooling_load_summary(design_loads)
             
             # Format results for results_display.py
             floor_area = building_info.get('floor_area', 100.0) or 100.0
             results = {
-                'total_load_watts': cooling_loads['total_load_watts'],
-                'total_load': cooling_loads['total_load_watts'] / 1000,  # kW
-                'load_per_area': cooling_loads['total_load_watts'] / floor_area,  # W/m²
-                'detailed_loads': cooling_loads['detailed_loads'],
+                'total_load': summary['total'] / 1000,  # kW
+                'sensible_load': summary['total_sensible'] / 1000,  # kW
+                'latent_load': summary['total_latent'] / 1000,  # kW
+                'load_per_area': summary['total'] / floor_area,  # W/m²
+                'component_loads': {
+                    'walls': design_loads['walls'] / 1000,
+                    'roof': design_loads['roofs'] / 1000,
+                    'windows': (design_loads['windows_conduction'] + design_loads['windows_solar']) / 1000,
+                    'doors': design_loads['doors'] / 1000,
+                    '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,
+                    'infiltration': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000,
+                    'ventilation': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                },
+                'detailed_loads': {
+                    'walls': [],
+                    'roofs': [],
+                    'windows': [],
+                    'doors': [],
+                    'internal': [],
+                    'infiltration': {
+                        'air_flow': formatted_internal_loads['infiltration']['flow_rate'],
+                        'sensible_load': design_loads['infiltration_sensible'] / 1000,
+                        'latent_load': design_loads['infiltration_latent'] / 1000,
+                        'total_load': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000
+                    },
+                    'ventilation': {
+                        'air_flow': formatted_internal_loads['ventilation']['flow_rate'],
+                        'sensible_load': design_loads['ventilation_sensible'] / 1000,
+                        'latent_load': design_loads['ventilation_latent'] / 1000,
+                        'total_load': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                    }
+                },
                 'building_info': building_info
             }
             
+            # Populate detailed loads
+            for wall in building_components.get('walls', []):
+                load = self.cooling_calculator.calculate_wall_cooling_load(
+                    wall=wall,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    month=outdoor_conditions['month'],
+                    hour=design_loads['design_hour'],
+                    latitude=outdoor_conditions['latitude']
+                )
+                results['detailed_loads']['walls'].append({
+                    'name': wall.name,
+                    'orientation': wall.orientation.value,
+                    'area': wall.area,
+                    'u_value': wall.u_value,
+                    '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',
+                        month=outdoor_conditions['month'],
+                        latitude=outdoor_conditions['latitude'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        outdoor_temp=outdoor_conditions['temperature']
+                    ),
+                    'load': load / 1000
+                })
+            
+            for roof in building_components.get('roofs', []):
+                load = self.cooling_calculator.calculate_roof_cooling_load(
+                    roof=roof,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    month=outdoor_conditions['month'],
+                    hour=design_loads['design_hour'],
+                    latitude=outdoor_conditions['latitude']
+                )
+                results['detailed_loads']['roofs'].append({
+                    'name': roof.name,
+                    'orientation': roof.orientation.value,
+                    'area': roof.area,
+                    'u_value': roof.u_value,
+                    'cltd': self.cooling_calculator.ashrae_tables.calculate_corrected_cltd_roof(
+                        roof_group=roof.roof_group,
+                        hour=design_loads['design_hour'],
+                        color='Dark',
+                        month=outdoor_conditions['month'],
+                        latitude=outdoor_conditions['latitude'],
+                        indoor_temp=indoor_conditions['temperature'],
+                        outdoor_temp=outdoor_conditions['temperature']
+                    ),
+                    'load': load / 1000
+                })
+            
+            for window in building_components.get('windows', []):
+                load_dict = self.cooling_calculator.calculate_window_cooling_load(
+                    window=window,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature'],
+                    month=outdoor_conditions['month'],
+                    hour=design_loads['design_hour'],
+                    latitude=f"{outdoor_conditions['latitude']}_{outdoor_conditions['month'].upper()}"
+                )
+                results['detailed_loads']['windows'].append({
+                    'name': window.name,
+                    'orientation': window.orientation.value,
+                    'area': window.area,
+                    'u_value': window.u_value,
+                    'shgc': window.shgc,
+                    'scl': self.cooling_calculator.ashrae_tables.get_scl(
+                        window.orientation.value,
+                        design_loads['design_hour'],
+                        f"{outdoor_conditions['latitude']}_{outdoor_conditions['month'].upper()}"
+                    ),
+                    'load': load_dict['total'] / 1000
+                })
+            
+            for door in building_components.get('doors', []):
+                load = self.cooling_calculator.calculate_door_cooling_load(
+                    door=door,
+                    outdoor_temp=outdoor_conditions['temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['doors'].append({
+                    'name': door.name,
+                    'orientation': door.orientation.value,
+                    'area': door.area,
+                    'u_value': door.u_value,
+                    'cltd': outdoor_conditions['temperature'] - indoor_conditions['temperature'],
+                    'load': load / 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'],
+                            hours_occupancy=f"{load['hours_in_operation']}h",
+                            hour=design_loads['design_hour']
+                        )
+                    elif load_type == 'lighting':
+                        load_dict = {'total': self.cooling_calculator.calculate_lights_cooling_load(
+                            power=load['power'],
+                            use_factor=load['usage_factor'],
+                            special_allowance=0.1,
+                            hours_operation=f"{load['hours_in_operation']}h",
+                            hour=design_loads['design_hour']
+                        )}
+                    else:
+                        load_dict = self.cooling_calculator.calculate_equipment_cooling_load(
+                            power=load['power'],
+                            use_factor=load['usage_factor'],
+                            radiation_factor=load['radiation_fraction'],
+                            hours_operation=f"{load['hours_in_operation']}h",
+                            hour=design_loads['design_hour']
+                        )
+                    results['detailed_loads']['internal'].append({
+                        'type': load_type.capitalize(),
+                        'name': load['name'],
+                        '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"
+                        ) if load_type == 'people' else 1.0,
+                        'load': load_dict['total'] / 1000
+                    })
+            
             return True, "Cooling calculation completed.", results
         except Exception as e:
             return False, f"Cooling calculation error: {str(e)}", {}
@@ -242,36 +429,159 @@ class HVACCalculator:
                 }
                 st.warning("No climate data provided. Using default values.")
             
-            # Format climate data
-            climate_conditions = {
-                'outdoor_temp_c': climate_data.get('winter_outdoor_db', -10.0),
-                'indoor_temp_c': building_info.get('indoor_temp', 21.0),
-                'ground_temperature_c': climate_data.get('ground_temperature', 10.0)
+            # Default conditions
+            outdoor_conditions = {
+                'design_temperature': climate_data.get('winter_outdoor_db', -10.0),
+                'design_relative_humidity': climate_data.get('winter_outdoor_rh', 80.0),
+                'ground_temperature': climate_data.get('ground_temperature', 10.0)
+            }
+            indoor_conditions = {
+                'temperature': building_info.get('indoor_temp', 21.0),
+                'relative_humidity': building_info.get('indoor_rh', 40.0)
             }
             
             # Format internal loads
             formatted_internal_loads = {
-                'people': sum(load['num_people'] for load in internal_loads.get('people', [])) * 70,  # W/person
-                'lighting': sum(load['power'] * load['usage_factor'] for load in internal_loads.get('lighting', [])),  # W
-                'equipment': sum(load['power'] * load['usage_factor'] for load in internal_loads.get('equipment', [])),  # W
-                'infiltration': building_info.get('infiltration_rate', 0.05) * building_info.get('floor_area', 100.0),  # m³/s
-                'ventilation': building_info.get('ventilation_rate', 0.1) * building_info.get('floor_area', 100.0)  # m³/s
+                'people': {
+                    'number': sum(load['num_people'] for load in internal_loads.get('people', [])),
+                    'sensible_gain': 70
+                },
+                'lights': {
+                    'power': sum(load['power'] for load in internal_loads.get('lighting', [])),
+                    'use_factor': internal_loads.get('lighting', [{}])[0].get('usage_factor', 0.8)
+                },
+                'equipment': {
+                    'power': sum(load['power'] for load in internal_loads.get('equipment', [])),
+                    'use_factor': internal_loads.get('equipment', [{}])[0].get('usage_factor', 0.7)
+                },
+                'infiltration': {'flow_rate': building_info.get('infiltration_rate', 0.05)},
+                'ventilation': {'flow_rate': building_info.get('ventilation_rate', 0.1)},
+                'usage_factor': 0.7
             }
             
-            # Initialize calculator and calculate
-            calculator = HeatingLoadCalculator()
-            heating_loads = calculator.calculate_heating_load(building_info, building_components, climate_conditions, formatted_internal_loads)
+            # Calculate design loads
+            design_loads = self.heating_calculator.calculate_design_heating_load(
+                building_components=building_components,
+                outdoor_conditions=outdoor_conditions,
+                indoor_conditions=indoor_conditions,
+                internal_loads=formatted_internal_loads
+            )
+            
+            # Get summary
+            summary = self.heating_calculator.calculate_heating_load_summary(design_loads)
             
             # Format results
             floor_area = building_info.get('floor_area', 100.0) or 100.0
             results = {
-                'total_load_watts': heating_loads['total_load_watts'],
-                'total_load': heating_loads['total_load_watts'] / 1000,  # kW
-                'load_per_area': heating_loads['total_load_watts'] / floor_area,  # W/m²
-                'detailed_loads': heating_loads['detailed_loads'],
+                'total_load': summary['total'] / 1000,  # kW
+                'load_per_area': summary['total'] / floor_area,  # W/m²
+                'design_heat_loss': summary['subtotal'] / 1000,  # kW
+                'safety_factor': summary['safety_factor'] * 100,  # %
+                'component_loads': {
+                    'walls': design_loads['walls'] / 1000,
+                    'roof': design_loads['roofs'] / 1000,
+                    'floor': design_loads['floors'] / 1000,
+                    'windows': design_loads['windows'] / 1000,
+                    'doors': design_loads['doors'] / 1000,
+                    'infiltration': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000,
+                    'ventilation': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                },
+                'detailed_loads': {
+                    'walls': [],
+                    'roofs': [],
+                    'floors': [],
+                    'windows': [],
+                    'doors': [],
+                    'infiltration': {
+                        'air_flow': formatted_internal_loads['infiltration']['flow_rate'],
+                        'delta_t': indoor_conditions['temperature'] - outdoor_conditions['design_temperature'],
+                        'load': (design_loads['infiltration_sensible'] + design_loads['infiltration_latent']) / 1000
+                    },
+                    'ventilation': {
+                        'air_flow': formatted_internal_loads['ventilation']['flow_rate'],
+                        'delta_t': indoor_conditions['temperature'] - outdoor_conditions['design_temperature'],
+                        'load': (design_loads['ventilation_sensible'] + design_loads['ventilation_latent']) / 1000
+                    }
+                },
                 'building_info': building_info
             }
             
+            # Populate detailed loads
+            delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
+            for wall in building_components.get('walls', []):
+                load = self.heating_calculator.calculate_wall_heating_load(
+                    wall=wall,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['walls'].append({
+                    'name': wall.name,
+                    'orientation': wall.orientation.value,
+                    'area': wall.area,
+                    'u_value': wall.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
+            for roof in building_components.get('roofs', []):
+                load = self.heating_calculator.calculate_roof_heating_load(
+                    roof=roof,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['roofs'].append({
+                    'name': roof.name,
+                    'orientation': roof.orientation.value,
+                    'area': roof.area,
+                    'u_value': roof.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
+            for floor in building_components.get('floors', []):
+                load = self.heating_calculator.calculate_floor_heating_load(
+                    floor=floor,
+                    ground_temp=outdoor_conditions['ground_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['floors'].append({
+                    'name': floor.name,
+                    'area': floor.area,
+                    'u_value': floor.u_value,
+                    'delta_t': indoor_conditions['temperature'] - outdoor_conditions['ground_temperature'],
+                    'load': load / 1000
+                })
+            
+            for window in building_components.get('windows', []):
+                load = self.heating_calculator.calculate_window_heating_load(
+                    window=window,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['windows'].append({
+                    'name': window.name,
+                    'orientation': window.orientation.value,
+                    'area': window.area,
+                    'u_value': window.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
+            for door in building_components.get('doors', []):
+                load = self.heating_calculator.calculate_door_heating_load(
+                    door=door,
+                    outdoor_temp=outdoor_conditions['design_temperature'],
+                    indoor_temp=indoor_conditions['temperature']
+                )
+                results['detailed_loads']['doors'].append({
+                    'name': door.name,
+                    'orientation': door.orientation.value,
+                    'area': door.area,
+                    'u_value': door.u_value,
+                    'delta_t': delta_t,
+                    'load': load / 1000
+                })
+            
             return True, "Heating calculation completed.", results
         except Exception as e:
             return False, f"Heating calculation error: {str(e)}", {}