Update utils/heat_transfer.py

utils/heat_transfer.py

@@ -1,30 +1,36 @@
 """
 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.
-Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Sections 18.3-18.4.
+This module implements heat transfer calculations for conduction, infiltration, and solar effects.
+Reference: ASHRAE Handbook—Fundamentals (2017), Chapters 16 and 18.
 """
 
-from typing import Optional, Tuple
+from typing import Dict, List, Any, Optional, Tuple
 import math
 import numpy as np
+import logging
+from dataclasses import dataclass
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import utility modules
 from utils.psychrometrics import Psychrometrics
 
+# Import data modules
+from data.building_components import Orientation
+
 
 class SolarCalculations:
-    """Class for solar geometry and irradiance calculations."""
-    
-    def __init__(self):
-        """Initialize solar calculations with cached values."""
-        self._declination_cache = {}  # Cache for declination by day of year
+    """Class for solar geometry and radiation calculations."""
     
     def validate_angle(self, angle: float, name: str, min_val: float, max_val: float) -> None:
         """
-        Validate an angle input.
+        Validate angle inputs for solar calculations.
         
         Args:
             angle: Angle in degrees
-            name: Name of the angle for error messages
+            name: Name of the angle
             min_val: Minimum allowed value
             max_val: Maximum allowed value
             
@@ -32,291 +38,133 @@ class SolarCalculations:
             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}°)")
-    
+            raise ValueError(f"{name} {angle}° must be between {min_val}° and {max_val}°")
+
     def solar_declination(self, day_of_year: int) -> float:
         """
-        Calculate solar declination angle for a given day of the year.
+        Calculate solar declination angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.6.
         
         Args:
             day_of_year: Day of the year (1-365)
             
         Returns:
-            Solar declination angle in degrees
+            Declination angle in degrees
         """
         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]
+            raise ValueError("Day of year must be between 1 and 365")
         
         declination = 23.45 * math.sin(math.radians(360 * (284 + day_of_year) / 365))
-        self._declination_cache[day_of_year] = declination
+        self.validate_angle(declination, "Declination angle", -23.45, 23.45)
         return declination
-    
+
     def solar_hour_angle(self, hour: float) -> float:
         """
-        Calculate solar hour angle for a given hour of the day.
+        Calculate solar hour angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.7.
         
         Args:
             hour: Hour of the day (0-23)
             
         Returns:
-            Solar hour angle in degrees
+            Hour angle in degrees
         """
-        if not 0 <= hour <= 23:
-            raise ValueError(f"Hour {hour} must be between 0 and 23")
-        return 15 * (hour - 12)
-    
+        if not 0 <= hour <= 24:
+            raise ValueError("Hour must be between 0 and 24")
+        
+        hour_angle = (hour - 12) * 15
+        self.validate_angle(hour_angle, "Hour angle", -180, 180)
+        return hour_angle
+
     def solar_altitude(self, latitude: float, declination: float, hour_angle: float) -> float:
         """
         Calculate solar altitude angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.8.
         
         Args:
             latitude: Latitude in degrees
-            declination: Solar declination angle in degrees
-            hour_angle: Solar hour angle in degrees
+            declination: Declination angle in degrees
+            hour_angle: Hour angle in degrees
             
         Returns:
-            Solar altitude angle in degrees
+            Altitude angle in degrees
         """
         self.validate_angle(latitude, "Latitude", -90, 90)
-        self.validate_angle(declination, "Declination", -90, 90)
+        self.validate_angle(declination, "Declination", -23.45, 23.45)
         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)
-    
+        sin_beta = (math.sin(math.radians(latitude)) * math.sin(math.radians(declination)) +
+                    math.cos(math.radians(latitude)) * math.cos(math.radians(declination)) *
+                    math.cos(math.radians(hour_angle)))
+        beta = math.degrees(math.asin(sin_beta))
+        self.validate_angle(beta, "Altitude angle", 0, 90)
+        return beta
+
     def solar_azimuth(self, latitude: float, declination: float, hour_angle: float, altitude: float) -> float:
         """
         Calculate solar azimuth angle.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 14, Equation 14.9.
         
         Args:
             latitude: Latitude in degrees
-            declination: Solar declination angle in degrees
-            hour_angle: Solar hour angle in degrees
-            altitude: Solar altitude angle in degrees
+            declination: Declination angle in degrees
+            hour_angle: Hour angle in degrees
+            altitude: Altitude angle in degrees
             
         Returns:
-            Solar azimuth angle in degrees
+            Azimuth angle in degrees
         """
         self.validate_angle(latitude, "Latitude", -90, 90)
-        self.validate_angle(declination, "Declination", -90, 90)
-        self.validate_angle(hour_angle, "Hour angle", -180ublisher: https://www.w3schools.com/howto/tryit.asp?filename=trycss_form_checkbox
+        self.validate_angle(declination, "Declination", -23.45, 23.45)
+        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))
+        sin_phi = (math.cos(math.radians(declination)) * math.sin(math.radians(hour_angle)) /
+                   math.cos(math.radians(altitude)))
+        phi = math.degrees(math.asin(sin_phi))
         
         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 angle of incidence for a surface.
-        
-        Args:
-            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:
-            Angle of incidence in degrees
-        """
-        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 direct normal irradiance.
+            phi = 180 - phi
+        elif hour_angle < 0:
+            phi = -180 - phi
         
-        Args:
-            solar_altitude: Solar altitude angle in degrees
-            
-        Returns:
-            Direct normal irradiance in W/m²
-        """
-        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:
-            dni: Direct normal irradiance in W/m²
-            solar_altitude: Solar altitude angle in degrees
-            
-        Returns:
-            Diffuse horizontal irradiance in W/m²
-        """
-        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 total irradiance on a tilted surface.
-        
-        Args:
-            dni: Direct normal irradiance in W/m²
-            dhi: Diffuse horizontal irradiance in W/m²
-            incident_angle: Angle of incidence in degrees
-            surface_tilt: Surface tilt angle in degrees
-            
-        Returns:
-            Total irradiance in W/m²
-        """
-        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)
+        self.validate_angle(phi, "Azimuth angle", -180, 180)
+        return phi
 
 
 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²
-            flow_rate: Flow rate in m³/s
-            
-        Raises:
-            ValueError: If inputs are out of acceptable ranges
+        Initialize heat transfer calculations with psychrometrics and solar calculations.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16.
         """
-        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² cannot be negative")
-        if flow_rate < 0:
-            raise ValueError(f"Flow rate {flow_rate}m³/s cannot be negative")
+        self.psychrometrics = Psychrometrics()
+        self.solar = SolarCalculations()
+        self.debug_mode = False
     
     def conduction_heat_transfer(self, u_value: float, area: float, delta_t: float) -> float:
         """
-        Calculate heat transfer by conduction.
+        Calculate heat transfer via conduction.
         Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.1.
         
         Args:
-            u_value: Overall heat transfer coefficient in W/(m²·K)
-            area: Surface area in m²
-            delta_t: Temperature difference in °C
-            
-        Returns:
-            Heat transfer rate in W
-        """
-        if u_value < 0:
-            raise ValueError(f"U-value {u_value} W/(m²·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.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.3.
-        
-        Args:
-            h: Convective heat transfer coefficient in W/(m²·K)
-            area: Surface area in m²
+            u_value: U-value of the component in W/(m²·K)
+            area: Area of the component in m²
             delta_t: Temperature difference in °C
             
         Returns:
             Heat transfer rate in W
         """
-        if h < 0:
-            raise ValueError(f"Convective coefficient {h} W/(m²·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.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.3.
-        
-        Args:
-            emissivity: Surface emissivity (0-1)
-            area: Surface area in m²
-            t_surface: Surface temperature in °C
-            t_surroundings: Surroundings temperature in °C
-            
-        Returns:
-            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²·K⁴)
-        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:
-        """
-        Calculate thermal lag factor for transient heat transfer.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.5.
+        if u_value < 0 or area < 0:
+            raise ValueError("U-value and area must be non-negative")
         
-        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, t_db: float, rh: float, p_atm: float = 101325) -> float:
+        q = u_value * area * delta_t
+        return q
+
+    def infiltration_heat_transfer(self, flow_rate: float, delta_t: float, 
+                                 t_db: float, rh: float, p_atm: float = 101325) -> float:
         """
         Calculate sensible heat transfer due to infiltration or ventilation.
         Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.5.
@@ -324,20 +172,26 @@ class HeatTransferCalculations:
         Args:
             flow_rate: Air flow rate in m³/s
             delta_t: Temperature difference in °C
-            t_db: Dry-bulb temperature in °C (for air properties)
-            rh: Relative humidity in % (for air properties)
-            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            t_db: Dry-bulb temperature for air properties in °C
+            rh: Relative humidity in % (0-100)
+            p_atm: Atmospheric pressure in Pa
             
         Returns:
             Sensible heat transfer rate in W
         """
-        self.validate_inputs(delta_t, flow_rate=flow_rate)
+        if flow_rate < 0:
+            raise ValueError("Flow rate cannot be negative")
+        
+        # Calculate air density and specific heat using psychrometrics
         w = self.psychrometrics.humidity_ratio(t_db, rh, p_atm)
         rho = self.psychrometrics.density(t_db, w, p_atm)
-        c_p = 1006 + w * 1860  # Specific heat of moist air in J/(kg·K)
-        return flow_rate * rho * c_p * delta_t
-    
-    def infiltration_latent_heat_transfer(self, flow_rate: float, delta_w: float, t_db: float, rh: float, p_atm: float = 101325) -> float:
+        c_p = 1006 + 1860 * w  # Specific heat of moist air in J/(kg·K)
+        
+        q = flow_rate * rho * c_p * delta_t
+        return q
+
+    def infiltration_latent_heat_transfer(self, flow_rate: float, delta_w: float, 
+                                        t_db: float, rh: float, p_atm: float = 101325) -> float:
         """
         Calculate latent heat transfer due to infiltration or ventilation.
         Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Equation 18.6.
@@ -345,67 +199,68 @@ class HeatTransferCalculations:
         Args:
             flow_rate: Air flow rate in m³/s
             delta_w: Humidity ratio difference in kg/kg
-            t_db: Dry-bulb temperature in °C (for air properties)
-            rh: Relative humidity in % (for air properties)
-            p_atm: Atmospheric pressure in Pa (default: 101325 Pa)
+            t_db: Dry-bulb temperature for air properties in °C
+            rh: Relative humidity in % (0-100)
+            p_atm: Atmospheric pressure in Pa
             
         Returns:
             Latent heat transfer rate in W
         """
-        self.validate_inputs(t_db, flow_rate=flow_rate)
+        if flow_rate < 0 or delta_w < 0:
+            raise ValueError("Flow rate and humidity ratio difference cannot be negative")
+        
+        # Calculate air density and latent heat
         w = self.psychrometrics.humidity_ratio(t_db, rh, p_atm)
         rho = self.psychrometrics.density(t_db, w, p_atm)
         h_fg = 2501000 + 1840 * t_db  # 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:
+        
+        q = flow_rate * rho * h_fg * delta_w
+        return q
+
+    def wind_pressure_difference(self, wind_speed: float) -> float:
         """
         Calculate pressure difference due to wind.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Section 16.3.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Equation 16.3.
         
         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")
+            raise ValueError("Wind speed cannot be negative")
         
-        rho = 1.2  # Air density in kg/m³ (simplified for wind calculations)
-        return 0.5 * wind_coefficient * rho * wind_speed**2
-    
-    def stack_pressure_difference(self, height: float, indoor_temp: float, outdoor_temp: float) -> float:
+        c_p = 0.6  # Wind pressure coefficient
+        rho_air = 1.2  # Air density at standard conditions in kg/m³
+        delta_p = 0.5 * c_p * rho_air * wind_speed**2
+        return delta_p
+
+    def stack_pressure_difference(self, height: float, t_inside: float, t_outside: float) -> float:
         """
         Calculate pressure difference due to stack effect.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Section 16.3.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Equation 16.4.
         
         Args:
-            height: Height difference in m
-            indoor_temp: Indoor temperature in K
-            outdoor_temp: Outdoor temperature in K
+            height: Height of the building in m
+            t_inside: Inside temperature in K
+            t_outside: Outside 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")
+        if height < 0 or t_inside <= 0 or t_outside <= 0:
+            raise ValueError("Height and temperatures must be positive")
         
         g = 9.81  # Gravitational acceleration in m/s²
-        rho = 1.2  # Air density in kg/m³ (simplified for stack calculations)
-        delta_t = abs(indoor_temp - outdoor_temp)
-        t_avg = (indoor_temp + outdoor_temp) / 2
-        return rho * g * height * delta_t / t_avg
-    
+        rho_air = 1.2  # Air density at standard conditions in kg/m³
+        delta_p = rho_air * g * height * (1 / t_outside - 1 / t_inside)
+        return delta_p
+
     def combined_pressure_difference(self, wind_pd: float, stack_pd: float) -> float:
         """
         Calculate combined pressure difference from wind and stack effects.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Section 16.3.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Section 16.2.
         
         Args:
             wind_pd: Wind pressure difference in Pa
@@ -414,121 +269,59 @@ class HeatTransferCalculations:
         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:
+        delta_p = math.sqrt(wind_pd**2 + stack_pd**2)
+        return delta_p
+
+    def crack_method_infiltration(self, crack_length: float, crack_width: float, delta_p: float) -> float:
         """
         Calculate infiltration flow rate using crack method.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Section 16.4.
+        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 16, Equation 16.5.
         
         Args:
-            crack_length: Total crack length in m
-            coefficient: Flow coefficient in m³/(s·m·Pa^n)
-            pressure_difference: Pressure difference in Pa
+            crack_length: Length of cracks in m
+            crack_width: Width of cracks in m
+            delta_p: Pressure difference across cracks in Pa
             
         Returns:
             Infiltration flow rate in m³/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 sol-air temperature for a surface.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
-        
-        Args:
-            outdoor_temp: Outdoor air temperature in °C
-            solar_irradiance: Solar irradiance on surface in W/m²
-            surface_absorptivity: Surface absorptivity (0-1)
-            surface_resistance: Surface resistance in m²·K/W
-            
-        Returns:
-            Sol-air temperature in °C
-        """
-        self.validate_inputs(outdoor_temp)
-        if solar_irradiance < 0:
-            raise ValueError(f"Solar irradiance {solar_irradiance} W/m² 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²·K/W cannot be negative")
+        if crack_length < 0 or crack_width < 0 or delta_p < 0:
+            raise ValueError("Crack dimensions and pressure difference 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.
-        Reference: ASHRAE Handbook—Fundamentals (2017), Chapter 18, Section 18.4.
-        
-        Args:
-            irradiance: Solar irradiance on surface in W/m²
-            area: Surface area in m²
-            shgc: Solar heat gain coefficient (0-1)
-            shading_coefficient: Shading coefficient (0-1)
-            
-        Returns:
-            Solar heat gain in W
-        """
-        self.validate_inputs(0, area)
-        if irradiance < 0:
-            raise ValueError(f"Irradiance {irradiance} W/m² 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
+        c_d = 0.65  # Discharge coefficient
+        area = crack_length * crack_width
+        rho_air = 1.2  # Air density at standard conditions in kg/m³
+        q = c_d * area * math.sqrt(2 * delta_p / rho_air)
+        return q
 
 
-# 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}°")
+    heat_transfer = HeatTransferCalculations()
+    heat_transfer.debug_mode = True
     
-    # Example heat transfer calculation
+    # Example conduction calculation
     u_value = 0.5  # W/(m²·K)
     area = 20.0  # m²
-    delta_t = 10.0  # °C
-    t_db = 25.0  # °C
-    rh = 50.0  # %
-    conduction = heat_transfer_calculator.conduction_heat_transfer(u_value, area, delta_t)
-    print(f"Conduction Heat Transfer: {conduction:.2f} W")
+    delta_t = 26.0  # °C
+    q_conduction = heat_transfer.conduction_heat_transfer(u_value, area, delta_t)
+    logger.info(f"Conduction heat transfer: {q_conduction:.2f} W")
     
     # Example infiltration calculation
     flow_rate = 0.05  # m³/s
-    infiltration = heat_transfer_calculator.infiltration_heat_transfer(flow_rate, delta_t, t_db, rh)
-    print(f"Infiltration Heat Transfer: {infiltration:.2f} W")
+    delta_t = 26.0  # °C
+    t_db = 21.0  # °C
+    rh = 40.0  # %
+    p_atm = 101325  # Pa
+    q_infiltration = heat_transfer.infiltration_heat_transfer(flow_rate, delta_t, t_db, rh, p_atm)
+    logger.info(f"Infiltration sensible heat transfer: {q_infiltration:.2f} W")
     
-    # Example psychrometric calculation
-    humidity_ratio = heat_transfer_calculator.psychrometrics.humidity_ratio(t_db, rh)
-    print(f"Humidity Ratio: {humidity_ratio:.6f} kg/kg")
+    # Example solar calculation
+    latitude = 40.0  # degrees
+    day_of_year = 172  # June 21
+    hour = 12.0  # Noon
+    declination = heat_transfer.solar.solar_declination(day_of_year)
+    hour_angle = heat_transfer.solar.solar_hour_angle(hour)
+    altitude = heat_transfer.solar.solar_altitude(latitude, declination, hour_angle)
+    azimuth = heat_transfer.solar.solar_azimuth(latitude, declination, hour_angle, altitude)
+    logger.info(f"Solar altitude: {altitude:.2f}°, Azimuth: {azimuth:.2f}°")