def data_setter(self, data): self.lats = data['lats'] self.longs = data['longs'] self.tilt = data['tilt'] self.surf_azi = data['surf_azi'] #since panel faces south self.altitude = data['altitude'] self.name = data['name'] self.timezone = data['timezone'] self.albedo = data['albedo'] self.mod_per_string = data['modules_per_string'] self.str_per_inv = data['strings_per_inverter'] try: self.panel_model = retrieve_sam('CECMod') self.panel_model = self.panel_model[data['module']] except: try: self.panel_model = retrieve_sam('SandiaMod') self.panel_model = self.panel_model[data['module']] except: return False, str('Module not found in the database!!') try: self.inverter_model = retrieve_sam('CECinverter') self.inverter_model = self.inverter_model[data['inverter']] except: try: self.inverter_model = retrieve_sam('SandiaInverter') self.inverter_model = self.inverter_model[data['inverter']] except: return False, str('Inverter model not found in the database!!') return True, str('Pass')
def sam_data(): data = {} data['cecmod'] = pvsystem.retrieve_sam('cecmod') data['sandiamod'] = pvsystem.retrieve_sam('sandiamod') data['cecinverter'] = pvsystem.retrieve_sam('cecinverter') data['adrinverter'] = pvsystem.retrieve_sam('adrinverter') return data
def test_retrieve_sam_raise_no_parameters(): """ Raise an exception if no parameters are provided to `retrieve_sam()`. """ with pytest.raises(ValueError) as error: pvsystem.retrieve_sam() assert 'A name or path must be provided!' == str(error.value)
def sam_data(): data = {} data['cecmod'] = pvsystem.retrieve_sam('cecmod') data['sandiamod'] = pvsystem.retrieve_sam('sandiamod') data['cecinverter'] = pvsystem.retrieve_sam('cecinverter') data['adrinverter'] = pvsystem.retrieve_sam('adrinverter') return data
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 system_parameters(): """System parameters for generating simulated power data.""" sandia_modules = pvsystem.retrieve_sam('SandiaMod') sapm_inverters = pvsystem.retrieve_sam('cecinverter') module = sandia_modules['Canadian_Solar_CS5P_220M___2009_'] inverter = sapm_inverters['ABB__MICRO_0_25_I_OUTD_US_208__208V_'] temperature_model_parameters = ( TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_glass']) return { 'module_parameters': module, 'inverter_parameters': inverter, 'temperature_model_parameters': temperature_model_parameters }
def test_retrieve_sam_cecinverter(): """ Test the expected data is retrieved from the CEC inverter database. In particular, check for a known inverter in the database and check for the expected keys for that inverter. """ data = pvsystem.retrieve_sam('cecinverter') keys = [ 'Vac', 'Paco', 'Pdco', 'Vdco', 'Pso', 'C0', 'C1', 'C2', 'C3', 'Pnt', 'Vdcmax', 'Idcmax', 'Mppt_low', 'Mppt_high', 'CEC_Date', 'CEC_Type', ] inverter = 'Yaskawa_Solectria_Solar__PVI_5300_208__208V_' assert inverter in data assert set(data[inverter].keys()) == set(keys)
def system_parameters(): """PVSystem parameters for generating simulated power data.""" sapm_inverters = pvsystem.retrieve_sam('cecinverter') inverter = sapm_inverters['ABB__MICRO_0_25_I_OUTD_US_208__208V_'] return { 'inverter_parameters': inverter, }
def AC_out(p_dc): ## Get list of inverters sapm_inverters = pvsystem.retrieve_sam('sandiainverter') ## Choose inverter (e.g. ABB__MICRO_0_25_I_OUTD_US_208_208V__CEC_2014) sapm_inverter = sapm_inverters[ 'ABB__MICRO_0_25_I_OUTD_US_208_208V__CEC_2014_'] ## Run SAPM model p_ac = pvsystem.snlinverter(p_dc.v_mp, p_dc.p_mp, sapm_inverter) return (p_ac)
def array_parameters(): """Array parameters for generating simulated power data.""" sandia_modules = pvsystem.retrieve_sam('SandiaMod') module = sandia_modules['Canadian_Solar_CS5P_220M___2009_'] temperature_model_parameters = ( TEMPERATURE_MODEL_PARAMETERS['sapm']['open_rack_glass_glass']) return { 'module_parameters': module, 'temperature_model_parameters': temperature_model_parameters }
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
def DC_out(solpos, poa_irrad, aoi, pvtemps): ## First calculate airmass airmass = atmosphere.relativeairmass(solpos['apparent_zenith']) ## Get list of modules sandia_modules = pvsystem.retrieve_sam('SandiaMod') ## Choose model (e.g. CS5P_220M___2009) sandia_module = sandia_modules.Canadian_Solar_CS5P_220M___2009_ ## Run SAPM model effective_irradiance = pvsystem.sapm_effective_irradiance( poa_irrad.poa_direct, poa_irrad.poa_diffuse, airmass, aoi, sandia_module) p_dc = pvsystem.sapm(effective_irradiance, pvtemps['temp_cell'], sandia_module) return (p_dc)
def prepare_data(): print('preparing single diode data from clear sky ghi...') # adjust values to change length of test data times = pd.DatetimeIndex(start='20180101', end='20190101', freq='1min', tz='America/Phoenix') location = pvlib.location.Location(32.2, -110.9, altitude=710) cs = location.get_clearsky(times) poa_data = cs['ghi'] cec_modules = pvsystem.retrieve_sam('cecmod') cec_module_params = cec_modules['Example_Module'] IL, I0, Rs, Rsh, nNsVth = pvsystem.calcparams_desoto( poa_data, temp_cell=25, alpha_isc=cec_module_params['alpha_sc'], module_parameters=cec_module_params, EgRef=1.121, dEgdT=-0.0002677) return IL, I0, Rs, Rsh, nNsVth
def test_retrieve_sam_cecmod(): """ Test the expected data is retrieved from the CEC module database. In particular, check for a known module in the database and check for the expected keys for that module. """ data = pvsystem.retrieve_sam('cecmod') keys = [ 'BIPV', 'Date', 'T_NOCT', 'A_c', 'N_s', 'I_sc_ref', 'V_oc_ref', 'I_mp_ref', 'V_mp_ref', 'alpha_sc', 'beta_oc', 'a_ref', 'I_L_ref', 'I_o_ref', 'R_s', 'R_sh_ref', 'Adjust', 'gamma_r', 'Version', 'STC', 'PTC', 'Technology', 'Bifacial', 'Length', 'Width', ] module = 'Itek_Energy_LLC_iT_300_HE' assert module in data assert set(data[module].keys()) == set(keys)
def chooseCECModuleCoeffs(file='sam-library-cec-modules-2015-6-30.csv', module_model='1Soltech_1STH_245_WH'): ''' This function helps choose a module from CEC module database and its output can be used to generate matrices for a large collection of modules. Parameters ---------- file: String A path to file that contains the module database. Could be the original or a (shorter) copy of that module_model: String A module name from the database Returns ------- module_params_stc: A dictionary of the STC parameters of the modules needed for the one diode model Also see generateMatrix ''' module_coeffs = pvsystem.retrieve_sam(name="CECMod", samfile=file) try: test_module = module_coeffs[module_model] module_params_stc = test_module.to_dict() except KeyError: raise KeyError( 'The chosen model does not exist or is typed incorrectly') return module_params_stc
import datetime as dt import pandas as pd import pvlib.atmosphere as atmosphere import pvlib.irradiance as irradiance import pvlib.pvsystem as pvsystem import pvlib.solarposition as solarposition from pvlib.location import Location _sandia_modules = pvsystem.retrieve_sam('SandiaMod') _cec_inverters = pvsystem.retrieve_sam('cecinverter') _sandia_module = _sandia_modules['Silevo_Triex_U300_Black__2014_'] _cec_inverter = _cec_inverters['ABB__MICRO_0_25_I_OUTD_US_208_208V__CEC_2014_'] _munich_location = Location(48.3, 11.8, 'CET', 447, 'Munich') _module_count = 20 def get_perfect_voltage_for_a_day(start, freq): """This method is used to build a pandas serie with voltage values. This serie has DateTime index and contains a value for every "freq" seconds during 24 hours starting from "start" date. There are several assumptions: 1. Location is Munich 2. A battery is pointing to the south, amount of blocks is 20 3. Sandia Module database is used 4. pvlib library is heavily used :param start: datetime. First timestamp in result series :param freq: str. How often voltage should be sampled :return: voltage : Series """
""" testing single-diode methods using JW Bishop 1988 """ import numpy as np from pvlib import pvsystem from pvlib.singlediode import bishop88, estimate_voc, VOLTAGE_BUILTIN import pytest from conftest import requires_scipy POA = 888 TCELL = 55 CECMOD = pvsystem.retrieve_sam('cecmod') @requires_scipy def test_newton_spr_e20_327(): """test pvsystem.singlediode with Newton method on SPR-E20-327""" spr_e20_327 = CECMOD.SunPower_SPR_E20_327 x = pvsystem.calcparams_desoto( effective_irradiance=POA, temp_cell=TCELL, alpha_sc=spr_e20_327.alpha_sc, a_ref=spr_e20_327.a_ref, I_L_ref=spr_e20_327.I_L_ref, I_o_ref=spr_e20_327.I_o_ref, R_sh_ref=spr_e20_327.R_sh_ref, R_s=spr_e20_327.R_s, EgRef=1.121, dEgdT=-0.0002677) il, io, rs, rsh, nnsvt = x pvs = pvsystem.singlediode(*x, method='lambertw') out = pvsystem.singlediode(*x, method='newton') isc, voc, imp, vmp, pmp, ix, ixx = out.values() assert np.isclose(pvs['i_sc'], isc) assert np.isclose(pvs['v_oc'], voc)
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 test_retrieve_sam_network(): sam_data["cecmod"] = pvsystem.retrieve_sam("cecmod") sam_data["sandiamod"] = pvsystem.retrieve_sam("sandiamod") sam_data["cecinverter"] = pvsystem.retrieve_sam("cecinverter")
tz = 'Etc/GMT+5' times = pd.date_range('2021-06-21', '2021-6-22', freq='1T', tz=tz) # create site system characteristics axis_tilt = 0 axis_azimuth = 180 gcr = 0.35 max_angle = 60 pvrow_height = 3 pvrow_width = 4 albedo = 0.2 bifaciality = 0.75 # load temperature parameters and module/inverter specifications temp_model_parameters = PARAMS['sapm']['open_rack_glass_glass'] cec_modules = pvsystem.retrieve_sam('CECMod') cec_module = cec_modules['Trina_Solar_TSM_300DEG5C_07_II_'] cec_inverters = pvsystem.retrieve_sam('cecinverter') cec_inverter = cec_inverters['ABB__MICRO_0_25_I_OUTD_US_208__208V_'] # create a location for site, and get solar position and clearsky data site_location = location.Location(lat, lon, tz=tz, name='Greensboro, NC') solar_position = site_location.get_solarposition(times) cs = site_location.get_clearsky(times) # load solar position and tracker orientation for use in pvsystem object sat_mount = pvsystem.SingleAxisTrackerMount(axis_tilt=axis_tilt, axis_azimuth=axis_azimuth, max_angle=max_angle, backtrack=True, gcr=gcr)
""" Retrieve standard sets of parameters """ from typing import List from fastapi import APIRouter, HTTPException, Path from pvlib.pvsystem import retrieve_sam # type: ignore from .. import models router = APIRouter() sandia_inverter_params = ( retrieve_sam("CECInverter").loc[models.SandiaInverterParameters.schema() ["properties"].keys()].astype(float)) # Database does not provide the fields 'EgRef', 'dEgdT' # which have defaults in the model. cec_keys = [ "alpha_sc", "a_ref", "I_L_ref", "I_o_ref", "R_sh_ref", "R_s", "gamma_r", "Adjust", "N_s", ] cec_module_params = (retrieve_sam("CECMod").loc[cec_keys].astype(float).rename( index={"N_s": "cells_in_series"}))
def __init__(self): self.inverters = retrieve_sam(name='SandiaInverter') self.inverter = None
def test_retrieve_sam_network(): sam_data['cecmod'] = pvsystem.retrieve_sam('cecmod') sam_data['sandiamod'] = pvsystem.retrieve_sam('sandiamod') sam_data['sandiainverter'] = pvsystem.retrieve_sam('sandiainverter')
def get_inv_list(): inv_list = list([]) avlb_invs = ['CECInverter', 'SandiaInverter', 'ADRInverter'] for invs in avlb_invs: inv_list = inv_list + retrieve_sam(invs).columns.values.tolist() return inv_list
def run_sim_on_tracker(tracker, tmy_data, sand_point, albedo, n_epochs=10, n_steps=500,): ''' Returns power, angle history ''' # print("running {} \n".format(tracker.name)) sandia_modules = retrieve_sam('sandiamod') cec_inverters = retrieve_sam('cecinverter') module = sandia_modules['Canadian_Solar_CS5P_220M___2009_'] cap = float(module['Isco']*module['Voco']/(10**6)) #convert to MW #TODO: save previous state/reward for e in range(n_epochs): #returning results from most recent epoch #TODO: avoid successive concats total = pd.DataFrame() angles = np.zeros((n_steps,)) energy_consumed_move = np.zeros((n_steps,)) temps = pd.DataFrame() radiation_rows = [] ac_all = np.zeros((n_steps,)) surface_azimuth = tracker.get_azimuth() old_tilt = 0 prev_reward = 0 for i in range(n_steps): print(i) current_step_data = tmy_data[tmy_data.index[i]:tmy_data.index[i]] solpos = pvlib.solarposition.get_solarposition(current_step_data.index, sand_point.latitude, sand_point.longitude) state = tmy_step_to_OOMDP(current_step_data, tracker, solpos, old_tilt, albedo) surface_tilt = float(tracker.get_angle(state, prev_reward)) angles[i] = surface_tilt sapm_out, ac, rad_timestep, pvtemps = calculate_energy(surface_tilt, surface_azimuth, albedo, current_step_data['Wspd'], current_step_data['DryBulb'], current_step_data.index, solpos, current_step_data['DHI'], current_step_data['DNI'], current_step_data['GHI'], tracker.name) radiation_rows.append(rad_timestep) eng_consumed_move = energy_motion(old_tilt, surface_tilt, cap) old_tilt = surface_tilt prev_reward = float(ac) - eng_consumed_move*1000 energy_consumed_move[i] = eng_consumed_move ac_all[i] = ac - eng_consumed_move*1000 #kwh to wh temps = temps.append(pvtemps) #convert angles to df angles_series = pd.Series(angles, index=tmy_data.index[0:n_steps]) energy_consumed = pd.Series(energy_consumed_move, index=tmy_data.index[0:n_steps]) radiation = pd.concat(radiation_rows, axis=0) #rename temps.rename(columns={'temp_cell': 'cell temp {}'.format(tracker.name)}, inplace=True) angles_df = pd.DataFrame(angles_series, columns=['angle {}'.format(tracker.name)]) energy_consumed_df = pd.DataFrame(energy_consumed, columns=['energy consumed {}'.format(tracker.name)]) ac_total = pd.Series(ac_all, index=tmy_data.index[0:n_steps]) sum = ac_total.sum() ac_df = pd.DataFrame(ac_total, columns=['ac_step']) ac_df['p cumulative {}'.format(tracker.name)] = ac_df.cumsum() return ac_df, angles_df, temps, energy_consumed_df, radiation, sum
def simulate_power_by_station(station_index, surface_tilt, surface_azimuth, pv_module, tcell_model_parameters, ghi, tamb, wspd, albedo, days, lead_times, air_mass, dni_extra, zenith, apparent_zenith, azimuth): """ This is the worker function for simulating power at a specified location. This function should be used inside of `simulate_power` and direct usage is discouraged. :param station_index: A station index :param ghi: See `simulate_power` :param tamb: See `simulate_power` :param wspd: See `simulate_power` :param albedo: See `simulate_power` :param days: See `simulate_power` :param lead_times: See `simulate_power` :param air_mass: See `simulate_power` :param dni_extra: See `simulate_power` :param zenith: See `simulate_power` :param apparent_zenith: See `simulate_power` :param azimuth: See `simulate_power` :param surface_tilt: See `simulate_power` :param surface_azimuth: See `simulate_power` :param pv_module: A PV module name :param tcell_model_parameters: A cell module name :return: A list with power, cell temperature, and the effective irradiance """ # Sanity check assert 0 <= station_index < ghi.shape[3], 'Invalid station index' # Determine the dimensions num_analogs = ghi.shape[0] num_lead_times = ghi.shape[1] num_days = ghi.shape[2] # Initialization p_mp = np.zeros((num_analogs, num_lead_times, num_days)) tcell = np.zeros((num_analogs, num_lead_times, num_days)) effective_irradiance = np.zeros((num_analogs, num_lead_times, num_days)) pv_module = pvsystem.retrieve_sam("SandiaMod")[pv_module] tcell_model_parameters = temperature.TEMPERATURE_MODEL_PARAMETERS["sapm"][ tcell_model_parameters] for day_index in range(num_days): for lead_time_index in range(num_lead_times): # Determine the current time current_posix = days[day_index] + lead_times[lead_time_index] current_time = pd.Timestamp(current_posix, tz="UTC", unit='s') for analog_index in range(num_analogs): ghi_ = ghi[analog_index, lead_time_index, day_index, station_index] if ghi_ == 0: continue albedo_ = albedo[analog_index, lead_time_index, day_index, station_index] wspd_ = wspd[analog_index, lead_time_index, day_index, station_index] tamb_ = tamb[analog_index, lead_time_index, day_index, station_index] air_mass_ = air_mass[lead_time_index, day_index, station_index] dni_extra_ = dni_extra[lead_time_index, day_index, station_index] zenith_ = zenith[lead_time_index, day_index, station_index] apparent_zenith_ = apparent_zenith[lead_time_index, day_index, station_index] azimuth_ = azimuth[lead_time_index, day_index, station_index] ########################################################################################## # # # Core procedures of simulating power at one location # # # ########################################################################################## # Decompose DNI from GHI dni_dict = irradiance.disc(ghi_, zenith_, current_time) # Calculate POA sky diffuse poa_sky_diffuse = irradiance.haydavies( surface_tilt, surface_azimuth, ghi_, dni_dict["dni"], dni_extra_, apparent_zenith_, azimuth_) # Calculate POA ground diffuse poa_ground_diffuse = irradiance.get_ground_diffuse( surface_tilt, ghi_, albedo_) # Calculate angle of incidence aoi = irradiance.aoi(surface_tilt, surface_azimuth, apparent_zenith_, azimuth_) # Calculate POA total poa_irradiance = irradiance.poa_components( aoi, dni_dict["dni"], poa_sky_diffuse, poa_ground_diffuse) # Calculate cell temperature tcell[analog_index, lead_time_index, day_index] = pvsystem.temperature.sapm_cell( poa_irradiance['poa_global'], tamb_, wspd_, tcell_model_parameters['a'], tcell_model_parameters['b'], tcell_model_parameters["deltaT"]) # Calculate effective irradiance effective_irradiance[ analog_index, lead_time_index, day_index] = pvsystem.sapm_effective_irradiance( poa_irradiance['poa_direct'], poa_irradiance['poa_diffuse'], air_mass_, aoi, pv_module) # Calculate power sapm_out = pvsystem.sapm( effective_irradiance[analog_index, lead_time_index, day_index], tcell[analog_index, lead_time_index, day_index], pv_module) # Save output to numpy p_mp[analog_index, lead_time_index, day_index] = sapm_out["p_mp"] return [p_mp, tcell, effective_irradiance]
import os import numpy as np import pandas as pd from pvlib import pvsystem from pvlib.singlediode_methods import bishop88, estimate_voc logging.basicConfig() LOGGER = logging.getLogger(__name__) LOGGER.setLevel(logging.DEBUG) TEST_DATA = 'bishop88_numerical_precision.csv' TEST_PATH = os.path.dirname(os.path.abspath(__file__)) PVLIB_PATH = os.path.dirname(TEST_PATH) DATA_PATH = os.path.join(PVLIB_PATH, 'data', TEST_DATA) POA = 888 TCELL = 55 CECMOD = pvsystem.retrieve_sam('cecmod') # get module from cecmod and apply temp/irrad desoto corrections SPR_E20_327 = CECMOD.SunPower_SPR_E20_327 ARGS = pvsystem.calcparams_desoto(effective_irradiance=POA, temp_cell=TCELL, alpha_sc=SPR_E20_327.alpha_sc, a_ref=SPR_E20_327.a_ref, I_L_ref=SPR_E20_327.I_L_ref, I_o_ref=SPR_E20_327.I_o_ref, R_sh_ref=SPR_E20_327.R_sh_ref, R_s=SPR_E20_327.R_s, EgRef=1.121, dEgdT=-0.0002677) IL, I0, RS, RSH, NNSVTH = ARGS IVCURVE_NPTS = 100
def get_panel_list(): panel_list = list([]) avlb_mods = ['SandiaMod', 'CECMod'] for mods in avlb_mods: panel_list = panel_list + retrieve_sam(mods).columns.values.tolist() return panel_list
#running PVLib simulation in steps from pvlib.pvsystem import PVSystem, retrieve_sam from pvlib.tracking import SingleAxisTracker from pvlib.modelchain import ModelChain from pvlib.forecast import GFS, NAM, NDFD, HRRR, RAP import pandas as pd import datetime import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt #set up system sandia_modules = retrieve_sam('sandiamod') cec_inverters = retrieve_sam('cecinverter') module = sandia_modules['Canadian_Solar_CS5P_220M___2009_'] inverter = cec_inverters['SMA_America__SC630CP_US_315V__CEC_2012_'] system = PVSystem(surface_tilt=20, surface_azimuth=200, module_parameters=module, inverter_parameters=inverter, modules_per_string=15, strings_per_inverter=300) latitude, longitude, tz = 32.2, -110.9, 'US/Arizona' start = pd.Timestamp(datetime.date.today() - pd.Timedelta(days=20), tz=tz) end = start + pd.Timedelta(days=7) # model = GFS()
def __init__(self): self.modules = retrieve_sam(name='SandiaMod') self.module = None
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})
import dash_core_components as dcc import dash_html_components as html import dash_bootstrap_components as dbc from pvlib import pvsystem all_modules = pvsystem.retrieve_sam(name='SandiaMod') module_names = list(all_modules.columns) layout = html.Div([ dbc.Nav( [ dbc.NavItem(dbc.NavLink('Home Page', href='/', style= {'color': 'white'}, external_link=True)), dbc.NavItem(dbc.NavLink('Load Configuration', href='/dashapp_profile/', style= {'color': 'white'}, external_link=True)), dbc.NavItem(dbc.NavLink('Simulation', active=True, href='/dashapp_simulation/', style= {'color': 'white'}, external_link=True)) ], className= 'navbar navbar-expand-lg navbar-dark bg-dark fixed-top' ), html.Div([ html.Div([ html.H5('Select Graph'), dcc.Dropdown( id='select_Graph', options=[ {'label': 'Costs', 'value': 'cost_graph'}, {'label': 'Energy Overview', 'value': 'power_graph'} ], value= 'cost_graph') ], className='col-3'), ], className='row', style={'paddingTop': '60px'}),
def retrieve_sam_network(): sam_data['cecmod'] = pvsystem.retrieve_sam('cecmod') sam_data['sandiamod'] = pvsystem.retrieve_sam('sandiamod') sam_data['cecinverter'] = pvsystem.retrieve_sam('cecinverter')
# 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, forecast_data['dhi'], forecast_data['dni'], dni_extra, solpos['apparent_zenith'], solpos['azimuth'])