def run(conf_path, output_path, definitions):
try:
print "configuring"
if conf_path is not None:
conf = cfg.load_conf(params.__dict__, conf_path)
params.__dict__.update(conf)
if definitions is not None:
cfg.update_conf(params.__dict__, params.__dict__, definitions)
if params.verbose:
print "verbose output enabled"
if params.lower_process_priority:
if params.verbose:
print "reducing process priority"
warning = svc.reduce_process_priority()
if warning:
output.warn(warning)
if params.graphs:
if not output_path:
raise InvocationError("no output directory")
output_path = os.path.normpath(output_path)
if params.verbose:
print "graphs will be written to:", output_path
output.output_dir = output_path
print "validating"
cfg.validate()
with mp.TaskPool(params.num_tasks, params.extended_mode, params.__dict__) as task_pool:
print "executing"
if params.verbose:
print "number of parallel tasks:", task_pool.num_tasks
start_time = time.time()
execute(task_pool)
end_time = time.time()
elapsed_time = end_time - start_time
print output.div_line
print "done"
if params.verbose:
print "finished in %.2f s" % elapsed_time
except (cfg.ConfigurationError, core.ComputationError, model.exc.ModelError) as exc:
output.print_error(str(exc))
sys.exit(1)
except MemoryError:
output.print_error("out of memory")
sys.exit(1)
except:
if not debug_mode:
output.print_exception()
sys.exit(1)
else:
raise
if params.verbose:
print int_type.__name__
integrator = model.integrator.DomainIntegrator(int_type)
min_count_int = integrator.num_integrator.min_count
min_count_amp_z = model.discrete.steps(model.discrete.divs(max(min_count_z, min_count_int)))
min_count_amp_t = model.discrete.steps(model.discrete.divs(max(min_count_t, min_count_int)))
min_count_amp = min_count_amp_z * min_count_amp_t
int_limit = limit // min_count_amp
try:
(count_rho, count_phi), int_rel_error = model.error.min_integration_steps(integrator, min_xverse, params.int_rtol, int_limit, active_medium, input_beam)
except model.exc.SoftLimitError:
sys.exc_clear()
continue
except (ValueError, MemoryError):
output.print_exception()
print >>sys.stderr, "attempting to recover"
sys.exc_clear()
continue
for amp_type in amp_types:
if params.verbose:
print amp_type.__name__
count_xverse = count_rho * count_phi
amp_limit = limit // count_xverse
try:
(count_z, count_t), amp_rel_error = model.error.min_amplification_steps(amp_type, min_evo, params.amp_rtol, amp_limit, active_medium, pulse_train, None, integrator)
except model.exc.SoftLimitError:
sys.exc_clear()
continue
