def start(self):
start_time = timeit.default_timer()
try:
self._decomposer.decompose()
except Exception, e:
logging.exception("Decomposition failed.")
return
def solve(self, params=None):
if not self._model:
raise Error()
if params and not isinstance(params, OptimizationParameters):
raise TypeError()
if not params:
params = OptimizationParameters()
self._optimization_params = params
logging.info("Optimize model %s with %d rows and %d columns.",
self._model.get_name(), self._model.get_num_rows(),
self._model.get_num_columns())
self._pipeline = pipeline.Pipeline()
self._executor = executor_manager.get_instance_of(params.executor.executor,
self._pipeline)
logging.info("Executor: %s", self._executor.__class__.__name__)
try:
self._driver = drivers.get_instance_of(params.driver.driver, self._model, params, self._pipeline)
except Exception:
logging.exception("Cannot create driver instance.")
return
logging.info("Driver: %s", self._driver.__class__.__name__)
logging.info("Default backend solver is %d", params.driver.default_backend_solver)
start_time = timeit.default_timer()
try:
self._executor.start()
solution = self._driver.start()
except KeyboardInterrupt:
self._executor.stop()
self._driver.stop()
return
except Exception, e:
logging.exception("Driver failed.")
self._executor.stop()
return
def run(self):
model = mp_model.build(self._args.file)
decomposer = decomposers.get_instance_of(self._args.decomposer_id, model)
try:
decomposer.decompose()
except Exception, e:
logging.exception('Cannot decompose the model.')
return
def execute(self, request):
model = request.get_model()
logging.debug('Solve model %s that has %d row(s) and %d column(s)'
' with solver %s',
model.get_name(), model.get_num_rows(),
model.get_num_columns(), request.get_solver_id())
solver = backend_solvers.get_instance_of(request.get_solver_id())
if not solver:
raise Error("Cannot instantiate backend solver by id: %d" %
request.get_solver_id())
try:
solver.load_model(model)
solver.solve()
except Error, e:
# TODO: send back a report.
logging.exception("Cannot execute given request: cannot solve the model.")
return None
def run(self):
try:
model = mp_model.build(self._args.file)
except Exception, e:
logging.exception('Cannot read the model.')
return
