Update data/climate_data.py

data/climate_data.py

@@ -81,12 +81,13 @@ class ClimateLocation:
     pressure: float  # Mean atmospheric pressure (Pa)
     direct_normal_irradiance: float  # Mean DNI (W/m²)
     diffuse_horizontal_irradiance: float  # Mean DHI (W/m²)
+    albedo: float  # Surface reflectivity (0-1)
     hourly_data: List[Dict]  # Hourly data for integration with main.py
     typical_extreme_periods: Dict[str, Dict]  # Typical/extreme periods (summer/winter)
     ground_temperatures: Dict[str, List[float]]  # Monthly ground temperatures by depth
-    solstice_zenith_angles: Dict[str, float]  # Summer and winter solstice zenith angles
-    _solar_cache: Dict[str, Dict[str, float]]  # Cache for solar angles
-
+    solstice_zenith_angles: Dict[str, float]  # Zenith angles for summer/winter solstices
+    _solar_cache: Dict[str, Dict[str, float]]  # Cache for solar angle calculations
+    
     def __init__(self, epw_file: pd.DataFrame, typical_extreme_periods: Dict, ground_temperatures: Dict, albedo: float = 0.2, **kwargs):
         """Initialize ClimateLocation with EPW file data and header information."""
         self.id = kwargs.get("id")
@@ -97,10 +98,11 @@ class ClimateLocation:
         self.longitude = kwargs.get("longitude")
         self.elevation = kwargs.get("elevation")
         self.time_zone = kwargs.get("time_zone")
+        self.albedo = albedo
         self.typical_extreme_periods = typical_extreme_periods
         self.ground_temperatures = ground_temperatures
         self._solar_cache = {}
-        self.albedo = albedo  # Default albedo from ASHRAE Fundamentals, Chapter 14, Table 4
+        self.solstice_zenith_angles = self._calculate_solstice_zenith_angles()
         
         # Extract columns from EPW data
         months = pd.to_numeric(epw_file[1], errors='coerce').values
@@ -120,9 +122,9 @@ class ClimateLocation:
         if (wind_speed > 15).any():
             logger.warning(f"High wind speeds detected: {wind_speed[wind_speed > 15].tolist()}")
         
-        # Filter irradiance outliers
-        direct_normal_irradiance = direct_normal_irradiance[direct_normal_irradiance <= 1200]
-        diffuse_horizontal_irradiance = diffuse_horizontal_irradiance[diffuse_horizontal_irradiance <= 1200]
+        # Filter irradiance outliers and handle negative/missing values
+        direct_normal_irradiance = np.where((np.isnan(direct_normal_irradiance) | (direct_normal_irradiance < 0)), 0.0, direct_normal_irradiance)
+        diffuse_horizontal_irradiance = np.where((np.isnan(diffuse_horizontal_irradiance) | (diffuse_horizontal_irradiance < 0)), 0.0, diffuse_horizontal_irradiance)
         if (direct_normal_irradiance > 1000).any():
             logger.warning(f"High DNI values detected: {direct_normal_irradiance[direct_normal_irradiance > 1000].tolist()}")
         if (diffuse_horizontal_irradiance > 600).any():
@@ -163,26 +165,11 @@ class ClimateLocation:
         # Assign climate zone
         self.climate_zone = ClimateData.assign_climate_zone(self.heating_degree_days, self.cooling_degree_days, np.nanmean(humidity))
         
-        # Calculate solstice zenith angles
-        self.solstice_zenith_angles = self._calculate_solstice_zenith_angles()
-        
         # Store hourly data with enhanced fields
         self.hourly_data = []
         for i in range(len(months)):
             if np.isnan(months[i]) or np.isnan(days[i]) or np.isnan(hours[i]) or np.isnan(dry_bulb[i]):
                 continue  # Skip records with missing critical fields
-            # Calculate solar time and angles
-            timestamp = datetime(2025, int(months[i]), int(days[i]), int(hours[i]) - 1)  # Hour is 1-24, adjust to 0-23
-            solar_time = self._calculate_solar_time(timestamp)
-            solar_angles = self._calculate_solar_angles(timestamp)
-            
-            # Handle DNI and DHI: set to 0 if missing or negative
-            dni = float(direct_normal_irradiance[i]) if not np.isnan(direct_normal_irradiance[i]) and direct_normal_irradiance[i] >= 0 else 0.0
-            dhi = float(diffuse_horizontal_irradiance[i]) if not np.isnan(diffuse_horizontal_irradiance[i]) and diffuse_horizontal_irradiance[i] >= 0 else 0.0
-            
-            # Calculate ground-reflected radiation
-            ground_reflected = self.albedo * (dni * np.cos(np.radians(solar_angles['zenith'])) + dhi)
-            
             record = {
                 "month": int(months[i]),
                 "day": int(days[i]),
@@ -191,14 +178,10 @@ class ClimateLocation:
                 "relative_humidity": float(humidity[i]) if not np.isnan(humidity[i]) else 0.0,
                 "atmospheric_pressure": float(pressure[i]) if not np.isnan(pressure[i]) else self.pressure,
                 "global_horizontal_radiation": float(global_radiation[i]) if not np.isnan(global_radiation[i]) else 0.0,
-                "direct_normal_irradiance": dni,
-                "diffuse_horizontal_irradiance": dhi,
+                "direct_normal_irradiance": float(direct_normal_irradiance[i]),
+                "diffuse_horizontal_irradiance": float(diffuse_horizontal_irradiance[i]),
                 "wind_speed": float(wind_speed[i]) if not np.isnan(wind_speed[i]) else 0.0,
-                "wind_direction": float(wind_direction[i]) if not np.isnan(wind_direction[i]) else 0.0,
-                "solar_time": float(solar_time),
-                "solar_zenith": float(solar_angles['zenith']),
-                "solar_azimuth": float(solar_angles['azimuth']),
-                "ground_reflected_radiation": float(ground_reflected)
+                "wind_direction": float(wind_direction[i]) if not np.isnan(wind_direction[i]) else 0.0
             }
             self.hourly_data.append(record)
         
@@ -206,27 +189,24 @@ class ClimateLocation:
             st.warning(f"Hourly data has {len(self.hourly_data)} records instead of 8760. Some records may have been excluded due to missing data.")
 
     def _calculate_solar_time(self, timestamp: datetime) -> float:
-        """Calculate solar time from local time, adjusting for longitude and time zone (ASHRAE Fundamentals, Chapter 14, Section 14.7)."""
-        # Standard meridian for the time zone
-        standard_meridian = self.time_zone * 15  # Time zone offset in degrees (15° per hour)
-        # Longitude correction (4 minutes per degree)
-        longitude_correction = (self.longitude - standard_meridian) * 4 / 60  # in hours
-        # Equation of time (simplified approximation, could use pvlib for precision)
+        """Calculate solar time using ASHRAE Fundamentals, Chapter 14, Section 14.7."""
+        standard_meridian = self.time_zone * 15
+        longitude_correction = (self.longitude - standard_meridian) * 4 / 60
         day_of_year = timestamp.timetuple().tm_yday
         B = (day_of_year - 1) * 360 / 365.242
-        E = 229.18 * (0.000075 + 0.001868 * np.cos(np.radians(B)) - 0.032077 * np.sin(np.radians(B)) -
-                      0.014615 * np.cos(np.radians(2 * B)) - 0.04089 * np.sin(np.radians(2 * B))) / 60  # in hours
-        # Local standard time in hours
+        E = 229.18 * (
+            0.000075 +
+            0.001868 * np.cos(np.radians(B)) -
+            0.032077 * np.sin(np.radians(B)) -
+            0.014615 * np.cos(np.radians(2 * B)) -
+            0.04089 * np.sin(np.radians(2 * B))
+        ) / 60
         local_std_time = timestamp.hour + timestamp.minute / 60
-        # Solar time
         solar_time = local_std_time + longitude_correction + E
-        # Normalize to 0-24 hours
-        solar_time = solar_time % 24
-        return solar_time
+        return solar_time % 24
 
     def _calculate_solar_angles(self, timestamp: datetime) -> Dict[str, float]:
-        """Calculate solar zenith and azimuth angles, caching results (ASHRAE Fundamentals, Chapter 14, Section 14.7)."""
-        # Create cache key
+        """Compute solar zenith and azimuth angles with caching."""
         cache_key = hashlib.md5(
             f"{timestamp.strftime('%Y-%m-%d_%H')}_{self.latitude}_{self.longitude}_{self.time_zone}".encode()
         ).hexdigest()
@@ -234,40 +214,59 @@ class ClimateLocation:
         if cache_key in self._solar_cache:
             return self._solar_cache[cache_key]
         
-        # Use pvlib for solar position
         solpos = pvlib.solarposition.get_solarposition(
             time=timestamp,
             latitude=self.latitude,
             longitude=self.longitude,
             altitude=self.elevation
         )
-        zenith = solpos['zenith'].iloc[0]
-        azimuth = solpos['azimuth'].iloc[0]
-        
-        # Cache results
-        self._solar_cache[cache_key] = {
-            'zenith': zenith,
-            'azimuth': azimuth
+        result = {
+            'zenith': float(solpos['zenith'].iloc[0]),
+            'azimuth': float(solpos['azimuth'].iloc[0])
         }
-        return self._solar_cache[cache_key]
+        self._solar_cache[cache_key] = result
+        return result
 
     def _calculate_solstice_zenith_angles(self) -> Dict[str, float]:
-        """Calculate solar zenith angles for summer and winter solstices at noon."""
-        dates = [
-            datetime(2025, 12, 21, 12),  # Summer solstice (Southern Hemisphere)
-            datetime(2025, 6, 21, 12)   # Winter solstice (Southern Hemisphere)
-        ]
-        solstice_zeniths = {}
-        for date in dates:
+        """Compute zenith angles for summer and winter solstices at noon."""
+        solstices = {
+            'summer': datetime(2025, 12, 21, 12, 0),
+            'winter': datetime(2025, 6, 21, 12, 0)
+        }
+        result = {}
+        for season, date in solstices.items():
             solpos = pvlib.solarposition.get_solarposition(
                 time=date,
                 latitude=self.latitude,
                 longitude=self.longitude,
                 altitude=self.elevation
             )
-            key = 'summer' if date.month == 12 else 'winter'
-            solstice_zeniths[key] = round(float(solpos['zenith'].iloc[0]), 1)
-        return solstice_zeniths
+            result[season] = round(float(solpos['zenith'].iloc[0]), 1)
+        return result
+
+    def calculate_ground_reflection(self):
+        """Calculate solar time, angles, and ground-reflected radiation for hourly data."""
+        for i, record in enumerate(self.hourly_data):
+            # Create timestamp (adjust hour from 1-24 to 0-23)
+            try:
+                timestamp = datetime(2025, record['month'], record['day'], record['hour'] - 1)
+            except ValueError:
+                logger.warning(f"Invalid date in hourly data at index {i}: {record['month']}/{record['day']} {record['hour']}")
+                continue
+            
+            # Calculate solar time
+            record['solar_time'] = round(self._calculate_solar_time(timestamp), 2)
+            
+            # Calculate solar angles
+            solar_angles = self._calculate_solar_angles(timestamp)
+            record['solar_zenith'] = round(solar_angles['zenith'], 1)
+            record['solar_azimuth'] = round(solar_angles['azimuth'], 1)
+            
+            # Calculate ground-reflected radiation
+            dni = record['direct_normal_irradiance']
+            dhi = record['diffuse_horizontal_irradiance']
+            ground_reflected = self.albedo * (dni * np.cos(np.radians(solar_angles['zenith'])) + dhi)
+            record['ground_reflected_radiation'] = round(max(0.0, ground_reflected), 1)
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert the climate location to a dictionary."""
@@ -343,8 +342,8 @@ class ClimateData:
             "climate_zone", "heating_degree_days", "cooling_degree_days",
             "winter_design_temp", "summer_design_temp_db", "summer_design_temp_wb",
             "summer_daily_range", "wind_speed", "pressure",
-            "direct_normal_irradiance", "diffuse_horizontal_irradiance", "hourly_data",
-            "albedo", "solstice_zenith_angles"
+            "direct_normal_irradiance", "diffuse_horizontal_irradiance", "albedo",
+            "hourly_data", "solstice_zenith_angles"
         ]
         
         for field in required_fields:
@@ -391,6 +390,13 @@ class ClimateData:
         if not (0 <= data["albedo"] <= 1):
             st.error(f"Validation failed: Albedo {data['albedo']} outside range")
             return False
+        if not all(k in data["solstice_zenith_angles"] for k in ["summer", "winter"]):
+            st.error("Validation failed: Missing summer or winter solstice zenith angles")
+            return False
+        if not all(0 <= data["solstice_zenith_angles"][k] <= 180 for k in ["summer", "winter"]):
+            st.error("Validation failed: Solstice zenith angles outside range 0-180")
+            return False
+        
         if not data["hourly_data"] or len(data["hourly_data"]) < 8700:
             st.error(f"Validation failed: Hourly data has {len(data['hourly_data'])} records, expected ~8760")
             return False
@@ -428,16 +434,17 @@ class ClimateData:
             if not (0 <= record["wind_direction"] <= 360):
                 st.error(f"Validation failed: Wind direction {record['wind_direction']} outside range")
                 return False
-            if not (0 <= record["solar_time"] < 24):
+            # Validate new hourly fields if present
+            if "solar_time" in record and not (0 <= record["solar_time"] < 24):
                 st.error(f"Validation failed: Solar time {record['solar_time']} outside range")
                 return False
-            if not (0 <= record["solar_zenith"] <= 180):
+            if "solar_zenith" in record and not (0 <= record["solar_zenith"] <= 180):
                 st.error(f"Validation failed: Solar zenith {record['solar_zenith']} outside range")
                 return False
-            if not (0 <= record["solar_azimuth"] <= 360):
+            if "solar_azimuth" in record and not (0 <= record["solar_azimuth"] <= 360):
                 st.error(f"Validation failed: Solar azimuth {record['solar_azimuth']} outside range")
                 return False
-            if not (0 <= record["ground_reflected_radiation"] <= 1200):
+            if "ground_reflected_radiation" in record and not (0 <= record["ground_reflected_radiation"] <= 1200):
                 st.error(f"Validation failed: Ground reflected radiation {record['ground_reflected_radiation']} outside range")
                 return False
         
@@ -460,14 +467,6 @@ class ClimateData:
                     st.error(f"Validation failed: Invalid ground temperatures for depth {depth}")
                     return False
         
-        # Validate solstice zenith angles
-        if "solstice_zenith_angles" not in data or not all(key in data["solstice_zenith_angles"] for key in ["summer", "winter"]):
-            st.error("Validation failed: Missing or incomplete solstice zenith angles")
-            return False
-        if not (0 <= data["solstice_zenith_angles"]["summer"] <= 180 and 0 <= data["solstice_zenith_angles"]["winter"] <= 180):
-            st.error("Validation failed: Invalid solstice zenith angles")
-            return False
-        
         return True
 
     @staticmethod
@@ -560,7 +559,7 @@ class ClimateData:
                                 period_name = parts[2 + i*4]
                                 period_type = parts[3 + i*4]
                                 start_date = parts[4 + i*4].strip()
-                                end_date = bits[5 + i*4].strip()
+                                end_date = parts[5 + i*4].strip()
                                 if period_name in [
                                     "Summer - Week Nearest Max Temperature For Period",
                                     "Summer - Week Nearest Average Temperature For Period",
@@ -632,7 +631,7 @@ class ClimateData:
                     epw_file=epw_data,
                     typical_extreme_periods=typical_extreme_periods,
                     ground_temperatures=ground_temperatures,
-                    albedo=albedo,  # Pass albedo from main
+                    albedo=albedo,
                     id=f"{country[:1].upper()}{city[:3].upper()}",
                     country=country,
                     state_province=state_province,
@@ -676,7 +675,7 @@ class ClimateData:
                 epw_file=epw_data,
                 typical_extreme_periods=climate_data_dict["typical_extreme_periods"],
                 ground_temperatures=climate_data_dict["ground_temperatures"],
-                albedo=climate_data_dict["albedo"],
+                albedo=climate_data_dict.get("albedo", albedo),
                 id=climate_data_dict["id"],
                 country=climate_data_dict["country"],
                 state_province=climate_data_dict["state_province"],
@@ -686,12 +685,20 @@ class ClimateData:
                 elevation=climate_data_dict["elevation"],
                 time_zone=climate_data_dict["time_zone"]
             )
-            # Override hourly_data to ensure consistency
+            # Override hourly_data and solstice_zenith_angles to ensure consistency
             location.hourly_data = climate_data_dict["hourly_data"]
-            location.solstice_zenith_angles = climate_data_dict["solstice_zenith_angles"]
+            location.solstice_zenith_angles = climate_data_dict.get("solstice_zenith_angles", location._calculate_solstice_zenith_angles())
             self.add_location(location)
             st.info("Displaying previously extracted climate data.")
         
+        # Add button for calculating ground reflection radiation
+        if location and epw_data is not None:
+            if st.button("Calculate Ground Reflection Radiation"):
+                with st.spinner("Calculating solar time, angles, and ground-reflected radiation... Please wait."):
+                    location.calculate_ground_reflection()
+                    session_state["climate_data"] = location.to_dict()
+                    st.success("Ground reflection calculations completed!")
+        
         # Display tabs if location and epw_data are available
         if location and epw_data is not None:
             tab1, tab2, tab3, tab4, tab5 = st.tabs([
@@ -1107,7 +1114,7 @@ class ClimateData:
                 epw_file=epw_data,
                 typical_extreme_periods=loc_dict["typical_extreme_periods"],
                 ground_temperatures=loc_dict["ground_temperatures"],
-                albedo=loc_dict["albedo"],
+                albedo=loc_dict.get("albedo", 0.2),
                 id=loc_dict["id"],
                 country=loc_dict["country"],
                 state_province=loc_dict["state_province"],
@@ -1117,12 +1124,12 @@ class ClimateData:
                 elevation=loc_dict["elevation"],
                 time_zone=loc_dict["time_zone"]
             )
-            location.hourly_data = loc_dict["hourly_data"]  # Restore all hourly data including solar and radiation fields
-            location.solstice_zenith_angles = loc_dict["solstice_zenith_angles"]
+            location.hourly_data = loc_dict["hourly_data"]  # Ensure consistency
+            location.solstice_zenith_angles = loc_dict.get("solstice_zenith_angles", location._calculate_solstice_zenith_angles())
             climate_data.add_location(location)
         return climate_data
 
 if __name__ == "__main__":
     climate_data = ClimateData()
     session_state = {"building_info": {"country": "Australia", "city": "Geelong"}, "page": "Climate Data"}
-    climate_data.display_climate_input(session_state, albedo=0.2)  # Default albedo
+    climate_data.display_climate_input(session_state, albedo=0.2)