Upload solar_calculations.py

data/solar_calculations.py

@@ -0,0 +1,145 @@
+import numpy as np
+from typing import List, Dict, Any
+import math
+from datetime import datetime
+import streamlit as st
+
+# Initialize session_state
+if "climate_data" not in st.session_state:
+    st.session_state["climate_data"] = {
+        "latitude": 0.0,
+        "longitude": 0.0,
+        "timezone": 0.0
+    }
+
+class SolarCalculations:
+    """Class for performing solar radiation and angle calculations based on ASHRAE methodologies."""
+
+    @staticmethod
+    def day_of_year(month: int, day: int, year: int) -> int:
+        """Calculate day of the year (n) from month, day, and year, accounting for leap years."""
+        days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+        if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
+            days_in_month[1] = 29
+        return sum(days_in_month[:month-1]) + day
+
+    @staticmethod
+    def equation_of_time(n: int) -> float:
+        """Calculate Equation of Time (EOT) in minutes using Spencer's formula."""
+        B = (n - 1) * 360 / 365
+        B_rad = math.radians(B)
+        EOT = 229.2 * (0.000075 + 0.001868 * math.cos(B_rad) - 0.032077 * math.sin(B_rad) -
+                       0.014615 * math.cos(2 * B_rad) - 0.04089 * math.sin(2 * B_rad))
+        return EOT
+
+    @staticmethod
+    def calculate_solar_parameters(
+        hourly_data: List[Dict[str, Any]],
+        latitude: float,
+        longitude: float,
+        timezone: float,
+        ground_reflectivity: float,
+        surface_tilt: float,
+        year: int = 2025
+    ) -> List[Dict[str, Any]]:
+        """Calculate solar angles and ground-reflected radiation for hourly data with GHI > 0."""
+        # Display input parameters in Streamlit UI
+        st.write("### Input Parameters")
+        st.write(f"- **Latitude**: {latitude}°")
+        st.write(f"- **Longitude**: {longitude}°")
+        st.write(f"- **Timezone**: {timezone} hours")
+        st.write(f"- **Ground Reflectivity**: {ground_reflectivity}")
+        st.write(f"- **Surface Tilt**: {surface_tilt}°")
+        st.write(f"- **Year**: {year}")
+        st.write("")  # Add spacing
+
+        results = []
+        lambda_std = 15 * timezone  # Standard meridian longitude (°)
+        first_hour = True
+
+        for record in hourly_data:
+            if record["global_horizontal_radiation"] <= 0:
+                continue  # Skip hours with no solar radiation
+
+            # Step 1: Extract data
+            month = record["month"]
+            day = record["day"]
+            hour = record["hour"]
+            ghi = record["global_horizontal_radiation"]
+            dni = record["direct_normal_radiation"]
+            dhi = record["diffuse_horizontal_radiation"]
+
+            if first_hour:
+                st.write(f"### Calculations for First Hour (Month: {month}, Day: {day}, Hour: {hour})")
+                st.write(f"- **Global Horizontal Radiation (GHI)**: {ghi} W/m²")
+                st.write(f"- **Direct Normal Radiation (DNI)**: {dni} W/m²")
+                st.write(f"- **Diffuse Horizontal Radiation (DHI)**: {dhi} W/m²")
+
+            # Step 2: Local Solar Time (LST) with Equation of Time
+            n = SolarCalculations.day_of_year(month, day, year)
+            if first_hour:
+                st.write(f"- **Day of Year (n)**: {n}")
+
+            EOT = SolarCalculations.equation_of_time(n)
+            if first_hour:
+                st.write(f"- **Equation of Time (EOT)**: {EOT:.2f} minutes")
+
+            standard_time = hour - 1 + 0.5  # Convert to decimal, assume mid-hour
+            LST = standard_time + (4 * (lambda_std - longitude) + EOT)/60 
+            if first_hour:
+                st.write(f"- **Local Solar Time (LST)**: {LST:.2f} hours")
+
+            # Step 3: Solar Declination (δ)
+            delta = 23.45 * math.sin(math.radians(360 / 365 * (284 + n)))
+            if first_hour:
+                st.write(f"- **Solar Declination (δ)**: {delta:.2f}°")
+
+            # Step 4: Hour Angle (HRA)
+            hra = 15 * (LST - 12)
+            if first_hour:
+                st.write(f"- **Hour Angle (HRA)**: {hra:.2f}°")
+
+            # Step 5: Solar Altitude (α) and Azimuth (Az)
+            phi = math.radians(latitude)
+            delta_rad = math.radians(delta)
+            hra_rad = math.radians(hra)
+
+            sin_alpha = math.sin(phi) * math.sin(delta_rad) + math.cos(phi) * math.cos(delta_rad) * math.cos(hra_rad)
+            alpha = math.degrees(math.asin(sin_alpha))
+            if first_hour:
+                st.write(f"- **Solar Altitude (α)**: {alpha:.2f}°")
+
+            if abs(math.cos(math.radians(alpha))) < 0.01:
+                azimuth = 0  # North at sunrise/sunset
+            else:
+                sin_az = math.cos(delta_rad) * math.sin(hra_rad) / math.cos(math.radians(alpha))
+                cos_az = (sin_alpha * math.sin(phi) - math.sin(delta_rad)) / (math.cos(math.radians(alpha)) * math.cos(phi))
+                azimuth = math.degrees(math.atan2(sin_az, cos_az))
+                if hra > 0:  # Afternoon
+                    azimuth = 360 - azimuth if azimuth > 0 else -azimuth
+            if first_hour:
+                st.write(f"- **Solar Azimuth (Az)**: {azimuth:.2f}°")
+
+            # Step 6: Ground-Reflected Radiation (I_gr)
+            view_factor = (1 - math.cos(math.radians(surface_tilt))) / 2
+            ground_reflected = ground_reflectivity * ghi * view_factor
+            if first_hour:
+                st.write(f"- **Ground-Reflected Radiation (I_gr)**: {ground_reflected:.2f} W/m²")
+                st.write("")  # Add spacing
+                first_hour = False
+
+            # Store results
+            result = {
+                "month": month,
+                "day": day,
+                "hour": hour,
+                "declination": round(delta, 2),
+                "LST": round(LST, 2),
+                "HRA": round(hra, 2),
+                "altitude": round(alpha, 2),
+                "azimuth": round(azimuth, 2),
+                "ground_reflected": round(ground_reflected, 2)
+            }
+            results.append(result)
+
+        return results