Update data/climate_data.py

data/climate_data.py

@@ -1,11 +1,10 @@
 """
 ASHRAE 169 climate data module for HVAC Load Calculator.
 Extracts climate data from EPW files and provides visualizations inspired by Climate Consultant.
-Includes solar radiation and position calculations for heat gain analysis.
 
 Author: Dr Majed Abuseif
 Date: May 2025
-Version: 2.1.7
+Version: 2.1.6
 """
 
 from typing import Dict, List, Any, Optional
@@ -85,9 +84,10 @@ class ClimateLocation:
     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_solar_angles: Dict[str, Dict]  # Solar angles for summer and winter solstices
-    
-    def __init__(self, epw_file: pd.DataFrame, typical_extreme_periods: Dict, ground_temperatures: Dict, **kwargs):
+    solstice_zenith_angles: Dict[str, float]  # Summer and winter solstice zenith angles
+    _solar_cache: Dict[str, Dict[str, float]]  # Cache for solar angles
+
+    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")
         self.country = kwargs.get("country")
@@ -99,9 +99,8 @@ class ClimateLocation:
         self.time_zone = kwargs.get("time_zone")
         self.typical_extreme_periods = typical_extreme_periods
         self.ground_temperatures = ground_temperatures
-        
-        # Cache for solar angles
-        self._solar_angle_cache = {}
+        self._solar_cache = {}
+        self.albedo = albedo  # Default albedo from ASHRAE Fundamentals, Chapter 14, Table 4
         
         # Extract columns from EPW data
         months = pd.to_numeric(epw_file[1], errors='coerce').values
@@ -114,16 +113,14 @@ class ClimateLocation:
         direct_normal_irradiance = pd.to_numeric(epw_file[14], errors='coerce').values
         diffuse_horizontal_irradiance = pd.to_numeric(epw_file[15], errors='coerce').values
         wind_direction = pd.to_numeric(epw_file[20], errors='coerce').values
-        wind_speed = pd.to_numeric(epw_file[21], errors='coerce').values
+        wind_speed = pd.to_numeric(epw_file[21], errors='coerce')
         
         # Filter wind speed outliers and log high values
         wind_speed = wind_speed[wind_speed <= 50]  # Remove extreme outliers
         if (wind_speed > 15).any():
             logger.warning(f"High wind speeds detected: {wind_speed[wind_speed > 15].tolist()}")
         
-        # Filter and validate irradiance outliers
-        direct_normal_irradiance = np.where(direct_normal_irradiance < 0, 0, direct_normal_irradiance)
-        diffuse_horizontal_irradiance = np.where(diffuse_horizontal_irradiance < 0, 0, diffuse_horizontal_irradiance)
+        # Filter irradiance outliers
         direct_normal_irradiance = direct_normal_irradiance[direct_normal_irradiance <= 1200]
         diffuse_horizontal_irradiance = diffuse_horizontal_irradiance[diffuse_horizontal_irradiance <= 1200]
         if (direct_normal_irradiance > 1000).any():
@@ -166,41 +163,25 @@ 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 solar angles (at solar noon, ~12:00)
-        self.solstice_solar_angles = self._calculate_solstice_solar_angles()
+        # Calculate solstice zenith angles
+        self.solstice_zenith_angles = self._calculate_solstice_zenith_angles()
         
-        # Store hourly data with enhanced fields, including solar angles and ground-reflected radiation
+        # Store hourly data with enhanced fields
         self.hourly_data = []
-        negative_dni_count = 0
-        negative_dhi_count = 0
         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)  # EPW hours are 1-24
+            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)
             
-            # Initialize defaults for solar-related fields
-            dni = 0.0
-            dhi = 0.0
-            ground_radiation = 0.0
+            # 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
             
-            # Perform solar calculations only if sun is above horizon (zenith < 90°)
-            if solar_angles['zenith'] < 90:
-                # Validate or fallback DNI/DHI
-                dni = float(direct_normal_irradiance[i]) if not np.isnan(direct_normal_irradiance[i]) else self._calculate_clear_sky_irradiance(timestamp, 'dni')
-                dhi = float(diffuse_horizontal_irradiance[i]) if not np.isnan(diffuse_horizontal_irradiance[i]) else self._calculate_clear_sky_irradiance(timestamp, 'dhi')
-                if dni < 0:
-                    negative_dni_count += 1
-                    dni = self._calculate_clear_sky_irradiance(timestamp, 'dni')
-                if dhi < 0:
-                    negative_dhi_count += 1
-                    dhi = self._calculate_clear_sky_irradiance(timestamp, 'dhi')
-                
-                # Calculate ground-reflected radiation
-                ground_radiation = self._calculate_ground_reflected_radiation(dni, dhi, solar_angles['zenith'])
+            # Calculate ground-reflected radiation
+            ground_reflected = self.albedo * (dni * np.cos(np.radians(solar_angles['zenith'])) + dhi)
             
             record = {
                 "month": int(months[i]),
@@ -212,99 +193,81 @@ class ClimateLocation:
                 "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,
-                "ground_reflected_radiation": ground_radiation,
                 "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_zenith": solar_angles['zenith'],
-                "solar_azimuth": solar_angles['azimuth']
+                "solar_time": float(solar_time),
+                "solar_zenith": float(solar_angles['zenith']),
+                "solar_azimuth": float(solar_angles['azimuth']),
+                "ground_reflected_radiation": float(ground_reflected)
             }
             self.hourly_data.append(record)
         
-        # Log summary of negative DNI/DHI corrections
-        if negative_dni_count > 0:
-            logger.warning(f"Corrected {negative_dni_count} negative DNI values using clear-sky model")
-        if negative_dhi_count > 0:
-            logger.warning(f"Corrected {negative_dhi_count} negative DHI values using clear-sky model")
-        
         if len(self.hourly_data) != 8760:
             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) -> datetime:
-        """Calculate solar time based on local time, longitude, and time zone (ASHRAE Fundamentals, Chapter 14, Section 14.7)."""
+    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  # Convert UTC offset to degrees
-        # Longitude correction in minutes (4 minutes per degree)
-        longitude_correction = 4 * (self.longitude - standard_meridian)
-        # Equation of time (simplified, using pvlib for accuracy)
+        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)
         day_of_year = timestamp.timetuple().tm_yday
-        solpos = pvlib.solarposition.get_solarposition(
-            time=timestamp,
-            latitude=self.latitude,
-            longitude=self.longitude,
-            altitude=self.elevation
-        )
-        # Solar time = Local time + Longitude correction + Equation of time
-        equation_of_time = solpos['equation_of_time'].iloc[0]  # in minutes
-        time_diff = longitude_correction + equation_of_time
-        solar_time = timestamp + timedelta(minutes=time_diff)
+        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
+        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
 
     def _calculate_solar_angles(self, timestamp: datetime) -> Dict[str, float]:
-        """Calculate solar zenith and azimuth angles using pvlib (ASHRAE Fundamentals, Chapter 14, Section 14.7)."""
-        # Create a cache key
-        cache_key = hashlib.md5(f"{timestamp.isoformat()}_{self.latitude}_{self.longitude}_{self.time_zone}".encode()).hexdigest()
+        """Calculate solar zenith and azimuth angles, caching results (ASHRAE Fundamentals, Chapter 14, Section 14.7)."""
+        # Create cache key
+        cache_key = hashlib.md5(
+            f"{timestamp.strftime('%Y-%m-%d_%H')}_{self.latitude}_{self.longitude}_{self.time_zone}".encode()
+        ).hexdigest()
         
-        if cache_key in self._solar_angle_cache:
-            return self._solar_angle_cache[cache_key]
+        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
         )
-        angles = {
-            'zenith': round(float(solpos['zenith'].iloc[0]), 2),
-            'azimuth': round(float(solpos['azimuth'].iloc[0]), 2)
-        }
+        zenith = solpos['zenith'].iloc[0]
+        azimuth = solpos['azimuth'].iloc[0]
         
-        # Cache the result
-        self._solar_angle_cache[cache_key] = angles
-        return angles
-
-    def _calculate_clear_sky_irradiance(self, timestamp: datetime, component: str) -> float:
-        """Calculate clear-sky DNI or DHI using ASHRAE clear-sky model (Chapter 14, Section 14.6)."""
-        clearsky = pvlib.clearsky.ineichen(
-            time=timestamp,
-            latitude=self.latitude,
-            longitude=self.longitude,
-            altitude=self.elevation,
-            pressure=self.pressure
-        )
-        return float(clearsky[component].iloc[0]) if component in ['dni', 'dhi'] else 0.0
-
-    def _calculate_ground_reflected_radiation(self, dni: float, dhi: float, zenith: float) -> float:
-        """Calculate ground-reflected radiation using albedo (ASHRAE Fundamentals, Chapter 14, Table 4)."""
-        albedo = 0.2  # Default albedo per ASHRAE
-        cos_zenith = np.cos(np.radians(zenith))
-        ground_radiation = albedo * (dni * cos_zenith + dhi)
-        return round(max(0, ground_radiation), 1)
+        # Cache results
+        self._solar_cache[cache_key] = {
+            'zenith': zenith,
+            'azimuth': azimuth
+        }
+        return self._solar_cache[cache_key]
 
-    def _calculate_solstice_solar_angles(self) -> Dict[str, Dict]:
-        """Calculate solar angles at solar noon for summer and winter solstices."""
+    def _calculate_solstice_zenith_angles(self) -> Dict[str, float]:
+        """Calculate solar zenith angles for summer and winter solstices at noon."""
         dates = [
-            datetime(2025, 6, 21, 12),  # Winter solstice (Southern Hemisphere)
-            datetime(2025, 12, 21, 12)  # Summer solstice (Southern Hemisphere)
+            datetime(2025, 12, 21, 12),  # Summer solstice (Southern Hemisphere)
+            datetime(2025, 6, 21, 12)   # Winter solstice (Southern Hemisphere)
         ]
-        solstice_angles = {}
+        solstice_zeniths = {}
         for date in dates:
-            season = 'winter' if date.month == 6 else 'summer'
-            angles = self._calculate_solar_angles(date)
-            solstice_angles[f"{season}_solstice"] = {
-                "zenith": angles['zenith'],
-                "azimuth": angles['azimuth']
-            }
-        return solstice_angles
+            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
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert the climate location to a dictionary."""
@@ -328,10 +291,11 @@ class ClimateLocation:
             "pressure": self.pressure,
             "direct_normal_irradiance": self.direct_normal_irradiance,
             "diffuse_horizontal_irradiance": self.diffuse_horizontal_irradiance,
+            "albedo": self.albedo,
             "hourly_data": self.hourly_data,
             "typical_extreme_periods": self.typical_extreme_periods,
             "ground_temperatures": self.ground_temperatures,
-            "solstice_solar_angles": self.solstice_solar_angles
+            "solstice_zenith_angles": self.solstice_zenith_angles
         }
 
 class ClimateData:
@@ -380,7 +344,7 @@ class ClimateData:
             "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",
-            "solstice_solar_angles"
+            "albedo", "solstice_zenith_angles"
         ]
         
         for field in required_fields:
@@ -424,7 +388,9 @@ class ClimateData:
         if not (0 <= data["diffuse_horizontal_irradiance"] <= 1200):
             st.error(f"Validation failed: Diffuse horizontal irradiance {data['diffuse_horizontal_irradiance']} outside range")
             return False
-        
+        if not (0 <= data["albedo"] <= 1):
+            st.error(f"Validation failed: Albedo {data['albedo']} outside range")
+            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
@@ -456,8 +422,14 @@ class ClimateData:
             if not (0 <= record["diffuse_horizontal_irradiance"] <= 1200):
                 st.error(f"Validation failed: Diffuse horizontal irradiance {record['diffuse_horizontal_irradiance']} outside range")
                 return False
-            if not (0 <= record["ground_reflected_radiation"] <= 1200):
-                st.error(f"Validation failed: Ground reflected radiation {record['ground_reflected_radiation']} outside range")
+            if not (0 <= record["wind_speed"] <= 30):
+                st.error(f"Validation failed: Wind speed {record['wind_speed']} outside range")
+                return False
+            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):
+                st.error(f"Validation failed: Solar time {record['solar_time']} outside range")
                 return False
             if not (0 <= record["solar_zenith"] <= 180):
                 st.error(f"Validation failed: Solar zenith {record['solar_zenith']} outside range")
@@ -465,11 +437,8 @@ class ClimateData:
             if not (0 <= record["solar_azimuth"] <= 360):
                 st.error(f"Validation failed: Solar azimuth {record['solar_azimuth']} outside range")
                 return False
-            if not (0 <= record["wind_speed"] <= 30):
-                st.error(f"Validation failed: Wind speed {record['wind_speed']} outside range")
-                return False
-            if not (0 <= record["wind_direction"] <= 360):
-                st.error(f"Validation failed: Wind direction {record['wind_direction']} outside range")
+            if not (0 <= record["ground_reflected_radiation"] <= 1200):
+                st.error(f"Validation failed: Ground reflected radiation {record['ground_reflected_radiation']} outside range")
                 return False
         
         # Validate typical/extreme periods (optional)
@@ -491,22 +460,12 @@ class ClimateData:
                     st.error(f"Validation failed: Invalid ground temperatures for depth {depth}")
                     return False
         
-        # Validate solstice solar angles
-        if "solstice_solar_angles" in data:
-            for season in ["summer_solstice", "winter_solstice"]:
-                if season not in data["solstice_solar_angles"]:
-                    st.error(f"Validation failed: Missing {season} in solstice_solar_angles")
-                    return False
-                angles = data["solstice_solar_angles"][season]
-                if not (0 <= angles["zenith"] <= 180 and 0 <= angles["azimuth"] <= 360):
-                    st.error(f"Validation failed: Invalid {season} angles: {angles}")
-                    return False
-        
-        # Log presence of ground_reflected_radiation during import
-        if all("ground_reflected_radiation" in record for record in data["hourly_data"]):
-            logger.info("Validated ground_reflected_radiation present in all hourly data records")
-        else:
-            st.error("Validation failed: Missing ground_reflected_radiation in some hourly data records")
+        # 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
@@ -539,8 +498,8 @@ class ClimateData:
         except ValueError:
             return False
 
-    def display_climate_input(self, session_state: Dict[str, Any]):
-        """Display Streamlit interface for EPW and JSON upload, and visualizations."""
+    def display_climate_input(self, session_state: Dict[str, Any], albedo: float = 0.2):
+        """Display Streamlit interface for EPW upload and visualizations."""
         st.title("Climate Data Analysis")
         
         # Apply consistent styling
@@ -551,64 +510,16 @@ class ClimateData:
             st.warning("Clearing invalid climate data from session state.")
             del session_state["climate_data"]
         
-        # File uploaders
-        uploaded_epw_file = st.file_uploader("Upload EPW File", type=["epw"])
-        uploaded_json_file = st.file_uploader("Upload JSON File", type=["json"])
+        uploaded_file = st.file_uploader("Upload EPW File", type=["epw"])
         
         # Initialize location and epw_data for display
         location = None
         epw_data = None
         
-        # Process JSON file if uploaded
-        if uploaded_json_file:
-            try:
-                json_content = uploaded_json_file.read().decode("utf-8")
-                json_data = json.loads(json_content)
-                for loc_id, loc_dict in json_data.items():
-                    if not self.validate_climate_data(loc_dict):
-                        raise ValueError("Invalid climate data in JSON file.")
-                    # Rebuild epw_data from hourly_data
-                    hourly_data = loc_dict["hourly_data"]
-                    epw_data = pd.DataFrame({
-                        1: [d["month"] for d in hourly_data],
-                        2: [d["day"] for d in hourly_data],
-                        3: [d["hour"] for d in hourly_data],
-                        6: [d["dry_bulb"] for d in hourly_data],
-                        8: [d["relative_humidity"] for d in hourly_data],
-                        9: [d["atmospheric_pressure"] for d in hourly_data],
-                        13: [d["global_horizontal_radiation"] for d in hourly_data],
-                        14: [d["direct_normal_irradiance"] for d in hourly_data],
-                        15: [d["diffuse_horizontal_irradiance"] for d in hourly_data],
-                        20: [d["wind_direction"] for d in hourly_data],
-                        21: [d["wind_speed"] for d in hourly_data],
-                    })
-                    location = ClimateLocation(
-                        epw_file=epw_data,
-                        typical_extreme_periods=loc_dict["typical_extreme_periods"],
-                        ground_temperatures=loc_dict["ground_temperatures"],
-                        id=loc_dict["id"],
-                        country=loc_dict["country"],
-                        state_province=loc_dict["state_province"],
-                        city=loc_dict["city"],
-                        latitude=loc_dict["latitude"],
-                        longitude=loc_dict["longitude"],
-                        elevation=loc_dict["elevation"],
-                        time_zone=loc_dict["time_zone"]
-                    )
-                    location.hourly_data = loc_dict["hourly_data"]
-                    location.solstice_solar_angles = loc_dict["solstice_solar_angles"]
-                    self.add_location(location)
-                    session_state["climate_data"] = loc_dict
-                    st.success(f"Climate data loaded from JSON for {loc_dict['city']}")
-                logger.info(f"Successfully imported JSON with ground_reflected_radiation for {loc_dict['city']}")
-            except Exception as e:
-                st.error(f"Error processing JSON file: {str(e)}. Ensure it has valid climate data.")
-        
-        # Process EPW file if uploaded
-        elif uploaded_epw_file:
+        if uploaded_file:
             try:
                 # Process new EPW file
-                epw_content = uploaded_epw_file.read().decode("utf-8")
+                epw_content = uploaded_file.read().decode("utf-8")
                 epw_lines = epw_content.splitlines()
                 
                 # Parse header
@@ -649,7 +560,7 @@ class ClimateData:
                                 period_name = parts[2 + i*4]
                                 period_type = parts[3 + i*4]
                                 start_date = parts[4 + i*4].strip()
-                                end_date = parts[5 + i*4].strip()
+                                end_date = bits[5 + i*4].strip()
                                 if period_name in [
                                     "Summer - Week Nearest Max Temperature For Period",
                                     "Summer - Week Nearest Average Temperature For Period",
@@ -721,6 +632,7 @@ class ClimateData:
                     epw_file=epw_data,
                     typical_extreme_periods=typical_extreme_periods,
                     ground_temperatures=ground_temperatures,
+                    albedo=albedo,  # Pass albedo from main
                     id=f"{country[:1].upper()}{city[:3].upper()}",
                     country=country,
                     state_province=state_province,
@@ -733,12 +645,9 @@ class ClimateData:
                 climate_data_dict = location.to_dict()
                 if not self.validate_climate_data(climate_data_dict):
                     raise ValueError("Invalid climate data extracted from EPW file.")
-                
-                # Add location and save to session state
-                self.add_location(location)
                 session_state["climate_data"] = climate_data_dict
                 st.success("Climate data extracted from EPW file!")
-       
+            
             except Exception as e:
                 st.error(f"Error processing EPW file: {str(e)}. Ensure it has 8760 hourly records and correct format.")
         
@@ -767,6 +676,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"],
                 id=climate_data_dict["id"],
                 country=climate_data_dict["country"],
                 state_province=climate_data_dict["state_province"],
@@ -778,7 +688,7 @@ class ClimateData:
             )
             # Override hourly_data to ensure consistency
             location.hourly_data = climate_data_dict["hourly_data"]
-            location.solstice_solar_angles = climate_data_dict["solstice_solar_angles"]
+            location.solstice_zenith_angles = climate_data_dict["solstice_zenith_angles"]
             self.add_location(location)
             st.info("Displaying previously extracted climate data.")
         
@@ -808,18 +718,13 @@ class ClimateData:
                 self.plot_wind_rose(epw_data)
         
         else:
-            st.info("No climate data available. Please upload an EPW or JSON file to proceed.")
+            st.info("No climate data available. Please upload an EPW file to proceed.")
         
     def display_design_conditions(self, location: ClimateLocation):
         """Display design conditions for HVAC calculations using styled HTML."""
         st.subheader("Design Conditions")
         
         # Location Details
-        solstice_items = [
-            f"<li><strong>{key.replace('_', ' ').title()} Zenith:</strong> {angles['zenith']}°</li>"
-            f"<li><strong>{key.replace('_', ' ').title()} Azimuth:</strong> {angles['azimuth']}°</li>"
-            for key, angles in location.solstice_solar_angles.items()
-        ]
         st.markdown(f"""
         <div class="markdown-text">
             <h3>Location Details</h3>
@@ -831,7 +736,8 @@ class ClimateData:
                 <li><strong>Longitude:</strong> {location.longitude}°</li>
                 <li><strong>Elevation:</strong> {location.elevation} m</li>
                 <li><strong>Time Zone:</strong> UTC{location.time_zone:+.1f}</li>
-                {''.join(solstice_items)}
+                <li><strong>Summer Solstice Zenith Angle (Dec 21):</strong> {location.solstice_zenith_angles['summer']}°</li>
+                <li><strong>Winter Solstice Zenith Angle (Jun 21):</strong> {location.solstice_zenith_angles['winter']}°</li>
             </ul>
         </div>
         """, unsafe_allow_html=True)
@@ -852,6 +758,7 @@ class ClimateData:
                 <li><strong>Mean Atmospheric Pressure:</strong> {location.pressure} Pa</li>
                 <li><strong>Mean Direct Normal Irradiance:</strong> {location.direct_normal_irradiance} W/m²</li>
                 <li><strong>Mean Diffuse Horizontal Irradiance:</strong> {location.diffuse_horizontal_irradiance} W/m²</li>
+                <li><strong>Albedo:</strong> {location.albedo}</li>
             </ul>
         </div>
         """, unsafe_allow_html=True)
@@ -871,21 +778,6 @@ class ClimateData:
             </div>
             """, unsafe_allow_html=True)
         
-        # Ground Temperatures (Table)
-        if location.typical_extreme_periods:
-            period_items = [
-                f"<li><strong>{key.replace('_', ' ').title()}:</strong> {period['start']['month']}/{period['start']['day']} to {period['end']['month']}/{period['end']['day']}</li>"
-                for key, period in location.typical_extreme_periods.items()
-            ]
-            st.markdown(f"""
-            <div class="markdown-text">
-                <h3>Typical/Extreme Periods</h3>
-                <ul>
-                    {''.join(period_items)}
-                </ul>
-            </div>
-            """, unsafe_allow_html=True)
-        
         # Ground Temperatures (Table)
         if location.ground_temperatures:
             st.markdown('<div class="markdown-text"><h3>Ground Temperatures</h3></div>', unsafe_allow_html=True)
@@ -1215,6 +1107,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"],
                 id=loc_dict["id"],
                 country=loc_dict["country"],
                 state_province=loc_dict["state_province"],
@@ -1224,12 +1117,12 @@ class ClimateData:
                 elevation=loc_dict["elevation"],
                 time_zone=loc_dict["time_zone"]
             )
-            location.hourly_data = loc_dict["hourly_data"]
-            location.solstice_solar_angles = loc_dict["solstice_solar_angles"]
+            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"]
             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)
+    climate_data.display_climate_input(session_state, albedo=0.2)  # Default albedo