Update utils/heating_load.py

utils/heating_load.py

@@ -1,518 +1,508 @@
 """
-Heating load calculation module for HVAC Load Calculator.
-Implements ASHRAE steady-state methods with optional thermal lag for energy analysis.
+Heat transfer calculation module for HVAC Load Calculator.
+This module provides enhanced calculations for conduction, convection, radiation,
+infiltration, and solar geometry, with improved modularity and error handling.
 """
 
-from typing import Dict, List, Any, Optional, Tuple
+from typing import Optional, Tuple
 import math
 import numpy as np
-from enum import Enum
-from dataclasses import dataclass
-
-# Import utility modules
 from utils.psychrometrics import Psychrometrics
-from utils.heat_transfer import HeatTransferCalculations
-
-# Import data modules
-from data.building_components import Wall, Roof, Floor, Window, Door, Orientation, ComponentType
 
-# Safely import streamlit for debug mode
-try:
-    import streamlit as st
-except ImportError:
-    st = None
 
-class HeatingLoadCalculator:
-    """Class for heating load calculations based on ASHRAE steady-state methods."""
+class SolarCalculations:
+    """Class for solar geometry and irradiance calculations."""
     
     def __init__(self):
-        """Initialize heating load calculator with psychrometric and heat transfer calculations."""
-        self.psychrometrics = Psychrometrics()
-        self.heat_transfer = HeatTransferCalculations()
-        self.safety_factor = 1.15  # 15% safety factor for design loads
-        self.time_step = 24.0  # Daily time step for thermal lag in hours
-
-    def validate_inputs(self, components: Dict[str, List[Any]], outdoor_temp: float, indoor_temp: float) -> None:
+        """Initialize solar calculations with cached values."""
+        self._declination_cache = {}  # Cache for declination by day of year
+    
+    def validate_angle(self, angle: float, name: str, min_val: float, max_val: float) -> None:
         """
-        Validate input parameters for heating load calculations.
+        Validate an angle input.
         
         Args:
-            components: Dictionary of building components
-            outdoor_temp: Outdoor design temperature in °C
-            indoor_temp: Indoor design temperature in °C
+            angle: Angle in degrees
+            name: Name of the angle for error messages
+            min_val: Minimum allowed value
+            max_val: Maximum allowed value
             
         Raises:
-            ValueError: If inputs are invalid
-        """
-        if not components:
-            raise ValueError("Building components dictionary cannot be empty")
-        for component_type, comp_list in components.items():
-            if not isinstance(comp_list, list):
-                raise ValueError(f"Components for {component_type} must be a list")
-            for comp in comp_list:
-                if not hasattr(comp, 'area') or comp.area <= 0:
-                    raise ValueError(f"Invalid area for {component_type}: {comp.name}")
-                if not hasattr(comp, 'u_value') or comp.u_value <= 0:
-                    raise ValueError(f"Invalid U-value for {component_type}: {comp.name}")
-        if not -50 <= outdoor_temp <= 60 or not -50 <= indoor_temp <= 60:
-            raise ValueError("Temperatures must be between -50°C and 60°C")
-        if indoor_temp - outdoor_temp < 1:
-            raise ValueError("Indoor temperature must be at least 1°C above outdoor temperature for heating")
-
-    def calculate_wall_heating_load(self, wall: Wall, outdoor_temp: float, indoor_temp: float, apply_thermal_lag: bool = False) -> float:
+            ValueError: If angle is out of range
+        """
+        if not min_val <= angle <= max_val:
+            raise ValueError(f"{name} {angle}° is outside valid range ({min_val} to {max_val}°)")
+    
+    def solar_declination(self, day_of_year: int) -> float:
         """
-        Calculate heating load for a wall, with optional thermal lag for energy analysis.
+        Calculate solar declination angle for a given day of the year.
         
         Args:
-            wall: Wall component
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            apply_thermal_lag: Apply thermal lag for transient calculations
+            day_of_year: Day of the year (1-365)
             
         Returns:
-            Heating load in W
-        """
-        delta_t = indoor_temp - outdoor_temp
-        if delta_t <= 1:
-            return 0.0
-        
-        lag_factor = 1.0
-        if apply_thermal_lag and wall.material_layers:
-            # Calculate total thermal mass (J/m²·K)
-            total_thermal_mass = sum(layer.thermal_mass for layer in wall.material_layers if layer.thermal_mass is not None)
-            if total_thermal_mass:
-                # Thermal mass per component (J/K)
-                component_thermal_mass = total_thermal_mass * wall.area
-                # Time constant: Assume R-value-based estimation (h)
-                total_r = wall.total_r_value_from_layers or wall.r_value
-                time_constant = total_thermal_mass * total_r / 3600  # Convert J/m²·K * m²·K/W to hours
-                lag_factor = self.heat_transfer.thermal_lag_factor(component_thermal_mass, time_constant, self.time_step)
-        
-        adjusted_delta_t = delta_t * lag_factor
-        load = self.heat_transfer.conduction_heat_transfer(wall.u_value, wall.area, adjusted_delta_t)
-        return max(0, load)
-
-    def calculate_roof_heating_load(self, roof: Roof, outdoor_temp: float, indoor_temp: float, apply_thermal_lag: bool = False) -> float:
+            Solar declination angle in degrees
         """
-        Calculate heating load for a roof, with optional thermal lag for energy analysis.
+        if not 1 <= day_of_year <= 365:
+            raise ValueError(f"Day of year {day_of_year} must be between 1 and 365")
+        
+        if day_of_year in self._declination_cache:
+            return self._declination_cache[day_of_year]
+        
+        declination = 23.45 * math.sin(math.radians(360 * (284 + day_of_year) / 365))
+        self._declination_cache[day_of_year] = declination
+        return declination
+    
+    def solar_hour_angle(self, hour: float) -> float:
+        """
+        Calculate solar hour angle for a given hour of the day.
         
         Args:
-            roof: Roof component
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
-            apply_thermal_lag: Apply thermal lag for transient calculations
+            hour: Hour of the day (0-23)
             
         Returns:
-            Heating load in W
-        """
-        delta_t = indoor_temp - outdoor_temp
-        if delta_t <= 1:
-            return 0.0
-        
-        lag_factor = 1.0
-        if apply_thermal_lag and roof.material_layers:
-            total_thermal_mass = sum(layer.thermal_mass for layer in roof.material_layers if layer.thermal_mass is not None)
-            if total_thermal_mass:
-                component_thermal_mass = total_thermal_mass * roof.area
-                total_r = roof.total_r_value_from_layers or roof.r_value
-                time_constant = total_thermal_mass * total_r / 3600
-                lag_factor = self.heat_transfer.thermal_lag_factor(component_thermal_mass, time_constant, self.time_step)
-        
-        adjusted_delta_t = delta_t * lag_factor
-        load = self.heat_transfer.conduction_heat_transfer(roof.u_value, roof.area, adjusted_delta_t)
-        return max(0, load)
-
-    def calculate_floor_heating_load(self, floor: Floor, ground_temp: float, indoor_temp: float) -> float:
+            Solar hour angle in degrees
         """
-        Calculate heating load for a floor, using dynamic F-factor for ground contact.
+        if not 0 <= hour <= 23:
+            raise ValueError(f"Hour {hour} must be between 0 and 23")
+        return 15 * (hour - 12)
+    
+    def solar_altitude(self, latitude: float, declination: float, hour_angle: float) -> float:
+        """
+        Calculate solar altitude angle.
         
         Args:
-            floor: Floor component
-            ground_temp: Ground temperature in °C
-            indoor_temp: Indoor temperature in °C
+            latitude: Latitude in degrees
+            declination: Solar declination angle in degrees
+            hour_angle: Solar hour angle in degrees
             
         Returns:
-            Heating load in W
-        """
-        delta_t = indoor_temp - ground_temp
-        if delta_t <= 1:
-            return 0.0
-        
-        if floor.is_ground_contact:
-            # Infer insulation from material layers
-            f_factor = 0.3 if (floor.total_r_value_from_layers and floor.total_r_value_from_layers > 2.0) else 0.73  # W/m·K
-            load = f_factor * floor.perimeter_length * delta_t
-        else:
-            load = self.heat_transfer.conduction_heat_transfer(floor.u_value, floor.area, delta_t)
-        
-        debug_mode = False
-        if st is not None and hasattr(st, 'session_state') and hasattr(st.session_state, 'debug_mode'):
-            debug_mode = st.session_state.debug_mode
-        if debug_mode:
-            print(f"Debug: Floor {floor.name} load: {load:.2f} W, Delta T: {delta_t:.2f}°C, F-factor: {f_factor:.2f}")
-        
-        return max(0, load)
-
-    def calculate_window_heating_load(self, window: Window, outdoor_temp: float, indoor_temp: float) -> float:
+            Solar altitude angle in degrees
+        """
+        self.validate_angle(latitude, "Latitude", -90, 90)
+        self.validate_angle(declination, "Declination", -90, 90)
+        self.validate_angle(hour_angle, "Hour angle", -180, 180)
+        
+        lat_rad = math.radians(latitude)
+        dec_rad = math.radians(declination)
+        ha_rad = math.radians(hour_angle)
+        
+        sin_alt = math.sin(lat_rad) * math.sin(dec_rad) + math.cos(lat_rad) * math.cos(dec_rad) * math.cos(ha_rad)
+        altitude = math.degrees(math.asin(sin_alt))
+        return max(0, altitude)
+    
+    def solar_azimuth(self, latitude: float, declination: float, hour_angle: float, altitude: float) -> float:
         """
-        Calculate heating load for a window.
+        Calculate solar azimuth angle.
         
         Args:
-            window: Window component
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
+            latitude: Latitude in degrees
+            declination: Solar declination angle in degrees
+            hour_angle: Solar hour angle in degrees
+            altitude: Solar altitude angle in degrees
             
         Returns:
-            Heating load in W
+            Solar azimuth angle in degrees
         """
-        delta_t = indoor_temp - outdoor_temp
-        if delta_t <= 1:
-            return 0.0
-        
-        # Use effective U-value with drapery if applicable
-        u_value = window.get_effective_u_value()
-        load = self.heat_transfer.conduction_heat_transfer(u_value, window.area, delta_t)
-        return max(0, load)
-
-    def calculate_door_heating_load(self, door: Door, outdoor_temp: float, indoor_temp: float) -> float:
+        self.validate_angle(latitude, "Latitude", -90, 90)
+        self.validate_angle(declination, "Declination", -90, 90)
+        self.validate_angle(hour_angle, "Hour angle", -180, 180)
+        self.validate_angle(altitude, "Altitude", 0, 90)
+        
+        lat_rad = math.radians(latitude)
+        dec_rad = math.radians(declination)
+        ha_rad = math.radians(hour_angle)
+        alt_rad = math.radians(altitude)
+        
+        cos_az = (math.sin(alt_rad) * math.sin(lat_rad) - math.sin(dec_rad)) / (math.cos(alt_rad) * math.cos(lat_rad))
+        cos_az = max(-1, min(1, cos_az))
+        azimuth = math.degrees(math.acos(cos_az))
+        
+        if hour_angle > 0:
+            azimuth = 360 - azimuth
+        return azimuth
+    
+    def incident_angle(self, surface_tilt: float, surface_azimuth: float, 
+                      solar_altitude: float, solar_azimuth: float) -> float:
         """
-        Calculate heating load for a door.
+        Calculate angle of incidence for a surface.
         
         Args:
-            door: Door component
-            outdoor_temp: Outdoor temperature in °C
-            indoor_temp: Indoor temperature in °C
+            surface_tilt: Surface tilt angle in degrees (0=horizontal, 90=vertical)
+            surface_azimuth: Surface azimuth angle in degrees
+            solar_altitude: Solar altitude angle in degrees
+            solar_azimuth: Solar azimuth angle in degrees
             
         Returns:
-            Heating load in W
+            Angle of incidence in degrees
         """
-        delta_t = indoor_temp - outdoor_temp
-        if delta_t <= 1:
-            return 0.0
-        
-        load = self.heat_transfer.conduction_heat_transfer(door.u_value, door.area, delta_t)
-        return max(0, load)
-
-    def calculate_infiltration_heating_load(self, indoor_conditions: Dict[str, float], 
-                                          outdoor_conditions: Dict[str, float], 
-                                          infiltration: Dict[str, float], 
-                                          building_height: float) -> Tuple[float, float]:
+        self.validate_angle(surface_tilt, "Surface tilt", 0, 180)
+        self.validate_angle(surface_azimuth, "Surface azimuth", 0, 360)
+        self.validate_angle(solar_altitude, "Solar altitude", 0, 90)
+        self.validate_angle(solar_azimuth, "Solar azimuth", 0, 360)
+        
+        tilt_rad = math.radians(surface_tilt)
+        az_diff_rad = math.radians(solar_azimuth - surface_azimuth)
+        alt_rad = math.radians(solar_altitude)
+        
+        cos_theta = (math.sin(alt_rad) * math.cos(tilt_rad) +
+                     math.cos(alt_rad) * math.sin(tilt_rad) * math.cos(az_diff_rad))
+        cos_theta = max(0, min(1, cos_theta))
+        return math.degrees(math.acos(cos_theta))
+    
+    def direct_normal_irradiance(self, solar_altitude: float) -> float:
         """
-        Calculate sensible and latent heating loads due to infiltration.
+        Calculate direct normal irradiance.
         
         Args:
-            indoor_conditions: Indoor conditions (temperature, relative_humidity)
-            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity, wind_speed)
-            infiltration: Infiltration parameters (flow_rate, crack_length, height)
-            building_height: Building height in m
+            solar_altitude: Solar altitude angle in degrees
             
         Returns:
-            Tuple of sensible and latent loads in W
-        """
-        delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
-        if delta_t <= 1:
-            return 0.0, 0.0
-        
-        # Calculate pressure differences
-        wind_pd = self.heat_transfer.wind_pressure_difference(outdoor_conditions['wind_speed'])
-        stack_pd = self.heat_transfer.stack_pressure_difference(
-            building_height, 
-            indoor_conditions['temperature'] + 273.15, 
-            outdoor_conditions['design_temperature'] + 273.15
-        )
-        total_pd = self.heat_transfer.combined_pressure_difference(wind_pd, stack_pd)
-        
-        # Calculate infiltration flow rate with adjusted coefficient
-        crack_length = infiltration.get('crack_length', 20.0)
-        flow_rate = self.heat_transfer.crack_method_infiltration(crack_length, 0.00031, total_pd)
-        
-        # Calculate humidity ratio difference
-        w_indoor = self.psychrometrics.humidity_ratio(
-            indoor_conditions['temperature'], 
-            indoor_conditions['relative_humidity']
-        )
-        w_outdoor = self.psychrometrics.humidity_ratio(
-            outdoor_conditions['design_temperature'], 
-            outdoor_conditions['design_relative_humidity']
-        )
-        delta_w = max(0, w_indoor - w_outdoor)
-        
-        # Calculate sensible and latent loads
-        sensible_load = self.heat_transfer.infiltration_heat_transfer(flow_rate, delta_t)
-        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(flow_rate, delta_w)
-        
-        debug_mode = False
-        if st is not None and hasattr(st, 'session_state') and hasattr(st.session_state, 'debug_mode'):
-            debug_mode = st.session_state.debug_mode
-        if debug_mode:
-            print(f"Debug: Infiltration flow rate: {flow_rate:.6f} m³/s, Sensible load: {sensible_load:.2f} W, Latent load: {latent_load:.2f} W")
-        
-        return max(0, sensible_load), max(0, latent_load)
-
-    def calculate_ventilation_heating_load(self, ventilation: Dict[str, float], 
-                                         indoor_conditions: Dict[str, float], 
-                                         outdoor_conditions: Dict[str, float]) -> Tuple[float, float]:
+            Direct normal irradiance in W/m^2
         """
-        Calculate sensible and latent heating loads due to ventilation.
+        self.validate_angle(solar_altitude, "Solar altitude", 0, 90)
+        if solar_altitude <= 0:
+            return 0
+        air_mass = 1 / math.cos(math.radians(90 - solar_altitude))
+        dni = 1367 * (1 - 0.14 * air_mass)  # Simplified model
+        return max(0, dni)
+    
+    def diffuse_horizontal_irradiance(self, dni: float, solar_altitude: float) -> float:
+        """
+        Calculate diffuse horizontal irradiance.
         
         Args:
-            ventilation: Ventilation parameters (flow_rate)
-            indoor_conditions: Indoor conditions (temperature, relative_humidity)
-            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity)
+            dni: Direct normal irradiance in W/m^2
+            solar_altitude: Solar altitude angle in degrees
             
         Returns:
-            Tuple of sensible and latent loads in W
+            Diffuse horizontal irradiance in W/m^2
         """
-        delta_t = indoor_conditions['temperature'] - outdoor_conditions['design_temperature']
-        if delta_t <= 1:
-            return 0.0, 0.0
-        
-        flow_rate = ventilation['flow_rate']
-        
-        w_indoor = self.psychrometrics.humidity_ratio(
-            indoor_conditions['temperature'], 
-            indoor_conditions['relative_humidity']
-        )
-        w_outdoor = self.psychrometrics.humidity_ratio(
-            outdoor_conditions['design_temperature'], 
-            outdoor_conditions['design_relative_humidity']
-        )
-        delta_w = max(0, w_indoor - w_outdoor)
-        
-        sensible_load = self.heat_transfer.infiltration_heat_transfer(flow_rate, delta_t)
-        latent_load = self.heat_transfer.infiltration_latent_heat_transfer(flow_rate, delta_w)
-        
-        return max(0, sensible_load), max(0, latent_load)
-
-    def calculate_internal_gains(self, internal_loads: Dict[str, Any]) -> float:
+        self.validate_angle(solar_altitude, "Solar altitude", 0, 90)
+        if solar_altitude <= 0:
+            return 0
+        return 0.1 * dni  # Simplified model
+    
+    def irradiance_on_surface(self, dni: float, dhi: float, incident_angle: float, surface_tilt: float) -> float:
         """
-        Calculate internal heat gains from people, lighting, and equipment.
+        Calculate total irradiance on a tilted surface.
         
         Args:
-            internal_loads: Internal loads (people, lights, equipment)
+            dni: Direct normal irradiance in W/m^2
+            dhi: Diffuse horizontal irradiance in W/m^2
+            incident_angle: Angle of incidence in degrees
+            surface_tilt: Surface tilt angle in degrees
             
         Returns:
-            Total internal gains in W
+            Total irradiance in W/m^2
         """
-        total_gains = 0.0
-        
-        # People gains
-        people = internal_loads.get('people', {})
-        if people.get('number', 0) > 0:
-            sensible_gain = people.get('sensible_gain', 70.0)
-            total_gains += people['number'] * sensible_gain
-        
-        # Lighting gains
-        lights = internal_loads.get('lights', {})
-        if lights.get('power', 0) > 0:
-            total_gains += lights['power'] * lights.get('use_factor', 0.8)
-        
-        # Equipment gains
-        equipment = internal_loads.get('equipment', {})
-        if equipment.get('power', 0) > 0:
-            total_gains += equipment['power'] * equipment.get('use_factor', 0.7)
-        
-        return max(0, total_gains)
+        self.validate_angle(incident_angle, "Incident angle", 0, 90)
+        self.validate_angle(surface_tilt, "Surface tilt", 0, 180)
+        if dni < 0 or dhi < 0:
+            raise ValueError("Irradiance values cannot be negative")
+        
+        direct = dni * math.cos(math.radians(incident_angle))
+        diffuse = dhi * (1 + math.cos(math.radians(surface_tilt))) / 2
+        return max(0, direct + diffuse)
+
 
-    def calculate_design_heating_load(self, building_components: Dict[str, List[Any]], 
-                                    outdoor_conditions: Dict[str, float], 
-                                    indoor_conditions: Dict[str, float], 
-                                    internal_loads: Dict[str, Any]) -> Dict[str, float]:
+class HeatTransferCalculations:
+    """Class for heat transfer calculations."""
+    
+    def __init__(self):
+        """Initialize heat transfer calculations with solar and psychrometric calculations."""
+        self.solar = SolarCalculations()
+        self.psychrometrics = Psychrometrics()
+    
+    def validate_inputs(self, temp: float, area: float = 0.0, flow_rate: float = 0.0) -> None:
+        """
+        Validate input parameters for heat transfer calculations.
+        
+        Args:
+            temp: Temperature in °C
+            area: Area in m^2
+            flow_rate: Flow rate in m^3/s
+            
+        Raises:
+            ValueError: If inputs are out of acceptable ranges
+        """
+        if not -50 <= temp <= 60:
+            raise ValueError(f"Temperature {temp}°C is outside valid range (-50 to 60°C)")
+        if area < 0:
+            raise ValueError(f"Area {area}m^2 cannot be negative")
+        if flow_rate < 0:
+            raise ValueError(f"Flow rate {flow_rate}m^3/s cannot be negative")
+    
+    def conduction_heat_transfer(self, u_value: float, area: float, delta_t: float) -> float:
         """
-        Calculate design heating loads for all components.
+        Calculate heat transfer by conduction.
         
         Args:
-            building_components: Dictionary of building components
-            outdoor_conditions: Outdoor conditions (design_temperature, design_relative_humidity, ground_temperature, wind_speed)
-            indoor_conditions: Indoor conditions (temperature, relative_humidity)
-            internal_loads: Internal loads (people, lights, equipment, infiltration, ventilation)
+            u_value: Overall heat transfer coefficient in W/(m^2·K)
+            area: Surface area in m^2
+            delta_t: Temperature difference in °C
             
         Returns:
-            Dictionary of design loads in W
-        """
-        try:
-            self.validate_inputs(building_components, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
-        except ValueError as e:
-            raise ValueError(f"Input validation failed: {str(e)}")
-        
-        loads = {
-            'walls': 0.0,
-            'roofs': 0.0,
-            'floors': 0.0,
-            'windows': 0.0,
-            'doors': 0.0,
-            'infiltration_sensible': 0.0,
-            'infiltration_latent': 0.0,
-            'ventilation_sensible': 0.0,
-            'ventilation_latent': 0.0,
-            'internal_gains': 0.0
-        }
-        
-        # Calculate envelope loads
-        for wall in building_components.get('walls', []):
-            loads['walls'] += self.calculate_wall_heating_load(wall, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
-        
-        for roof in building_components.get('roofs', []):
-            loads['roofs'] += self.calculate_roof_heating_load(roof, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
-        
-        for floor in building_components.get('floors', []):
-            loads['floors'] += self.calculate_floor_heating_load(floor, outdoor_conditions['ground_temperature'], indoor_conditions['temperature'])
-        
-        for window in building_components.get('windows', []):
-            loads['windows'] += self.calculate_window_heating_load(window, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
-        
-        for door in building_components.get('doors', []):
-            loads['doors'] += self.calculate_door_heating_load(door, outdoor_conditions['design_temperature'], indoor_conditions['temperature'])
-        
-        # Calculate infiltration and ventilation loads
-        building_height = internal_loads.get('infiltration', {}).get('height', 3.0)
-        infiltration_sensible, infiltration_latent = self.calculate_infiltration_heating_load(
-            indoor_conditions, outdoor_conditions, internal_loads.get('infiltration', {}), building_height
-        )
-        loads['infiltration_sensible'] = infiltration_sensible
-        loads['infiltration_latent'] = infiltration_latent
-        
-        ventilation_sensible, ventilation_latent = self.calculate_ventilation_heating_load(
-            internal_loads.get('ventilation', {}), indoor_conditions, outdoor_conditions
-        )
-        loads['ventilation_sensible'] = ventilation_sensible
-        loads['ventilation_latent'] = ventilation_latent
-        
-        # Calculate internal gains (negative for heating)
-        loads['internal_gains'] = -self.calculate_internal_gains(internal_loads)
-        
-        return loads
-
-    def calculate_heating_load_summary(self, design_loads: Dict[str, float]) -> Dict[str, float]:
+            Heat transfer rate in W
         """
-        Summarize heating loads with safety factor.
+        if u_value < 0:
+            raise ValueError(f"U-value {u_value} W/(m^2·K) cannot be negative")
+        self.validate_inputs(delta_t, area)
+        return u_value * area * delta_t
+    
+    def convection_heat_transfer(self, h: float, area: float, delta_t: float) -> float:
+        """
+        Calculate heat transfer by convection.
         
         Args:
-            design_loads: Dictionary of design loads in W
+            h: Convective heat transfer coefficient in W/(m^2·K)
+            area: Surface area in m^2
+            delta_t: Temperature difference in °C
             
         Returns:
-            Summary dictionary with total, subtotal, and safety factor
-        """
-        subtotal = sum(
-            load for key, load in design_loads.items()
-            if key not in ['internal_gains'] and load > 0
-        )
-        internal_gains = design_loads.get('internal_gains', 0)
-        
-        total = max(0, subtotal + internal_gains) * self.safety_factor
-        
-        return {
-            'subtotal': subtotal,
-            'internal_gains': internal_gains,
-            'total': total,
-            'safety_factor': self.safety_factor
-        }
-
-    def calculate_heating_degree_days(self, base_temp: float, monthly_temps: Dict[str, float]) -> float:
+            Heat transfer rate in W
         """
-        Calculate heating degree days for a year.
+        if h < 0:
+            raise ValueError(f"Convective coefficient {h} W/(m^2·K) cannot be negative")
+        self.validate_inputs(delta_t, area)
+        return h * area * delta_t
+    
+    def radiation_heat_transfer(self, emissivity: float, area: float, t_surface: float, t_surroundings: float) -> float:
+        """
+        Calculate heat transfer by radiation using Stefan-Boltzmann law.
         
         Args:
-            base_temp: Base temperature for HDD calculation in °C
-            monthly_temps: Dictionary of monthly average temperatures
+            emissivity: Surface emissivity (0-1)
+            area: Surface area in m^2
+            t_surface: Surface temperature in °C
+            t_surroundings: Surroundings temperature in °C
             
         Returns:
-            Total heating degree days
+            Heat transfer rate in W
+        """
+        if not 0 <= emissivity <= 1:
+            raise ValueError(f"Emissivity {emissivity} must be between 0 and 1")
+        self.validate_inputs(t_surface, area)
+        self.validate_inputs(t_surroundings)
+        
+        sigma = 5.67e-8  # Stefan-Boltzmann constant in W/(m^2·K^4)
+        t_s = t_surface + 273.15
+        t_sur = t_surroundings + 273.15
+        return emissivity * sigma * area * (t_s**4 - t_sur**4)
+    
+    def thermal_lag_factor(self, thermal_mass: float, time_constant: float, time_step: float) -> float:
         """
-        hdd = 0.0
-        days_per_month = {
-            'Jan': 31, 'Feb': 28, 'Mar': 31, 'Apr': 30, 'May': 31, 'Jun': 30,
-            'Jul': 31, 'Aug': 31, 'Sep': 30, 'Oct': 31, 'Nov': 30, 'Dec': 31
-        }
+        Calculate thermal lag factor for transient heat transfer.
         
-        for month, temp in monthly_temps.items():
-            if temp < base_temp:
-                hdd += (base_temp - temp) * days_per_month[month]
+        Args:
+            thermal_mass: Thermal mass in J/K
+            time_constant: Time constant in hours
+            time_step: Time step in hours
+            
+        Returns:
+            Thermal lag factor (0-1)
+        """
+        if thermal_mass < 0:
+            raise ValueError(f"Thermal mass {thermal_mass} J/K cannot be negative")
+        if time_constant <= 0:
+            raise ValueError(f"Time constant {time_constant} hours must be positive")
+        if time_step < 0:
+            raise ValueError(f"Time step {time_step} hours cannot be negative")
+        
+        return math.exp(-time_step / time_constant)
+    
+    def infiltration_heat_transfer(self, flow_rate: float, delta_t: float) -> float:
+        """
+        Calculate sensible heat transfer due to infiltration or ventilation.
         
-        return hdd
-
-    def calculate_annual_heating_energy(self, design_loads: Dict[str, float], 
-                                      monthly_temps: Dict[str, float], 
-                                      indoor_temp: float, 
-                                      operating_hours: str) -> float:
+        Args:
+            flow_rate: Air flow rate in m^3/s
+            delta_t: Temperature difference in °C
+            
+        Returns:
+            Sensible heat transfer rate in W
         """
-        Calculate annual heating energy consumption.
+        self.validate_inputs(delta_t, flow_rate=flow_rate)
+        rho = 1.2  # Air density in kg/m^3
+        cp = 1005  # Specific heat of air in J/(kg·K)
+        return flow_rate * rho * cp * delta_t
+    
+    def infiltration_latent_heat_transfer(self, flow_rate: float, delta_w: float) -> float:
+        """
+        Calculate latent heat transfer due to infiltration or ventilation.
         
         Args:
-            design_loads: Dictionary of design loads in W
-            monthly_temps: Dictionary of monthly average temperatures
-            indoor_temp: Indoor design temperature in °C
-            operating_hours: Operating hours (e.g., '8:00-18:00')
+            flow_rate: Air flow rate in m^3/s
+            delta_w: Humidity ratio difference in kg/kg
             
         Returns:
-            Annual heating energy in kWh
+            Latent heat transfer rate in W
+        """
+        self.validate_inputs(0, flow_rate=flow_rate)
+        rho = 1.2  # Air density in kg/m^3
+        h_fg = 2501000  # Latent heat of vaporization in J/kg
+        return flow_rate * rho * h_fg * delta_w
+    
+    def wind_pressure_difference(self, wind_speed: float, wind_coefficient: float = 0.4) -> float:
         """
-        base_temp = indoor_temp
-        hdd = self.calculate_heating_degree_days(base_temp, monthly_temps)
+        Calculate pressure difference due to wind.
         
-        # Parse operating hours
-        start_hour, end_hour = map(lambda x: int(x.split(':')[0]), operating_hours.split('-'))
-        daily_hours = end_hour - start_hour
+        Args:
+            wind_speed: Wind speed in m/s
+            wind_coefficient: Wind pressure coefficient
+            
+        Returns:
+            Pressure difference in Pa
+        """
+        if wind_speed < 0:
+            raise ValueError(f"Wind speed {wind_speed} m/s cannot be negative")
+        if not 0 <= wind_coefficient <= 1:
+            raise ValueError(f"Wind coefficient {wind_coefficient} must be between 0 and 1")
         
-        # Calculate design condition degree days
-        design_temp = min(monthly_temps.values())
-        design_delta_t = indoor_temp - design_temp
-        if design_delta_t <= 1:
-            return 0.0
+        rho = 1.2  # Air density in kg/m^3
+        return 0.5 * wind_coefficient * rho * wind_speed**2
+    
+    def stack_pressure_difference(self, height: float, indoor_temp: float, outdoor_temp: float) -> float:
+        """
+        Calculate pressure difference due to stack effect.
         
-        total_load = self.calculate_heating_load_summary(design_loads)['total']
+        Args:
+            height: Height difference in m
+            indoor_temp: Indoor temperature in K
+            outdoor_temp: Outdoor temperature in K
+            
+        Returns:
+            Pressure difference in Pa
+        """
+        if height < 0:
+            raise ValueError(f"Height {height} m cannot be negative")
+        if indoor_temp <= 0 or outdoor_temp <= 0:
+            raise ValueError("Temperatures must be positive in Kelvin")
+        
+        g = 9.81  # Gravitational acceleration in m/s^2
+        rho = 1.2  # Air density in kg/m^3
+        delta_t = abs(indoor_temp - outdoor_temp)
+        t_avg = (indoor_temp + outdoor_temp) / 2
+        return rho * g * height * delta_t / t_avg
+    
+    def combined_pressure_difference(self, wind_pd: float, stack_pd: float) -> float:
+        """
+        Calculate combined pressure difference from wind and stack effects.
         
-        # Scale load by HDD and operating hours
-        annual_energy = (total_load / design_delta_t) * hdd * (daily_hours / 24) / 1000  # kWh
+        Args:
+            wind_pd: Wind pressure difference in Pa
+            stack_pd: Stack pressure difference in Pa
+            
+        Returns:
+            Combined pressure difference in Pa
+        """
+        if wind_pd < 0 or stack_pd < 0:
+            raise ValueError("Pressure differences cannot be negative")
+        return math.sqrt(wind_pd**2 + stack_pd**2)
+    
+    def crack_method_infiltration(self, crack_length: float, coefficient: float, 
+                                pressure_difference: float) -> float:
+        """
+        Calculate infiltration flow rate using crack method.
         
-        return max(0, annual_energy)
-
-    def calculate_monthly_heating_loads(self, building_components: Dict[str, List[Any]], 
-                                      outdoor_conditions: Dict[str, float], 
-                                      indoor_conditions: Dict[str, float], 
-                                      internal_loads: Dict[str, Any], 
-                                      monthly_temps: Dict[str, float]) -> Dict[str, float]:
+        Args:
+            crack_length: Total crack length in m
+            coefficient: Flow coefficient in m^3/(s·m·Pa^n)
+            pressure_difference: Pressure difference in Pa
+            
+        Returns:
+            Infiltration flow rate in m^3/s
+        """
+        if crack_length < 0:
+            raise ValueError(f"Crack length {crack_length} m cannot be negative")
+        if coefficient < 0:
+            raise ValueError(f"Coefficient {coefficient} cannot be negative")
+        if pressure_difference < 0:
+            raise ValueError(f"Pressure difference {pressure_difference} Pa cannot be negative")
+        
+        n = 0.65  # Flow exponent
+        return coefficient * crack_length * pressure_difference**n
+    
+    def sol_air_temperature(self, outdoor_temp: float, solar_irradiance: float, 
+                           surface_absorptivity: float, surface_resistance: float) -> float:
         """
-        Calculate monthly heating loads with thermal lag for walls and roofs.
+        Calculate sol-air temperature for a surface.
         
         Args:
-            building_components: Dictionary of building components
-            outdoor_conditions: Outdoor conditions
-            indoor_conditions: Indoor conditions
-            internal_loads: Internal loads
-            monthly_temps: Dictionary of monthly average temperatures
+            outdoor_temp: Outdoor air temperature in °C
+            solar_irradiance: Solar irradiance on surface in W/m^2
+            surface_absorptivity: Surface absorptivity (0-1)
+            surface_resistance: Surface resistance in m^2·K/W
             
         Returns:
-            Dictionary of monthly heating loads in kW
-        """
-        monthly_loads = {}
-        days_per_month = {
-            'Jan': 31, 'Feb': 28, 'Mar': 31, 'Apr': 30, 'May': 31, 'Jun': 30,
-            'Jul': 31, 'Aug': 31, 'Sep': 30, 'Oct': 31, 'Nov': 30, 'Dec': 31
-        }
-        
-        for month, temp in monthly_temps.items():
-            modified_outdoor = outdoor_conditions.copy()
-            modified_outdoor['design_temperature'] = temp
-            modified_outdoor['ground_temperature'] = temp
+            Sol-air temperature in °C
+        """
+        self.validate_inputs(outdoor_temp)
+        if solar_irradiance < 0:
+            raise ValueError(f"Solar irradiance {solar_irradiance} W/m^2 cannot be negative")
+        if not 0 <= surface_absorptivity <= 1:
+            raise ValueError(f"Surface absorptivity {surface_absorptivity} must be between 0 and 1")
+        if surface_resistance < 0:
+            raise ValueError(f"Surface resistance {surface_resistance} m^2·K/W cannot be negative")
+        
+        h_ext = 1 / surface_resistance  # External convective coefficient
+        delta_t_rad = surface_absorptivity * solar_irradiance / h_ext
+        return outdoor_temp + delta_t_rad
+    
+    def solar_heat_gain(self, irradiance: float, area: float, shgc: float, 
+                       shading_coefficient: float = 1.0) -> float:
+        """
+        Calculate solar heat gain through a surface.
+        
+        Args:
+            irradiance: Solar irradiance on surface in W/m^2
+            area: Surface area in m^2
+            shgc: Solar heat gain coefficient (0-1)
+            shading_coefficient: Shading coefficient (0-1)
             
-            try:
-                # Apply thermal lag for walls and roofs in monthly calculations
-                design_loads = self.calculate_design_heating_load(
-                    building_components, modified_outdoor, indoor_conditions, internal_loads
-                )
-                # Recalculate wall and roof loads with thermal lag
-                design_loads['walls'] = sum(
-                    self.calculate_wall_heating_load(wall, temp, indoor_conditions['temperature'], apply_thermal_lag=True)
-                    for wall in building_components.get('walls', [])
-                )
-                design_loads['roofs'] = sum(
-                    self.calculate_roof_heating_load(roof, temp, indoor_conditions['temperature'], apply_thermal_lag=True)
-                    for roof in building_components.get('roofs', [])
-                )
-                summary = self.calculate_heating_load_summary(design_loads)
-                monthly_loads[month] = summary['total'] / 1000  # kW
-            except ValueError:
-                monthly_loads[month] = 0.0  # Skip invalid months
-        
-        return monthly_loads
+        Returns:
+            Solar heat gain in W
+        """
+        self.validate_inputs(0, area)
+        if irradiance < 0:
+            raise ValueError(f"Irradiance {irradiance} W/m^2 cannot be negative")
+        if not 0 <= shgc <= 1:
+            raise ValueError(f"SHGC {shgc} must be between 0 and 1")
+        if not 0 <= shading_coefficient <= 1:
+            raise ValueError(f"Shading coefficient {shading_coefficient} must be between 0 and 1")
+        
+        return irradiance * area * shgc * shading_coefficient
+
+
+# Create a singleton instance
+heat_transfer_calculator = HeatTransferCalculations()
+
+# Example usage
+if __name__ == "__main__":
+    # Example solar calculations
+    latitude = 40.0
+    day_of_year = 204
+    hour = 12.0
+    
+    declination = heat_transfer_calculator.solar.solar_declination(day_of_year)
+    hour_angle = heat_transfer_calculator.solar.solar_hour_angle(hour)
+    altitude = heat_transfer_calculator.solar.solar_altitude(latitude, declination, hour_angle)
+    azimuth = heat_transfer_calculator.solar.solar_azimuth(latitude, declination, hour_angle, altitude)
+    
+    print(f"Solar Declination: {declination:.2f}°")
+    print(f"Solar Hour Angle: {hour_angle:.2f}°")
+    print(f"Solar Altitude: {altitude:.2f}°")
+    print(f"Solar Azimuth: {azimuth:.2f}°")
+    
+    # Example heat transfer calculation
+    u_value = 0.5  # W/(m^2·K)
+    area = 20.0  # m^2
+    delta_t = 10.0  # °C
+    conduction = heat_transfer_calculator.conduction_heat_transfer(u_value, area, delta_t)
+    print(f"Conduction Heat Transfer: {conduction:.2f} W")
+    
+    # Example psychrometric calculation
+    temp = 25.0  # °C
+    rh = 50.0  # %
+    humidity_ratio = heat_transfer_calculator.psychrometrics.humidity_ratio(temp, rh)
+    print(f"Humidity Ratio: {humidity_ratio:.6f} kg/kg")