Update data/climate_data.py

data/climate_data.py

@@ -18,6 +18,7 @@ import plotly.graph_objects as go
 from io import StringIO
 import pvlib
 from datetime import datetime, timedelta
+import re
 
 # Define paths
 DATA_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -45,8 +46,9 @@ class ClimateLocation:
     hourly_data: List[Dict]  # Hourly data for integration with main.py
     typical_extreme_periods: Dict[str, Dict]  # Typical/extreme periods (summer/winter)
     ground_temperatures: Dict[str, List[float]]  # Monthly ground temperatures by depth
+    design_conditions: Dict[str, Any]  # Design conditions from EPW header
     
-    def __init__(self, epw_file: pd.DataFrame, typical_extreme_periods: Dict, ground_temperatures: Dict, **kwargs):
+    def __init__(self, epw_file: pd.DataFrame, typical_extreme_periods: Dict, ground_temperatures: Dict, design_conditions: Dict, **kwargs):
         """Initialize ClimateLocation with EPW file data and header information."""
         self.id = kwargs.get("id")
         self.country = kwargs.get("country")
@@ -57,6 +59,7 @@ class ClimateLocation:
         self.elevation = kwargs.get("elevation")
         self.typical_extreme_periods = typical_extreme_periods
         self.ground_temperatures = ground_temperatures
+        self.design_conditions = design_conditions
         
         # Extract columns from EPW data
         months = pd.to_numeric(epw_file[1], errors='coerce').values
@@ -95,24 +98,25 @@ class ClimateLocation:
         self.climate_zone = ClimateData.assign_climate_zone(self.heating_degree_days, self.cooling_degree_days, np.nanmean(humidity))
         
         # Store hourly data with enhanced fields
-        self.hourly_data = [
-            {
+        self.hourly_data = []
+        for i in range(len(months)):
+            if np.isnan(months[i]) or np.isnan(days[i]) or np.isnan(hours[i]) or np.isnan(dry_bulb[i]):
+                continue  # Skip records with missing critical fields
+            record = {
                 "month": int(months[i]),
                 "day": int(days[i]),
                 "hour": int(hours[i]),
                 "dry_bulb": float(dry_bulb[i]),
-                "relative_humidity": float(humidity[i]),
-                "atmospheric_pressure": float(pressure[i]),
-                "global_horizontal_radiation": float(global_radiation[i]),
-                "wind_speed": float(wind_speed[i]),
-                "wind_direction": float(wind_direction[i])
+                "relative_humidity": float(humidity[i]) if not np.isnan(humidity[i]) else 0.0,
+                "atmospheric_pressure": float(pressure[i]) if not np.isnan(pressure[i]) else self.pressure,
+                "global_horizontal_radiation": float(global_radiation[i]) if not np.isnan(global_radiation[i]) else 0.0,
+                "wind_speed": float(wind_speed[i]) if not np.isnan(wind_speed[i]) else 0.0,
+                "wind_direction": float(wind_direction[i]) if not np.isnan(wind_direction[i]) else 0.0
             }
-            for i in range(len(months))
-            if not any(np.isnan([
-                months[i], days[i], hours[i], dry_bulb[i], humidity[i],
-                pressure[i], global_radiation[i], wind_speed[i], wind_direction[i]
-            ]))
-        ]
+            self.hourly_data.append(record)
+        
+        if len(self.hourly_data) != 8760:
+            st.warning(f"Hourly data has {len(self.hourly_data)} records instead of 8760. Some records may have been excluded due to missing data.")
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert the climate location to a dictionary."""
@@ -135,7 +139,8 @@ class ClimateLocation:
             "pressure": self.pressure,
             "hourly_data": self.hourly_data,
             "typical_extreme_periods": self.typical_extreme_periods,
-            "ground_temperatures": self.ground_temperatures
+            "ground_temperatures": self.ground_temperatures,
+            "design_conditions": self.design_conditions
         }
 
 class ClimateData:
@@ -182,70 +187,102 @@ class ClimateData:
             "id", "country", "city", "latitude", "longitude", "elevation",
             "climate_zone", "heating_degree_days", "cooling_degree_days",
             "winter_design_temp", "summer_design_temp_db", "summer_design_temp_wb",
-            "summer_daily_range", "wind_speed", "pressure", "hourly_data",
-            "typical_extreme_periods", "ground_temperatures"
+            "summer_daily_range", "wind_speed", "pressure", "hourly_data"
         ]
         
         for field in required_fields:
             if field not in data:
+                st.error(f"Validation failed: Missing required field '{field}'")
                 return False
         
         if not (-90 <= data["latitude"] <= 90 and -180 <= data["longitude"] <= 180):
+            st.error("Validation failed: Invalid latitude or longitude")
             return False
         if data["elevation"] < 0:
+            st.error("Validation failed: Negative elevation")
             return False
         if data["climate_zone"] not in ["0A", "0B", "1A", "1B", "2A", "2B", "3A", "3B", "3C", "4A", "4B", "4C", "5A", "5B", "5C", "6A", "6B", "7", "8"]:
+            st.error(f"Validation failed: Invalid climate zone '{data['climate_zone']}'")
             return False
         if not (data["heating_degree_days"] >= 0 and data["cooling_degree_days"] >= 0):
+            st.error("Validation failed: Negative degree days")
             return False
         if not (-50 <= data["winter_design_temp"] <= 20):
+            st.error(f"Validation failed: Winter design temp {data['winter_design_temp']} outside range")
             return False
         if not (0 <= data["summer_design_temp_db"] <= 50 and 0 <= data["summer_design_temp_wb"] <= 40):
+            st.error("Validation failed: Invalid summer design temperatures")
             return False
         if data["summer_daily_range"] < 0:
+            st.error("Validation failed: Negative summer daily range")
             return False
         if not (0 <= data["wind_speed"] <= 20):
+            st.error(f"Validation failed: Wind speed {data['wind_speed']} outside range")
             return False
         if not (80000 <= data["pressure"] <= 110000):
+            st.error(f"Validation failed: Pressure {data['pressure']} outside range")
             return False
         
-        if not data["hourly_data"] or len(data["hourly_data"]) != 8760:
+        if not data["hourly_data"] or len(data["hourly_data"]) < 8700:  # Allow slight data loss
+            st.error(f"Validation failed: Hourly data has {len(data['hourly_data'])} records, expected ~8760")
             return False
         for record in data["hourly_data"]:
             if not (1 <= record["month"] <= 12):
+                st.error(f"Validation failed: Invalid month {record['month']}")
                 return False
             if not (1 <= record["day"] <= 31):
+                st.error(f"Validation failed: Invalid day {record['day']}")
                 return False
             if not (1 <= record["hour"] <= 24):
+                st.error(f"Validation failed: Invalid hour {record['hour']}")
                 return False
             if not (-50 <= record["dry_bulb"] <= 50):
+                st.error(f"Validation failed: Dry bulb {record['dry_bulb']} outside range")
                 return False
             if not (0 <= record["relative_humidity"] <= 100):
+                st.error(f"Validation failed: Relative humidity {record['relative_humidity']} outside range")
                 return False
             if not (80000 <= record["atmospheric_pressure"] <= 110000):
+                st.error(f"Validation failed: Atmospheric pressure {record['atmospheric_pressure']} outside range")
                 return False
             if not (0 <= record["global_horizontal_radiation"] <= 1200):
+                st.error(f"Validation failed: Global radiation {record['global_horizontal_radiation']} outside range")
                 return False
             if not (0 <= record["wind_speed"] <= 20):
+                st.error(f"Validation failed: Wind speed {record['wind_speed']} outside range")
                 return False
             if not (0 <= record["wind_direction"] <= 360):
+                st.error(f"Validation failed: Wind direction {record['wind_direction']} outside range")
                 return False
         
-        # Validate typical/extreme periods
-        expected_periods = ["summer_extreme", "summer_typical", "winter_extreme", "winter_typical"]
-        if not all(key in data["typical_extreme_periods"] for key in expected_periods):
-            return False
-        for period in data["typical_extreme_periods"].values():
-            for date in ["start", "end"]:
-                if not (1 <= period[date]["month"] <= 12 and 1 <= period[date]["day"] <= 31):
+        # Validate typical/extreme periods (optional)
+        if "typical_extreme_periods" in data and data["typical_extreme_periods"]:
+            expected_periods = ["summer_extreme", "summer_typical", "winter_extreme", "winter_typical"]
+            if not all(key in data["typical_extreme_periods"] for key in expected_periods):
+                st.warning("Validation warning: Missing some typical/extreme periods")
+            for period in data["typical_extreme_periods"].values():
+                for date in ["start", "end"]:
+                    if not (1 <= period[date]["month"] <= 12 and 1 <= period[date]["day"] <= 31):
+                        st.error(f"Validation failed: Invalid date in typical/extreme periods: {period[date]}")
+                        return False
+        
+        # Validate ground temperatures (optional)
+        if "ground_temperatures" in data and data["ground_temperatures"]:
+            for depth, temps in data["ground_temperatures"].items():
+                if len(temps) != 12 or not all(0 <= t <= 50 for t in temps):
+                    st.error(f"Validation failed: Invalid ground temperatures for depth {depth}")
                     return False
         
-        # Validate ground temperatures
-        if not data["ground_temperatures"]:
-            return False
-        for depth, temps in data["ground_temperatures"].items():
-            if len(temps) != 12 or not all(0 <= t <= 50 for t in temps):
-                return False
+        # Validate design conditions (optional)
+        if "design_conditions" in data and data["design_conditions"]:
+            if not all(key in data["design_conditions"] for key in ["heating", "cooling", "extremes"]):
+                st.warning("Validation warning: Incomplete design conditions")
+            for section in ["heating", "cooling", "extremes"]:
+                if section in data["design_conditions"]:
+                    for key, value in data["design_conditions"][section].items():
+                        if isinstance(value, (int, float)) and not (-50 <= value <= 50):
+                            st.error(f"Validation failed: Invalid {section} design condition {key}: {value}")
+                            return False
         
         return True
 
@@ -294,6 +331,59 @@ class ClimateData:
                 longitude = float(header_parts[7])
                 elevation = float(header_parts[8])
                 
+                # Parse DESIGN CONDITIONS
+                design_conditions = {}
+                for line in epw_lines:
+                    if line.startswith("DESIGN CONDITIONS"):
+                        parts = line.strip().split(',')
+                        design_conditions = {
+                            "heating": {
+                                "coldest_month": int(parts[3]),
+                                "dry_bulb": float(parts[4]),
+                                "mean_coincident_db": float(parts[5]),
+                                "humidification_db": float(parts[6]),
+                                "mean_coincident_wb": float(parts[7]),
+                                "wind_speed_1": float(parts[8]),
+                                "wind_direction_1": float(parts[9]),
+                                "wind_speed_2": float(parts[10]),
+                                "wind_direction_2": float(parts[11])
+                            },
+                            "cooling": {
+                                "hottest_month": int(parts[12]),
+                                "dry_bulb_0_4": float(parts[13]),
+                                "mean_coincident_wb_0_4": float(parts[14]),
+                                "wet_bulb_0_4": float(parts[15]),
+                                "mean_coincident_db_0_4": float(parts[16]),
+                                "dry_bulb_1_0": float(parts[17]),
+                                "mean_coincident_wb_1_0": float(parts[18]),
+                                "wet_bulb_1_0": float(parts[19]),
+                                "mean_coincident_db_1_0": float(parts[20]),
+                                "dry_bulb_2_0": float(parts[21]),
+                                "mean_coincident_wb_2_0": float(parts[22]),
+                                "wet_bulb_2_0": float(parts[23]),
+                                "mean_coincident_db_2_0": float(parts[24]),
+                                "evaporation_wb_0_4": float(parts[25]),
+                                "mean_coincident_db_wb_0_4": float(parts[26])
+                            },
+                            "extremes": {
+                                "annual_max_db": float(parts[27]),
+                                "mean_db": float(parts[28]),
+                                "std_dev_db": float(parts[29]),
+                                "min_db": float(parts[30]),
+                                "max_db_1": float(parts[31]),
+                                "min_db_1": float(parts[32]),
+                                "max_db_2": float(parts[33]),
+                                "min_db_2": float(parts[34]),
+                                "max_db_3": float(parts[35]),
+                                "min_db_3": float(parts[36]),
+                                "max_db_4": float(parts[37]),
+                                "min_db_4": float(parts[38]),
+                                "max_db_5": float(parts[39]),
+                                "min_db_5": float(parts[40])
+                            }
+                        }
+                        break
+                
                 # Parse TYPICAL/EXTREME PERIODS
                 typical_extreme_periods = {}
                 for line in epw_lines:
@@ -313,7 +403,9 @@ class ClimateData:
                             ]:
                                 key = f"{'summer' if 'Summer' in period_name else 'winter'}_{'extreme' if 'Max' in period_name else 'typical' if 'Average' in period_name else ''}"
                                 start_month, start_day = map(int, start_date.split('/'))
-                                end_month, end_day = map(int, end_date.replace(' ', '').split('/'))
+                                # Robustly handle spaces in end_date (e.g., "1/ 5")
+                                end_date_clean = re.sub(r'\s+', '', end_date)
+                                end_month, end_day = map(int, end_date_clean.split('/'))
                                 typical_extreme_periods[key] = {
                                     "start": {"month": start_month, "day": start_day},
                                     "end": {"month": end_month, "day": end_day}
@@ -351,6 +443,7 @@ class ClimateData:
                     epw_file=epw_data,
                     typical_extreme_periods=typical_extreme_periods,
                     ground_temperatures=ground_temperatures,
+                    design_conditions=design_conditions,
                     id=f"{country[:1].upper()}{city[:3].upper()}",
                     country=country,
                     state_province=state_province,
@@ -392,6 +485,7 @@ class ClimateData:
                 epw_file=epw_data,
                 typical_extreme_periods=climate_data_dict["typical_extreme_periods"],
                 ground_temperatures=climate_data_dict["ground_temperatures"],
+                design_conditions=climate_data_dict["design_conditions"],
                 id=climate_data_dict["id"],
                 country=climate_data_dict["country"],
                 state_province=climate_data_dict["state_province"],
@@ -437,7 +531,8 @@ class ClimateData:
         """Display design conditions for HVAC calculations using Markdown."""
         st.subheader("Design Conditions")
         
-        st.markdown(f"""
+        # Location Details
+        st.markdown("""
         **Location Details:**
         - **Country**: {location.country}
         - **City**: {location.city}
@@ -445,8 +540,11 @@ class ClimateData:
         - **Latitude**: {location.latitude}°
         - **Longitude**: {location.longitude}°
         - **Elevation**: {location.elevation} m
-
-        **Climate Parameters:**
+        """.format(location=location))
+        
+        # Calculated Climate Parameters
+        st.markdown("""
+        **Calculated Climate Parameters:**
         - **Climate Zone**: {location.climate_zone}
         - **Heating Degree Days (base 18°C)**: {location.heating_degree_days} HDD
         - **Cooling Degree Days (base 18°C)**: {location.cooling_degree_days} CDD
@@ -456,7 +554,42 @@ class ClimateData:
         - **Summer Daily Temperature Range**: {location.summer_daily_range} °C
         - **Mean Wind Speed**: {location.wind_speed} m/s
         - **Mean Atmospheric Pressure**: {location.pressure} Pa
-        """)
+        """.format(location=location))
+        
+        # EPW Header Design Conditions
+        if location.design_conditions:
+            st.markdown("**Design Conditions (EPW Header):**")
+            st.markdown("""
+            - **Heating:**
+              - Coldest Month: {location.design_conditions['heating']['coldest_month']}
+              - Dry-Bulb Temp: {location.design_conditions['heating']['dry_bulb']} °C
+              - Mean Coincident Dry-Bulb: {location.design_conditions['heating']['mean_coincident_db']} °C
+              - Humidification Dry-Bulb: {location.design_conditions['heating']['humidification_db']} °C
+              - Mean Coincident Wet-Bulb: {location.design_conditions['heating']['mean_coincident_wb']} °C
+            - **Cooling:**
+              - Hottest Month: {location.design_conditions['cooling']['hottest_month']}
+              - Dry-Bulb Temp (0.4%): {location.design_conditions['cooling']['dry_bulb_0_4']} °C
+              - Wet-Bulb Temp (0.4%): {location.design_conditions['cooling']['wet_bulb_0_4']} °C
+              - Mean Coincident Wet-Bulb (0.4%): {location.design_conditions['cooling']['mean_coincident_wb_0_4']} °C
+            - **Extremes:**
+              - Annual Max Dry-Bulb: {location.design_conditions['extremes']['annual_max_db']} °C
+              - Annual Min Dry-Bulb: {location.design_conditions['extremes']['min_db']} °C
+            """.format(location=location))
+        
+        # Typical/Extreme Periods
+        if location.typical_extreme_periods:
+            st.markdown("**Typical/Extreme Periods:**")
+            for key, period in location.typical_extreme_periods.items():
+                period_name = key.replace('_', ' ').title()
+                st.markdown(f"- **{period_name}**: {period['start']['month']}/{period['start']['day']} to {period['end']['month']}/{period['end']['day']}")
+        
+        # Ground Temperatures
+        if location.ground_temperatures:
+            st.markdown("**Ground Temperatures:**")
+            month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+            for depth, temps in location.ground_temperatures.items():
+                temp_str = ", ".join(f"{month}: {temp:.2f}°C" for month, temp in zip(month_names, temps))
+                st.markdown(f"- **Depth {depth}m**: {temp_str}")
 
     @staticmethod
     def assign_climate_zone(hdd: float, cdd: float, avg_humidity: float) -> str:
@@ -773,6 +906,7 @@ class ClimateData:
                 epw_file=epw_data,
                 typical_extreme_periods=loc_dict["typical_extreme_periods"],
                 ground_temperatures=loc_dict["ground_temperatures"],
+                design_conditions=loc_dict["design_conditions"],
                 id=loc_dict["id"],
                 country=loc_dict["country"],
                 state_province=loc_dict["state_province"],