import math import json from datetime import datetime class BifacialSolarSimulation: def __init__(self): # Panel specifications (Hanersun N-TOPCon 700W) self.panel_power = 700 # watts self.panel_efficiency = 0.225 # 22.5% self.bifaciality_factor = 0.80 # Average of 75-85% self.panel_area = 2.384 * 1.303 # m² # Location: Lago Brown, Chile self.latitude = -47.3919449 self.longitude = -72.3174973 self.elevation = 165 # meters # IDEAL CONDITIONS - no weather effects, clear skies self.monthly_ghi = { 1: 8.5, # January (summer, some clouds) 2: 7.2, # February 3: 5.4, # March (autumn transition) 4: 3.5, # April 5: 2.4, # May (late autumn) 6: 1.2, # June (winter solstice, very low sun, clouds, snow) 7: 1.4, # July (still winter but days getting longer) 8: 2.8, # August (late winter) 9: 4.6, # September (spring begins) 10: 6.5, # October (spring) 11: 7.8, # November (late spring) 12: 8.8 # December (summer solstice) } # Ground albedo (reflection factor) - clay soil year-round self.ground_albedo = { 1: 0.15, # January - clay soil 2: 0.15, # February - clay soil 3: 0.15, # March - clay soil 4: 0.15, # April - clay soil 5: 0.15, # May - clay soil 6: 0.15, # June - clay soil 7: 0.15, # July - clay soil 8: 0.15, # August - clay soil 9: 0.15, # September - clay soil 10: 0.15, # October - clay soil 11: 0.15, # November - clay soil 12: 0.15 # December - clay soil } def solar_position(self, day_of_year, hour): """Calculate solar position for given day and hour""" # Solar declination declination = 23.45 * math.sin(math.radians(360 * (284 + day_of_year) / 365)) # Hour angle hour_angle = 15 * (hour - 12) # Solar elevation angle elevation = math.asin( math.sin(math.radians(declination)) * math.sin(math.radians(self.latitude)) + math.cos(math.radians(declination)) * math.cos(math.radians(self.latitude)) * math.cos(math.radians(hour_angle)) ) # Solar azimuth angle (standard formula gives azimuth from South) azimuth_from_south = math.atan2( math.sin(math.radians(hour_angle)), math.cos(math.radians(hour_angle)) * math.sin(math.radians(self.latitude)) - math.tan(math.radians(declination)) * math.cos(math.radians(self.latitude)) ) # Convert to azimuth from North (0° = North, 90° = East, 180° = South, 270° = West) azimuth = math.degrees(azimuth_from_south) + 180 if azimuth >= 360: azimuth -= 360 if azimuth < 0: azimuth += 360 return math.degrees(elevation), azimuth def calculate_sunrise_sunset(self, day_of_year): """Calculate sunrise and sunset times and azimuths for given day""" # Solar declination declination = 23.45 * math.sin(math.radians(360 * (284 + day_of_year) / 365)) lat_rad = math.radians(self.latitude) decl_rad = math.radians(declination) # Hour angle at sunrise/sunset (when elevation = 0) try: cos_hour_angle = -math.tan(lat_rad) * math.tan(decl_rad) if cos_hour_angle > 1: # Polar night return None, None, None, None elif cos_hour_angle < -1: # Polar day return 0, 24, 90, 270 # Simplified hour_angle_sunrise = math.degrees(math.acos(cos_hour_angle)) sunrise_hour = 12 - hour_angle_sunrise / 15 sunset_hour = 12 + hour_angle_sunrise / 15 # Calculate sunrise and sunset azimuths # At sunrise/sunset, elevation = 0, so we can calculate azimuth directly cos_azimuth_sunrise = ( math.sin(decl_rad) / math.cos(lat_rad) ) if cos_azimuth_sunrise > 1: cos_azimuth_sunrise = 1 elif cos_azimuth_sunrise < -1: cos_azimuth_sunrise = -1 azimuth_offset = math.degrees(math.acos(cos_azimuth_sunrise)) # In southern hemisphere, sunrise is generally northeast, sunset northwest sunrise_azimuth = 90 - azimuth_offset # East of north sunset_azimuth = 270 + azimuth_offset # West of north # Ensure azimuths are in 0-360 range if sunrise_azimuth < 0: sunrise_azimuth += 360 if sunset_azimuth >= 360: sunset_azimuth -= 360 return sunrise_hour, sunset_hour, sunrise_azimuth, sunset_azimuth except: # Fallback for calculation errors return 6, 18, 90, 270 def calculate_irradiance_on_tilted_surface(self, ghi, solar_elevation, solar_azimuth, panel_tilt, panel_azimuth, month, hour, panel_type='tilted'): """Calculate irradiance on tilted surface with enhanced bifacial effects""" if solar_elevation <= 0: return 0, 0 # Convert to radians se_rad = math.radians(solar_elevation) sa_rad = math.radians(solar_azimuth) pt_rad = math.radians(panel_tilt) pa_rad = math.radians(panel_azimuth) # Special handling for East-West vertical panels if panel_type == 'ew_vertical': # For East-West orientation, panel acts like it has two sides: # East side (azimuth 90°) and West side (azimuth 270°) # Calculate irradiance on East side (morning peak) east_azimuth = 90 ea_rad = math.radians(east_azimuth) cos_incidence_east = ( math.sin(se_rad) * math.cos(pt_rad) + math.cos(se_rad) * math.sin(pt_rad) * math.cos(sa_rad - ea_rad) ) if cos_incidence_east < 0: cos_incidence_east = 0 # Calculate irradiance on West side (evening peak) west_azimuth = 270 wa_rad = math.radians(west_azimuth) cos_incidence_west = ( math.sin(se_rad) * math.cos(pt_rad) + math.cos(se_rad) * math.sin(pt_rad) * math.cos(sa_rad - wa_rad) ) if cos_incidence_west < 0: cos_incidence_west = 0 # For East-West, combine both sides as one effective irradiance cos_incidence_front = max(cos_incidence_east, cos_incidence_west) cos_incidence_back = min(cos_incidence_east, cos_incidence_west) * 0.8 # Back side gets less else: # Standard calculation for tilted panels # Angle of incidence on front surface cos_incidence_front = ( math.sin(se_rad) * math.cos(pt_rad) + math.cos(se_rad) * math.sin(pt_rad) * math.cos(sa_rad - pa_rad) ) if cos_incidence_front < 0: cos_incidence_front = 0 # For tilted panels, back surface can receive direct light during morning/evening # when sun elevation is low and sun azimuth is opposite to panel azimuth back_azimuth = (panel_azimuth + 180) % 360 ba_rad = math.radians(back_azimuth) cos_incidence_back = ( math.sin(se_rad) * math.cos(pt_rad) + math.cos(se_rad) * math.sin(pt_rad) * math.cos(sa_rad - ba_rad) ) if cos_incidence_back < 0: cos_incidence_back = 0 # Direct normal irradiance dni = ghi * 0.8 if solar_elevation > 0 else 0 # Simplified bifacial calculation - front side gets direct light when cos_incidence > 0 # Back side gets reduced direct light (mainly from reflections) direct_front = dni * cos_incidence_front direct_back = dni * cos_incidence_back * 0.1 # Back side gets 10% of direct light (ground reflections) # Diffuse irradiance (isotropic sky model) diffuse_irradiance = ghi * 0.2 * (1 + math.cos(pt_rad)) / 2 # Ground reflected irradiance (depends on albedo) current_albedo = self.ground_albedo[month] ground_reflected = ghi * current_albedo * (1 - math.cos(pt_rad)) / 2 # IDEAL CONDITIONS - No weather effects, perfect clear sky # Front side irradiance front_irradiance = direct_front + diffuse_irradiance + ground_reflected # Back side irradiance back_base = ground_reflected + diffuse_irradiance * 0.4 back_direct_component = direct_back # Enhanced bifacial effect for vertical panels if panel_tilt >= 60: # Vertical or near-vertical bifacial_boost = 1.2 # 20% boost for vertical installations else: bifacial_boost = 1.0 back_irradiance = (back_base + back_direct_component) * self.bifaciality_factor * bifacial_boost return front_irradiance, back_irradiance def calculate_monthly_production(self, panel_tilt, panel_azimuth, panel_type='tilted'): """Calculate monthly energy production for given panel configuration""" monthly_production = {} for month in range(1, 13): # Get representative day of month day_of_year = month * 30 - 15 # Approximate middle of month daily_production = 0 hourly_data = [] # Daylight hours depend on season (southern hemisphere) if month in [1, 2, 11, 12]: # Summer months - longer days daylight_hours = range(5, 21) # 5 AM to 8 PM elif month in [6, 7]: # Winter months - shorter days daylight_hours = range(8, 17) # 8 AM to 4 PM else: # Transition months daylight_hours = range(6, 19) # 6 AM to 6 PM for hour in daylight_hours: solar_elev, solar_az = self.solar_position(day_of_year, hour) if solar_elev > 0: # Get hourly irradiance (realistic solar noon peak distribution) # Solar radiation peaks around solar noon (12:00-13:00) # Create realistic bell curve centered at 12:30 time_from_noon = abs(hour + 0.5 - 12.5) # Distance from solar noon hour_factor = max(0, math.cos(math.pi * time_from_noon / 8)) # Gentler curve, broader peak hourly_ghi = self.monthly_ghi[month] * hour_factor * 1000 / 6 # Convert to W/m² and distribute over effective daylight hours front_irr, back_irr = self.calculate_irradiance_on_tilted_surface( hourly_ghi, solar_elev, solar_az, panel_tilt, panel_azimuth, month, hour, panel_type ) total_irradiance = front_irr + back_irr # Power calculation (irradiance in kW/m², panel_power in W) power = (total_irradiance / 1000) * self.panel_power daily_production += power hourly_data.append({ 'hour': hour, 'solar_elevation': round(solar_elev, 1), 'front_irradiance': round(front_irr, 2), 'back_irradiance': round(back_irr, 2), 'total_irradiance': round(total_irradiance, 2), 'power': round(power, 1) }) # Days in month days_in_month = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month-1] monthly_energy = daily_production * days_in_month / 1000 # kWh monthly_production[month] = { 'energy_kwh': round(monthly_energy, 1), 'daily_production': round(daily_production, 1), 'hourly_data': hourly_data } return monthly_production def run_simulation(self): """Run simulation for all configurations""" configurations = [ {'name': 'Vertical North-South', 'tilt': 90, 'azimuth': 0, 'type': 'ns_vertical'}, # Vertical, facing North (southern hemisphere) {'name': 'Vertical East-West', 'tilt': 90, 'azimuth': 90, 'type': 'ew_vertical'}, # Vertical, facing East (EW oriented) {'name': 'Tilt 20°', 'tilt': 20, 'azimuth': 0, 'type': 'tilted'}, # Tilted facing North (southern hemisphere) {'name': 'Tilt 30°', 'tilt': 30, 'azimuth': 0, 'type': 'tilted'}, # Tilted facing North (southern hemisphere) {'name': 'Tilt 45°', 'tilt': 45, 'azimuth': 0, 'type': 'tilted'}, # Tilted facing North (southern hemisphere) {'name': 'Tilt 60°', 'tilt': 60, 'azimuth': 0, 'type': 'tilted'}, # Tilted facing North (southern hemisphere) {'name': 'Tilt 70°', 'tilt': 70, 'azimuth': 0, 'type': 'tilted'} # Tilted facing North (southern hemisphere) ] results = {} print("Running simulation for all configurations...") for config in configurations: print(f" - {config['name']}") production = self.calculate_monthly_production(config['tilt'], config['azimuth'], config['type']) results[config['name']] = production return results def create_data_tables(self, results): """Create data tables for the report""" months = list(range(1, 13)) month_names = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'] # Monthly production table monthly_table = [] header = ['Month'] + list(results.keys()) monthly_table.append(header) for i, month in enumerate(months): row = [month_names[i]] for config_name, data in results.items(): row.append(f"{data[month]['energy_kwh']:.1f}") monthly_table.append(row) # Annual totals annual_row = ['ANNUAL TOTAL'] for config_name, data in results.items(): annual_total = sum(data[month]['energy_kwh'] for month in months) annual_row.append(f"{annual_total:.1f}") monthly_table.append(annual_row) # Hourly production example tables for 15th of each month hourly_tables = {} for month in months: hourly_table = [] # Header hour_header = ['Hour'] + list(results.keys()) hourly_table.append(hour_header) # Get hours from first configuration first_config = list(results.keys())[0] hours = [h['hour'] for h in results[first_config][month]['hourly_data']] for hour in hours: row = [f"{hour}:00"] for config_name, data in results.items(): # Find power for this hour power = 0 for h_data in data[month]['hourly_data']: if h_data['hour'] == hour: power = h_data['power'] break row.append(f"{power:.1f}") hourly_table.append(row) hourly_tables[month_names[month-1]] = hourly_table return monthly_table, hourly_tables def create_html_report(results, monthly_table, hourly_tables): """Create HTML report with charts and tables""" # Calculate annual totals for summary annual_totals = {} months = list(range(1, 13)) for config_name, data in results.items(): annual_total = sum(data[month]['energy_kwh'] for month in months) annual_totals[config_name] = annual_total html_content = """ Analýza výkonu bifaciálního panelu - Lago Brown, Chile

🌞 Analýza výkonu bifaciálního panelu

Hanersun N-TOPCon 700W • Lago Brown, Chile • Simulace různých orientací

Specifikace panelu a lokace

Panel Hanersun N-TOPCon

Výkon: 700 W
Účinnost: 22.5%
Bifacialita: 75-85%
Rozměry: 2384 × 1303 mm
Hmotnost: 38.7 kg

Lokace Lago Brown

Zeměpisná šířka: -47.39°
Zeměpisná délka: -72.32°
Nadmořská výška: 165 m
Klimatická oblast: Patagonská Chile
Albedo terénu: 0.15 (jíl celý rok), červen/červenec (0.6 sníh)

📊 Roční souhrn výroby energie

""" # Add summary cards for each configuration for config_name, annual_total in annual_totals.items(): html_content += f"""

{config_name}

{annual_total:.0f}
kWh/rok
""" html_content += """
📈 Graf porovnání ročních výnosů by byl zde
Nejlepší výkon: Sklon 30° ({:.0f} kWh/rok)

📅 Měsíční výroba energie

""".format(max(annual_totals.values())) # Add monthly table with highlighting highlight_columns = ['Vertical North-South', 'Tilt 70°'] # Columns to highlight highlight_rows = ['May', 'June', 'July', 'August'] # Rows to highlight for i, row in enumerate(monthly_table): if i == 0: # Header html_content += "" for j, cell in enumerate(row): # Add highlight class for specified columns if cell in highlight_columns: html_content += f"" else: html_content += f"" html_content += "" else: # Check if this row should be highlighted row_month = row[0] # First column is month name row_highlight = row_month in highlight_rows if row_highlight: html_content += "" else: html_content += "" for j, cell in enumerate(row): # Determine column name from header if j < len(monthly_table[0]): column_name = monthly_table[0][j] column_highlight = column_name in highlight_columns # Apply CSS classes based on row and column highlighting css_classes = [] if row_highlight: css_classes.append('highlight-row') if column_highlight: css_classes.append('highlight-column') if css_classes: html_content += f"" else: html_content += f"" else: html_content += f"" html_content += "" html_content += """
{cell}{cell}
{cell}{cell}{cell}

💡 Poznámky k měsíční výrobě:

  • Hodnoty jsou v kWh za měsíc
  • Simulace předpokládá ideální podmínky: jasná obloha bez mraků, bez zastínění, konstantní sluneční svit
  • Bifaciální efekt je zahrnut ve všech konfiguracích
  • Nejlepší výkon v létě (prosinec-únor), nejhorší v zimě (červen-srpen)
📈 Graf měsíční výroby by byl zde
Zobrazující sezónní trendy pro všechny konfigurace

⏰ Hodinová výroba (15. den v měsíci)

""" # Add month tabs month_names = ['Leden', 'Únor', 'Březen', 'Duben', 'Květen', 'Červen', 'Červenec', 'Srpen', 'Září', 'Říjen', 'Listopad', 'Prosinec'] for i, month_name in enumerate(month_names): active_class = "active" if i == 0 else "" html_content += f'' html_content += "
" # Add month content for i, (month_name, hourly_table) in enumerate(hourly_tables.items()): active_class = "active" if i == 0 else "" html_content += f'
' html_content += f"

Hodinová výroba - {month_name} (15. den)

" html_content += "" for j, row in enumerate(hourly_table): if j == 0: # Header html_content += "" for cell in row: html_content += f"" html_content += "" else: html_content += "" for cell in row: html_content += f"" html_content += "" html_content += "
{cell}
{cell} W
" html_content += """

⚡ Poznámky k hodinové výrobě:

  • Hodnoty jsou ve wattech (W) pro každou hodinu
  • Simulováno pro 15. den každého měsíce
  • Hodinová data zahrnují bifaciální efekt zadní strany panelu
  • Maxima odpovídají poledním hodinám při optimálním úhlu slunce
  • V zimních měsících je výroba omezena kratším dnem a nízkým sluncem
📈 Graf hodinové výroby by byl zde
Zobrazující denní křivky pro vybraný měsíc

🔍 Analýza a doporučení

Nejlepší konfigurace

Optimální sklon: 30° - 45°
Roční výnos: {:.0f} - {:.0f} kWh
Orientace: Jih (180°)

Vertikální instalace

North-South: {:.0f} kWh/rok
East-West: {:.0f} kWh/rok
Výhoda: Méně sněhu

Bifaciální efekt

Přínos zadní strany: 15-25%
Nejlepší u: Vertikální E-W
Albedo závislost: Vysoká

🎯 Klíčová doporučení:

  1. Pro maximální výnos: Použijte sklon 30-45° směrem na jih
  2. Pro zimní podmínky: Zvažte vertikální instalaci (méně sněhu)
  3. Pro bifaciální efekt: Zajistěte světlý podklad (písek, bílé kameny)
  4. Údržba: Pravidelné čištění zvýší výkon o 5-10%
  5. Monitorování: Sledujte pokles výkonu kvůli stárnutí (0.5%/rok)

Simulace vytvořena pro panel Hanersun N-TOPCon 700W v lokalitě Lago Brown, Chile
Datum: {}
Poznámka: Simulace předpokládá ideální podmínky - jasná obloha bez mraků, bez zastínění, konstantní sluneční svit

""".format( max(annual_totals.values()), min([v for k, v in annual_totals.items() if 'Tilt' in k]), annual_totals.get('Vertical North-South', 0), annual_totals.get('Vertical East-West', 0), datetime.now().strftime("%d.%m.%Y") ) return html_content def main(): simulation = BifacialSolarSimulation() print("🌞 Spouštím simulaci bifaciálního panelu pro Lago Brown, Chile...") print(f"Panel: Hanersun N-TOPCon 700W Bifacial") print(f"Lokace: {simulation.latitude}°, {simulation.longitude}°") print("Konfigurace: Vertikální N-S, Vertikální E-W, Sklony 20°-70°") print() # Run simulation results = simulation.run_simulation() # Create data tables monthly_table, hourly_tables = simulation.create_data_tables(results) # Create HTML report html_content = create_html_report(results, monthly_table, hourly_tables) # Save HTML report with open('/home/www/claudev.cz/orb3/solar_panel_report.html', 'w', encoding='utf-8') as f: f.write(html_content) # Calculate and display summary months = list(range(1, 13)) annual_totals = {} for config_name, data in results.items(): annual_total = sum(data[month]['energy_kwh'] for month in months) annual_totals[config_name] = annual_total print("\n📊 Souhrn roční výroby energie:") for config, total in annual_totals.items(): print(f" {config}: {total:.1f} kWh/rok") print(f"\n✅ HTML report byl vytvořen: solar_panel_report.html") print(f"🎯 Nejlepší konfigurace: {max(annual_totals, key=annual_totals.get)} ({max(annual_totals.values()):.1f} kWh/rok)") return results, monthly_table, hourly_tables if __name__ == "__main__": results, monthly_table, hourly_tables = main()