Update app/climate_data.py

app/climate_data.py

@@ -2,8 +2,8 @@
 BuildSustain - Climate Data Module
 
 This module handles the climate data selection, EPW file processing, and display of climate information
-for the BuildSustain application. It allows users to upload EPW weather files and extracts
-relevant climate data for use in load calculations.
+for the BuildSustain application. It allows users to upload EPW weather files or select climate projection
+data and extracts relevant climate data for use in load calculations.
 
 Developed by: Dr Majed Abuseif, Deakin University
 © 2025
@@ -21,6 +21,8 @@ import plotly.express as px
 from datetime import datetime
 from typing import Dict, List, Any, Optional, Tuple, Union
 import math
+import re
+from os.path import join as os_join
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -29,6 +31,38 @@ logger = logging.getLogger(__name__)
 # Define constants
 MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
 CLIMATE_ZONES = ["0A", "0B", "1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"]
+AU_CCH_DIR = "au_cch"  # Relative path to au_cch folder
+
+# Location mapping for Australian climate projections
+LOCATION_MAPPING = {
+    "24": {"city": "Canberra", "state": "ACT"},
+    "11": {"city": "Coffs Harbour", "state": "NSW"},
+    "17": {"city": "Sydney RO (Observatory Hill)", "state": "NSW"},
+    "56": {"city": "Mascot (Sydney Airport)", "state": "NSW"},
+    "77": {"city": "Parramatta", "state": "NSW"},
+    "78": {"city": "Sub-Alpine (Cooma Airport)", "state": "NSW"},
+    "79": {"city": "Blue Mountains", "state": "NSW"},
+    "1": {"city": "Darwin", "state": "NT"},
+    "6": {"city": "Alice Springs", "state": "NT"},
+    "5": {"city": "Townsville", "state": "QLD"},
+    "7": {"city": "Rockhampton", "state": "QLD"},
+    "10": {"city": "Brisbane", "state": "QLD"},
+    "19": {"city": "Charleville", "state": "QLD"},
+    "32": {"city": "Cairns", "state": "QLD"},
+    "70": {"city": "Toowoomba", "state": "QLD"},
+    "16": {"city": "Adelaide", "state": "SA"},
+    "75": {"city": "Adelaide Coastal (AMO)", "state": "SA"},
+    "26": {"city": "Hobart", "state": "TAS"},
+    "21": {"city": "Melbourne RO", "state": "VIC"},
+    "27": {"city": "Mildura", "state": "VIC"},
+    "60": {"city": "Tullamarine (Melbourne Airport)", "state": "VIC"},
+    "63": {"city": "Warrnambool", "state": "VIC"},
+    "66": {"city": "Ballarat", "state": "VIC"},
+    "30": {"city": "Wyndham", "state": "WA"},
+    "52": {"city": "Swanbourne", "state": "WA"},
+    "58": {"city": "Albany", "state": "WA"},
+    "83": {"city": "Christmas Island", "state": "WA"}
+}
 
 class ClimateDataManager:
     """Class for managing climate data from EPW files."""
@@ -37,19 +71,28 @@ class ClimateDataManager:
         """Initialize climate data manager."""
         pass
     
-    def load_epw(self, uploaded_file) -> Dict[str, Any]:
+    def load_epw(self, uploaded_file, location_num: str = None, rcp: str = None, year: str = None) -> Dict[str, Any]:
         """
         Parse an EPW file and extract climate data.
         
         Args:
-            uploaded_file: The uploaded EPW file object
+            uploaded_file: The uploaded EPW file object or file content as string
+            location_num: Location number for climate projection (optional)
+            rcp: RCP scenario for climate projection (optional)
+            year: Year for climate projection (optional)
             
         Returns:
             Dict containing parsed climate data
         """
         try:
             # Read the EPW file
-            content = uploaded_file.getvalue().decode('utf-8')
+            if isinstance(uploaded_file, str):
+                content = uploaded_file
+                epw_filename = f"{location_num}_{rcp}_{year}.epw"
+            else:
+                content = uploaded_file.getvalue().decode('utf-8')
+                epw_filename = uploaded_file.name
+            
             lines = content.split('\n')
             
             # Extract header information (first 8 lines)
@@ -71,6 +114,82 @@ class ClimateDataManager:
                 "elevation": float(location_data[9])
             }
             
+            # Override city and state from LOCATION_MAPPING if provided
+            if location_num in LOCATION_MAPPING:
+                location["city"] = LOCATION_MAPPING[location_num]["city"]
+                location["state_province"] = LOCATION_MAPPING[location_num]["state"]
+            
+            # Parse TYPICAL/EXTREME PERIODS
+            typical_extreme_periods = {}
+            date_pattern = r'^\d{1,2}\s*/\s*\d{1,2}$'
+            for line in lines:
+                if line.startswith("TYPICAL/EXTREME PERIODS"):
+                    parts = line.strip().split(',')
+                    try:
+                        num_periods = int(parts[1])
+                    except ValueError:
+                        logger.warning("Invalid number of periods in TYPICAL/EXTREME PERIODS, skipping parsing.")
+                        break
+                    for i in range(num_periods):
+                        try:
+                            if len(parts) < 2 + i*4 + 4:
+                                logger.warning(f"Insufficient fields for period {i+1}, skipping.")
+                                continue
+                            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()
+                            if period_name in [
+                                "Summer - Week Nearest Max Temperature For Period",
+                                "Summer - Week Nearest Average Temperature For Period",
+                                "Winter - Week Nearest Min Temperature For Period",
+                                "Winter - Week Nearest Average Temperature For Period"
+                            ]:
+                                season = 'summer' if 'Summer' in period_name else 'winter'
+                                period_type = 'extreme' if 'Max' in period_name or 'Min' in period_name else 'typical'
+                                key = f"{season}_{period_type}"
+                                start_date_clean = re.sub(r'\s+', '', start_date)
+                                end_date_clean = re.sub(r'\s+', '', end_date)
+                                if not re.match(date_pattern, start_date) or not re.match(date_pattern, end_date):
+                                    logger.warning(f"Invalid date format for period {period_name}: {start_date} to {end_date}, skipping.")
+                                    continue
+                                start_month, start_day = map(int, start_date_clean.split('/'))
+                                end_month, end_day = map(int, end_date_clean.split('/'))
+                                typical_extreme_periods[key] = {
+                                    "start": {"month": start_month, "day": start_day},
+                                    "end": {"month": end_month, "day": end_day}
+                                }
+                        except (IndexError, ValueError) as e:
+                            logger.warning(f"Error parsing period {i+1}: {str(e)}, skipping.")
+                            continue
+                    break
+            
+            # Parse GROUND TEMPERATURES
+            ground_temperatures = {}
+            for line in lines:
+                if line.startswith("GROUND TEMPERATURES"):
+                    parts = line.strip().split(',')
+                    try:
+                        num_depths = int(parts[1])
+                    except ValueError:
+                        logger.warning("Invalid number of depths in GROUND TEMPERATURES, skipping parsing.")
+                        break
+                    for i in range(num_depths):
+                        try:
+                            if len(parts) < 2 + i*16 + 16:
+                                logger.warning(f"Insufficient fields for ground temperature depth {i+1}, skipping.")
+                                continue
+                            depth = parts[2 + i*16]
+                            temps = [float(t) for t in parts[6 + i*16:18 + i*16] if t.strip()]
+                            if len(temps) != 12:
+                                logger.warning(f"Invalid number of temperatures for depth {depth}m, expected 12, got {len(temps)}, skipping.")
+                                continue
+                            ground_temperatures[depth] = temps
+                        except (ValueError, IndexError) as e:
+                            logger.warning(f"Error parsing ground temperatures for depth {i+1}: {str(e)}, skipping.")
+                            continue
+                    break
+            
             # Parse data rows (starting from line 9)
             data_lines = lines[8:]
             
@@ -119,15 +238,17 @@ class ClimateDataManager:
             
             # Create climate data dictionary
             climate_data = {
-                "id": f"{location['city']}_{location['country']}".replace(" ", "_"),
+                "id": f"{location['city']}_{location['country']}_{rcp}_{year}".replace(" ", "_") if rcp and year else f"{location['city']}_{location['country']}".replace(" ", "_"),
                 "location": location,
                 "design_conditions": design_conditions,
                 "climate_zone": climate_zone,
                 "hourly_data": hourly_data,
-                "epw_filename": uploaded_file.name
+                "epw_filename": epw_filename,
+                "typical_extreme_periods": typical_extreme_periods,
+                "ground_temperatures": ground_temperatures
             }
             
-            logger.info(f"EPW file processed successfully: {uploaded_file.name}")
+            logger.info(f"EPW file processed successfully: {epw_filename}")
             return climate_data
             
         except Exception as e:
@@ -152,7 +273,7 @@ class ClimateDataManager:
             winter_design_temp = np.percentile(temp_col, 0.4)  # 99.6% heating design temperature
             summer_design_temp_db = np.percentile(temp_col, 99.6)  # 0.4% cooling design temperature
             
-            # Calculate wet-bulb temperature (simplified)
+            # Calculate wet-bulb temperature
             rh_col = df["relative_humidity"].astype(float)
             wet_bulb_temp = self._calculate_wet_bulb(temp_col, rh_col)
             summer_design_temp_wb = np.percentile(wet_bulb_temp, 99.6)  # 0.4% cooling wet-bulb temperature
@@ -177,8 +298,6 @@ class ClimateDataManager:
             monthly_radiation = df.groupby(df["month"])["global_horizontal_radiation"].mean().tolist()
             
             # Calculate summer daily temperature range
-            # Summer months: 6-8 for Northern Hemisphere, 12-2 for Southern Hemisphere
-            # Determine hemisphere based on latitude
             latitude = df["latitude"].iloc[0] if "latitude" in df.columns else 0
             
             if latitude >= 0:  # Northern Hemisphere
@@ -213,7 +332,6 @@ class ClimateDataManager:
             
         except Exception as e:
             logger.error(f"Error calculating design conditions: {str(e)}")
-            # Return default values if calculation fails
             return {
                 "winter_design_temp": 0.0,
                 "summer_design_temp_db": 30.0,
@@ -296,7 +414,6 @@ class ClimateDataManager:
         Returns:
             ASHRAE climate zone designation
         """
-        # Simplified climate zone determination based on ASHRAE 169
         if hdd >= 7000:
             return "8"
         elif hdd >= 5400:
@@ -326,15 +443,21 @@ class ClimateDataManager:
         Returns:
             Wet-bulb temperature in °C
         """
-        # Simplified formula for wet-bulb temperature
         wet_bulb = dry_bulb * np.arctan(0.151977 * np.sqrt(relative_humidity + 8.313659)) + \
                    np.arctan(dry_bulb + relative_humidity) - np.arctan(relative_humidity - 1.676331) + \
                    0.00391838 * (relative_humidity)**(3/2) * np.arctan(0.023101 * relative_humidity) - 4.686035
         
-        # Ensure wet-bulb is not higher than dry-bulb
         wet_bulb = np.minimum(wet_bulb, dry_bulb)
         
         return wet_bulb
+    
+    def get_locations_by_state(self, state: str) -> List[Dict[str, str]]:
+        """Get list of locations for a given state from LOCATION_MAPPING."""
+        return [
+            {"number": loc_num, "city": loc_info["city"]}
+            for loc_num, loc_info in LOCATION_MAPPING.items()
+            if loc_info["state"] == state
+        ]
 
 def display_climate_page():
     """
@@ -343,6 +466,14 @@ def display_climate_page():
     """
     st.title("Climate Data and Design Requirements")
     
+    # Notify if climate data exists in session state
+    if "project_data" in st.session_state and "climate_data" in st.session_state.project_data and st.session_state.project_data["climate_data"]:
+        climate_data = st.session_state.project_data["climate_data"]
+        st.info(
+            f"Climate data already extracted for {climate_data['location']['city']}, {climate_data['location']['country']}. "
+            f"View details in the 'Climate Summary' tab or upload/select new data below."
+        )
+    
     # Display help information in an expandable section
     with st.expander("Help & Information"):
         display_climate_help()
@@ -355,55 +486,132 @@ def display_climate_page():
     
     # EPW Data Input tab
     with tab1:
-        st.subheader("Upload EPW Weather File")
+        st.subheader("Select Climate Data Source")
         
-        # File uploader for EPW files
-        uploaded_file = st.file_uploader(
-            "Upload EPW File",
-            type=["epw"],
-            help="Upload an EnergyPlus Weather (EPW) file for your location."
+        # Option to choose data source
+        data_source = st.radio(
+            "Choose data source:",
+            ["Upload EPW File", "Select Climate Projection"],
+            key="data_source"
         )
         
-        if uploaded_file is not None:
-            try:
-                # Process the uploaded EPW file
-                with st.spinner("Processing EPW file..."):
-                    climate_data = climate_manager.load_epw(uploaded_file)
-                
-                # Store climate data in session state
-                st.session_state.project_data["climate_data"] = climate_data
-                
-                # Show success message
-                st.success(f"EPW file processed successfully: {uploaded_file.name}")
-                
-                # Display basic location information
-                location = climate_data["location"]
-                st.subheader("Location Information")
-                
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.write(f"**City:** {location['city']}")
-                    st.write(f"**State/Province:** {location['state_province']}")
-                    st.write(f"**Country:** {location['country']}")
-                
-                with col2:
-                    st.write(f"**Latitude:** {location['latitude']}°")
-                    st.write(f"**Longitude:** {location['longitude']}°")
-                    st.write(f"**Elevation:** {location['elevation']} m")
-                
-                # Automatically switch to Climate Summary tab
-                st.button("View Climate Summary", on_click=lambda: st.session_state.update({"climate_tab": "Climate Summary"}))
+        if data_source == "Upload EPW File":
+            # File uploader for EPW files
+            uploaded_file = st.file_uploader(
+                "Upload EPW File",
+                type=["epw"],
+                help="Upload an EnergyPlus Weather (EPW) file for your location."
+            )
+            
+            if uploaded_file is not None:
+                try:
+                    with st.spinner("Processing EPW file..."):
+                        climate_data = climate_manager.load_epw(uploaded_file)
+                    
+                    # Store climate data in session state
+                    st.session_state.project_data["climate_data"] = climate_data
+                    
+                    st.success(f"EPW file processed successfully: {uploaded_file.name}")
+                    
+                    # Display basic location information
+                    location = climate_data["location"]
+                    st.subheader("Location Information")
+                    
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.write(f"**City:** {location['city']}")
+                        st.write(f"**State/Province:** {location['state_province']}")
+                        st.write(f"**Country:** {location['country']}")
+                    
+                    with col2:
+                        st.write(f"**Latitude:** {location['latitude']}°")
+                        st.write(f"**Longitude:** {location['longitude']}°")
+                        st.write(f"**Elevation:** {location['elevation']} m")
+                        st.write(f"**Time Zone:** {location['timezone']} hours (UTC)")
+                    
+                    st.button("View Climate Summary", on_click=lambda: st.session_state.update({"climate_tab": "Climate Summary"}))
                 
-            except Exception as e:
-                st.error(f"Error processing EPW file: {str(e)}")
-                logger.error(f"Error processing EPW file: {str(e)}")
+                except Exception as e:
+                    st.error(f"Error processing EPW file: {str(e)}")
+                    logger.error(f"Error processing EPW file: {str(e)}")
+        
+        else:  # Select Climate Projection
+            st.markdown("""
+            ### Climate Projection
+            Select from available Australian climate projection data based on CSIRO 2022 projections.
+            """)
+            
+            # Dropdown menus for climate projection
+            country = st.selectbox("Country", ["Australia"], key="projection_country")
+            states = ["ACT", "NSW", "NT", "QLD", "SA", "TAS", "VIC", "WA"]
+            state = st.selectbox("State", states, key="projection_state")
+            
+            locations = climate_manager.get_locations_by_state(state)
+            location_options = [f"{loc['city']} ({loc['number']})" for loc in locations]
+            location_display = st.selectbox("Location", location_options, key="location")
+            
+            location_num = ""
+            if location_display:
+                location_num = next(loc["number"] for loc in locations if f"{loc['city']} ({loc['number']})" == location_display)
+            
+            rcp_options = ["RCP2.6", "RCP4.5", "RCP8.5"]
+            rcp = st.selectbox("RCP Scenario", rcp_options, key="rcp")
+            
+            year_options = ["2030", "2050", "2070", "2090"]
+            year = st.selectbox("Year", year_options, key="year")
+            
+            if st.button("Extract Projection Data"):
+                with st.spinner("Extracting climate projection data..."):
+                    file_path = os_join(AU_CCH_DIR, location_num, rcp, year)
+                    logger.debug(f"Attempting to access directory: {os.path.abspath(file_path)}")
+                    
+                    if not os.path.exists(file_path):
+                        st.error(
+                            f"No directory found at au_cch/{location_num}/{rcp}/{year}/. "
+                            f"Ensure the 'au_cch' folder is in the repository root with structure "
+                            f"au_cch/{location_num}/{rcp}/{year} (e.g., au_cch/1/RCP2.6/2070/) "
+                            f"containing a single .epw file."
+                        )
+                        logger.error(f"Directory does not exist: {file_path}")
+                    else:
+                        try:
+                            epw_files = [f for f in os.listdir(file_path) if f.endswith(".epw")]
+                            if not epw_files:
+                                st.error(
+                                    f"No EPW file found in au_cch/{location_num}/{rcp}/{year}/. "
+                                    f"Ensure the directory contains a single .epw file."
+                                )
+                                logger.error(f"No EPW file found in {file_path}")
+                            elif len(epw_files) > 1:
+                                st.error(
+                                    f"Multiple EPW files found in au_cch/{location_num}/{rcp}/{year}/: {epw_files}. "
+                                    f"Ensure exactly one .epw file per directory."
+                                )
+                                logger.error(f"Multiple EPW files found: {epw_files}")
+                            else:
+                                epw_file_path = os_join(file_path, epw_files[0])
+                                with open(epw_file_path, 'r') as f:
+                                    epw_content = f.read()
+                                
+                                climate_data = climate_manager.load_epw(epw_content, location_num, rcp, year)
+                                st.session_state.project_data["climate_data"] = climate_data
+                                st.success(
+                                    f"Successfully extracted climate projection data for "
+                                    f"{climate_data['location']['city']}, {climate_data['location']['country']}, "
+                                    f"{rcp}, {year}!"
+                                )
+                                logger.info(f"Successfully processed projection: {climate_data['id']}")
+                                st.button("View Climate Summary", on_click=lambda: st.session_state.update({"climate_tab": "Climate Summary"}))
+                        except Exception as e:
+                            st.error(f"Error reading {epw_file_path}: {str(e)}")
+                            logger.error(f"Error reading {epw_file_path}: {str(e)}")
     
     # Climate Summary tab
     with tab2:
-        if "climate_data" in st.session_state.project_data and st.session_state.project_data["climate_data"]:
+        if "project_data" in st.session_state and "climate_data" in st.session_state.project_data and st.session_state.project_data["climate_data"]:
             display_climate_summary(st.session_state.project_data["climate_data"])
         else:
-            st.info("Please upload an EPW file in the 'EPW Data Input' tab to view climate summary.")
+            st.info("Please upload an EPW file or select a climate projection in the 'EPW Data Input' tab to view climate summary.")
     
     # Navigation buttons
     col1, col2 = st.columns(2)
@@ -415,9 +623,8 @@ def display_climate_page():
     
     with col2:
         if st.button("Continue to Material Library", key="continue_to_material"):
-            # Check if climate data is available before proceeding
-            if "climate_data" not in st.session_state.project_data or not st.session_state.project_data["climate_data"]:
-                st.warning("Please upload an EPW file before continuing.")
+            if "project_data" not in st.session_state or "climate_data" not in st.session_state.project_data or not st.session_state.project_data["climate_data"]:
+                st.warning("Please upload an EPW file or select a climate projection before continuing.")
             else:
                 st.session_state.current_page = "Material Library"
                 st.rerun()
@@ -431,17 +638,28 @@ def display_climate_summary(climate_data: Dict[str, Any]):
     """
     st.subheader("Climate Summary")
     
-    # Extract design conditions
+    # Extract data
     design = climate_data["design_conditions"]
     location = climate_data["location"]
     
-    # Display climate zone
+    # Location Details
+    st.markdown(f"""
+    ### Location Details
+    - **Country:** {location['country']}
+    - **City:** {location['city']}
+    - **State/Province:** {location['state_province']}
+    - **Latitude:** {location['latitude']}°
+    - **Longitude:** {location['longitude']}°
+    - **Elevation:** {location['elevation']} m
+    - **Time Zone:** {location['timezone']} hours (UTC)
+    """)
+    
+    # Climate Zone
     st.markdown(f"### ASHRAE Climate Zone: {climate_data['climate_zone']}")
     
-    # Create columns for layout
+    # Design Conditions
     col1, col2 = st.columns(2)
     
-    # Design temperatures
     with col1:
         st.subheader("Design Temperatures")
         st.write(f"**Winter Design Temperature:** {design['winter_design_temp']}°C")
@@ -449,7 +667,6 @@ def display_climate_summary(climate_data: Dict[str, Any]):
         st.write(f"**Summer Design Temperature (WB):** {design['summer_design_temp_wb']}°C")
         st.write(f"**Summer Daily Temperature Range:** {design['summer_daily_range']}°C")
     
-    # Degree days
     with col2:
         st.subheader("Degree Days")
         st.write(f"**Heating Degree Days (Base 18°C):** {design['heating_degree_days']}")
@@ -457,7 +674,35 @@ def display_climate_summary(climate_data: Dict[str, Any]):
         st.write(f"**Average Wind Speed:** {design['wind_speed']} m/s")
         st.write(f"**Average Atmospheric Pressure:** {design['pressure']} Pa")
     
-    # Monthly temperature chart
+    # Typical/Extreme Periods
+    if climate_data.get("typical_extreme_periods"):
+        st.subheader("Typical/Extreme Periods")
+        period_items = [
+            f"- **{key.replace('_', ' ').title()}:** {period['start']['month']}/{period['start']['day']} to {period['end']['month']}/{period['end']['day']}"
+            for key, period in climate_data["typical_extreme_periods"].items()
+        ]
+        st.markdown("\n".join(period_items))
+    
+    # Ground Temperatures
+    if climate_data.get("ground_temperatures"):
+        st.subheader("Ground Temperatures")
+        table_data = []
+        for depth, temps in climate_data["ground_temperatures"].items():
+            row = {"Depth (m)": float(depth)}
+            row.update({month: f"{temp:.2f}" for month, temp in zip(MONTHS, temps)})
+            table_data.append(row)
+        df = pd.DataFrame(table_data)
+        st.dataframe(df, use_container_width=True)
+        csv = df.to_csv(index=False)
+        st.download_button(
+            label="Download Ground Temperatures as CSV",
+            data=csv,
+            file_name=f"ground_temperatures_{location['city']}_{location['country']}.csv",
+            mime="text/csv",
+            key=f"download_ground_temperatures_{climate_data['id']}"
+        )
+    
+    # Monthly Temperature Chart
     st.subheader("Monthly Average Temperatures")
     
     fig_temp = go.Figure()
@@ -479,7 +724,7 @@ def display_climate_summary(climate_data: Dict[str, Any]):
     
     st.plotly_chart(fig_temp, use_container_width=True)
     
-    # Monthly radiation chart
+    # Monthly Radiation Chart
     st.subheader("Monthly Average Solar Radiation")
     
     fig_rad = go.Figure()
@@ -499,7 +744,7 @@ def display_climate_summary(climate_data: Dict[str, Any]):
     
     st.plotly_chart(fig_rad, use_container_width=True)
     
-    # Display hourly data statistics
+    # Hourly Data Statistics
     st.subheader("Hourly Data Statistics")
     
     if "hourly_data" in climate_data and climate_data["hourly_data"]:
@@ -508,6 +753,35 @@ def display_climate_summary(climate_data: Dict[str, Any]):
         
         if hourly_count < 8760:
             st.warning(f"Expected 8760 hourly records for a full year, but found {hourly_count}. Some data may be missing.")
+        
+        # Hourly Climate Data Table
+        st.subheader("Hourly Climate Data")
+        hourly_table_data = [
+            {
+                "Month": record["month"],
+                "Day": record["day"],
+                "Hour": record["hour"],
+                "Dry Bulb Temp (°C)": f"{record['dry_bulb']:.1f}",
+                "Relative Humidity (%)": f"{record['relative_humidity']:.1f}",
+                "Atmospheric Pressure (Pa)": f"{record['atmospheric_pressure']:.1f}",
+                "Global Horizontal Radiation (W/m²)": f"{record['global_horizontal_radiation']:.1f}",
+                "Direct Normal Radiation (W/m²)": f"{record['direct_normal_radiation']:.1f}",
+                "Diffuse Horizontal Radiation (W/m²)": f"{record['diffuse_horizontal_radiation']:.1f}",
+                "Wind Speed (m/s)": f"{record['wind_speed']:.1f}",
+                "Wind Direction (°)": f"{record['wind_direction']:.1f}"
+            }
+            for record in climate_data["hourly_data"]
+        ]
+        hourly_df = pd.DataFrame(hourly_table_data)
+        st.dataframe(hourly_df, use_container_width=True)
+        csv = hourly_df.to_csv(index=False)
+        st.download_button(
+            label="Download Hourly Climate Data as CSV",
+            data=csv,
+            file_name=f"hourly_climate_data_{location['city']}_{location['country']}.csv",
+            mime="text/csv",
+            key=f"download_hourly_climate_{climate_data['id']}"
+        )
     else:
         st.warning("No hourly data available.")
 
@@ -516,7 +790,7 @@ def display_climate_help():
     st.markdown("""
     ### Climate Data Help
     
-    This section allows you to upload and process weather data for your location, which is essential for accurate calculations.
+    This section allows you to upload or select weather data for your location, which is essential for accurate calculations.
     
     **EPW Files:**
     
@@ -534,15 +808,22 @@ def display_climate_help():
     * [Climate.OneBuilding.Org](https://climate.onebuilding.org/)
     * [ASHRAE International Weather for Energy Calculations (IWEC)](https://www.ashrae.org/technical-resources/bookstore/ashrae-international-weather-files-for-energy-calculations-2-0-iwec2)
     
+    **Climate Projections:**
+    
+    Select from predefined Australian climate projection data (CSIRO 2022) by choosing a location, RCP scenario, and future year.
+    
     **Climate Summary:**
     
-    After uploading an EPW file, the Climate Summary tab will display:
+    After uploading an EPW file or selecting a climate projection, the Climate Summary tab will display:
     
+    * Location details (including Time Zone)
     * ASHRAE Climate Zone
     * Design temperatures for heating and cooling
     * Heating and cooling degree days
+    * Typical/Extreme periods
+    * Ground temperatures by depth
     * Monthly average temperatures and solar radiation
-    * Hourly data statistics
+    * Hourly data statistics with downloadable tables
     
     This information will be used throughout the calculation process.
-    """)
+    """)