Update data/climate_data.py

data/climate_data.py

@@ -4,7 +4,7 @@ Extracts climate data from EPW files and provides visualizations inspired by Cli
 
 Author: Dr Majed Abuseif
 Date: May 2025
-Version: 2.1.1
+Version: 2.1.2
 """
 
 from typing import Dict, List, Any, Optional
@@ -23,6 +23,24 @@ import re
 # Define paths
 DATA_DIR = os.path.dirname(os.path.abspath(__file__))
 
+# CSS for consistent formatting
+STYLE = """
+<style>
+.markdown-text {
+    font-family: Roboto, sans-serif;
+    font-size: 14px;
+    line-height: 1.5;
+}
+.markdown-text ul {
+    margin-top: 0;
+    margin-bottom: 10px;
+}
+.markdown-text li {
+    margin-bottom: 5px;
+}
+</style>
+"""
+
 @dataclass
 class ClimateLocation:
     """Class representing a climate location with ASHRAE 169 data derived from EPW files."""
@@ -258,8 +276,9 @@ class ClimateData:
         # 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")
+            missing_periods = [p for p in expected_periods if p not in data["typical_extreme_periods"]]
+            if missing_periods:
+                st.warning(f"Validation warning: Missing typical/extreme periods: {', '.join(missing_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):
@@ -309,6 +328,9 @@ class ClimateData:
         """Display Streamlit interface for EPW upload and visualizations."""
         st.title("Climate Data Analysis")
         
+        # Apply consistent styling
+        st.markdown(STYLE, unsafe_allow_html=True)
+        
         # Clear invalid session_state["climate_data"] to prevent validation errors
         if "climate_data" in session_state and not all(key in session_state["climate_data"] for key in ["id", "country", "city"]):
             st.warning("Clearing invalid climate data from session state.")
@@ -342,55 +364,96 @@ class ClimateData:
                     if line.startswith("DESIGN CONDITIONS"):
                         parts = line.strip().split(',')
                         if len(parts) < 41:
-                            st.warning("Incomplete DESIGN CONDITIONS data, skipping parsing.")
+                            st.warning(f"DESIGN CONDITIONS has {len(parts)} fields, expected 41. Skipping parsing.")
                             break
                         try:
                             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])
-                                }
+                                "heating": {},
+                                "cooling": {},
+                                "extremes": {}
                             }
+                            # Heating section
+                            if parts[3] and parts[3].strip():
+                                design_conditions["heating"]["coldest_month"] = int(parts[3])
+                            if parts[4] and parts[4].strip():
+                                design_conditions["heating"]["dry_bulb"] = float(parts[4])
+                            if parts[5] and parts[5].strip():
+                                design_conditions["heating"]["mean_coincident_db"] = float(parts[5])
+                            if parts[6] and parts[6].strip():
+                                design_conditions["heating"]["humidification_db"] = float(parts[6])
+                            if parts[7] and parts[7].strip():
+                                design_conditions["heating"]["mean_coincident_wb"] = float(parts[7])
+                            if parts[8] and parts[8].strip():
+                                design_conditions["heating"]["wind_speed_1"] = float(parts[8])
+                            if parts[9] and parts[9].strip():
+                                design_conditions["heating"]["wind_direction_1"] = float(parts[9])
+                            if parts[10] and parts[10].strip():
+                                design_conditions["heating"]["wind_speed_2"] = float(parts[10])
+                            if parts[11] and parts[11].strip():
+                                design_conditions["heating"]["wind_direction_2"] = float(parts[11])
+                            # Cooling section
+                            if parts[12] and parts[12].strip():
+                                design_conditions["cooling"]["hottest_month"] = int(parts[12])
+                            if parts[13] and parts[13].strip():
+                                design_conditions["cooling"]["dry_bulb_0_4"] = float(parts[13])
+                            if parts[14] and parts[14].strip():
+                                design_conditions["cooling"]["mean_coincident_wb_0_4"] = float(parts[14])
+                            if parts[15] and parts[15].strip():
+                                design_conditions["cooling"]["wet_bulb_0_4"] = float(parts[15])
+                            if parts[16] and parts[16].strip():
+                                design_conditions["cooling"]["mean_coincident_db_0_4"] = float(parts[16])
+                            if parts[17] and parts[17].strip():
+                                design_conditions["cooling"]["dry_bulb_1_0"] = float(parts[17])
+                            if parts[18] and parts[18].strip():
+                                design_conditions["cooling"]["mean_coincident_wb_1_0"] = float(parts[18])
+                            if parts[19] and parts[19].strip():
+                                design_conditions["cooling"]["wet_bulb_1_0"] = float(parts[19])
+                            if parts[20] and parts[20].strip():
+                                design_conditions["cooling"]["mean_coincident_db_1_0"] = float(parts[20])
+                            if parts[21] and parts[21].strip():
+                                design_conditions["cooling"]["dry_bulb_2_0"] = float(parts[21])
+                            if parts[22] and parts[22].strip():
+                                design_conditions["cooling"]["mean_coincident_wb_2_0"] = float(parts[22])
+                            if parts[23] and parts[23].strip():
+                                design_conditions["cooling"]["wet_bulb_2_0"] = float(parts[23])
+                            if parts[24] and parts[24].strip():
+                                design_conditions["cooling"]["mean_coincident_db_2_0"] = float(parts[24])
+                            if parts[25] and parts[25].strip():
+                                design_conditions["cooling"]["evaporation_wb_0_4"] = float(parts[25])
+                            if parts[26] and parts[26].strip():
+                                design_conditions["cooling"]["mean_coincident_db_wb_0_4"] = float(parts[26])
+                            # Extremes section
+                            if parts[27] and parts[27].strip():
+                                design_conditions["extremes"]["annual_max_db"] = float(parts[27])
+                            if parts[28] and parts[28].strip():
+                                design_conditions["extremes"]["mean_db"] = float(parts[28])
+                            if parts[29] and parts[29].strip():
+                                design_conditions["extremes"]["std_dev_db"] = float(parts[29])
+                            if parts[30] and parts[30].strip():
+                                design_conditions["extremes"]["min_db"] = float(parts[30])
+                            if parts[31] and parts[31].strip():
+                                design_conditions["extremes"]["max_db_1"] = float(parts[31])
+                            if parts[32] and parts[32].strip():
+                                design_conditions["extremes"]["min_db_1"] = float(parts[32])
+                            if parts[33] and parts[33].strip():
+                                design_conditions["extremes"]["max_db_2"] = float(parts[33])
+                            if parts[34] and parts[34].strip():
+                                design_conditions["extremes"]["min_db_2"] = float(parts[34])
+                            if parts[35] and parts[35].strip():
+                                design_conditions["extremes"]["max_db_3"] = float(parts[35])
+                            if parts[36] and parts[36].strip():
+                                design_conditions["extremes"]["min_db_3"] = float(parts[36])
+                            if parts[37] and parts[37].strip():
+                                design_conditions["extremes"]["max_db_4"] = float(parts[37])
+                            if parts[38] and parts[38].strip():
+                                design_conditions["extremes"]["min_db_4"] = float(parts[38])
+                            if parts[39] and parts[39].strip():
+                                design_conditions["extremes"]["max_db_5"] = float(parts[39])
+                            if parts[40] and parts[40].strip():
+                                design_conditions["extremes"]["min_db_5"] = float(parts[40])
+                            if not design_conditions["heating"] and not design_conditions["cooling"] and not design_conditions["extremes"]:
+                                design_conditions = {}
+                                st.warning("No valid DESIGN CONDITIONS fields parsed.")
                         except (ValueError, IndexError) as e:
                             st.warning(f"Error parsing DESIGN CONDITIONS: {str(e)}. Using empty design conditions.")
                             design_conditions = {}
@@ -398,7 +461,7 @@ class ClimateData:
                 
                 # Parse TYPICAL/EXTREME PERIODS
                 typical_extreme_periods = {}
-                date_pattern = r'^\d{1,2}/\d{1,2}$'
+                date_pattern = r'^\d{1,2}\s*/\s*\d{1,2}$'
                 for line in epw_lines:
                     if line.startswith("TYPICAL/EXTREME PERIODS"):
                         parts = line.strip().split(',')
@@ -409,10 +472,13 @@ class ClimateData:
                             break
                         for i in range(num_periods):
                             try:
+                                if len(parts) < 2 + i*4 + 4:
+                                    st.warning(f"Insufficient fields for period {i+1}, skipping.")
+                                    continue
                                 period_name = parts[2 + i*4]
                                 period_type = parts[3 + i*4]
-                                start_date = parts[4 + i*4]
-                                end_date = parts[5 + i*4]
+                                start_date = parts[4 + i*4].strip()
+                                end_date = parts[5 + i*4].strip()
                                 if period_name in [
                                     "Summer - Week Nearest Max Temperature For Period",
                                     "Summer - Week Nearest Average Temperature For Period",
@@ -420,11 +486,15 @@ class ClimateData:
                                     "Winter - Week Nearest Average Temperature For Period"
                                 ]:
                                     key = f"{'summer' if 'Summer' in period_name else 'winter'}_{'extreme' if 'Max' in period_name else 'typical' if 'Average' in period_name else ''}"
-                                    if not re.match(date_pattern, start_date) or not re.match(date_pattern, end_date.replace(' ', '')):
+                                    # Clean dates to remove non-standard whitespace
+                                    start_date_clean = re.sub(r'\s+', '', start_date)
+                                    end_date_clean = re.sub(r'\s+', '', end_date)
+                                    # Debug logging
+                                    st.write(f"Parsing period {period_name}: start_date='{start_date_clean}', end_date='{end_date_clean}'")
+                                    if not re.match(date_pattern, start_date) or not re.match(date_pattern, end_date):
                                         st.warning(f"Invalid date format for period {period_name}: {start_date} to {end_date}, skipping.")
                                         continue
-                                    start_month, start_day = map(int, start_date.split('/'))
-                                    end_date_clean = re.sub(r'\s+', '', end_date)
+                                    start_month, start_day = map(int, start_date_clean.split('/'))
                                     end_month, end_day = map(int, end_date_clean.split('/'))
                                     typical_extreme_periods[key] = {
                                         "start": {"month": start_month, "day": start_day},
@@ -447,8 +517,14 @@ class ClimateData:
                             break
                         for i in range(num_depths):
                             try:
+                                if len(parts) < 2 + i*16 + 16:
+                                    st.warning(f"Insufficient fields for ground temperature depth {i+1}, skipping.")
+                                    continue
                                 depth = parts[2 + i*16]
-                                temps = [float(t) for t in parts[6 + i*16:18 + i*16]]
+                                temps = [float(t) for t in parts[6 + i*16:18 + i*16] if t.strip()]
+                                if len(temps) != 12:
+                                    st.warning(f"Invalid number of temperatures for depth {depth}m, expected 12, got {len(temps)}, skipping.")
+                                    continue
                                 ground_temperatures[depth] = temps
                             except (ValueError, IndexError) as e:
                                 st.warning(f"Error parsing ground temperatures for depth {i+1}: {str(e)}, skipping.")
@@ -563,7 +639,8 @@ class ClimateData:
         st.subheader("Design Conditions")
         
         # Location Details
-        st.markdown("""
+        st.markdown(f"""
+        <div class="markdown-text">
         **Location Details:**
         - **Country**: {location.country}
         - **City**: {location.city}
@@ -571,10 +648,12 @@ class ClimateData:
         - **Latitude**: {location.latitude}°
         - **Longitude**: {location.longitude}°
         - **Elevation**: {location.elevation} m
-        """.format(location=location))
+        </div>
+        """, unsafe_allow_html=True)
         
         # Calculated Climate Parameters
-        st.markdown("""
+        st.markdown(f"""
+        <div class="markdown-text">
         **Calculated Climate Parameters:**
         - **Climate Zone**: {location.climate_zone}
         - **Heating Degree Days (base 18°C)**: {location.heating_degree_days} HDD
@@ -585,42 +664,64 @@ 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))
+        </div>
+        """, unsafe_allow_html=True)
         
         # EPW Header Design Conditions
         if location.design_conditions:
-            st.markdown("**Design Conditions (EPW Header):**")
-            st.markdown("""
+            heating_items = [
+                f"- Coldest Month: {location.design_conditions['heating'].get('coldest_month', 'N/A')}",
+                f"- Dry-Bulb Temp: {location.design_conditions['heating'].get('dry_bulb', 'N/A')} °C",
+                f"- Mean Coincident Dry-Bulb: {location.design_conditions['heating'].get('mean_coincident_db', 'N/A')} °C",
+                f"- Humidification Dry-Bulb: {location.design_conditions['heating'].get('humidification_db', 'N/A')} °C",
+                f"- Mean Coincident Wet-Bulb: {location.design_conditions['heating'].get('mean_coincident_wb', 'N/A')} °C"
+            ]
+            cooling_items = [
+                f"- Hottest Month: {location.design_conditions['cooling'].get('hottest_month', 'N/A')}",
+                f"- Dry-Bulb Temp (0.4%): {location.design_conditions['cooling'].get('dry_bulb_0_4', 'N/A')} °C",
+                f"- Wet-Bulb Temp (0.4%): {location.design_conditions['cooling'].get('wet_bulb_0_4', 'N/A')} °C",
+                f"- Mean Coincident Wet-Bulb (0.4%): {location.design_conditions['cooling'].get('mean_coincident_wb_0_4', 'N/A')} °C"
+            ]
+            extremes_items = [
+                f"- Annual Max Dry-Bulb: {location.design_conditions['extremes'].get('annual_max_db', 'N/A')} °C",
+                f"- Annual Min Dry-Bulb: {location.design_conditions['extremes'].get('min_db', 'N/A')} °C"
+            ]
+            st.markdown(f"""
+            <div class="markdown-text">
+            **Design Conditions (EPW Header):**
             - **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
+              {'<br>'.join(heating_items)}
             - **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
+              {'<br>'.join(cooling_items)}
             - **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))
+              {'<br>'.join(extremes_items)}
+            </div>
+            """, unsafe_allow_html=True)
         
         # 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']}")
+            period_items = [
+                f"- **{key.replace('_', ' ').title()}**: {period['start']['month']}/{period['start']['day']} to {period['end']['month']}/{period['end']['day']}"
+                for key, period in location.typical_extreme_periods.items()
+            ]
+            st.markdown(f"""
+            <div class="markdown-text">
+            **Typical/Extreme Periods:**
+            {'<br>'.join(period_items)}
+            </div>
+            """, unsafe_allow_html=True)
         
-        # Ground Temperatures
+        # Ground Temperatures (Table)
         if location.ground_temperatures:
-            st.markdown("**Ground Temperatures:**")
+            st.markdown('<div class="markdown-text">**Ground Temperatures:**</div>', unsafe_allow_html=True)
             month_names = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+            table_data = []
             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}")
+                row = {"Depth (m)": float(depth)}
+                row.update({month: f"{temp:.2f}" for month, temp in zip(month_names, temps)})
+                table_data.append(row)
+            df = pd.DataFrame(table_data)
+            st.dataframe(df, use_container_width=True)
 
     @staticmethod
     def assign_climate_zone(hdd: float, cdd: float, avg_humidity: float) -> str:
@@ -660,7 +761,7 @@ class ClimateData:
         vapor_pressure = humidity / 100 * saturation_pressure
         humidity_ratio = 0.62198 * vapor_pressure / (pressure - vapor_pressure) * 1000  # Convert to g/kg
         
-        fig = go.Figure()
+        figastanza = go.Figure()
         
         # Hourly data points
         fig.add_trace(go.Scatter(