Update data/climate_data.py

data/climate_data.py

@@ -30,7 +30,7 @@ logger = logging.getLogger(__name__)
 # Define paths at module level
 AU_CCH_DIR = "au_cch"  # Relative path to au_cch folder from climate_data.py in data/ (e.g., au_cch/1/RCP2.6/2070/)
 
-# CSS for consistent formatting (from your original file)
+# CSS for consistent formatting
 STYLE = """
 <style>
 .markdown-text {
@@ -59,7 +59,7 @@ STYLE = """
 </style>
 """
 
-# Location mapping from provided list (from your original file)
+# Location mapping from provided list
 LOCATION_MAPPING = {
     "24": {"city": "Canberra", "state": "ACT"},
     "11": {"city": "Coffs Harbour", "state": "NSW"},
@@ -148,12 +148,12 @@ class ClimateLocation:
             logger.warning(f"High wind speeds detected: {wind_speed[wind_speed > 15].tolist()}")
         
         # Calculate wet-bulb temperature
-        self.wet_bulb_temperatures = ClimateData.calculate_wet_bulb(dry_bulb, humidity) # Store for potential use
+        wet_bulb = ClimateData.calculate_wet_bulb(dry_bulb, humidity)
         
         # Calculate design conditions
         self.winter_design_temp = round(np.nanpercentile(dry_bulb, 0.4), 1)
         self.summer_design_temp_db = round(np.nanpercentile(dry_bulb, 99.6), 1)
-        self.summer_design_temp_wb = round(np.nanpercentile(self.wet_bulb_temperatures, 99.6), 1)
+        self.summer_design_temp_wb = round(np.nanpercentile(wet_bulb, 99.6), 1)
         
         # Calculate degree days
         daily_temps = np.nanmean(dry_bulb.reshape(-1, 24), axis=1)
@@ -420,29 +420,15 @@ class ClimateData:
 
     def load_climate_data(self, country: str, city: str) -> Optional[Dict[str, Any]]:
         """Load climate data for a given country and city."""
-        # This implementation assumes EPW files are stored in a specific directory structure
-        # e.g., data/au_cch/1/RCP2.6/2070/
-        
-        # This is a simplified example, you would need a more robust way to find the EPW file
-        # based on country and city, potentially from a manifest or by scanning directories.
-        
-        # For demonstration, let's assume a direct path if a dummy EPW is available
-        # In a real scenario, you'd map country/city to a specific EPW file path.
-        
         epw_file_path = None
-        # Example: If you have a known EPW file for Geelong or other mapped locations
         found_id = None
         for loc_id, loc_info in LOCATION_MAPPING.items():
-            if loc_info["city"] == city and (loc_info["state"] == "VIC" if city == "Melbourne RO" else True): # Add specific check for Melbourne RO
-                # This is a placeholder for the actual EPW file path logic
-                # You'll need to map LOCATION_MAPPING IDs to actual EPW file names.
-                # For now, using a generic example.
-                epw_file_name = f"AUS_VIC_Melbourne.AP.720520_TMY3.epw" # Default example
+            if loc_info["city"] == city and (loc_info["state"] == "VIC" if city == "Melbourne RO" else True):
+                epw_file_name = f"AUS_VIC_Melbourne.AP.720520_TMY3.epw" 
                 if city == "Geelong":
-                    epw_file_name = "AUS_VIC_Melbourne.AP.720520_TMY3.epw" # Placeholder for Geelong
+                    epw_file_name = "AUS_VIC_Melbourne.AP.720520_TMY3.epw" 
                 elif city == "Sydney RO (Observatory Hill)":
-                    epw_file_name = "AUS_NSW_Sydney.AP.947670_TMY3.epw" # Placeholder for Sydney
-                # Add more specific mappings as needed
+                    epw_file_name = "AUS_NSW_Sydney.AP.947670_TMY3.epw" 
                 
                 epw_file_path = os_join("data", AU_CCH_DIR, epw_file_name)
                 found_id = loc_id
@@ -457,37 +443,40 @@ class ClimateData:
         if epw_data_df.empty:
             return None
 
-        hourly_data = self._process_epw_data(epw_data_df)
-        
-        # Extract metadata from EPW header (simplified for this example)
-        # In a real scenario, you'd parse the EPW header more thoroughly
-        location_id = found_id if found_id else f"{country}_{city}".replace(" ", "_").lower()
+        # Pass the raw epw_data_df to ClimateLocation for its __init__ to process
+        # This ensures ClimateLocation's internal calculations (like design temps, degree days)
+        # are based on the full EPW data as originally intended.
         
         # Retrieve typical_extreme_periods and ground_temperatures
         typical_extreme_periods = self.get_typical_extreme_periods(epw_file_path)
         ground_temperatures = self.get_ground_temperatures(epw_file_path)
 
+        location_id = found_id if found_id else f"{country}_{city}".replace(" ", "_").lower()
+        
         location = ClimateLocation(
-            epw_file=epw_file_path,
+            epw_file=epw_data_df, # Pass the DataFrame here
             typical_extreme_periods=typical_extreme_periods,
             ground_temperatures=ground_temperatures,
             id=location_id,
             country=country,
-            state_province=LOCATION_MAPPING.get(found_id, {}).get("state", "N/A"), # Use mapped state
+            state_province=LOCATION_MAPPING.get(found_id, {}).get("state", "N/A"),
             city=city,
-            latitude=epw_data_df.loc[0, 'latitude'], # Assuming lat/lon in first row of epw_data_df
+            latitude=epw_data_df.loc[0, 'latitude'],
             longitude=epw_data_df.loc[0, 'longitude'],
             elevation=epw_data_df.loc[0, 'elevation'],
             time_zone=epw_data_df.loc[0, 'time_zone'],
-            climate_zone="Unknown", # You'd need a method to determine this from lat/lon or EPW
-            hourly_data=hourly_data
+            climate_zone="Unknown", # This should ideally be determined by a lookup based on location
+            # hourly_data is now handled internally by ClimateLocation's __init__
+            # based on the epw_file DataFrame passed above.
+            # We explicitly pass it as a keyword argument to satisfy the dataclass init if needed,
+            # but the __init__ will re-process it.
+            hourly_data=[] # Dummy, will be populated by ClimateLocation's __init__
         )
         self.add_location(location)
         return location.to_dict()
 
     def get_climate_zone_description(self, climate_zone_code: str) -> str:
         """Return a description for a given ASHRAE climate zone code."""
-        # This is a placeholder; you'd have a mapping for climate zone codes to descriptions
         zone_descriptions = {
             "1A": "Hot-Humid", "1B": "Hot-Dry",
             "2A": "Warm-Humid", "2B": "Warm-Dry",
@@ -506,18 +495,14 @@ class ClimateData:
             with open(epw_file_path, 'r') as f:
                 for line in f:
                     if line.startswith('COMMENT1'):
-                        # Example: COMMENT1 TYPICAL EXTREME PERIODS: Summer Design Day, Winter Design Day
                         match = re.search(r'TYPICAL EXTREME PERIODS: (.+)', line)
                         if match:
                             periods_str = match.group(1)
-                            # This parsing is highly dependent on the exact format in EPW comments
-                            # A more robust parser might be needed for varied EPW files.
-                            # For now, a dummy structure, as in your original file's behavior:
                             typical_extreme_periods = {
                                 "summer_design_day": {"start_date": "07/21", "end_date": "07/21"},
                                 "winter_design_day": {"start_date": "01/21", "end_date": "01/21"}
                             }
-                        break # Assume only one COMMENT1 line for this info
+                        break
         except Exception as e:
             logger.warning(f"Could not extract typical/extreme periods from EPW comments: {e}")
         return typical_extreme_periods
@@ -525,7 +510,7 @@ class ClimateData:
     def get_ground_temperatures(self, epw_file_path: str) -> Dict[str, List[float]]:
         """Extract ground temperatures from EPW file comments."""
         ground_temperatures = {
-            "depth_0.5m": [15.0] * 12, # Dummy monthly values
+            "depth_0.5m": [15.0] * 12,
             "depth_1.0m": [14.0] * 12,
             "depth_2.0m": [13.0] * 12,
             "depth_4.0m": [12.0] * 12
@@ -534,11 +519,6 @@ class ClimateData:
             with open(epw_file_path, 'r') as f:
                 for line in f:
                     if line.startswith('COMMENT2'):
-                        # Example: COMMENT2 GROUND TEMPERATURES (C) 0.5m: 15.0,15.1,...
-                        # This parsing is highly dependent on the exact format in EPW comments
-                        # and would need to be robust.
-                        # For now, we'll stick with the dummy values as parsing this from raw EPW
-                        # comments can be fragile without specific format knowledge.
                         pass
         except Exception as e:
             logger.warning(f"Could not extract ground temperatures from EPW comments: {e}")
@@ -546,10 +526,7 @@ class ClimateData:
 
     def save_climate_data(self, climate_data_dict: Dict[str, Any]):
         """Save climate data to a JSON file."""
-        # This is a placeholder for saving logic.
-        # In a real app, you might save to a user-specific location or database.
         logger.info(f"Saving climate data (placeholder): {climate_data_dict['id']}")
-        # Example: save to a 'saved_data' directory
         save_dir = "saved_data"
         os.makedirs(save_dir, exist_ok=True)
         file_path = os_join(save_dir, f"{climate_data_dict['id']}.json")
@@ -563,8 +540,6 @@ class ClimateData:
 
     def load_saved_climate_data(self) -> 'ClimateData':
         """Load saved climate data from JSON files."""
-        # This is a placeholder for loading logic.
-        # It would typically scan a directory or query a database.
         load_dir = "saved_data"
         if os.path.exists(load_dir):
             for filename in os.listdir(load_dir):
@@ -573,16 +548,11 @@ class ClimateData:
                     try:
                         with open(file_path, 'r') as f:
                             loc_dict = json.load(f)
-                            # Reconstruct ClimateLocation object
-                            # Ensure all expected keys are present, handle missing gracefully
                             hourly_data = loc_dict.get("hourly_data", [])
                             
-                            # The original ClimateLocation __init__ expects a DataFrame for epw_file.
-                            # When loading from JSON, you'd typically have processed hourly_data.
-                            # We need to adapt this. For now, we'll pass a dummy DataFrame
-                            # if epw_file is not explicitly loaded, and rely on hourly_data.
-                            
-                            # Create a dummy DataFrame if not available, as ClimateLocation expects it
+                            # Create a dummy DataFrame with required columns for ClimateLocation __init__
+                            # This ensures the __init__ can run and re-process the hourly_data
+                            # and calculate design conditions, etc., as it expects a DataFrame.
                             dummy_epw_df = pd.DataFrame({
                                 1: [d['month'] for d in hourly_data],
                                 2: [d['day'] for d in hourly_data],
@@ -595,11 +565,21 @@ class ClimateData:
                                 15: [d['diffuse_horizontal_radiation'] for d in hourly_data],
                                 20: [d['wind_direction'] for d in hourly_data],
                                 21: [d['wind_speed'] for d in hourly_data],
+                                # Add metadata columns if they are expected by ClimateLocation's __init__
+                                'latitude': [loc_dict.get('latitude', 0.0)] * len(hourly_data),
+                                'longitude': [loc_dict.get('longitude', 0.0)] * len(hourly_data),
+                                'elevation': [loc_dict.get('elevation', 0.0)] * len(hourly_data),
+                                'time_zone': [loc_dict.get('time_zone', 0.0)] * len(hourly_data),
+                                # Add other pvlib expected columns if they are used in ClimateLocation's __init__
+                                'temp_dry_bulb': [d['dry_bulb'] for d in hourly_data],
+                                'relative_humidity': [d['relative_humidity'] for d in hourly_data],
+                                'station_pressure': [d['atmospheric_pressure'] for d in hourly_data],
+                                'ghi': [d['global_horizontal_radiation'] for d in hourly_data],
+                                'dni': [d['direct_normal_radiation'] for d in hourly_data],
+                                'dhi': [d['diffuse_horizontal_radiation'] for d in hourly_data],
+                                'wind_direction': [d['wind_direction'] for d in hourly_data],
+                                'wind_speed': [d['wind_speed'] for d in hourly_data],
                             })
-                            # Add dummy metadata columns if they don't exist, as ClimateLocation expects them
-                            for col in ['latitude', 'longitude', 'elevation', 'time_zone']:
-                                if col not in dummy_epw_df.columns:
-                                    dummy_epw_df[col] = loc_dict.get(col, 0.0) # Use saved value or default
 
                             location = ClimateLocation(
                                 epw_file=dummy_epw_df, # Pass dummy DataFrame for __init__
@@ -988,8 +968,135 @@ class ClimateData:
 
         return fig
 
+    def display_climate_input(self, session_state: Dict[str, Any]):
+        """Display climate data input and selection in Streamlit."""
+        st.markdown(STYLE, unsafe_allow_html=True)
+        st.subheader("Climate Data Input")
+
+        # Country selection
+        country_options = sorted(self.countries)
+        selected_country = st.selectbox(
+            "Select Country",
+            country_options,
+            index=country_options.index(session_state["building_info"].get("country", "Australia"))
+            if session_state["building_info"].get("country", "Australia") in country_options
+            else 0,
+            key="climate_country_select"
+        )
+        session_state["building_info"]["country"] = selected_country
+
+        # State/Province selection
+        if selected_country and selected_country in self.country_states:
+            state_options = sorted(self.country_states[selected_country].keys())
+            selected_state = st.selectbox(
+                "Select State/Province",
+                state_options,
+                index=state_options.index(session_state["building_info"].get("state_province", "Victoria"))
+                if session_state["building_info"].get("state_province", "Victoria") in state_options
+                else 0,
+                key="climate_state_select"
+            )
+            session_state["building_info"]["state_province"] = selected_state
+        else:
+            selected_state = None
+            st.warning("No states available for the selected country.")
+
+        # City selection
+        if selected_state and selected_country in self.country_states and selected_state in self.country_states[selected_country]:
+            city_options = sorted(self.country_states[selected_country][selected_state])
+            selected_city = st.selectbox(
+                "Select City",
+                city_options,
+                index=city_options.index(session_state["building_info"].get("city", "Geelong"))
+                if session_state["building_info"].get("city", "Geelong") in city_options
+                else 0,
+                key="climate_city_select"
+            )
+            session_state["building_info"]["city"] = selected_city
+        else:
+            selected_city = None
+            st.warning("No cities available for the selected state/province.")
+
+        # Load data button
+        if st.button("Load Climate Data"):
+            if selected_country and selected_city:
+                with st.spinner(f"Loading climate data for {selected_city}, {selected_country}..."):
+                    loaded_data = self.load_climate_data(selected_country, selected_city)
+                    if loaded_data:
+                        if self.validate_climate_data(loaded_data):
+                            session_state["climate_data"] = loaded_data
+                            st.success(f"Climate data loaded successfully for {selected_city}, {selected_country}!")
+                            logger.info(f"Climate data loaded for {selected_city}, {selected_country}.")
+                        else:
+                            st.error("Loaded climate data failed validation. Please check the data source.")
+                            logger.error("Loaded climate data failed validation.")
+                    else:
+                        st.error(f"Failed to load climate data for {selected_city}, {selected_country}.")
+                        logger.error(f"Failed to load climate data for {selected_city}, {selected_country}.")
+            else:
+                st.warning("Please select a country and city to load climate data.")
+
+        # Display loaded data if available
+        if "climate_data" in session_state and session_state["climate_data"]:
+            st.subheader("Loaded Climate Data Summary")
+            climate_info = session_state["climate_data"]
+            
+            st.markdown(f"""
+            <div class="markdown-text">
+                <h3>Location Details:</h3>
+                <ul>
+                    <li><strong>ID:</strong> {climate_info.get('id', 'N/A')}</li>
+                    <li><strong>Country:</strong> {climate_info.get('country', 'N/A')}</li>
+                    <li><strong>State/Province:</strong> {climate_info.get('state_province', 'N/A')}</li>
+                    <li><strong>City:</strong> {climate_info.get('city', 'N/A')}</li>
+                    <li><strong>Latitude:</strong> {climate_info.get('latitude', 'N/A'):.2f}°</li>
+                    <li><strong>Longitude:</strong> {climate_info.get('longitude', 'N/A'):.2f}°</li>
+                    <li><strong>Elevation:</strong> {climate_info.get('elevation', 'N/A'):.1f} m</li>
+                    <li><strong>Time Zone:</strong> UTC{climate_info.get('time_zone', 'N/A'):.1f}</li>
+                    <li><strong>Climate Zone:</strong> {climate_info.get('climate_zone', 'N/A')} ({self.get_climate_zone_description(climate_info.get('climate_zone', ''))})</li>
+                </ul>
+
+                <h3>Design Conditions:</h3>
+                <ul>
+                    <li><strong>Heating Degree Days (Base 18°C):</strong> {climate_info.get('heating_degree_days', 'N/A')} HDD</li>
+                    <li><strong>Cooling Degree Days (Base 18°C):</strong> {climate_info.get('cooling_degree_days', 'N/A')} CDD</li>
+                    <li><strong>Winter Design Temp (99.6%):</strong> {climate_info.get('winter_design_temp', 'N/A'):.1f}°C</li>
+                    <li><strong>Summer Design Dry-Bulb (0.4%):</strong> {climate_info.get('summer_design_temp_db', 'N/A'):.1f}°C</li>
+                    <li><strong>Summer Design Wet-Bulb (0.4%):</strong> {climate_info.get('summer_design_temp_wb', 'N/A'):.1f}°C</li>
+                    <li><strong>Summer Daily Range:</strong> {climate_info.get('summer_daily_range', 'N/A'):.1f}°C</li>
+                    <li><strong>Mean Wind Speed:</strong> {climate_info.get('wind_speed', 'N/A'):.1f} m/s</li>
+                    <li><strong>Mean Atmospheric Pressure:</strong> {climate_info.get('pressure', 'N/A'):.1f} Pa</li>
+                </ul>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            # Display Typical/Extreme Periods
+            st.subheader("Typical and Extreme Periods")
+            if climate_info.get("typical_extreme_periods"):
+                for period_name, details in climate_info["typical_extreme_periods"].items():
+                    st.write(f"**{period_name.replace('_', ' ').title()}:** Start Date: {details.get('start_date', 'N/A')}, End Date: {details.get('end_date', 'N/A')}")
+            else:
+                st.info("No typical and extreme periods data available for this location.")
+
+            # Display Ground Temperatures
+            st.subheader("Ground Temperatures (Monthly Average)")
+            if climate_info.get("ground_temperatures"):
+                temp_df = pd.DataFrame(climate_info["ground_temperatures"])
+                temp_df.index = [f"Month {i+1}" for i in range(12)]
+                st.dataframe(temp_df)
+            else:
+                st.info("No ground temperature data available for this location.")
+
+            # Option to save data
+            if st.button("Save Climate Data"):
+                self.save_climate_data(climate_info)
+            
+            st.subheader("Psychrometric Chart")
+            # Generate and display the psychrometric chart
+            psych_fig = self.plot_psychrometric_chart(climate_info["id"], session_state)
+            st.plotly_chart(psych_fig, use_container_width=True)
+
 # --- Original if __name__ == "__main__": block from your file ---
 if __name__ == "__main__":
     climate_data = ClimateData()
-    session_state = {"building_info": {"country": "Australia", "city": "Geelong"}, "page": "Climate Data"}
-    climate_data.display_climate_input(session_state)
+    session_state = {"building_info": {"country": "Australia", "city": "Geelong"}, "page": "Climate Data"}