Update air_quality_map.py

air_quality_map.py

@@ -6,6 +6,8 @@ from folium.plugins import MarkerCluster
 import tempfile
 import os
 import json
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 
 # Get API credentials from environment variables
 EPA_AQS_API_BASE_URL = "https://aqs.epa.gov/data/api"
@@ -14,7 +16,6 @@ API_KEY = os.environ.get("EPA_AQS_API_KEY", "")  # Get from environment variable
 
 class AirQualityApp:
     def __init__(self):
-        # [Keep all your existing initialization code the same]
         self.states = {
             "AL": "Alabama", "AK": "Alaska", "AZ": "Arizona", "AR": "Arkansas", 
             "CA": "California", "CO": "Colorado", "CT": "Connecticut", "DE": "Delaware", 
@@ -67,45 +68,67 @@ class AirQualityApp:
             "Very Unhealthy": "#99004c",  # Purple
             "Hazardous": "#7e0023"  # Maroon
         }
+
+        # Cache for storing monitored data
+        self.all_monitors_cache = {}
+        self.all_aqi_data_cache = {}
         
-        # Sample county data for demo
-        self.mock_counties = {
-            "CA": [
-                {"code": "037", "value": "Los Angeles"},
-                {"code": "067", "value": "Sacramento"},
-                {"code": "073", "value": "San Diego"},
-                {"code": "075", "value": "San Francisco"}
-            ],
-            "NY": [
-                {"code": "061", "value": "New York"},
-                {"code": "047", "value": "Kings (Brooklyn)"},
-                {"code": "081", "value": "Queens"},
-                {"code": "005", "value": "Bronx"}
-            ],
-            "TX": [
-                {"code": "201", "value": "Harris (Houston)"},
-                {"code": "113", "value": "Dallas"},
-                {"code": "029", "value": "Bexar (San Antonio)"},
-                {"code": "453", "value": "Travis (Austin)"}
-            ]
-        }
+        # Load data on initialization
+        print("Initializing and loading all monitors data...")
+        self.load_all_monitors()
+        print("Loading AQI data...")
+        self.load_all_aqi_data()
+        print("Initialization complete.")
+    
+    def load_all_monitors(self):
+        """Load monitors data for all states"""
+        # If we don't have API credentials, use mock data
+        if not EMAIL or not API_KEY:
+            for state_code in self.states.keys():
+                self.all_monitors_cache[state_code] = self.mock_get_monitors(state_code)
+            return
         
-        # Sample parameters for demo
-        self.mock_parameters = [
-            {"code": "88101", "value_represented": "PM2.5 - Local Conditions"},
-            {"code": "44201", "value_represented": "Ozone"},
-            {"code": "42401", "value_represented": "Sulfur dioxide"},
-            {"code": "42101", "value_represented": "Carbon monoxide"},
-            {"code": "42602", "value_represented": "Nitrogen dioxide"},
-            {"code": "81102", "value_represented": "PM10 - Local Conditions"}
-        ]
+        # With API credentials, load data for all states using multithreading
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            future_to_state = {executor.submit(self.get_monitors, state_code): state_code for state_code in self.states.keys()}
+            for future in as_completed(future_to_state):
+                state_code = future_to_state[future]
+                try:
+                    result = future.result()
+                    self.all_monitors_cache[state_code] = result
+                    print(f"Loaded {len(result)} monitors for {state_code}")
+                except Exception as e:
+                    print(f"Error loading monitors for {state_code}: {e}")
+                    # Fall back to mock data
+                    self.all_monitors_cache[state_code] = self.mock_get_monitors(state_code)
+                
+                # Sleep briefly to avoid overwhelming the API
+                time.sleep(0.5)
+    
+    def load_all_aqi_data(self):
+        """Load AQI data for all states"""
+        # If we don't have API credentials, use mock data
+        if not EMAIL or not API_KEY:
+            for state_code in self.states.keys():
+                self.all_aqi_data_cache[state_code] = self._generate_mock_aqi_data(state_code)
+            return
         
-        # Mock air quality data for demo
-        self.mock_aqi_data = {
-            "CA": self._generate_mock_aqi_data("CA"),
-            "NY": self._generate_mock_aqi_data("NY"),
-            "TX": self._generate_mock_aqi_data("TX")
-        }
+        # With API credentials, load data for all states using multithreading
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            future_to_state = {executor.submit(self.get_latest_aqi, state_code): state_code for state_code in self.states.keys()}
+            for future in as_completed(future_to_state):
+                state_code = future_to_state[future]
+                try:
+                    result = future.result()
+                    self.all_aqi_data_cache[state_code] = result
+                    print(f"Loaded {len(result)} AQI readings for {state_code}")
+                except Exception as e:
+                    print(f"Error loading AQI data for {state_code}: {e}")
+                    # Fall back to mock data
+                    self.all_aqi_data_cache[state_code] = self._generate_mock_aqi_data(state_code)
+                
+                # Sleep briefly to avoid overwhelming the API
+                time.sleep(0.5)
     
     def _generate_mock_aqi_data(self, state_code):
         """Generate mock AQI data for a state"""
@@ -117,43 +140,80 @@ class AirQualityApp:
         # Get numeric state code
         numeric_state_code = self.state_code_mapping.get(state_code, "01")
         
-        # Generate data for the most recent 7 days
-        for days_ago in range(7):
-            # Generate date
-            date = (datetime.now() - timedelta(days=days_ago)).strftime("%Y-%m-%d")
-            
-            # Generate random data for each county in the state
-            counties = self.mock_counties.get(state_code, [{"code": "001", "value": "County 1"}])
-            for county in counties:
-                county_code = county["code"]
+        # Make mock data for our standard states
+        if state_code in ["CA", "NY", "TX"]:
+            # Generate data for the most recent 7 days
+            for days_ago in range(7):
+                # Generate date
+                date = (datetime.now() - timedelta(days=days_ago)).strftime("%Y-%m-%d")
+                
+                # Get monitors for this state from cache
+                monitors = self.all_monitors_cache.get(state_code, self.mock_get_monitors(state_code))
                 
-                # Generate data for each parameter
-                for param in self.mock_parameters:
-                    param_code = param["code"]
-                    param_name = param["value_represented"]
+                # Generate AQI data for each monitor
+                for monitor in monitors:
+                    county_code = monitor.get("county_code", "001")
+                    site_number = monitor.get("site_number", "0001")
+                    parameter_code = monitor.get("parameter_code", "88101")
+                    parameter_name = monitor.get("parameter_name", "PM2.5 - Local Conditions")
                     
-                    # Generate a few site numbers per county
-                    for site_num in range(1, 4):
-                        site_number = f"{site_num:04d}"
-                        
-                        # Generate random AQI value (between 0 and 300)
-                        aqi_value = random.randint(0, 300)
-                        
-                        aqi_data.append({
-                            "state_code": numeric_state_code,
-                            "county_code": county_code,
-                            "site_number": site_number,
-                            "parameter_code": param_code,
-                            "parameter_name": param_name,
-                            "date_local": date,
-                            "aqi": aqi_value
-                        })
+                    # Generate random AQI value (between 0 and 300)
+                    aqi_value = random.randint(0, 300)
+                    
+                    aqi_data.append({
+                        "state_code": numeric_state_code,
+                        "county_code": county_code,
+                        "site_number": site_number,
+                        "parameter_code": parameter_code,
+                        "parameter_name": parameter_name,
+                        "date_local": date,
+                        "aqi": aqi_value
+                    })
+        else:
+            # For other states, generate minimal data
+            # Current date
+            date = datetime.now().strftime("%Y-%m-%d")
+            
+            # Make 2 fake monitors with random AQI values
+            aqi_data.append({
+                "state_code": numeric_state_code,
+                "county_code": "001",
+                "site_number": "0001",
+                "parameter_code": "88101",
+                "parameter_name": "PM2.5 - Local Conditions",
+                "date_local": date,
+                "aqi": random.randint(0, 300)
+            })
+            
+            aqi_data.append({
+                "state_code": numeric_state_code,
+                "county_code": "001",
+                "site_number": "0002",
+                "parameter_code": "44201",
+                "parameter_name": "Ozone",
+                "date_local": date,
+                "aqi": random.randint(0, 300)
+            })
         
         return aqi_data
     
-    # [Keep all your existing methods the same]
     def get_monitors(self, state_code, county_code=None, parameter_code=None):
-        # [Same as original]
+        """Fetch monitoring stations for a given state and optional county"""
+        # Check cache first
+        if state_code in self.all_monitors_cache:
+            monitors = self.all_monitors_cache[state_code]
+            
+            # Filter by county if provided
+            if county_code:
+                monitors = [m for m in monitors if m.get("county_code") == county_code]
+                
+            # Filter by parameter if provided
+            if parameter_code:
+                monitors = [m for m in monitors if m.get("parameter_code") == parameter_code]
+                
+            return monitors
+        
+        # If not in cache, fetch from API
         # If we don't have API credentials, use mock data
         if not EMAIL or not API_KEY:
             return self.mock_get_monitors(state_code, county_code, parameter_code)
@@ -184,12 +244,7 @@ class AirQualityApp:
             response = requests.get(endpoint, params=params)
             data = response.json()
             
-            # Add detailed debugging
-            print(f"API Response Keys: {list(data.keys()) if isinstance(data, dict) else 'Not a dictionary'}")
-            if isinstance(data, dict) and "Header" in data:
-                print(f"Header type: {type(data['Header'])}, content: {data['Header'][:100]}...")
-            
-            # Handle the specific response structure we observed
+            # Handle the specific response structure
             if isinstance(data, dict):
                 if "Data" in data and isinstance(data["Data"], list):
                     return data["Data"]
@@ -209,7 +264,6 @@ class AirQualityApp:
             return self.mock_get_monitors(state_code, county_code, parameter_code)
     
     def get_counties(self, state_code):
-        # [Same as original]
         """Fetch counties for a given state"""
         # If we don't have API credentials, use mock data
         if not EMAIL or not API_KEY:
@@ -251,7 +305,6 @@ class AirQualityApp:
             return []
     
     def get_parameters(self):
-        # [Same as original]
         """Fetch available parameter codes (pollutants)"""
         # If we don't have API credentials, use mock data
         if not EMAIL or not API_KEY:
@@ -294,22 +347,24 @@ class AirQualityApp:
     
     def get_latest_aqi(self, state_code, county_code=None, parameter_code=None):
         """Fetch the latest AQI data for monitors"""
-        # If we don't have API credentials, use mock data
-        if not EMAIL or not API_KEY:
-            # Use mock data for demo
-            if state_code in self.mock_aqi_data:
-                aqi_data = self.mock_aqi_data[state_code]
-                
-                # Filter by county if provided
-                if county_code:
-                    aqi_data = [item for item in aqi_data if item.get('county_code') == county_code]
+        # Check cache first
+        if state_code in self.all_aqi_data_cache:
+            aqi_data = self.all_aqi_data_cache[state_code]
+            
+            # Filter by county if provided
+            if county_code:
+                aqi_data = [item for item in aqi_data if item.get('county_code') == county_code]
                 
-                # Filter by parameter if provided
-                if parameter_code:
-                    aqi_data = [item for item in aqi_data if item.get('parameter_code') == parameter_code]
+            # Filter by parameter if provided
+            if parameter_code:
+                aqi_data = [item for item in aqi_data if item.get('parameter_code') == parameter_code]
                 
-                return aqi_data
-            return []
+            return aqi_data
+        
+        # If not in cache, fetch from API
+        # If we don't have API credentials, use mock data
+        if not EMAIL or not API_KEY:
+            return self._generate_mock_aqi_data(state_code)
         
         # Convert state code to numeric format for API
         api_state_code = state_code
@@ -336,11 +391,6 @@ class AirQualityApp:
             response = requests.get(endpoint, params=params)
             data = response.json()
             
-            # Add detailed debugging
-            print(f"AQI API Response Keys: {list(data.keys()) if isinstance(data, dict) else 'Not a dictionary'}")
-            if isinstance(data, dict) and "Header" in data:
-                print(f"AQI Header type: {type(data['Header'])}, content: {data['Header'][:100]}...")
-            
             # Handle the specific response structure we observed
             aqi_data = []
             if isinstance(data, dict) and "Data" in data and isinstance(data["Data"], list):
@@ -355,51 +405,69 @@ class AirQualityApp:
             print(f"Error fetching AQI data: {e}")
             return []
     
-    def create_map(self, state_code, county_code=None, parameter_code=None):
-        """Create a map with air quality monitoring stations"""
-        # IMPORTANT: We don't pass county_code to get_monitors anymore since the API doesn't support it
-        monitors = self.get_monitors(state_code, parameter_code=parameter_code)
+    def create_map(self, focus_state=None, county_code=None, parameter_code=None):
+        """Create a map with air quality monitoring stations for all states"""
+        # Get all monitors - either focused on a state or all states
+        all_monitors = []
+        
+        if focus_state:
+            # Get monitors just for the focused state
+            monitors = self.get_monitors(focus_state, county_code, parameter_code)
+            if monitors:
+                all_monitors.extend(monitors)
+        else:
+            # Get all monitors from all states
+            for state_code in self.states.keys():
+                monitors = self.get_monitors(state_code)
+                if monitors:
+                    all_monitors.extend(monitors)
         
-        if not monitors:
+        if not all_monitors:
             return {"map": "No monitoring stations found for the selected criteria.", "legend": "", "data": None}
         
         # Convert to DataFrame for easier manipulation
-        df = pd.DataFrame(monitors)
+        df = pd.DataFrame(all_monitors)
         
-        # Now filter by county if provided - do this AFTER getting the monitors
-        if county_code:
-            print(f"Filtering by county_code: {county_code}")
-            county_code_str = str(county_code)
-            df = df[df['county_code'].astype(str) == county_code_str]
-            print(f"After filtering, {len(df)} monitors remain")
-            
-            if len(df) == 0:
-                return {"map": "No monitoring stations found for the selected county.", "legend": "", "data": None}
-        
-        # Create a map centered on the mean latitude and longitude
-        center_lat = df["latitude"].mean()
-        center_lon = df["longitude"].mean()
+        # Create a map centered on the continental US
+        if focus_state:
+            # Center on the focused state
+            center_lat = df["latitude"].mean()
+            center_lon = df["longitude"].mean()
+            zoom_start = 7
+        else:
+            # Center on continental US
+            center_lat = 39.8283
+            center_lon = -98.5795
+            zoom_start = 4
         
-        # Create a map with a specific width and height - make it bigger
-        m = folium.Map(location=[center_lat, center_lon], zoom_start=7, width='100%', height=500)
+        # Create a map with a specific width and height
+        m = folium.Map(location=[center_lat, center_lon], zoom_start=zoom_start, width='100%', height=700)
         
         # Add a marker cluster
         marker_cluster = MarkerCluster().add_to(m)
         
-        # Get latest AQI data if credentials are provided
-        aqi_data = {}
-        all_aqi_readings = []
+        # Get all AQI data
+        all_aqi_data = []
+        aqi_data_by_site = {}
         
-        # Get AQI data either from API or mock data
-        aqi_results = self.get_latest_aqi(state_code, county_code, parameter_code)
-        
-        # Create a lookup dictionary by site ID
-        for item in aqi_results:
-            site_id = f"{item['state_code']}-{item['county_code']}-{item['site_number']}"
-            if site_id not in aqi_data:
-                aqi_data[site_id] = []
-            aqi_data[site_id].append(item)
-            all_aqi_readings.append(item)
+        # Process AQI data for each state
+        for state_code in self.states.keys():
+            # Skip states we don't need if focusing on a specific state
+            if focus_state and state_code != focus_state:
+                continue
+                
+            # Get AQI data for this state
+            state_aqi_data = self.get_latest_aqi(state_code, county_code, parameter_code)
+            
+            if state_aqi_data:
+                all_aqi_data.extend(state_aqi_data)
+                
+                # Create a lookup dictionary by site ID
+                for item in state_aqi_data:
+                    site_id = f"{item['state_code']}-{item['county_code']}-{item['site_number']}"
+                    if site_id not in aqi_data_by_site:
+                        aqi_data_by_site[site_id] = []
+                    aqi_data_by_site[site_id].append(item)
         
         # Add markers for each monitoring station
         for _, row in df.iterrows():
@@ -409,7 +477,7 @@ class AirQualityApp:
             color = "blue"
             
             # Get AQI data for this station if available
-            station_aqi_data = aqi_data.get(site_id, [])
+            station_aqi_data = aqi_data_by_site.get(site_id, [])
             latest_aqi = None
             aqi_category = None
             
@@ -464,14 +532,14 @@ class AirQualityApp:
             # Create popup content with detailed information
             popup_content = f"""
             <div style="min-width: 300px;">
-                <h3>{row['local_site_name']}</h3>
+                <h3>{row.get('local_site_name', 'Monitoring Station')}</h3>
                 <p><strong>Site ID:</strong> {site_id}</p>
                 <p><strong>Address:</strong> {row.get('address', 'N/A')}</p>
                 <p><strong>City:</strong> {row.get('city_name', 'N/A')}</p>
                 <p><strong>County:</strong> {row.get('county_name', 'N/A')}</p>
-                <p><strong>State:</strong> {row.get('state_name', 'N/A')}</p>
-                <p><strong>Parameter:</strong> {row['parameter_name']}</p>
-                <p><strong>Coordinates:</strong> {row['latitude']}, {row['longitude']}</p>
+                <p><strong>State:</strong> {row.get('state_name', self.states.get(row.get('state_code', ''), 'Unknown'))}</p>
+                <p><strong>Parameter:</strong> {row.get('parameter_name', 'N/A')}</p>
+                <p><strong>Coordinates:</strong> {row.get('latitude', 'N/A')}, {row.get('longitude', 'N/A')}</p>
                 {aqi_readings_html}
             </div>
             """
@@ -493,11 +561,10 @@ class AirQualityApp:
         return {
             "map": map_html, 
             "legend": legend_html,
-            "data": all_aqi_readings
+            "data": all_aqi_data
         }
     
     def create_legend_html(self):
-        # [Same as original]
         """Create the HTML for the AQI legend"""
         legend_html = """
         <div style="padding: 10px; border: 1px solid #ccc; border-radius: 5px; background-color: white; margin-top: 10px;">
@@ -516,7 +583,6 @@ class AirQualityApp:
         return legend_html
     
     def get_aqi_category(self, aqi_value):
-        # [Same as original]
         """Determine AQI category based on value"""
         try:
             aqi = int(aqi_value)
@@ -535,11 +601,25 @@ class AirQualityApp:
         except (ValueError, TypeError):
             return "Unknown"
     
-    def format_air_quality_data_table(self, aqi_data):
+    def format_air_quality_data_table(self, aqi_data, state_filter=None, county_filter=None):
         """Format air quality data as an HTML table for display"""
         if not aqi_data or len(aqi_data) == 0:
             return "<p>No air quality data available for the selected criteria.</p>"
         
+        # Filter by state if provided
+        if state_filter:
+            # Convert state code if needed
+            if len(state_filter) == 2:
+                state_filter = self.state_code_mapping.get(state_filter, state_filter)
+            aqi_data = [item for item in aqi_data if item.get('state_code') == state_filter]
+        
+        # Filter by county if provided
+        if county_filter:
+            aqi_data = [item for item in aqi_data if item.get('county_code') == county_filter]
+        
+        if not aqi_data or len(aqi_data) == 0:
+            return "<p>No air quality data available for the selected criteria.</p>"
+        
         # Sort by date (most recent first) and then by AQI value (highest first)
         sorted_data = sorted(aqi_data, 
                             key=lambda x: (x.get('date_local', ''), -int(x.get('aqi', 0)) if x.get('aqi') and str(x.get('aqi')).isdigit() else 0), 
@@ -562,6 +642,8 @@ class AirQualityApp:
             <table style="width:100%; border-collapse: collapse;">
                 <tr style="background-color: #f2f2f2; position: sticky; top: 0;">
                     <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Date</th>
+                    <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">State</th>
+                    <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">County</th>
                     <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Location</th>
                     <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">Pollutant</th>
                     <th style="padding: 8px; text-align: left; border: 1px solid #ddd;">AQI</th>
@@ -573,11 +655,18 @@ class AirQualityApp:
         for i, item in enumerate(site_data.values()):
             date = item.get('date_local', 'N/A')
             
-            # Try to get a nice location name
+            # Get state and county names
             state_code = item.get('state_code', 'N/A')
+            state_name = 'N/A'
+            # Reverse lookup state name
+            for code, name in self.state_code_mapping.items():
+                if name == state_code:
+                    state_name = self.states.get(code, 'Unknown')
+                    break
+            
             county_code = item.get('county_code', 'N/A')
             site_number = item.get('site_number', 'N/A')
-            location = f"Site {state_code}-{county_code}-{site_number}"
+            location = f"Site {site_number}"
             
             pollutant = item.get('parameter_name', 'N/A')
             aqi_value = item.get('aqi', 'N/A')
@@ -590,6 +679,8 @@ class AirQualityApp:
             html += f"""
             <tr{row_style}>
                 <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{date}</td>
+                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{state_name}</td>
+                <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{county_code}</td>
                 <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{location}</td>
                 <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{pollutant}</td>
                 <td style="padding: 8px; text-align: left; border: 1px solid #ddd;">{aqi_value}</td>
@@ -604,11 +695,32 @@ class AirQualityApp:
         
         return html
     
-    # [Keep all your mock data methods the same]
     def mock_get_counties(self, state_code):
         """Return mock county data for the specified state"""
-        if state_code in self.mock_counties:
-            counties = self.mock_counties[state_code]
+        # Sample county data for demo
+        mock_counties = {
+            "CA": [
+                {"code": "037", "value": "Los Angeles"},
+                {"code": "067", "value": "Sacramento"},
+                {"code": "073", "value": "San Diego"},
+                {"code": "075", "value": "San Francisco"}
+            ],
+            "NY": [
+                {"code": "061", "value": "New York"},
+                {"code": "047", "value": "Kings (Brooklyn)"},
+                {"code": "081", "value": "Queens"},
+                {"code": "005", "value": "Bronx"}
+            ],
+            "TX": [
+                {"code": "201", "value": "Harris (Houston)"},
+                {"code": "113", "value": "Dallas"},
+                {"code": "029", "value": "Bexar (San Antonio)"},
+                {"code": "453", "value": "Travis (Austin)"}
+            ]
+        }
+        
+        if state_code in mock_counties:
+            counties = mock_counties[state_code]
             return [f"{c['code']}: {c['value']}" for c in counties]
         else:
             # Return generic counties for other states
@@ -621,7 +733,17 @@ class AirQualityApp:
     
     def mock_get_parameters(self):
         """Return mock parameter data"""
-        return [f"{p['code']}: {p['value_represented']}" for p in self.mock_parameters]
+        # Sample parameters for demo
+        mock_parameters = [
+            {"code": "88101", "value_represented": "PM2.5 - Local Conditions"},
+            {"code": "44201", "value_represented": "Ozone"},
+            {"code": "42401", "value_represented": "Sulfur dioxide"},
+            {"code": "42101", "value_represented": "Carbon monoxide"},
+            {"code": "42602", "value_represented": "Nitrogen dioxide"},
+            {"code": "81102", "value_represented": "PM10 - Local Conditions"}
+        ]
+        
+        return [f"{p['code']}: {p['value_represented']}" for p in mock_parameters]
     
     def mock_get_monitors(self, state_code, county_code=None, parameter_code=None):
         """Mock function to return sample data for development"""
@@ -787,8 +909,8 @@ class AirQualityApp:
                     "parameter_code": "88101",
                     "parameter_name": "PM2.5 - Local Conditions",
                     "poc": 1,
-                    "latitude": 40.0 + float(ord(state_code[0])) / 10,
-                    "longitude": -90.0 - float(ord(state_code[1])) / 10,
+                    "latitude": 40.0 + float(ord(state_code[0]) % 10) / 10,
+                    "longitude": -90.0 - float(ord(state_code[0]) % 10) / 10,
                     "local_site_name": f"{self.states.get(state_code, 'Unknown')} - Station 1",
                     "address": "123 Main Street",
                     "city_name": "City 1",
@@ -803,8 +925,8 @@ class AirQualityApp:
                     "parameter_code": "44201",
                     "parameter_name": "Ozone",
                     "poc": 1,
-                    "latitude": 40.5 + float(ord(state_code[0])) / 10,
-                    "longitude": -90.5 - float(ord(state_code[1])) / 10,
+                    "latitude": 40.5 + float(ord(state_code[0]) % 10) / 10,
+                    "longitude": -90.5 - float(ord(state_code[0]) % 10) / 10,
                     "local_site_name": f"{self.states.get(state_code, 'Unknown')} - Station 2",
                     "address": "456 Oak Street",
                     "city_name": "City 2",
@@ -824,9 +946,9 @@ class AirQualityApp:
             
         return monitors
 
-# Create the UI with the new Air Quality Data panel
+# Create the new UI with the nationwide map
 def create_air_quality_map_ui():
-    """Create the Gradio interface for the Air Quality Map application with a separate data panel"""
+    """Create the Gradio interface for the Air Quality Map application with nationwide data preloaded"""
     app = AirQualityApp()
     
     def update_counties(state_code):
@@ -834,7 +956,7 @@ def create_air_quality_map_ui():
         counties = app.get_counties(state_code)
         return gr.Dropdown(choices=counties)
     
-    def show_map_and_data(state, county=None, parameter=None):
+    def show_map_and_data(state=None, county=None, parameter=None):
         """Callback to generate and display both the map and the air quality data"""
         # Extract code from county string if provided
         county_code = None
@@ -846,7 +968,7 @@ def create_air_quality_map_ui():
         if parameter and ":" in parameter:
             parameter_code = parameter.split(":")[0].strip()
             
-        # Generate the map and get data
+        # Generate the map and get data - focus on state if selected
         result = app.create_map(state, county_code, parameter_code)
         
         if isinstance(result, dict):
@@ -860,7 +982,7 @@ def create_air_quality_map_ui():
             
             # Process air quality data for the separate panel
             if result["data"]:
-                data_html = app.format_air_quality_data_table(result["data"])
+                data_html = app.format_air_quality_data_table(result["data"], state, county_code)
             else:
                 data_html = "<p>No air quality data available for the selected criteria.</p>"
                 
@@ -874,39 +996,39 @@ def create_air_quality_map_ui():
     with gr.Blocks(title="Air Quality Monitoring Stations") as interface:
         gr.Markdown("# NOAA Air Quality Monitoring Stations Map")
         gr.Markdown("""
-        This application displays air quality monitoring stations in the United States and shows current air quality readings.
+        This application displays air quality monitoring stations across the United States and shows current air quality readings.
         
         **Note:** To use the actual EPA AQS API, you need to register for an API key and set 
         `EPA_AQS_EMAIL` and `EPA_AQS_API_KEY` environment variables in your Hugging Face Space.
         
-        For demonstration without an API key, the app shows sample data for California (CA), New York (NY), and Texas (TX).
+        For demonstration without an API key, the app shows sample data with more detailed information for California (CA), New York (NY), and Texas (TX).
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
-                # State dropdown with default value
+                # State dropdown with empty default (all states)
                 state_dropdown = gr.Dropdown(
-                    choices=list(app.states.keys()),
-                    label="Select State",
-                    value="CA"
+                    choices=[""] + list(app.states.keys()),
+                    label="Filter by State (Optional)",
+                    value=""
                 )
                 
-                # County dropdown with mock counties for the default state
+                # County dropdown (initially empty)
                 county_dropdown = gr.Dropdown(
-                    choices=app.mock_get_counties("CA"),
-                    label="Select County (Optional)",
+                    choices=[],
+                    label="Filter by County (Optional)",
                     allow_custom_value=True
                 )
                 
                 # Parameter dropdown (pollutant type)
                 parameter_dropdown = gr.Dropdown(
                     choices=app.mock_get_parameters(),
-                    label="Select Pollutant (Optional)",
+                    label="Filter by Pollutant (Optional)",
                     allow_custom_value=True
                 )
                 
-                # Button to generate map and data
-                map_button = gr.Button("Show Map and Air Quality Data")
+                # Button to update filters
+                map_button = gr.Button("Update Filters")
         
         # Create two tabs for the map and data
         with gr.Tabs() as tabs:
@@ -930,6 +1052,13 @@ def create_air_quality_map_ui():
             inputs=[state_dropdown, county_dropdown, parameter_dropdown],
             outputs=[map_html, data_html]
         )
+        
+        # Load initial map when the app starts
+        interface.load(
+            fn=show_map_and_data,
+            inputs=None,
+            outputs=[map_html, data_html]
+        )
     
     return interface