Update data/climate_data.py

data/climate_data.py

@@ -1,68 +1,4 @@
-"""
-ASHRAE 169 climate data module for HVAC Load Calculator.
-This module provides access to climate data for various locations based on ASHRAE 169 standard.
-
-Author: Dr Majed Abuseif
-Date: March 2025
-Version: 1.0.0
-"""
-
-from typing import Dict, List, Any, Optional, Tuple
-import pandas as pd
-import numpy as np
-import os
-import json
-from dataclasses import dataclass
-import streamlit as st
-import plotly.graph_objects as go
-from io import StringIO
-
-# Define paths
-DATA_DIR = os.path.dirname(os.path.abspath(__file__))
-
-
-@dataclass
-class ClimateLocation:
-    """Class representing a climate location with ASHRAE 169 data."""
-    
-    id: str
-    country: str
-    state_province: str
-    city: str
-    latitude: float
-    longitude: float
-    elevation: float  # meters
-    climate_zone: str
-    heating_degree_days: float  # base 18°C
-    cooling_degree_days: float  # base 18°C
-    winter_design_temp: float  # 99.6% heating design temperature (°C)
-    summer_design_temp_db: float  # 0.4% cooling design dry-bulb temperature (°C)
-    summer_design_temp_wb: float  # 0.4% cooling design wet-bulb temperature (°C)
-    summer_daily_range: float  # Mean daily temperature range in summer (°C)
-    monthly_temps: Dict[str, float]  # Average monthly temperatures (°C)
-    monthly_humidity: Dict[str, float]  # Average monthly relative humidity (%)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Convert the climate location to a dictionary."""
-        return {
-            "id": self.id,
-            "country": self.country,
-            "state_province": self.state_province,
-            "city": self.city,
-            "latitude": self.latitude,
-            "longitude": self.longitude,
-            "elevation": self.elevation,
-            "climate_zone": self.climate_zone,
-            "heating_degree_days": self.heating_degree_days,
-            "cooling_degree_days": self.cooling_degree_days,
-            "winter_design_temp": self.winter_design_temp,
-            "summer_design_temp_db": self.summer_design_temp_db,
-            "summer_design_temp_wb": self.summer_design_temp_wb,
-            "summer_daily_range": self.summer_daily_range,
-            "monthly_temps": self.monthly_temps,
-            "monthly_humidity": self.monthly_humidity
-        }
-
+# ... (Previous imports and ClimateLocation class unchanged) ...
 
 class ClimateData:
     """Class for managing ASHRAE 169 climate data."""
@@ -93,47 +29,6 @@ class ClimateData:
         self.countries = sorted(list(set(loc.country for loc in self.locations.values())))
         self.country_states = self._group_locations_by_country_state()
 
-    def _infer_epw_columns(self, epw_data: pd.DataFrame) -> Dict[str, int]:
-        """Infer column indices for key weather parameters based on data ranges."""
-        column_map = {}
-        for col in epw_data.columns:
-            values = pd.to_numeric(epw_data[col], errors='coerce')
-            if values.isna().all():
-                continue  # Skip if all values are NaN
-            mean_val = np.nanmean(values)
-            min_val = np.nanmin(values)
-            max_val = np.nanmax(values)
-
-            # Dry Bulb Temperature (°C): -50 to 50°C
-            if -50 <= min_val <= max_val <= 50 and col not in column_map:
-                column_map["dry_bulb"] = col
-            # Wet Bulb Temperature (°C): -50 to 40°C
-            elif -50 <= min_val <= max_val <= 40 and col not in column_map:
-                column_map["wet_bulb"] = col
-            # Relative Humidity (%): 0 to 100%
-            elif 0 <= min_val <= max_val <= 100 and col not in column_map:
-                column_map["humidity"] = col
-            # Atmospheric Pressure (Pa): 80000 to 105000 Pa
-            elif 80000 <= min_val <= max_val <= 105000 and col not in column_map:
-                column_map["pressure"] = col
-
-        # Standard EPW column indices as fallback
-        standard_map = {
-            "dry_bulb": 6,
-            "wet_bulb": 8,
-            "humidity": 21,
-            "pressure": 9
-        }
-
-        for key in standard_map:
-            if key not in column_map:
-                st.warning(f"Could not infer {key} column. Using standard EPW index {standard_map[key]}.")
-                column_map[key] = standard_map[key]
-            elif column_map[key] != standard_map[key]:
-                st.warning(f"Inferred {key} column ({column_map[key]}) differs from standard EPW ({standard_map[key]}). Proceeding with inferred column.")
-
-        return column_map
-
     def display_climate_input(self, session_state: Dict[str, Any]):
         """Display form for manual input or EPW upload in Streamlit."""
         st.title("Climate Data")
@@ -146,7 +41,7 @@ class ClimateData:
         st.subheader(f"Location: {session_state.building_info['country']}, {session_state.building_info['city']}")
         tab1, tab2 = st.tabs(["Manual Input", "Upload EPW File"])
         
-        # Manual Input Tab
+        # Manual Input Tab (unchanged)
         with tab1:
             with st.form("manual_climate_form"):
                 col1, col2 = st.columns(2)
@@ -218,49 +113,48 @@ class ClimateData:
                     epw_lines = epw_content.splitlines()
                     header = next(line for line in epw_lines if line.startswith("LOCATION"))
                     header_parts = header.split(",")
-                    latitude = float(header_parts[6])
-                    longitude = float(header_parts[7])
-                    elevation = float(header_parts[8])
+                    latitude = float(header_parts[6])  # 64.13
+                    longitude = float(header_parts[7])  # -21.90
+                    elevation = float(header_parts[8])  # 61.0
                     
-                    # Load EPW data as strings first, then convert
-                    epw_data = pd.read_csv(StringIO("\n".join(epw_lines[8:])), header=None, dtype=str)
+                    # Load data starting after "DATA PERIODS"
+                    data_start_idx = epw_lines.index("DATA PERIODS,1,1,Data,Sunday, 1/ 1,12/31") + 1
+                    epw_data = pd.read_csv(StringIO("\n".join(epw_lines[data_start_idx:])), header=None, dtype=str)
                     if len(epw_data) != 8760:
                         raise ValueError(f"EPW file has {len(epw_data)} records, expected 8760.")
-                    
+
                     # Convert all columns to numeric, coercing errors to NaN
                     for col in epw_data.columns:
                         epw_data[col] = pd.to_numeric(epw_data[col], errors='coerce')
                     
-                    # Debugging: Show NaN counts
-                    nan_counts = epw_data.isna().sum()
+                    # Check for NaN in critical columns
+                    critical_cols = {6: "Dry Bulb", 8: "Wet Bulb", 21: "Humidity", 1: "Month"}
+                    nan_counts = epw_data[[col for col in critical_cols]].isna().sum()
                     if nan_counts.max() > 0:
-                        st.warning(f"NaN values detected in columns: {nan_counts[nan_counts > 0].to_dict()}")
+                        st.warning(f"NaN values detected: {nan_counts[nan_counts > 0].to_dict()}")
 
-                    # Infer column indices
-                    column_map = self._infer_epw_columns(epw_data)
-                    
-                    # Extract and validate data
-                    months = epw_data[1].values.astype(float)
-                    dry_bulb = epw_data[column_map["dry_bulb"]].values.astype(float)
-                    wet_bulb = epw_data[column_map["wet_bulb"]].values.astype(float)
-                    humidity = epw_data[column_map["humidity"]].values.astype(float)
+                    # Extract data using fixed EPW column indices
+                    months = epw_data[1].values  # Month
+                    dry_bulb = epw_data[6].values  # Dry Bulb Temperature (°C)
+                    wet_bulb = epw_data[8].values  # Wet Bulb Temperature (°C)
+                    humidity = epw_data[21].values  # Relative Humidity (%)
                     
                     if np.all(np.isnan(dry_bulb)) or np.all(np.isnan(humidity)):
-                        raise ValueError("Critical columns (dry bulb or humidity) are entirely NaN.")
+                        raise ValueError("Dry bulb or humidity data is entirely NaN.")
 
-                    # Calculate daily averages for HDD/CDD
+                    # Calculate HDD and CDD (base 18°C)
                     daily_temps = np.nanmean(dry_bulb.reshape(-1, 24), axis=1)
-                    hdd = round(sum(max(18 - temp, 0) for temp in daily_temps if not np.isnan(temp)))
-                    cdd = round(sum(max(temp - 18, 0) for temp in daily_temps if not np.isnan(temp)))
+                    hdd = round(np.nansum(np.maximum(18 - daily_temps, 0)))
+                    cdd = round(np.nansum(np.maximum(daily_temps - 18, 0)))
                     
-                    # Design conditions with NaN handling
+                    # Design conditions
                     winter_design_temp = round(np.nanpercentile(dry_bulb, 0.4), 1)
                     summer_design_temp_db = round(np.nanpercentile(dry_bulb, 99.6), 1)
                     summer_idx = np.argmax(dry_bulb >= summer_design_temp_db)
                     summer_design_temp_wb = round(wet_bulb[summer_idx], 1) if not np.isnan(wet_bulb[summer_idx]) else 25.0
                     summer_mask = (months >= 6) & (months <= 8)
                     summer_temps = dry_bulb[summer_mask].reshape(-1, 24)
-                    summer_daily_range = round(np.nanmean(summer_temps.max(axis=1) - summer_temps.min(axis=1)), 1)
+                    summer_daily_range = round(np.nanmean(np.nanmax(summer_temps, axis=1) - np.nanmin(summer_temps, axis=1)), 1)
                     
                     # Monthly averages
                     monthly_temps = {}
@@ -295,7 +189,7 @@ class ClimateData:
                     self.add_location(location)
                     st.success("Climate data extracted from EPW file!")
                     self.display_design_conditions(location)
-                    self.visualize_data(location, epw_data=epw_data, column_map=column_map)
+                    self.visualize_data(location, epw_data=epw_data)
                 except Exception as e:
                     st.error(f"Error processing EPW file: {str(e)}. Ensure it has 8760 hourly records and correct format.")
 
@@ -309,54 +203,7 @@ class ClimateData:
             else:
                 st.button("Continue to Building Components", disabled=True)
 
-    def display_design_conditions(self, location: ClimateLocation):
-        """Display a table of design conditions for calculations."""
-        st.subheader("Design Conditions for HVAC Calculations")
-        design_data = pd.DataFrame({
-            "Parameter": [
-                "Climate Zone",
-                "Heating Degree Days (base 18°C)",
-                "Cooling Degree Days (base 18°C)",
-                "Winter Design Temperature (99.6%)",
-                "Summer Design Dry-Bulb Temp (0.4%)",
-                "Summer Design Wet-Bulb Temp (0.4%)",
-                "Summer Daily Temperature Range"
-            ],
-            "Value": [
-                location.climate_zone,
-                f"{location.heating_degree_days} HDD",
-                f"{location.cooling_degree_days} CDD",
-                f"{location.winter_design_temp} °C",
-                f"{location.summer_design_temp_db} °C",
-                f"{location.summer_design_temp_wb} °C",
-                f"{location.summer_daily_range} °C"
-            ]
-        })
-        st.table(design_data)
-
-    @staticmethod
-    def assign_climate_zone(hdd: float, cdd: float, avg_humidity: float) -> str:
-        """Assign ASHRAE 169 climate zone based on HDD, CDD, and humidity."""
-        if cdd > 10000:
-            return "0A" if avg_humidity > 60 else "0B"
-        elif cdd > 5000:
-            return "1A" if avg_humidity > 60 else "1B"
-        elif cdd > 2500:
-            return "2A" if avg_humidity > 60 else "2B"
-        elif hdd < 2000 and cdd > 1000:
-            return "3A" if avg_humidity > 60 else "3B" if avg_humidity < 40 else "3C"
-        elif hdd < 3000:
-            return "4A" if avg_humidity > 60 else "4B" if avg_humidity < 40 else "4C"
-        elif hdd < 4000:
-            return "5A" if avg_humidity > 60 else "5B" if avg_humidity < 40 else "5C"
-        elif hdd < 5000:
-            return "6A" if avg_humidity > 60 else "6B"
-        elif hdd < 7000:
-            return "7"
-        else:
-            return "8"
-
-    def visualize_data(self, location: ClimateLocation, epw_data: Optional[pd.DataFrame] = None, column_map: Optional[Dict[str, int]] = None):
+    def visualize_data(self, location: ClimateLocation, epw_data: Optional[pd.DataFrame] = None):
         """Visualize monthly temperature and humidity data with min, max, and average."""
         st.subheader("Monthly Climate Data Visualization")
         
@@ -365,10 +212,10 @@ class ClimateData:
         temps_avg = [location.monthly_temps[m] for m in month_names]
         humidity_avg = [location.monthly_humidity[m] for m in month_names]
         
-        if epw_data is not None and column_map is not None:
-            dry_bulb = epw_data[column_map["dry_bulb"]].values.astype(float)
-            humidity = epw_data[column_map["humidity"]].values.astype(float)
-            month_col = epw_data[1].values.astype(float)
+        if epw_data is not None:
+            dry_bulb = epw_data[6].values
+            humidity = epw_data[21].values
+            month_col = epw_data[1].values
             
             temps_min = []
             temps_max = []
@@ -460,29 +307,11 @@ class ClimateData:
         )
         st.plotly_chart(fig_hum, use_container_width=True)
 
-    def export_to_json(self, file_path: str) -> None:
-        """Export all climate data to a JSON file."""
-        data = {loc_id: loc.to_dict() for loc_id, loc in self.locations.items()}
-        with open(file_path, 'w') as f:
-            json.dump(data, f, indent=4)
-
-    @classmethod
-    def from_json(cls, file_path: str) -> 'ClimateData':
-        """Create a ClimateData instance from a JSON file."""
-        with open(file_path, 'r') as f:
-            data = json.load(f)
-        climate_data = cls()
-        climate_data.locations = {}
-        for loc_id, loc_dict in data.items():
-            climate_data.locations[loc_id] = ClimateLocation(**loc_dict)
-        climate_data.countries = sorted(list(set(loc.country for loc in climate_data.locations.values())))
-        climate_data.country_states = climate_data._group_locations_by_country_state()
-        return climate_data
-
+    # ... (Other methods like display_design_conditions, assign_climate_zone unchanged) ...
 
 if __name__ == "__main__":
     if "building_info" not in st.session_state:
-        st.session_state.building_info = {"country": "Australia", "city": "Melbourne"}
+        st.session_state.building_info = {"country": "Iceland", "city": "Reykjavik"}
     if "page" not in st.session_state:
         st.session_state.page = "Climate Data"