#principle index
principle_index = 1
nfe = 50000
if __name__ == "__main__":
print("uncertainty analysis started for: " +
principles_list[principle_index] + " case for " + str(nfe) +
" scenario's")
model = PyRICE(model_specification="EMA", welfare_function="prioritarian")
RICE = Model('RICE', function=model)
RICE.uncertainties = [
IntegerParameter('fdamage', 0, 2),
IntegerParameter('t2xco2_index', 0, 999),
IntegerParameter('t2xco2_dist', 0, 2),
RealParameter('fosslim', 4000, 13649),
IntegerParameter('scenario_pop_gdp', 0, 5),
IntegerParameter('scenario_sigma', 0, 2),
IntegerParameter('scenario_cback', 0, 1),
IntegerParameter('scenario_elasticity_of_damages', 0, 2),
IntegerParameter('scenario_limmiu', 0, 1)
]
#same for all formulations
RICE.outcomes = get_all_model_outcomes_uncertainty_search(
optimization_formulation="utilitarian")
ema_logging.log_to_stderr(ema_logging.INFO)
largest_cc = max(nx.connected_components(er), key=len)
Sf = len(largest_cc)
gd = nx.density(er)
return {'density': gd}
if __name__ == '__main__':
ema_logging.LOG_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s'
ema_logging.log_to_stderr(ema_logging.INFO)
mapper = {0: 'n', 1: 'p'}
model = Model('SimulateER', function=simulate) # instantiate the model
# specify uncertainties
model.uncertainties = [RealParameter("p", 0.1, 1.0)]
model.levers = [IntegerParameter("n", 10, 100)]
# specify outcomes
model.outcomes = [ScalarOutcome('density')]
model.constants = [Constant('replications', 10)]
n_scenarios = 10
n_policies = 10
res = perform_experiments(model, n_scenarios, n_policies)
"""
with MultiprocessingEvaluator(model) as evaluator:
res = evaluator.perform_experiments(n_scenarios, n_policies,
levers_sampling=MC)
"""
ema_logging.log_to_stderr(ema_logging.INFO)
# %%
if __name__ == '__main__':
ema_logging.log_to_stderr(ema_logging.INFO)
model = PyDICE()
dice_sm = Model('dicesmEMA', function=model)
dice_sm.uncertainties = [
RealParameter('tfp_gr', 0.07, 0.09),
RealParameter('sigma_gr', -0.012, -0.008),
RealParameter('pop_gr', 0.1, 0.15),
RealParameter('fosslim', 4000.0, 13649),
IntegerParameter('cback', 100, 600),
RealParameter('emdd', -1, 0.99),
IntegerParameter('vd_switch', 0, 1),
]
dice_sm.levers = [
RealParameter('sr', 0.1, 0.5),
RealParameter('prtp_con', 0.001, 0.015),
RealParameter('emuc', 1.01, 2.00),
# IntegerParameter('vd_switch', 0, 1),
IntegerParameter('periodfullpart', 10, 58),
IntegerParameter('miu_period', 10, 58)
]
dice_sm.outcomes = [
TimeSeriesOutcome('Atmospheric Temperature'),
def get_model_for_problem_formulation(problem_formulation_id):
''' Prepare DikeNetwork in a way it can be input in the EMA-workbench.
Specify uncertainties, levers and problem formulation.
'''
# Load the model:
function = DikeNetwork()
# workbench model:
dike_model = Model('dikesnet', function=function)
# Uncertainties and Levers:
# Specify uncertainties range:
Real_uncert = {'Bmax': [30, 350], 'pfail': [0, 1]} # m and [.]
# breach growth rate [m/day]
cat_uncert_loc = {'Brate': (1, 1.5, 10)}
cat_uncert = {
'discount rate {}'.format(n): (1.5, 2.5, 3.5, 4.5)
for n in function.planning_steps
}
Int_uncert = {'A.0_ID flood wave shape': [0, 132]}
# Range of dike heightening:
dike_lev = {'DikeIncrease': [0, 10]} # dm
# Series of five Room for the River projects:
rfr_lev = ['{}_RfR'.format(project_id) for project_id in range(0, 5)]
# Time of warning: 0, 1, 2, 3, 4 days ahead from the flood
EWS_lev = {'EWS_DaysToThreat': [0, 4]} # days
uncertainties = []
levers = []
for uncert_name in cat_uncert.keys():
categories = cat_uncert[uncert_name]
uncertainties.append(CategoricalParameter(uncert_name, categories))
for uncert_name in Int_uncert.keys():
uncertainties.append(
IntegerParameter(uncert_name, Int_uncert[uncert_name][0],
Int_uncert[uncert_name][1]))
# RfR levers can be either 0 (not implemented) or 1 (implemented)
for lev_name in rfr_lev:
for n in function.planning_steps:
lev_name_ = '{} {}'.format(lev_name, n)
levers.append(IntegerParameter(lev_name_, 0, 1))
# Early Warning System lever
for lev_name in EWS_lev.keys():
levers.append(
IntegerParameter(lev_name, EWS_lev[lev_name][0],
EWS_lev[lev_name][1]))
for dike in function.dikelist:
# uncertainties in the form: locationName_uncertaintyName
for uncert_name in Real_uncert.keys():
name = "{}_{}".format(dike, uncert_name)
lower, upper = Real_uncert[uncert_name]
uncertainties.append(RealParameter(name, lower, upper))
for uncert_name in cat_uncert_loc.keys():
name = "{}_{}".format(dike, uncert_name)
categories = cat_uncert_loc[uncert_name]
uncertainties.append(CategoricalParameter(name, categories))
# location-related levers in the form: locationName_leversName
for lev_name in dike_lev.keys():
for n in function.planning_steps:
name = "{}_{} {}".format(dike, lev_name, n)
levers.append(
IntegerParameter(name, dike_lev[lev_name][0],
dike_lev[lev_name][1]))
# load uncertainties and levers in dike_model:
dike_model.uncertainties = uncertainties
dike_model.levers = levers
# Problem formulations:
# Outcomes are all costs, thus they have to minimized:
direction = ScalarOutcome.MINIMIZE
# 2-objective PF:
if problem_formulation_id == 0:
variable_names = []
variable_names_ = []
for n in function.planning_steps:
variable_names.extend([
'{}_{} {}'.format(dike, e, n)
for e in ['Expected Annual Damage', 'Dike Investment Costs']
for dike in function.dikelist
])
variable_names_.extend([
'{}_{} {}'.format(dike, e, n)
for e in ['Expected Number of Deaths']
for dike in function.dikelist
])
variable_names.extend(['RfR Total Costs {}'.format(n)])
variable_names.extend(['Expected Evacuation Costs {}'.format(n)])
dike_model.outcomes = [
ScalarOutcome('All Costs',
variable_name=[var for var in variable_names],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Number of Deaths',
variable_name=[var for var in variable_names_],
function=sum_over,
kind=direction)
]
# 3-objectives PF:
elif problem_formulation_id == 1:
variable_names = []
variable_names_ = []
variable_names__ = []
for n in function.planning_steps:
variable_names.extend([
'{}_Expected Annual Damage {}'.format(dike, n)
for dike in function.dikelist
])
variable_names_.extend([
'{}_Dike Investment Costs {}'.format(dike, n)
for dike in function.dikelist
] + ['RfR Total Costs {}'.format(n)] +
['Expected Evacuation Costs {}'.format(n)])
variable_names__.extend([
'{}_Expected Number of Deaths {}'.format(dike, n)
for dike in function.dikelist
])
dike_model.outcomes = [
ScalarOutcome('Expected Annual Damage',
variable_name=[var for var in variable_names],
function=sum_over,
kind=direction),
ScalarOutcome('Total Investment Costs',
variable_name=[var for var in variable_names_],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Number of Deaths',
variable_name=[var for var in variable_names__],
function=sum_over,
kind=direction)
]
# 5-objectives PF:
elif problem_formulation_id == 2:
variable_names = []
variable_names_ = []
variable_names__ = []
variable_names___ = []
variable_names____ = []
for n in function.planning_steps:
variable_names.extend([
'{}_Expected Annual Damage {}'.format(dike, n)
for dike in function.dikelist
])
variable_names_.extend([
'{}_Dike Investment Costs {}'.format(dike, n)
for dike in function.dikelist
])
variable_names__.extend(['RfR Total Costs {}'.format(n)])
variable_names___.extend(
['Expected Evacuation Costs {}'.format(n)])
variable_names____.extend([
'{}_Expected Number of Deaths {}'.format(dike, n)
for dike in function.dikelist
])
dike_model.outcomes = [
ScalarOutcome('Expected Annual Damage',
variable_name=[var for var in variable_names],
function=sum_over,
kind=direction),
ScalarOutcome('Dike Investment Costs',
variable_name=[var for var in variable_names_],
function=sum_over,
kind=direction),
ScalarOutcome('RfR Investment Costs',
variable_name=[var for var in variable_names__],
function=sum_over,
kind=direction),
ScalarOutcome('Evacuation Costs',
variable_name=[var for var in variable_names___],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Number of Deaths',
variable_name=[var for var in variable_names____],
function=sum_over,
kind=direction)
]
# Disaggregate over locations:
elif problem_formulation_id == 3:
outcomes = []
for dike in function.dikelist:
variable_name = []
for e in ['Expected Annual Damage', 'Dike Investment Costs']:
variable_name.extend([
'{}_{} {}'.format(dike, e, n)
for n in function.planning_steps
])
outcomes.append(
ScalarOutcome('{} Total Costs'.format(dike),
variable_name=[var for var in variable_name],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('{}_Expected Number of Deaths'.format(dike),
variable_name=[
'{}_Expected Number of Deaths {}'.format(
dike, n) for n in function.planning_steps
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('RfR Total Costs',
variable_name=[
'RfR Total Costs {}'.format(n)
for n in function.planning_steps
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs',
variable_name=[
'Expected Evacuation Costs {}'.format(n)
for n in function.planning_steps
],
function=sum_over,
kind=direction))
dike_model.outcomes = outcomes
# Disaggregate over time:
elif problem_formulation_id == 4:
outcomes = []
for n in function.planning_steps:
for dike in function.dikelist:
outcomes.append(
ScalarOutcome('Expected Annual Damage {}'.format(n),
variable_name=[
'{}_Expected Annual Damage {}'.format(
dike, n)
for dike in function.dikelist
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('Dike Investment Costs {}'.format(n),
variable_name=[
'{}_Dike Investment Costs {}'.format(
dike, n)
for dike in function.dikelist
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('Expected Number of Deaths {}'.format(n),
variable_name=[
'{}_Expected Number of Deaths {}'.format(
dike, n)
for dike in function.dikelist
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('RfR Total Costs {}'.format(n), kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs {}'.format(n),
kind=direction))
dike_model.outcomes = outcomes
# Fully disaggregated:
elif problem_formulation_id == 5:
outcomes = []
for n in function.planning_steps:
for dike in function.dikelist:
for entry in [
'Expected Annual Damage', 'Dike Investment Costs',
'Expected Number of Deaths'
]:
o = ScalarOutcome('{}_{} {}'.format(dike, entry, n),
kind=direction)
outcomes.append(o)
outcomes.append(
ScalarOutcome('RfR Total Costs {}'.format(n), kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs {}'.format(n),
kind=direction))
dike_model.outcomes = outcomes
# OWN PROBLEM FORMULATION:
elif problem_formulation_id == 6:
outcomes = []
function.gelderland_dikelist = function.dikelist[:
-2] #Cut the dikelist by removing the last two dike rings
function.ring12_dikelist = function.dikelist[:-3]
function.ring3_dikelist = function.dikelist[2:-2]
variable_names_1 = []
variable_names_2 = []
variable_names_3 = []
variable_names_4 = []
variable_names_5 = []
for n in function.planning_steps:
for dike in function.ring12_dikelist:
variable_names_1.extend(
['{}_Expected Annual Damage {}'.format(dike, n)])
variable_names_2.extend(
['{}_Expected Number of Deaths {}'.format(dike, n)])
for dike in function.ring3_dikelist:
variable_names_3.extend(
['{}_Expected Annual Damage {}'.format(dike, n)])
variable_names_4.extend(
['{}_Expected Number of Deaths {}'.format(dike, n)])
for dike in function.gelderland_dikelist:
variable_names_5.extend(
['{}_Dike Investment Costs {}'.format(dike, n)])
variable_names_5.extend(['RfR Total Costs {}'.format(n)])
outcomes.append(
ScalarOutcome(
'A1/2_EAD', #Expected Annual Cost
variable_name=[var for var in variable_names_1],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'A1/2_END', #Expected Number of Deaths
variable_name=[var for var in variable_names_2],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'A3_EAD', #Expected Annual Cost
variable_name=[var for var in variable_names_3],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'A3_END', #Expected Number of Deaths
variable_name=[var for var in variable_names_4],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'G_TIC', #Gelderland Total Investment Cost
variable_name=[var for var in variable_names_5],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'EEC', #Expected Evacuation Cost
variable_name=[
'Expected Evacuation Costs {}'.format(n)
for n in function.planning_steps
],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
dike_model.outcomes = outcomes
elif problem_formulation_id == 7:
outcomes = []
variable_names_1 = []
variable_names_2 = []
variable_names_3 = []
variable_names_4 = []
for n in function.planning_steps:
for dike in function.dikelist:
variable_names_1.extend(
['{}_Expected Annual Damage {}'.format(dike, n)])
variable_names_2.extend(
['{}_Expected Number of Deaths {}'.format(dike, n)])
variable_names_4.extend(
['{}_Dike Investment Costs {}'.format(dike, n)])
# variable_names_3.extend(['Expected Evacuation Costs {}'.format(n)])
variable_names_4.extend(['RfR Total Costs {}'.format(n)])
outcomes.append(
ScalarOutcome(
'EAD', #Expected Annual Cost
variable_name=[var for var in variable_names_1],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'END', #Expected Number of Deaths
variable_name=[var for var in variable_names_2],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'TIC', #Expected Number of Deaths
variable_name=[var for var in variable_names_4],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'EEC', #Expected Evacuation Cost
variable_name=[
'Expected Evacuation Costs {}'.format(n)
for n in function.planning_steps
],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
dike_model.outcomes = outcomes
elif problem_formulation_id == 9:
outcomes = []
variable_names_1 = []
variable_names_2 = []
variable_names_3 = []
variable_names_4 = []
for n in function.planning_steps:
for dike in function.dikelist:
variable_names_1.extend(
['{}_Expected Annual Damage {}'.format(dike, n)])
variable_names_2.extend(
['{}_Expected Number of Deaths {}'.format(dike, n)])
variable_names_4.extend(
['{}_Dike Investment Costs {}'.format(dike, n)])
# variable_names_3.extend(['Expected Evacuation Costs {}'.format(n)])
variable_names_4.extend(['RfR Total Costs {}'.format(n)])
outcomes.append(
ScalarOutcome(
'EAD', #Expected Annual Cost
variable_name=[var for var in variable_names_1],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'END', #Expected Number of Deaths
variable_name=[var for var in variable_names_2],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'TIC', #Expected Number of Deaths
variable_name=[var for var in variable_names_4],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'EEC', #Expected Evacuation Cost
variable_name=[
'Expected Evacuation Costs {}'.format(n)
for n in function.planning_steps
],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
function.gelderland_dikelist = function.dikelist[:
-2] #Cut the dikelist by removing the last two dike rings
function.ring12_dikelist = function.dikelist[:-3]
function.ring3_dikelist = function.dikelist[2:-2]
variable_names_11 = []
variable_names_12 = []
variable_names_13 = []
variable_names_14 = []
variable_names_15 = []
for n in function.planning_steps:
for dike in function.ring12_dikelist:
variable_names_11.extend(
['{}_Expected Annual Damage {}'.format(dike, n)])
variable_names_12.extend(
['{}_Expected Number of Deaths {}'.format(dike, n)])
for dike in function.ring3_dikelist:
variable_names_13.extend(
['{}_Expected Annual Damage {}'.format(dike, n)])
variable_names_14.extend(
['{}_Expected Number of Deaths {}'.format(dike, n)])
for dike in function.gelderland_dikelist:
variable_names_15.extend(
['{}_Dike Investment Costs {}'.format(dike, n)])
variable_names_15.extend(['RfR Total Costs {}'.format(n)])
outcomes.append(
ScalarOutcome(
'A1/2_EAD', #Expected Annual Cost
variable_name=[var for var in variable_names_11],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'A1/2_END', #Expected Number of Deaths
variable_name=[var for var in variable_names_12],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'A3_EAD', #Expected Annual Cost
variable_name=[var for var in variable_names_13],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'A3_END', #Expected Number of Deaths
variable_name=[var for var in variable_names_14],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
outcomes.append(
ScalarOutcome(
'G_TIC', #Gelderland Total Investment Cost
variable_name=[var for var in variable_names_15],
function=sum_over,
kind=ScalarOutcome.MINIMIZE))
for dike in function.dikelist:
variable_name = []
for e in ['Expected Annual Damage', 'Dike Investment Costs']:
variable_name.extend([
'{}_{} {}'.format(dike, e, n)
for n in function.planning_steps
])
outcomes.append(
ScalarOutcome('{} Total Costs'.format(dike),
variable_name=[var for var in variable_name],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('{}_Expected Number of Deaths'.format(dike),
variable_name=[
'{}_Expected Number of Deaths {}'.format(
dike, n) for n in function.planning_steps
],
function=sum_over,
kind=direction))
dike_model.outcomes = outcomes
else:
raise TypeError('unknownx identifier')
return dike_model, function.planning_steps
'name': 'no policy'
}, {
'params': {
'AlarmEdu': 1
},
'name': 'Alarm Education'
}]
if __name__ == '__main__':
ema_logging.log_to_stderr(ema_logging.INFO)
waas_model = WaasModel("waasmodel", wd='./model')
waas_model.uncertainties = [
IntegerParameter("climate scenarios",
1,
30,
pff=True,
resolution=[x for x in range(1, 31)]),
RealParameter("fragility dikes", -0.1, 0.1),
RealParameter("DamFunctTbl", -0.1, 0.1),
RealParameter("ShipTbl1", -0.1, 0.1),
RealParameter("ShipTbl2", -0.1, 0.1),
RealParameter("ShipTbl3", -0.1, 0.1),
RealParameter("collaboration", 1, 1.6),
CategoricalParameter("land use scenarios", [
"NoChange", "moreNature", "Deurbanization", "sustainableGrowth",
"urbanizationDeurbanization", "urbanizationLargeAndFast",
"urbanizationLargeSteady"
],
pff=True)
]
indices.plot.bar(yerr=err.values.T, ax=ax)
fig.set_size_inches(8, 6)
fig.subplots_adjust(bottom=0.3)
plt.ylim([0, 1])
plt.grid()
plt.show()
#%%
# Generate random dike heightening policy with early warning system and RfR set to 0
# First comment out line 56-65 in problem_formulation file
my_lever = [
IntegerParameter('A.1_DikeIncrease 0', 0, 10),
IntegerParameter('A.1_DikeIncrease 1', 0, 10),
IntegerParameter('A.1_DikeIncrease 2', 0, 10),
IntegerParameter('A.2_DikeIncrease 0', 0, 10),
IntegerParameter('A.2_DikeIncrease 2', 0, 10),
IntegerParameter('A.3_DikeIncrease 0', 0, 10),
IntegerParameter('A.3_DikeIncrease 1', 0, 10),
IntegerParameter('A.3_DikeIncrease 2', 0, 10),
IntegerParameter('A.4_DikeIncrease 0', 0, 10),
IntegerParameter('A.4_DikeIncrease 1', 0, 10),
IntegerParameter('A.4_DikeIncrease 2', 0, 10),
IntegerParameter('A.5_DikeIncrease 0', 0, 10),
IntegerParameter('A.5_DikeIncrease 1', 0, 10),
IntegerParameter('A.5_DikeIncrease 2', 0, 10)
]
edge_dict = {}
for key, val in d.iteritems():
keyn = str(key[0]) + str(key[1])
edge_dict.update({keyn: val})
return edge_dict
from ema_workbench import (Model, RealParameter, ScalarOutcome, Constant,
IntegerParameter)
#instantiate the model
criticality_model = Model('criticality', function=ema_criticality)
#specify uncertainties
criticality_model.uncertainties = [
IntegerParameter('det_idx', 1, 3),
RealParameter('od_exp', 0.75, 1.5),
RealParameter('od_loc1', 0.75, 1.5),
RealParameter('od_loc2', 0.75, 1.5),
RealParameter('od_loc3', 0.75, 1.5),
RealParameter('od_loc4', 0.75, 1.5),
RealParameter('theta', 30, 70),
RealParameter('beta', 0.25, 0.75),
RealParameter('cutoff', 0.025, 0.075),
RealParameter('m10_buffer', 0.0025, 0.0075),
RealParameter('penalty', 1, 1.5)
]
#specify outcomes
criticality_model.outcomes = [
ScalarOutcome(key) for key, val in edge_dict.iteritems()
def get_model_for_problem_formulation(problem_formulation_id):
''' Prepare DikeNetwork in a way it can be input in the EMA-workbench.
Specify uncertainties, levers and problem formulation.
'''
# Load the model:
function = DikeNetwork()
# workbench model:
dike_model = Model('dikesnet', function=function)
# Uncertainties and Levers:
# Specify uncertainties range:
Real_uncert = {'Bmax': [30, 350], 'pfail': [0, 1]} # m and [.]
# breach growth rate [m/day]
cat_uncert_loc = {'Brate': (0.9, 1.5, 1000)}
cat_uncert = {'discount rate': (1.5, 2.5, 3.5, 4.5)}
Int_uncert = {'A.0_ID flood wave shape': [0, 132]}
# Range of dike heightening:
dike_lev = {'DikeIncrease': [0, 10]} # dm
# Series of five Room for the River projects:
rfr_lev = ['{}_RfR'.format(project_id) for project_id in range(0, 5)]
# Time of warning: 0, 1, 2, 3, 4 days ahead from the flood
EWS_lev = {'EWS_DaysToThreat': [0, 4]} # days
uncertainties = []
levers = []
for dike in function.dikelist:
# uncertainties in the form: locationName_uncertaintyName
for uncert_name in Real_uncert.keys():
name = "{}_{}".format(dike, uncert_name)
lower, upper = Real_uncert[uncert_name]
uncertainties.append(RealParameter(name, lower, upper))
for uncert_name in cat_uncert_loc.keys():
name = "{}_{}".format(dike, uncert_name)
categories = cat_uncert_loc[uncert_name]
uncertainties.append(CategoricalParameter(name, categories))
# location-related levers in the form: locationName_leversName
for lev_name in dike_lev.keys():
name = "{}_{}".format(dike, lev_name)
levers.append(
IntegerParameter(name, dike_lev[lev_name][0],
dike_lev[lev_name][1]))
for uncert_name in cat_uncert.keys():
categories = cat_uncert[uncert_name]
uncertainties.append(CategoricalParameter(uncert_name, categories))
# project-related levers can be either 0 (not implemented) or 1
# (implemented)
for uncert_name in Int_uncert.keys():
uncertainties.append(
IntegerParameter(uncert_name, Int_uncert[uncert_name][0],
Int_uncert[uncert_name][1]))
# RfR levers can be either 0 (not implemented) or 1 (implemented)
for lev_name in rfr_lev:
levers.append(IntegerParameter(lev_name, 0, 1))
# Early Warning System lever
for lev_name in EWS_lev.keys():
levers.append(
IntegerParameter(lev_name, EWS_lev[lev_name][0],
EWS_lev[lev_name][1]))
# load uncertainties and levers in dike_model:
dike_model.uncertainties = uncertainties
dike_model.levers = levers
# Problem formulations:
# Outcomes are all costs, thus they have to minimized:
direction = ScalarOutcome.MINIMIZE
# 2-objective PF:
if problem_formulation_id == 0:
dikes_variable_names = []
for dike in function.dikelist:
dikes_variable_names.extend([
'{}_{}'.format(dike, e)
for e in ['Expected Annual Damage', 'Dike Investment Costs']
])
dikes_variable_names.extend(['RfR Total Costs'])
dikes_variable_names.extend(['Expected Evacuation Costs'])
dike_model.outcomes = [
ScalarOutcome('All Costs',
variable_name=[var for var in dikes_variable_names],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Number of Deaths',
variable_name=[
'{}_Expected Number of Deaths'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction)
]
# 3-objectives PF:
elif problem_formulation_id == 1:
dike_model.outcomes = [
ScalarOutcome('Expected Annual Damage',
variable_name=[
'{}_Expected Annual Damage'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction),
ScalarOutcome('Total Investment Costs',
variable_name=[
'{}_Dike Investment Costs'.format(dike)
for dike in function.dikelist
] + ['RfR Total Costs'] +
['Expected Evacuation Costs'],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Number of Deaths',
variable_name=[
'{}_Expected Number of Deaths'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction)
]
# 12-objectives PF:
elif problem_formulation_id == 2:
outcomes = []
for dike in function.dikelist:
outcomes.append(
ScalarOutcome(
'{} Total Costs'.format(dike),
variable_name=[
'{}_{}'.format(dike, e) for e in
['Expected Annual Damage', 'Dike Investment Costs']
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('{}_Expected Number of Deaths'.format(dike),
kind=direction))
outcomes.append(ScalarOutcome('RfR Total Costs', kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs', kind=direction))
dike_model.outcomes = outcomes
# 17-objectives PF:
elif problem_formulation_id == 3:
outcomes = []
for dike in function.dikelist:
for entry in [
'Expected Annual Damage', 'Dike Investment Costs',
'Expected Number of Deaths'
]:
o = ScalarOutcome('{}_{}'.format(dike, entry), kind=direction)
outcomes.append(o)
outcomes.append(ScalarOutcome('RfR Total Costs', kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs', kind=direction))
dike_model.outcomes = outcomes
# 8-objectives PF:
elif problem_formulation_id == 4:
outcomes = []
dikeDeventer = function.dikelist[len(function.dikelist) - 1]
outcomes.append(
ScalarOutcome('Expected Number of Deaths',
variable_name=[
'{}_Expected Number of Deaths'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction))
outcomes.append(ScalarOutcome('RfR Total Costs', kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs', kind=direction))
outcomes.append(
ScalarOutcome(
'Gelderland Dike Investment Costs',
variable_name=[
'{}_Dike Investment Costs'.format(dike)
for dike in function.dikelist[0:len(function.dikelist) - 1]
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('OverIjsel Dike Investment Costs',
variable_name=[
'{}_Dike Investment Costs'.format(dikeDeventer)
],
kind=direction))
outcomes.append(
ScalarOutcome(
'GelderlandUpstream Expected Annual Damage',
variable_name=[
'{}_Expected Annual Damage'.format(dike)
for dike in function.dikelist[0:len(function.dikelist) - 3]
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome(
'GelderlandDownstream Expected Annual Damage',
variable_name=[
'{}_Expected Annual Damage'.format(dike)
for dike in function.dikelist[2:len(function.dikelist) - 1]
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('OverIjsel Expected Annual Damage',
variable_name=[
'{}_Expected Annual Damage'.format(dikeDeventer)
],
kind=direction))
dike_model.outcomes = outcomes
else:
raise TypeError('unknonw identifier')
return dike_model
from ema_workbench.em_framework.evaluators import BaseEvaluator
from ema_workbench.em_framework.optimization import (EpsilonProgress,
HyperVolume)
ema_logging.log_to_stderr(ema_logging.INFO)
BaseEvaluator.reporting_frequency = 0.1
# ema_logging.log_to_stderr(ema_logging.DEBUG)
from PyRICE_V8 import PyRICE
model = PyRICE(model_specification="EMA", welfare_function="utilitarian")
RICE = Model('RICE', function=model)
RICE.uncertainties = [
IntegerParameter('fdamage', 0, 1),
IntegerParameter('scenario_pop_tfp', 0, 5),
IntegerParameter('scenario_sigma', 0, 5),
IntegerParameter('scenario_cback', 0, 2),
IntegerParameter('cback_to_zero', 0, 1),
RealParameter('fosslim', 4000.0, 13649),
RealParameter('limmiu', 0.8, 1.2)
]
RICE.levers = [
RealParameter('sr', 0.1, 0.5),
IntegerParameter('miu_period', 5, 30)
]
RICE.outcomes = [
ScalarOutcome('Utility 2055', ScalarOutcome.MAXIMIZE),
def main():
hybridmodel = Model('hybridmodel', function=hybridloop)
hybridmodel.uncertainties = [
IntegerParameter("inputpowerfactor", 15, 25), #7 13
IntegerParameter("inputLNGprice", 200, 1000),
IntegerParameter("inputtransferprice", 50, 300),
IntegerParameter("inputCapincrease", 1000, 3000),
IntegerParameter("inputCapincreasetime", 1, 2),
IntegerParameter("inputLNGCapincrease", 1000, 3000),
IntegerParameter("inputLNGCapincreasetime", 1, 2),
RealParameter("DemandBalanceSupplyEnergyPrice", 0.4, 0.7),
RealParameter("SupplyElasticityGas", 0.06, 0.07),
RealParameter("SupplyElasticityOil", 0.1, 0.2),
RealParameter("SupplyElasticityCoal", 0.1, 0.2),
RealParameter("SupplyElasticityNuclear", 0.007, 0.017),
RealParameter("SupplyElasticityBiofuel", 0.1, 0.2),
RealParameter("SupplyElasticityOR", 0.15, 0.3),
IntegerParameter("EconomicGrowthScenario", 1, 3),
IntegerParameter("EnergyIntensityScenario", 1, 3),
RealParameter("CO2coal", 95, 105),
RealParameter("CO2oil", 65, 95),
RealParameter("Variancepower", -5.0, -0.1),
RealParameter("AutonomousEnergyIntensityDecrease", 0, 0.02)
]
# IntegerParameter("POil", 8900, 9100),
# IntegerParameter("PCoal", 2800, 3100),
# IntegerParameter("PBio", 29000, 32000),
# IntegerParameter("PNuc", 16000, 17000),
# IntegerParameter("POR", 19000, 22000),
# IntegerParameter("PGasE", 6500, 7000),
# IntegerParameter("PGasNA", 2500, 2700),
# IntegerParameter("PGasSCA", 2500, 2700),
# IntegerParameter("PGasCIS", 6500, 7000),
# IntegerParameter("PGasME", 7000, 8000),
# IntegerParameter("PGasAF", 7000, 8000),
# IntegerParameter("PGasAP", 7000, 8000)]
hybridmodel.outcomes = [
TimeSeriesOutcome("EU_GasSup"),
# TimeSeriesOutcome("EU_GasDem"),
# TimeSeriesOutcome("EU_GasCon"),
TimeSeriesOutcome("EU_OilSup"),
# TimeSeriesOutcome("EU_OilDem"),
# TimeSeriesOutcome("EU_OilCon"),
TimeSeriesOutcome("EU_CoalSup"),
# TimeSeriesOutcome("EU_CoalDem"),
# TimeSeriesOutcome("EU_CoalCon"),
TimeSeriesOutcome("EU_NucSup"),
# TimeSeriesOutcome("EU_NucDem"),
# TimeSeriesOutcome("EU_NucCon"),
TimeSeriesOutcome("EU_BioSup"),
# TimeSeriesOutcome("EU_BioDem"),
# TimeSeriesOutcome("EU_BioCon"),
TimeSeriesOutcome("EU_ORSup"),
# TimeSeriesOutcome("EU_ORDem"),
# TimeSeriesOutcome("EU_ORCon"),
TimeSeriesOutcome("EU_EDem"),
TimeSeriesOutcome("EU_ESup"),
TimeSeriesOutcome("EU_GDP"),
TimeSeriesOutcome("EU_CO2"),
TimeSeriesOutcome("EU_RusGas"),
TimeSeriesOutcome("EU_EUGI"),
TimeSeriesOutcome("EU_GIC"),
# TimeSeriesOutcome("EU_RGperAG"),
# TimeSeriesOutcome("EU_RGperTES"),
# TimeSeriesOutcome("EU_RGperGC"),
# TimeSeriesOutcome("EU_GICperBBTU"),
TimeSeriesOutcome("Oil_Price"),
TimeSeriesOutcome("Coal_Price"),
TimeSeriesOutcome("Bio_Price"),
TimeSeriesOutcome("Gas_PriceE"),
TimeSeriesOutcome("Nuc_PriceE"),
TimeSeriesOutcome("OR_PriceE"),
# TimeSeriesOutcome("FuncpriceGas"),
# TimeSeriesOutcome("FuncpriceOil"),
# TimeSeriesOutcome("FuncpriceCoal"),
TimeSeriesOutcome("Gas_PriceCIS")
]
hybridmodel.levers = [
IntegerParameter("EnergyUnion", 0, 1),
IntegerParameter("CO2Cost", 0, 2)
]
ema_logging.log_to_stderr(ema_logging.INFO)
with MultiprocessingEvaluator(hybridmodel, n_processes=24) as evaluator:
results = evaluator.perform_experiments(scenarios=200,
policies=6,
levers_sampling='ff')
save_results(results, './results/1200 runs V40.tar.gz')
for i in range(0,len(policies)):
policy_dict = policies.iloc[i].to_dict()
policy_list_principle.append(Policy(policies.index[i], **policy_dict))
total_policy_list.append(policy_list_principle)
nfe = 25000
principle_index =0
if __name__ == "__main__":
for principle in principles_list:
print("uncertainty analysis started for: " + principles_list[principle_index] + " case for " + str(nfe) + " scenario's")
model = PyRICE(model_specification="EMA", welfare_function = principle)
RICE = Model('RICE', function = model)
RICE.uncertainties =[IntegerParameter('fdamage',0,2),
IntegerParameter('t2xco2_index',0,999),
IntegerParameter('t2xco2_dist',0,2),
RealParameter('fosslim', 4000, 13649),
RealParameter('long_run_nordhaus_tfp_gr', 0.85, 1.15),
RealParameter('long_run_nordhaus_sigma', 0.75, 1.25),
RealParameter('long_run_nordhaus_pop_gr', 0.75, 1.25),
IntegerParameter('scenario_cback',0,1),
IntegerParameter('scenario_elasticity_of_damages',0,2),
IntegerParameter('scenario_limmiu',0,1)]
#same for all formulations
RICE.outcomes = get_all_model_outcomes_uncertainty_search(optimization_formulation = "utilitarian",horizon=2305,precision = 20)
def get_model_for_problem_formulation(problem_formulation_id=2,
Bmax_low=30,
Bmax_high=350,
pfail_low=0,
pfail_high=1,
Brate=(0.9, 1.5, 1000),
disc=(1.5, 2.5, 3.5, 4.5),
wave_shape_low=0,
wave_shape_high=132,
dike_low=0,
dike_high=10,
EWS_low=0,
EWS_high=4):
''' Prepare DikeNetwork in a way it can be input in the EMA-workbench.
Specify uncertainties, levers and problem formulation.
'''
# Load the model:
function = DikeNetwork()
# workbench model:
dike_model = Model('dikesnet', function=function)
# Uncertainties and Levers:
# Specify uncertainties range:
#Real_uncert = {'Bmax': [30, 350], 'pfail': [0, 1]} # m and [.]
Real_uncert_changed = {
'Bmax': [Bmax_low, Bmax_high],
'pfail': [pfail_low, pfail_high]
} # m and [.]
# breach growth rate [m/day]
#cat_uncert_loc = {'Brate': (0.9, 1.5, 1000)}
cat_uncert_loc_changed = {'Brate': Brate}
#cat_uncert = {'discount rate': (1.5, 2.5, 3.5, 4.5)}
cat_uncert_changed = {'discount rate': disc}
#Int_uncert = {'A.0_ID flood wave shape': [0, 132]}
Int_uncert_changed = {
'A.0_ID flood wave shape': [wave_shape_low, wave_shape_high]
}
# Range of dike heightening:
#dike_lev = {'DikeIncrease': [0, 10]} # dm
dike_lev_changed = {'DikeIncrease': [dike_low, dike_high]} # dm
# Series of five Room for the River projects:
rfr_lev = ['{}_RfR'.format(project_id) for project_id in range(0, 5)]
# Time of warning: 0, 1, 2, 3, 4 days ahead from the flood
#EWS_lev = {'EWS_DaysToThreat': [0, 4]} # days
EWS_lev_changed = {'EWS_DaysToThreat': [EWS_low, EWS_high]} # days
uncertainties = []
levers = []
for dike in function.dikelist:
# uncertainties in the form: locationName_uncertaintyName
for uncert_name in Real_uncert_changed.keys():
name = "{}_{}".format(dike, uncert_name)
lower, upper = Real_uncert_changed[uncert_name]
uncertainties.append(RealParameter(name, lower, upper))
for uncert_name in cat_uncert_loc_changed.keys():
name = "{}_{}".format(dike, uncert_name)
categories = cat_uncert_loc_changed[uncert_name]
uncertainties.append(CategoricalParameter(name, categories))
for lev_name in dike_lev_changed.keys():
name = "{}_{}".format(dike, lev_name)
levers.append(
IntegerParameter(name, dike_lev_changed[lev_name][0],
dike_lev_changed[lev_name][1]))
# (can be changed)
for uncert_name in cat_uncert_changed.keys():
categories = cat_uncert_changed[uncert_name]
uncertainties.append(CategoricalParameter(uncert_name, categories))
# (can be changed)
for uncert_name in Int_uncert_changed.keys():
uncertainties.append(
IntegerParameter(uncert_name, Int_uncert_changed[uncert_name][0],
Int_uncert_changed[uncert_name][1]))
# project-related levers can be either 0 (not implemented) or 1
# (implemented)
#(can be changed)
# Early Warning System lever
for lev_name in EWS_lev_changed.keys():
levers.append(
IntegerParameter(lev_name, EWS_lev_changed[lev_name][0],
EWS_lev_changed[lev_name][1]))
# RfR levers can be either 0 (not implemented) or 1 (implemented)
for lev_name in rfr_lev:
levers.append(IntegerParameter(lev_name, 0, 1))
# # RfR levers Off
# constants = []
# for lev_name in rfr_lev:
# constants.append(Constant(lev_name, 0))
# load uncertainties and levers in dike_model:
dike_model.uncertainties = uncertainties
dike_model.levers = levers
# dike_model.constants = constants
# Problem formulations:
# Outcomes are all costs, thus they have to minimized:
direction = ScalarOutcome.MINIMIZE
# 2-objective PF:
if problem_formulation_id == 0:
dikes_variable_names = []
for dike in function.dikelist:
dikes_variable_names.extend([
'{}_{}'.format(dike, e)
for e in ['Expected Annual Damage', 'Dike Investment Costs']
])
dikes_variable_names.extend(['RfR Total Costs'])
dikes_variable_names.extend(['Expected Evacuation Costs'])
dike_model.outcomes = [
ScalarOutcome('All Costs',
variable_name=[var for var in dikes_variable_names],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Number of Deaths',
variable_name=[
'{}_Expected Number of Deaths'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction)
]
# 4-objectives PF:
elif problem_formulation_id == 1:
dikes_variable_names = []
for dike in function.dikelist:
dikes_variable_names.extend([
'{}_{}'.format(dike, e)
for e in ['Expected Annual Damage', 'Dike Investment Costs']
])
dikes_variable_names.extend(['RfR Total Costs'])
dikes_variable_names.extend(['Expected Evacuation Costs'])
dike_model.outcomes = [
ScalarOutcome('Expected Annual Damage',
variable_name=[
'{}_Expected Annual Damage'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction),
ScalarOutcome('Total Investment Costs',
variable_name=[
'{}_Dike Investment Costs'.format(dike)
for dike in function.dikelist
] + ['RfR Total Costs'] +
['Expected Evacuation Costs'],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Number of Deaths',
variable_name=[
'{}_Expected Number of Deaths'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction),
ScalarOutcome('All Costs',
variable_name=[var for var in dikes_variable_names],
function=sum_over,
kind=direction)
]
# 4-objectives PF:
elif problem_formulation_id == 2:
dikes_variable_names = []
for dike in function.dikelist:
dikes_variable_names.extend([
'{}_{}'.format(dike, e)
for e in ['Expected Annual Damage', 'Dike Investment Costs']
])
dikes_variable_names.extend(['RfR Total Costs'])
dikes_variable_names.extend(['Expected Evacuation Costs'])
dike_model.outcomes = [
ScalarOutcome('Expected Number of Deaths',
variable_name=[
'{}_Expected Number of Deaths'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction),
ScalarOutcome('Expected Evacuation Costs', kind=direction),
ScalarOutcome('Expected Annual Damage',
variable_name=[
'{}_Expected Annual Damage'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction),
ScalarOutcome('Total Construction Costs',
variable_name=[
'{}_Dike Investment Costs'.format(dike)
for dike in function.dikelist
] + ['RfR Total Costs'],
function=sum_over,
kind=direction)
]
# 12-objectives PF:
elif problem_formulation_id == 3:
outcomes = []
for dike in function.dikelist:
outcomes.append(
ScalarOutcome(
'{} Total Costs'.format(dike),
variable_name=[
'{}_{}'.format(dike, e) for e in
['Expected Annual Damage', 'Dike Investment Costs']
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('{}_Expected Number of Deaths'.format(dike),
kind=direction))
outcomes.append(ScalarOutcome('RfR Total Costs', kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs', kind=direction))
dike_model.outcomes = outcomes
# 17-objectives PF:
elif problem_formulation_id == 4:
outcomes = []
for dike in function.dikelist:
for entry in [
'Expected Annual Damage', 'Dike Investment Costs',
'Expected Number of Deaths'
]:
o = ScalarOutcome('{}_{}'.format(dike, entry), kind=direction)
outcomes.append(o)
outcomes.append(ScalarOutcome('RfR Total Costs', kind=direction))
outcomes.append(
ScalarOutcome('Expected Evacuation Costs', kind=direction))
dike_model.outcomes = outcomes
elif problem_formulation_id == 5:
# All possible Objectives
dikes_variable_names = []
outcomes = []
for dike in function.dikelist:
dikes_variable_names.extend([
'{}_{}'.format(dike, e)
for e in ['Expected Annual Damage', 'Dike Investment Costs']
])
dikes_variable_names.extend(['RfR Total Costs'])
dikes_variable_names.extend(['Expected Evacuation Costs'])
outcomes.append(
ScalarOutcome(
'{} Total Costs'.format(dike),
variable_name=[
'{}_{}'.format(dike, e) for e in
['Expected Annual Damage', 'Dike Investment Costs']
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome('{}_Expected Number of Deaths'.format(dike),
kind=direction))
# outcomes.append(ScalarOutcome('Expected Annual Damage',
# variable_name=['{}_Expected Annual Damage'.format(dike)
# for dike in function.dikelist],
# function=sum_over, kind=direction))
outcomes.append(
ScalarOutcome('Expected Investment Costs',
variable_name=[
'{}_Dike Investment Costs'.format(dike)
for dike in function.dikelist
] + ['RfR Total Costs'] +
['Expected Evacuation Costs'],
function=sum_over,
kind=direction))
# outcomes.append(ScalarOutcome('RfR Total Costs', kind=direction))
# outcomes.append(ScalarOutcome('Expected Evacuation Costs', kind=direction))
outcomes.append(
ScalarOutcome('Expected Number of Deaths',
variable_name=[
'{}_Expected Number of Deaths'.format(dike)
for dike in function.dikelist
],
function=sum_over,
kind=direction))
outcomes.append(
ScalarOutcome(
'Total Costs',
variable_name=[var for var in dikes_variable_names],
function=sum_over,
kind=direction))
dike_model.outcomes = outcomes
else:
raise TypeError('unknonw identifier')
return dike_model