Update data/climate_data.py

data/climate_data.py

@@ -1,479 +1,490 @@
-"""
-ASHRAE 169 climate data module for HVAC Load Calculator.
-This module provides access to climate data for various locations based on ASHRAE 169 standard.
-
-Author: Dr Majed Abuseif
-Date: March 2025
-Version: 1.0.0
-"""
-
-from typing import Dict, List, Any, Optional, Tuple
-import pandas as pd
-import numpy as np
-import os
-import json
-from dataclasses import dataclass
-import streamlit as st
-import plotly.graph_objects as go
-from io import StringIO
-
-# Define paths
-DATA_DIR = os.path.dirname(os.path.abspath(__file__))
-
-
-@dataclass
-class ClimateLocation:
-    """Class representing a climate location with ASHRAE 169 data."""
-    
-    id: str
-    country: str
-    state_province: str
-    city: str
-    latitude: float
-    longitude: float
-    elevation: float  # meters
-    climate_zone: str
-    heating_degree_days: float  # base 18°C
-    cooling_degree_days: float  # base 18°C
-    winter_design_temp: float  # 99.6% heating design temperature (°C)
-    summer_design_temp_db: float  # 0.4% cooling design dry-bulb temperature (°C)
-    summer_design_temp_wb: float  # 0.4% cooling design wet-bulb temperature (°C)
-    summer_daily_range: float  # Mean daily temperature range in summer (°C)
-    monthly_temps: Dict[str, float]  # Average monthly temperatures (°C)
-    monthly_humidity: Dict[str, float]  # Average monthly relative humidity (%)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert the climate location to a dictionary."""
-        return {
-            "id": self.id,
-            "country": self.country,
-            "state_province": self.state_province,
-            "city": self.city,
-            "latitude": self.latitude,
-            "longitude": self.longitude,
-            "elevation": self.elevation,
-            "climate_zone": self.climate_zone,
-            "heating_degree_days": self.heating_degree_days,
-            "cooling_degree_days": self.cooling_degree_days,
-            "winter_design_temp": self.winter_design_temp,
-            "summer_design_temp_db": self.summer_design_temp_db,
-            "summer_design_temp_wb": self.summer_design_temp_wb,
-            "summer_daily_range": self.summer_daily_range,
-            "monthly_temps": self.monthly_temps,
-            "monthly_humidity": self.monthly_humidity
-        }
-
-
-class ClimateData:
-    """Class for managing ASHRAE 169 climate data."""
-    
-    def __init__(self):
-        """Initialize climate data."""
-        self.locations = {}
-        self.countries = []
-        self.country_states = {}
-    
-    def _group_locations_by_country_state(self) -> Dict[str, Dict[str, List[str]]]:
-        """Group locations by country and state/province."""
-        result = {}
-        for loc in self.locations.values():
-            if loc.country not in result:
-                result[loc.country] = {}
-            if loc.state_province not in result[loc.country]:
-                result[loc.country][loc.state_province] = []
-            result[loc.country][loc.state_province].append(loc.city)
-        for country in result:
-            for state in result[country]:
-                result[country][state] = sorted(result[country][state])
-        return result
-    
-    def add_location(self, location: ClimateLocation):
-        """Add a new location to the dictionary."""
-        self.locations[location.id] = location
-        self.countries = sorted(list(set(loc.country for loc in self.locations.values())))
-        self.country_states = self._group_locations_by_country_state()
-
-    def _infer_epw_columns(self, epw_data: pd.DataFrame) -> Dict[str, int]:
-        """Infer column indices for key weather parameters based on data ranges."""
-        column_map = {}
-        for col in epw_data.columns:
-            values = epw_data[col].values
-            mean_val = np.mean(values)
-            min_val = np.min(values)
-            max_val = np.max(values)
-
-            # Dry Bulb Temperature (°C): -50 to 50°C
-            if -50 <= min_val <= max_val <= 50 and col not in column_map:
-                column_map["dry_bulb"] = col
-            # Wet Bulb Temperature (°C): -50 to 40°C, usually less than dry bulb
-            elif -50 <= min_val <= max_val <= 40 and col not in column_map:
-                column_map["wet_bulb"] = col
-            # Relative Humidity (%): 0 to 100%
-            elif 0 <= min_val <= max_val <= 100 and col not in column_map:
-                column_map["humidity"] = col
-            # Atmospheric Pressure (Pa): 80000 to 105000 Pa
-            elif 80000 <= min_val <= max_val <= 105000 and col not in column_map:
-                column_map["pressure"] = col
-
-        # Standard EPW column indices as fallback
-        standard_map = {
-            "dry_bulb": 6,
-            "wet_bulb": 8,
-            "humidity": 21,
-            "pressure": 9
-        }
-
-        # Validate inferred columns against standard, warn if mismatched
-        for key in standard_map:
-            if key not in column_map:
-                st.warning(f"Could not infer {key} column. Using standard EPW index {standard_map[key]}.")
-                column_map[key] = standard_map[key]
-            elif column_map[key] != standard_map[key]:
-                st.warning(f"Inferred {key} column ({column_map[key]}) differs from standard EPW ({standard_map[key]}). Proceeding with inferred column.")
-
-        return column_map
-
-    def display_climate_input(self, session_state: Dict[str, Any]):
-        """Display form for manual input or EPW upload in Streamlit."""
-        st.title("Climate Data")
-        
-        if not session_state.building_info.get("country") or not session_state.building_info.get("city"):
-            st.warning("Please enter country and city in Building Information first.")
-            st.button("Go to Building Information", on_click=lambda: setattr(session_state, "page", "Building Information"))
-            return
-        
-        st.subheader(f"Location: {session_state.building_info['country']}, {session_state.building_info['city']}")
-        tab1, tab2 = st.tabs(["Manual Input", "Upload EPW File"])
-        
-        # Manual Input Tab
-        with tab1:
-            with st.form("manual_climate_form"):
-                col1, col2 = st.columns(2)
-                with col1:
-                    id_input = st.text_input("Location ID", value=f"{session_state.building_info['country'][:2].upper()}-{session_state.building_info['city'][:3].upper()}")
-                    state_province = st.text_input("State/Province", value="N/A")
-                    latitude = st.number_input("Latitude", min_value=-90.0, max_value=90.0, value=0.0, step=0.1)
-                    longitude = st.number_input("Longitude", min_value=-180.0, max_value=180.0, value=0.0, step=0.1)
-                    elevation = st.number_input("Elevation (m)", min_value=0.0, value=0.0, step=10.0)
-                    climate_zone = st.selectbox("Climate Zone", ["0A", "0B", "1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"])
-                
-                with col2:
-                    hdd = st.number_input("Heating Degree Days (base 18°C)", min_value=0.0, value=0.0, step=100.0)
-                    cdd = st.number_input("Cooling Degree Days (base 18°C)", min_value=0.0, value=0.0, step=100.0)
-                    winter_design_temp = st.number_input("Winter Design Temp (99.6%) (°C)", min_value=-50.0, max_value=20.0, value=0.0, step=0.5)
-                    summer_design_temp_db = st.number_input("Summer Design Temp DB (0.4%) (°C)", min_value=0.0, max_value=50.0, value=35.0, step=0.5)
-                    summer_design_temp_wb = st.number_input("Summer Design Temp WB (0.4%) (°C)", min_value=0.0, max_value=40.0, value=25.0, step=0.5)
-                    summer_daily_range = st.number_input("Summer Daily Range (°C)", min_value=0.0, value=5.0, step=0.5)
-                
-                st.subheader("Monthly Data")
-                monthly_temps = {}
-                monthly_humidity = {}
-                month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
-                col1, col2 = st.columns(2)
-                with col1:
-                    for month in month_names[:6]:
-                        monthly_temps[month] = st.number_input(f"{month} Temp (°C)", min_value=-50.0, max_value=50.0, value=20.0, step=0.5, key=f"temp_{month}")
-                with col2:
-                    for month in month_names[6:]:
-                        monthly_temps[month] = st.number_input(f"{month} Temp (°C)", min_value=-50.0, max_value=50.0, value=20.0, step=0.5, key=f"temp_{month}")
-                col1, col2 = st.columns(2)
-                with col1:
-                    for month in month_names[:6]:
-                        monthly_humidity[month] = st.number_input(f"{month} Humidity (%)", min_value=0.0, max_value=100.0, value=50.0, step=5.0, key=f"hum_{month}")
-                with col2:
-                    for month in month_names[6:]:
-                        monthly_humidity[month] = st.number_input(f"{month} Humidity (%)", min_value=0.0, max_value=100.0, value=50.0, step=5.0, key=f"hum_{month}")
-                
-                if st.form_submit_button("Save Climate Data"):
-                    location = ClimateLocation(
-                        id=id_input,
-                        country=session_state.building_info["country"],
-                        state_province=state_province,
-                        city=session_state.building_info["city"],
-                        latitude=latitude,
-                        longitude=longitude,
-                        elevation=elevation,
-                        climate_zone=climate_zone,
-                        heating_degree_days=hdd,
-                        cooling_degree_days=cdd,
-                        winter_design_temp=winter_design_temp,
-                        summer_design_temp_db=summer_design_temp_db,
-                        summer_design_temp_wb=summer_design_temp_wb,
-                        summer_daily_range=summer_daily_range,
-                        monthly_temps=monthly_temps,
-                        monthly_humidity=monthly_humidity
-                    )
-                    self.add_location(location)
-                    st.success("Climate data saved manually!")
-                    self.display_design_conditions(location)
-                    self.visualize_data(location, epw_data=None)  # No EPW data for manual input
-
-        # EPW Upload Tab
-        with tab2:
-            uploaded_file = st.file_uploader("Upload EPW File", type=["epw"])
-            if uploaded_file:
-                try:
-                    epw_content = uploaded_file.read().decode("utf-8")
-                    epw_lines = epw_content.splitlines()
-                    header = next(line for line in epw_lines if line.startswith("LOCATION"))
-                    header_parts = header.split(",")
-                    latitude = float(header_parts[6])
-                    longitude = float(header_parts[7])
-                    elevation = float(header_parts[8])
-                    
-                    epw_data = pd.read_csv(StringIO("\n".join(epw_lines[8:])), header=None)
-                    if len(epw_data) != 8760:
-                        raise ValueError("EPW file must contain 8760 hourly records.")
-
-                    # Infer column indices
-                    column_map = self._infer_epw_columns(epw_data)
-                    
-                    # Extract data with inferred columns
-                    months = epw_data[1].values  # Month column
-                    dry_bulb = epw_data[column_map["dry_bulb"]].values
-                    wet_bulb = epw_data[column_map["wet_bulb"]].values
-                    humidity = epw_data[column_map["humidity"]].values
-                    
-                    # Calculate daily averages for HDD/CDD
-                    daily_temps = dry_bulb.reshape(-1, 24).mean(axis=1)
-                    hdd = round(sum(max(18 - temp, 0) for temp in daily_temps))
-                    cdd = round(sum(max(temp - 18, 0) for temp in daily_temps))
-                    
-                    # Design conditions
-                    winter_design_temp = round(np.percentile(dry_bulb, 0.4), 1)
-                    summer_design_temp_db = round(np.percentile(dry_bulb, 99.6), 1)
-                    summer_idx = np.argmax(dry_bulb >= summer_design_temp_db)
-                    summer_design_temp_wb = round(wet_bulb[summer_idx], 1)
-                    summer_mask = (months >= 6) & (months <= 8)
-                    summer_temps = dry_bulb[summer_mask].reshape(-1, 24)
-                    summer_daily_range = round(np.mean(summer_temps.max(axis=1) - summer_temps.min(axis=1)), 1)
-                    
-                    # Monthly averages, mins, and maxes (stored only averages in ClimateLocation)
-                    monthly_temps = {}
-                    monthly_humidity = {}
-                    month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
-                    for i in range(1, 13):
-                        month_mask = (months == i)
-                        monthly_temps[month_names[i-1]] = round(np.mean(dry_bulb[month_mask]), 1)
-                        monthly_humidity[month_names[i-1]] = round(np.mean(humidity[month_mask]), 1)
-                    
-                    avg_humidity = np.mean(humidity)
-                    climate_zone = self.assign_climate_zone(hdd, cdd, avg_humidity)
-                    
-                    location = ClimateLocation(
-                        id=f"{session_state.building_info['country'][:2].upper()}-{session_state.building_info['city'][:3].upper()}",
-                        country=session_state.building_info["country"],
-                        state_province="N/A",
-                        city=session_state.building_info["city"],
-                        latitude=latitude,
-                        longitude=longitude,
-                        elevation=elevation,
-                        climate_zone=climate_zone,
-                        heating_degree_days=hdd,
-                        cooling_degree_days=cdd,
-                        winter_design_temp=winter_design_temp,
-                        summer_design_temp_db=summer_design_temp_db,
-                        summer_design_temp_wb=summer_design_temp_wb,
-                        summer_daily_range=summer_daily_range,
-                        monthly_temps=monthly_temps,
-                        monthly_humidity=monthly_humidity
-                    )
-                    self.add_location(location)
-                    st.success("Climate data extracted from EPW file!")
-                    self.display_design_conditions(location)
-                    self.visualize_data(location, epw_data=epw_data, column_map=column_map)
-                except Exception as e:
-                    st.error(f"Error processing EPW file: {str(e)}. Ensure it has 8760 hourly records and correct format.")
-
-        # Navigation buttons
-        col1, col2 = st.columns(2)
-        with col1:
-            st.button("Back to Building Information", on_click=lambda: setattr(session_state, "page", "Building Information"))
-        with col2:
-            if self.locations:
-                st.button("Continue to Building Components", on_click=lambda: setattr(session_state, "page", "Building Components"))
-            else:
-                st.button("Continue to Building Components", disabled=True)
-
-    def display_design_conditions(self, location: ClimateLocation):
-        """Display a table of design conditions for calculations."""
-        st.subheader("Design Conditions for HVAC Calculations")
-        design_data = pd.DataFrame({
-            "Parameter": [
-                "Climate Zone",
-                "Heating Degree Days (base 18°C)",
-                "Cooling Degree Days (base 18°C)",
-                "Winter Design Temperature (99.6%)",
-                "Summer Design Dry-Bulb Temp (0.4%)",
-                "Summer Design Wet-Bulb Temp (0.4%)",
-                "Summer Daily Temperature Range"
-            ],
-            "Value": [
-                location.climate_zone,
-                f"{location.heating_degree_days} HDD",
-                f"{location.cooling_degree_days} CDD",
-                f"{location.winter_design_temp} °C",
-                f"{location.summer_design_temp_db} °C",
-                f"{location.summer_design_temp_wb} °C",
-                f"{location.summer_daily_range} °C"
-            ]
-        })
-        st.table(design_data)
-
-    @staticmethod
-    def assign_climate_zone(hdd: float, cdd: float, avg_humidity: float) -> str:
-        """Assign ASHRAE 169 climate zone based on HDD, CDD, and humidity."""
-        if cdd > 10000:
-            return "0A" if avg_humidity > 60 else "0B"
-        elif cdd > 5000:
-            return "1A" if avg_humidity > 60 else "1B"
-        elif cdd > 2500:
-            return "2A" if avg_humidity > 60 else "2B"
-        elif hdd < 2000 and cdd > 1000:
-            return "3A" if avg_humidity > 60 else "3B" if avg_humidity < 40 else "3C"
-        elif hdd < 3000:
-            return "4A" if avg_humidity > 60 else "4B" if avg_humidity < 40 else "4C"
-        elif hdd < 4000:
-            return "5A" if avg_humidity > 60 else "5B" if avg_humidity < 40 else "5C"
-        elif hdd < 5000:
-            return "6A" if avg_humidity > 60 else "6B"
-        elif hdd < 7000:
-            return "7"
-        else:
-            return "8"
-
-    def visualize_data(self, location: ClimateLocation, epw_data: Optional[pd.DataFrame] = None, column_map: Optional[Dict[str, int]] = None):
-        """Visualize monthly temperature and humidity data with min, max, and average."""
-        st.subheader("Monthly Climate Data Visualization")
-        
-        months = list(range(1, 13))
-        month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
-        temps_avg = [location.monthly_temps[m] for m in month_names]
-        humidity_avg = [location.monthly_humidity[m] for m in month_names]
-        
-        # If EPW data is provided, calculate min/max from raw data
-        if epw_data is not None and column_map is not None:
-            dry_bulb = epw_data[column_map["dry_bulb"]].values
-            humidity = epw_data[column_map["humidity"]].values
-            month_col = epw_data[1].values
-            
-            temps_min = []
-            temps_max = []
-            humidity_min = []
-            humidity_max = []
-            for i in range(1, 13):
-                month_mask = (month_col == i)
-                temps_min.append(round(np.min(dry_bulb[month_mask]), 1))
-                temps_max.append(round(np.max(dry_bulb[month_mask]), 1))
-                humidity_min.append(round(np.min(humidity[month_mask]), 1))
-                humidity_max.append(round(np.max(humidity[month_mask]), 1))
-        else:
-            # For manual input, only show averages (no min/max available)
-            temps_min = temps_avg
-            temps_max = temps_avg
-            humidity_min = humidity_avg
-            humidity_max = humidity_avg
-
-        # Temperature Plot
-        fig_temp = go.Figure()
-        fig_temp.add_trace(go.Scatter(
-            x=months,
-            y=temps_avg,
-            mode='lines+markers',
-            name='Avg Temperature (°C)',
-            line=dict(color='red'),
-            marker=dict(size=8)
-        ))
-        fig_temp.add_trace(go.Scatter(
-            x=months,
-            y=temps_max,
-            mode='lines',
-            name='Max Temperature (°C)',
-            line=dict(color='red', dash='dash'),
-            opacity=0.5
-        ))
-        fig_temp.add_trace(go.Scatter(
-            x=months,
-            y=temps_min,
-            mode='lines',
-            name='Min Temperature (°C)',
-            line=dict(color='red', dash='dash'),
-            opacity=0.5,
-            fill='tonexty',  # Fill area between min and max
-            fillcolor='rgba(255, 0, 0, 0.1)'
-        ))
-        fig_temp.update_layout(
-            title='Monthly Temperatures',
-            xaxis_title='Month',
-            yaxis_title='Temperature (°C)',
-            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names),
-            legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
-        )
-        st.plotly_chart(fig_temp, use_container_width=True)
-        
-        # Humidity Plot
-        fig_hum = go.Figure()
-        fig_hum.add_trace(go.Scatter(
-            x=months,
-            y=humidity_avg,
-            mode='lines+markers',
-            name='Avg Humidity (%)',
-            line=dict(color='blue'),
-            marker=dict(size=8)
-        ))
-        fig_hum.add_trace(go.Scatter(
-            x=months,
-            y=humidity_max,
-            mode='lines',
-            name='Max Humidity (%)',
-            line=dict(color='blue', dash='dash'),
-            opacity=0.5
-        ))
-        fig_hum.add_trace(go.Scatter(
-            x=months,
-            y=humidity_min,
-            mode='lines',
-            name='Min Humidity (%)',
-            line=dict(color='blue', dash='dash'),
-            opacity=0.5,
-            fill='tonexty',  # Fill area between min and max
-            fillcolor='rgba(0, 0, 255, 0.1)'
-        ))
-        fig_hum.update_layout(
-            title='Monthly Relative Humidity',
-            xaxis_title='Month',
-            yaxis_title='Relative Humidity (%)',
-            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names),
-            legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
-        )
-        st.plotly_chart(fig_hum, use_container_width=True)
-
-    def export_to_json(self, file_path: str) -> None:
-        """Export all climate data to a JSON file."""
-        data = {loc_id: loc.to_dict() for loc_id, loc in self.locations.items()}
-        with open(file_path, 'w') as f:
-            json.dump(data, f, indent=4)
-
-    @classmethod
-    def from_json(cls, file_path: str) -> 'ClimateData':
-        """Create a ClimateData instance from a JSON file."""
-        with open(file_path, 'r') as f:
-            data = json.load(f)
-        climate_data = cls()
-        climate_data.locations = {}
-        for loc_id, loc_dict in data.items():
-            climate_data.locations[loc_id] = ClimateLocation(**loc_dict)
-        climate_data.countries = sorted(list(set(loc.country for loc in climate_data.locations.values())))
-        climate_data.country_states = climate_data._group_locations_by_country_state()
-        return climate_data
-
-
-if __name__ == "__main__":
-    # Ensure session_state is initialized for standalone testing
-    if "building_info" not in st.session_state:
-        st.session_state.building_info = {"country": "Australia", "city": "Melbourne"}
-    if "page" not in st.session_state:
-        st.session_state.page = "Climate Data"
-    
-    climate_data = ClimateData()
+"""
+ASHRAE 169 climate data module for HVAC Load Calculator.
+This module provides access to climate data for various locations based on ASHRAE 169 standard.
+
+Author: Dr Majed Abuseif
+Date: March 2025
+Version: 1.0.0
+"""
+
+from typing import Dict, List, Any, Optional, Tuple
+import pandas as pd
+import numpy as np
+import os
+import json
+from dataclasses import dataclass
+import streamlit as st
+import plotly.graph_objects as go
+from io import StringIO
+
+# Define paths
+DATA_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+@dataclass
+class ClimateLocation:
+    """Class representing a climate location with ASHRAE 169 data."""
+    
+    id: str
+    country: str
+    state_province: str
+    city: str
+    latitude: float
+    longitude: float
+    elevation: float  # meters
+    climate_zone: str
+    heating_degree_days: float  # base 18°C
+    cooling_degree_days: float  # base 18°C
+    winter_design_temp: float  # 99.6% heating design temperature (°C)
+    summer_design_temp_db: float  # 0.4% cooling design dry-bulb temperature (°C)
+    summer_design_temp_wb: float  # 0.4% cooling design wet-bulb temperature (°C)
+    summer_daily_range: float  # Mean daily temperature range in summer (°C)
+    monthly_temps: Dict[str, float]  # Average monthly temperatures (°C)
+    monthly_humidity: Dict[str, float]  # Average monthly relative humidity (%)
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert the climate location to a dictionary."""
+        return {
+            "id": self.id,
+            "country": self.country,
+            "state_province": self.state_province,
+            "city": self.city,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "elevation": self.elevation,
+            "climate_zone": self.climate_zone,
+            "heating_degree_days": self.heating_degree_days,
+            "cooling_degree_days": self.cooling_degree_days,
+            "winter_design_temp": self.winter_design_temp,
+            "summer_design_temp_db": self.summer_design_temp_db,
+            "summer_design_temp_wb": self.summer_design_temp_wb,
+            "summer_daily_range": self.summer_daily_range,
+            "monthly_temps": self.monthly_temps,
+            "monthly_humidity": self.monthly_humidity
+        }
+
+
+class ClimateData:
+    """Class for managing ASHRAE 169 climate data."""
+    
+    def __init__(self):
+        """Initialize climate data."""
+        self.locations = {}
+        self.countries = []
+        self.country_states = {}
+    
+    def _group_locations_by_country_state(self) -> Dict[str, Dict[str, List[str]]]:
+        """Group locations by country and state/province."""
+        result = {}
+        for loc in self.locations.values():
+            if loc.country not in result:
+                result[loc.country] = {}
+            if loc.state_province not in result[loc.country]:
+                result[loc.country][loc.state_province] = []
+            result[loc.country][loc.state_province].append(loc.city)
+        for country in result:
+            for state in result[country]:
+                result[country][state] = sorted(result[country][state])
+        return result
+    
+    def add_location(self, location: ClimateLocation):
+        """Add a new location to the dictionary."""
+        self.locations[location.id] = location
+        self.countries = sorted(list(set(loc.country for loc in self.locations.values())))
+        self.country_states = self._group_locations_by_country_state()
+
+    def _infer_epw_columns(self, epw_data: pd.DataFrame) -> Dict[str, int]:
+        """Infer column indices for key weather parameters based on data ranges."""
+        column_map = {}
+        for col in epw_data.columns:
+            values = pd.to_numeric(epw_data[col], errors='coerce')
+            if values.isna().all():
+                continue  # Skip if all values are NaN
+            mean_val = np.nanmean(values)
+            min_val = np.nanmin(values)
+            max_val = np.nanmax(values)
+
+            # Dry Bulb Temperature (°C): -50 to 50°C
+            if -50 <= min_val <= max_val <= 50 and col not in column_map:
+                column_map["dry_bulb"] = col
+            # Wet Bulb Temperature (°C): -50 to 40°C
+            elif -50 <= min_val <= max_val <= 40 and col not in column_map:
+                column_map["wet_bulb"] = col
+            # Relative Humidity (%): 0 to 100%
+            elif 0 <= min_val <= max_val <= 100 and col not in column_map:
+                column_map["humidity"] = col
+            # Atmospheric Pressure (Pa): 80000 to 105000 Pa
+            elif 80000 <= min_val <= max_val <= 105000 and col not in column_map:
+                column_map["pressure"] = col
+
+        # Standard EPW column indices as fallback
+        standard_map = {
+            "dry_bulb": 6,
+            "wet_bulb": 8,
+            "humidity": 21,
+            "pressure": 9
+        }
+
+        for key in standard_map:
+            if key not in column_map:
+                st.warning(f"Could not infer {key} column. Using standard EPW index {standard_map[key]}.")
+                column_map[key] = standard_map[key]
+            elif column_map[key] != standard_map[key]:
+                st.warning(f"Inferred {key} column ({column_map[key]}) differs from standard EPW ({standard_map[key]}). Proceeding with inferred column.")
+
+        return column_map
+
+    def display_climate_input(self, session_state: Dict[str, Any]):
+        """Display form for manual input or EPW upload in Streamlit."""
+        st.title("Climate Data")
+        
+        if not session_state.building_info.get("country") or not session_state.building_info.get("city"):
+            st.warning("Please enter country and city in Building Information first.")
+            st.button("Go to Building Information", on_click=lambda: setattr(session_state, "page", "Building Information"))
+            return
+        
+        st.subheader(f"Location: {session_state.building_info['country']}, {session_state.building_info['city']}")
+        tab1, tab2 = st.tabs(["Manual Input", "Upload EPW File"])
+        
+        # Manual Input Tab
+        with tab1:
+            with st.form("manual_climate_form"):
+                col1, col2 = st.columns(2)
+                with col1:
+                    id_input = st.text_input("Location ID", value=f"{session_state.building_info['country'][:2].upper()}-{session_state.building_info['city'][:3].upper()}")
+                    state_province = st.text_input("State/Province", value="N/A")
+                    latitude = st.number_input("Latitude", min_value=-90.0, max_value=90.0, value=0.0, step=0.1)
+                    longitude = st.number_input("Longitude", min_value=-180.0, max_value=180.0, value=0.0, step=0.1)
+                    elevation = st.number_input("Elevation (m)", min_value=0.0, value=0.0, step=10.0)
+                    climate_zone = st.selectbox("Climate Zone", ["0A", "0B", "1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"])
+                
+                with col2:
+                    hdd = st.number_input("Heating Degree Days (base 18°C)", min_value=0.0, value=0.0, step=100.0)
+                    cdd = st.number_input("Cooling Degree Days (base 18°C)", min_value=0.0, value=0.0, step=100.0)
+                    winter_design_temp = st.number_input("Winter Design Temp (99.6%) (°C)", min_value=-50.0, max_value=20.0, value=0.0, step=0.5)
+                    summer_design_temp_db = st.number_input("Summer Design Temp DB (0.4%) (°C)", min_value=0.0, max_value=50.0, value=35.0, step=0.5)
+                    summer_design_temp_wb = st.number_input("Summer Design Temp WB (0.4%) (°C)", min_value=0.0, max_value=40.0, value=25.0, step=0.5)
+                    summer_daily_range = st.number_input("Summer Daily Range (°C)", min_value=0.0, value=5.0, step=0.5)
+                
+                st.subheader("Monthly Data")
+                monthly_temps = {}
+                monthly_humidity = {}
+                month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+                col1, col2 = st.columns(2)
+                with col1:
+                    for month in month_names[:6]:
+                        monthly_temps[month] = st.number_input(f"{month} Temp (°C)", min_value=-50.0, max_value=50.0, value=20.0, step=0.5, key=f"temp_{month}")
+                with col2:
+                    for month in month_names[6:]:
+                        monthly_temps[month] = st.number_input(f"{month} Temp (°C)", min_value=-50.0, max_value=50.0, value=20.0, step=0.5, key=f"temp_{month}")
+                col1, col2 = st.columns(2)
+                with col1:
+                    for month in month_names[:6]:
+                        monthly_humidity[month] = st.number_input(f"{month} Humidity (%)", min_value=0.0, max_value=100.0, value=50.0, step=5.0, key=f"hum_{month}")
+                with col2:
+                    for month in month_names[6:]:
+                        monthly_humidity[month] = st.number_input(f"{month} Humidity (%)", min_value=0.0, max_value=100.0, value=50.0, step=5.0, key=f"hum_{month}")
+                
+                if st.form_submit_button("Save Climate Data"):
+                    location = ClimateLocation(
+                        id=id_input,
+                        country=session_state.building_info["country"],
+                        state_province=state_province,
+                        city=session_state.building_info["city"],
+                        latitude=latitude,
+                        longitude=longitude,
+                        elevation=elevation,
+                        climate_zone=climate_zone,
+                        heating_degree_days=hdd,
+                        cooling_degree_days=cdd,
+                        winter_design_temp=winter_design_temp,
+                        summer_design_temp_db=summer_design_temp_db,
+                        summer_design_temp_wb=summer_design_temp_wb,
+                        summer_daily_range=summer_daily_range,
+                        monthly_temps=monthly_temps,
+                        monthly_humidity=monthly_humidity
+                    )
+                    self.add_location(location)
+                    st.success("Climate data saved manually!")
+                    self.display_design_conditions(location)
+                    self.visualize_data(location, epw_data=None)
+
+        # EPW Upload Tab
+        with tab2:
+            uploaded_file = st.file_uploader("Upload EPW File", type=["epw"])
+            if uploaded_file:
+                try:
+                    epw_content = uploaded_file.read().decode("utf-8")
+                    epw_lines = epw_content.splitlines()
+                    header = next(line for line in epw_lines if line.startswith("LOCATION"))
+                    header_parts = header.split(",")
+                    latitude = float(header_parts[6])
+                    longitude = float(header_parts[7])
+                    elevation = float(header_parts[8])
+                    
+                    # Load EPW data as strings first, then convert
+                    epw_data = pd.read_csv(StringIO("\n".join(epw_lines[8:])), header=None, dtype=str)
+                    if len(epw_data) != 8760:
+                        raise ValueError(f"EPW file has {len(epw_data)} records, expected 8760.")
+                    
+                    # Convert all columns to numeric, coercing errors to NaN
+                    for col in epw_data.columns:
+                        epw_data[col] = pd.to_numeric(epw_data[col], errors='coerce')
+                    
+                    # Debugging: Show NaN counts
+                    nan_counts = epw_data.isna().sum()
+                    if nan_counts.max() > 0:
+                        st.warning(f"NaN values detected in columns: {nan_counts[nan_counts > 0].to_dict()}")
+
+                    # Infer column indices
+                    column_map = self._infer_epw_columns(epw_data)
+                    
+                    # Extract and validate data
+                    months = epw_data[1].values.astype(float)
+                    dry_bulb = epw_data[column_map["dry_bulb"]].values.astype(float)
+                    wet_bulb = epw_data[column_map["wet_bulb"]].values.astype(float)
+                    humidity = epw_data[column_map["humidity"]].values.astype(float)
+                    
+                    if np.all(np.isnan(dry_bulb)) or np.all(np.isnan(humidity)):
+                        raise ValueError("Critical columns (dry bulb or humidity) are entirely NaN.")
+
+                    # Calculate daily averages for HDD/CDD
+                    daily_temps = np.nanmean(dry_bulb.reshape(-1, 24), axis=1)
+                    hdd = round(sum(max(18 - temp, 0) for temp in daily_temps if not np.isnan(temp)))
+                    cdd = round(sum(max(temp - 18, 0) for temp in daily_temps if not np.isnan(temp)))
+                    
+                    # Design conditions with NaN handling
+                    winter_design_temp = round(np.nanpercentile(dry_bulb, 0.4), 1)
+                    summer_design_temp_db = round(np.nanpercentile(dry_bulb, 99.6), 1)
+                    summer_idx = np.argmax(dry_bulb >= summer_design_temp_db)
+                    summer_design_temp_wb = round(wet_bulb[summer_idx], 1) if not np.isnan(wet_bulb[summer_idx]) else 25.0
+                    summer_mask = (months >= 6) & (months <= 8)
+                    summer_temps = dry_bulb[summer_mask].reshape(-1, 24)
+                    summer_daily_range = round(np.nanmean(summer_temps.max(axis=1) - summer_temps.min(axis=1)), 1)
+                    
+                    # Monthly averages
+                    monthly_temps = {}
+                    monthly_humidity = {}
+                    month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+                    for i in range(1, 13):
+                        month_mask = (months == i)
+                        monthly_temps[month_names[i-1]] = round(np.nanmean(dry_bulb[month_mask]), 1)
+                        monthly_humidity[month_names[i-1]] = round(np.nanmean(humidity[month_mask]), 1)
+                    
+                    avg_humidity = np.nanmean(humidity)
+                    climate_zone = self.assign_climate_zone(hdd, cdd, avg_humidity)
+                    
+                    location = ClimateLocation(
+                        id=f"{session_state.building_info['country'][:2].upper()}-{session_state.building_info['city'][:3].upper()}",
+                        country=session_state.building_info["country"],
+                        state_province="N/A",
+                        city=session_state.building_info["city"],
+                        latitude=latitude,
+                        longitude=longitude,
+                        elevation=elevation,
+                        climate_zone=climate_zone,
+                        heating_degree_days=hdd,
+                        cooling_degree_days=cdd,
+                        winter_design_temp=winter_design_temp,
+                        summer_design_temp_db=summer_design_temp_db,
+                        summer_design_temp_wb=summer_design_temp_wb,
+                        summer_daily_range=summer_daily_range,
+                        monthly_temps=monthly_temps,
+                        monthly_humidity=monthly_humidity
+                    )
+                    self.add_location(location)
+                    st.success("Climate data extracted from EPW file!")
+                    self.display_design_conditions(location)
+                    self.visualize_data(location, epw_data=epw_data, column_map=column_map)
+                except Exception as e:
+                    st.error(f"Error processing EPW file: {str(e)}. Ensure it has 8760 hourly records and correct format.")
+
+        # Navigation buttons
+        col1, col2 = st.columns(2)
+        with col1:
+            st.button("Back to Building Information", on_click=lambda: setattr(session_state, "page", "Building Information"))
+        with col2:
+            if self.locations:
+                st.button("Continue to Building Components", on_click=lambda: setattr(session_state, "page", "Building Components"))
+            else:
+                st.button("Continue to Building Components", disabled=True)
+
+    def display_design_conditions(self, location: ClimateLocation):
+        """Display a table of design conditions for calculations."""
+        st.subheader("Design Conditions for HVAC Calculations")
+        design_data = pd.DataFrame({
+            "Parameter": [
+                "Climate Zone",
+                "Heating Degree Days (base 18°C)",
+                "Cooling Degree Days (base 18°C)",
+                "Winter Design Temperature (99.6%)",
+                "Summer Design Dry-Bulb Temp (0.4%)",
+                "Summer Design Wet-Bulb Temp (0.4%)",
+                "Summer Daily Temperature Range"
+            ],
+            "Value": [
+                location.climate_zone,
+                f"{location.heating_degree_days} HDD",
+                f"{location.cooling_degree_days} CDD",
+                f"{location.winter_design_temp} °C",
+                f"{location.summer_design_temp_db} °C",
+                f"{location.summer_design_temp_wb} °C",
+                f"{location.summer_daily_range} °C"
+            ]
+        })
+        st.table(design_data)
+
+    @staticmethod
+    def assign_climate_zone(hdd: float, cdd: float, avg_humidity: float) -> str:
+        """Assign ASHRAE 169 climate zone based on HDD, CDD, and humidity."""
+        if cdd > 10000:
+            return "0A" if avg_humidity > 60 else "0B"
+        elif cdd > 5000:
+            return "1A" if avg_humidity > 60 else "1B"
+        elif cdd > 2500:
+            return "2A" if avg_humidity > 60 else "2B"
+        elif hdd < 2000 and cdd > 1000:
+            return "3A" if avg_humidity > 60 else "3B" if avg_humidity < 40 else "3C"
+        elif hdd < 3000:
+            return "4A" if avg_humidity > 60 else "4B" if avg_humidity < 40 else "4C"
+        elif hdd < 4000:
+            return "5A" if avg_humidity > 60 else "5B" if avg_humidity < 40 else "5C"
+        elif hdd < 5000:
+            return "6A" if avg_humidity > 60 else "6B"
+        elif hdd < 7000:
+            return "7"
+        else:
+            return "8"
+
+    def visualize_data(self, location: ClimateLocation, epw_data: Optional[pd.DataFrame] = None, column_map: Optional[Dict[str, int]] = None):
+        """Visualize monthly temperature and humidity data with min, max, and average."""
+        st.subheader("Monthly Climate Data Visualization")
+        
+        months = list(range(1, 13))
+        month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        temps_avg = [location.monthly_temps[m] for m in month_names]
+        humidity_avg = [location.monthly_humidity[m] for m in month_names]
+        
+        if epw_data is not None and column_map is not None:
+            dry_bulb = epw_data[column_map["dry_bulb"]].values.astype(float)
+            humidity = epw_data[column_map["humidity"]].values.astype(float)
+            month_col = epw_data[1].values.astype(float)
+            
+            temps_min = []
+            temps_max = []
+            humidity_min = []
+            humidity_max = []
+            for i in range(1, 13):
+                month_mask = (month_col == i)
+                temps_min.append(round(np.nanmin(dry_bulb[month_mask]), 1))
+                temps_max.append(round(np.nanmax(dry_bulb[month_mask]), 1))
+                humidity_min.append(round(np.nanmin(humidity[month_mask]), 1))
+                humidity_max.append(round(np.nanmax(humidity[month_mask]), 1))
+        else:
+            temps_min = temps_avg
+            temps_max = temps_avg
+            humidity_min = humidity_avg
+            humidity_max = humidity_avg
+
+        # Temperature Plot
+        fig_temp = go.Figure()
+        fig_temp.add_trace(go.Scatter(
+            x=months,
+            y=temps_avg,
+            mode='lines+markers',
+            name='Avg Temperature (°C)',
+            line=dict(color='red'),
+            marker=dict(size=8)
+        ))
+        fig_temp.add_trace(go.Scatter(
+            x=months,
+            y=temps_max,
+            mode='lines',
+            name='Max Temperature (°C)',
+            line=dict(color='red', dash='dash'),
+            opacity=0.5
+        ))
+        fig_temp.add_trace(go.Scatter(
+            x=months,
+            y=temps_min,
+            mode='lines',
+            name='Min Temperature (°C)',
+            line=dict(color='red', dash='dash'),
+            opacity=0.5,
+            fill='tonexty',
+            fillcolor='rgba(255, 0, 0, 0.1)'
+        ))
+        fig_temp.update_layout(
+            title='Monthly Temperatures',
+            xaxis_title='Month',
+            yaxis_title='Temperature (°C)',
+            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names),
+            legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
+        )
+        st.plotly_chart(fig_temp, use_container_width=True)
+        
+        # Humidity Plot
+        fig_hum = go.Figure()
+        fig_hum.add_trace(go.Scatter(
+            x=months,
+            y=humidity_avg,
+            mode='lines+markers',
+            name='Avg Humidity (%)',
+            line=dict(color='blue'),
+            marker=dict(size=8)
+        ))
+        fig_hum.add_trace(go.Scatter(
+            x=months,
+            y=humidity_max,
+            mode='lines',
+            name='Max Humidity (%)',
+            line=dict(color='blue', dash='dash'),
+            opacity=0.5
+        ))
+        fig_hum.add_trace(go.Scatter(
+            x=months,
+            y=humidity_min,
+            mode='lines',
+            name='Min Humidity (%)',
+            line=dict(color='blue', dash='dash'),
+            opacity=0.5,
+            fill='tonexty',
+            fillcolor='rgba(0, 0, 255, 0.1)'
+        ))
+        fig_hum.update_layout(
+            title='Monthly Relative Humidity',
+            xaxis_title='Month',
+            yaxis_title='Relative Humidity (%)',
+            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names),
+            legend=dict(yanchor="top", y=0.99, xanchor="left", x=0.01)
+        )
+        st.plotly_chart(fig_hum, use_container_width=True)
+
+    def export_to_json(self, file_path: str) -> None:
+        """Export all climate data to a JSON file."""
+        data = {loc_id: loc.to_dict() for loc_id, loc in self.locations.items()}
+        with open(file_path, 'w') as f:
+            json.dump(data, f, indent=4)
+
+    @classmethod
+    def from_json(cls, file_path: str) -> 'ClimateData':
+        """Create a ClimateData instance from a JSON file."""
+        with open(file_path, 'r') as f:
+            data = json.load(f)
+        climate_data = cls()
+        climate_data.locations = {}
+        for loc_id, loc_dict in data.items():
+            climate_data.locations[loc_id] = ClimateLocation(**loc_dict)
+        climate_data.countries = sorted(list(set(loc.country for loc in climate_data.locations.values())))
+        climate_data.country_states = climate_data._group_locations_by_country_state()
+        return climate_data
+
+
+if __name__ == "__main__":
+    if "building_info" not in st.session_state:
+        st.session_state.building_info = {"country": "Australia", "city": "Melbourne"}
+    if "page" not in st.session_state:
+        st.session_state.page = "Climate Data"
+    
+    climate_data = ClimateData()
     climate_data.display_climate_input(st.session_state)