Update app/hvac_loads.py

app/hvac_loads.py

@@ -11,7 +11,7 @@ from typing import Dict, List, Optional, NamedTuple, Any, Tuple
 from enum import Enum
 import streamlit as st
 from app.materials_library import GlazingMaterial, Material, MaterialLibrary
-from app.internal_loads import PEOPLE_ACTIVITY_LEVELS, DIVERSITY_FACTORS, LIGHTING_FIXTURE_TYPES, EQUIPMENT_HEAT_GAINS, VENTILATION_RATES, INFILTRATION_SETTINGS
+from app.internal_loads import PEOPLE_ACTIVITY_LEVELS, LIGHTING_FIXTURE_TYPES, DEFAULT_BUILDING_INTERNALS
 from datetime import datetime
 from collections import defaultdict
 import logging
@@ -64,31 +64,17 @@ class TFMCalculations:
         ctf = CTFCalculator.calculate_ctf_coefficients(component)
         
         # Initialize history terms (simplified: assume steady-state history for demonstration)
-        # In practice, maintain temperature and flux histories
         load = component.u_value * component.area * delta_t
         for i in range(len(ctf.Y)):
             load += component.area * ctf.Y[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
             load -= component.area * ctf.Z[i] * (outdoor_temp - indoor_temp) * np.exp(-i * 3600 / 3600)
-            # Note: F terms require flux history, omitted here for simplicity
         cooling_load = load / 1000 if mode == "cooling" else 0
         heating_load = -load / 1000 if mode == "heating" else 0
         return cooling_load, heating_load
 
     @staticmethod
     def day_of_year(month: int, day: int, year: int) -> int:
-        """Calculate day of the year (n) from month, day, and year, accounting for leap years.
-
-        Args:
-            month (int): Month of the year (1-12).
-            day (int): Day of the month (1-31).
-            year (int): Year.
-
-        Returns:
-            int: Day of the year (1-365 or 366 for leap years).
-
-        References:
-            ASHRAE Handbook—Fundamentals, Chapter 18.
-        """
+        """Calculate day of the year (n) from month, day, and year, accounting for leap years."""
         days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
         if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
             days_in_month[1] = 29
@@ -96,17 +82,7 @@ class TFMCalculations:
 
     @staticmethod
     def equation_of_time(n: int) -> float:
-        """Calculate Equation of Time (EOT) in minutes using Spencer's formula.
-
-        Args:
-            n (int): Day of the year (1-365 or 366).
-
-        Returns:
-            float: Equation of Time in minutes.
-
-        References:
-            ASHRAE Handbook—Fundamentals, Chapter 18.
-        """
+        """Calculate Equation of Time (EOT) in minutes using Spencer's formula."""
         B = (n - 1) * 360 / 365
         B_rad = math.radians(B)
         EOT = 229.2 * (0.000075 + 0.001868 * math.cos(B_rad) - 0.032077 * math.sin(B_rad) -
@@ -115,24 +91,12 @@ class TFMCalculations:
 
     @staticmethod
     def calculate_dynamic_shgc(glazing_type: str, cos_theta: float) -> float:
-        """Calculate dynamic SHGC based on incidence angle.
-
-        Args:
-            glazing_type (str): Type of glazing (e.g., 'Single Clear').
-            cos_theta (float): Cosine of the angle of incidence.
-
-        Returns:
-            float: Dynamic SHGC value.
-
-        References:
-            ASHRAE Handbook—Fundamentals, Chapter 15, Table 13.
-        """
+        """Calculate dynamic SHGC based on incidence angle."""
         if glazing_type not in TFMCalculations.SHGC_COEFFICIENTS:
             logger.warning(f"Unknown glazing type '{glazing_type}'. Using default SHGC coefficients for Single Clear.")
             glazing_type = "Single Clear"
         
         c = TFMCalculations.SHGC_COEFFICIENTS[glazing_type]
-        # Incidence angle modifier: f(cos(θ)) = c_0 + c_1·cos(θ) + c_2·cos²(θ) + c_3·cos³(θ) + c_4·cos⁴(θ) + c_5·cos⁵(θ)
         f_cos_theta = (c[0] + c[1] * cos_theta + c[2] * cos_theta**2 +
                        c[3] * cos_theta**3 + c[4] * cos_theta**4 + c[5] * cos_theta**5)
         return f_cos_theta
@@ -141,60 +105,37 @@ class TFMCalculations:
     def get_surface_parameters(component: Any, building_info: Dict, material_library: MaterialLibrary, 
                              project_materials: Dict, project_constructions: Dict, 
                              project_glazing_materials: Dict) -> Tuple[float, float, float, Optional[float], float]:
-        """
-        Determine surface parameters (tilt, azimuth, h_o, emissivity, absorptivity) for a component.
-        Uses MaterialLibrary to fetch properties from first layer for walls/roofs, and GlazingMaterial for windows/skylights.
-        Handles orientation and tilt based on component type:
-        - Walls, Windows: Azimuth = elevation base azimuth + component.rotation; Tilt = 90°.
-        - Roofs, Skylights: Azimuth = component.orientation; Tilt = component.tilt (default 0°).
-        - Floors: Tilt = 180°; Azimuth = 0°.
-        
-        Args:
-            component: Component object with component_type, elevation, rotation, orientation, tilt,
-                      construction, or glazing_material.
-            building_info (Dict): Building information containing orientation_angle for elevation mapping.
-            material_library: MaterialLibrary instance for accessing library materials/constructions.
-            project_materials: Dict of project-specific Material objects.
-            project_constructions: Dict of project-specific Construction objects.
-            project_glazing_materials: Dict of project-specific GlazingMaterial objects.
-
-        Returns:
-            Tuple[float, float, float, Optional[float], float]: Surface tilt (°), surface azimuth (°),
-            h_o (W/m²·K), emissivity, absorptivity.
-        """
-        # Default parameters
+        """Determine surface parameters (tilt, azimuth, h_o, emissivity, absorptivity) for a component."""
         component_name = getattr(component, 'name', 'unnamed_component')
         
-        # Initialize default values
-        surface_tilt = 90.0  # Default vertical for walls, windows
-        surface_azimuth = 0.0  # Default north-facing
-        h_o = 17.0  # Default exterior convection coefficient
-        emissivity = 0.9  # Default for opaque components
-        absorptivity = 0.6  # Default
+        surface_tilt = 90.0
+        surface_azimuth = 0.0
+        h_o = 17.0
+        emissivity = 0.9
+        absorptivity = 0.6
         
         try:
-            # Set component-specific defaults based on type
             if component.component_type == ComponentType.ROOF:
-                surface_tilt = getattr(component, 'tilt', 0.0)  # Horizontal, upward if tilt absent
-                h_o = 23.0  # W/m²·K for roofs
+                surface_tilt = getattr(component, 'tilt', 0.0)
+                h_o = 23.0
                 surface_azimuth = getattr(component, 'orientation', 0.0)
                 logger.debug(f"Roof component {component_name}: using orientation={surface_azimuth}, tilt={surface_tilt}")
                 
             elif component.component_type == ComponentType.SKYLIGHT:
-                surface_tilt = getattr(component, 'tilt', 0.0)  # Horizontal, upward if tilt absent
-                h_o = 23.0  # W/m²·K for skylights
+                surface_tilt = getattr(component, 'tilt', 0.0)
+                h_o = 23.0
                 surface_azimuth = getattr(component, 'orientation', 0.0)
                 logger.debug(f"Skylight component {component_name}: using orientation={surface_azimuth}, tilt={surface_tilt}")
                 
             elif component.component_type == ComponentType.FLOOR:
-                surface_tilt = 180.0  # Horizontal, downward
-                h_o = 17.0  # W/m²·K
-                surface_azimuth = 0.0  # Default azimuth for floors
+                surface_tilt = 180.0
+                h_o = 17.0
+                surface_azimuth = 0.0
                 logger.debug(f"Floor component {component_name}: using default azimuth={surface_azimuth}, tilt={surface_tilt}")
                 
             else:  # WALL, WINDOW
-                surface_tilt = 90.0  # Vertical
-                h_o = 17.0  # W/m²·K
+                surface_tilt = 90.0
+                h_o = 17.0
                 elevation = getattr(component, 'elevation', None)
                 if not elevation:
                     logger.warning(f"Component {component_name} ({component.component_type.value}) is missing 'elevation' field. Using default azimuth=0.")
@@ -207,23 +148,17 @@ class TFMCalculations:
                         "C": (base_azimuth + 180.0) % 360,
                         "D": (base_azimuth + 270.0) % 360
                     }
-
                     if elevation not in elevation_angles:
-                        logger.warning(f"Invalid elevation '{elevation}' for component {component_name} ({component.component_type.value}). "
-                                      f"Expected one of {list(elevation_angles.keys())}. Using default azimuth=0.")
+                        logger.warning(f"Invalid elevation '{elevation}' for component {component_name}. Using default azimuth=0.")
                         surface_azimuth = 0.0
                     else:
                         surface_azimuth = (elevation_angles[elevation] + getattr(component, 'rotation', 0.0)) % 360
-                        logger.debug(f"Component {component_name} ({component.component_type.value}): elevation={elevation}, "
-                                    f"base_azimuth={elevation_angles[elevation]}, rotation={getattr(component, 'rotation', 0.0)}, "
-                                    f"total_azimuth={surface_azimuth}, tilt={surface_tilt}")
+                        logger.debug(f"Component {component_name}: elevation={elevation}, base_azimuth={elevation_angles[elevation]}, rotation={getattr(component, 'rotation', 0.0)}, total_azimuth={surface_azimuth}")
 
-            # Fetch material properties
             if component.component_type in [ComponentType.WALL, ComponentType.ROOF]:
                 construction = getattr(component, 'construction', None)
                 if not construction:
-                    logger.warning(f"No construction defined for {component_name} ({component.component_type.value}). "
-                                  f"Using defaults: absorptivity=0.6, emissivity=0.9.")
+                    logger.warning(f"No construction defined for {component_name}. Using defaults: absorptivity=0.6, emissivity=0.9.")
                 else:
                     construction_obj = None
                     if hasattr(construction, 'name'):
@@ -231,25 +166,21 @@ class TFMCalculations:
                                            material_library.library_constructions.get(construction.name))
                     
                     if not construction_obj:
-                        logger.warning(f"Construction not found for {component_name} ({component.component_type.value}). "
-                                      f"Using defaults: absorptivity=0.6, emissivity=0.9.")
+                        logger.warning(f"Construction not found for {component_name}. Using defaults: absorptivity=0.6, emissivity=0.9.")
                     elif not construction_obj.layers:
-                        logger.warning(f"No layers in construction for {component_name} ({component.component_type.value}). "
-                                      f"Using defaults: absorptivity=0.6, emissivity=0.9.")
+                        logger.warning(f"No layers in construction for {component_name}. Using defaults: absorptivity=0.6, emissivity=0.9.")
                     else:
                         first_layer = construction_obj.layers[0]
                         material = first_layer.get("material")
                         if material:
                             absorptivity = getattr(material, 'absorptivity', 0.6)
                             emissivity = getattr(material, 'emissivity', 0.9)
-                            logger.debug(f"Using first layer material for {component_name} ({component.component_type.value}): "
-                                        f"absorptivity={absorptivity}, emissivity={emissivity}")
+                            logger.debug(f"Using first layer material for {component_name}: absorptivity={absorptivity}, emissivity={emissivity}")
 
             elif component.component_type in [ComponentType.WINDOW, ComponentType.SKYLIGHT]:
                 glazing_material = getattr(component, 'glazing_material', None)
                 if not glazing_material:
-                    logger.warning(f"No glazing material defined for {component_name} ({component.component_type.value}). "
-                                  f"Using default SHGC=0.7, h_o={h_o}.")
+                    logger.warning(f"No glazing material defined for {component_name}. Using default SHGC=0.7, h_o={h_o}.")
                     shgc = 0.7
                 else:
                     glazing_material_obj = None
@@ -258,18 +189,16 @@ class TFMCalculations:
                                                material_library.library_glazing_materials.get(glazing_material.name))
                     
                     if not glazing_material_obj:
-                        logger.warning(f"Glazing material not found for {component_name} ({component.component_type.value}). "
-                                      f"Using default SHGC=0.7, h_o={h_o}.")
+                        logger.warning(f"Glazing material not found for {component_name}. Using default SHGC=0.7, h_o={h_o}.")
                         shgc = 0.7
                     else:
                         shgc = getattr(glazing_material_obj, 'shgc', 0.7)
                         h_o = getattr(glazing_material_obj, 'h_o', h_o)
-                        logger.debug(f"Using glazing material for {component_name} ({component.component_type.value}): "
-                                    f"shgc={shgc}, h_o={h_o}")
+                        logger.debug(f"Using glazing material for {component_name}: shgc={shgc}, h_o={h_o}")
                 emissivity = None
 
         except Exception as e:
-            logger.error(f"Error retrieving surface parameters for {component_name} ({component.component_type.value}): {str(e)}")
+            logger.error(f"Error retrieving surface parameters for {component_name}: {str(e)}")
             if component.component_type == ComponentType.ROOF:
                 surface_tilt = 0.0
                 h_o = 23.0
@@ -294,27 +223,12 @@ class TFMCalculations:
                 shgc = 0.7
                 emissivity = None
 
-        logger.info(f"Final surface parameters for {component_name} ({component.component_type.value}): "
-                   f"tilt={surface_tilt:.1f}, azimuth={surface_azimuth:.1f}, h_o={h_o:.1f}")
+        logger.info(f"Final surface parameters for {component_name}: tilt={surface_tilt:.1f}, azimuth={surface_azimuth:.1f}, h_o={h_o:.1f}")
         return surface_tilt, surface_azimuth, h_o, emissivity, absorptivity
 
     @staticmethod
     def calculate_solar_load(component, hourly_data: Dict, hour: int, building_orientation: float, mode: str = "none") -> float:
-        """Calculate solar load in kW (cooling only) using ASHRAE-compliant solar calculations.
-        
-        Args:
-            component: Component object with area, component_type, elevation, glazing_material, shgc, iac.
-            hourly_data (Dict): Hourly weather data including solar radiation.
-            hour (int): Current hour.
-            building_orientation (float): Building orientation angle in degrees.
-            mode (str): Operating mode ('cooling', 'heating', 'none').
-
-        Returns:
-            float: Solar cooling load in kW. Returns 0 for non-cooling modes or non-fenestration components.
-
-        References:
-            ASHRAE Handbook—Fundamentals, Chapters 15 and 18.
-        """
+        """Calculate solar load in kW (cooling only) using ASHRAE-compliant solar calculations."""
         if mode != "cooling":
             return 0
             
@@ -329,8 +243,8 @@ class TFMCalculations:
                 from app.material_library import MaterialLibrary
                 material_library = MaterialLibrary()
                 st.session_state.material_library = material_library
-                logger.info(f"Created new MaterialLibrary for {component_name} ({component.component_type.value})")
-            
+                logger.info(f"Created new MaterialLibrary for {component_name}")
+
             project_materials = st.session_state.get("project_data", {}).get("materials", {}).get("project", {})
             project_constructions = st.session_state.get("project_data", {}).get("constructions", {}).get("project", {})
             project_glazing_materials = st.session_state.get("project_data", {}).get("fenestrations", {}).get("project", {})
@@ -338,45 +252,45 @@ class TFMCalculations:
             latitude = climate_data.get("latitude", 0.0)
             longitude = climate_data.get("longitude", 0.0)
             timezone = climate_data.get("time_zone", 0.0)
-            ground_reflectivity = st.session_state.get("project_data", {}).get("climate_data", {}).get("ground_reflectivity", 0.2)
+            ground_reflectivity = climate_data.get("ground_reflectivity", 0.2)
 
             if not -90 <= latitude <= 90:
-                logger.warning(f"Invalid latitude {latitude} for {component_name} ({component.component_type.value}). Using default 0.0.")
+                logger.warning(f"Invalid latitude {latitude} for {component_name}. Using default 0.0.")
                 latitude = 0.0
             if not -180 <= longitude <= 180:
-                logger.warning(f"Invalid longitude {longitude} for {component_name} ({component.component_type.value}). Using default 0.0.")
+                logger.warning(f"Invalid longitude {longitude} for {component_name}. Using default 0.0.")
                 longitude = 0.0
             if not -12 <= timezone <= 14:
-                logger.warning(f"Invalid timezone {timezone} for {component_name} ({component.component_type.value}). Using default 0.0.")
+                logger.warning(f"Invalid timezone {timezone} for {component_name}. Using default 0.0.")
                 timezone = 0.0
             if not 0 <= ground_reflectivity <= 1:
-                logger.warning(f"Invalid ground_reflectivity {ground_reflectivity} for {component_name} ({component.component_type.value}). Using default 0.2.")
+                logger.warning(f"Invalid ground_reflectivity {ground_reflectivity} for {component_name}. Using default 0.2.")
                 ground_reflectivity = 0.2
 
             required_fields = ["month", "day", "hour", "global_horizontal_radiation", "direct_normal_radiation", 
                              "diffuse_horizontal_radiation", "dry_bulb"]
             if not all(field in hourly_data for field in required_fields):
-                logger.warning(f"Missing required fields in hourly_data for hour {hour} for {component_name} ({component.component_type.value}): {hourly_data}")
+                logger.warning(f"Missing required fields in hourly_data for hour {hour} for {component_name}: {hourly_data}")
                 return 0
 
             if hourly_data["global_horizontal_radiation"] <= 0:
-                logger.info(f"No solar load for hour {hour} due to GHI={hourly_data['global_horizontal_radiation']} for {component_name} ({component.component_type.value})")
+                logger.info(f"No solar load for hour {hour} due to GHI={hourly_data['global_horizontal_radiation']} for {component_name}")
                 return 0
 
             month = hourly_data["month"]
             day = hourly_data["day"]
             hour = hourly_data["hour"]
             ghi = hourly_data["global_horizontal_radiation"]
-            dni = hourly_data.get("direct_normal_radiation", ghi * 0.7)
+            dni = hourly_data.get("direct_normal_radiation", echi * 0.7)
             dhi = hourly_data.get("diffuse_horizontal_radiation", ghi * 0.3)
             outdoor_temp = hourly_data["dry_bulb"]
 
             if ghi < 0 or dni < 0 or dhi < 0:
-                logger.error(f"Negative radiation values for {month}/{day}/{hour} for {component_name} ({component.component_type.value})")
+                logger.error(f"Negative radiation values for {month}/{day}/{hour} for {component_name}")
                 raise ValueError(f"Negative radiation values for {month}/{day}/{hour}")
 
             logger.info(f"Processing solar for {month}/{day}/{hour} with GHI={ghi}, DNI={dni}, DHI={dhi}, "
-                       f"dry_bulb={outdoor_temp} for {component_name} ({component.component_type.value})")
+                       f"dry_bulb={outdoor_temp} for {component_name}")
 
             year = 2025
             n = TFMCalculations.day_of_year(month, day, year)
@@ -404,7 +318,7 @@ class TFMCalculations:
                     azimuth = 360 - azimuth if azimuth > 0 else -azimuth
 
             logger.info(f"Solar angles for {month}/{day}/{hour}: declination={delta:.2f}, LST={LST:.2f}, "
-                       f"HRA={hra:.2f}, altitude={alpha:.2f}, azimuth={azimuth:.2f} for {component_name} ({component.component_type.value})")
+                       f"HRA={hra:.2f}, altitude={alpha:.2f}, azimuth={azimuth:.2f} for {component_name}")
 
             building_info = {"orientation_angle": building_orientation}
             try:
@@ -446,7 +360,7 @@ class TFMCalculations:
             
             cos_theta = max(min(cos_theta, 1.0), 0.0)
             
-            logger.info(f"  Component {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
+            logger.info(f"  Component {component_name} at {month}/{day}/{hour}: "
                         f"surface_tilt={surface_tilt:.2f}, surface_azimuth={surface_azimuth:.2f}, "
                         f"cos_theta={cos_theta:.4f}")
 
@@ -473,7 +387,7 @@ class TFMCalculations:
                         shgc = getattr(glazing_material_obj, 'shgc', 0.7)
                         h_o = getattr(glazing_material_obj, 'h_o', h_o)
                     else:
-                        logger.warning(f"Glazing material not found for {component_name} ({component.component_type.value}). Using default SHGC=0.7.")
+                        logger.warning(f"Glazing material not found for {component_name}. Using default SHGC=0.7.")
                 
                 glazing_type = "Single Clear"
                 if hasattr(component, 'name') and component.name in TFMCalculations.GLAZING_TYPE_MAPPING:
@@ -485,7 +399,7 @@ class TFMCalculations:
                 
                 solar_heat_gain = component.area * shgc_dynamic * I_t * iac / 1000
                 
-                logger.info(f"Fenestration solar heat gain for {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
+                logger.info(f"Fenestration solar heat gain for {component_name} at {month}/{day}/{hour}: "
                             f"{solar_heat_gain:.4f} kW (area={component.area}, shgc_dynamic={shgc_dynamic:.4f}, "
                             f"I_t={I_t:.2f}, iac={iac})")
             
@@ -494,97 +408,203 @@ class TFMCalculations:
                 
                 solar_heat_gain = component.area * absorptivity * I_t * surface_resistance / 1000
                 
-                logger.info(f"Opaque surface solar heat gain for {component_name} ({component.component_type.value}) at {month}/{day}/{hour}: "
+                logger.info(f"Opaque surface solar heat gain for {component_name} at {month}/{day}/{hour}: "
                             f"{solar_heat_gain:.4f} kW (area={component.area}, absorptivity={absorptivity:.2f}, "
                             f"I_t={I_t:.2f}, surface_resistance={surface_resistance:.4f})")
             
             return solar_heat_gain
 
         except Exception as e:
-            logger.error(f"Error calculating solar load for {component_name} ({component.component_type.value}) at hour {hour}: {str(e)}")
+            logger.error(f"Error calculating solar load for {component_name} at hour {hour}: {str(e)}")
             return 0
 
+    @staticmethod
+    def get_schedule_fraction(schedule_name: str, hour: int, is_weekend: bool) -> float:
+        """Get the schedule fraction for the given hour and day type."""
+        schedules = st.session_state.project_data["internal_loads"].get("schedules", {})
+        schedule = schedules.get(schedule_name, {})
+        if not schedule:
+            logger.warning(f"Schedule '{schedule_name}' not found. Using fraction=1.0.")
+            return 1.0
+        values = schedule.get("weekend" if is_weekend else "weekday", [1.0] * 24)
+        hour_idx = hour % 24
+        if 0 <= hour_idx < len(values):
+            fraction = values[hour_idx]
+            logger.debug(f"Schedule '{schedule_name}' at hour {hour_idx} ({'weekend' if is_weekend else 'weekday'}): fraction={fraction:.2f}")
+            return fraction
+        logger.warning(f"Invalid hour index {hour_idx} for schedule '{schedule_name}'. Using fraction=1.0.")
+        return 1.0
+
     @staticmethod
     def calculate_internal_load(internal_loads: Dict, hour: int, operation_hours: int, area: float) -> float:
-        """Calculate total internal load in kW."""
-        total_load = 0
-        for group in internal_loads.get("people", []):
-            activity_data = group["activity_data"]
-            sensible = (activity_data["sensible_min_w"] + activity_data["sensible_max_w"]) / 2
-            latent = (activity_data["latent_min_w"] + activity_data["latent_max_w"]) / 2
-            load_per_person = sensible + latent
-            total_load += group["num_people"] * load_per_person * group["diversity_factor"]
-        for light in internal_loads.get("lighting", []):
-            lpd = light["lpd"]
-            lighting_operating_hours = light["operating_hours"]
-            fraction = min(lighting_operating_hours, operation_hours) / operation_hours if operation_hours > 0 else 0
-            lighting_load = lpd * area * fraction
-            total_load += lighting_load
-        equipment = internal_loads.get("equipment", {})
-        total_power_density = equipment.get("total_power_density", 0)
-        equipment_load = total_power_density * area
-        total_load += equipment_load
-        return total_load / 1000
+        """Calculate total internal load in kW, incorporating schedules."""
+        total_load = 0.0
+        is_weekend = False  # Simplified; in practice, determine from date
+        try:
+            # People loads
+            for group in internal_loads.get("people", []):
+                schedule_name = group.get("schedule", "Continuous")
+                fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+                sensible = group.get("total_sensible_heat", 0.0)
+                latent = group.get("total_latent_heat", 0.0)
+                group_load = (sensible + latent) * fraction / 1000  # Convert W to kW
+                total_load += group_load
+                logger.debug(f"People group '{group.get('name', 'unknown')}': sensible={sensible:.2f} W, latent={latent:.2f} W, fraction={fraction:.2f}, load={group_load:.3f} kW")
+
+            # Lighting loads
+            for light in internal_loads.get("lighting", []):
+                schedule_name = light.get("schedule", "Continuous")
+                fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+                total_power = light.get("total_power", 0.0)
+                lighting_load = total_power * fraction / 1000  # Convert W to kW
+                total_load += lighting_load
+                logger.debug(f"Lighting system '{light.get('name', 'unknown')}': total_power={total_power:.2f} W, fraction={fraction:.2f}, load={lighting_load:.3f} kW")
+
+            # Equipment loads
+            for equip in internal_loads.get("equipment", []):
+                schedule_name = equip.get("schedule", "Continuous")
+                fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+                sensible = equip.get("total_sensible_power", 0.0)
+                latent = equip.get("total_latent_power", 0.0)
+                equip_load = (sensible + latent) * fraction / 1000  # Convert W to kW
+                total_load += equip_load
+                logger.debug(f"Equipment '{equip.get('name', 'unknown')}': sensible={sensible:.2f} W, latent={latent:.2f} W, fraction={fraction:.2f}, load={equip_load:.3f} kW")
+
+            logger.info(f"Total internal load for hour {hour}: {total_load:.3f} kW")
+            return total_load
+
+        except Exception as e:
+            logger.error(f"Error calculating internal load for hour {hour}: {str(e)}")
+            return 0.0
 
     @staticmethod
     def calculate_ventilation_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> tuple[float, float]:
         """Calculate ventilation load for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
-        ventilation = internal_loads.get("ventilation", {})
-        if not ventilation:
-            return 0, 0
-        space_rate = ventilation.get("space_rate", 0.3)
-        people_rate = ventilation.get("people_rate", 2.5)
-        num_people = sum(group["num_people"] for group in internal_loads.get("people", []))
-        ventilation_flow = (space_rate * area + people_rate * num_people) / 1000
-        air_density = 1.2
-        specific_heat = 1000
         delta_t = outdoor_temp - indoor_temp
         if mode == "cooling" and delta_t <= 0:
             return 0, 0
         if mode == "heating" and delta_t >= 0:
             return 0, 0
-        load = ventilation_flow * air_density * specific_heat * delta_t / 1000
-        cooling_load = load if mode == "cooling" else 0
-        heating_load = -load if mode == "heating" else 0
-        return cooling_load, heating_load
+
+        total_cooling_load = 0.0
+        total_heating_load = 0.0
+        air_density = 1.2  # kg/m³
+        specific_heat = 1000  # J/kg·K
+        is_weekend = False  # Simplified; determine from date in practice
+
+        try:
+            for system in internal_loads.get("ventilation", []):
+                schedule_name = system.get("schedule", "Continuous")
+                fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+                system_type = system.get("system_type", "AirChanges/Hour")
+                system_area = system.get("area", area)
+                ventilation_flow = 0.0
+
+                if system_type == "AirChanges/Hour":
+                    design_flow_rate = system.get("design_flow_rate", 1.0)  # L/s·m²
+                    ventilation_flow = design_flow_rate * system_area / 1000  # Convert L/s to m³/s
+                    if system.get("ventilation_type", "Natural") == "Mechanical":
+                        fan_power = (system.get("fan_pressure_rise", 200.0) * ventilation_flow) / system.get("fan_efficiency", 0.7) / 1000  # kW
+                        total_cooling_load += fan_power * fraction
+                        logger.debug(f"Ventilation '{system.get('name', 'unknown')}': fan_power={fan_power:.3f} kW, fraction={fraction:.2f}")
+
+                elif system_type == "Wind and Stack Open Area":
+                    opening_effectiveness = system.get("opening_effectiveness", 50.0) / 100
+                    # Assume simplified flow based on area and effectiveness
+                    ventilation_flow = 0.001 * system_area * opening_effectiveness  # m³/s (placeholder)
+                
+                elif system_type in ["Balanced Flow", "Heat Recovery"]:
+                    design_flow_rate = system.get("design_flow_rate", 1.0)  # L/s·m²
+                    ventilation_flow = design_flow_rate * system_area / 1000  # Convert L/s to m³/s
+                    fan_power = (system.get("fan_pressure_rise", 200.0) * ventilation_flow) / system.get("fan_efficiency", 0.7) / 1000  # kW
+                    total_cooling_load += fan_power * fraction
+                    if system_type == "Heat Recovery":
+                        sensible_eff = system.get("sensible_effectiveness", 0.5)
+                        delta_t = delta_t * (1 - sensible_eff)
+                        logger.debug(f"Heat Recovery '{system.get('name', 'unknown')}': sensible_eff={sensible_eff:.2f}, adjusted_delta_t={delta_t:.2f}")
+
+                load = ventilation_flow * air_density * specific_heat * delta_t * fraction / 1000  # kW
+                cooling_load = load if mode == "cooling" else 0
+                heating_load = -load if mode == "heating" else 0
+                total_cooling_load += cooling_load
+                total_heating_load += heating_load
+                logger.debug(f"Ventilation '{system.get('name', 'unknown')}': flow={ventilation_flow:.4f} m³/s, fraction={fraction:.2f}, cooling={cooling_load:.3f} kW, heating={heating_load:.3f} kW")
+
+            logger.info(f"Total ventilation load for hour {hour}: cooling={total_cooling_load:.3f} kW, heating={total_heating_load:.3f} kW")
+            return total_cooling_load, total_heating_load
+
+        except Exception as e:
+            logger.error(f"Error calculating ventilation load for hour {hour}: {str(e)}")
+            return 0, 0
 
     @staticmethod
     def calculate_infiltration_load(internal_loads: Dict, outdoor_temp: float, indoor_temp: float, area: float, building_info: Dict, mode: str = "none") -> tuple[float, float]:
         """Calculate infiltration load for heating and cooling in kW based on mode."""
         if mode == "none":
             return 0, 0
-        infiltration = internal_loads.get("infiltration", {})
-        if not infiltration:
-            return 0, 0
-        method = infiltration.get("method", "ACH")
-        settings = infiltration.get("settings", {})
-        building_height = building_info.get("building_height", 3.0)
-        volume = area * building_height
-        air_density = 1.2
-        specific_heat = 1000
         delta_t = outdoor_temp - indoor_temp
         if mode == "cooling" and delta_t <= 0:
             return 0, 0
         if mode == "heating" and delta_t >= 0:
             return 0, 0
-        if method == "ACH":
-            ach = settings.get("rate", 0.5)
-            infiltration_flow = ach * volume / 3600
-        elif method == "Crack Flow":
-            ela = settings.get("ela", 0.0001)
-            wind_speed = 4.0
-            infiltration_flow = ela * area * wind_speed / 2
-        else:  # Empirical Equations
-            c = settings.get("c", 0.1)
-            n = settings.get("n", 0.65)
-            delta_t_abs = abs(delta_t)
-            infiltration_flow = c * (delta_t_abs ** n) * area / 3600
-        load = infiltration_flow * air_density * specific_heat * delta_t / 1000
-        cooling_load = load if mode == "cooling" else 0
-        heating_load = -load if mode == "heating" else 0
-        return cooling_load, heating_load
+
+        total_cooling_load = 0.0
+        total_heating_load = 0.0
+        air_density = 1.2  # kg/m³
+        specific_heat = 1000  # J/kg·K
+        building_height = building_info.get("building_height", 3.0)
+        volume = area * building_height
+        is_weekend = False  # Simplified; determine from date in practice
+
+        try:
+            for system in internal_loads.get("infiltration", []):
+                schedule_name = system.get("schedule", "Continuous")
+                fraction = TFMCalculations.get_schedule_fraction(schedule_name, hour, is_weekend)
+                system_type = system.get("system_type", "AirChanges/Hour")
+                system_area = system.get("area", area)
+                infiltration_flow = 0.0
+
+                if system_type == "AirChanges/Hour":
+                    ach = system.get("design_flow_rate", 0.3)
+                    infiltration_flow = ach * system_area * building_height / 3600  # m³/s
+                
+                elif system_type == "Effective Leakage Area":
+                    ela = system.get("effective_air_leakage_area", 100.0) / 10000  # Convert cm² to m²
+                    stack_coeff = system.get("stack_coefficient", 0.0001)
+                    wind_coeff = system.get("wind_coefficient", 0.0001)
+                    delta_t_abs = abs(delta_t)
+                    wind_speed = 4.0  # m/s, assumed
+                    Q_stack = stack_coeff * ela * (delta_t_abs ** 0.5)
+                    Q_wind = wind_coeff * ela * (wind_speed ** 2)
+                    infiltration_flow = (Q_stack ** 2 + Q_wind ** 2) ** 0.5  # m³/s
+                
+                elif system_type == "Flow Coefficient":
+                    c = system.get("flow_coefficient", 0.0001)  # m³/s·Paⁿ
+                    n = system.get("pressure_exponent", 0.6)
+                    stack_coeff = system.get("stack_coefficient", 0.0001)
+                    wind_coeff = system.get("wind_coefficient", 0.0001)
+                    delta_t_abs = abs(delta_t)
+                    wind_speed = 4.0  # m/s, assumed
+                    delta_p_stack = stack_coeff * delta_t_abs
+                    delta_p_wind = wind_coeff * (wind_speed ** 2)
+                    delta_p = (delta_p_stack ** 2 + delta_p_wind ** 2) ** 0.5
+                    infiltration_flow = c * (delta_p ** n) * system_area
+
+                load = infiltration_flow * air_density * specific_heat * delta_t * fraction / 1000  # kW
+                cooling_load = load if mode == "cooling" else 0
+                heating_load = -load if mode == "heating" else 0
+                total_cooling_load += cooling_load
+                total_heating_load += heating_load
+                logger.debug(f"Infiltration '{system.get('name', 'unknown')}': flow={infiltration_flow:.4f} m³/s, fraction={fraction:.2f}, cooling={cooling_load:.3f} kW, heating={heating_load:.3f} kW")
+
+            logger.info(f"Total infiltration load for hour {hour}: cooling={total_cooling_load:.3f} kW, heating={total_heating_load:.3f} kW")
+            return total_cooling_load, total_heating_load
+
+        except Exception as e:
+            logger.error(f"Error calculating infiltration load for hour {hour}: {str(e)}")
+            return 0, 0
 
     @staticmethod
     def get_adaptive_comfort_temp(outdoor_temp: float) -> float: