def main():
option_group = EstimationOptionGroup()
parser = option_group.parser
(options, args) = parser.parse_args()
if options.model_name is None:
raise StandardError, "Model name (argument -m) must be given."
if (options.configuration_path is None) and (options.xml_configuration is
None):
raise StandardError, "Configuration path (argument -c) or XML configuration (argument -x) must be given."
if (options.specification is None) and (options.xml_configuration is None):
logger.log_warning(
"No specification given (arguments -s or -x). Specification taken from the cache."
)
if options.xml_configuration is not None:
xconfig = XMLConfiguration(options.xml_configuration)
else:
xconfig = None
if options.configuration_path is None:
config = None
else:
config = get_config_from_opus_path(options.configuration_path)
estimator = EstimationRunner(model=options.model_name,
specification_module=options.specification,
xml_configuration=xconfig,
model_group=options.model_group,
configuration=config,
save_estimation_results=options.save_results)
estimator.estimate()
return estimator
def main():
option_group = EstimationOptionGroup()
parser = option_group.parser
(options, args) = parser.parse_args()
if options.model_name is None:
raise StandardError, "Model name (argument -m) must be given."
if (options.configuration_path is None) and (options.xml_configuration is None):
raise StandardError, "Configuration path (argument -c) or XML configuration (argument -x) must be given."
if (options.specification is None) and (options.xml_configuration is None):
logger.log_warning("No specification given (arguments -s or -x). Specification taken from the cache.")
if options.xml_configuration is not None:
xconfig = XMLConfiguration(options.xml_configuration)
else:
xconfig = None
if options.configuration_path is None:
config = None
else:
config = get_config_from_opus_path(options.configuration_path)
estimator = EstimationRunner(model=options.model_name,
specification_module=options.specification,
xml_configuration=xconfig,
model_group=options.model_group,
configuration=config,
save_estimation_results=options.save_results)
estimator.estimate()
return estimator
class OpusEstimation(object):
# xml_config, model_name, model_group
def __init__(self, xml_config, model_name, model_group = None):
'''
@param xml_config (XMLConfiguration): xml configuration object for the model
@param model_name (String): the name of the model to run
@param model_group (String): name of the sub model group to run
'''
dummy_callback = lambda x: None
self.xml_config = xml_config
self.model_name = model_name
self.model_group = model_group
self.er = None
self.progressCallback = dummy_callback
self.finishedCallback = dummy_callback
self.errorCallback = dummy_callback
self.guiElement = None
self.config = None
self.statusfile = None
self.firstRead = True
self.running = False
self.paused = False
self.cancelled = False
self.statusfile = None
def pause(self):
self.paused = True
print "Pause pressed"
# Can access the estimation manager via self.er
def resume(self):
self.paused = False
print "Resume pressed"
# Can access the estimation manager via self.er
def cancel(self):
self.running = False
self.paused = False
self.cancelled = True
print "Cancel pressed"
# Can access the estimation manager via self.er
def run(self):
# Start the estimation. This code adapted from urbansim/tools/start_estimation.py
# statusdir is a temporary directory into which to write a status file
# regarding the progress of the simulation - the progress bar reads this file
statusfile = None
succeeded = False
try:
# get the configuration for estimations
estimation_section = self.xml_config.get_section('model_manager')
estimation_config = estimation_section['estimation_config']
self.config = estimation_config
# TODO: put this option into post run dialog
save_results = estimation_config['save_estimation_results']
# If we've paused the estimation, wait 10 seconds, and see if we are unpaused. If we've cancelled,
# exit the loop. Note that this is a fairly coarse level of pause/resume/stop (at the level of
# estimating an entire model, rather than a bit of a model).
while self.paused and not self.cancelled:
time.sleep(10)
if not self.cancelled:
self.er = EstimationRunner(model = self.model_name,
specification_module = None,
xml_configuration = self.xml_config,
model_group = self.model_group,
configuration = None,
save_estimation_results=save_results)
self.running = True
self.er.estimate()
self.running = False
succeeded = True
except:
succeeded = False
self.running = False
errorInfo = formatExceptionInfo(custom_message = 'Unexpected Error From Estimation')
self.errorCallback(errorInfo)
if statusfile is not None:
os.remove(statusfile)
del self.er
self.er = None
gc.collect()
self.finishedCallback(succeeded)
def _compute_progress(self):
if self.statusfile is None:
return {"percentage":0,"message":"Estimation initializing..."}
#TODO: Compute percent progress for the progress bar.
percentage = 0
message = 'Estimation initializing...'
return {"percentage":percentage,"message":message}
def _get_current_log(self, key):
newKey = key
# We attempt to keep up on the current progress of the model run. We pass into this
# function an initial "key" value of 0 and expect to get back a new "key" after the
# function returns. It is up to us in this function to use this key to determine
# what has happened since last time this function was called.
# In this example we use the key to indicate where in a logfile we last stopped reading
# and seek into that file point and read to the end of the file and append to the
# log text edit field in the GUI.
if self.config is not None and 'cache_directory' in self.config:
try:
base_year = self.config['base_year']
f = open(os.path.join(self.config['cache_directory'],'year_%d_log.txt' % base_year))
f.seek(key)
lines = f.read()
newKey = f.tell()
if newKey != key:
self.guiElement.logText.append(lines)
f.close()
except IOError:
if self.firstRead == True:
self.guiElement.logText.append("No logfile yet")
self.firstRead = False
else:
self.guiElement.logText.insertPlainText(QString("."))
#self.guiElement.logText.append("ping")
return newKey