Update data/climate_data.py

data/climate_data.py

@@ -41,11 +41,13 @@ class ClimateLocation:
     summer_design_temp_wb: float  # 0.4% cooling design wet-bulb temperature (°C)
     summer_daily_range: float  # Mean daily temperature range in summer (°C)
     wind_speed: float  # Mean wind speed (m/s)
-    pressure: float  # Atmospheric pressure (Pa)
+    pressure: float  # Mean atmospheric pressure (Pa)
     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
     
-    def __init__(self, epw_file: pd.DataFrame, **kwargs):
-        """Initialize ClimateLocation with EPW file data."""
+    def __init__(self, epw_file: pd.DataFrame, typical_extreme_periods: Dict, ground_temperatures: Dict, **kwargs):
+        """Initialize ClimateLocation with EPW file data and header information."""
         self.id = kwargs.get("id")
         self.country = kwargs.get("country")
         self.state_province = kwargs.get("state_province", "N/A")
@@ -53,44 +55,63 @@ class ClimateLocation:
         self.latitude = kwargs.get("latitude")
         self.longitude = kwargs.get("longitude")
         self.elevation = kwargs.get("elevation")
+        self.typical_extreme_periods = typical_extreme_periods
+        self.ground_temperatures = ground_temperatures
         
+        # Extract columns from EPW data
         months = pd.to_numeric(epw_file[1], errors='coerce').values
+        days = pd.to_numeric(epw_file[2], errors='coerce').values
+        hours = pd.to_numeric(epw_file[3], errors='coerce').values
         dry_bulb = pd.to_numeric(epw_file[6], errors='coerce').values
         humidity = pd.to_numeric(epw_file[8], errors='coerce').values
         pressure = pd.to_numeric(epw_file[9], errors='coerce').values
-        wind_speed = pd.to_numeric(epw_file[21], errors='coerce').values
-        wind_direction = pd.to_numeric(epw_file[20], errors='coerce').values
         global_radiation = pd.to_numeric(epw_file[13], errors='coerce').values
+        wind_direction = pd.to_numeric(epw_file[20], errors='coerce').values
+        wind_speed = pd.to_numeric(epw_file[21], errors='coerce').values
         
+        # Calculate wet-bulb temperature
         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(wet_bulb, 99.6), 1)
         
+        # Calculate degree days
         daily_temps = np.nanmean(dry_bulb.reshape(-1, 24), axis=1)
         self.heating_degree_days = round(np.nansum(np.maximum(18 - daily_temps, 0)))
         self.cooling_degree_days = round(np.nansum(np.maximum(daily_temps - 18, 0)))
         
+        # Calculate summer daily temperature range (June–August, Southern Hemisphere)
         summer_mask = (months >= 6) & (months <= 8)
         summer_temps = dry_bulb[summer_mask].reshape(-1, 24)
         self.summer_daily_range = round(np.nanmean(np.nanmax(summer_temps, axis=1) - np.nanmin(summer_temps, axis=1)), 1)
         
+        # Calculate mean wind speed and pressure
         self.wind_speed = round(np.nanmean(wind_speed), 1)
         self.pressure = round(np.nanmean(pressure), 1)
+        
+        # Assign climate zone
         self.climate_zone = ClimateData.assign_climate_zone(self.heating_degree_days, self.cooling_degree_days, np.nanmean(humidity))
         
-        # Store hourly data for main.py integration
+        # Store hourly data with enhanced fields
         self.hourly_data = [
             {
                 "month": int(months[i]),
-                "hour": i % 24,
+                "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])
-            } for i in range(len(months)) if not any(np.isnan([months[i], dry_bulb[i], humidity[i], global_radiation[i], wind_speed[i], wind_direction[i]]))
+            }
+            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]
+            ]))
         ]
 
     def to_dict(self) -> Dict[str, Any]:
@@ -112,7 +133,9 @@ class ClimateLocation:
             "summer_daily_range": self.summer_daily_range,
             "wind_speed": self.wind_speed,
             "pressure": self.pressure,
-            "hourly_data": self.hourly_data
+            "hourly_data": self.hourly_data,
+            "typical_extreme_periods": self.typical_extreme_periods,
+            "ground_temperatures": self.ground_temperatures
         }
 
 class ClimateData:
@@ -159,7 +182,8 @@ 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"
+            "summer_daily_range", "wind_speed", "pressure", "hourly_data",
+            "typical_extreme_periods", "ground_temperatures"
         ]
         
         for field in required_fields:
@@ -182,18 +206,24 @@ class ClimateData:
             return False
         if not (0 <= data["wind_speed"] <= 20):
             return False
-        if not (50000 <= data["pressure"] <= 120000):
+        if not (80000 <= data["pressure"] <= 110000):
             return False
         
         if not data["hourly_data"] or len(data["hourly_data"]) != 8760:
             return False
         for record in data["hourly_data"]:
-            if not (1 <= record["month"] <= 12 and 0 <= record["hour"] <= 23):
+            if not (1 <= record["month"] <= 12):
+                return False
+            if not (1 <= record["day"] <= 31):
+                return False
+            if not (1 <= record["hour"] <= 24):
                 return False
             if not (-50 <= record["dry_bulb"] <= 50):
                 return False
             if not (0 <= record["relative_humidity"] <= 100):
                 return False
+            if not (80000 <= record["atmospheric_pressure"] <= 110000):
+                return False
             if not (0 <= record["global_horizontal_radiation"] <= 1200):
                 return False
             if not (0 <= record["wind_speed"] <= 20):
@@ -201,6 +231,22 @@ class ClimateData:
             if not (0 <= record["wind_direction"] <= 360):
                 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):
+                    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
+        
         return True
 
     @staticmethod
@@ -237,6 +283,8 @@ class ClimateData:
                 # Process new EPW file
                 epw_content = uploaded_file.read().decode("utf-8")
                 epw_lines = epw_content.splitlines()
+                
+                # Parse header
                 header = next(line for line in epw_lines if line.startswith("LOCATION"))
                 header_parts = header.split(",")
                 city = header_parts[1].strip()
@@ -246,6 +294,45 @@ class ClimateData:
                 longitude = float(header_parts[7])
                 elevation = float(header_parts[8])
                 
+                # Parse TYPICAL/EXTREME PERIODS
+                typical_extreme_periods = {}
+                for line in epw_lines:
+                    if line.startswith("TYPICAL/EXTREME PERIODS"):
+                        parts = line.strip().split(',')
+                        num_periods = int(parts[1])
+                        for i in range(num_periods):
+                            period_name = parts[2 + i*4]
+                            period_type = parts[3 + i*4]
+                            start_date = parts[4 + i*4]
+                            end_date = parts[5 + i*4]
+                            if period_name in [
+                                "Summer - Week Nearest Max Temperature For Period",
+                                "Summer - Week Nearest Average Temperature For Period",
+                                "Winter - Week Nearest Min Temperature For Period",
+                                "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 ''}"
+                                start_month, start_day = map(int, start_date.split('/'))
+                                end_month, end_day = map(int, end_date.replace(' ', '').split('/'))
+                                typical_extreme_periods[key] = {
+                                    "start": {"month": start_month, "day": start_day},
+                                    "end": {"month": end_month, "day": end_day}
+                                }
+                        break
+                
+                # Parse GROUND TEMPERATURES
+                ground_temperatures = {}
+                for line in epw_lines:
+                    if line.startswith("GROUND TEMPERATURES"):
+                        parts = line.strip().split(',')
+                        num_depths = int(parts[1])
+                        for i in range(num_depths):
+                            depth = parts[2 + i*16]
+                            temps = [float(t) for t in parts[6 + i*16:18 + i*16]]
+                            ground_temperatures[depth] = temps
+                        break
+                
+                # Read data section
                 data_start_idx = next(i for i, line in enumerate(epw_lines) if line.startswith("DATA PERIODS")) + 1
                 epw_data = pd.read_csv(StringIO("\n".join(epw_lines[data_start_idx:])), header=None, dtype=str)
                 
@@ -254,13 +341,16 @@ class ClimateData:
                 if len(epw_data.columns) != 35:
                     raise ValueError(f"EPW file has {len(epw_data.columns)} columns, expected 35.")
                 
-                for col in [1, 6, 8, 9, 13, 20, 21]:
+                for col in [1, 2, 3, 6, 8, 9, 13, 20, 21]:
                     epw_data[col] = pd.to_numeric(epw_data[col], errors='coerce')
                     if epw_data[col].isna().all():
                         raise ValueError(f"Column {col} contains only non-numeric or missing data.")
                 
+                # Create ClimateLocation
                 location = ClimateLocation(
                     epw_file=epw_data,
+                    typical_extreme_periods=typical_extreme_periods,
+                    ground_temperatures=ground_temperatures,
                     id=f"{country[:1].upper()}{city[:3].upper()}",
                     country=country,
                     state_province=state_province,
@@ -287,9 +377,11 @@ class ClimateData:
             hourly_data = climate_data_dict["hourly_data"]
             epw_data = pd.DataFrame({
                 1: [d["month"] for d in hourly_data],  # Month
+                2: [d["day"] for d in hourly_data],  # Day
+                3: [d["hour"] for d in hourly_data],  # Hour
                 6: [d["dry_bulb"] for d in hourly_data],  # Dry-bulb temperature
                 8: [d["relative_humidity"] for d in hourly_data],  # Relative humidity
-                9: [climate_data_dict["pressure"]] * len(hourly_data),  # Pressure (mean value)
+                9: [d["atmospheric_pressure"] for d in hourly_data],  # Pressure
                 13: [d["global_horizontal_radiation"] for d in hourly_data],  # Global horizontal radiation
                 20: [d["wind_direction"] for d in hourly_data],  # Wind direction
                 21: [d["wind_speed"] for d in hourly_data],  # Wind speed
@@ -298,6 +390,8 @@ class ClimateData:
             # Create ClimateLocation with reconstructed epw_data
             location = ClimateLocation(
                 epw_file=epw_data,
+                typical_extreme_periods=climate_data_dict["typical_extreme_periods"],
+                ground_temperatures=climate_data_dict["ground_temperatures"],
                 id=climate_data_dict["id"],
                 country=climate_data_dict["country"],
                 state_province=climate_data_dict["state_province"],
@@ -662,7 +756,32 @@ class ClimateData:
             data = json.load(f)
         climate_data = cls()
         for loc_id, loc_dict in data.items():
-            location = ClimateLocation(epw_file=pd.DataFrame(), **loc_dict)
+            # Rebuild epw_data from hourly_data
+            hourly_data = loc_dict["hourly_data"]
+            epw_data = pd.DataFrame({
+                1: [d["month"] for d in hourly_data],
+                2: [d["day"] for d in hourly_data],
+                3: [d["hour"] for d in hourly_data],
+                6: [d["dry_bulb"] for d in hourly_data],
+                8: [d["relative_humidity"] for d in hourly_data],
+                9: [d["atmospheric_pressure"] for d in hourly_data],
+                13: [d["global_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],
+            })
+            location = ClimateLocation(
+                epw_file=epw_data,
+                typical_extreme_periods=loc_dict["typical_extreme_periods"],
+                ground_temperatures=loc_dict["ground_temperatures"],
+                id=loc_dict["id"],
+                country=loc_dict["country"],
+                state_province=loc_dict["state_province"],
+                city=loc_dict["city"],
+                latitude=loc_dict["latitude"],
+                longitude=loc_dict["longitude"],
+                elevation=loc_dict["elevation"]
+            )
+            location.hourly_data = loc_dict["hourly_data"]  # Ensure consistency
             climate_data.add_location(location)
         return climate_data