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 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 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 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 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
natural_inflows[t-1] average_daily_P[t] += X[t]/nsamples reliability += np.sum(X < Pcrit)/(nsamples*myears) 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) ]
def lake_model(): lake_model_actual() if __name__ == '__main__': 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'),
dx = (prey_birth_rate * prey[r, t]) - (predation_rate * prey[r, t] * predators[r, t]) dy = (predator_efficiency * predators[r, t] * prey[r, t]) - (predator_loss_rate * predators[r, t]) prey[r, t + 1] = max(prey[r, t] + dx * dt, 0) predators[r, t + 1] = max(predators[r, t] + dy * dt, 0) sim_time[r, t + 1] = (t + 1) * dt #Return outcomes return {'TIME': sim_time, 'predators': predators, 'prey': prey} # Instantiate Python model modelPython = Model('PredPreyPython', function=pred_prey) # instantiate the model def generate_regression(X, y): # Add column of ones to the end of the dependent variable matrix X = sm.add_constant(X, prepend=False) # Fit and summarize OLS model mod = sm.OLS(y, X) res = mod.fit() print(res.summary()) def generate_regression_single(x, y): # Add column of ones to the end of the dependent variable matrix x = sm.add_constant(x, prepend=False)
def omegaDriver(**arg): o.reset() setUpExperiment(**arg) o.run() 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'),
largest_cc = max(nx.connected_components(er), key=len) Sf = len(largest_cc) 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) """
IntegerParameter, ScalarOutcome, MultiprocessingEvaluator) from ema_workbench.util import ema_logging from ema_workbench.em_framework.evaluators import BaseEvaluator from ema_workbench.em_framework.optimization import (EpsilonProgress, HyperVolume) ema_logging.log_to_stderr(ema_logging.INFO) BaseEvaluator.reporting_frequency = 0.1 # ema_logging.log_to_stderr(ema_logging.DEBUG) from PyRICE_V8 import PyRICE model = PyRICE(model_specification="EMA", welfare_function="utilitarian") RICE = Model('RICE', function=model) RICE.uncertainties = [ IntegerParameter('fdamage', 0, 1), IntegerParameter('scenario_pop_tfp', 0, 5), IntegerParameter('scenario_sigma', 0, 5), IntegerParameter('scenario_cback', 0, 2), IntegerParameter('cback_to_zero', 0, 1), RealParameter('fosslim', 4000.0, 13649), RealParameter('limmiu', 0.8, 1.2) ] RICE.levers = [ RealParameter('sr', 0.1, 0.5), RealParameter('irstp', 0.001, 0.015), IntegerParameter('miu_period', 5, 30)
model_version = 'v6' from dicemodel.specs import nordhaus_policy, reference_scenario # %% from ema_workbench.em_framework.evaluators import BaseEvaluator from ema_workbench import (perform_experiments, Model, Policy, Scenario, ReplicatorModel, RealParameter, IntegerParameter, TimeSeriesOutcome, ScalarOutcome, ArrayOutcome, Constant, ema_logging, SequentialEvaluator, MultiprocessingEvaluator, IpyparallelEvaluator) from ema_workbench import save_results, load_results from ema_workbench.analysis import prim, cart from ema_workbench.analysis import scenario_discovery_util as sdutil from ema_workbench.analysis import plotting, plotting_util 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),
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')
profit = income - fuel_cost - salary_cost results = { "profit": profit, "fuel_use": fuel_use, "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), ]
.. 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) # 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
average_daily_P[t] += X[t] / float(nsamples) reliability += np.sum(X < Pcrit) / float(nsamples * nvars) max_P = np.max(average_daily_P) utility = np.sum(alpha * decisions * np.power(delta, np.arange(nvars))) inertia = np.sum(np.diff(decisions) > -0.02) / float(nvars - 1) 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
IntegerParameter, ScalarOutcome, MultiprocessingEvaluator) from ema_workbench.util import ema_logging from ema_workbench.em_framework.evaluators import BaseEvaluator from ema_workbench.em_framework.optimization import (EpsilonProgress, HyperVolume) ema_logging.log_to_stderr(ema_logging.INFO) BaseEvaluator.reporting_frequency = 0.1 # ema_logging.log_to_stderr(ema_logging.DEBUG) from PyRICE_V8 import PyRICE model = PyRICE(model_specification="EMA", welfare_function="egalitarian") RICE = Model('RICE', function=model) RICE.uncertainties = [ IntegerParameter('fdamage', 0, 2), 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),
#if (rflowJat[lstep+1] >= floodstart) : part.flooddam += flooddamage #part.value = (part.HydroPSag+part.HydroPCir+part.HydroPJat+part.irrival-part.flooddam)*benscale #if part.value > part.bestvalue: #part.bestvalue=part.value #for iparam in range(nparam): part.bestparam[iparam]=part.param[iparam] #output.put((ipart,part.value,part.HydroPSag,part.HydroPCir,part.HydroPJat,part.irrival,part.flooddam)) from ema_workbench import (Model, RealParameter, ScalarOutcome, MultiprocessingEvaluator, ema_logging, Constant, SequentialEvaluator) if __name__ == '__main__': ema_logging.log_to_stderr(ema_logging.INFO) #instantiate the model basin_model = Model('ribasim', function=ribasimmodel) #basin_model.time_horizon = 1 # used to specify the number of t/imesteps #specify uncertainties #for i in range(180): # basin_model.uncertainties = [RealParameter('part1', part1min, part1max), # RealParameter('part2', part2min, part2max), # RealParameter('part3', part3min, part3max), # RealParameter('part4', part4min, part4max), # RealParameter('part5', part5min, part5max)] #ahmed=np.zeros((3,12)) #bine=np.zeros((3,12)) #hassan=np.zeros((3,12)) #moullay=np.zeros((3,12)) #almassira=np.zeros((3,12)) ahmed = np.array([[
.. 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)
reliability += np.sum(X < Pcrit) / (nsamples * myears) 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), CategoricalParameter("w1", np.linspace(0, 1, 10)) ] # specify outcomes
from ema_workbench import (Model, Constraint, Scenario, RealParameter, IntegerParameter, ScalarOutcome, MultiprocessingEvaluator) from ema_workbench.util import ema_logging from ema_workbench.em_framework.evaluators import BaseEvaluator from ema_workbench.em_framework.optimization import (EpsilonProgress, HyperVolume) ema_logging.log_to_stderr(ema_logging.INFO) BaseEvaluator.reporting_frequency = 0.1 # ema_logging.log_to_stderr(ema_logging.DEBUG) from PyRICE_V8 import PyRICE # Sufficitarian principle with aggregated utility 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),
immune_population_region_1 = immune_population_region_1_NEXT immune_population_region_2 = immune_population_region_2_NEXT deceased_population_region_1.append(deceased_population_region_1_NEXT) deceased_population_region_2.append(deceased_population_region_2_NEXT) # End of main code return {"TIME": runTime, "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),
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
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]
#principle index principle_index = 2 #print(total_policy_list[0]) #print(total_policy_list[1]) nfe = 25000 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) ] RICE.levers = [ RealParameter('sr', 0.1, 0.5),
average_daily_P[t] += X[t]/float(nsamples) reliability += np.sum(X < Pcrit)/float(nsamples*nvars) max_P = np.max(average_daily_P) utility = np.sum(alpha*decisions*np.power(delta,np.arange(nvars))) inertia = np.sum(np.absolute(np.diff(decisions)) < 0.02)/float(nvars-1) 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',),
immune_population_region_1 = immune_population_region_1_NEXT immune_population_region_2 = immune_population_region_2_NEXT deceased_population_region_1.append(deceased_population_region_1_NEXT) deceased_population_region_2.append(deceased_population_region_2_NEXT) # End of main code return {"TIME": runTime, "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),
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
#principle index principle_index = 2 nfe = 50000 #print(total_policy_list[0]) #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(
def base_model(params): base = Model('base', function=modelData.dps.lake_model) base.uncertainties = params.uncertainties return base
from ema_workbench import (RealParameter, ScalarOutcome, Constant, Model) from lakemodel_function import lake_problem import numpy as np import pandas as pd import seaborn as sns import matplotlib.pyplot as plt 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'),
deceased_population_region_1.append(deceased_population_region_1_NEXT) deceased_population_region_2.append(deceased_population_region_2_NEXT) # End of main code return { "TIME": runTime, "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),
prey_std_np = np.array(prey_std) # Create plots including subplots fig1 = plt.figure() fig1.tight_layout() fig1.set_size_inches(20, 10) ax1 = fig1.add_subplot(131) ax2 = fig1.add_subplot(132, sharey=ax1) ax3 = fig1.add_subplot(133, sharey=ax1) # Perform sobol analysis on experiment result using SALib for every output of interest perform_SALib_sobol(model, prey_final_np, "Final value of prey", ax1) perform_SALib_sobol(model, prey_mean_np, "Mean value of prey", ax2) perform_SALib_sobol(model, prey_std_np, "Standard deviation of prey", ax3) modelPredPrey = Model('PredPreyGSA', function=pred_prey) number_scenarios = 50 print("Performing {} scenarios:".format(number_scenarios)) perform_EMA_sobol_experiment(modelPredPrey, number_scenarios) number_scenarios = 250 print("Performing {} scenarios:".format(number_scenarios)) perform_EMA_sobol_experiment(modelPredPrey, number_scenarios) number_scenarios = 1000 print("Performing {} scenarios:".format(number_scenarios)) perform_EMA_sobol_experiment(modelPredPrey, number_scenarios)
G.add_node("E", activation=default, clamped=False) addEdge(G, ["C", "D"], "A", 1.0) G.add_edge("E", "B", weight=1.0) 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