Update data/climate_data.py

data/climate_data.py

@@ -1,10 +1,6 @@
 """
 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
@@ -13,9 +9,6 @@ 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__))
@@ -35,10 +28,14 @@ class ClimateLocation:
     climate_zone: str
     heating_degree_days: float  # base 18°C
     cooling_degree_days: float  # base 18°C
+    
+    # Design conditions
     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 data
     monthly_temps: Dict[str, float]  # Average monthly temperatures (°C)
     monthly_humidity: Dict[str, float]  # Average monthly relative humidity (%)
     
@@ -69,303 +66,409 @@ class ClimateData:
     
     def __init__(self):
         """Initialize climate data."""
-        self.locations = {}
-        self.countries = []
-        self.country_states = {}
+        self.locations = self._load_climate_locations()
+        self.countries = sorted(list(set(loc.country for loc in self.locations.values())))
+        self.country_states = self._group_locations_by_country_state()
+    
+    def _load_climate_locations(self) -> Dict[str, ClimateLocation]:
+        """
+        Load climate location data.
+        
+        Returns:
+            Dictionary of climate locations indexed by ID
+        """
+        # This would typically load from a JSON or CSV file with ASHRAE 169 data
+        # For now, we'll define some sample locations inline
+        
+        # Sample monthly data (for all locations in this example)
+        months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+        
+        # New York monthly temperatures (°C)
+        ny_temps = {
+            "Jan": 0.5, "Feb": 2.1, "Mar": 6.3, "Apr": 12.5, "May": 18.2, 
+            "Jun": 23.1, "Jul": 25.8, "Aug": 24.9, "Sep": 20.7, "Oct": 14.3, 
+            "Nov": 8.2, "Dec": 2.4
+        }
+        
+        # New York monthly humidity (%)
+        ny_humidity = {
+            "Jan": 65, "Feb": 62, "Mar": 58, "Apr": 55, "May": 60, 
+            "Jun": 65, "Jul": 68, "Aug": 70, "Sep": 68, "Oct": 63, 
+            "Nov": 67, "Dec": 68
+        }
+        
+        # Los Angeles monthly temperatures (°C)
+        la_temps = {
+            "Jan": 14.6, "Feb": 15.1, "Mar": 15.8, "Apr": 17.1, "May": 18.3, 
+            "Jun": 20.1, "Jul": 22.3, "Aug": 22.9, "Sep": 22.1, "Oct": 20.3, 
+            "Nov": 17.2, "Dec": 14.9
+        }
+        
+        # Los Angeles monthly humidity (%)
+        la_humidity = {
+            "Jan": 63, "Feb": 67, "Mar": 70, "Apr": 71, "May": 74, 
+            "Jun": 75, "Jul": 76, "Aug": 76, "Sep": 74, "Oct": 70, 
+            "Nov": 65, "Dec": 63
+        }
+        
+        # Chicago monthly temperatures (°C)
+        chi_temps = {
+            "Jan": -3.5, "Feb": -1.2, "Mar": 4.1, "Apr": 10.3, "May": 16.5, 
+            "Jun": 22.1, "Jul": 24.8, "Aug": 23.9, "Sep": 19.7, "Oct": 12.8, 
+            "Nov": 5.2, "Dec": -1.4
+        }
+        
+        # Chicago monthly humidity (%)
+        chi_humidity = {
+            "Jan": 72, "Feb": 70, "Mar": 65, "Apr": 60, "May": 64, 
+            "Jun": 67, "Jul": 70, "Aug": 73, "Sep": 71, "Oct": 68, 
+            "Nov": 72, "Dec": 75
+        }
+        
+        # London monthly temperatures (°C)
+        lon_temps = {
+            "Jan": 5.2, "Feb": 5.5, "Mar": 7.4, "Apr": 9.9, "May": 13.3, 
+            "Jun": 16.7, "Jul": 18.7, "Aug": 18.3, "Sep": 15.9, "Oct": 12.2, 
+            "Nov": 8.3, "Dec": 5.9
+        }
+        
+        # London monthly humidity (%)
+        lon_humidity = {
+            "Jan": 84, "Feb": 80, "Mar": 76, "Apr": 72, "May": 70, 
+            "Jun": 70, "Jul": 71, "Aug": 72, "Sep": 75, "Oct": 80, 
+            "Nov": 84, "Dec": 86
+        }
+        
+        # Sydney monthly temperatures (°C)
+        syd_temps = {
+            "Jan": 23.5, "Feb": 23.4, "Mar": 22.1, "Apr": 19.5, "May": 16.5, 
+            "Jun": 14.1, "Jul": 13.4, "Aug": 14.5, "Sep": 16.6, "Oct": 18.8, 
+            "Nov": 20.6, "Dec": 22.6
+        }
+        
+        # Sydney monthly humidity (%)
+        syd_humidity = {
+            "Jan": 65, "Feb": 68, "Mar": 68, "Apr": 67, "May": 70, 
+            "Jun": 70, "Jul": 68, "Aug": 63, "Sep": 60, "Oct": 60, 
+            "Nov": 62, "Dec": 63
+        }
+        
+        # Create sample locations
+        locations = {
+            "US-NY-NYC": ClimateLocation(
+                id="US-NY-NYC",
+                country="United States",
+                state_province="New York",
+                city="New York",
+                latitude=40.7128,
+                longitude=-74.0060,
+                elevation=10.0,
+                climate_zone="4A",
+                heating_degree_days=2600,
+                cooling_degree_days=1200,
+                winter_design_temp=-8.3,
+                summer_design_temp_db=32.8,
+                summer_design_temp_wb=25.6,
+                summer_daily_range=8.3,
+                monthly_temps=ny_temps,
+                monthly_humidity=ny_humidity
+            ),
+            "US-CA-LAX": ClimateLocation(
+                id="US-CA-LAX",
+                country="United States",
+                state_province="California",
+                city="Los Angeles",
+                latitude=34.0522,
+                longitude=-118.2437,
+                elevation=93.0,
+                climate_zone="3B",
+                heating_degree_days=800,
+                cooling_degree_days=1200,
+                winter_design_temp=8.3,
+                summer_design_temp_db=32.2,
+                summer_design_temp_wb=23.3,
+                summer_daily_range=6.7,
+                monthly_temps=la_temps,
+                monthly_humidity=la_humidity
+            ),
+            "US-IL-CHI": ClimateLocation(
+                id="US-IL-CHI",
+                country="United States",
+                state_province="Illinois",
+                city="Chicago",
+                latitude=41.8781,
+                longitude=-87.6298,
+                elevation=179.0,
+                climate_zone="5A",
+                heating_degree_days=3500,
+                cooling_degree_days=1000,
+                winter_design_temp=-16.7,
+                summer_design_temp_db=33.3,
+                summer_design_temp_wb=25.6,
+                summer_daily_range=8.9,
+                monthly_temps=chi_temps,
+                monthly_humidity=chi_humidity
+            ),
+            "UK-LDN": ClimateLocation(
+                id="UK-LDN",
+                country="United Kingdom",
+                state_province="England",
+                city="London",
+                latitude=51.5074,
+                longitude=-0.1278,
+                elevation=35.0,
+                climate_zone="4A",
+                heating_degree_days=2500,
+                cooling_degree_days=200,
+                winter_design_temp=-3.9,
+                summer_design_temp_db=28.3,
+                summer_design_temp_wb=20.0,
+                summer_daily_range=10.0,
+                monthly_temps=lon_temps,
+                monthly_humidity=lon_humidity
+            ),
+            "AU-NSW-SYD": ClimateLocation(
+                id="AU-NSW-SYD",
+                country="Australia",
+                state_province="New South Wales",
+                city="Sydney",
+                latitude=-33.8688,
+                longitude=151.2093,
+                elevation=3.0,
+                climate_zone="3C",
+                heating_degree_days=600,
+                cooling_degree_days=900,
+                winter_design_temp=7.2,
+                summer_design_temp_db=31.1,
+                summer_design_temp_wb=24.4,
+                summer_daily_range=7.8,
+                monthly_temps=syd_temps,
+                monthly_humidity=syd_humidity
+            )
+        }
+        
+        return locations
     
     def _group_locations_by_country_state(self) -> Dict[str, Dict[str, List[str]]]:
-        """Group locations by country and state/province."""
+        """
+        Group locations by country and state/province.
+        
+        Returns:
+            Nested dictionary of countries, states, and cities
+        """
         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)
+        
+        # Sort states and cities
         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 display_climate_input(self, session_state: Dict[str, Any]):
-        """Display form for manual input or EPW upload in Streamlit."""
-        st.title("Climate Data")
+    def get_location(self, location_id: str) -> Optional[ClimateLocation]:
+        """
+        Get climate location by ID.
         
-        # Check if building info has country and city
-        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']}")
-        
-        # Tabs for manual input or EPW upload
-        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 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.")
-                    months = epw_data[1].values  # Month column
-                    dry_bulb = epw_data[6].values  # Dry-bulb temperature
-                    wet_bulb = epw_data[8].values  # Wet-bulb temperature
-                    humidity = epw_data[9].values  # Relative humidity
-                    
-                    # 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 (ASHRAE standards)
-                    winter_design_temp = round(np.percentile(dry_bulb, 0.4), 1)  # 99.6% heating design
-                    summer_design_temp_db = round(np.percentile(dry_bulb, 99.6), 1)  # 0.4% cooling design DB
-                    summer_idx = np.argmax(dry_bulb >= summer_design_temp_db)
-                    summer_design_temp_wb = round(wet_bulb[summer_idx], 1)  # Corresponding WB
-                    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
-                    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)
-                    
-                    # Assign climate zone
-                    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)
-                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"
-
-    @staticmethod
-    def visualize_data(location: ClimateLocation):
-        """Visualize monthly temperature and humidity data."""
-        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 = [location.monthly_temps[m] for m in month_names]
-        humidity = [location.monthly_humidity[m] for m in month_names]
-        
-        # Temperature Plot
-        fig_temp = go.Figure()
-        fig_temp.add_trace(go.Scatter(
-            x=months,
-            y=temps,
-            mode='lines+markers',
-            name='Temperature (°C)',
-            line=dict(color='red')
-        ))
-        fig_temp.update_layout(
-            title='Monthly Temperatures',
-            xaxis_title='Month',
-            yaxis_title='Temperature (°C)',
-            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names)
-        )
-        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,
-            mode='lines+markers',
-            name='Humidity (%)',
-            line=dict(color='blue')
-        ))
-        fig_hum.update_layout(
-            title='Monthly Relative Humidity',
-            xaxis_title='Month',
-            yaxis_title='Relative Humidity (%)',
-            xaxis=dict(tickmode='array', tickvals=months, ticktext=month_names)
-            yaxis=dict(range=[0, 100]),  # Set y-axis range from 0 to 100
-        )
-        st.plotly_chart(fig_hum, use_container_width=True)
-
+        Args:
+            location_id: Location identifier
+            
+        Returns:
+            ClimateLocation object or None if not found
+        """
+        return self.locations.get(location_id)
+    
+    def find_location(self, country: str, state_province: str = None, city: str = None) -> Optional[ClimateLocation]:
+        """
+        Find a climate location by country, state/province, and city.
+        
+        Args:
+            country: Country name
+            state_province: State or province name (optional)
+            city: City name (optional)
+            
+        Returns:
+            ClimateLocation object or None if not found
+        """
+        for loc in self.locations.values():
+            if loc.country == country:
+                if state_province is None or loc.state_province == state_province:
+                    if city is None or loc.city == city:
+                        return loc
+        return None
+    
+    def find_locations_by_climate_zone(self, climate_zone: str) -> List[ClimateLocation]:
+        """
+        Find climate locations by climate zone.
+        
+        Args:
+            climate_zone: ASHRAE climate zone
+            
+        Returns:
+            List of ClimateLocation objects
+        """
+        return [loc for loc in self.locations.values() if loc.climate_zone == climate_zone]
+    
+    def get_states_for_country(self, country: str) -> List[str]:
+        """
+        Get states/provinces for a country.
+        
+        Args:
+            country: Country name
+            
+        Returns:
+            List of state/province names
+        """
+        if country in self.country_states:
+            return sorted(self.country_states[country].keys())
+        return []
+    
+    def get_cities_for_state(self, country: str, state_province: str) -> List[str]:
+        """
+        Get cities for a state/province.
+        
+        Args:
+            country: Country name
+            state_province: State or province name
+            
+        Returns:
+            List of city names
+        """
+        if country in self.country_states and state_province in self.country_states[country]:
+            return self.country_states[country][state_province]
+        return []
+    
+    def get_location_id(self, country: str, state_province: str, city: str) -> Optional[str]:
+        """
+        Get location ID for a city.
+        
+        Args:
+            country: Country name
+            state_province: State or province name
+            city: City name
+            
+        Returns:
+            Location ID or None if not found
+        """
+        for loc_id, loc in self.locations.items():
+            if (loc.country == country and 
+                loc.state_province == state_province and 
+                loc.city == city):
+                return loc_id
+        return None
+    
     def export_to_json(self, file_path: str) -> None:
-        """Export all climate data to a JSON file."""
+        """
+        Export all climate data to a JSON file.
+        
+        Args:
+            file_path: Path to the output 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."""
+        """
+        Create a ClimateData instance from a JSON file.
+        
+        Args:
+            file_path: Path to the input JSON file
+            
+        Returns:
+            A new ClimateData instance
+        """
         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.locations[loc_id] = ClimateLocation(
+                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"],
+                climate_zone=loc_dict["climate_zone"],
+                heating_degree_days=loc_dict["heating_degree_days"],
+                cooling_degree_days=loc_dict["cooling_degree_days"],
+                winter_design_temp=loc_dict["winter_design_temp"],
+                summer_design_temp_db=loc_dict["summer_design_temp_db"],
+                summer_design_temp_wb=loc_dict["summer_design_temp_wb"],
+                summer_daily_range=loc_dict["summer_daily_range"],
+                monthly_temps=loc_dict["monthly_temps"],
+                monthly_humidity=loc_dict["monthly_humidity"]
+            )
+        
         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
+    
+    def display_climate_input(self, session_state):
+        """Display climate data input form in Streamlit and store selection in session state."""
+        import streamlit as st
+        
+        st.title("Climate Data")
+        st.write("Select a location to load its ASHRAE 169 climate data.")
+        
+        # Dropdown for country selection
+        country = st.selectbox("Country", self.countries, key="climate_country")
+        
+        # Dropdown for state/province selection
+        states = self.get_states_for_country(country)
+        state = st.selectbox("State/Province", states, key="climate_state") if states else None
+        
+        # Dropdown for city selection
+        cities = self.get_cities_for_state(country, state) if state else []
+        city = st.selectbox("City", cities, key="climate_city") if cities else None
+        
+        # Button to confirm selection
+        if st.button("Load Climate Data") and country and state and city:
+            location_id = self.get_location_id(country, state, city)
+            if location_id:
+                location = self.get_location(location_id)
+                if location:
+                    # Store the selected location in session state
+                    session_state["climate_data"] = location.to_dict()
+                    st.success(f"Loaded climate data for {city}, {state}, {country}")
+                    
+                    # Display key climate data
+                    st.subheader("Selected Location Climate Data")
+                    st.write(f"Climate Zone: {location.climate_zone}")
+                    st.write(f"Winter Design Temperature: {location.winter_design_temp}°C")
+                    st.write(f"Summer Design Dry-Bulb Temperature: {location.summer_design_temp_db}°C")
+                    st.write(f"Summer Design Wet-Bulb Temperature: {location.summer_design_temp_wb}°C")
+                    st.write(f"Heating Degree Days: {location.heating_degree_days}")
+                    st.write(f"Cooling Degree Days: {location.cooling_degree_days}")
+                else:
+                    st.error("Location data not found.")
+            else:
+                st.error("Invalid location selection.")
+        
+        # Display existing selection if available
+        if "climate_data" in session_state and session_state["climate_data"]:
+            st.subheader("Current Selection")
+            st.json(session_state["climate_data"])
+
 
+# Create a singleton instance
+climate_data = ClimateData()
 
+# Export climate data to JSON if needed
 if __name__ == "__main__":
-    climate_data = ClimateData()
-    climate_data.display_climate_input(st.session_state)
+    climate_data.export_to_json(os.path.join(DATA_DIR, "climate_data.json"))