Update utils/solar.py

utils/solar.py

@@ -288,10 +288,10 @@ class SolarCalculations:
     ) -> List[Dict[str, Any]]:
         """
         Calculate solar angles, sol-air temperature, and solar heat gain for hourly data with global_horizontal_radiation > 0.
-
+    
         Uses the Perez model for diffuse radiation on tilted surfaces, accounting for anisotropic sky conditions
         (circumsolar and horizon brightening). Direct and ground-reflected radiation follow ASHRAE isotropic models.
-
+    
         Args:
             hourly_data (List[Dict]): Hourly weather data containing month, day, hour, global_horizontal_radiation,
                                       direct_normal_radiation, diffuse_horizontal_radiation, dry_bulb, dew_point,
@@ -302,21 +302,21 @@ class SolarCalculations:
             ground_reflectivity (float): Ground reflectivity (albedo, typically 0.2).
             components (Dict[str, List]): Dictionary of component lists (e.g., walls, windows) with id, area,
                                          type, facade, construction, fenestration, or door_material.
-
+    
         Returns:
             List[Dict]: List of results for each hour with global_horizontal_radiation > 0, containing solar angles
                         and per-component results (total_incident_radiation, sol_air_temp, solar_heat_gain, etc.).
-
+    
         Raises:
             ValueError: If required weather data or component parameters are missing or invalid.
-
+    
         References:
             ASHRAE Handbook—Fundamentals (2021), Chapters 14 and 15.
             Duffie & Beckman, Solar Engineering of Thermal Processes, 4th Ed., Section 2.16.
         """
         year = 2025  # Fixed year since not provided in data
         results = []
-
+    
         # Validate input parameters
         if not -90 <= latitude <= 90:
             logger.warning(f"Invalid latitude {latitude}. Using default 0.0.")
@@ -330,12 +330,12 @@ class SolarCalculations:
         if not 0 <= ground_reflectivity <= 1:
             logger.warning(f"Invalid ground_reflectivity {ground_reflectivity}. Using default 0.2.")
             ground_reflectivity = 0.2
-
+    
         logger.info(f"Using parameters: latitude={latitude}, longitude={longitude}, timezone={timezone}, "
                    f"ground_reflectivity={ground_reflectivity}")
-
+    
         lambda_std = 15 * timezone  # Standard meridian longitude (°)
-
+    
         # Cache facade azimuths (used only for walls, windows)
         building_info = components.get("_building_info", {})
         facade_cache = {
@@ -344,7 +344,7 @@ class SolarCalculations:
             "C": (building_info.get("orientation_angle", 0.0) + 180.0) % 360,
             "D": (building_info.get("orientation_angle", 0.0) + 270.0) % 360
         }
-
+    
         for record in hourly_data:
             # Step 1: Extract and validate data
             month = record.get("month")
@@ -363,44 +363,44 @@ class SolarCalculations:
                 logger.warning(f"Diffuse radiation {diffuse_horizontal_radiation} exceeds global {global_horizontal_radiation} "
                               f"at {month}/{day}/{hour}. Capping diffuse to global.")
                 diffuse_horizontal_radiation = global_horizontal_radiation
-
+    
             if None in [month, day, hour, outdoor_temp]:
                 logger.error(f"Missing required weather data for {month}/{day}/{hour}")
                 raise ValueError(f"Missing required weather data for {month}/{day}/{hour}")
-
+    
             if global_horizontal_radiation < 0 or direct_normal_radiation < 0 or diffuse_horizontal_radiation < 0:
                 logger.error(f"Negative radiation values for {month}/{day}/{hour}")
                 raise ValueError(f"Negative radiation values for {month}/{day}/{hour}")
-
+    
             if global_horizontal_radiation <= 0:
                 logger.info(f"Skipping hour {month}/{day}/{hour} due to global_horizontal_radiation={global_horizontal_radiation} <= 0")
                 continue  # Skip hours with no solar radiation
-
+    
             logger.info(f"Processing solar for {month}/{day}/{hour} with global_horizontal_radiation={global_horizontal_radiation}, "
                        f"direct_normal_radiation={direct_normal_radiation}, diffuse_horizontal_radiation={diffuse_horizontal_radiation}, "
                        f"dry_bulb={outdoor_temp}, dew_point={dew_point}, wind_speed={wind_speed}, "
                        f"total_sky_cover={total_sky_cover}")
-
+    
             # Step 2: Local Solar Time (LST) with Equation of Time
             n = self.day_of_year(month, day, year)
             EOT = self.equation_of_time(n)
             standard_time = hour - 1 + 0.5  # Convert to decimal, assume mid-hour
             LST = standard_time + (4 * (lambda_std - longitude) + EOT) / 60 
-
+    
             # Step 3: Solar Declination (δ)
             delta = 23.45 * math.sin(math.radians(360 / 365 * (284 + n)))
-
+    
             # Step 4: Hour Angle (HRA)
             hra = 15 * (LST - 12)
-
+    
             # Step 5: Solar Altitude (α) and Azimuth (ψ)
             phi = math.radians(latitude)
             delta_rad = math.radians(delta)
             hra_rad = math.radians(hra)
-
+    
             sin_alpha = math.sin(phi) * math.sin(delta_rad) + math.cos(phi) * math.cos(delta_rad) * math.cos(hra_rad)
             alpha = math.degrees(math.asin(sin_alpha))
-
+    
             if abs(math.cos(math.radians(alpha))) < 0.01:
                 azimuth = 0  # North at sunrise/sunset
             else:
@@ -409,10 +409,10 @@ class SolarCalculations:
                 azimuth = math.degrees(math.atan2(sin_az, cos_az))
                 if hra > 0:  # Afternoon
                     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}")
-
+    
             # Calculate clearness index (kt) and Perez coefficients once per hour
             zenith_deg = 90 - alpha  # Zenith angle = 90 - altitude
             if global_horizontal_radiation > 0 and zenith_deg < 90:
@@ -421,7 +421,7 @@ class SolarCalculations:
                 f1, f2 = self.calculate_perez_coefficients(kt, zenith_deg)
             else:
                 kt, f1, f2 = 0.0, 0.0, 0.0
-
+    
             # Step 6: Component-specific calculations
             component_results = []
             for comp_type, comp_list in components.items():
@@ -433,7 +433,7 @@ class SolarCalculations:
                         if comp.get('adiabatic', False) and comp.get('ground_contact', False):
                             logger.warning(f"Component {comp.get('name', 'unknown_component')} has both adiabatic and ground_contact set to True. Treating as adiabatic, setting ground_contact to False.")
                             comp['ground_contact'] = False
-        
+    
                         # Get surface parameters
                         surface_tilt, surface_azimuth, h_o, emissivity, absorptivity = \
                             self.get_surface_parameters(comp, building_info)
@@ -441,17 +441,17 @@ class SolarCalculations:
                         # For windows/skylights, get SHGC from component
                         shgc = comp.get('shgc', 0.7)
                         fenestration_name = comp.get('fenestration', None)
-        
+    
                         # Calculate angle of incidence (θ)
                         cos_theta = (math.sin(math.radians(alpha)) * math.cos(math.radians(surface_tilt)) +
                                      math.cos(math.radians(alpha)) * math.sin(math.radians(surface_tilt)) *
                                      math.cos(math.radians(azimuth - surface_azimuth)))
                         cos_theta = max(min(cos_theta, 1.0), 0.0)  # Clamp to [0, 1]
-        
+    
                         logger.info(f"  Component {comp.get('name', 'unknown_component')} at {month}/{day}/{hour}: "
                                    f"surface_tilt={surface_tilt:.2f}, surface_azimuth={surface_azimuth:.2f}, "
-                                   f"cos_theta={cos_theta:.2f}, h_o={h_o:.2f}")
-        
+                                   f"cos_theta={cos_theta:.2f}")
+    
                         # Calculate total incident radiation (I_t) with Perez model
                         view_factor = (1 - math.cos(math.radians(surface_tilt))) / 2
                         ground_reflected = ground_reflectivity * global_horizontal_radiation * view_factor
@@ -466,7 +466,7 @@ class SolarCalculations:
                         direct_tilted = direct_normal_radiation * max(cos_theta, 0.0)
                         I_t = direct_tilted + diffuse_tilted + ground_reflected
                         I_t = max(I_t, 0.0)  # Ensure non-negative radiation
-        
+    
                         # Initialize result
                         comp_result = {
                             "component_id": comp.get('name', 'unknown_component'),
@@ -474,13 +474,13 @@ class SolarCalculations:
                             "absorptivity": round(absorptivity, 2),
                             "emissivity": round(emissivity, 2) if emissivity is not None else None
                         }
-        
+    
                         # Skip calculations for adiabatic surfaces
                         if comp.get('adiabatic', False):
                             logger.info(f"Skipping solar calculations for adiabatic component {comp_result['component_id']} at {month}/{day}/{hour}")
                             component_results.append(comp_result)
                             continue
-        
+    
                         # Handle ground-contact surfaces
                         if comp.get('ground_contact', False):
                             # Validate component type
@@ -490,7 +490,7 @@ class SolarCalculations:
                                 logger.warning(f"Invalid ground-contact component type '{component_type}' for {comp_result['component_id']}. Skipping ground temperature assignment.")
                                 component_results.append(comp_result)
                                 continue
-        
+    
                             # Retrieve ground temperature
                             climate_data = st.session_state.project_data.get("climate_data", {})
                             ground_temperatures = climate_data.get("ground_temperatures", {})
@@ -504,7 +504,7 @@ class SolarCalculations:
                             logger.info(f"Ground-contact component {comp_result['component_id']} at {month}/{day}/{hour}: ground_temp={ground_temp:.2f}°C")
                             component_results.append(comp_result)
                             continue
-        
+    
                         # Calculate sol-air temperature for opaque surfaces (non-ground-contact)
                         if comp.get('type', '').lower() in ['walls', 'roofs'] and not comp.get('ground_contact', False):
                             T_sol_air = CTFCalculator.calculate_sol_air_temperature(
@@ -513,26 +513,32 @@ class SolarCalculations:
                             )
                             comp_result["sol_air_temp"] = round(T_sol_air, 2)
                             logger.info(f"Sol-air temp for {comp_result['component_id']} at {month}/{day}/{hour}: {T_sol_air:.2f}°C")
-        
+    
                         # Calculate solar heat gain for fenestration
                         elif comp.get('type', '').lower() in ['windows', 'skylights']:
                             glazing_type = self.GLAZING_TYPE_MAPPING.get(comp.get('fenestration', ''), 'Single Clear')
                             iac = comp.get('shading_coefficient', 1.0)
+                            # Adjust shading coefficient based on shading type
+                            shading_type = comp.get('shading_type', 'No shading')
+                            if shading_type == "External Shading":
+                                iac *= 0.6
+                            elif shading_type == "Internal Shading":
+                                iac *= 0.8
                             shgc_dynamic = shgc * self.calculate_dynamic_shgc(glazing_type, cos_theta)
                             solar_heat_gain = comp.get('area', 0.0) * shgc_dynamic * I_t * iac / 1000  # kW
                             comp_result["solar_heat_gain"] = round(solar_heat_gain, 2)
                             comp_result["shgc_dynamic"] = round(shgc_dynamic, 2)
                             logger.info(f"Solar heat gain for {comp_result['component_id']} at {month}/{day}/{hour}: "
                                        f"{solar_heat_gain:.2f} kW (area={comp.get('area', 0.0)}, shgc_dynamic={shgc_dynamic:.2f}, "
-                                       f"I_t={I_t:.2f}, iac={iac})")
+                                       f"I_t={I_t:.2f}, iac={iac}, shading_type={shading_type})")
                         
                         component_results.append(comp_result)
-        
+    
                     except Exception as e:
                         component_name = comp.get('name', 'unknown_component')
                         logger.error(f"Error processing component {component_name} at {month}/{day}/{hour}: {str(e)}")
                         continue
-
+    
             # Store results for this hour
             result = {
                 "month": month,
@@ -546,5 +552,5 @@ class SolarCalculations:
                 "component_results": component_results
             }
             results.append(result)
-
+    
         return results