def central_wrapper(g, horizon, searchers, b0, M_target, gamma, timeout):
"""Add variables, constraints, objective function and solve the model
compute all paths"""
solver_type = 'central'
# V^{s, t}
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, horizon, searchers)
# create model
md = mf.create_model()
# add variables
my_vars = mf.add_variables(md, g, horizon, start, vertices_t, searchers)
# add constraints (central algorithm)
mf.add_constraints(md, g, my_vars, searchers, vertices_t, horizon, b0,
M_target)
# objective function
mf.set_solver_parameters(md, gamma, horizon, my_vars, timeout)
# solve and save results
obj_fun, time_sol, gap, x_searchers, b_target, threads = mf.solve_model(md)
# clean things
md.reset()
md.terminate()
del md
#
# clean things
return obj_fun, time_sol, gap, x_searchers, b_target, threads
def test_run_solver_get_model_data():
horizon, theta, deadline, solver_type = get_solver_param()
g, v0_target, v0_searchers, target_motion, belief_distribution = parameters_sim()
gamma = 0.99
timeout = 60
# initialize parameters according to inputs
b_0 = cp.set_initial_belief(g, v0_target, belief_distribution)
M = cp.set_motion_matrix(g, target_motion)
searchers = cp.create_dict_searchers(g, v0_searchers)
# solve: 1 [low level]
start, vertices_t, times_v = cm.get_vertices_and_steps(g, horizon, searchers)
# create model
md = mf.create_model()
# add variables
my_vars = mf.add_variables(md, g, horizon, start, vertices_t, searchers)
# add constraints (central algorithm)
mf.add_constraints(md, g, my_vars, searchers, vertices_t, horizon, b_0, M)
# objective function
mf.set_solver_parameters(md, gamma, horizon, my_vars, timeout)
# update
md.update()
# Optimize model
md.optimize()
x_s1, b_target1 = mf.query_variables(md)
obj_fun1, time_sol1, gap1, threads1 = mf.get_model_data(md)
pi_dict1 = core.extract_info.xs_to_path_dict(x_s1)
path1 = core.extract_info.path_as_list(pi_dict1)
# solve: 2
obj_fun2, time_sol2, gap2, x_s2, b_target2, threads2 = pln.run_solver(g, horizon, searchers, b_0, M)
pi_dict2 = core.extract_info.xs_to_path_dict(x_s2)
path2 = core.extract_info.path_as_list(pi_dict2)
# solve: 3
specs = my_specs()
# initialize instances of classes
path3 = pln.run_planner(specs)
assert obj_fun1 == md.objVal
assert round(time_sol1, 2) == round(md.Runtime, 2)
assert gap1 == md.MIPGap
# 1 x 2
assert x_s1 == x_s2
assert b_target1 == b_target2
assert obj_fun2 == obj_fun1
assert round(time_sol2, 2) == round(time_sol1, 2)
assert gap2 == gap1
assert threads2 == threads1
# paths
assert pi_dict1 == pi_dict2
assert path1 == path2
# 1 x 3
assert path1 == path3
def test_solver_data_class():
horizon = 3
n, b_0, M, searchers, g = parameters_7v_random_motion2()
# solve
# create model
md = Model("my_model")
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, horizon, searchers)
start1, vertices_t1, times_v1 = cm.get_vertices_and_steps(
g, horizon, searchers)
my_vars = mf.add_variables(md, g, horizon, start, vertices_t)
mf.add_constraints(md, g, my_vars, searchers, vertices_t, horizon, b_0, M)
mf.set_solver_parameters(md, 0.99, horizon, my_vars)
md.update()
# Optimize model
md.optimize()
x_s, b_target = mf.query_variables(md)
obj_fun = md.objVal
gap = md.MIPGap
time_sol = round(md.Runtime, 4)
threads = md.Params.Threads
deadline = 6
theta = 3
my_data = MySolverData(horizon, deadline, theta, g, 'central')
t = 0
my_data.store_new_data(obj_fun, time_sol, gap, threads, x_s, b_target, t,
horizon)
assert all(start1) == all(start)
assert all(vertices_t) == all(vertices_t1)
assert all(times_v) == all(times_v1)
assert my_data.obj_value[0] == obj_fun
assert my_data.solve_time[0] == time_sol
assert my_data.threads[0] == md.Params.Threads
assert my_data.gap[0] == gap
assert my_data.x_s[0] == x_s
assert my_data.belief[0] == b_target
assert my_data.solver_type == 'central'
assert my_data.threads[0] == threads
def distributed_wrapper(g,
horizon,
searchers,
b0,
M_target,
gamma,
timeout=5,
n_inter=1,
pre_solver=-1):
"""Distributed version of the algorithm """
# parameter to stop iterations
# number of full loops s= 1..m
n_it = n_inter
# iterative parameters
total_time_sol = 0
previous_obj_fun = 0
my_counter = 0
# temporary path for the searchers
temp_pi = init_temp_path(searchers, horizon)
# get last searcher number [m]
m = ext.get_last_info(searchers)[0]
obj_fun_list = {}
time_sol_list = {}
gap_list = {}
while True:
for s_id in searchers.keys():
# create model
md = mf.create_model()
temp_pi['current_searcher'] = s_id
start, vertices_t, times_v = cm.get_vertices_and_steps_distributed(
g, horizon, searchers, temp_pi)
# add variables
my_vars = mf.add_variables(md, g, horizon, start, vertices_t,
searchers)
mf.add_constraints(md, g, my_vars, searchers, vertices_t, horizon,
b0, M_target)
# objective function
mf.set_solver_parameters(md, gamma, horizon, my_vars, timeout,
pre_solver)
# solve and save results
obj_fun, time_sol, gap, x_searchers, b_target, threads = mf.solve_model(
md)
if md.SolCount == 0:
# problem was infeasible or other error (no solution found)
print('Error, no solution found!')
obj_fun, time_sol, gap, threads = -1, -1, -1, -1
# keep previous belief
b_target = {}
v = 0
for el in b0:
b_target[(v, 0)] = el
v += 1
x_searchers = keep_all_still(temp_pi)
# clean things
md.reset()
md.terminate()
del md
# ------------------------------------------------------
# append to the list
obj_fun_list[s_id] = obj_fun
time_sol_list[s_id] = time_sol
gap_list[s_id] = gap
# save the current searcher's path
temp_pi = update_temp_path(x_searchers, temp_pi, s_id)
total_time_sol = total_time_sol + time_sol_list[s_id]
# end of a loop through searchers
if s_id == m:
# compute difference between previous and current objective functions
delta_obj = abs(previous_obj_fun - obj_fun)
# iterate
previous_obj_fun = obj_fun
my_counter = my_counter + 1
# check for stoppers: either the objective function converged or iterated as much as I wanted
if (delta_obj < 1e-4) or (my_counter >= n_it):
time_sol_list['total'] = total_time_sol
# clean and delete
disposeDefaultEnv()
return obj_fun_list, time_sol_list, gap_list, x_searchers, b_target, threads
def test_position_searchers():
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
# input for target initial vertices (belief)
v_target = [7]
# initial searcher vertices
v0_searchers = [1, 2]
horizon = 3
# type of motion
target_motion = 'random'
belief_distribution = 'uniform'
b0, M = cp.my_target_motion(g, v_target, belief_distribution,
target_motion)
# searchers
searchers = cp.create_dict_searchers(g, v0_searchers)
# solve
# create model
md = Model("my_model")
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, horizon, searchers)
# add variables
my_vars = mf.add_variables(
md,
g,
horizon,
start,
vertices_t,
)
# add constraints (central algorithm)
mf.add_constraints(md, g, my_vars, searchers, vertices_t, horizon, b0, M)
mf.set_solver_parameters(md, 0.99, horizon, my_vars)
md.update()
# Optimize model
md.optimize()
x_s, b_target = mf.query_variables(md)
# check searcher position (1)
assert x_s.get((1, 1, 0)) == 1
assert x_s.get((1, 3, 1)) == 1
assert x_s.get((1, 5, 2)) == 1
assert x_s.get((1, 6, 3)) == 1
# check searcher position (2)
assert x_s.get((2, 2, 0)) == 1
assert x_s.get((2, 5, 1)) == 1
assert x_s.get((2, 6, 2)) == 1
assert x_s.get((2, 7, 3)) == 1
# check target belief t = 0
assert b_target.get((0, 0)) == 0
assert b_target.get((1, 0)) == 0
assert b_target.get((2, 0)) == 0
assert b_target.get((3, 0)) == 0
assert b_target.get((4, 0)) == 0
assert b_target.get((5, 0)) == 0
assert b_target.get((6, 0)) == 0
assert b_target.get((7, 0)) == 1
# check target belief t = 1
assert b_target.get((0, 1)) == 0
assert b_target.get((1, 1)) == 0
assert b_target.get((2, 1)) == 0
assert b_target.get((3, 1)) == 0
assert b_target.get((4, 1)) == 0
assert b_target.get((5, 1)) == 0
assert b_target.get((6, 1)) == 0.5
assert b_target.get((7, 1)) == 0.5
# check target belief t = 2
assert round(b_target.get((0, 2)), 3) == 0.583
assert b_target.get((1, 2)) == 0
assert b_target.get((2, 2)) == 0
assert b_target.get((3, 2)) == 0
assert b_target.get((4, 2)) == 0
assert b_target.get((5, 2)) == 0
assert b_target.get((6, 2)) == 0
assert round(b_target.get((7, 2)), 3) == 0.417
# check target belief t = 3
assert b_target.get((0, 3)) == 1
assert b_target.get((1, 3)) == 0
assert b_target.get((2, 3)) == 0
assert b_target.get((3, 3)) == 0
assert b_target.get((4, 3)) == 0
assert b_target.get((5, 3)) == 0
assert b_target.get((6, 3)) == 0
assert b_target.get((7, 3)) == 0