Update data/climate_data.py

data/climate_data.py

@@ -1,6 +1,10 @@
 """
 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
@@ -9,6 +13,9 @@ 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__))
@@ -28,14 +35,10 @@ 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 (%)
     
@@ -66,409 +69,302 @@ class ClimateData:
     
     def __init__(self):
         """Initialize climate data."""
-        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
+        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.
-        
-        Returns:
-            Nested dictionary of countries, states, and cities
-        """
+        """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)
-        
-        # Sort states and cities
         for country in result:
             for state in result[country]:
                 result[country][state] = sorted(result[country][state])
-        
         return result
     
-    def get_location(self, location_id: str) -> Optional[ClimateLocation]:
-        """
-        Get climate location by ID.
-        
-        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.
+    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")
         
-        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
-    
+        # 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)
+        )
+        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.
-        
-        Args:
-            file_path: Path to the output JSON file
-        """
+        """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.
-        
-        Args:
-            file_path: Path to the input JSON file
-            
-        Returns:
-            A new ClimateData instance
-        """
+        """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(
-                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.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
-    
-    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.export_to_json(os.path.join(DATA_DIR, "climate_data.json"))
+    climate_data = ClimateData()
+    climate_data.display_climate_input(st.session_state)