Update data/climate_data.py

data/climate_data.py

@@ -171,6 +171,8 @@ class ClimateLocation:
         
         # Store hourly data with enhanced fields, including solar angles and ground-reflected radiation
         self.hourly_data = []
+        negative_dni_count = 0
+        negative_dhi_count = 0
         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
@@ -180,18 +182,25 @@ class ClimateLocation:
             solar_time = self._calculate_solar_time(timestamp)
             solar_angles = self._calculate_solar_angles(timestamp)
             
-            # Validate or fallback DNI/DHI
-            dni = float(direct_normal_irradiance[i]) if not np.isnan(direct_normal_irradiance[i]) else self._calculate_clear_sky_irradiance(timestamp, 'dni')
-            dhi = float(diffuse_horizontal_irradiance[i]) if not np.isnan(diffuse_horizontal_irradiance[i]) else self._calculate_clear_sky_irradiance(timestamp, 'dhi')
-            if dni < 0:
-                logger.warning(f"Negative DNI at {timestamp}, using clear-sky model: {dni}")
-                dni = self._calculate_clear_sky_irradiance(timestamp, 'dni')
-            if dhi < 0:
-                logger.warning(f"Negative DHI at {timestamp}, using clear-sky model: {dhi}")
-                dhi = self._calculate_clear_sky_irradiance(timestamp, 'dhi')
+            # Initialize defaults for solar-related fields
+            dni = 0.0
+            dhi = 0.0
+            ground_radiation = 0.0
             
-            # Calculate ground-reflected radiation
-            ground_radiation = self._calculate_ground_reflected_radiation(dni, dhi, solar_angles['zenith'])
+            # Perform solar calculations only if sun is above horizon (zenith < 90°)
+            if solar_angles['zenith'] < 90:
+                # Validate or fallback DNI/DHI
+                dni = float(direct_normal_irradiance[i]) if not np.isnan(direct_normal_irradiance[i]) else self._calculate_clear_sky_irradiance(timestamp, 'dni')
+                dhi = float(diffuse_horizontal_irradiance[i]) if not np.isnan(diffuse_horizontal_irradiance[i]) else self._calculate_clear_sky_irradiance(timestamp, 'dhi')
+                if dni < 0:
+                    negative_dni_count += 1
+                    dni = self._calculate_clear_sky_irradiance(timestamp, 'dni')
+                if dhi < 0:
+                    negative_dhi_count += 1
+                    dhi = self._calculate_clear_sky_irradiance(timestamp, 'dhi')
+                
+                # Calculate ground-reflected radiation
+                ground_radiation = self._calculate_ground_reflected_radiation(dni, dhi, solar_angles['zenith'])
             
             record = {
                 "month": int(months[i]),
@@ -211,6 +220,12 @@ class ClimateLocation:
             }
             self.hourly_data.append(record)
         
+        # Log summary of negative DNI/DHI corrections
+        if negative_dni_count > 0:
+            logger.warning(f"Corrected {negative_dni_count} negative DNI values using clear-sky model")
+        if negative_dhi_count > 0:
+            logger.warning(f"Corrected {negative_dhi_count} negative DHI values using clear-sky model")
+        
         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.")
 
@@ -487,6 +502,13 @@ class ClimateData:
                     st.error(f"Validation failed: Invalid {season} angles: {angles}")
                     return False
         
+        # Log presence of ground_reflected_radiation during import
+        if all("ground_reflected_radiation" in record for record in data["hourly_data"]):
+            logger.info("Validated ground_reflected_radiation present in all hourly data records")
+        else:
+            st.error("Validation failed: Missing ground_reflected_radiation in some hourly data records")
+            return False
+        
         return True
 
     @staticmethod
@@ -518,7 +540,7 @@ class ClimateData:
             return False
 
     def display_climate_input(self, session_state: Dict[str, Any]):
-        """Display Streamlit interface for EPW upload and visualizations."""
+        """Display Streamlit interface for EPW and JSON upload, and visualizations."""
         st.title("Climate Data Analysis")
         
         # Apply consistent styling
@@ -529,16 +551,64 @@ class ClimateData:
             st.warning("Clearing invalid climate data from session state.")
             del session_state["climate_data"]
         
-        uploaded_file = st.file_uploader("Upload EPW File", type=["epw"])
+        # File uploaders
+        uploaded_epw_file = st.file_uploader("Upload EPW File", type=["epw"])
+        uploaded_json_file = st.file_uploader("Upload JSON File", type=["json"])
         
         # Initialize location and epw_data for display
         location = None
         epw_data = None
         
-        if uploaded_file:
+        # Process JSON file if uploaded
+        if uploaded_json_file:
+            try:
+                json_content = uploaded_json_file.read().decode("utf-8")
+                json_data = json.loads(json_content)
+                for loc_id, loc_dict in json_data.items():
+                    if not self.validate_climate_data(loc_dict):
+                        raise ValueError("Invalid climate data in JSON file.")
+                    # 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],
+                        14: [d["direct_normal_irradiance"] for d in hourly_data],
+                        15: [d["diffuse_horizontal_irradiance"] 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"],
+                        time_zone=loc_dict["time_zone"]
+                    )
+                    location.hourly_data = loc_dict["hourly_data"]
+                    location.solstice_solar_angles = loc_dict["solstice_solar_angles"]
+                    self.add_location(location)
+                    session_state["climate_data"] = loc_dict
+                    st.success(f"Climate data loaded from JSON for {loc_dict['city']}")
+                logger.info(f"Successfully imported JSON with ground_reflected_radiation for {loc_dict['city']}")
+            except Exception as e:
+                st.error(f"Error processing JSON file: {str(e)}. Ensure it has valid climate data.")
+        
+        # Process EPW file if uploaded
+        elif uploaded_epw_file:
             try:
                 # Process new EPW file
-                epw_content = uploaded_file.read().decode("utf-8")
+                epw_content = uploaded_epw_file.read().decode("utf-8")
                 epw_lines = epw_content.splitlines()
                 
                 # Parse header
@@ -608,7 +678,7 @@ class ClimateData:
                 
                 # Parse GROUND TEMPERATURES
                 ground_temperatures = {}
-                for sista in epw_lines:
+                for line in epw_lines:
                     if line.startswith("GROUND TEMPERATURES"):
                         parts = line.strip().split(',')
                         try:
@@ -663,8 +733,17 @@ class ClimateData:
                 climate_data_dict = location.to_dict()
                 if not self.validate_climate_data(climate_data_dict):
                     raise ValueError("Invalid climate data extracted from EPW file.")
+                
+                # Add location and save to session state
+                self.add_location(location)
                 session_state["climate_data"] = climate_data_dict
                 st.success("Climate data extracted from EPW file!")
+                
+                # Export to JSON automatically
+                json_file_path = os.path.join(DATA_DIR, f"{city}_climate_data.json")
+                self.export_to_json(json_file_path)
+                st.info(f"Climate data exported to {json_file_path}")
+                logger.info(f"Exported climate data with ground_reflected_radiation to {json_file_path}")
             
             except Exception as e:
                 st.error(f"Error processing EPW file: {str(e)}. Ensure it has 8760 hourly records and correct format.")
@@ -735,7 +814,7 @@ class ClimateData:
                 self.plot_wind_rose(epw_data)
         
         else:
-            st.info("No climate data available. Please upload an EPW file to proceed.")
+            st.info("No climate data available. Please upload an EPW or JSON file to proceed.")
         
     def display_design_conditions(self, location: ClimateLocation):
         """Display design conditions for HVAC calculations using styled HTML."""
@@ -798,6 +877,21 @@ class ClimateData:
             </div>
             """, unsafe_allow_html=True)
         
+        # Ground Temperatures (Table)
+        if location.typical_extreme_periods:
+            period_items = [
+                f"<li><strong>{key.replace('_', ' ').title()}:</strong> {period['start']['month']}/{period['start']['day']} to {period['end']['month']}/{period['end']['day']}</li>"
+                for key, period in location.typical_extreme_periods.items()
+            ]
+            st.markdown(f"""
+            <div class="markdown-text">
+                <h3>Typical/Extreme Periods</h3>
+                <ul>
+                    {''.join(period_items)}
+                </ul>
+            </div>
+            """, unsafe_allow_html=True)
+        
         # Ground Temperatures (Table)
         if location.ground_temperatures:
             st.markdown('<div class="markdown-text"><h3>Ground Temperatures</h3></div>', unsafe_allow_html=True)