def load_optimization_results(file_name, weights, zipped=True):
'''
load the specified bz2 file. the file is assumed to be saves
using save_results.
:param file: the path of the file
:param zipped: load the pickled data from a zip file if True
:return: the unpickled results
:raises: IOError if file not found
:raises: EMAError if weights are not correct
'''
creator.create("Fitness", base.Fitness, weights=weights)
creator.create("Individual", dict,
fitness=creator.Fitness) #@UndefinedVariable
file_name = os.path.abspath(file_name)
debug("loading "+file_name)
try:
if zipped:
file_name = bz2.BZ2File(file_name, 'rb')
else:
file_name = open(file_name, 'rb')
results = cPickle.load(file_name)
if results[0].weights != weights:
raise EMAError("weights are %s, should be %s" % (weights, results[0].weights))
except IOError:
warning(file_name + " not found")
raise
return results
def pickled_load_results(file_name, zipped=True):
'''
load the specified bz2 file. the file is assumed to be saves
using save_results.
:param file: the path of the file
:param zipped: load the pickled data from a zip file if True
:return: the unpickled results
:raises: IOError if file not found
'''
results = None
file_name = os.path.abspath(file_name)
debug("loading "+file_name)
try:
if zipped:
file_handle = bz2.BZ2File(file_name, 'rb')
else:
file_handle = open(file_name, 'rb')
results = cPickle.load(file_handle)
except IOError:
warning(file_name + " not found")
raise
return results
def pickled_save_results(results, file_name, zipped=True):
'''
save the results to the specified bz2 file. To facilitate transfer
across different machines. the files are saved in binary format
see also: http://projects.scipy.org/numpy/ticket/1284
:param results: the return of run_experiments
:param file: the path of the file
:param zipped: save the pickled data to a zip file if True
:raises: IOError if file not found
'''
file_name = os.path.abspath(file_name)
debug("saving results to: " + file_name)
try:
if zipped:
file_name = bz2.BZ2File(file_name, 'wb')
else:
file_name = open(file_name, 'wb')
cPickle.dump(results, file_name, protocol=2)
except IOError:
warning(os.path.abspath(file_name) + " not found")
raise
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
'''
debug("executing COMMAND: SIMULATE>SPECIAL>LOADMODEL|"+file)
try:
command(r"SPECIAL>LOADMODEL|"+file)
except VensimWarning as w:
warning(str(w))
raise VensimError("vensim file not found")
def get_data(filename, varname, step=1):
'''
Retrieves data from simulation runs or imported data sets.
:param filename: the name of the .vdf file that contains the data
:param varname: the name of the variable to retrieve data on
:param step: steps used in slicing. Defaults to 1, meaning the full
recored time series is returned.
:return: an array with the values for varname over the simulation
'''
vval = []
try:
vval, tval = vensimDLLwrapper.get_data(filename, varname)
except VensimWarning as w:
warning(str(w))
return vval
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:
debug(" executing COMMAND: SIMULATE>RUNNAME|"+file+"|O")
command("SIMULATE>RUNNAME|"+file+"|O")
debug(r"MENU>RUN|o")
command(r"MENU>RUN|o")
except VensimWarning as w:
warning((str(w)))
raise VensimError(str(w))
def set_value(variable, value):
'''
set the value of a variable to value
current implementation only works for lookups and normal values. In case
of a list, a lookup is assumed, else a normal value is assumed.
See the DSS reference supplement, p. 58 for details.
:param variable: name of the variable to set.
:param value: the value for the variable.
**note**: the value can be either a list, or an float/integer.
If it is a list, it is assumed the variable is a lookup.
'''
if type(value) == types.ListType:
command(r"SIMULATE>SETVAL|"+variable+"("+ str(value)[1:-1] + ")")
else:
try:
command(r"SIMULATE>SETVAL|"+variable+"="+str(value))
except VensimWarning:
warning('variable: \'' +variable+'\' not found')
def run_model(self, case):
"""
Method for running an instantiated model structures. This
implementation assumes that the names of the uncertainties correspond
to the name of the cells in Excel. See e.g. `this site <http://spreadsheets.about.com/od/exceltips/qt/named_range.htm>`_
for details or use Google and search on 'named range'. One of the
requirements on the names is that the cannot contains spaces.
For the extraction of results, the same approach is used. That is,
this implementation assumes that the name of a :class:`~outcomes.Outcome`
instance corresponds to the name of a cell, or set of cells.
:param case: dictionary with arguments for running the model
"""
#find right sheet
try:
sheet = self.wb.Sheets(self.sheet)
except Exception :
ema_logging.warning("com error: sheet not found")
self.cleanup()
raise
#set values on sheet
for key, value in case.items():
try:
sheet.Range(key).Value = value
except com_error:
ema_logging.warning("com error: no cell(s) named %s found" % key,)
#get results
results = {}
for outcome in self.outcomes:
try:
output = sheet.Range(outcome.name).Value
try:
output = [value[0] for value in output]
output = np.array(output)
except TypeError:
output = np.array(output)
results[outcome.name] = output
except com_error:
ema_logging.warning("com error: no cell(s) named %s found" % outcome.name,)
self.output = results
def worker(inqueue, outqueue, model_interfaces, model_kwargs=None):
#
# Code run by worker processes
#
debug("worker started")
put = outqueue.put
get = inqueue.get
if hasattr(inqueue, "_writer"):
inqueue._writer.close()
outqueue._reader.close()
def cleanup(model_interfaces):
for msi in model_interfaces:
msi.cleanup()
del msi
msis = {msi.name: msi for msi in model_interfaces}
while 1:
try:
task = get()
except (EOFError, IOError):
debug("worker got EOFError or IOError -- exiting")
break
if task is None:
debug("worker got sentinel -- exiting")
cleanup(model_interfaces)
break
job, i, experiment = task
msi_initialization_dict = {}
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(model_interfaces)
result = (False, inst)
put((job, i, result))
except Exception:
exception("some exception occurred when invoking the init")
cleanup(model_interfaces)
result = (False, EMAParallelError("failure to initialize"))
put((job, i, result))
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()
result = (True, (case, policy, msi.name, result))
msi.reset_model()
debug("trying to reset model")
put((job, i, result))
