initial files

Author: Akenji

.gitignore

@@ -2,7 +2,7 @@
 __pycache__/
 *.py[cod]
 *$py.class
-
+venv/
 # C extensions
 *.so
 

main.py

@@ -0,0 +1,37 @@
+from sun_position import SunPosition
+from solar_panel import SolarPanel
+from weather_service import WeatherService
+from solar_optimizer import SolarOptimizer
+from datetime import datetime
+import os
+
+def main():
+    # Configuration
+    latitude = 37.7749  # San Francisco
+    longitude = -122.4194
+    api_key = os.getenv('WEATHER_API_KEY')  # Get API key from environment variable
+    
+    # Initialize components
+    sun_calculator = SunPosition(latitude, longitude)
+    weather_service = WeatherService(api_key) if api_key else None
+    optimizer = SolarOptimizer(sun_calculator, weather_service)
+    
+    # Set date for optimization
+    date = datetime(2024, 6, 21)  # Summer solstice
+    
+    # Find optimal placement
+    optimal_tilt, optimal_orientation, max_energy = optimizer.optimize_placement(date)
+    
+    print(f"Optimal tilt: {optimal_tilt}°")
+    print(f"Optimal orientation: {optimal_orientation}°")
+    print(f"Maximum daily energy: {max_energy/1000:.2f} kWh")
+    
+    # Simulate with optimal placement
+    optimal_panel = SolarPanel(optimal_tilt, optimal_orientation)
+    daily_output = optimizer.simulate_day(optimal_panel, date)
+    
+    # Visualize results
+    optimizer.visualize_results(daily_output)
+
+if __name__ == "__main__":
+    main()

solar_optimizer.py

@@ -0,0 +1,140 @@
+import numpy as np
+from datetime import datetime, timedelta
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import pandas as pd
+from solar_panel import SolarPanel
+
+
+class SolarOptimizer:
+    def __init__(self, sun_position, weather_service=None):
+        """
+        Initialize optimizer
+        
+        Args:
+            sun_position (SunPosition): SunPosition calculator instance
+            weather_service (WeatherService): Optional WeatherService instance
+        """
+        self.sun_calculator = sun_position
+        self.weather_service = weather_service
+        self.results = []
+        
+    def simulate_day(self, panel, date, time_step_minutes=30):
+        """
+        Simulate panel output over a day
+        
+        Args:
+            panel (SolarPanel): Solar panel object
+            date (datetime): Date to simulate
+            time_step_minutes (int): Time step for simulation
+            
+        Returns:
+            list: Hourly power outputs
+        """
+        daily_output = []
+        
+        # Simulate for each time step
+        for hour in range(24):
+            for minute in range(0, 60, time_step_minutes):
+                time = date.replace(hour=hour, minute=minute)
+                altitude, azimuth = self.sun_calculator.calculate_sun_position(time)
+                
+                # Get weather data if available
+                weather_data = None
+                if self.weather_service:
+                    weather_data = self.weather_service.get_weather_data(
+                        np.degrees(self.sun_calculator.latitude),
+                        np.degrees(self.sun_calculator.longitude),
+                        time
+                    )
+                
+                if altitude > 0:  # Only calculate during daylight
+                    power = panel.calculate_power_output(altitude, azimuth, weather_data)
+                    daily_output.append({
+                        'time': time,
+                        'power': power,
+                        'altitude': altitude,
+                        'azimuth': azimuth,
+                        'weather': weather_data
+                    })
+                    
+        return daily_output
+    
+    def optimize_placement(self, date, tilt_range=(0, 90), orientation_range=(0, 360)):
+        """
+        Find optimal panel placement
+        
+        Args:
+            date (datetime): Date to optimize for
+            tilt_range (tuple): Range of tilt angles to test
+            orientation_range (tuple): Range of orientation angles to test
+            
+        Returns:
+            tuple: (optimal_tilt, optimal_orientation, max_daily_energy)
+        """
+        max_energy = 0
+        optimal_tilt = 0
+        optimal_orientation = 0
+        results = []
+        
+        # Test different combinations
+        for tilt in range(tilt_range[0], tilt_range[1], 5):
+            for orientation in range(orientation_range[0], orientation_range[1], 5):
+                panel = SolarPanel(tilt, orientation)
+                daily_output = self.simulate_day(panel, date)
+                
+                # Calculate total daily energy
+                daily_energy = sum(record['power'] for record in daily_output)
+                results.append({
+                    'tilt': tilt,
+                    'orientation': orientation,
+                    'energy': daily_energy
+                })
+                
+                if daily_energy > max_energy:
+                    max_energy = daily_energy
+                    optimal_tilt = tilt
+                    optimal_orientation = orientation
+        
+        self.results = results
+        return optimal_tilt, optimal_orientation, max_energy
+    
+    def visualize_results(self, daily_output):
+        """
+        Create visualization of daily power output
+        
+        Args:
+            daily_output (list): Simulation results
+        """
+        # Daily power output plot
+        plt.figure(figsize=(12, 6))
+        times = [record['time'] for record in daily_output]
+        powers = [record['power'] for record in daily_output]
+        
+        plt.plot(times, powers)
+        plt.title('Solar Panel Power Output Over Day')
+        plt.xlabel('Time')
+        plt.ylabel('Power Output (W)')
+        plt.xticks(rotation=45)
+        plt.grid(True)
+        plt.tight_layout()
+        plt.show()
+        
+        # Optimization results heat map
+        if self.results:
+            df = pd.DataFrame(self.results)
+            pivot_table = df.pivot_table(
+                values='energy', 
+                index='tilt', 
+                columns='orientation', 
+                aggfunc='first'
+            )
+            
+            plt.figure(figsize=(12, 8))
+            plt.imshow(pivot_table, cmap='viridis', aspect='auto')
+            plt.colorbar(label='Daily Energy (Wh)')
+            plt.title('Energy Production by Panel Orientation and Tilt')
+            plt.xlabel('Orientation (degrees)')
+            plt.ylabel('Tilt (degrees)')
+            plt.tight_layout()
+            plt.show()

solar_panel.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+class SolarPanel:
+    def __init__(self, tilt, orientation, efficiency=0.2, area=1.6):
+        """
+        Initialize solar panel properties
+        
+        Args:
+            tilt (float): Panel tilt angle in degrees
+            orientation (float): Panel orientation (azimuth) in degrees
+            efficiency (float): Panel efficiency (default 20%)
+            area (float): Panel area in square meters
+        """
+        self.tilt = np.radians(tilt)
+        self.orientation = np.radians(orientation)
+        self.efficiency = efficiency
+        self.area = area
+        
+    def calculate_power_output(self, sun_altitude, sun_azimuth, weather_data=None):
+        """
+        Calculate power output based on sun position and weather conditions
+        
+        Args:
+            sun_altitude (float): Sun's altitude in degrees
+            sun_azimuth (float): Sun's azimuth in degrees
+            weather_data (dict): Optional weather data including cloud cover and temperature
+            
+        Returns:
+            float: Power output in watts
+        """
+        # Base solar intensity (W/m²)
+        solar_intensity = 1000
+        
+        # Adjust for weather conditions if available
+        if weather_data:
+            cloud_factor = 1 - (weather_data.get('cloud_cover', 0) / 100)
+            temp_coefficient = 1 - (0.004 * (weather_data.get('temperature', 25) - 25))  # Temperature coefficient
+            solar_intensity *= cloud_factor * temp_coefficient
+        
+        # Convert sun position to radians
+        sun_altitude_rad = np.radians(sun_altitude)
+        sun_azimuth_rad = np.radians(sun_azimuth)
+        
+        # Calculate incidence angle using spherical trigonometry
+        cos_incidence = (
+            np.cos(sun_altitude_rad) * np.sin(self.tilt) * 
+            np.cos(sun_azimuth_rad - self.orientation) +
+            np.sin(sun_altitude_rad) * np.cos(self.tilt)
+        )
+        
+        # Calculate power output
+        if cos_incidence > 0:
+            # Add air mass effect
+            air_mass = 1 / (np.sin(sun_altitude_rad) + 0.50572 * (6.07995 + sun_altitude)**-1.6364)
+            atmospheric_loss = 0.7 ** air_mass
+            
+            power = solar_intensity * cos_incidence * self.efficiency * self.area * atmospheric_loss
+            return power
+        return 0

sun_position.py

@@ -0,0 +1,55 @@
+import numpy as np
+from datetime import datetime
+
+class SunPosition:
+    def __init__(self, latitude, longitude):
+        """
+        Initialize with location coordinates
+        
+        Args:
+            latitude (float): Location latitude in degrees
+            longitude (float): Location longitude in degrees
+        """
+        self.latitude = np.radians(latitude)
+        self.longitude = np.radians(longitude)
+        
+    def calculate_sun_position(self, date_time):
+        """
+        Calculate sun's altitude and azimuth for a given date and time
+        
+        Args:
+            date_time (datetime): Date and time for calculation
+            
+        Returns:
+            tuple: (altitude, azimuth) in degrees
+        """
+        # Calculate day of year
+        day_of_year = date_time.timetuple().tm_yday
+        
+        # Calculate solar declination
+        declination = np.radians(23.45 * np.sin(np.radians(360/365 * (day_of_year - 81))))
+        
+        # Calculate hour angle
+        hour_angle = np.radians(15 * (date_time.hour + date_time.minute/60 - 12))
+        
+        # Calculate solar altitude
+        altitude = np.arcsin(
+            np.sin(self.latitude) * np.sin(declination) +
+            np.cos(self.latitude) * np.cos(declination) * np.cos(hour_angle)
+        )
+        
+        # Calculate solar azimuth
+        azimuth = np.arccos(
+            (np.sin(declination) - np.sin(altitude) * np.sin(self.latitude)) /
+            (np.cos(altitude) * np.cos(self.latitude))
+        )
+        
+        # Convert to degrees
+        altitude_deg = np.degrees(altitude)
+        azimuth_deg = np.degrees(azimuth)
+        
+        # Adjust azimuth based on time of day
+        if hour_angle > 0:
+            azimuth_deg = 360 - azimuth_deg
+            
+        return altitude_deg, azimuth_deg

test_api.py

@@ -0,0 +1,16 @@
+import requests
+import os
+
+api_key = os.getenv('WEATHER_API_KEY')
+
+# Test URL
+url = f"http://api.weatherapi.com/v1/current.json?key={"3ab2eda07aaf460086064219250502"}&q=London"
+
+response = requests.get(url)
+if response.status_code == 200:
+    print("API connection successful!")
+    data = response.json()
+    print(f"Current temperature in London: {data['current']['temp_c']}°C")
+else:
+    print(f"Error: {response.status_code}")
+    print(response.text)

weather_service.py

@@ -0,0 +1,92 @@
+import requests
+from datetime import datetime
+import json
+
+class WeatherService:
+    def __init__(self, api_key):
+        """
+        Initialize weather service with API key
+        
+        Args:
+            api_key (str): API key for weather service
+        """
+        self.api_key = api_key
+        self.base_url = "http://api.weatherapi.com/v1"
+        
+    def get_weather_data(self, latitude, longitude, date_time):
+        """
+        Get weather data for specific location and time
+        
+        Args:
+            latitude (float): Location latitude
+            longitude (float): Location longitude
+            date_time (datetime): Date and time for weather data
+            
+        Returns:
+            dict: Weather data including temperature and cloud cover
+        """
+        try:
+            # Format date for API
+            date_str = date_time.strftime("%Y-%m-%d")
+            
+            # Make API request
+            response = requests.get(
+                f"{self.base_url}/history.json",
+                params={
+                    "key": self.api_key,
+                    "q": f"{latitude},{longitude}",
+                    "dt": date_str
+                }
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                hour = date_time.hour
+                
+                # Extract relevant weather data
+                weather_data = {
+                    'temperature': data['forecast']['forecastday'][0]['hour'][hour]['temp_c'],
+                    'cloud_cover': data['forecast']['forecastday'][0]['hour'][hour]['cloud'],
+                    'humidity': data['forecast']['forecastday'][0]['hour'][hour]['humidity']
+                }
+                
+                return weather_data
+            else:
+                print(f"Error fetching weather data: {response.status_code}")
+                return None
+                
+        except Exception as e:
+            print(f"Error: {str(e)}")
+            return None
+            
+    def get_forecast(self, latitude, longitude, days=1):
+        """
+        Get weather forecast for future optimization
+        
+        Args:
+            latitude (float): Location latitude
+            longitude (float): Location longitude
+            days (int): Number of days to forecast
+            
+        Returns:
+            dict: Forecast data
+        """
+        try:
+            response = requests.get(
+                f"{self.base_url}/forecast.json",
+                params={
+                    "key": self.api_key,
+                    "q": f"{latitude},{longitude}",
+                    "days": days
+                }
+            )
+            
+            if response.status_code == 200:
+                return response.json()['forecast']['forecastday']
+            else:
+                print(f"Error fetching forecast: {response.status_code}")
+                return None
+                
+        except Exception as e:
+            print(f"Error: {str(e)}")
+            return None