def model_init(self, policy, kwargs): """ Init of the model, The provided implementation here assumes that `self.model_file` is set correctly. In case of using different vensim models for different policies, it is recomended to extent this method, extract the model file from the policy dict, set `self.model_file` to this file and then call this implementation through calling `super`. :param policy: a dict specifying the policy. In this implementation, this argument is ignored. :param kwargs: additional keyword arguments. In this implementation this argument is ignored. """ load_model(self.working_directory+self.model_file) #load the model ema_logging.debug("model initialized successfully") be_quiet() # minimize the screens that are shown try: initialTime = get_val('INITIAL TIME') finalTime = get_val('FINAL TIME') timeStep = get_val('TIME STEP') savePer = get_val('SAVEPER') if savePer > 0: timeStep = savePer self.runLength = int((finalTime - initialTime)/timeStep +1) except VensimWarning: raise EMAWarning(str(VensimWarning))
def test_save_results(): ema_logging.log_to_stderr(ema_logging.DEBUG) data = util.load_results("./data/1000 flu cases no policy.cPickle", zip=False) file_name = "test.bz2" util.save_results(data, file_name) os.remove(file_name) ema_logging.debug("removing " + file_name)
def _handle_outcomes(self, fns): for key, value in fns.iteritems(): if key in self.normal_handling: # voor "normale" globals werkt dit with open(value) as fh: result = fh.readline() result = result.strip() result = result.split() result = [float(entry) for entry in result] self.output[key] = np.asarray(result) elif key in self.once_handling: with open(value) as fh: result = fh.readline() # lees line die bestaat uit nullen en een list result = result.strip() #spaties weghalen result = result.strip('[')# haakje weghalen, welke alleen in de lijst nog zitten eventueel result = result.strip(']')# haakje weghalen, welke alleen in de lijst nog zitten eventueel result = result.split() # splitsen op elementen: nullen en een list results = np.zeros((self.run_length*10)) # lege array maken for j, entry in enumerate(result): if entry: entry = float(entry) else: entry = 0 results[j] = entry self.output[key] = results else: raise CaseError('no hander specified for {}'.format(key), {}) for value in fns.values(): ema_logging.debug('value: {}'.format(value)) try: os.remove(value) except WindowsError: pass
def experiment_generator(sampled_unc, model_structures, policies, sampler): ''' generator function which yields experiments ''' # experiment is made up of case, policy, and msi # to get case, we need msi for msi in model_structures: debug("generating designs for model %s" % (msi.name)) samples = [sampled_unc[unc.name] for unc in msi.uncertainties if\ sampled_unc.has_key(unc.name)] uncertainties = [unc.name for unc in msi.uncertainties if\ sampled_unc.has_key(unc.name)] for policy in policies: debug("generating designs for policy %s" % (policy['name'])) designs = sampler.generate_designs(samples) for design in designs: experiment = {uncertainties[i]: design[i] for i in\ range(len(uncertainties))} experiment['policy'] = policy experiment['model'] = msi.name yield experiment
def test_load_results(): data = np.random.rand(1000, 1000) file_name = "test.bz2" util.save_results(data, file_name) ema_logging.log_to_stderr(ema_logging.DEBUG) util.load_results(file_name) os.remove(file_name) ema_logging.debug("removing " + file_name)
def make_name(ind): keys = sorted(ind.keys()) try: keys.pop(keys.index('name')) except ValueError: ema_logging.debug("value error in make name, field 'name' not in list") name = "" for key in keys: name += " "+str(ind[key]) return name
def read_cin_file(file): ''' read a .cin file :param file: location of the .cin file. :exception: raises a :class:`~EMAExceptions.VensimWarning` if the cin file cannot be read. ''' ema_logging.debug("executing COMMAND: SIMULATE>READCIN|"+file) try: command(r"SIMULATE>READCIN|"+file) except VensimWarning as w: ema_logging.debug(str(w)) raise w
def run_model(self, case): for key, value in self.policy.items(): vensim.set_value(key, value) switches = case.pop("preference switches") case["SWITCH preference for MIC"] = switches[0] case["SWITCH preference for expected cost per MWe"]= switches[1] case["SWITCH preference against unknown"]= switches[2] case["SWITCH preference for expected progress"]= switches[3] case["SWITCH preference against specific CO2 emissions"]= switches[4] for key, value in case.items(): vensim.set_value(key, value) ema_logging.debug("model parameters set successfully") ema_logging.debug("run simulation, results stored in " + self.workingDirectory+self.resultFile) try: vensim.run_simulation(self.workingDirectory+self.resultFile) except VensimError: raise results = {} error = False for output in self.outcomes: ema_logging.debug("getting data for %s" %output.name) result = vensim.get_data(self.workingDirectory+self.resultFile, output.name ) ema_logging.debug("successfully retrieved data for %s" %output.name) if not result == []: if result.shape[0] != self.runLength: a = np.zeros((self.runLength)) a[0:result.shape[0]] = result result = a error = True else: result = result[0::self.step] try: results[output.name] = result except ValueError: print "what" a = results.keys() for output in self.activation: value = results[output.name] time = results["TIME"] activationTimeStep = time[value>0] if activationTimeStep.shape[0] > 0: activationTimeStep = activationTimeStep[0] else: activationTimeStep = np.array([0]) results[output.name] = activationTimeStep self.output = results if error: raise CaseError("run not completed", case)
def __store_result(self, result): for outcome in self.outcomes: try: outcome_res = result[outcome] except KeyError: ema_logging.debug("%s not in msi" % outcome) else: try: self.results[outcome][self.i-1, ] = outcome_res except KeyError: shape = np.asarray(outcome_res).shape shape = list(shape) shape.insert(0, self.nr_experiments) self.results[outcome] = np.empty(shape) self.results[outcome][:] = np.NAN self.results[outcome][self.i-1, ] = outcome_res
def load_model(file): ''' load the model :param file: the location of the .vpm file to be loaded. :exception: raises a :class:`~EMAExceptions.VensimError` if the model cannot be loaded. .. note: only works for .vpm files ''' ema_logging.debug("executing COMMAND: SIMULATE>SPECIAL>LOADMODEL|"+file) try: command(r"SPECIAL>LOADMODEL|"+file) except VensimWarning as w: ema_logging.warning(str(w)) raise VensimError("vensim file not found")
def run_model(self, case): for key, value in self.defaults.items(): case[key] = value replications = defaultdict(list) for i in range(self.nr_replications): ema_logging.debug('running replication {}'.format(i)) self._run_case(case) for key, value in self.output.items(): replications[key].append(value) for key, value in replications.items(): data = np.asarray(value) self.output[key + '_mean'] = np.mean(data, axis=0) self.output[key + '_std'] = np.std(data, axis=0)
def run_model(self, case): for key, value in self.defaults.items(): case[key] = value replications = defaultdict(list) for i in range(self.nr_replications): ema_logging.debug('running replication {}'.format(i)) self._run_case(case) for key, value in self.output.items(): replications[key].append(value) for key, value in replications.items(): data = np.asarray(value) self.output[key+'_mean'] = np.mean(data, axis=0) self.output[key+'_std'] = np.std(data, axis=0)
def __call__(self, case, policy, name, result): ''' Method responsible for storing results. The implementation in this class only keeps track of how many runs have been completed and logging this. :param case: the case to be stored :param policy: the name of the policy being used :param name: the name of the model being used :param result: the result dict ''' self.i+=1 debug(str(self.i)+" cases completed") if self.i % self.reporting_interval == 0: info(str(self.i)+" cases completed")
def __init__(self, working_directory, name): """interface to the model :param working_directory: working_directory for the model. :param name: name of the modelInterface. The name should contain only alphanumerical characters. .. note:: Anything that is relative to `self.working_directory` should be specified in `model_init` and not in `__init__`. Otherwise, the code will not work when running it in parallel. The reason for this is that the working directory is being updated by parallelEMA to the worker's separate working directory prior to calling `model_init`. """ super(VensimModelStructureInterface, self).__init__(working_directory, name) self.outcomes.append(Outcome('TIME' , time=True)) ema_logging.debug("vensim interface init completed")
def experiment_generator_predef_cases(designs, model_structures, policies): ''' generator function which yields experiments ''' # experiment is made up of case, policy, and msi # to get case, we need msi for msi in model_structures: debug("generating designs for model %s" % (msi.name)) for policy in policies: debug("generating designs for policy %s" % (policy['name'])) for experiment in designs: experiment['policy'] = copy.deepcopy(policy) experiment['model'] = msi.name yield experiment
def cleanup(self): ''' cleaning up prior to finishing performing experiments. This will close the workbook and close Excel. ''' ema_logging.debug("cleaning up") if self.wb: self.wb.Close(False) del self.wb if self.xl: self.xl.DisplayAlerts = False self.xl.Quit() del self.xl self.xl = None self.wb = None
def run_simulation(file): ''' Convenient function to run a model and store the results of the run in the specified .vdf file. The specified output file will be overwritten by default :param file: the location of the outputfile :exception: raises a :class:`~EMAExceptions.VensimError` if running the model failed in some way. ''' try: ema_logging.debug(" executing COMMAND: SIMULATE>RUNNAME|"+file+"|O") command("SIMULATE>RUNNAME|"+file+"|O") ema_logging.debug(r"MENU>RUN|o") command(r"MENU>RUN|o") except VensimWarning as w: ema_logging.warning((str(w))) raise VensimError(str(w))
def model_init(self, policy, kwargs): ''' :param policy: policy to be run, in the default implementation, this argument is ignored. Extent :meth:`model_init` to specify how this argument should be used. :param kwargs: keyword arguments to be used by :meth:`model_init` ''' if not self.xl: try: ema_logging.debug("trying to start Excel") self.xl = win32com.client.Dispatch("Excel.Application") ema_logging.debug("Excel started") except com_error as e: raise EMAError(str(e)) ema_logging.debug("trying to open workbook") self.wb = self.xl.Workbooks.Open(self.working_directory + self.workbook) ema_logging.debug("workbook opened") ema_logging.debug(self.working_directory)
def run_model(self, case): for key, value in case.items(): vensim.set_value(key, value) ema_logging.debug("model parameters set successfully") ema_logging.debug("run simulation, results stored in " + self.workingDirectory+self.resultFile) try: vensim.run_simulation(self.workingDirectory+self.resultFile) except VensimError: raise results = {} error = False for output in self.outcomes: ema_logging.debug("getting data for %s" %output.name) result = vensim.get_data(self.workingDirectory+self.resultFile, output.name ) ema_logging.debug("successfully retrieved data for %s" %output.name) if not result == []: if result.shape[0] != self.runLength: a = np.zeros((self.runLength)) a[0:result.shape[0]] = result result = a error = True else: result = result[0::self.step] try: results[output.name] = result except ValueError: print "what" self.output = results if error: raise CaseError("run not completed", case)
def perform_experiments(self, cases, callback=DefaultCallback, reporting_interval=100, model_kwargs = {}, which_uncertainties=INTERSECTION, which_outcomes=INTERSECTION, **kwargs): """ Method responsible for running the experiments on a structure. In case of multiple model structures, the outcomes are set to the intersection of the sets of outcomes of the various models. :param cases: In case of Latin Hypercube sampling and Monte Carlo sampling, cases specifies the number of cases to generate. In case of Full Factorial sampling, cases specifies the resolution to use for sampling continuous uncertainties. Alternatively, one can supply a list of dicts, where each dicts contains a case. That is, an uncertainty name as key, and its value. :param callback: Class that will be called after finishing a single experiment, :param reporting_interval: parameter for specifying the frequency with which the callback reports the progress. (Default is 100) :param model_kwargs: dictionary of keyword arguments to be passed to model_init :param which_uncertainties: keyword argument for controlling whether, in case of multiple model structure interfaces, the intersection or the union of uncertainties should be used. (Default is intersection). :param which_uncertainties: keyword argument for controlling whether, in case of multiple model structure interfaces, the intersection or the union of outcomes should be used. (Default is intersection). :param kwargs: generic keyword arguments to pass on to callback :returns: a `structured numpy array <http://docs.scipy.org/doc/numpy/user/basics.rec.html>`_ containing the experiments, and a dict with the names of the outcomes as keys and an numpy array as value. .. rubric:: suggested use In general, analysis scripts require both the structured array of the experiments and the dictionary of arrays containing the results. The recommended use is the following:: >>> results = ensemble.perform_experiments(10000) #recommended use >>> experiments, output = ensemble.perform_experiments(10000) The latter option will work fine, but most analysis scripts require to wrap it up into a tuple again:: >>> data = (experiments, output) Another reason for the recommended use is that you can save this tuple directly:: >>> import expWorkbench.util as util >>> util.save_results(results, filename) .. note:: The current implementation has a hard coded limit to the number of designs possible. This is set to 50.000 designs. If one want to go beyond this, set `self.max_designs` to a higher value. """ if not self._policies: self._policies.append({"name": "None"}) # identify the uncertainties and sample over them if type(cases) == types.IntType: sampled_unc, unc_dict = self._generate_samples(cases, which_uncertainties) nr_of_exp =self.sampler.deterimine_nr_of_designs(sampled_unc)\ *len(self._policies)*len(self._msis) experiments = self._generate_experiments(sampled_unc) elif type(cases) == types.ListType: unc_dict = self.determine_uncertainties()[1] unc_names = cases[0].keys() sampled_unc = {name:[] for name in unc_names} nr_of_exp = len(cases)*len(self._policies)*len(self._msis) experiments = self._generate_experiments(cases) else: raise EMAError("unknown type for cases") uncertainties = [unc_dict[unc] for unc in sorted(sampled_unc)] # identify the outcomes that are to be included overview_dict, element_dict = self._determine_unique_attributes("outcomes") if which_outcomes==UNION: outcomes = element_dict.keys() elif which_outcomes==INTERSECTION: outcomes = overview_dict[tuple([msi.name for msi in self._msis])] outcomes = [outcome.name for outcome in outcomes] else: raise ValueError("incomplete value for which_outcomes") info(str(nr_of_exp) + " experiment will be executed") #initialize the callback object callback = callback(uncertainties, outcomes, nr_of_exp, reporting_interval=reporting_interval, **kwargs) if self.parallel: info("preparing to perform experiment in parallel") if not self._pool: self._make_pool(model_kwargs) info("starting to perform experiments in parallel") self._pool.run_experiments(experiments, callback) else: info("starting to perform experiments sequentially") def cleanup(modelInterfaces): for msi in modelInterfaces: msi.cleanup() del msi msi_initialization_dict = {} msis = {msi.name: msi for msi in self._msis} job_counter = itertools.count() cwd = os.getcwd() for experiment in experiments: case_id = job_counter.next() policy = experiment.pop('policy') msi = experiment.pop('model') # check whether we already initialized the model for this # policy if not msi_initialization_dict.has_key((policy['name'], msi)): try: debug("invoking model init") msis[msi].model_init(copy.deepcopy(policy),\ copy.deepcopy(model_kwargs)) except (EMAError, NotImplementedError) as inst: exception(inst) cleanup(self._msis) raise except Exception: exception("some exception occurred when invoking the init") cleanup(self._msis) raise debug("initialized model %s with policy %s" % (msi, policy['name'])) #always, only a single initialized msi instance msi_initialization_dict = {(policy['name'], msi):msis[msi]} msi = msis[msi] case = copy.deepcopy(experiment) try: debug("trying to run model") msi.run_model(case) except CaseError as e: warning(str(e)) debug("trying to retrieve output") result = msi.retrieve_output() msi.reset_model() debug("trying to reset model") callback(case_id, experiment, policy, msi.name, result) cleanup(self._msis) os.chdir(cwd) results = callback.get_results() info("experiments finished") return results
def test_callback_store_results(): nr_experiments = 3 uncs = [ParameterUncertainty((0,1), "a"), ParameterUncertainty((0,1), "b")] outcomes = [Outcome("test", time=True)] case = {unc.name:random.random() for unc in uncs} policy = {'name':'none'} name = "test" # case 1 scalar shape = (1) debug('----------- case 1 -----------') callback = DefaultCallback(uncs, [outcome.name for outcome in outcomes], nr_experiments=nr_experiments) result = {outcomes[0].name: 1} callback(case, policy, name, result) results = callback.get_results() for key, value in results[1].iteritems(): debug("\n" + str(key) + "\n" + str(value)) # case 2 time series shape = (1, nr_time_steps) debug('----------- case 2 -----------') callback = DefaultCallback(uncs, [outcome.name for outcome in outcomes], nr_experiments=nr_experiments) result = {outcomes[0].name: np.random.rand(10)} callback(case, policy, name, result) results = callback.get_results() for key, value in results[1].iteritems(): debug("\n" + str(key) + "\n" + str(value)) # case 3 maps etc. shape = (x,y) debug('----------- case 3 -----------') callback = DefaultCallback(uncs, [outcome.name for outcome in outcomes], nr_experiments=nr_experiments) result = {outcomes[0].name: np.random.rand(2,2)} callback(case, policy, name, result) results = callback.get_results() for key, value in results[1].iteritems(): debug("\n" + str(key) + "\n" + str(value)) # case 4 maps etc. shape = (x,y) debug('----------- case 4 -----------') callback = DefaultCallback(uncs, [outcome.name for outcome in outcomes], nr_experiments=nr_experiments) result = {outcomes[0].name: np.random.rand(2,2, 2)} callback(case, policy, name, result)
def test_callback_call_union(): # there are actually 3 cases that should be tested here # union unc, intersection outcomes # intersection unc, union outcomes # union unc, union outcomes # case 1 union unc, intersection outcomes # debug('----------- case 1 -----------') # nr_experiments = 10 # uncs = [ParameterUncertainty((0,1), "a"), # ParameterUncertainty((0,1), "b")] # outcomes = [Outcome("test", time=True)] # callback = DefaultCallback(uncs, outcomes, nr_experiments=nr_experiments) # # policy = {"name": "none"} # name = "test" # # for i in range(nr_experiments): # if i % 2 == 0: # case = {uncs[0].name: np.random.rand(1)} # else: # case = {uncs[1].name: np.random.rand(1)} # result = {outcome.name: np.random.rand(10) for outcome in outcomes} # # callback(case, policy, name, result) # # results = callback.get_results() # debug("\n"+str(results[0])) debug('----------- case 2 -----------') # nr_experiments = 10 # uncs = [ParameterUncertainty((0,1), "a"), # ParameterUncertainty((0,1), "b")] # outcomes = [Outcome("test 1", time=True), # Outcome("test 2", time=True)] # callback = DefaultCallback(uncs, outcomes, nr_experiments=nr_experiments) # # policy = {"name": "none"} # name = "test" # # for i in range(nr_experiments): # case = {unc.name: random.random()for unc in uncs} # if i % 2 == 0: # result = {outcomes[0].name: np.random.rand(10)} # else: # result = {outcomes[1].name: np.random.rand(10)} # # callback(case, policy, name, result) # debug('----------- case 3 -----------') nr_experiments = 10 uncs = [ParameterUncertainty((0,1), "a"), ParameterUncertainty((0,1), "b")] outcomes = [Outcome("test 1", time=True), Outcome("test 2", time=True)] callback = DefaultCallback(uncs, outcomes, nr_experiments=nr_experiments) policy = {"name": "none"} name = "test" for i in range(nr_experiments): if i % 2 == 0: case = {uncs[0].name: random.random()} result = {outcomes[0].name: np.random.rand(10)} else: case = {uncs[1].name: random.random()} result = {outcomes[1].name: np.random.rand(10)} callback(case, policy, name, result) results = callback.get_results() debug("\n"+str(results[0])) for key, value in results[1].iteritems(): debug("\n" + str(key) + "\n" + str(value))
def envelopes(results, outcomes_to_show = [], group_by = None, grouping_specifiers = None, density='', fill=False, legend=True, titles={}, ylabels={}, **kwargs): ''' Make envelop plots. An envelope shows over time the minimum and maximum value for a set of runs over time. It is thus to be used in case of time series data. The function will try to find a result labeled "TIME". If this is present, these values will be used on the X-axis. In case of Vensim models, TIME is present by default. :param results: return from :meth:`perform_experiments`. :param outcomes_to_show: list of outcome of interest you want to plot. If empty, all outcomes are plotted. **Note**: just names. :param group_by: name of the column in the cases array to group results by. Alternatively, `index` can be used to use indexing arrays as the basis for grouping. :param grouping_specifiers: set of categories to be used as a basis for grouping by. Grouping_specifiers is only meaningful if group_by is provided as well. In case of grouping by index, the grouping specifiers should be in a dictionary where the key denotes the name of the group. :param density: boolean, if true, the density of the endstates will be plotted. :param fill: boolean, if true, fill the envelope. :param legend: boolean, if true, and there is a column specified for grouping, show a legend. :param titles: a way for controlling whether each of the axes should have a title. There are three possibilities. If set to None, no title will be shown for any of the axes. If set to an empty dict, the default, the title is identical to the name of the outcome of interest. If you want to override these default names, provide a dict with the outcome of interest as key and the desired title as value. This dict need only contain the outcomes for which you want to use a different title. :param ylabels: a way for controlling the ylabels. Works identical to titles. :rtype: a `figure <http://matplotlib.sourceforge.net/api/figure_api.html>`_ instance and a dict with the individual axes. Additional key word arguments will be passed along to the density function, if density is `True`. ======== =================================== property description ======== =================================== log log the resulting histogram or GKDE ======== =================================== .. rubric:: an example of use >>> import expWorkbench.util as util >>> data = util.load_results(r'1000 flu cases.cPickle') >>> envelopes(data, column='policy') will show an envelope for three three different policies, for all the outcomes of interest. .. plot:: ../docs/source/pyplots/basicEnvelope.py while >>> envelopes(data, column='policy', categories=['static policy', 'adaptive policy']) will only show results for the two specified policies, ignoring any results associated with \'no policy\'. .. plot:: ../docs/source/pyplots/basicEnvelope2.py .. note:: the current implementation is limited to seven different categories in case of column, categories, and/or discretesize. This limit is due to the colors specified in COLOR_LIST. ''' debug("generating envelopes") prepared_data = prepare_data(results, outcomes_to_show, group_by, grouping_specifiers) outcomes, outcomes_to_show, time, grouping_labels = prepared_data figure, grid = make_grid(outcomes_to_show, density) # do the plotting axes_dict = {} for i, outcome_to_plot in enumerate(outcomes_to_show): ax = figure.add_subplot(grid[i,0]) axes_dict[outcome_to_plot] = ax ax_d= None if density: ax_d = figure.add_subplot(grid[i,1]) axes_dict[outcome_to_plot+"_density"] = ax_d if group_by: # group_labels = sorted(outcomes.keys()) group_by_envelopes(outcomes,outcome_to_plot, time, density, ax, ax_d, fill, grouping_labels, **kwargs) else: single_envelope(outcomes, outcome_to_plot, time, density, ax, ax_d, fill, **kwargs) if ax_d: for tl in ax_d.get_yticklabels(): tl.set_visible(False) ax.set_xlabel(TIME_LABEL) do_ylabels(ax, ylabels, outcome_to_plot) do_titles(ax, titles, outcome_to_plot) if legend and group_by: make_legend(grouping_labels, figure) if plotting_util.TIGHT: grid.tight_layout(figure) return figure, axes_dict
def lines(results, outcomes_to_show = [], group_by = None, grouping_specifiers = None, density='', titles={}, ylabels={}, legend=True, experiments_to_show=None, show_envelope=False, **kwargs): ''' This function takes the results from :meth:`perform_experiments` and visualizes these as line plots. It is thus to be used in case of time series data. The function will try to find a result labeled "TIME". If this is present, these values will be used on the X-axis. In case of Vensim models, TIME is present by default. :param results: return from :meth:`perform_experiments`. :param outcomes_to_show: list of outcome of interest you want to plot. If empty, all outcomes are plotted. **Note**: just names. :param group_by: name of the column in the cases array to group results by. Alternatively, `index` can be used to use indexing arrays as the basis for grouping. :param grouping_specifiers: set of categories to be used as a basis for grouping by. Grouping_specifiers is only meaningful if group_by is provided as well. In case of grouping by index, the grouping specifiers should be in a dictionary where the key denotes the name of the group. :param density: boolean, if true, the density of the endstates will be plotted. :param legend: boolean, if true, and there is a column specified for grouping, show a legend. :param titles: a way for controlling whether each of the axes should have a title. There are three possibilities. If set to None, no title will be shown for any of the axes. If set to an empty dict, the default, the title is identical to the name of the outcome of interest. If you want to override these default names, provide a dict with the outcome of interest as key and the desired title as value. This dict need only contain the outcomes for which you want to use a different title. :param ylabels: a way for controlling the ylabels. Works identical to titles. :param experiments_to_show: numpy array containing the indices of the experiments to be visualized. Defaults to None, implying that all experiments should be shown. :param show_envelope: boolean, indicates whether envelopes should be plotted in combination with lines. Default is False. :rtype: a `figure <http://matplotlib.sourceforge.net/api/figure_api.html>`_ instance and a dict with the individual axes. .. note:: the current implementation is limited to seven different categories in case of column, categories, and/or discretesize. This limit is due to the colors specified in COLOR_LIST. ''' debug("generating line graph") if show_envelope: return plot_lines_with_envelopes(results, outcomes_to_show=outcomes_to_show, group_by=group_by, legend=legend, density=density, grouping_specifiers=grouping_specifiers, experiments_to_show=experiments_to_show, titles=titles, ylabels=ylabels, **kwargs) if experiments_to_show != None: experiments, outcomes = results experiments = experiments[experiments_to_show] new_outcomes = {} for key, value in outcomes.items(): new_outcomes[key] = value[experiments_to_show] results = experiments, new_outcomes data = prepare_data(results, outcomes_to_show, group_by, grouping_specifiers) outcomes, outcomes_to_show, time, grouping_labels = data figure, grid = make_grid(outcomes_to_show, density) axes_dict = {} # do the plotting for i, outcome_to_plot in enumerate(outcomes_to_show): ax = figure.add_subplot(grid[i,0]) axes_dict[outcome_to_plot] = ax ax_d= None if density: ax_d = figure.add_subplot(grid[i,1]) axes_dict[outcome_to_plot+"_density"] = ax_d for tl in ax_d.get_yticklabels(): tl.set_visible(False) if group_by: # group_by_labels = sorted(outcomes.keys()) group_by_lines(outcomes,outcome_to_plot, time, density, ax, ax_d, grouping_labels, **kwargs) else: simple_lines(outcomes, outcome_to_plot, time, density, ax, ax_d, **kwargs) ax.set_xlabel(TIME_LABEL) do_ylabels(ax, ylabels, outcome_to_plot) do_titles(ax, titles, outcome_to_plot) if legend and group_by: make_legend(grouping_labels, figure) if plotting_util.TIGHT: grid.tight_layout(figure) return figure, axes_dict
class EnergyTrans(VensimModelStructureInterface): def __init__(self, workingDirectory, name): """interface to the model""" super(EnergyTrans, self).__init__(workingDirectory, name) self.modelFile = r'\CESUN_optimized_new.vpm' #outcomes self.outcomes.append( Outcome('total fraction new technologies', time=True)) self.outcomes.append(Outcome('total capacity installed', time=True)) #Initial values self.uncertainties.append( ParameterUncertainty((14000, 16000), "ini cap T1")) # self.uncertainties.append(ParameterUncertainty((1, 2), "ini cap T2")) # self.uncertainties.append(ParameterUncertainty((1, 2), "ini cap T3")) # self.uncertainties.append(ParameterUncertainty((1, 2), "ini cap T4")) # self.uncertainties.append( ParameterUncertainty((500000, 1500000), "ini cost T1")) #1000000 self.uncertainties.append( ParameterUncertainty((5000000, 10000000), "ini cost T2")) #8000000 self.uncertainties.append( ParameterUncertainty((5000000, 10000000), "ini cost T3")) #8000000 self.uncertainties.append( ParameterUncertainty((5000000, 10000000), "ini cost T4")) #8000000 self.uncertainties.append( ParameterUncertainty((5000000, 10000000), "ini cum decom cap T1")) self.uncertainties.append( ParameterUncertainty((1, 100), "ini cum decom cap T2")) self.uncertainties.append( ParameterUncertainty((1, 100), "ini cum decom cap T3")) self.uncertainties.append( ParameterUncertainty((1, 100), "ini cum decom cap T4")) self.uncertainties.append( ParameterUncertainty( (1, 5), "average planning and construction period T1")) self.uncertainties.append( ParameterUncertainty( (1, 5), "average planning and construction period T2")) self.uncertainties.append( ParameterUncertainty( (1, 5), "average planning and construction period T3")) self.uncertainties.append( ParameterUncertainty( (1, 5), "average planning and construction period T4")) self.uncertainties.append( ParameterUncertainty((0.85, 0.95), "ini PR T1")) self.uncertainties.append( ParameterUncertainty((0.7, 0.95), "ini PR T2")) self.uncertainties.append( ParameterUncertainty((0.7, 0.95), "ini PR T3")) self.uncertainties.append( ParameterUncertainty((0.7, 0.95), "ini PR T4")) #Plain Parametric Uncertainties self.uncertainties.append(ParameterUncertainty((30, 50), "lifetime T1")) self.uncertainties.append(ParameterUncertainty((15, 20), "lifetime T2")) self.uncertainties.append(ParameterUncertainty((15, 20), "lifetime T3")) self.uncertainties.append(ParameterUncertainty((15, 20), "lifetime T4")) # # #One uncertain development over time -- smoothed afterwards self.uncertainties.append( ParameterUncertainty((0.03, 0.035), "ec gr t1")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t2")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t3")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t4")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t5")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t6")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t7")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t8")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t9")) #0.03 self.uncertainties.append( ParameterUncertainty((-0.01, 0.03), "ec gr t10")) #0.03 #Uncertainties in Random Functions self.uncertainties.append( ParameterUncertainty((0.9, 1), "random PR min")) self.uncertainties.append( ParameterUncertainty((1, 1.1), "random PR max")) self.uncertainties.append( ParameterUncertainty((1, 100), "seed PR T1", integer=True)) self.uncertainties.append( ParameterUncertainty((1, 100), "seed PR T2", integer=True)) self.uncertainties.append( ParameterUncertainty((1, 100), "seed PR T3", integer=True)) self.uncertainties.append( ParameterUncertainty((1, 100), "seed PR T4", integer=True)) #Uncertainties in Preference Functions self.uncertainties.append( ParameterUncertainty((2, 5), "absolute preference for MIC")) self.uncertainties.append( ParameterUncertainty( (1, 3), "absolute preference for expected cost per MWe")) self.uncertainties.append( ParameterUncertainty((2, 5), "absolute preference against unknown")) self.uncertainties.append( ParameterUncertainty((1, 3), "absolute preference for expected progress")) self.uncertainties.append( ParameterUncertainty( (2, 5), "absolute preference against specific CO2 emissions")) #TOEVOEGEN SWITCHES ZODAT BOVENSTAANDE CRITERIA WEL OF NIET GEBRUIKT WORDEN... self.uncertainties.append( CategoricalUncertainty((0, 1), "SWITCH preference for MIC", default=1)) self.uncertainties.append( CategoricalUncertainty( (0, 1), "SWITCH preference for expected cost per MWe", default=0)) self.uncertainties.append( CategoricalUncertainty((0, 1), "SWITCH preference against unknown", default=0)) self.uncertainties.append( CategoricalUncertainty((0, 1), "SWITCH preference for expected progress", default=0)) self.uncertainties.append( CategoricalUncertainty( (0, 1), "SWITCH preference against specific CO2 emissions", default=0)) #Uncertainties DIE NOG AANGEPAST MOETEN WORDEN self.uncertainties.append( ParameterUncertainty((1, 2), "performance expected cost per MWe T1")) self.uncertainties.append( ParameterUncertainty((1, 5), "performance expected cost per MWe T2")) self.uncertainties.append( ParameterUncertainty((1, 5), "performance expected cost per MWe T3")) self.uncertainties.append( ParameterUncertainty((1, 5), "performance expected cost per MWe T4")) self.uncertainties.append( ParameterUncertainty((4, 5), "performance CO2 avoidance T1")) self.uncertainties.append( ParameterUncertainty((1, 5), "performance CO2 avoidance T2")) self.uncertainties.append( ParameterUncertainty((1, 5), "performance CO2 avoidance T3")) self.uncertainties.append( ParameterUncertainty((1, 5), "performance CO2 avoidance T4")) # #Switches op technologies self.uncertainties.append( CategoricalUncertainty((0, 1), "SWITCH T3", default=1)) self.uncertainties.append( CategoricalUncertainty((0, 1), "SWITCH T4", default=1)) self.uncertainties.append( CategoricalUncertainty(([(0, 0, 0, 0, 1), (0, 0, 0, 1, 0), (0, 0, 0, 1, 1), (0, 0, 1, 0, 0), (0, 0, 1, 0, 1), (0, 0, 1, 1, 0), (0, 0, 1, 1, 1), (0, 1, 0, 0, 0), (0, 1, 0, 0, 1), (0, 1, 0, 1, 0), (0, 1, 0, 1, 1), (0, 1, 1, 0, 0), (0, 1, 1, 0, 1), (0, 1, 1, 1, 0), (0, 1, 1, 1, 1), (1, 0, 0, 0, 0), (1, 0, 0, 0, 1), (1, 0, 0, 1, 0), (1, 0, 0, 1, 1), (1, 0, 1, 0, 0), (1, 0, 1, 0, 1), (1, 0, 1, 1, 0), (1, 0, 1, 1, 1), (1, 1, 0, 0, 0), (1, 1, 0, 0, 1), (1, 1, 0, 1, 0), (1, 1, 0, 1, 1), (1, 1, 1, 0, 0), (1, 1, 1, 0, 1), (1, 1, 1, 1, 0), (1, 1, 1, 1, 1)]), "preference switches")) #switch for addfactor activation # self.uncertainties.append(CategoricalUncertainty((0,1), "switchaddfactorco2", default = 1)) def model_init(self, policy, kwargs): try: self.modelFile = policy['file'] except: logging.debug("no policy specified") super(EnergyTrans, self).model_init(policy, kwargs) def run_model(self, case): switches = case.pop("preference switches") case["SWITCH preference for MIC"] = switches[0] case["SWITCH preference for expected cost per MWe"] = switches[1] case["SWITCH preference against unknown"] = switches[2] case["SWITCH preference for expected progress"] = switches[3] case["SWITCH preference against specific CO2 emissions"] = switches[4] if np.sum(switches) == 0: print "sifir olan cikti haci!" for key, value in case.items(): vensim.set_value(key, value) ema_logging.debug("model parameters set successfully") ema_logging.debug("run simulation, results stored in " + self.workingDirectory + self.resultFile) try: vensim.run_simulation(self.workingDirectory + self.resultFile) except VensimError as e: raise results = {} error = False for output in self.outcomes: ema_logging.debug("getting data for %s" % output.name) result = vensim.get_data(self.workingDirectory + self.resultFile, output.name) ema_logging.debug("successfully retrieved data for %s" % output.name) if not result == []: if result.shape[0] != self.runLength: a = np.zeros((self.runLength)) a[0:result.shape[0]] = result result = a error = True else: result = result[0::self.step] try: results[output.name] = result except ValueError as e: print "what" # for output in self.activation: # value = results[output.name] # time = results["TIME"] # activationTimeStep = time[value>0] # if len(activationTimeStep) > 0: # activationTimeStep = activationTimeStep[0] # else: # activationTimeStep = np.array([0]) ## if activationTimeStep.shape[0] > 0: ## activationTimeStep = activationTimeStep ## else: ## activationTimeStep = np.array([0]) # results[output.name] = activationTimeStep self.output = results if error: raise CaseError("run not completed", case)
def _run_optimization(self, toolbox, generate_individual, evaluate_population, attr_list, keys, obj_function, pop_size, reporting_interval, weights, nr_of_generations, crossover_rate, mutation_rate, levers, caching, **kwargs): ''' Helper function that runs the actual optimization :param toolbox: :param generate_individual: helper function for generating an individual :param evaluate_population: helper function for evaluating the population :param attr_list: list of attributes (alleles) :param keys: the names of the attributes in the same order as attr_list :param obj_function: the objective function :param pop_size: the size of the population :param reporting_interval: the interval for reporting progress, passed on to perform_experiments :param weights: the weights on the outcomes :param nr_of_generations: number of generations for which the GA will be run :param crossover_rate: the crossover rate of the GA :param mutation_rate: the muation rate of the GA :param levers: a dictionary with param keys as keys, and as values info used in mutation. ''' # figure out whether we are doing single or multi-objective # optimization #TODO raise error if not specified single_obj = True if len(weights) >1: single_obj=False # Structure initializers toolbox.register("individual", generate_individual, creator.Individual, #@UndefinedVariable attr_list, keys=keys) toolbox.register("population", tools.initRepeat, list, toolbox.individual) # Operator registering toolbox.register("evaluate", obj_function) toolbox.register("crossover", tools.cxOnePoint) toolbox.register("mutate", mut_polynomial_bounded) if single_obj: toolbox.register("select", tools.selTournament) else: toolbox.register("select", tools.selNSGA2) # generate population # for some stupid reason, DEAP demands a multiple of four for # population size in case of NSGA-2 pop_size = closest_multiple_of_four(pop_size) info("population size restricted to %s " % (pop_size)) pop = toolbox.population(pop_size) debug("Start of evolution") # Evaluate the entire population evaluate_population(pop, reporting_interval, toolbox, self) if not single_obj: # This is just to assign the crowding distance to the individuals tools.assignCrowdingDist(pop) #some statistics logging stats_callback = NSGA2StatisticsCallback(weights=weights, nr_of_generations=nr_of_generations, crossover_rate=crossover_rate, mutation_rate=mutation_rate, pop_size=pop_size, caching=caching) stats_callback(pop) stats_callback.log_stats(0) # Begin the generational process for gen in range(nr_of_generations): pop = self._run_geneneration(pop, crossover_rate, mutation_rate, toolbox, reporting_interval, levers, evaluate_population, keys, single_obj, stats_callback, caching, **kwargs) stats_callback(pop) stats_callback.log_stats(gen) info("-- End of (successful) evolution --") return stats_callback, pop
def run_interval(model,loop_index,interval,VOI,edges,ind_cons, double_list,case): # Load the model. vensim.load_model(model) case = copy.deepcopy(case) set_lookups(case) for key,value in case.items(): vensim.set_value(key,repr(value)) # print key, repr(value), vensim.get_val(key), value-vensim.get_val(key) # We run the model in game mode. step = vensim.get_val(r'TIME STEP') start_interval = interval[0]*step end_interval = interval[1]*step venDLL.command('GAME>GAMEINTERVAL|'+str(start_interval)) # Initiate the model to be run in game mode. venDLL.command("MENU>GAME") if start_interval > 0: venDLL.command('GAME>GAMEON') loop_on = 1 loop_off = 0 loop_turned_off = False while True: # Initiate the experiment of interest. # In other words set the uncertainties to the same value as in # those experiments. time = vensim.get_val(r'TIME') ema_logging.debug(time) if time ==(2000+step*interval[0]) and not loop_turned_off: loop_turned_off = True if loop_index != 0: # If loop elimination method is based on unique edge. if loop_index-1 < ind_cons: constant_value = vensim.get_val(edges[int(loop_index-1)][0]) if loop_off==1: constant_value = 0 vensim.set_value('value loop '+str(loop_index), constant_value) vensim.set_value('switch loop '+str(loop_index), loop_off) # Else it is based on unique consecutive edges. else: constant_value = vensim.get_val(edges[int(loop_index-1)][0]) if loop_off==1: constant_value = 0 # Name of constant value used does not fit loop index minus 'start of cons'-index. if loop_index-ind_cons in double_list: vensim.set_value('value cons loop '+str(loop_index-ind_cons-1), constant_value) vensim.set_value('switch cons loop '+str(loop_index-ind_cons-1), loop_off) else: vensim.set_value('value cons loop '+str(loop_index-ind_cons), constant_value) vensim.set_value('switch cons loop '+str(loop_index-ind_cons), loop_off) venDLL.command('GAME>GAMEINTERVAL|'+str(end_interval-start_interval)) elif time ==(2000+step*interval[1]) and loop_turned_off: loop_turned_off = False if loop_index != 0: # If loop elimination method is based on unique edge. if loop_index-1 < ind_cons: constant_value = 0 vensim.set_value('value loop '+str(loop_index), constant_value) vensim.set_value('switch loop '+str(loop_index), loop_on) # Else it is based on unique consecutive edges. else: constant_value = 0 # Name of constant value used does not fit loop index minus 'start of cons'-index. if loop_index-ind_cons in double_list: vensim.set_value('value cons loop '+str(loop_index-ind_cons-1), constant_value) vensim.set_value('switch cons loop '+str(loop_index-ind_cons-1), loop_on) else: vensim.set_value('value cons loop '+str(loop_index-ind_cons), constant_value) vensim.set_value('switch cons loop '+str(loop_index-ind_cons), loop_on) finalT = vensim.get_val('FINAL TIME') currentT = vensim.get_val('TIME') venDLL.command('GAME>GAMEINTERVAL|'+str(finalT - currentT)) else: break finalT = vensim.get_val('FINAL TIME') currentT = vensim.get_val('TIME') if finalT != currentT: venDLL.command('GAME>GAMEON') venDLL.command('GAME>ENDGAME') interval_series = vensim.get_data('Base.vdf',VOI) return interval_series
def pairs_density(results, outcomes_to_show = [], group_by = None, grouping_specifiers = None, ylabels = {}, point_in_time=-1, log=True, gridsize=50, colormap='jet', filter_scalar=True): ''' Generate a `R style pairs <http://www.stat.psu.edu/~dhunter/R/html/graphics/html/pairs.html>`_ hexbin density multiplot. In case of time-series data, the end states are used. hexbin makes hexagonal binning plot of x versus y, where x, y are 1-D sequences of the same length, N. If C is None (the default), this is a histogram of the number of occurences of the observations at (x[i],y[i]). For further detail see `matplotlib on hexbin <http://matplotlib.sourceforge.net/api/pyplot_api.html#matplotlib.pyplot.hexbin>`_ :param results: return from perform_experiments. :param outcomes_to_show: list of outcome of interest you want to plot. If empty, all outcomes are plotted. :param group_by: name of the column in the cases array to group results by. Alternatively, `index` can be used to use indexing arrays as the basis for grouping. :param grouping_specifiers: set of categories to be used as a basis for grouping by. Grouping_specifiers is only meaningful if group_by is provided as well. In case of grouping by index, the grouping specifiers should be in a dictionary where the key denotes the name of the group. :param ylabels: ylabels is a dictionary with the outcome names as keys, the specified values will be used as labels for the y axis. :param point_in_time: the point in time at which the scatter is to be made. If None is provided, the end states are used. point_in_time should be a valid value on time :param log: boolean, indicating whether density should be log scaled. Defaults to True. :param gridsize: controls the gridsize for the hexagonal binning :param cmap: color map that is to be used in generating the hexbin. For details on the available maps, see `pylab <http://matplotlib.sourceforge.net/examples/pylab_examples/show_colormaps.html#pylab-examples-show-colormaps>`_. (Defaults = jet) :param filter_scalar: boolean, remove the non-time-series outcomes. Defaults to True. :rtype: a `figure <http://matplotlib.sourceforge.net/api/figure_api.html>`_ instance and a dict with the individual axes. ''' debug("generating pairwise density plot") prepared_data = prepare_pairs_data(results, outcomes_to_show, group_by, grouping_specifiers, point_in_time, filter_scalar) outcomes, outcomes_to_show, grouping_specifiers = prepared_data if group_by: #figure out the extents for each combination extents = determine_extents(outcomes, outcomes_to_show) axes_dicts = {} figures = [] for key, value in outcomes.items(): figure, axes_dict = simple_pairs_density(value, outcomes_to_show, log, colormap, gridsize, ylabels, extents=extents, title=key) axes_dicts[key] = axes_dict figures.append(figure) # harmonize the color scaling across figures combis = [(field1, field2) for field1 in outcomes_to_show\ for field2 in outcomes_to_show] for combi in combis: vmax = -1 for entry in axes_dicts.values(): vmax = max(entry[combi].collections[0].norm.vmax, vmax) for entry in axes_dicts.values(): ax = entry[combi] ax.collections[0].set_clim(vmin=0, vmax=vmax) del vmax return figures, axes_dicts else: return simple_pairs_density(outcomes, outcomes_to_show, log, colormap, gridsize, ylabels)
def pairs_scatter(results, outcomes_to_show = [], group_by = None, grouping_specifiers = None, ylabels = {}, legend=True, point_in_time=-1, filter_scalar=True, **kwargs): ''' Generate a `R style pairs <http://www.stat.psu.edu/~dhunter/R/html/graphics/html/pairs.html>`_ scatter multiplot. In case of time-series data, the end states are used. :param results: return from perform_experiments. :param outcomes_to_show: list of outcome of interest you want to plot. If empty, all outcomes are plotted. :param group_by: name of the column in the cases array to group results by. Alternatively, `index` can be used to use indexing arrays as the basis for grouping. :param grouping_specifiers: set of categories to be used as a basis for grouping by. Grouping_specifiers is only meaningful if group_by is provided as well. In case of grouping by index, the grouping specifiers should be in a dictionary where the key denotes the name of the group. :param ylabels: ylabels is a dictionary with the outcome names as keys, the specified values will be used as labels for the y axis. :param legend: boolean, if true, and there is a column specified for grouping, show a legend. :param point_in_time: the point in time at which the scatter is to be made. If None is provided, the end states are used. point_in_time should be a valid value on time :param filter_scalar: boolean, remove the non-time-series outcomes. Defaults to True. :rtype: a `figure <http://matplotlib.sourceforge.net/api/figure_api.html>`_ instance and a dict with the individual axes. .. note:: the current implementation is limited to seven different categories in case of column, categories, and/or discretesize. This limit is due to the colors specified in COLOR_LIST. ''' debug("generating pairwise scatter plot") prepared_data = prepare_pairs_data(results, outcomes_to_show, group_by, grouping_specifiers, point_in_time, filter_scalar) outcomes, outcomes_to_show, grouping_labels = prepared_data grid = gridspec.GridSpec(len(outcomes_to_show), len(outcomes_to_show)) grid.update(wspace = 0.1, hspace = 0.1) #the plotting figure = plt.figure() axes_dict = {} if group_by and legend: make_legend(grouping_labels, figure, legend_type='scatter') combis = [(field1, field2) for field1 in outcomes_to_show\ for field2 in outcomes_to_show] for field1, field2 in combis: i = outcomes_to_show.index(field1) j = outcomes_to_show.index(field2) ax = figure.add_subplot(grid[i,j]) axes_dict[(field1, field2)] = ax if group_by: for x, group in enumerate(grouping_labels): y_data = outcomes[group][field1] x_data = outcomes[group][field2] facecolor = COLOR_LIST[x] edgecolor = 'k' if i==j: facecolor = 'white' edgecolor = 'white' ax.scatter(x_data, y_data, facecolor=facecolor, edgecolor=edgecolor) else: y_data = outcomes[field1] x_data = outcomes[field2] facecolor = 'b' edgecolor = 'k' if i==j: facecolor = 'white' edgecolor = 'white' ax.scatter(x_data, y_data, facecolor=facecolor, edgecolor=edgecolor) do_text_ticks_labels(ax, i, j, field1, field2, ylabels, outcomes_to_show) return figure, axes_dict
def run_model(self, case): """ Method for running an instantiated model structure. the provided implementation assumes that the keys in the case match the variable names in the Vensim model. If lookups are to be set specify their transformation from uncertainties to lookup values in the extension of this method, then call this one using super with the updated case dict. if you want to use cinFiles, set the cin_file, or cinFiles in the extension of this method to `self.cin_file`. :param case: the case to run .. note:: setting parameters should always be done via run_model. The model is reset to its initial values automatically after each run. """ if self.cin_file: try: read_cin_file(self.working_directory+self.cin_file) except VensimWarning as w: ema_logging.debug(str(w)) else: ema_logging.debug("cin file read successfully") for lookup_uncertainty in self.lookup_uncertainties: # ask the lookup to transform the retreived uncertainties to the # proper lookup value case[lookup_uncertainty.name] = lookup_uncertainty.transform(case) for key, value in case.items(): set_value(key, value) ema_logging.debug("model parameters set successfully") ema_logging.debug("run simulation, results stored in " + self.working_directory+self.result_file) try: run_simulation(self.working_directory+self.result_file) except VensimError: raise results = {} error = False for output in self.outcomes: ema_logging.debug("getting data for %s" %output.name) result = get_data(self.working_directory+self.result_file, output.name ) ema_logging.debug("successfully retrieved data for %s" %output.name) if not result == []: if result.shape[0] != self.runLength: got = result.shape[0] a = np.zeros((self.runLength)) a[0:result.shape[0]] = result result = a error = True if not output.time: result = [-1] else: result = result[0::self.step] try: results[output.name] = result except ValueError as e: print "what" raise e self.output = results if error: raise CaseError("run not completed, got %s, expected %s" % (got, self.runLength), case)
def model_init(self, policy, kwargs): try: self.modelFile = policy['file'] except: logging.debug("no policy specified") super(EnergyTrans, self).model_init(policy, kwargs)
def pairs_lines(results, outcomes_to_show = [], group_by = None, grouping_specifiers = None, ylabels = {}, legend=True, **kwargs): ''' Generate a `R style pairs <http://www.stat.psu.edu/~dhunter/R/html/graphics/html/pairs.html>`_ lines multiplot. It shows the behavior of two outcomes over time against each other. The origin is denoted with a circle and the end is denoted with a '+'. :param results: return from perform_experiments. :param outcomes_to_show: list of outcome of interest you want to plot. If empty, all outcomes are plotted. :param group_by: name of the column in the cases array to group results by. Alternatively, `index` can be used to use indexing arrays as the basis for grouping. :param grouping_specifiers: set of categories to be used as a basis for grouping by. Grouping_specifiers is only meaningful if group_by is provided as well. In case of grouping by index, the grouping specifiers should be in a dictionary where the key denotes the name of the group. :param ylabels: ylabels is a dictionary with the outcome names as keys, the specified values will be used as labels for the y axis. :param legend: boolean, if true, and there is a column specified for grouping, show a legend. :param point_in_time: the point in time at which the scatter is to be made. If None is provided, the end states are used. point_in_time should be a valid value on time :rtype: a `figure <http://matplotlib.sourceforge.net/api/figure_api.html>`_ instance and a dict with the individual axes. ''' #unravel return from run_experiments debug("making a pars lines plot") prepared_data = prepare_pairs_data(results, outcomes_to_show, group_by, grouping_specifiers, None) outcomes, outcomes_to_show, grouping_labels = prepared_data grid = gridspec.GridSpec(len(outcomes_to_show), len(outcomes_to_show)) grid.update(wspace = 0.1, hspace = 0.1) #the plotting figure = plt.figure() axes_dict = {} if group_by and legend: make_legend(grouping_labels, figure) combis = [(field1, field2) for field1 in outcomes_to_show\ for field2 in outcomes_to_show] for field1, field2 in combis: i = outcomes_to_show.index(field1) j = outcomes_to_show.index(field2) ax = figure.add_subplot(grid[i,j]) axes_dict[(field1, field2)] = ax if group_by: for x, entry in enumerate(grouping_labels): data1 = outcomes[entry][field1] data2 = outcomes[entry][field2] color = COLOR_LIST[x] if i==j: color = 'white' simple_pairs_lines(ax, data1, data2, color) else: data1 = outcomes[field1] data2 = outcomes[field2] color = 'b' if i==j: color = 'white' simple_pairs_lines(ax, data1, data2, color) do_text_ticks_labels(ax, i, j, field1, field2, ylabels, outcomes_to_show) return figure, axes_dict