def test_tower_with_dispatch_model(site): """Testing pySSC tower model using HOPP built-in dispatch model""" expected_energy = 3842225.688 interconnection_size_kw = 50000 technologies = { 'tower': { 'cycle_capacity_kw': 50 * 1000, 'solar_multiple': 2.0, 'tes_hours': 6.0, 'optimize_field_before_sim': False } } system = HybridSimulation(technologies, site, interconnect_kw=interconnection_size_kw, dispatch_options={ 'is_test_start_year': True, 'is_test_end_year': True }) system.tower.value('helio_width', 10.0) system.tower.value('helio_height', 10.0) system.tower.value('h_tower', 117.7) system.tower.value('rec_height', 11.3) system.tower.value('D_rec', 11.12) system.ppa_price = (0.12, ) system.simulate() assert system.tower.annual_energy_kwh == pytest.approx( expected_energy, 1e-2) # Check dispatch targets disp_outputs = system.tower.outputs.dispatch ssc_outputs = system.tower.outputs.ssc_time_series for i in range(len(ssc_outputs['gen'])): # cycle start-up allowed target = 1 if (disp_outputs['is_cycle_generating'][i] + disp_outputs['is_cycle_starting'][i]) > 0.01 else 0 assert target == pytest.approx(ssc_outputs['is_pc_su_allowed'][i], 1e-5) # receiver start-up allowed target = 1 if (disp_outputs['is_field_generating'][i] + disp_outputs['is_field_starting'][i]) > 0.01 else 0 assert target == pytest.approx(ssc_outputs['is_rec_su_allowed'][i], 1e-5) # cycle thermal power start_power = system.tower.dispatch.allowable_cycle_startup_power if disp_outputs[ 'is_cycle_starting'][i] else 0 target = disp_outputs['cycle_thermal_power'][i] + start_power assert target == pytest.approx(ssc_outputs['q_dot_pc_target_on'][i], 1e-3) # thermal energy storage state-of-charge if i % system.dispatch_builder.options.n_roll_periods == 0: tes_estimate = disp_outputs['thermal_energy_storage'][i] tes_actual = ssc_outputs['e_ch_tes'][i] assert tes_estimate == pytest.approx(tes_actual, 0.01)
def test_trough_with_dispatch_model(site): """Testing pySSC tower model using HOPP built-in dispatch model""" expected_energy = 1873589.560 interconnection_size_kw = 50000 technologies = { 'trough': { 'cycle_capacity_kw': 50 * 1000, 'solar_multiple': 2.0, 'tes_hours': 6.0 } } system = HybridSimulation(technologies, site, interconnect_kw=interconnection_size_kw, dispatch_options={ 'is_test_start_year': True, 'is_test_end_year': True }) system.ppa_price = (0.12, ) system.simulate() assert system.trough.annual_energy_kwh == pytest.approx( expected_energy, 1e-2)
def test_hybrid_dispatch_financials(site): wind_solar_battery = {key: technologies[key] for key in ('pv', 'wind', 'battery')} hybrid_plant = HybridSimulation(wind_solar_battery, site, interconnect_mw * 1000, dispatch_options={'grid_charging': True}) hybrid_plant.ppa_price = (0.06,) hybrid_plant.simulate(1) assert sum(hybrid_plant.battery.Outputs.P) < 0.0
def test_hybrid_tax_incentives(site): wind_pv_battery = { key: technologies[key] for key in ('pv', 'wind', 'battery') } hybrid_plant = HybridSimulation( wind_pv_battery, site, interconnect_kw=interconnection_size_kw, dispatch_options={'battery_dispatch': 'one_cycle_heuristic'}) hybrid_plant.ppa_price = (0.03, ) hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.pv._financial_model.TaxCreditIncentives.itc_fed_percent = 0.0 hybrid_plant.wind._financial_model.TaxCreditIncentives.ptc_fed_amount = ( 1, ) hybrid_plant.pv._financial_model.TaxCreditIncentives.ptc_fed_amount = (2, ) hybrid_plant.battery._financial_model.TaxCreditIncentives.ptc_fed_amount = ( 3, ) hybrid_plant.wind._financial_model.TaxCreditIncentives.ptc_fed_escal = 0 hybrid_plant.pv._financial_model.TaxCreditIncentives.ptc_fed_escal = 0 hybrid_plant.battery._financial_model.TaxCreditIncentives.ptc_fed_escal = 0 hybrid_plant.simulate() ptc_wind = hybrid_plant.wind._financial_model.value("cf_ptc_fed")[1] assert ptc_wind == approx( hybrid_plant.wind._financial_model.value("ptc_fed_amount")[0] * hybrid_plant.wind.annual_energy_kwh, rel=1e-3) ptc_pv = hybrid_plant.pv._financial_model.value("cf_ptc_fed")[1] assert ptc_pv == approx( hybrid_plant.pv._financial_model.value("ptc_fed_amount")[0] * hybrid_plant.pv.annual_energy_kwh, rel=1e-3) ptc_batt = hybrid_plant.battery._financial_model.value("cf_ptc_fed")[1] assert ptc_batt == approx( hybrid_plant.battery._financial_model.value("ptc_fed_amount")[0] * hybrid_plant.battery._financial_model.LCOS. batt_annual_discharge_energy[1], rel=1e-3) ptc_hybrid = hybrid_plant.grid._financial_model.value("cf_ptc_fed")[1] ptc_fed_amount = hybrid_plant.grid._financial_model.value( "ptc_fed_amount")[0] assert ptc_fed_amount == approx(1.229, rel=1e-2) assert ptc_hybrid == approx( ptc_fed_amount * hybrid_plant.grid._financial_model.Outputs.cf_energy_net[1], rel=1e-3)
def test_hybrid_wind_only(site): wind_only = {'wind': technologies['wind']} hybrid_plant = HybridSimulation(wind_only, site, interconnect_kw=interconnection_size_kw) hybrid_plant.layout.plot() hybrid_plant.ppa_price = (0.01, ) hybrid_plant.simulate(25) aeps = hybrid_plant.annual_energies npvs = hybrid_plant.net_present_values assert aeps.wind == approx(33615479, 1e3) assert aeps.hybrid == approx(33615479, 1e3) assert npvs.wind == approx(-13692784, 1e3) assert npvs.hybrid == approx(-13692784, 1e3)
def test_pv_wind_battery_hybrid_dispatch(site): expected_objective = 39460.698 wind_solar_battery = {key: technologies[key] for key in ('pv', 'wind', 'battery')} hybrid_plant = HybridSimulation(wind_solar_battery, site, interconnect_mw * 1000, dispatch_options={'grid_charging': False, 'include_lifecycle_count': False}) hybrid_plant.grid.value("federal_tax_rate", (0., )) hybrid_plant.grid.value("state_tax_rate", (0., )) hybrid_plant.ppa_price = (0.06, ) hybrid_plant.pv.dc_degradation = [0.5] * 1 hybrid_plant.pv.simulate(1) hybrid_plant.wind.simulate(1) hybrid_plant.dispatch_builder.dispatch.initialize_parameters() hybrid_plant.dispatch_builder.dispatch.update_time_series_parameters(0) hybrid_plant.battery.dispatch.initial_SOC = hybrid_plant.battery.dispatch.minimum_soc # Set to min SOC results = HybridDispatchBuilderSolver.glpk_solve_call(hybrid_plant.dispatch_builder.pyomo_model) assert results.solver.termination_condition == TerminationCondition.optimal gross_profit_objective = pyomo.value(hybrid_plant.dispatch_builder.dispatch.objective_value) assert gross_profit_objective == pytest.approx(expected_objective, 1e-3) n_look_ahead_periods = hybrid_plant.dispatch_builder.options.n_look_ahead_periods available_resource = hybrid_plant.pv.generation_profile[0:n_look_ahead_periods] dispatch_generation = hybrid_plant.pv.dispatch.generation for t in hybrid_plant.dispatch_builder.pyomo_model.forecast_horizon: assert dispatch_generation[t] * 1e3 == pytest.approx(available_resource[t], 1e-3) available_resource = hybrid_plant.wind.generation_profile[0:n_look_ahead_periods] dispatch_generation = hybrid_plant.wind.dispatch.generation for t in hybrid_plant.dispatch_builder.pyomo_model.forecast_horizon: assert dispatch_generation[t] * 1e3 == pytest.approx(available_resource[t], 1e-3) assert sum(hybrid_plant.battery.dispatch.charge_power) > 0.0 assert sum(hybrid_plant.battery.dispatch.discharge_power) > 0.0 assert (sum(hybrid_plant.battery.dispatch.charge_power) * hybrid_plant.battery.dispatch.round_trip_efficiency / 100.0 == pytest.approx(sum(hybrid_plant.battery.dispatch.discharge_power))) transmission_limit = hybrid_plant.grid.value('grid_interconnection_limit_kwac') system_generation = hybrid_plant.grid.dispatch.system_generation for t in hybrid_plant.dispatch_builder.pyomo_model.forecast_horizon: assert system_generation[t] * 1e3 <= transmission_limit + 1e-3 assert system_generation[t] * 1e3 >= 0.0
def test_hybrid_pv_only(site): solar_only = {'pv': technologies['pv']} hybrid_plant = HybridSimulation(solar_only, site, interconnect_kw=interconnection_size_kw) hybrid_plant.layout.plot() hybrid_plant.ppa_price = (0.01, ) hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.simulate() aeps = hybrid_plant.annual_energies npvs = hybrid_plant.net_present_values assert aeps.pv == approx(9884106.55, 1e-3) assert aeps.hybrid == approx(9884106.55, 1e-3) assert npvs.pv == approx(-5121293, 1e3) assert npvs.hybrid == approx(-5121293, 1e3)
def test_hybrid_om_costs_error(site): wind_pv_battery = { key: technologies[key] for key in ('pv', 'wind', 'battery') } hybrid_plant = HybridSimulation( wind_pv_battery, site, interconnect_kw=interconnection_size_kw, dispatch_options={'battery_dispatch': 'one_cycle_heuristic'}) hybrid_plant.ppa_price = (0.03, ) hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.battery._financial_model.SystemCosts.om_production = (1, ) try: hybrid_plant.simulate() except ValueError as e: assert e
def test_tower_pv_battery_hybrid(site): interconnection_size_kw_test = 50000 technologies_test = { 'tower': { 'cycle_capacity_kw': 50 * 1000, 'solar_multiple': 2.0, 'tes_hours': 12.0 }, 'pv': { 'system_capacity_kw': 50 * 1000 }, 'battery': { 'system_capacity_kwh': 40 * 1000, 'system_capacity_kw': 20 * 1000 } } solar_hybrid = { key: technologies_test[key] for key in ('tower', 'pv', 'battery') } hybrid_plant = HybridSimulation( solar_hybrid, site, interconnect_kw=interconnection_size_kw_test, dispatch_options={ 'is_test_start_year': True, 'is_test_end_year': True }) hybrid_plant.ppa_price = (0.12, ) # $/kWh hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.tower.value('helio_width', 10.0) hybrid_plant.tower.value('helio_height', 10.0) hybrid_plant.simulate() aeps = hybrid_plant.annual_energies npvs = hybrid_plant.net_present_values assert aeps.pv == approx(104053614.17, 1e-3) assert aeps.tower == approx(3769716.50, 5e-2) assert aeps.battery == approx(-9449.70, 2e-1) assert aeps.hybrid == approx(107882747.80, 1e-2) assert npvs.pv == approx(45233832.23, 1e3)
def test_tower_field_optimize_before_sim(site): """Testing pySSC tower model using HOPP built-in dispatch model""" interconnection_size_kw = 50000 technologies = { 'tower': { 'cycle_capacity_kw': 50 * 1000, 'solar_multiple': 2.0, 'tes_hours': 6.0, 'optimize_field_before_sim': True }, 'grid': 50000 } system = {key: technologies[key] for key in ('tower', 'grid')} system = HybridSimulation(system, site, interconnect_kw=interconnection_size_kw, dispatch_options={'is_test_start_year': True}) system.ppa_price = (0.12, ) system.tower.value('helio_width', 10.0) system.tower.value('helio_height', 10.0) system.tower.generate_field() # Get old field: field_parameters = [ 'N_hel', 'D_rec', 'rec_height', 'h_tower', 'land_area_base', 'A_sf_in' ] old_values = {} for k in field_parameters: old_values[k] = system.tower.value(k) system.simulate() new_values = {} for k in field_parameters: new_values[k] = system.tower.value(k) assert system.tower.optimize_field_before_sim for k in field_parameters: assert old_values[k] != new_values[k]
def test_hybrid(site): """ Performance from Wind is slightly different from wind-only case because the solar presence modified the wind layout """ solar_wind_hybrid = {key: technologies[key] for key in ('pv', 'wind')} hybrid_plant = HybridSimulation(solar_wind_hybrid, site, interconnect_kw=interconnection_size_kw) hybrid_plant.layout.plot() hybrid_plant.ppa_price = (0.01, ) hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.simulate() # plt.show() aeps = hybrid_plant.annual_energies npvs = hybrid_plant.net_present_values assert aeps.pv == approx(8703525.94, 13) assert aeps.wind == approx(33615479.57, 1e3) assert aeps.hybrid == approx(41681662.63, 1e3) assert npvs.pv == approx(-5121293, 1e3) assert npvs.wind == approx(-13909363, 1e3) assert npvs.hybrid == approx(-19216589, 1e3)
def test_trough_pv_hybrid(site): interconnection_size_kw_test = 50000 technologies_test = { 'trough': { 'cycle_capacity_kw': 50 * 1000, 'solar_multiple': 2.0, 'tes_hours': 12.0 }, 'pv': { 'system_capacity_kw': 50 * 1000 } } solar_hybrid = {key: technologies_test[key] for key in ('trough', 'pv')} hybrid_plant = HybridSimulation( solar_hybrid, site, interconnect_kw=interconnection_size_kw_test, dispatch_options={ 'is_test_start_year': True, 'is_test_end_year': True }) hybrid_plant.ppa_price = (0.12, ) # $/kWh hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.simulate() aeps = hybrid_plant.annual_energies npvs = hybrid_plant.net_present_values assert aeps.pv == approx(104053614.17, 1e-3) assert aeps.trough == approx(1871471.58, 2e-2) assert aeps.hybrid == approx(105926003.55, 1e-3) assert npvs.pv == approx(45233832.23, 1e3)
def test_capacity_credit(site): site = SiteInfo(data=flatirons_site, solar_resource_file=solar_resource_file, wind_resource_file=wind_resource_file, capacity_hours=capacity_credit_hours) wind_pv_battery = { key: technologies[key] for key in ('pv', 'wind', 'battery') } hybrid_plant = HybridSimulation(wind_pv_battery, site, interconnect_kw=interconnection_size_kw) hybrid_plant.battery.dispatch.lifecycle_cost_per_kWh_cycle = 0.01 hybrid_plant.ppa_price = (0.03, ) hybrid_plant.pv.dc_degradation = [0] * 25 # Backup values for resetting before tests gen_max_feasible_orig = hybrid_plant.battery.gen_max_feasible capacity_hours_orig = hybrid_plant.site.capacity_hours interconnect_kw_orig = hybrid_plant.interconnect_kw def reinstate_orig_values(): hybrid_plant.battery.gen_max_feasible = gen_max_feasible_orig hybrid_plant.site.capacity_hours = capacity_hours_orig hybrid_plant.interconnect_kw = interconnect_kw_orig # Test when 0 gen_max_feasible reinstate_orig_values() hybrid_plant.battery.gen_max_feasible = [0] * 8760 capacity_credit_battery = hybrid_plant.battery.calc_capacity_credit_percent( hybrid_plant.interconnect_kw) assert capacity_credit_battery == approx(0, rel=0.05) # Test when representative gen_max_feasible reinstate_orig_values() hybrid_plant.battery.gen_max_feasible = [2500] * 8760 capacity_credit_battery = hybrid_plant.battery.calc_capacity_credit_percent( hybrid_plant.interconnect_kw) assert capacity_credit_battery == approx(50, rel=0.05) # Test when no capacity hours reinstate_orig_values() hybrid_plant.battery.gen_max_feasible = [2500] * 8760 hybrid_plant.site.capacity_hours = [False] * 8760 capacity_credit_battery = hybrid_plant.battery.calc_capacity_credit_percent( hybrid_plant.interconnect_kw) assert capacity_credit_battery == approx(0, rel=0.05) # Test when no interconnect capacity reinstate_orig_values() hybrid_plant.battery.gen_max_feasible = [2500] * 8760 hybrid_plant.interconnect_kw = 0 capacity_credit_battery = hybrid_plant.battery.calc_capacity_credit_percent( hybrid_plant.interconnect_kw) assert capacity_credit_battery == approx(0, rel=0.05) # Test integration with system simulation reinstate_orig_values() cap_payment_mw = 100000 hybrid_plant.assign({"cp_capacity_payment_amount": [cap_payment_mw]}) hybrid_plant.simulate() total_gen_max_feasible = np.array(hybrid_plant.pv.gen_max_feasible) \ + np.array(hybrid_plant.wind.gen_max_feasible) \ + np.array(hybrid_plant.battery.gen_max_feasible) assert sum(hybrid_plant.grid.gen_max_feasible) == approx(sum(np.minimum(hybrid_plant.grid.interconnect_kw * hybrid_plant.site.interval / 60, \ total_gen_max_feasible)), rel=0.01) total_nominal_capacity = hybrid_plant.pv.calc_nominal_capacity(hybrid_plant.interconnect_kw) \ + hybrid_plant.wind.calc_nominal_capacity(hybrid_plant.interconnect_kw) \ + hybrid_plant.battery.calc_nominal_capacity(hybrid_plant.interconnect_kw) assert total_nominal_capacity == approx(18845.8, rel=0.01) assert total_nominal_capacity == approx( hybrid_plant.grid.hybrid_nominal_capacity, rel=0.01) capcred = hybrid_plant.capacity_credit_percent assert capcred['pv'] == approx(8.03, rel=0.05) assert capcred['wind'] == approx(33.25, rel=0.10) assert capcred['battery'] == approx(58.95, rel=0.05) assert capcred['hybrid'] == approx(43.88, rel=0.05) cp_pay = hybrid_plant.capacity_payments np_cap = hybrid_plant.system_nameplate_mw # This is not the same as nominal capacity... assert cp_pay['pv'][1] / (np_cap['pv']) / (capcred['pv'] / 100) == approx( cap_payment_mw, 0.05) assert cp_pay['wind'][1] / (np_cap['wind']) / (capcred['wind'] / 100) == approx( cap_payment_mw, 0.05) assert cp_pay['battery'][1] / (np_cap['battery']) / (capcred['battery'] / 100) == approx( cap_payment_mw, 0.05) assert cp_pay['hybrid'][1] / (np_cap['hybrid']) / (capcred['hybrid'] / 100) == approx( cap_payment_mw, 0.05) aeps = hybrid_plant.annual_energies assert aeps.pv == approx(9882421, rel=0.05) assert aeps.wind == approx(33637983, rel=0.05) assert aeps.battery == approx(-31287, rel=0.05) assert aeps.hybrid == approx(43489117, rel=0.05) npvs = hybrid_plant.net_present_values assert npvs.pv == approx(-565098, rel=5e-2) assert npvs.wind == approx(-1992106, rel=5e-2) assert npvs.battery == approx(-4773045, rel=5e-2) assert npvs.hybrid == approx(-5849767, rel=5e-2) taxes = hybrid_plant.federal_taxes assert taxes.pv[1] == approx(86826, rel=5e-2) assert taxes.wind[1] == approx(348124, rel=5e-2) assert taxes.battery[1] == approx(239607, rel=5e-2) assert taxes.hybrid[1] == approx(633523, rel=5e-2) apv = hybrid_plant.energy_purchases_values assert apv.pv[1] == approx(0, rel=5e-2) assert apv.wind[1] == approx(0, rel=5e-2) assert apv.battery[1] == approx(40158, rel=5e-2) assert apv.hybrid[1] == approx(2980, rel=5e-2) debt = hybrid_plant.debt_payment assert debt.pv[1] == approx(0, rel=5e-2) assert debt.wind[1] == approx(0, rel=5e-2) assert debt.battery[1] == approx(0, rel=5e-2) assert debt.hybrid[1] == approx(0, rel=5e-2) esv = hybrid_plant.energy_sales_values assert esv.pv[1] == approx(353105, rel=5e-2) assert esv.wind[1] == approx(956067, rel=5e-2) assert esv.battery[1] == approx(80449, rel=5e-2) assert esv.hybrid[1] == approx(1352445, rel=5e-2) depr = hybrid_plant.federal_depreciation_totals assert depr.pv[1] == approx(762811, rel=5e-2) assert depr.wind[1] == approx(2651114, rel=5e-2) assert depr.battery[1] == approx(1486921, rel=5e-2) assert depr.hybrid[1] == approx(4900847, rel=5e-2) insr = hybrid_plant.insurance_expenses assert insr.pv[0] == approx(0, rel=5e-2) assert insr.wind[0] == approx(0, rel=5e-2) assert insr.battery[0] == approx(0, rel=5e-2) assert insr.hybrid[0] == approx(0, rel=5e-2) om = hybrid_plant.om_total_expenses assert om.pv[1] == approx(74993, rel=5e-2) assert om.wind[1] == approx(420000, rel=5e-2) assert om.battery[1] == approx(75000, rel=5e-2) assert om.hybrid[1] == approx(569993, rel=5e-2) rev = hybrid_plant.total_revenues assert rev.pv[1] == approx(393226, rel=5e-2) assert rev.wind[1] == approx(1288603, rel=5e-2) assert rev.battery[1] == approx(375215, rel=5e-2) assert rev.hybrid[1] == approx(2229976, rel=5e-2) tc = hybrid_plant.tax_incentives assert tc.pv[1] == approx(1123104, rel=5e-2) assert tc.wind[1] == approx(504569, rel=5e-2) assert tc.battery[1] == approx(0, rel=5e-2) assert tc.hybrid[1] == approx(1646170, rel=5e-2)
def init_hybrid_plant(): """ Initialize hybrid simulation object using specific project inputs :return: HybridSimulation as defined for this problem """ is_test = False # Turns off full year dispatch and optimize tower and receiver techs_in_sim = ['tower', 'pv', 'battery', 'grid'] site_data = { "lat": 34.85, "lon": -116.9, "elev": 641, "year": 2012, "tz": -8, "no_wind": True } root = "C:/Users/WHamilt2/Documents/Projects/HOPP/CSP_PV_battery_dispatch_plots/" solar_file = root + "34.865371_-116.783023_psmv3_60_tmy.csv" prices_file = root + "constant_nom_prices.csv" schedule_scale = 100 # MWe desired_schedule_file = root + "sample_load_profile_normalized.csv" # Reading in desired schedule with open(desired_schedule_file) as f: csvreader = csv.reader(f) desired_schedule = [] for row in csvreader: desired_schedule.append(float(row[0])*schedule_scale) # If normalized pricing is used, then PPA price must be adjusted after HybridSimulation is initialized site = SiteInfo(site_data, solar_resource_file=solar_file, grid_resource_file=prices_file, desired_schedule=desired_schedule ) technologies = {'tower': { 'cycle_capacity_kw': 100 * 1000, #100 * 1000, 'solar_multiple': 3.0, #2.0, 'tes_hours': 16.0, #16.0, 'optimize_field_before_sim': not is_test, 'scale_input_params': True, }, 'trough': { 'cycle_capacity_kw': 100 * 1000, 'solar_multiple': 4.0, 'tes_hours': 20.0 }, 'pv': { 'system_capacity_kw': 50 * 1000 }, 'battery': { 'system_capacity_kwh': 300 * 1000, 'system_capacity_kw': 100 * 1000 }, 'grid': 150 * 1000} # Create model hybrid_plant = HybridSimulation({key: technologies[key] for key in techs_in_sim}, site, interconnect_kw=technologies['grid'], dispatch_options={ 'is_test_start_year': is_test, 'is_test_end_year': is_test, 'solver': 'xpress', 'grid_charging': False, 'pv_charging_only': True, }, simulation_options={ 'storage_capacity_credit': False, } ) # Defaults: # {'cost_per_field_generation': 0.5, # 'cost_per_field_start_rel': 1.5, # 'cost_per_cycle_generation': 2.0, # 'cost_per_cycle_start_rel': 40.0, # 'cost_per_change_thermal_input': 0.5} csp_dispatch_obj_costs = dict() csp_dispatch_obj_costs = { 'cost_per_field_generation': 0.0, #0.5, # 'cost_per_field_start_rel': 0.0, # 'cost_per_cycle_generation': 2.0, 'cost_per_cycle_start_rel': 0.0, 'cost_per_change_thermal_input': 0.5} # Set CSP costs if hybrid_plant.tower: hybrid_plant.tower.dispatch.objective_cost_terms.update(csp_dispatch_obj_costs) hybrid_plant.tower.value('cycle_max_frac', 1.0) if hybrid_plant.trough: hybrid_plant.trough.dispatch.objective_cost_terms.update(csp_dispatch_obj_costs) hybrid_plant.trough.value('cycle_max_frac', 1.0) # if hybrid_plant.battery: # hybrid_plant.battery.dispatch.lifecycle_cost_per_kWh_cycle = 0.0265 / 100 # # hybrid_plant.battery.dispatch.lifecycle_cost_per_kWh_cycle = 1e-6 if hybrid_plant.pv: hybrid_plant.pv.dc_degradation = [0.5] * 25 hybrid_plant.pv.value('array_type', 2) # 1-axis tracking hybrid_plant.pv.value('tilt', 0) # Tilt for 1-axis # This is required if normalized prices are provided hybrid_plant.ppa_price = (0.12,) # $/kWh return hybrid_plant
'num_turbines': 10, 'turbine_rating_kw': 2000 }} # Get resource lat = flatirons_site['lat'] lon = flatirons_site['lon'] prices_file = examples_dir.parent / "resource_files" / "grid" / "pricing-data-2015-IronMtn-002_factors.csv" site = SiteInfo(flatirons_site, grid_resource_file=prices_file) # Create model hybrid_plant = HybridSimulation(technologies, site, interconnect_kw=interconnection_size_mw * 1000) hybrid_plant.pv.system_capacity_kw = solar_size_mw * 1000 hybrid_plant.wind.system_capacity_by_num_turbines(wind_size_mw * 1000) hybrid_plant.ppa_price = 0.1 hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.simulate(25) # Save the outputs annual_energies = hybrid_plant.annual_energies wind_plus_solar_npv = hybrid_plant.net_present_values.wind + hybrid_plant.net_present_values.pv npvs = hybrid_plant.net_present_values wind_installed_cost = hybrid_plant.wind.total_installed_cost solar_installed_cost = hybrid_plant.pv.total_installed_cost hybrid_installed_cost = hybrid_plant.grid.total_installed_cost print("Wind Installed Cost: {}".format(wind_installed_cost)) print("Solar Installed Cost: {}".format(solar_installed_cost)) print("Hybrid Installed Cost: {}".format(hybrid_installed_cost))
def run_hopp_calc(Site, scenario_description, bos_details, total_hybrid_plant_capacity_mw, solar_size_mw, wind_size_mw, nameplate_mw, interconnection_size_mw, load_resource_from_file, ppa_price, results_dir): """ run_hopp_calc Establishes sizing models, creates a wind or solar farm based on the desired sizes, and runs SAM model calculations for the specified inputs. save_outputs contains a dictionary of all results for the hopp calculation. :param scenario_description: Project scenario - 'greenfield' or 'solar addition'. :param bos_details: contains bos details including type of analysis to conduct (cost/mw, json lookup, HybridBOSSE). :param total_hybrid_plant_capacity_mw: capacity in MW of hybrid plant. :param solar_size_mw: capacity in MW of solar component of plant. :param wind_size_mw: capacity in MW of wind component of plant. :param nameplate_mw: nameplate capacity of total plant. :param interconnection_size_mw: interconnection size in MW. :param load_resource_from_file: flag determining whether resource is loaded directly from file or through interpolation routine. :param ppa_price: PPA price in USD($) :return: collection of outputs from SAM and hybrid-specific calculations (includes e.g. AEP, IRR, LCOE), plus wind and solar filenames used (save_outputs) """ # Get resource data if load_resource_from_file: pass else: Site[ 'resource_filename_solar'] = "" # Unsetting resource filename to force API download of wind resource Site[ 'resource_filename_wind'] = "" # Unsetting resource filename to force API download of solar resource site = SiteInfo(Site, solar_resource_file=sample_site['resource_filename_solar'], wind_resource_file=sample_site['resource_filename_wind']) #TODO: Incorporate this in SiteInfo # if 'roll_tz' in Site.keys(): # site.solar_resource.roll_timezone(Site['roll_tz'], Site['roll_tz']) # Set up technology and cost model info technologies = { 'solar': solar_size_mw, # mw system capacity 'wind': wind_size_mw, # mw system capacity 'grid': interconnection_size_mw } # mw interconnect # Create model hybrid_plant = HybridSimulation(technologies, site, interconnect_kw=interconnection_size_mw * 1000) hybrid_plant.setup_cost_calculator( create_cost_calculator(interconnection_size_mw, bos_details['BOSSource'], scenario_description)) hybrid_plant.ppa_price = ppa_price hybrid_plant.discount_rate = 6.4 hybrid_plant.solar.system_capacity_kw = solar_size_mw * 1000 hybrid_plant.wind.system_capacity_by_num_turbines(wind_size_mw * 1000) actual_solar_pct = hybrid_plant.solar.system_capacity_kw / \ (hybrid_plant.solar.system_capacity_kw + hybrid_plant.wind.system_capacity_kw) logger.info("Run with solar percent {}".format(actual_solar_pct)) hybrid_plant.simulate() outputs = hybrid_plant.hybrid_outputs() for k, v in outputs.items(): outputs[k] = [v] return outputs, site.wind_resource.filename, site.solar_resource.filename
def run_hopp_calc(Site, scenario_description, bos_details, total_hybrid_plant_capacity_mw, solar_size_mw, wind_size_mw, nameplate_mw, interconnection_size_mw, load_resource_from_file, ppa_price, results_dir): """ run_hopp_calc Establishes sizing models, creates a wind or solar farm based on the desired sizes, and runs SAM model calculations for the specified inputs. save_outputs contains a dictionary of all results for the hopp calculation. :param scenario_description: Project scenario - 'greenfield' or 'solar addition'. :param bos_details: contains bos details including type of analysis to conduct (cost/mw, json lookup, HybridBOSSE). :param total_hybrid_plant_capacity_mw: capacity in MW of hybrid plant. :param solar_size_mw: capacity in MW of solar component of plant. :param wind_size_mw: capacity in MW of wind component of plant. :param nameplate_mw: nameplate capacity of total plant. :param interconnection_size_mw: interconnection size in MW. :param load_resource_from_file: flag determining whether resource is loaded directly from file or through interpolation routine. :param ppa_price: PPA price in USD($) :return: collection of outputs from SAM and hybrid-specific calculations (includes e.g. AEP, IRR, LCOE), plus wind and solar filenames used (save_outputs) """ # Get resource data # sample_site['lat'] = Site['Lat'] # sample_site['lon'] = Site['Lon'] # # site = SiteInfo(sample_site, solar_resource_file=Site['resource_filename_solar'], # # wind_resource_file=Site['resource_filename_wind']) if load_resource_from_file: pass else: Site['resource_filename_solar'] = "" # Unsetting resource filename to force API download of wind resource Site['resource_filename_wind'] = "" # Unsetting resource filename to force API download of solar resource site = SiteInfo(Site) if 'roll_tz' in Site.keys(): site.solar_resource.roll_timezone(Site['roll_tz'], Site['roll_tz']) # Set up technology and cost model info technologies = {'solar': solar_size_mw, # mw system capacity 'wind': wind_size_mw # mw system capacity } # Create model hybrid_plant = HybridSimulation(technologies, site, interconnect_kw=interconnection_size_mw * 1000) # hybrid_plant.setup_cost_calculator(create_cost_calculator(bos_cost_source='boslookup', interconnection_mw=interconnection_size_mw)) hybrid_plant.setup_cost_calculator(create_cost_calculator(bos_cost_source=bos_details['BOSSource'], interconnection_mw=interconnection_size_mw, modify_costs=bos_details['Modify Costs'], cost_reductions=bos_details, wind_installed_cost_mw=1696000, solar_installed_cost_mw=1088600, storage_installed_cost_mw=0, storage_installed_cost_mwh=0, )) hybrid_plant.ppa_price = ppa_price hybrid_plant.discount_rate = 6.4 hybrid_plant.solar.system_capacity_kw = solar_size_mw * 1000 hybrid_plant.wind.rotor_diameter = 100 # Modify Wind Turbine Coordinates Nx = 8 Ny = 5 spacing = hybrid_plant.wind.row_spacing turbine_x = np.linspace(0, (Nx * spacing) - spacing, Nx) turbine_y = np.linspace(0, (Ny * spacing) - spacing, Ny) turbX = np.zeros(Nx * Ny) turbY = np.zeros(Nx * Ny) count = 0 for i in range(Nx): for j in range(Ny): turbX[count] = turbine_x[i] turbY[count] = turbine_y[j] count = count + 1 hybrid_plant.wind.modify_coordinates(list(turbX), list(turbY)) hybrid_plant.wind.system_capacity_by_num_turbines(wind_size_mw * 1000) actual_solar_pct = hybrid_plant.solar.system_capacity_kw / \ (hybrid_plant.solar.system_capacity_kw + hybrid_plant.wind.system_capacity_kw) logger.info("Run with solar percent {}".format(actual_solar_pct)) hybrid_plant.simulate() outputs = hybrid_plant.hybrid_outputs() for k, v in outputs.items(): outputs[k] = [v] return outputs, site.wind_resource.filename, site.solar_resource.filename
def init_hybrid_plant(techs_in_sim: list, is_test: bool = False, ud_techs: dict = {}): """ Initialize hybrid simulation object using specific project inputs :param techs_in_sim: List of technologies to include in the simulation :param is_test: if True, runs dispatch for the first and last 5 days of the year and turns off tower and receiver optimization :param ud_techs: Dictionary containing technology initialization parameters required by HybridSimulation :return: HybridSimulation as defined for this problem """ schedule_scale = 100 # MWe grid_interconnect_mw = 100 # MWe example_root = get_example_path_root() # Set plant location site_data = { "lat": 34.8653, "lon": -116.7830, "elev": 561, "tz": 1, "no_wind": True } solar_file = example_root + "02_weather_data/daggett_ca_34.865371_-116.783023_psmv3_60_tmy.csv" prices_file = example_root + "03_cost_load_price_data/constant_norm_prices.csv" desired_schedule_file = example_root + "03_cost_load_price_data/desired_schedule_normalized.csv" # Reading in desired schedule with open(desired_schedule_file) as f: csvreader = csv.reader(f) desired_schedule = [] for row in csvreader: desired_schedule.append(float(row[0]) * schedule_scale) # If normalized pricing is used, then PPA price must be adjusted after HybridSimulation is initialized site = SiteInfo(site_data, solar_resource_file=solar_file, grid_resource_file=prices_file, desired_schedule=desired_schedule) # Load in system costs with open(example_root + "03_cost_load_price_data/system_costs_SAM.json") as f: cost_info = json.load(f) # Initializing technologies if ud_techs: technologies = ud_techs else: technologies = { 'tower': { 'cycle_capacity_kw': 200 * 1000, #100 'solar_multiple': 4.0, #2.0 'tes_hours': 20.0, #14 'optimize_field_before_sim': not is_test, 'scale_input_params': True, }, 'trough': { 'cycle_capacity_kw': 200 * 1000, 'solar_multiple': 6.0, 'tes_hours': 28.0 }, 'pv': { 'system_capacity_kw': 120 * 1000 }, 'battery': { 'system_capacity_kwh': 200 * 1000, 'system_capacity_kw': 100 * 1000 }, 'grid': grid_interconnect_mw * 1000 } # Create hybrid simulation class based on the technologies needed in the simulation sim_techs = {key: technologies[key] for key in techs_in_sim} sim_techs['grid'] = technologies['grid'] hybrid_plant = HybridSimulation(sim_techs, site, interconnect_kw=technologies['grid'], dispatch_options={ 'is_test_start_year': is_test, 'is_test_end_year': is_test, 'solver': 'cbc', 'grid_charging': False, 'pv_charging_only': True }, cost_info=cost_info['cost_info']) csp_dispatch_obj_costs = { 'cost_per_field_generation': 0.5, 'cost_per_field_start_rel': 0.0, 'cost_per_cycle_generation': 2.0, 'cost_per_cycle_start_rel': 0.0, 'cost_per_change_thermal_input': 0.5 } # Set CSP costs if hybrid_plant.tower: hybrid_plant.tower.ssc.set(cost_info['tower_costs']) hybrid_plant.tower.dispatch.objective_cost_terms = csp_dispatch_obj_costs if hybrid_plant.trough: hybrid_plant.trough.ssc.set(cost_info['trough_costs']) hybrid_plant.trough.dispatch.objective_cost_terms = csp_dispatch_obj_costs # Set O&M costs for all technologies for tech in ['tower', 'trough', 'pv', 'battery']: if not tech in techs_in_sim: cost_info["SystemCosts"].pop(tech) hybrid_plant.assign(cost_info["SystemCosts"]) # Set financial parameters for singleowner model with open(example_root + '03_cost_load_price_data/financial_parameters_SAM.json') as f: fin_info = json.load(f) hybrid_plant.assign(fin_info["FinancialParameters"]) hybrid_plant.assign(fin_info["TaxCreditIncentives"]) hybrid_plant.assign(fin_info["Revenue"]) hybrid_plant.assign(fin_info["Depreciation"]) hybrid_plant.assign(fin_info["PaymentIncentives"]) # Set specific technology assumptions here if hybrid_plant.pv: hybrid_plant.pv.dc_degradation = [0.5] * 25 hybrid_plant.pv.value('array_type', 2) # 1-axis tracking hybrid_plant.pv.value('tilt', 0) # Tilt for 1-axis # This is required if normalized prices are provided hybrid_plant.ppa_price = (0.10, ) # $/kWh return hybrid_plant
def test_wind_pv_with_storage_dispatch(site): wind_pv_battery = { key: technologies[key] for key in ('pv', 'wind', 'battery') } hybrid_plant = HybridSimulation(wind_pv_battery, site, interconnect_kw=interconnection_size_kw) hybrid_plant.battery.dispatch.lifecycle_cost_per_kWh_cycle = 0.01 hybrid_plant.ppa_price = (0.03, ) hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.simulate() aeps = hybrid_plant.annual_energies npvs = hybrid_plant.net_present_values taxes = hybrid_plant.federal_taxes apv = hybrid_plant.energy_purchases_values debt = hybrid_plant.debt_payment esv = hybrid_plant.energy_sales_values depr = hybrid_plant.federal_depreciation_totals insr = hybrid_plant.insurance_expenses om = hybrid_plant.om_total_expenses rev = hybrid_plant.total_revenues tc = hybrid_plant.tax_incentives assert aeps.pv == approx(9882421, rel=0.05) assert aeps.wind == approx(33637983, rel=0.05) assert aeps.battery == approx(-31287, rel=0.05) assert aeps.hybrid == approx(43489117, rel=0.05) assert npvs.pv == approx(-853226, rel=5e-2) assert npvs.wind == approx(-4380277, rel=5e-2) assert npvs.battery == approx(-6889961, rel=5e-2) assert npvs.hybrid == approx(-11861790, rel=5e-2) assert taxes.pv[1] == approx(94661, rel=5e-2) assert taxes.wind[1] == approx(413068, rel=5e-2) assert taxes.battery[1] == approx(297174, rel=5e-2) assert taxes.hybrid[1] == approx(804904, rel=5e-2) assert apv.pv[1] == approx(0, rel=5e-2) assert apv.wind[1] == approx(0, rel=5e-2) assert apv.battery[1] == approx(40158, rel=5e-2) assert apv.hybrid[1] == approx(3050, rel=5e-2) assert debt.pv[1] == approx(0, rel=5e-2) assert debt.wind[1] == approx(0, rel=5e-2) assert debt.battery[1] == approx(0, rel=5e-2) assert debt.hybrid[1] == approx(0, rel=5e-2) assert esv.pv[1] == approx(353105, rel=5e-2) assert esv.wind[1] == approx(956067, rel=5e-2) assert esv.battery[1] == approx(80449, rel=5e-2) assert esv.hybrid[1] == approx(1352445, rel=5e-2) assert depr.pv[1] == approx(762811, rel=5e-2) assert depr.wind[1] == approx(2651114, rel=5e-2) assert depr.battery[1] == approx(1486921, rel=5e-2) assert depr.hybrid[1] == approx(4900847, rel=5e-2) assert insr.pv[0] == approx(0, rel=5e-2) assert insr.wind[0] == approx(0, rel=5e-2) assert insr.battery[0] == approx(0, rel=5e-2) assert insr.hybrid[0] == approx(0, rel=5e-2) assert om.pv[1] == approx(74993, rel=5e-2) assert om.wind[1] == approx(420000, rel=5e-2) assert om.battery[1] == approx(75000, rel=5e-2) assert om.hybrid[1] == approx(569993, rel=5e-2) assert rev.pv[1] == approx(353105, rel=5e-2) assert rev.wind[1] == approx(956067, rel=5e-2) assert rev.battery[1] == approx(80449, rel=5e-2) assert rev.hybrid[1] == approx(1352445, rel=5e-2) assert tc.pv[1] == approx(1123104, rel=5e-2) assert tc.wind[1] == approx(504569, rel=5e-2) assert tc.battery[1] == approx(0, rel=5e-2) assert tc.hybrid[1] == approx(1646170, rel=5e-2)
def test_hybrid_om_costs(site): wind_pv_battery = { key: technologies[key] for key in ('pv', 'wind', 'battery') } hybrid_plant = HybridSimulation( wind_pv_battery, site, interconnect_kw=interconnection_size_kw, dispatch_options={'battery_dispatch': 'one_cycle_heuristic'}) hybrid_plant.ppa_price = (0.03, ) hybrid_plant.pv.dc_degradation = [0] * 25 # set all O&M costs to 0 to start hybrid_plant.wind.om_fixed = 0 hybrid_plant.wind.om_capacity = 0 hybrid_plant.wind.om_variable = 0 hybrid_plant.pv.om_fixed = 0 hybrid_plant.pv.om_capacity = 0 hybrid_plant.pv.om_variable = 0 hybrid_plant.battery.om_fixed = 0 hybrid_plant.battery.om_capacity = 0 hybrid_plant.battery.om_variable = 0 # test variable costs hybrid_plant.wind.om_variable = 5 hybrid_plant.pv.om_variable = 2 hybrid_plant.battery.om_variable = 3 hybrid_plant.simulate() var_om_costs = hybrid_plant.om_variable_expenses total_om_costs = hybrid_plant.om_total_expenses for i in range(len(var_om_costs.hybrid)): assert var_om_costs.pv[i] + var_om_costs.wind[ i] + var_om_costs.battery[i] == approx(var_om_costs.hybrid[i], rel=1e-1) assert total_om_costs.pv[i] == approx(var_om_costs.pv[i]) assert total_om_costs.wind[i] == approx(var_om_costs.wind[i]) assert total_om_costs.battery[i] == approx(var_om_costs.battery[i]) assert total_om_costs.hybrid[i] == approx(var_om_costs.hybrid[i]) hybrid_plant.wind.om_variable = 0 hybrid_plant.pv.om_variable = 0 hybrid_plant.battery.om_variable = 0 # test fixed costs hybrid_plant.wind.om_fixed = 5 hybrid_plant.pv.om_fixed = 2 hybrid_plant.battery.om_fixed = 3 hybrid_plant.simulate() fixed_om_costs = hybrid_plant.om_fixed_expenses total_om_costs = hybrid_plant.om_total_expenses for i in range(len(fixed_om_costs.hybrid)): assert fixed_om_costs.pv[i] + fixed_om_costs.wind[i] + fixed_om_costs.battery[i] \ == approx(fixed_om_costs.hybrid[i]) assert total_om_costs.pv[i] == approx(fixed_om_costs.pv[i]) assert total_om_costs.wind[i] == approx(fixed_om_costs.wind[i]) assert total_om_costs.battery[i] == approx(fixed_om_costs.battery[i]) assert total_om_costs.hybrid[i] == approx(fixed_om_costs.hybrid[i]) hybrid_plant.wind.om_fixed = 0 hybrid_plant.pv.om_fixed = 0 hybrid_plant.battery.om_fixed = 0 # test capacity costs hybrid_plant.wind.om_capacity = 5 hybrid_plant.pv.om_capacity = 2 hybrid_plant.battery.om_capacity = 3 hybrid_plant.simulate() cap_om_costs = hybrid_plant.om_capacity_expenses total_om_costs = hybrid_plant.om_total_expenses for i in range(len(cap_om_costs.hybrid)): assert cap_om_costs.pv[i] + cap_om_costs.wind[i] + cap_om_costs.battery[i] \ == approx(cap_om_costs.hybrid[i]) assert total_om_costs.pv[i] == approx(cap_om_costs.pv[i]) assert total_om_costs.wind[i] == approx(cap_om_costs.wind[i]) assert total_om_costs.battery[i] == approx(cap_om_costs.battery[i]) assert total_om_costs.hybrid[i] == approx(cap_om_costs.hybrid[i]) hybrid_plant.wind.om_capacity = 0 hybrid_plant.pv.om_capacity = 0 hybrid_plant.battery.om_capacity = 0
def test_desired_schedule_dispatch(): # Creating a contrived schedule daily_schedule = [interconnect_mw]*10 daily_schedule.extend([20] * 8) daily_schedule.append(interconnect_mw + 5) daily_schedule.extend([0] * 5) desired_schedule = daily_schedule*365 desired_schedule_site = SiteInfo(flatirons_site, desired_schedule=desired_schedule) tower_pv_battery = {key: technologies[key] for key in ('pv', 'tower', 'battery')} # Default case doesn't leave enough head room for battery operations tower_pv_battery['tower'] = {'cycle_capacity_kw': 35 * 1000, 'solar_multiple': 2.0, 'tes_hours': 10.0} tower_pv_battery['pv'] = {'system_capacity_kw': 80 * 1000} hybrid_plant = HybridSimulation(tower_pv_battery, desired_schedule_site, interconnect_mw * 1000, dispatch_options={'is_test_start_year': True, 'is_test_end_year': False, 'grid_charging': False, 'pv_charging_only': True, 'include_lifecycle_count': False }) hybrid_plant.ppa_price = (0.06, ) # Constant price # hybrid_plant.site.elec_prices = [100] * hybrid_plant.site.n_timesteps hybrid_plant.simulate(1) system_generation = hybrid_plant.dispatch_builder.dispatch.system_generation system_load = hybrid_plant.dispatch_builder.dispatch.system_load electricity_sold = hybrid_plant.grid.dispatch.electricity_sold electricity_purchased = hybrid_plant.grid.dispatch.electricity_purchased gen_limit = hybrid_plant.grid.dispatch.generation_transmission_limit transmission_limit = hybrid_plant.grid.value('grid_interconnection_limit_kwac') schedule = daily_schedule*2 # System generation does not exceed schedule limits for t in hybrid_plant.dispatch_builder.pyomo_model.forecast_horizon: assert gen_limit[t] * 1e3 <= transmission_limit assert system_generation[t] - system_load[t] <= schedule[t] + 1e-3 if system_generation[t] > system_load[t]: assert electricity_sold[t] == pytest.approx(system_generation[t] - system_load[t], 1e-3) assert electricity_purchased[t] == pytest.approx(0.0, 1e-3) else: assert electricity_purchased[t] == pytest.approx(system_load[t] - system_generation[t], 1e-3) assert electricity_sold[t] == pytest.approx(0.0, 1e-3) # Battery charges and discharges assert sum(hybrid_plant.battery.dispatch.charge_power) > 0.0 assert sum(hybrid_plant.battery.dispatch.discharge_power) > 0.0 # PV can be curtailed assert sum(hybrid_plant.pv.dispatch.generation) <= sum(hybrid_plant.pv.dispatch.available_generation) # CSP can run assert sum(hybrid_plant.tower.dispatch.cycle_generation) > 0.0 assert sum(hybrid_plant.tower.dispatch.receiver_thermal_power) > 0.0
}} # Get resource lat = flatirons_site['lat'] lon = flatirons_site['lon'] prices_file = Path(__file__).parent.absolute().parent.parent / 'resource_files' / 'grid' / 'pricing-data-2015-IronMtn-002_factors.csv' site = SiteInfo(flatirons_site, grid_resource_file=prices_file) # Create model hybrid_plant = HybridSimulation(technologies, site, interconnect_kw=interconnection_size_mw * 1000) hybrid_plant.pv.system_capacity_kw = solar_size_mw * 1000 hybrid_plant.pv.dc_degradation = [0] * 25 hybrid_plant.wind.system_capacity_by_num_turbines(wind_size_mw * 1000) hybrid_plant.ppa_price = 0.06 # [$/kWh] hybrid_plant.simulate(2) file = 'figures/' tag = 'simple2_' #plot_battery_dispatch_error(hybrid_plant, plot_filename=file+tag+'battery_dispatch_error.png') ''' for d in range(0, 360, 5): plot_battery_output(hybrid_plant, start_day=d, plot_filename=file+tag+'day'+str(d)+'_battery_gen.png') plot_generation_profile(hybrid_plant, start_day=d, plot_filename=file+tag+'day'+str(d)+'_system_gen.png') ''' plot_battery_dispatch_error(hybrid_plant) plot_battery_output(hybrid_plant) plot_generation_profile(hybrid_plant) #plot_battery_dispatch_error(hybrid_plant, plot_filename=tag+'battery_dispatch_error.png')