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 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 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
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')
"deceased_population_region_1": deceased_population_region_1}
if __name__ == '__main__':
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model('mexicanFlu', function=flu_model)
model.uncertainties = [RealParameter('x11', 0, 0.5),
RealParameter('x12', 0, 0.5),
RealParameter('x21', 0.0001, 0.1),
RealParameter('x22', 0.0001, 0.1),
RealParameter('x31', 0, 0.5),
RealParameter('x32', 0, 0.5),
RealParameter('x41', 0, 0.9),
RealParameter('x51', 0, 0.5),
RealParameter('x52', 0, 0.5),
RealParameter('x61', 0, 0.8),
RealParameter('x62', 0, 0.8),
RealParameter('x81', 1, 10),
RealParameter('x82', 1, 10),
RealParameter('x91', 0, 0.1),
RealParameter('x92', 0, 0.1),
RealParameter('x101', 0, 200),
RealParameter('x102', 0, 200)]
model.outcomes = [TimeSeriesOutcome("TIME"),
TimeSeriesOutcome("deceased_population_region_1")]
nr_experiments = 500
with MultiprocessingEvaluator(model) as evaluator:
return x_distributed
non_uniform_sampling = False
# set uncertainties
n_eval_per_var = 12
sampling = distributed_sampling if non_uniform_sampling == True else lambda x, y: (
np.linspace(x, y, num=n_eval_per_var))
model.uncertainties = [ #CategoricalParameter('wind_multiplier', sampling(1.0, 2.0) ), # up to 100% increase in wind speed
CategoricalParameter('sea_level_shift',
sampling(0.0,
1)), # up to 1.5 meter shift water level
CategoricalParameter('peak_inflow_multiplier',
sampling(1, 2)), # up to 100% increase in inflow
CategoricalParameter('low_flow_shift', sampling(
0., 100.)), # up to a reduction of low flow of 100 m^3/s
#CategoricalParameter('evaporation_multiplier', sampling(1, 2)), # Increase of potential evaporation
#CategoricalParameter('precipitation_multiplier', sampling(1,3) )
]
# set levers
policies = [
CategoricalParameter('summer_target', (-0.2, 0.2)),
CategoricalParameter('pump_capacity', (0, 500)),
#CategoricalParameter('winter_target', (-0.4, -0.1) ),
CategoricalParameter('sluices_widening', (1, 2))
]
model.levers = policies
ema_logging.log_to_stderr(ema_logging.INFO)
model = PyDICE()
dice_sm = Model('dicesmEMA', function=model)
#%%
dice_opt = pd.read_excel("DICE2013R.xlsm", sheet_name="Opttax", index_col=0)
#%%
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 = [
events = o.data.events[PLAYER]
metrics = o.data.endOfRun[PLAYER]
out = collectOutputs(events, metrics)
return out
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)]
inertia += np.sum(np.absolute(np.diff(decisions) < 0.02)) / (nsamples*myears)
utility += np.sum(alpha*decisions*np.power(delta, np.arange(myears))) / nsamples
max_P = np.max(average_daily_P)
return max_P, utility, inertia, reliability
if __name__ == '__main__':
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'),
gd = nx.density(er)
mydensity.append(gd)
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,
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
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 = [
if __name__ == '__main__':
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model('mexicanFlu', function=flu_model)
model.uncertainties = [
RealParameter('x11', 0, 0.5),
RealParameter('x12', 0, 0.5),
RealParameter('x21', 0.0001, 0.1),
RealParameter('x22', 0.0001, 0.1),
RealParameter('x31', 0, 0.5),
RealParameter('x32', 0, 0.5),
RealParameter('x41', 0, 0.9),
RealParameter('x51', 0, 0.5),
RealParameter('x52', 0, 0.5),
RealParameter('x61', 0, 0.8),
RealParameter('x62', 0, 0.8),
RealParameter('x81', 1, 10),
RealParameter('x82', 1, 10),
RealParameter('x91', 0, 0.1),
RealParameter('x92', 0, 0.1),
RealParameter('x101', 0, 200),
RealParameter('x102', 0, 200)
]
model.outcomes = [
TimeSeriesOutcome("TIME"),
TimeSeriesOutcome("deceased_population_region_1")
]
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
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
# input domain name from command line
domain = sys.argv[1]
ema_logging.LOG_FORMAT = '[%(name)s/%(levelname)s/%(processName)s] %(message)s'
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model('grsystem', function=gr_system)
# set levers
model.uncertainties = [IntegerParameter("phi", 0,100),
RealParameter("delta", 0, 5),
RealParameter("lamb", 1, 5),
RealParameter("threshold", 0.6, 1.0)]
# model.levers = [CategoricalParameter("domain", ["sokoban", "blocks-world"])]
model.constants = [Constant("domain", domain)]
#specify outcomes
model.outcomes = [ScalarOutcome('p_10'),
ScalarOutcome('r_10'),
ScalarOutcome('a_10'),
ScalarOutcome('p_30'),
ScalarOutcome('r_30'),
ScalarOutcome('a_30'),
ScalarOutcome('p_50'),
ScalarOutcome('r_50'),
ScalarOutcome('a_50'),
def vpl_model(x1=None, x2=None, x3=None):
return {'y':x1*x2+x3}
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('simpleModel', function=modelvpl) #instantiate the model
#specify uncertainties
model.uncertainties = [RealParameter("indice_custo", 0.9, 1.1),
RealParameter("indice_faturamento", 0.9,1.3),
RealParameter("i", 0.01,0.05)]
#specify outcomes
model.outcomes = [ScalarOutcome('y')]
results = perform_experiments(model, 1000)
util.utilities.save_results(results, './results/results.tar.gz')
# print(results)
# ensemble = ModelEnsemble() #instantiate an ensemble
# ensemble.model_structure = model #set the model on the ensemble
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()
]
from ema_workbench import Policy, perform_experiments
from ema_workbench import ema_logging
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),
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),
# Generate heatmaps for different parameters of max. features
tree_generate_heatmap(x, prey_final_np, prey_mean_np, prey_std_np, 100,
0.4, ax1)
tree_generate_heatmap(x, prey_final_np, prey_mean_np, prey_std_np, 100,
0.6, ax2)
tree_generate_heatmap(x, prey_final_np, prey_mean_np, prey_std_np, 100,
0.8, ax3)
plt.show()
model = Model('PredPreyGSA', function=pred_prey)
model.uncertainties = [
RealParameter('prey_birth_rate', 0.015, 0.035),
RealParameter('predation_rate', 0.0005, 0.003),
RealParameter('predator_efficiency', 0.001, 0.004),
RealParameter('predator_loss_rate', 0.04, 0.08)
]
model.outcomes = [
TimeSeriesOutcome('TIME', function=np.squeeze),
TimeSeriesOutcome('predators', function=np.squeeze),
TimeSeriesOutcome('prey', function=np.squeeze)
]
run_full_tree_experiment(50)
run_full_tree_experiment(250)
run_full_tree_experiment(1000)
# We can see that the sample size has a significant impact on the relative sobol indices. Most noticably, the tree model predicts a lower importance of the predator efficiency on the prey_mean value.
#
### import time
start_time = time.time()
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('UZHModel', function=snow_Model) # instantiate the model
# 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'),
def base_model(params):
base = Model('base', function=modelData.dps.lake_model)
base.uncertainties = params.uncertainties
return base
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
.. codeauthor:: jhkwakkel <j.h.kwakkel (at) tudelft (dot) nl>
'''
from __future__ import (absolute_import, print_function, division,
unicode_literals)
from ema_workbench import (Model, RealParameter, ScalarOutcome, ema_logging,
perform_experiments)
def some_model(x1=None, x2=None, x3=None):
return {'y': x1 * x2 + x3}
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('simpleModel', function=some_model) # instantiate the model
# specify uncertainties
model.uncertainties = [
RealParameter("x1", 0.1, 10),
RealParameter("x2", -0.01, 0.01),
RealParameter("x3", -0.01, 0.01)
]
# specify outcomes
model.outcomes = [ScalarOutcome('y')]
results = perform_experiments(model, 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 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
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
if __name__ == "__main__":
ema_logging.log_to_stderr(ema_logging.INFO)
model = Model("mexicanFlu", function=flu_model)
model.uncertainties = [
RealParameter("x11", 0, 0.5),
RealParameter("x12", 0, 0.5),
RealParameter("x21", 0.0001, 0.1),
RealParameter("x22", 0.0001, 0.1),
RealParameter("x31", 0, 0.5),
RealParameter("x32", 0, 0.5),
RealParameter("x41", 0, 0.9),
RealParameter("x51", 0, 0.5),
RealParameter("x52", 0, 0.5),
RealParameter("x61", 0, 0.8),
RealParameter("x62", 0, 0.8),
RealParameter("x81", 1, 10),
RealParameter("x82", 1, 10),
RealParameter("x91", 0, 0.1),
RealParameter("x92", 0, 0.1),
RealParameter("x101", 0, 200),
RealParameter("x102", 0, 200),
]
model.outcomes = [TimeSeriesOutcome("TIME"), TimeSeriesOutcome("deceased_population_region_1")]
nr_experiments = 500
results = perform_experiments(model, nr_experiments, parallel=True)
return max_P, utility, inertia, reliability
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"),
]
#print(total_policy_list[1])
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="egalitarian")
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)
#only needed on IPython console within Anaconda
__spec__ = "ModuleSpec(name='builtins', loader=<class '_frozen_importlib.BuiltinImporter'>)"
with MultiprocessingEvaluator(RICE) as evaluator:
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"),
]
# run experiments
results = perform_experiments(model, scenarios=10, policies=3)
# # save results
# results_file_name = os.path.join(RESULT_FOLDER, f"cabelpooling_ema_results_{RUNID}.tar.gz")
freeze_support()
lake_model_actual()
#####################################################################################################
# now connect the model with the workbench
from ema_workbench import Model, RealParameter, ScalarOutcome, Constant
model = Model('lakeproblem', function=lake_model_actual)
model.time_horizon = 100
# 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)
]
# specify outcomes
model.outcomes = [
ScalarOutcome('max_P'),
ScalarOutcome('utility'),
ScalarOutcome('inertia'),
ScalarOutcome('reliability')
]
# set levers
#model.levers = [RealParameter('decisions', 0, 0.1)]
model.levers = [
'''
from __future__ import (absolute_import, print_function, division,
unicode_literals)
from ema_workbench import (Model, RealParameter, ScalarOutcome, ema_logging,
perform_experiments)
def some_model(x1=None, x2=None, x3=None):
return {'y':x1*x2+x3}
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('simpleModel', function=some_model) #instantiate the model
#specify uncertainties
model.uncertainties = [RealParameter("x1", 0.1, 10),
RealParameter("x2", -0.01,0.01),
RealParameter("x3", -0.01,0.01)]
#specify outcomes
model.outcomes = [ScalarOutcome('y')]
results = perform_experiments(model, 100)
# ensemble = ModelEnsemble() #instantiate an ensemble
# ensemble.model_structure = model #set the model on the ensemble
# results = ensemble.perform_experiments(100, reporting_interval=1) #run 1000 experiments
