def set_model(func=recycle_model):
experiment_model = EMA_Model('plastic', function=func)
uncertainties = [
RealParameter('target_mean', 0.05, 0.20),
RealParameter('amb_mean', 0.1, 0.5),
RealParameter('percep_range', 0.1, 0.5),
RealParameter('know_range', 0.1, 0.5),
RealParameter('technology', 0.1, 0.5),
RealParameter('tech_std', 0.05, 0.20),
IntegerParameter('cap_mean', 400, 800),
IntegerParameter('cap_std', 100, 400),
]
levers = [
RealParameter("campaign_bud_prop", 0.05, 0.5),
RealParameter("final_target", 0.1, 0.4)
]
outcomes = [
ScalarOutcome('target_met_frac', ),
ScalarOutcome('no_budget_frac', ),
ScalarOutcome('avg_fine_period'),
ScalarOutcome('fine_per_house'),
ScalarOutcome('time_conv'),
ScalarOutcome('profit_std'),
]
experiment_model.uncertainties = uncertainties
experiment_model.levers = levers
experiment_model.outcomes = outcomes
return experiment_model
def get_lake_model():
"""Returns a fully formulated model of the lake problem."""
# instantiate the model
lake_model = Model('lakeproblem', function=lake_problem)
lake_model.time_horizon = 100
# specify uncertainties
lake_model.uncertainties = [
RealParameter('b', 0.1, 0.45),
RealParameter('q', 2.0, 4.5),
RealParameter('mean', 0.01, 0.05),
RealParameter('stdev', 0.001, 0.005),
RealParameter('delta', 0.93, 0.99)
]
# set levers, one for each time step
lake_model.levers = [
RealParameter(str(i), 0, 0.1) for i in range(lake_model.time_horizon)
]
# specify outcomes
lake_model.outcomes = [
ScalarOutcome('max_P', ),
ScalarOutcome('utility'),
ScalarOutcome('inertia'),
ScalarOutcome('reliability')
]
# override some of the defaults of the model
lake_model.constants = [Constant('alpha', 0.41), Constant('nsamples', 150)]
return lake_model
def performExperiments():
ema_logging.LOG_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s'
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model('SimulateER', function=simulate_ER) # instantiate the model
# specify uncertainties
model.uncertainties = [RealParameter("p", 0.1, 1.0)]
model.uncertainties = [RealParameter("f", 0.1, 0.9)]
model.levers = [IntegerParameter("n", 10, 100)]
# specify outcomes
model.outcomes = [ScalarOutcome('cc')]
model.constants = [Constant('replications', 10)]
n_scenarios = 10
n_policies = 10
res = perform_experiments(model, n_scenarios, n_policies)
experiments, outcomes = res
data = experiments[['n', 'p', 'f']]
data.to_csv('out.csv', index=False)
return data
def intertemporal_model(params):
intertemporal = Model('intertemporal',
function=modelData.intertemporal.lake_model)
intertemporal.timeHorizon = params.timeHorizon
intertemporal.uncertainties = params.uncertainties
intertemporal.levers = [
RealParameter('l{}'.format(i), 0, 0.1) for i in range(100)
]
intertemporal.outcomes = params.outcomes
intertemporal.constants = params.constants
intertemporal.constraints = params.constraints
return intertemporal
def dps_model(params):
dps = Model('dps', function=modelData.dps.lake_model)
dps.timeHorizon = params.timeHorizon
dps.uncertainties = params.uncertainties
dps.levers = [RealParameter("c1", -2, 2),
RealParameter("c2", -2, 2),
RealParameter("r1", 0, 2),
RealParameter("r2", 0, 2),
RealParameter("w1", 0, 1)]
dps.outcomes = params.outcomes
dps.constants = params.constants
dps.constraints = params.constraints
return dps
def planned_adaptive_model(params):
adaptive = Model('plannedadaptive',
function=modelData.planned_adaptive.lake_model)
adaptive.timeHorizon = params.timeHorizon
adaptive.uncertainties = params.uncertainties
adaptive.levers = [RealParameter("c1", -2, 2),
RealParameter("c2", -2, 2),
RealParameter("r1", 0, 2),
RealParameter("r2", 0, 2),
RealParameter("w1", 0, 1)]
adaptive.outcomes = params.outcomes
adaptive.constants = params.constants
adaptive.constraints = params.constraints
return adaptive
ema_logging.log_to_stderr(ema_logging.INFO)
# instantiate the model
lake_model = Model('lakeproblem', function=lake_problem)
# specify uncertainties
lake_model.uncertainties = [RealParameter('b', 0.1, 0.45),
RealParameter('q', 2.0, 4.5),
RealParameter('mean', 0.01, 0.05),
RealParameter('stdev', 0.001, 0.005),
RealParameter('delta', 0.93, 0.99)]
# set levers
lake_model.levers = [RealParameter("c1", -2, 2),
RealParameter("c2", -2, 2),
RealParameter("r1", 0, 2),
RealParameter("r2", 0, 2),
CategoricalParameter("w1", np.linspace(0, 1, 10))
]
# specify outcomes
lake_model.outcomes = [ScalarOutcome('max_P',
kind=ScalarOutcome.MINIMIZE), # @UndefinedVariable
ScalarOutcome('utility',
kind=ScalarOutcome.MAXIMIZE), # @UndefinedVariable
ScalarOutcome('inertia',
kind=ScalarOutcome.MAXIMIZE), # @UndefinedVariable
ScalarOutcome('reliability',
kind=ScalarOutcome.MAXIMIZE)] # @UndefinedVariable
# override some of the defaults of the model
lake_model.constants = [Constant('alpha', 0.41),
Constant('nsamples', 100),
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("MaximumChangeinDemand", 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", 93.46, 113.67),
RealParameter("CO2oil", 59.58, 102.12),
RealParameter("Variancepower", -5.0, -0.1),
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")
]
hybridmodel.levers = [
IntegerParameter("EnergyUnion", 0, 1),
IntegerParameter("CO2Cost", 0, 1)
]
# In[ ]:
ema_logging.log_to_stderr(ema_logging.INFO)
with MultiprocessingEvaluator(hybridmodel) as evaluator:
results = evaluator.perform_experiments(scenarios=1,
policies=4,
levers_sampling='ff')
# In[1]:
save_results(results, r'./1000 runs V30.tar.gz')
"capacity_of_energy_power_solar_pv_solar_radiation": capacity_of_energy_power_solar_pv_solar_radiation,
}
ETMi.user_values.update(constants)
ETMi.update_inputs()
ETMi._update_metrics(output_format="dict")
getter = lambda m: ETMi.metrics.get(m, 0)["future"]
return {metric: getter(metric) for metric in metrics}
model = Model("ETMwrapper", function=ETMwrapper)
# set levers
model.levers = [RealParameter("solarVSwind", 0, 1)]
# specify outcomes
model.outcomes = [ScalarOutcome(metric) for metric in metrics]
# model.outcomes = [ScalarOutcome("hv_net_capacity_delta_present_future")]
# initiate ETM connection
ref_scenario = 769771
ETM = init_ETM(ref_scenario, metrics)
# override some of the defaults of the model
model.constants = [
# standard = 1920 hours / year
Constant("ETM_instance", ETM),
Constant("flh_of_energy_power_wind_turbine_inland", 3000),
Constant("flh_of_solar_pv_solar_radiation", 1000), # standard = 867 / year
model = Model('lakeproblem', function=lake_problem)
#specify uncertainties
model.uncertainties = [
RealParameter('b', 0.1, 0.45),
RealParameter('q', 2.0, 4.5),
RealParameter('mean', 0.01, 0.05),
RealParameter('stdev', 0.001, 0.005),
RealParameter('delta', 0.93, 0.99)
]
# set levers
model.levers = [
RealParameter("c1", -2, 2),
RealParameter("c2", -2, 2),
RealParameter("r1", 0, 2),
RealParameter("r2", 0, 2),
RealParameter("w1", 0, 1)
]
#specify outcomes
model.outcomes = [
ScalarOutcome('max_P'),
ScalarOutcome('utility'),
ScalarOutcome('inertia'),
ScalarOutcome('reliability')
]
# override some of the defaults of the model
model.constants = [
Constant('alpha', 0.41),
if __name__ == '__main__':
ema_logging.LOG_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s'
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model('omegaDriver', function=omegaDriver) # instantiate the model
# specify uncertainties
model.uncertainties = [
RealParameter("SCUDB.targetRange", 100000.0, 200000.0),
RealParameter("SCUDB.targetAltitude", 15000.0, 20000.0)
]
model.levers = [
RealParameter("SCUDB.MassProperties.initialMass", 5000.0, 6000.0)
]
model.outcomes = [
ScalarOutcome('burnout'),
ScalarOutcome('impact'),
ScalarOutcome('apogeeAlt'),
ScalarOutcome('apogeeTime')
]
#model.constants = [Constant('replications', 10)]
n_contextScenarios = 10
n_designPolicies = 10
res = perform_experiments(model,
def definemodel(modelname, modelfunction):
model = Model(modelname, function=modelfunction)
model.uncertainties = [
RealParameter('b', 0.1, 0.45),
RealParameter('mean', 0.01, 0.05),
RealParameter('stdev', 0.001, 0.005),
RealParameter('delta', 0.93, 0.99),
RealParameter('q', 2, 4.5)
]
model.levers = [
RealParameter('l0', 0.0, 0.1),
RealParameter('l36', 0.0, 0.1),
RealParameter('l72', 0.0, 0.1),
RealParameter('l1', 0.0, 0.1),
RealParameter('l37', 0.0, 0.1),
RealParameter('l73', 0.0, 0.1),
RealParameter('l2', 0.0, 0.1),
RealParameter('l38', 0.0, 0.1),
RealParameter('l74', 0.0, 0.1),
RealParameter('l3', 0.0, 0.1),
RealParameter('l39', 0.0, 0.1),
RealParameter('l75', 0.0, 0.1),
RealParameter('l4', 0.0, 0.1),
RealParameter('l40', 0.0, 0.1),
RealParameter('l76', 0.0, 0.1),
RealParameter('l5', 0.0, 0.1),
RealParameter('l41', 0.0, 0.1),
RealParameter('l77', 0.0, 0.1),
RealParameter('l6', 0.0, 0.1),
RealParameter('l42', 0.0, 0.1),
RealParameter('l78', 0.0, 0.1),
RealParameter('l7', 0.0, 0.1),
RealParameter('l43', 0.0, 0.1),
RealParameter('l79', 0.0, 0.1),
RealParameter('l8', 0.0, 0.1),
RealParameter('l44', 0.0, 0.1),
RealParameter('l80', 0.0, 0.1),
RealParameter('l9', 0.0, 0.1),
RealParameter('l45', 0.0, 0.1),
RealParameter('l81', 0.0, 0.1),
RealParameter('l10', 0.0, 0.1),
RealParameter('l46', 0.0, 0.1),
RealParameter('l82', 0.0, 0.1),
RealParameter('l11', 0.0, 0.1),
RealParameter('l47', 0.0, 0.1),
RealParameter('l83', 0.0, 0.1),
RealParameter('l12', 0.0, 0.1),
RealParameter('l48', 0.0, 0.1),
RealParameter('l84', 0.0, 0.1),
RealParameter('l13', 0.0, 0.1),
RealParameter('l49', 0.0, 0.1),
RealParameter('l85', 0.0, 0.1),
RealParameter('l14', 0.0, 0.1),
RealParameter('l50', 0.0, 0.1),
RealParameter('l86', 0.0, 0.1),
RealParameter('l15', 0.0, 0.1),
RealParameter('l51', 0.0, 0.1),
RealParameter('l87', 0.0, 0.1),
RealParameter('l16', 0.0, 0.1),
RealParameter('l52', 0.0, 0.1),
RealParameter('l88', 0.0, 0.1),
RealParameter('l17', 0.0, 0.1),
RealParameter('l53', 0.0, 0.1),
RealParameter('l89', 0.0, 0.1),
RealParameter('l18', 0.0, 0.1),
RealParameter('l54', 0.0, 0.1),
RealParameter('l90', 0.0, 0.1),
RealParameter('l19', 0.0, 0.1),
RealParameter('l55', 0.0, 0.1),
RealParameter('l91', 0.0, 0.1),
RealParameter('l20', 0.0, 0.1),
RealParameter('l56', 0.0, 0.1),
RealParameter('l92', 0.0, 0.1),
RealParameter('l21', 0.0, 0.1),
RealParameter('l57', 0.0, 0.1),
RealParameter('l93', 0.0, 0.1),
RealParameter('l22', 0.0, 0.1),
RealParameter('l58', 0.0, 0.1),
RealParameter('l94', 0.0, 0.1),
RealParameter('l23', 0.0, 0.1),
RealParameter('l59', 0.0, 0.1),
RealParameter('l95', 0.0, 0.1),
RealParameter('l24', 0.0, 0.1),
RealParameter('l60', 0.0, 0.1),
RealParameter('l96', 0.0, 0.1),
RealParameter('l25', 0.0, 0.1),
RealParameter('l61', 0.0, 0.1),
RealParameter('l97', 0.0, 0.1),
RealParameter('l26', 0.0, 0.1),
RealParameter('l62', 0.0, 0.1),
RealParameter('l98', 0.0, 0.1),
RealParameter('l27', 0.0, 0.1),
RealParameter('l63', 0.0, 0.1),
RealParameter('l99', 0.0, 0.1),
RealParameter('l28', 0.0, 0.1),
RealParameter('l64', 0.0, 0.1),
RealParameter('l29', 0.0, 0.1),
RealParameter('l65', 0.0, 0.1),
RealParameter('l30', 0.0, 0.1),
RealParameter('l66', 0.0, 0.1),
RealParameter('l31', 0.0, 0.1),
RealParameter('l67', 0.0, 0.1),
RealParameter('l32', 0.0, 0.1),
RealParameter('l68', 0.0, 0.1),
RealParameter('l33', 0.0, 0.1),
RealParameter('l69', 0.0, 0.1),
RealParameter('l34', 0.0, 0.1),
RealParameter('l70', 0.0, 0.1),
RealParameter('l35', 0.0, 0.1),
RealParameter('l71', 0.0, 0.1)
]
model.outcomes = [
ScalarOutcome('max_P'),
ScalarOutcome('utility'),
ScalarOutcome('inertia'),
ScalarOutcome('reliability')
]
return model
cum = 0
for d in mydensity:
cum = cum + d
density = cum / replications
return {'density': density}
if __name__ == '__main__':
ema_logging.LOG_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s'
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model('SimulateER', function=simulate_ER) # 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)
"""
if __name__ == '__main__':
ema_logging.log_to_stderr(ema_logging.INFO)
# instantiate the model
lake_model = Model('lakeproblem', function=lake_problem)
lake_model.time_horizon = 100
#specify uncertainties
lake_model.uncertainties = [RealParameter('b', 0.1, 0.45),
RealParameter('q', 2.0, 4.5),
RealParameter('mean', 0.01, 0.05),
RealParameter('stdev', 0.001, 0.005),
RealParameter('delta', 0.93, 0.99)]
# set levers, one for each time step
lake_model.levers = [RealParameter(str(i), 0, 0.1) for i in
range(lake_model.time_horizon)]
#specify outcomes
lake_model.outcomes = [ScalarOutcome('max_P',),
ScalarOutcome('utility'),
ScalarOutcome('inertia'),
ScalarOutcome('reliability')]
# override some of the defaults of the model
lake_model.constants = [Constant('alpha', 0.41),
Constant('nsamples', 150)]
# generate sa single default no release policy
policy = Policy('no release', **{str(i):0.1 for i in range(100)})
from cablepool_leso_handshake import METRICS, CablePooling
from ema_workbench import (
RealParameter,
CategoricalParameter,
ScalarOutcome,
Model,
)
# initiate model
model = Model(name='Cablepool', function=CablePooling)
# levers / policies
model.levers = [
CategoricalParameter("approach", [1, 0]),
]
# uncertainties / scenarios
model.uncertainties = [
RealParameter("pv_cost_factor", 0.38, 0.85),
RealParameter("battery_cost_factor", 0.41, 0.70),
RealParameter("wind_cost_factor", 0.77, 0.98)
]
# specify outcomes
model.outcomes = [ScalarOutcome(metric) for metric in METRICS]
def problem_definition(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
## TODO implement own problem
# 3-objectives PF:
if problem_formulation_id.lower() == 'damage, cost, deaths':
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.lower() == 'damage, investment, rfr, deaths':
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.lower() == 'vars per location':
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 locations:
elif problem_formulation_id.lower() == 'a4, a5 vars':
outcomes = []
for dike in function.dikelist:
if '4' in dike or '5' in dike:
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.lower() == 'vars per planningstep':
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.lower() == 'all vars':
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
else:
raise TypeError('unknownx identifier')
return dike_model, function.planning_steps
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
else:
raise TypeError('unknownx identifier')
return dike_model, function.planning_steps
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)
]
RICE.levers = [
RealParameter('sr', 0.1, 0.5),
RealParameter('irstp', 0.001, 0.015),
IntegerParameter('miu_period', 5, 30),
#controls for prioritarian case
RealParameter('growth_factor_prio', 1, 1.04),
IntegerParameter('prioritarian_discounting', 0, 1)
]
RICE.outcomes = [
ScalarOutcome('Lowest income per capita 2055', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Highest climate impact per capita 2055',
ScalarOutcome.MINIMIZE),
ScalarOutcome('Lowest income per capita 2105', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Highest climate impact per capita 2105',
ScalarOutcome.MINIMIZE),
ScalarOutcome('Lowest income per capita 2155', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Highest climate impact per capita 2155',
ScalarOutcome.MINIMIZE),
from evhub_leso_handshake import METRICS, EVHub
from ema_workbench import (
RealParameter,
CategoricalParameter,
ScalarOutcome,
Model,
)
# initiate model
model = Model(name='EVHub', function=EVHub)
# levers / policies
model.levers = [
CategoricalParameter("grid_capacity", [0, 0.5, 1, 1.5]),
]
# uncertainties / scenarios
model.uncertainties = [
RealParameter("pv_cost_factor", 0.38, 0.85),
RealParameter("wind_cost_factor", 0.77, 0.98),
RealParameter("battery_cost_factor", 0.41, 0.70),
]
# specify outcomes
model.outcomes = [ScalarOutcome(metric) for metric in METRICS]
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),
RealParameter('irstp', 0.001, 0.015),
IntegerParameter('miu_period', 5, 30)
]
RICE.outcomes = [
ScalarOutcome('Damages 2055', ScalarOutcome.MINIMIZE),
ScalarOutcome('Utility 2055', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Damages 2105', ScalarOutcome.MINIMIZE),
ScalarOutcome('Utility 2105', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Damages 2155', ScalarOutcome.MINIMIZE),
ScalarOutcome('Utility 2155', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Damages 2205', ScalarOutcome.MINIMIZE),
ScalarOutcome('Utility 2205', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Damages 2305', ScalarOutcome.MINIMIZE),
ScalarOutcome('Utility 2305', ScalarOutcome.MAXIMIZE),
ScalarOutcome('Total Aggregated Utility', ScalarOutcome.MAXIMIZE)
activations = coherenceMaximizer(G)
c = activations["C"]
d = activations["D"]
e = activations["E"]
return {'c': c, 'd': d, 'e': e}
if __name__ == '__main__':
ema_logging.LOG_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s'
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model('SimulateCM', function=simulate_CM) # instantiate the model
# specify uncertainties
model.uncertainties = [RealParameter("a", 0.1, 1.0)]
model.levers = [RealParameter("b", 0.0, 0.01)]
# specify outcomes
model.outcomes = [
ScalarOutcome('c'),
ScalarOutcome('d'),
ScalarOutcome('e')
]
#model.constants = [Constant('replications', 10)]
n_scenarios = 10
n_policies = 10
res = perform_experiments(model, n_scenarios, n_policies)
# specify process model parameters xRCP=None, xClimateModel=None
model.uncertainties = [
RealParameter("Xfactor1", 0.51, 3.49),
IntegerParameter("xRCP", 1, 3),
#RealParameter("xRCP", 0.51, 3.49),
RealParameter("xClimateModel", 0, 1),
RealParameter("X2fM", 1.01, 1.61),
RealParameter("X3iPot", 900, 1100),
RealParameter("X5temp", 3.0, 6.0),
RealParameter("X6tempArt", -2.0, -1.0)
]
# specify polices IntegerParameter
model.levers = [
RealParameter("x1SnowThershold", 200.0, 300.0),
RealParameter("xGoodDays", 70.0, 100.0)
]
# specify outcomes
model.outcomes = [
ScalarOutcome('y'),
ScalarOutcome('y1'),
ArrayOutcome('y3'),
ScalarOutcome('y4'),
ScalarOutcome('y5'),
ScalarOutcome('y6'),
ScalarOutcome('y7')
]
# override some of the defaults of the model
model.constants = [
model = PyRICE(model_specification="EMA",welfare_function="sufficitarian")
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, 13649),
RealParameter('limmiu',0.8,1.2)]
RICE.levers = [RealParameter('sr', 0.1, 0.5),
RealParameter('irstp', 0.001, 0.015),
IntegerParameter('miu_period', 5, 30),
IntegerParameter('sufficitarian_discounting', 0,1),
RealParameter('growth_factor_suf',1,1.04),
RealParameter('ini_suf_treshold',0.7,2.4)]
RICE.outcomes =[ScalarOutcome('Distance to treshold 2055', ScalarOutcome.MINIMIZE),
ScalarOutcome('Population under treshold 2055', ScalarOutcome.MINIMIZE),
ScalarOutcome('Distance to treshold 2105', ScalarOutcome.MINIMIZE),
ScalarOutcome('Population under treshold 2105', ScalarOutcome.MINIMIZE),
ScalarOutcome('Distance to treshold 2155', ScalarOutcome.MINIMIZE),
ScalarOutcome('Population under treshold 2155', ScalarOutcome.MINIMIZE),
ScalarOutcome('Distance to treshold 2205', ScalarOutcome.MINIMIZE),
ScalarOutcome('Population under treshold 2205', ScalarOutcome.MINIMIZE),
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
# Specific to Gelderland Province
elif problem_formulation_id == 6:
damage_a1_a2 = []
damage_a3 = []
casualties_a1_a2 = []
casualties_a3 = []
dike_costs = []
rfr_costs = []
evacuation_costs = []
outcomes = []
for n in function.planning_steps:
#Damage
damage_a1_a2.extend([
'A.1_Expected Annual Damage {}'.format(n),
'A.2_Expected Annual Damage {}'.format(n)
])
damage_a3.extend(['A.3_Expected Annual Damage {}'.format(n)])
#Casualties
casualties_a1_a2.extend([
'A.1_Expected Number of Deaths {}'.format(n),
'A.2_Expected Number of Deaths {}'.format(n)
])
casualties_a3.extend(
['A.3_Expected Number of Deaths {}'.format(n)])
#Costs
for dike in function.dikelist:
dike_costs.extend([
'{}_Dike Investment Costs {}'.format(dike, n)
for dike in function.dikelist
])
rfr_costs.extend(['RfR Total Costs {}'.format(n)])
evacuation_costs.extend(['Expected Evacuation Costs {}'.format(n)])
dike_model.outcomes = [
ScalarOutcome('A1_2 Aggr Expected Annual Damage',
variable_name=[var for var in damage_a1_a2],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A3 Expected Annual Damage',
variable_name=[var for var in damage_a3],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A1_2 Aggr Expected Number of Deaths',
variable_name=[var for var in casualties_a1_a2],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A3 Aggr Expected Number of Deaths',
variable_name=[var for var in casualties_a3],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A1_5 Dike Investment Costs',
variable_name=[var for var in dike_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Room for River Investment Costs',
variable_name=[var for var in rfr_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Evacuation Costs',
variable_name=[var for var in evacuation_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE)
]
#Specified for Overijssel
elif problem_formulation_id == 7:
damage_a4 = []
damage_a5 = []
casualties_a4 = []
casualties_a5 = []
dike_costs = []
rfr_costs = []
evacuation_costs = []
outcomes = []
for n in function.planning_steps:
#Damage
damage_a4.extend(['A.4_Expected Annual Damage {}'.format(n)])
damage_a5.extend(['A.5_Expected Annual Damage {}'.format(n)])
#Casualties
casualties_a4.extend(
['A.4_Expected Number of Deaths {}'.format(n)])
casualties_a5.extend(
['A.5_Expected Number of Deaths {}'.format(n)])
#Costs
for dike in function.dikelist:
dike_costs.extend([
'{}_Dike Investment Costs {}'.format(dike, n)
for dike in function.dikelist
])
rfr_costs.extend(['RfR Total Costs {}'.format(n)])
evacuation_costs.extend(['Expected Evacuation Costs {}'.format(n)])
dike_model.outcomes = [
ScalarOutcome('A4 Expected Annual Damage',
variable_name=[var for var in damage_a4],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A5 Expected Annual Damage',
variable_name=[var for var in damage_a5],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A4 Expected Number of Deaths',
variable_name=[var for var in casualties_a4],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A5 Expected Number of Deaths',
variable_name=[var for var in casualties_a5],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('A1_5 Dike Investment Costs',
variable_name=[var for var in dike_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Room for River Investment Costs',
variable_name=[var for var in rfr_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Evacuation Costs',
variable_name=[var for var in evacuation_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE)
]
# 7-Objectives PF Holistic View:
elif problem_formulation_id == 8:
casualties = []
rfr_costs = []
evacuation_costs = []
gelderland_dike_cost = []
overijssel_dike_cost = []
gelderland_expected_damage = []
overijssel_expected_damage = []
outcomes = []
for n in function.planning_steps:
#Damage
gelderland_expected_damage.extend([
'A.1_Expected Annual Damage {}'.format(n),
'A.2_Expected Annual Damage {}'.format(n),
'A.3_Expected Annual Damage {}'.format(n)
])
overijssel_expected_damage.extend([
'A.4_Expected Annual Damage {}'.format(n),
'A.5_Expected Annual Damage {}'.format(n)
])
#Casualties
casualties.extend([
'A.1_Expected Number of Deaths {}'.format(n),
'A.2_Expected Number of Deaths {}'.format(n),
'A.3_Expected Number of Deaths {}'.format(n),
'A.4_Expected Number of Deaths {}'.format(n),
'A.5_Expected Number of Deaths {}'.format(n)
])
#Costs
for dike in function.dikelist:
gelderland_dike_cost.extend([
'{}_Dike Investment Costs {}'.format(dike, n)
for dike in function.dikelist[0:len(function.dikelist) - 1]
])
overijssel_dike_cost.extend([
'{}_Dike Investment Costs {}'.format(dike, n)
for dike in function.dikelist[4:5]
])
rfr_costs.extend(['RfR Total Costs {}'.format(n)])
evacuation_costs.extend(['Expected Evacuation Costs {}'.format(n)])
dike_model.outcomes = [
ScalarOutcome(
'Gelderland Expected Annual Damage',
variable_name=[var for var in gelderland_expected_damage],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome(
'Overijssel Expected Annual Damage',
variable_name=[var for var in overijssel_expected_damage],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Expected Number of Deaths',
variable_name=[var for var in casualties],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Gelderland Dike Cost',
variable_name=[var for var in gelderland_dike_cost],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Overijssel Dike Cost',
variable_name=[var for var in overijssel_dike_cost],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Room for River Investment Costs',
variable_name=[var for var in rfr_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Evacuation Costs',
variable_name=[var for var in evacuation_costs],
function=sum_over,
kind=ScalarOutcome.MINIMIZE)
]
else:
raise TypeError('unknownx identifier')
return dike_model, function.planning_steps
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 [.]
cat_uncert_loc = {'Brate': (0.9, 1.5, 1000)} # breach growth rate [m/day]
cat_uncert = {'discount rate': (1.5, 2.5, 3.5, 4.5)}
Int_uncert = {'A.0_ID flood wave shape': [0, 133]}
# 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
else:
raise TypeError('unknonw identifier')
return dike_model
#set levers, one for each time step
#n=1
#for i in range(basin_model.time_horizon):
for k in range(len(dams)):
for j in range(12):
a = RealParameter(dams[k][0][j], minimum[k], maximum[k])
l.append(a)
a = RealParameter(dams[k][1][j], 0, 1)
l.append(a)
a = RealParameter(dams[k][2][j], 0, 1)
l.append(a)
#basin_model.levers.append(a)
#l.append(a)
print(l)
basin_model.levers = l
#basin_model.levers = [RealParameter(part1[j], part1min, part1max),
#RealParameter(part2[j], part1min, part1max),
#RealParameter(part3[j], part1min, part1max),
#RealParameter(pat4[j], part2min, part2max),
#RealParameter(part5[j], part2min, part2max),
#RealParameter(part6[j], part2min, part2max),
#RealParameter(part7[j], part3min, part3max),
#RealParameter(part8[j], part3min, part3max),
#RealParameter(part9[j], part3min, part3max),
#RealParameter(part10[j], part4min, part4max),
#RealParameter(part11[j], part4min, part4max),
#RealParameter(part12[j], part4min, part4max),
#RealParameter(part13[j], part5min, part5max),
#RealParameter(part14[j], part5min, part5max),
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)
]
RICE.levers = [
RealParameter('sr', 0.1, 0.5),
RealParameter('irstp', 0.001, 0.015),
IntegerParameter('miu_period', 5, 30),
IntegerParameter('egalitarian_discounting', 0, 1)
] #0 = no discouting , 1 = normal discounting,
RICE.outcomes = [
ScalarOutcome('Intratemporal utility GINI 2055',
ScalarOutcome.MINIMIZE),
ScalarOutcome('Intratemporal impact GINI 2055',
ScalarOutcome.MINIMIZE),
ScalarOutcome('Intratemporal utility GINI 2105',
ScalarOutcome.MINIMIZE),
ScalarOutcome('Intratemporal impact GINI 2105',
ScalarOutcome.MINIMIZE),
ScalarOutcome('Intertemporal utility GINI', ScalarOutcome.MINIMIZE),
ScalarOutcome('Intertemporal impact GINI', ScalarOutcome.MINIMIZE)
]
# instantiate the model
lake_model = Model("lakeproblem", function=lake_problem)
lake_model.time_horizon = 100
# specify uncertainties
lake_model.uncertainties = [
RealParameter("b", 0.1, 0.45),
RealParameter("q", 2.0, 4.5),
RealParameter("mean", 0.01, 0.05),
RealParameter("stdev", 0.001, 0.005),
RealParameter("delta", 0.93, 0.99),
]
# set levers, one for each time step
lake_model.levers = [RealParameter(str(i), 0, 0.1) for i in range(lake_model.time_horizon)]
# specify outcomes
lake_model.outcomes = [
ScalarOutcome("max_P"),
ScalarOutcome("utility"),
ScalarOutcome("inertia"),
ScalarOutcome("reliability"),
]
# override some of the defaults of the model
lake_model.constants = [Constant("alpha", 0.41), Constant("nsamples", 150)]
# generate some random policies by sampling over levers
policies = samplers.sample_levers(lake_model, 4, sampler=samplers.MonteCarloSampler(), name=util.counter)
ema_logging.log_to_stderr(ema_logging.INFO)
#instantiate the model
lake_model = Model('lakeproblem', function=lake_problem)
#specify uncertainties
lake_model.uncertainties = [RealParameter('b', 0.1, 0.45),
RealParameter('q', 2.0, 4.5),
RealParameter('mean', 0.01, 0.05),
RealParameter('stdev', 0.001, 0.005),
RealParameter('delta', 0.93, 0.99)]
# set levers
lake_model.levers = [RealParameter("c1", -2, 2),
RealParameter("c2", -2, 2),
RealParameter("r1", 0, 2),
RealParameter("r2", 0, 2),
RealParameter("w1", 0, 1)
]
#specify outcomes
lake_model.outcomes = [ScalarOutcome('max_P'),
ScalarOutcome('utility'),
ScalarOutcome('inertia'),
ScalarOutcome('reliability')]
# override some of the defaults of the model
lake_model.constants = [Constant('alpha', 0.41),
Constant('nsamples', 100),
Constant('myears', 100)]
# setup and execute the robust optimization
"time_spent": time_spent
}
return results
from ema_workbench import (RealParameter, ScalarOutcome, perform_experiments,
Model, save_results)
# initiate model
model = Model(name='taxidriver', function=ema_experiment)
# levers
model.levers = [
RealParameter("startup_fee", 2, 5),
RealParameter("km_fee", 0.2, 0.5),
RealParameter("speed", 90, 130),
]
# uncertainties
model.uncertainties = [
RealParameter("distance", 3, 60),
RealParameter("fuel_price", 1.1, 1.8),
RealParameter("driver_salary_rate", 10, 20),
]
# specify outcomes
model.outcomes = [
ScalarOutcome("profit"),
ScalarOutcome("fuel_use"),
ScalarOutcome("time_spent"),
RealParameter('stdev', 0.001, 0.005),
RealParameter('delta', 0.93, 0.99)
]
# specify outcomes
model.outcomes = [
ScalarOutcome('max_P'),
ScalarOutcome('utility'),
ScalarOutcome('inertia'),
ScalarOutcome('reliability')
]
# set levers
#model.levers = [RealParameter('decisions', 0, 0.1)]
model.levers = [
RealParameter(f"l{i}", 0, 0.1) for i in range(model.time_horizon)
]
# model constants
model.constants = [Constant('alpha', 0.4), Constant('nsamples', 100)]
#####################################################################################################
from ema_workbench import Policy
# performing experiments
# generate experiments
n_scenarios = 1000
n_policies = 4
policy = Policy("no release", **{l.name: 0 for l in model.levers})
from ema_workbench import (MultiprocessingEvaluator, ema_logging,
perform_experiments)
#%%
dice_sm.uncertainties = [IntegerParameter('t2xco2_index', 0, 999),
# IntegerParameter('t2xco2_dist',0,2),
# IntegerParameter('fdamage', 0, 2),
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', -0.5, 0.99),
]
dice_sm.levers = [RealParameter('sr', 0.1, 0.5),
RealParameter('prtp_con', 0.001, 0.015),
# RealParameter('prtp_dam', 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 = [
ScalarOutcome('Atmospheric Temperature 2300', kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Total Output 2300', kind=ScalarOutcome.MAXIMIZE),
# ScalarOutcome('Per Capita Consumption 2300', kind=ScalarOutcome.INFO),
# ScalarOutcome('Consumption Growth 2300', kind=ScalarOutcome.INFO),
ScalarOutcome('Utility of Consumption 2300', kind=ScalarOutcome.MAXIMIZE),
# ScalarOutcome('Per Capita Damage 2300', kind=ScalarOutcome.INFO),
# ScalarOutcome('Damage Growth 2300', kind=ScalarOutcome.INFO),
ScalarOutcome('Disutility of Damage 2300', kind=ScalarOutcome.MINIMIZE),
ScalarOutcome('Welfare 2300', kind=ScalarOutcome.MAXIMIZE),
# ScalarOutcome('Undiscounted Period Welfare 2300', kind=ScalarOutcome.INFO),
