def run_scenario(scenario,
path_input,
path_results,
solver='glpk',
time_limit=30,
troubleshooting=True,
show_opt_balance=True,
show_opt_soc=True,
show_flex_res=True,
save_opt_res=True,
show_aggregated_flex=True,
save_flex_offers=False,
convert_input_tocsv=True,
show_aggregated_flex_price='bar'):
""" run an OpenTUMFlex model for given scenario
Args:
- scenario: predefined scenario function which will modify the parameters in opentumflex dictionary to create
a certain scenario
- path_input: path of input file which can be used to read devices parameters and forecasting data
- path_results: path to be saved in for results of the optimization
- fcst_only: if true, read_data() will only read forecasting data from input file, otherwise it will also read
device parameters
- time_limit: determine the maximum duration of optimization in seconds
Returns:
opentumflex dictionary with optimization results and flexibility offers
"""
init_time_step = 0
end_step = 96
# initialize with basic time settings
my_ems = opentumflex.initialize_time_setting(0,
t_inval=15,
start_time='2019-12-18 00:00',
end_time='2019-12-18 23:45')
full_ems = opentumflex.initialize_time_setting(
0,
t_inval=15,
start_time='2019-12-18 00:00',
end_time='2019-12-20 23:45')
if scenario == opentumflex.scenario_fromfile:
# read devices parameters and forecasting data from xlsx or csv file
my_ems = opentumflex.read_data(my_ems,
init_time_step,
end_step,
path_input,
fcst_only=False,
to_csv=convert_input_tocsv)
full_ems = opentumflex.read_data(full_ems,
init_time_step,
-1,
path_input,
fcst_only=False,
to_csv=convert_input_tocsv)
else:
# read only the input time series from the excel table
my_ems = opentumflex.read_data(my_ems,
init_time_step,
end_step,
path_input,
fcst_only=False,
to_csv=convert_input_tocsv)
# modify the opentumflex regarding to predefined scenario
my_ems = scenario(my_ems)
# read only the input time series from the excel table
full_ems = opentumflex.read_data(full_ems,
init_time_step,
-1,
path_input,
fcst_only=False,
to_csv=convert_input_tocsv)
# modify the opentumflex regarding to predefined scenario
full_ems = scenario(full_ems)
# create Pyomo model from opentumflex data
m = opentumflex.create_model(my_ems)
# solve the optimization problem
m = opentumflex.solve_model(m,
solver=solver,
time_limit=time_limit,
troubleshooting=troubleshooting)
# extract the results from model and store them in opentumflex['optplan'] dictionary
my_ems = opentumflex.extract_res(m, my_ems)
# create Pyomo model from opentumflex data
mf = opentumflex.create_model(full_ems)
# solve the optimization problem
mf = opentumflex.solve_model(mf,
solver=solver,
time_limit=time_limit,
troubleshooting=troubleshooting)
# extract the results from model and store them in opentumflex['optplan'] dictionary
full_ems = opentumflex.extract_res(mf, full_ems)
# visualize the optimization results
opentumflex.plot_optimal_results(my_ems,
show_balance=show_opt_balance,
show_soc=show_opt_soc)
# save the data in .xlsx in given path
if save_opt_res:
opentumflex.save_results(my_ems, path_results)
# calculate the flexibility
# create a group of all flex calculators
calc_flex = {
opentumflex.calc_flex_hp: 'hp',
opentumflex.calc_flex_ev: 'ev',
opentumflex.calc_flex_chp: 'chp',
opentumflex.calc_flex_bat: 'bat',
opentumflex.calc_flex_pv: 'pv'
}
# iterate through all the flexibility functions
for function, device_name in calc_flex.items():
if my_ems['devices'][device_name]['maxpow'] != 0:
function(my_ems, reopt=False)
function(full_ems, reopt=False)
# plot the results of flexibility calculation
if show_flex_res:
for device_name in calc_flex.values():
if my_ems['devices'][device_name]['maxpow'] != 0:
opentumflex.plot_flex(my_ems, device_name)
# plot stacked flexibility of all devices
if show_aggregated_flex:
opentumflex.plot_aggregated_flex_power(my_ems)
opentumflex.plot_aggregated_flex_price(
my_ems, plot_flexpr=show_aggregated_flex_price)
# save flex offers
if save_flex_offers:
opentumflex.save_offers(my_ems, market='comax')
my_ems['reoptim']['flexstep'] = my_ems['time_data']['nsteps']
pd.set_option("display.max_rows", None, "display.max_columns", None)
A = pd.DataFrame()
date_time = []
for num in range(len(my_ems['time_data']['time_slots'])):
date_time.append(my_ems['time_data']['time_slots'][num])
date_time = pd.DataFrame(date_time, columns=['Time'])
A = pd.concat([A, date_time], axis=1)
key_list = list(my_ems['flexopts'])
for comp in key_list:
A = pd.concat([
A, my_ems['flexopts'][comp]['Pos_P'],
my_ems['flexopts'][comp]['Neg_P']
],
axis=1)
print(A)
return my_ems, full_ems
def run_scenario(scenario,
path_input,
path_results,
solver='glpk',
time_limit=30,
troubleshooting=True,
show_opt_balance=True,
show_opt_soc=True,
show_flex_res=True,
save_opt_res=True,
show_aggregated_flex=True,
save_flex_offers=False,
convert_input_tocsv=True,
show_aggregated_flex_price='bar'):
""" run an OpenTUMFlex model for given scenario
Args:
- scenario: predefined scenario function which will modify the parameters in opentumflex dictionary to create
a certain scenario
- path_input: path of input file which can be used to read devices parameters and forecasting data
- path_results: path to be saved in for results of the optimization
- fcst_only: if true, read_data() will only read forecasting data from input file, otherwise it will also read
device parameters
- time_limit: determine the maximum duration of optimization in seconds
Returns:
opentumflex dictionary with optimization results and flexibility offers
"""
# initialize with basic time settings
my_ems = opentumflex.initialize_time_setting(t_inval=15,
start_time='2019-12-18 00:00',
end_time='2019-12-18 23:45')
if scenario == opentumflex.scenario_fromfile:
# read devices parameters and forecasting data from xlsx or csv file
my_ems = opentumflex.read_data(my_ems,
path_input,
fcst_only=False,
to_csv=convert_input_tocsv)
else:
# read only the input time series from the excel table
my_ems = opentumflex.read_data(my_ems,
path_input,
fcst_only=False,
to_csv=convert_input_tocsv)
# modify the opentumflex regarding to predefined scenario
my_ems = scenario(my_ems)
# create Pyomo model from opentumflex data
m = opentumflex.create_model(my_ems)
# solve the optimization problem
m = opentumflex.solve_model(m,
solver=solver,
time_limit=time_limit,
troubleshooting=troubleshooting)
# extract the results from model and store them in opentumflex['optplan'] dictionary
my_ems = opentumflex.extract_res(m, my_ems)
# visualize the optimization results
opentumflex.plot_optimal_results(my_ems,
show_balance=show_opt_balance,
show_soc=show_opt_soc)
# save the data in .xlsx in given path
if save_opt_res:
opentumflex.save_results(my_ems, path_results)
# calculate the flexibility
# create a group of all flex calculators
calc_flex = {
opentumflex.calc_flex_hp: 'hp',
opentumflex.calc_flex_ev: 'ev',
opentumflex.calc_flex_chp: 'chp',
opentumflex.calc_flex_bat: 'bat',
opentumflex.calc_flex_pv: 'pv'
}
# iterate through all the flexibility functions
for function, device_name in calc_flex.items():
if my_ems['devices'][device_name]['maxpow'] != 0:
function(my_ems, reopt=False)
# plot the results of flexibility calculation
if show_flex_res:
for device_name in calc_flex.values():
if my_ems['devices'][device_name]['maxpow'] != 0:
opentumflex.plot_flex(my_ems, device_name)
# plot stacked flexibility of all devices
if show_aggregated_flex:
opentumflex.plot_aggregated_flex_power(my_ems)
opentumflex.plot_aggregated_flex_price(
my_ems, plot_flexpr=show_aggregated_flex_price)
# save flex offers
if save_flex_offers:
opentumflex.save_offers(my_ems, market='comax')
return my_ems
def calc_ev_flex_offers_parallel(param_variation, param_fix):
"""
This function calculates the flexibility of each vehicle availability for a specific power level & pricing strategy.
:param param_variation: parameter variation as a list containing charging power (float), pricing strategy (string)
and vehicle availability (list)
:param param_fix: fix parameters consisting of 'conversion_distance_2_km', 'conversion_km_2_kwh', 'rtp_input_data_path',
'output_path', 'pricing_strategies', 'plotting'
:return: None
"""
# initialize with basic time settings
my_ems = opentumflex.initialize_time_setting(t_inval=15,
start_time='2012-01-01 00:00',
end_time='2012-01-01 23:00')
# Reset forecasts
my_ems['fcst'] = {}
# Ceil arrival time to next quarter hour
t_arrival_ceiled = pd.Timestamp(param_variation[2][4]).ceil(freq='15Min')
# Floor departure time to previous quarter hour
t_departure_floored = pd.Timestamp(
param_variation[2][5]).floor(freq='15Min')
# Check whether time between ceiled arrival and floored departure time are at least two time steps
if t_arrival_ceiled >= t_departure_floored:
if param_fix['info']:
print('#' + str(param_variation[2][0]) + ': Time not sufficient.')
return
else:
if param_fix['info']:
print('#' + str(param_variation[2][0]) + ': Power=' +
str(param_variation[0]) + ' Pricing=' + param_variation[1])
# change the time interval
my_ems['time_data']['start_time'] = t_arrival_ceiled.strftime(
'%Y-%m-%d %H:%M')
my_ems['time_data']['end_time'] = t_departure_floored.strftime(
'%Y-%m-%d %H:%M')
my_ems.update(opentumflex.update_time_data(my_ems))
my_ems['fcst']['temperature'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['solar_power'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['load_heat'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['load_elec'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['gas_price'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['ele_price_out'] = [0] * my_ems['time_data']['nsteps']
# Get simulated price forecast for given time period
price_fcst = forecast.simulate_elect_price_fcst(
rtp_input_data_path=param_fix['rtp_input_data_path'],
t_start=t_arrival_ceiled,
t_end=t_departure_floored,
pr_constant=0.19,
pricing=param_fix['pricing_strategies'])
# Update forecast data
my_ems['fcst']['ele_price_in'] = price_fcst[param_variation[1]].to_list()
# Update EV parameters
my_ems['devices'].update(
opentumflex.create_device(
device_name='ev',
minpow=0,
maxpow=param_variation[0],
stocap=round(param_variation[2][2] *
param_fix['conversion_distance_2_km'] *
param_fix['conversion_km_2_kwh']),
init_soc=[0],
end_soc=[100],
eta=0.98,
ev_aval=[
my_ems['time_data']['start_time'],
my_ems['time_data']['end_time']
],
timesetting=my_ems['time_data']))
# create Pyomo model from opentumflex data
m = opentumflex.create_model(my_ems)
# solve the optimization problem
m = opentumflex.solve_model(m,
solver='glpk',
time_limit=30,
troubleshooting=False)
# extract the results from model and store them in opentumflex['optplan'] dictionary
my_ems = opentumflex.extract_res(m, my_ems)
# Calculate ev flexibility
my_ems = opentumflex.calc_flex_ev(my_ems)
# Plot flex result
if param_fix['plotting']:
opentumflex.plot_flex(my_ems, 'ev')
# Save results to files
opentumflex.save_ems(my_ems,
path=param_fix['output_path'] +
str(param_variation[0]) + '/' + param_variation[1] +
'/ev_avail_' + str(param_variation[2][0]) + '.txt')
def calc_ev_flex_offers(
veh_availabilities,
rtp_input_data_path='../analysis/input/RTP/',
output_path='output/',
power_levels=[3.7, 11, 22],
pricing_strategies={'ToU', 'Constant', 'Con_mi', 'ToU_mi', 'RTP'},
conversion_distance_2_km=1.61,
conversion_km_2_kwh=0.2,
plotting=False):
"""
This function iteratively calculates the flexibility of each vehicle availability for every power level
and pricing strategy.
:param veh_availabilities: vehicle availabilities consisting of arrival and departure times, distance travelled
:param output_path: path where output shall be stored
:param rtp_input_data_path: real time prices input file in h5 format
:param power_levels: charging power levels
:param pricing_strategies: pricing strategies for simulations
:param conversion_distance_2_km: conversion rate, e.g. 1 mile = 1.61 km
:param conversion_km_2_kwh: conversion rate from km to kwh
:param plotting: plotting parameter, default is False
:return: None
"""
# initialize with basic time settings
my_ems = opentumflex.initialize_time_setting(t_inval=15,
start_time='2012-01-01 00:00',
end_time='2012-01-01 23:00')
# Reset forecasts
my_ems['fcst'] = {}
# Counter for keeping track of insufficient time differences
t_insufficient_count = 0
# Go through all vehicle availabilities
for i in range(len(veh_availabilities)):
print('################# Vehicle availability #' + str(i) +
' #################')
# Ceil arrival time to next quarter hour
t_arrival_ceiled = pd.Timestamp(
veh_availabilities['t_arrival'][i]).ceil(freq='15Min')
# Floor departure time to previous quarter hour
t_departure_floored = pd.Timestamp(
veh_availabilities['t_departure'][i]).floor(freq='15Min')
# Check whether time between ceiled arrival and floored departure time are at least two time steps
if t_arrival_ceiled >= t_departure_floored:
print('### Time is not sufficient for timestep:', i, '###')
t_insufficient_count += 1
continue
# change the time interval
my_ems['time_data']['start_time'] = t_arrival_ceiled.strftime(
'%Y-%m-%d %H:%M')
my_ems['time_data']['end_time'] = t_departure_floored.strftime(
'%Y-%m-%d %H:%M')
my_ems.update(opentumflex.update_time_data(my_ems))
my_ems['fcst']['temp'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['solar'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['last_heat'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['last_elec'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['gas'] = [0] * my_ems['time_data']['nsteps']
my_ems['fcst']['ele_price_out'] = [0] * my_ems['time_data']['nsteps']
# Get simulated price forecast for given time period
price_fcst = forecast.simulate_elect_price_fcst(
rtp_input_data_path=rtp_input_data_path,
t_start=t_arrival_ceiled,
t_end=t_departure_floored,
pr_constant=0.19,
pricing=pricing_strategies)
# Go through all price strategies
for price in price_fcst.columns:
# Go through all power levels
for power in power_levels:
print('#' + str(i) + ': Power=' + str(power) + ' Pricing=' +
price)
# Update forecast data
my_ems['fcst']['ele_price_in'] = price_fcst[price].to_list()
# Update EV parameters
my_ems['devices'].update(
opentumflex.create_device(
device_name='ev',
minpow=0,
maxpow=power,
stocap=round(veh_availabilities['d_travelled'][i] *
conversion_distance_2_km *
conversion_km_2_kwh),
init_soc=[0],
end_soc=[100],
eta=0.98,
ev_aval=[
my_ems['time_data']['start_time'],
my_ems['time_data']['end_time']
],
timesetting=my_ems['time_data']))
# create Pyomo model from opentumflex data
m = opentumflex.create_model(my_ems)
# solve the optimization problem
m = opentumflex.solve_model(m,
solver='glpk',
time_limit=30,
troubleshooting=False)
# extract the results from model and store them in opentumflex['optplan'] dictionary
my_ems = opentumflex.extract_res(m, my_ems)
# Calculate ev flexibility
my_ems = opentumflex.calc_flex_ev(my_ems)
# Plot flex result
if plotting:
opentumflex.plot_flex(my_ems, 'ev')
# Save results to files
opentumflex.save_ems(my_ems,
path=output_path + str(power) + '/' +
price + '/ev_avail_' + str(i) + '.txt')
def run_scenario_reopt(scenario,
old_ems,
full_ems,
path_results,
reopt_data=[0, 'no-flex'],
solver='glpk',
time_limit=30,
troubleshooting=True,
show_opt_balance=True,
show_opt_soc=True,
show_flex_res=True,
save_opt_res=True,
show_aggregated_flex=True,
save_flex_offers=False,
convert_input_tocsv=True,
show_aggregated_flex_price='bar'):
""" run an OpenTUMFlex model for given scenario
Args:
- scenario: predefined scenario function which will modify the parameters in opentumflex dictionary to create
a certain scenario
- path_input: path of input file which can be used to read devices parameters and forecasting data
- path_results: path to be saved in for results of the optimization
- fcst_only: if true, read_data() will only read forecasting data from input file, otherwise it will also read
device parameters
- time_limit: determine the maximum duration of optimization in seconds
Returns:
opentumflex dictionary with optimization results and flexibility offers
"""
init_time_step = reopt_data[0] #for the ith step find the time
flex_device = reopt_data[
1] #for the ith step find the device whose offer is to be selected
full_ems_start_step = 0
for tim in full_ems['time_data']['time_slots'] == old_ems['time_data'][
'time_slots'][init_time_step]:
if tim == True:
break
else:
full_ems_start_step += 1
# initialize with basic time settings
my_ems = opentumflex.initialize_time_setting(
0,
t_inval=15,
start_time=full_ems['time_data']['time_slots'][full_ems_start_step],
end_time=full_ems['time_data']['time_slots'][full_ems_start_step + 95])
if old_ems['reoptim']['flexstep'] == old_ems['time_data']['nsteps']:
my_ems['reoptim']['flexstep'] = init_time_step
else:
init_time_step = init_time_step - old_ems['reoptim']['flexstep']
#my_ems = opentumflex.initialize_time_setting(init_time_step,t_inval=15, start_time=old_ems['time_data']['start_time'], end_time='2019-12-18 23:45')
my_ems['reoptim']['flexstep'] = reopt_data[0]
#preparation of my_ems from old_ems
key_list = list(old_ems['optplan'])
for ind_para in key_list:
my_ems['optplan'][ind_para] = full_ems['optplan'][ind_para][
full_ems_start_step:full_ems_start_step + 96]
my_ems['optplan'][ind_para][:96 - init_time_step] = old_ems['optplan'][
ind_para][init_time_step:]
key_list = list(old_ems['flexopts'])
for ind_para in key_list:
my_ems['flexopts'][ind_para] = full_ems['flexopts'][ind_para][
full_ems_start_step:full_ems_start_step + 96]
my_ems['flexopts'][ind_para].reset_index(drop=True, inplace=True)
key_list = list(old_ems['fcst'])
my_ems['fcst'] = {}
for ind_para in key_list:
my_ems['fcst'][ind_para] = full_ems['fcst'][ind_para][
full_ems_start_step:full_ems_start_step + 96]
my_ems['devices'] = full_ems['devices']
my_ems['reoptim']['type_flex'] = [0] * 96
if flex_device == 'PV_n':
if abs(old_ems['flexopts']['pv']['Neg_P'][init_time_step]) <= 0.000001:
print('Negative flexibility of PV not available in this time step')
return old_ems
inc = 1
while abs(old_ems['flexopts']['pv']['Neg_P'][init_time_step]) - abs(
old_ems['flexopts']['pv']['Neg_P'][init_time_step + inc]) <= 0:
inc += 1
for a in range(96):
if a <= inc:
my_ems['reoptim']['type_flex'][a] = 1
else:
break
my_ems['reoptim']['flex_value'] = [
-1 * old_ems['flexopts']['pv']['Neg_P'][init_time_step]
] * inc
my_ems['reoptim']['flex_value'][inc:] = [0] * (96 - inc)
elif flex_device == 'PV_p':
if abs(old_ems['flexopts']['pv']['Pos_P'][init_time_step]) <= 0.00001:
print('Positive flexibility of PV not available in this time step')
return old_ems
inc = 1
while abs(old_ems['flexopts']['pv']['Pos_P'][init_time_step]) <= abs(
old_ems['flexopts']['pv']['Pos_P'][init_time_step + inc]):
inc += 1
for a in range(96):
if a <= inc:
my_ems['reoptim']['type_flex'][a] = 2
else:
break
my_ems['reoptim']['flex_value'] = [
old_ems['flexopts']['pv']['Pos_P'][init_time_step]
] * inc
my_ems['reoptim']['flex_value'][inc:] = [0] * (96 - inc)
elif flex_device == 'BAT_n':
if abs(old_ems['flexopts']['bat']['Neg_P']
[init_time_step]) <= 0.000001:
print(
'Negative flexibility of Battery not available in this time step'
)
return old_ems
inc = 0
bat_SOC = old_ems['optplan']['bat_SOC'][init_time_step - 1]
ntsteps = old_ems['time_data']['ntsteps']
stocap = old_ems['devices']['bat']['stocap']
max_pow = old_ems['devices']['bat']['maxpow']
while bat_SOC + max_pow / (ntsteps * stocap) * 100 <= 100:
inc += 1
bat_SOC += max_pow / (ntsteps * stocap) * 100
for a in range(96):
if a < inc:
my_ems['reoptim']['type_flex'][a] = 3
else:
break
my_ems['reoptim']['flex_value'] = [
-1 * old_ems['flexopts']['bat']['Neg_P'][init_time_step]
] * inc
my_ems['reoptim']['flex_value'][inc:] = [0] * (96 - inc)
elif flex_device == 'BAT_p':
if abs(old_ems['flexopts']['bat']['Pos_P']
[init_time_step]) <= 0.000001:
print(
'Positive flexibility of Battery not available in this time step'
)
return old_ems
inc = 0
bat_SOC = old_ems['optplan']['bat_SOC'][init_time_step - 1]
ntsteps = old_ems['time_data']['ntsteps']
stocap = old_ems['devices']['bat']['stocap']
max_pow = old_ems['devices']['bat']['maxpow']
while bat_SOC - max_pow / (ntsteps * stocap) * 100 >= 0:
inc += 1
bat_SOC -= max_pow / (ntsteps * stocap) * 100
for a in range(96):
if a < inc:
my_ems['reoptim']['type_flex'][a] = 4
else:
break
my_ems['reoptim']['flex_value'] = [
old_ems['flexopts']['bat']['Pos_P'][init_time_step]
] * inc
my_ems['reoptim']['flex_value'][inc:] = [0] * (96 - inc)
#storing flexibilty value for further calculations in the code
flex_value = deepcopy(my_ems['reoptim']['flex_value'][0])
#setting up SOC of my_ems equal to the last step before implementation of reoptimizaiton
my_ems['devices']['bat']['initSOC'] = old_ems['optplan']['bat_SOC'][
init_time_step - 1]
#creating deepcopy so that changes in my_ems_without_flex does not bring changes in my_ems
my_ems_without_flex = deepcopy(my_ems)
#setting type flexibility to 0 in order to run the original model wihtout flexibility constrainst
for a in range(96):
my_ems_without_flex['reoptim']['type_flex'][a] = 0
my_ems_without_flex['reoptim']['flex_value'] = [0] * 96
#forming ems without flexibility offer for comparison
m_without_flex = opentumflex.create_model(my_ems_without_flex)
m_without_flex = opentumflex.solve_model(m_without_flex,
solver=solver,
time_limit=time_limit,
troubleshooting=troubleshooting)
my_ems_without_flex = opentumflex.extract_res(m_without_flex,
my_ems_without_flex)
#solving mes with flexibility offer
m = opentumflex.create_model(my_ems)
m = opentumflex.solve_model(m,
solver=solver,
time_limit=time_limit,
troubleshooting=troubleshooting)
my_ems = opentumflex.extract_res(m, my_ems)
calc_flex = {
opentumflex.calc_flex_hp: 'hp',
opentumflex.calc_flex_ev: 'ev',
opentumflex.calc_flex_chp: 'chp',
opentumflex.calc_flex_bat: 'bat',
opentumflex.calc_flex_pv: 'pv'
}
# visualize the optimization results
opentumflex.plot_optimal_results(my_ems,
show_balance=show_opt_balance,
show_soc=show_opt_soc)
#the one below compares result of reoptimization starting from the instance of offer selection
#opentumflex.compare_optimal_results(my_ems, my_ems_without_flex,0,inc)
#the code below compares optimization result starting from the start point of old_ems
historical_data = True
if historical_data == True:
my_ems_without_flex_hd = {}
my_ems_without_flex_hd['devices'] = old_ems['devices']
my_ems_without_flex_hd['fcst'] = old_ems['fcst']
my_ems_without_flex_hd['time_data'] = old_ems['time_data']
my_ems_without_flex_hd['optplan'] = old_ems['optplan']
my_ems_without_flex_hd['flexopts'] = old_ems['flexopts']
my_ems_hd = deepcopy(my_ems_without_flex_hd)
my_ems_hd['reoptim'] = {}
my_ems_hd['reoptim']['flex_value'] = [0] * len(
my_ems['time_data']['time_slots'])
my_ems_hd['reoptim'][
'flex_value'][init_time_step:init_time_step +
inc] = [my_ems['reoptim']['flex_value'][0]] * inc
key_list = list(old_ems['optplan'])
for ind_para in key_list:
my_ems_without_flex_hd['optplan'][ind_para][
init_time_step:] = my_ems_without_flex['optplan'][
ind_para][:96 - init_time_step]
my_ems_hd['optplan'][ind_para][init_time_step:] = my_ems[
'optplan'][ind_para][:96 - init_time_step]
key_list = list(old_ems['flexopts'])
for ind_para in key_list:
my_ems_without_flex_hd['flexopts'][ind_para][
init_time_step:] = np.array(
my_ems_without_flex['flexopts'][ind_para][:96 -
init_time_step])
my_ems_hd['flexopts'][ind_para][init_time_step:] = np.array(
my_ems['flexopts'][ind_para][:96 - init_time_step])
opentumflex.compare_optimal_results(my_ems_hd, my_ems_without_flex_hd,
init_time_step,
init_time_step + inc, flex_device,
flex_value)
#the code below makes the calculation for two cases: 1)revenue generation without flexibity 2) revenue generation with flexibility
ntsteps = old_ems['time_data']['ntsteps']
Revenue_without_flex = np.empty(
((len(my_ems_without_flex['time_data']['time_slots']) + 1, 2)))
#Revenue_without_flex['Time_slots']= np.array(my_ems_without_flex['time_data']['time_slots'])
Revenue_without_flex[:-1, 0] = np.array(
my_ems_without_flex['fcst']['ele_price_out']) * np.array(
my_ems_without_flex['optplan']['grid_export']) / ntsteps
Revenue_without_flex[:-1, 1] = np.array(
my_ems_without_flex['fcst']['ele_price_in']) * np.array(
my_ems_without_flex['optplan']['grid_import']) / ntsteps
Revenue_without_flex[-1, 0] = np.sum(Revenue_without_flex[:-1, 0])
Revenue_without_flex[-1, 1] = np.sum(Revenue_without_flex[:-1, 1])
Revenue_with_flex = np.empty(
((len(my_ems_hd['time_data']['time_slots']) + 1, 3)))
#Revenue_with_flex['Time_slots']= np.array(my_ems_hd['time_data']['time_slots'])
Revenue_with_flex[:-1, 0] = np.array(
my_ems_hd['fcst']['ele_price_out']) * np.array(
my_ems_hd['optplan']['grid_export']) / ntsteps
Revenue_with_flex[:-1, 1] = np.array(
my_ems_hd['fcst']['ele_price_in']) * np.array(
my_ems_hd['optplan']['grid_import']) / ntsteps
if flex_device == 'PV_p':
Revenue_with_flex[:-1, 2] = np.array(
my_ems_hd['flexopts']['pv']['Pos_Pr'][init_time_step]) * np.array(
my_ems_hd['reoptim']['flex_value']) / ntsteps
elif flex_device == 'PV_n':
Revenue_with_flex[:-1, 2] = np.array(
my_ems_hd['flexopts']['pv']['Neg_Pr'][init_time_step]) * np.array(
my_ems_hd['reoptim']['flex_value']) / ntsteps
elif flex_device == 'BAT_p':
Revenue_with_flex[:-1, 2] = np.array(
my_ems_hd['flexopts']['bat']['Pos_Pr'][init_time_step]) * np.array(
my_ems_hd['reoptim']['flex_value']) / ntsteps
elif flex_device == 'BAT_n':
Revenue_with_flex[:-1, 2] = np.array(
my_ems_hd['flexopts']['bat']['Neg_Pr'][init_time_step]) * np.array(
my_ems_hd['reoptim']['flex_value']) / ntsteps
Revenue_with_flex[-1, 0] = np.sum(Revenue_with_flex[:-1, 0])
Revenue_with_flex[-1, 1] = np.sum(Revenue_with_flex[:-1, 1])
Revenue_with_flex[-1, 2] = np.sum(Revenue_with_flex[:-1, 2])
index = my_ems_without_flex['time_data']['time_slots']
index = index.append(pd.Index(['Total']))
columns_withouttf = ['Export Earning', 'Import Expenditure']
columns_withtf = [
'Export Earning', 'Import Expenditure', 'Flexibility Earning'
]
Revenue_withoutf = pd.DataFrame(Revenue_without_flex,
index=index,
columns=columns_withouttf)
Revenue_withf = pd.DataFrame(Revenue_with_flex,
index=index,
columns=columns_withtf)
revenue_minus_expenditure_withf = Revenue_with_flex[
-1, 0] - Revenue_with_flex[-1, 1] + Revenue_with_flex[-1, 2]
revenue_minus_expenditure_withoutf = Revenue_without_flex[
-1, 0] - Revenue_without_flex[-1, 1]
Net_gain = revenue_minus_expenditure_withf - revenue_minus_expenditure_withoutf
print(Net_gain)
# save the data in .xlsx in given path
if save_opt_res:
opentumflex.save_results(my_ems, path_results)
# plot the results of flexibility calculation
if show_flex_res:
for device_name in calc_flex.values():
if my_ems['devices'][device_name]['maxpow'] != 0:
opentumflex.plot_flex(my_ems, device_name)
# plot stacked flexibility of all devices
if show_aggregated_flex:
opentumflex.plot_aggregated_flex_power(my_ems)
opentumflex.plot_aggregated_flex_price(
my_ems, plot_flexpr=show_aggregated_flex_price)
# save flex offers
if save_flex_offers:
opentumflex.save_offers(my_ems, market='comax')
return my_ems