def load_GFS_data(latitude=33.8688,
longitude=151.2093,
tz='Australia/Sydney',
days=7):
# latitude, longitude, tz = 32.2, -110.9, 'US/Arizona'
# latitude, longitude, tz = 32.2, -110.9, 'US/Arizona'
# latitude = 33.8688
# longitude=151.2093
# tz='Australia/Sydney'
start = pd.Timestamp(datetime.date.today(), tz=tz)
end = start + pd.Timedelta(days=7)
irrad_vars = ['ghi', 'dni', 'dhi']
model = GFS()
raw_data = model.get_data(latitude, longitude, start, end)
print(raw_data.head())
data = raw_data
data = model.rename(data)
data['temp_air'] = model.kelvin_to_celsius(data['temp_air'])
data['wind_speed'] = model.uv_to_speed(data)
irrad_data = model.cloud_cover_to_irradiance(data['total_clouds'])
data = data.join(irrad_data, how='outer')
data = data[model.output_variables]
print(data.head())
data = model.process_data(raw_data)
print(data.head())
data = model.get_processed_data(latitude, longitude, start, end)
print(data.head())
return (data)
def __get_weather(self, start: pd.Timestamp, end: pd.Timestamp) -> pd.DataFrame:
"""
Get weather data for period.
:param start: - pd.Timestamp, begin of period
:param end: - pd.Timestamp, end of period
:return: pd.DataFrame,
Column names are: ``ghi, dni, dhi``
"""
fx_model = GFS()
return fx_model.get_processed_data(self.geo["latitude"], self.geo["longitude"], start, end)
def download_forecasts(request):
modules_per_string = request.session['modules_per_string']
strings_per_inverter = request.session['strings_per_inverter']
module = request.session['module']
inverter = request.session['inverter']
latitude = request.session['latitude']
longitude = request.session['longitude']
tz = request.session['timezone']
sandia_modules = retrieve_sam('SandiaMod')
cec_inverters = retrieve_sam('SandiaInverter')
# Parametros de la granja solar
surface_tilt = 30
surface_azimuth = 180 # pvlib uses 0=North, 90=East, 180=South, 270=West convention
albedo = 0.2
# Rango de tiempo
start = pd.Timestamp(date.today(), tz=tz)
# Pronostico a 3 días en adelante
end = start + pd.Timedelta(days=3)
module = pd.Series(sandia_modules[module])
inverter = cec_inverters[inverter]
# model a big tracker for more fun
system = SingleAxisTracker(module_parameters=module,
inverter_parameters=inverter,
modules_per_string=modules_per_string,
strings_per_inverter=strings_per_inverter)
# fx is a common abbreviation for forecast
fx_model = GFS()
fx_data = fx_model.get_processed_data(latitude, longitude, start, end)
# use a ModelChain object to calculate modeling intermediates
mc = ModelChain(system, fx_model.location)
# extract relevant data for model chain
mc.run_model(fx_data.index, weather=fx_data)
AC = mc.ac.fillna(0)
response = HttpResponse(content_type='text/csv')
response[
'Content-Disposition'] = 'attachment; filename=AC_5days_forecasts.csv'
AC.to_csv(path_or_buf=response,
sep=';',
float_format='%.2f',
index=True,
decimal=",")
return response
def get_cast(start_date, end_date):
from pvlib.pvsystem import PVSystem, retrieve_sam
from pvlib.temperature import TEMPERATURE_MODEL_PARAMETERS
from pvlib.tracking import SingleAxisTracker
from pvlib.modelchain import ModelChain
sandia_modules = retrieve_sam('sandiamod')
cec_inverters = retrieve_sam('cecinverter')
module = sandia_modules['SolarWorld_Sunmodule_250_Poly__2013_']
inverter = cec_inverters['ABB__TRIO_20_0_TL_OUTD_S1_US_480__480V_']
temperature_model_parameters = TEMPERATURE_MODEL_PARAMETERS['sapm'][
'open_rack_glass_glass']
# model a single axis tracker
system = SingleAxisTracker(
module_parameters=module,
inverter_parameters=inverter,
temperature_model_parameters=temperature_model_parameters,
modules_per_string=15,
strings_per_inverter=4)
# fx is a common abbreviation for forecast
fx_model = GFS()
forecast_mod = fx_model.get_processed_data(latitude, longitude, start_date,
end_date)
# use a ModelChain object to calculate modeling intermediates
mchain = ModelChain(system, fx_model.location)
# extract relevant data for model chain
mchain.run_model(forecast_mod)
acp = mchain.ac.fillna(0)
return acp
import pandas as pd
import datetime
from pvlib.forecast import GFS
# specify location (Tucson, AZ)
latitude, longitude, tz = 32.2, -110.9, 'US/Arizona'
# specify time range.
start = pd.Timestamp(datetime.date.today(), tz=tz)
end = start + pd.Timedelta(days=7)
irrad_vars = ['ghi', 'dni', 'dhi']
model = GFS()
processed_data = model.get_processed_data(latitude=latitude,
longitude=longitude,
start=start,
end=end,
headers={
'User-Agent': 'UserNoAuth',
'Front-End-Https': 'on'
},
verify=False)
'SMA_America__SC630CP_US__with_ABB_EcoDry_Ultra_transformer_']
temperature_model_parameters = TEMPERATURE_MODEL_PARAMETERS['sapm'][
'open_rack_glass_polymer']
system = PVSystem(surface_tilt=20,
surface_azimuth=180,
module_parameters=myModule,
inverter_parameters=inverter,
temperature_model_parameters=temperature_model_parameters,
modules_per_string=25,
strings_per_inverter=8)
fx_model = GFS()
fx_data = fx_model.get_processed_data(latitudeEsfahan, longitudeEsfahan, start,
end)
fx_data = fx_data.resample('60min').interpolate()
mc = ModelChain(system, fx_model.location)
mc.run_model(fx_data)
data = (mc.results.ac.fillna(0) / 200 / 274)
data = list(zip(data, data.index))
conn = psycopg2.connect(
user="******",
password="******",
host="ec2-63-34-97-163.eu-west-1.compute.amazonaws.com",
port="5432",
database="d94t9tih4i30sp")
cur = conn.cursor()
latitude = -28.893597
longitude = 31.468293
tz = 'Africa/Johannesburg'
surface_tilt = 30
surface_azimuth = 180
albedo = 0.2
#Set beginning and end date
end = pd.Timestamp(datetime.date.today(), tz=tz)
start = end - timedelta(12)
# Define forecast model
fm = GFS()
# Retrieve data from forecast API and perform data preparation
previous_forecast = fm.get_processed_data(latitude, longitude, start, end)
previous_forecast.index = previous_forecast.index.strftime('%Y-%m-%d %H:%M:%S')
previous_forecast.index = pd.to_datetime(previous_forecast.index)
#resample to three hours to match weather data sampling rate
data_res = physical_asset.resample('3H').mean()
#set datetime limits of solar farm data to match weather data
forecast_dates = previous_forecast.index
start_datetime = forecast_dates[0]
list_r = data_res.index
stop_datetime = list_r[-5]
date_ranges = [start_datetime, stop_datetime]
data_res = data_res[start_datetime:stop_datetime]
start = pd.Timestamp(datetime.date.today(), tz=tz) # today's date
end = start + pd.Timedelta(days=7) # 7 days from today
# Define forecast model
fm = GFS()
#fm = NAM()
#fm = NDFD()
#fm = RAP()
#fm = HRRR()
# Retrieve data
forecast_data = fm.get_processed_data(latitude, longitude, start, end)
ghi = forecast_data['ghi']
sandia_modules = pvsystem.retrieve_sam('SandiaMod')
sandia_module = sandia_modules.Canadian_Solar_CS5P_220M___2009_
# retrieve time and location parameters
time = forecast_data.index
a_point = fm.location
solpos = a_point.get_solarposition(time)
dni_extra = irradiance.get_extra_radiation(fm.time)
airmass = atmosphere.get_relative_airmass(solpos['apparent_zenith'])
poa_sky_diffuse = irradiance.haydavies(surface_tilt, surface_azimuth,
start_time = timeit.default_timer()
radiationForecast = RadiationFrameHandler.forecast(location)
elapsed = timeit.default_timer() - start_time
print("Solcast Radiation Forecast Location: %s Time: %s (seconds)" %
(location.name, '%.6f' % elapsed))
# specify time range with timezone
start = pd.Timestamp(datetime.date.today(), tz=location.timezone)
end = start + pd.Timedelta(days=7)
start_time = timeit.default_timer()
# fx is a common abbreviation for forecast
fx_model = GFS(
) # From Forecast models http://pvlib-python.readthedocs.io/en/latest/api.html#forecast-models
fx_data = fx_model.get_processed_data(location.lat, location.lng, start, end)
elapsed = timeit.default_timer() - start_time
print("pvlib (GFS) Radiation Forecast Location: %s Time: %s (seconds)" %
(location.name, '%.6f' % elapsed))
plt.plot(fx_data.ghi, label="ghi - PVLIB (GFS)")
plt.plot(radiationForecast.ghi, label="ghi - Solcast", linestyle='dashdot')
plt.plot(fx_data.dhi, label="dhi - PVLIB (GFS)")
plt.plot(radiationForecast.dhi, label="dhi - Solcast", linestyle='dashdot')
plt.plot(fx_data.dni, label="dni - PVLIB (GFS)")
plt.plot(radiationForecast.dni, label="dni - Solcast", linestyle='dashdot')
plt.legend()
plt.show()
class Forecast():
# forecast_models = [GFS(), NAM(), NDFD(), RAP(), HRRR()]
def get_avg_daily_dc_power(self):
total = self.sapm_out.p_mp.values.sum()
avg = total / self.forecast_length
return np.format_float_positional(avg, precision=3)
def get_avg_daily_ac_power(self):
total = self.ac_power.values.sum()
avg = total / self.forecast_length
return np.format_float_positional(avg, precision=3)
# forecast_length in days
def __init__(self, panel=None, forecast_length=7, forecast_model=None):
self.forecast_length = forecast_length
if panel == None:
self.panel = Panel()
else:
self.panel = panel
if forecast_model == None:
self.fm = GFS()
else:
self.fm = forecast_model
self.start = pd.Timestamp(datetime.date.today(),
tz=self.panel.tz) # today's date
self.end = self.start + pd.Timedelta(
days=forecast_length) # days from today
print(
"getting processed data with lat: %s, lng: %s, start:%s, end:%s" %
(self.panel.latitude, self.panel.longitude, self.start, self.end))
# get forecast data
forecast_data = self.fm.get_processed_data(self.panel.latitude,
self.panel.longitude,
self.start, self.end)
ghi = forecast_data['ghi']
# get solar position
time = forecast_data.index
a_point = self.fm.location
solpos = a_point.get_solarposition(time)
# get PV(photovoltaic device) modules
sandia_modules = pvsystem.retrieve_sam('SandiaMod')
sandia_module = sandia_modules.Canadian_Solar_CS5P_220M___2009_
dni_extra = irradiance.get_extra_radiation(
self.fm.time) # extra terrestrial radiation
airmass = atmosphere.get_relative_airmass(solpos['apparent_zenith'])
# POA: Plane Of Array: an image sensing device consisting of an array
# (typically rectangular) of light-sensing pixels at the focal plane of a lens.
# https://en.wikipedia.org/wiki/Staring_array
# Diffuse sky radiation is solar radiation reaching the Earth's surface after
# having been scattered from the direct solar beam by molecules or particulates
# in the atmosphere.
# https://en.wikipedia.org/wiki/Diffuse_sky_radiation
poa_sky_diffuse = irradiance.haydavies(self.panel.surface_tilt,
self.panel.surface_azimuth,
forecast_data['dhi'],
forecast_data['dni'], dni_extra,
solpos['apparent_zenith'],
solpos['azimuth'])
# Diffuse reflection is the reflection of light or other waves or particles
# from a surface such that a ray incident on the surface is scattered at many
# angles rather than at just one angle as in the case of specular reflection.
poa_ground_diffuse = irradiance.get_ground_diffuse(
self.panel.surface_tilt, ghi, albedo=self.panel.albedo)
# AOI: Angle Of Incidence
aoi = irradiance.aoi(self.panel.surface_tilt,
self.panel.surface_azimuth,
solpos['apparent_zenith'], solpos['azimuth'])
# irradiance is the radiant flux (power) received by a surface per unit area
# https://en.wikipedia.org/wiki/Irradiance
poa_irrad = irradiance.poa_components(aoi, forecast_data['dni'],
poa_sky_diffuse,
poa_ground_diffuse)
temperature = forecast_data['temp_air']
wnd_spd = forecast_data['wind_speed']
# pvtemps: pv temperature
pvtemps = pvsystem.sapm_celltemp(poa_irrad['poa_global'], wnd_spd,
temperature)
# irradiance actually used by PV
effective_irradiance = pvsystem.sapm_effective_irradiance(
poa_irrad.poa_direct, poa_irrad.poa_diffuse, airmass, aoi,
sandia_module)
# SAPM: Sandia PV Array Performance Model
# https://pvpmc.sandia.gov/modeling-steps/2-dc-module-iv/point-value-models/sandia-pv-array-performance-model/
self.sapm_out = pvsystem.sapm(effective_irradiance,
pvtemps['temp_cell'], sandia_module)
sapm_inverters = pvsystem.retrieve_sam('sandiainverter')
sapm_inverter = sapm_inverters[
'ABB__MICRO_0_25_I_OUTD_US_208_208V__CEC_2014_']
self.ac_power = pvsystem.snlinverter(self.sapm_out.v_mp,
self.sapm_out.p_mp, sapm_inverter)
def pvlib_location(request):
if request.method == 'POST':
formulario = location_pv(request.POST)
if formulario.is_valid():
params = formulario.cleaned_data
#Creación del diccionario para las caracteristicas del modulo PV utilizado en Cutonalá
#Canadian_Solar_CS6X_320P___2016_ = {"Vintage": 2016, "Area":1.91 , "Material": "Poly-crystalline", "Cells_in_Series": 72, "Parallel_Strings": 1,
# "Isco":9.26, "Voco":45.3, "Impo":8.69, "Vmpo":36.8, "Aisc":0.000397, "Aimp":0.000181, "C0":1.01284, "C1":-0.0128398, "Bvoco":-0.21696,
# "Mbvoc":0, "Bvmpo":-0.235488, "Mbvmp":0, "N":1.4032, "C2":0.279317, "C3":-7.24463, "A0":0.928385, "A1":0.068093, "A2":-0.0157738, "A3":0.0016605999999999997,
# "A4":-6.929999999999999e-05, "B0":1, "B1":-0.002438, "B2":0.0003103, "B3":-1.246e-05, "B4":2.1100000000000002e-07, "B5":-1.36e-09, "DTC":3.0, "FD":1, "A":-3.4064099999999997, "B":-0.0842075, "C4":0.9964459999999999,
# "C5":0.003554, "IXO":4.97599, "IXXO":3.18803, "C6":1.15535, "C7":-0.155353, "Notes":"caracteristicas del modulo instalado en CUT"}
#module = pd.Series(Canadian_Solar_CS6X_320P___2016_, name="Canadian_Solar_CS6X_320P___2016_")
#Modulo desde la librería de Sandia labs
#cec_inverters = retrieve_sam('cecinverter')
#inverter = cec_inverters['SMA_America__SC630CP_US_315V__CEC_2012_']
modules_per_string = params['modules_per_string']
strings_per_inverter = params['strings_per_inverter']
module = params['module']
inverter = params['inverter']
request.session['modules_per_string'] = modules_per_string
request.session['strings_per_inverter'] = strings_per_inverter
request.session['module'] = module
request.session['inverter'] = inverter
#Calcular la potencia CD, aqui debemos tener el diccionario para el tipo de Modulo en CUTonalá
sandia_modules = retrieve_sam('SandiaMod')
#### Modulo desde la librería de Sandia labs
cec_inverters = retrieve_sam('cecinverter')
# Lugar Tonalá
latitude, longitude = params['latitude'], params['longitude']
request.session['latitude'] = latitude
request.session['longitude'] = longitude
tz = tzwhere.tzwhere().tzNameAt(latitude, longitude)
request.session['timezone'] = tz
# Parametros de la granja solar
surface_tilt = 30
surface_azimuth = 180 # pvlib uses 0=North, 90=East, 180=South, 270=West convention
albedo = 0.2
# Rango de tiempo
start = pd.Timestamp(date.today(), tz=tz)
# Pronostico a 3 días en adelante
end = start + pd.Timedelta(days=5)
module = pd.Series(sandia_modules[module])
inverter = cec_inverters[inverter]
# model a big tracker for more fun
system = SingleAxisTracker(
module_parameters=module,
inverter_parameters=inverter,
modules_per_string=modules_per_string,
strings_per_inverter=strings_per_inverter)
# fx is a common abbreviation for forecast
fx_model = GFS()
fx_data = fx_model.get_processed_data(latitude, longitude, start,
end)
# use a ModelChain object to calculate modeling intermediates
mc = ModelChain(system, fx_model.location)
# extract relevant data for model chain
mc.run_model(fx_data.index, weather=fx_data)
#mc.run_model(fx_data)
AC = mc.ac.fillna(0)
#AC = pd.DataFrame(AC)
#labeles = AC.keys()
#valores = AC.values()
#data = {
# "Dates": labeles,
# "Power (W)": valores,
#}
#here we print the data the correct thing would be to use them to graph them
#print(AC.head())
#return render(request, 'chart.html', {'forma': formulario})
template = 'chart.html'
#columns = [{'field': 'date', 'title': 'Date'}, {'field': 'value', 'title': 'Value'}]
#Write the DataFrame to JSON (as easy as can be)
#json = AC.to_json(orient='records') # output just the records (no fieldnames) as a collection of tuples
#Proceed to create your context object containing the columns and the data
#context = {
# 'data': json,
# 'columns': columns
# }
#And render it!
#return render(request, template, context)
AC = AC.reset_index()
AC.rename(columns={
'index': 'Time',
0: 'AC Power (W)'
},
inplace=True)
figure = px.line(AC, x='Time', y='AC Power (W)')
#figure.update_layout(title="Your 5 days AC power output forecast (W)", font=dict(size=20, color='black'))
#figure.update_xaxes(title_font=dict(size=16, color='black'))
#figure.update_yaxes(title_font=dict(size=16, color='black'))
figure.update_xaxes(dtick=10800000)
plot_div = plot(figure,
image_height='100%',
output_type='div',
include_plotlyjs=False)
context = {'linechart': plot_div}
return render(request, template, context)
else:
formulario = location_pv()
return render(request, 'forecast_data.html', {'form': formulario})
