def test_get_var():
"""Test for expected B in simple graph"""
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0_searchers = [3, 1]
deadline = 3
# searchers
searchers = cp.create_dict_searchers(g, v0_searchers)
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, deadline, searchers)
md = Model("my_model")
# time indexes
Tau_ = ext.get_idx_time(deadline)
searchers_vars = mf.add_searcher_variables(md, g, start, vertices_t,
deadline)[0]
# variables related to target position belief and capture
target_vars = mf.add_target_variables(md, g, deadline)[0]
# get my variables together in one dictionary
my_vars = {}
my_vars.update(searchers_vars)
my_vars.update(target_vars)
my_chosen_var = mf.get_var(my_vars, 'x')
my_empty_var = mf.get_var(my_vars, 'f')
assert my_chosen_var == searchers_vars.get('x')
assert my_empty_var is None
def my_specs():
theta = 2
deadline = 6
horizon = 3
solver_type = 'central'
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
target_motion = 'random'
belief_distribution = 'uniform'
v0_target = [7]
v0_searchers = [1, 2]
specs = MyInputs()
specs.set_graph(0)
specs.set_theta(theta)
specs.set_deadline(deadline)
specs.set_solver_type(solver_type)
specs.set_horizon(horizon)
specs.set_start_target(v0_target)
specs.set_start_searchers(v0_searchers)
specs.set_target_motion(target_motion)
specs.set_belief_distribution(belief_distribution)
return specs
def test_capture_range():
graph_file = 'G64V_grid'
g = ext.get_graph(graph_file)
v_target = [1, 2, 3]
v_searchers = [5]
target_motion = 'random'
distribution_type = 'uniform'
capture_range = 1
zeta = None
b_0 = cp.set_initial_belief(g, v_target, distribution_type)
M = cp.set_motion_matrix(g, target_motion)
assert b_0[0] == 0.0
assert b_0[1] == 1 / 3
assert b_0[2] == 1 / 3
assert b_0[3] == 1 / 3
assert M[0][0] == 1 / 3
assert M[-1][-1] == 1 / 3
searchers = cp.create_dict_searchers(g, v_searchers, capture_range, zeta)
s_id = 1
u = 1
s = searchers[s_id]
C = s.get_capture_matrix(u)
assert C[0][0] == 1
assert C[1][0] == 1
assert C[2][0] == 1
assert C[9][0] == 1
def test_product_capture_matrix():
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
# initial searcher vertices
v_searchers = [1]
# type of motion
target_motion = 'random'
belief_distribution = 'uniform'
# searchers
searchers = cp.create_dict_searchers(g, v_searchers)
s = 1
v = 1
t = 0
C1 = searchers[s].get_capture_matrix(v)
new_pos = dict()
new_pos[s] = v
prod_C = cm.product_capture_matrix(searchers, new_pos, 7)
assert prod_C.all() == C1.all()
def test_add_searcher_variables_y():
"""Test for expected Y in simple graph"""
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0_searchers = [3, 1]
deadline = 3
# searchers
searchers = cp.create_dict_searchers(g, v0_searchers)
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, deadline, searchers)
md = Model("my_model")
var_for_test = mf.add_searcher_variables(md, g, start, vertices_t,
deadline)[1]
assert var_for_test.get('y')[0] == 'y[1,3,1,0]'
assert var_for_test.get('y')[1] == 'y[1,3,5,0]'
assert var_for_test.get('y')[2] == 'y[1,3,3,0]'
assert var_for_test.get('y')[3] == 'y[1,1,2,1]'
assert var_for_test.get('y')[4] == 'y[1,1,3,1]'
assert var_for_test.get('y')[5] == 'y[1,1,1,1]'
assert var_for_test.get('y')[6] == 'y[1,3,1,1]'
assert var_for_test.get('y')[7] == 'y[1,3,5,1]'
assert var_for_test.get('y')[8] == 'y[1,3,3,1]'
def set_graph(self, graph_number_or_file):
if isinstance(graph_number_or_file, int):
if graph_number_or_file == 0:
self.graph = ext.get_graph_00()
elif graph_number_or_file == 1:
# OFFICE
self.graph = ext.get_graph_01()
elif graph_number_or_file == 2:
# GRID 10x10
self.graph = ext.get_graph_02()
elif graph_number_or_file == 3:
# GRID 8x8
self.graph = ext.get_graph_03()
elif graph_number_or_file == 4:
self.graph = ext.get_graph_04()
elif graph_number_or_file == 5:
self.graph = ext.get_graph_05()
elif graph_number_or_file == 6:
self.graph = ext.get_graph_06()
elif graph_number_or_file == 7:
# MUSEUM
self.graph = ext.get_graph_07()
elif graph_number_or_file == 8:
# school
self.graph = ext.get_graph_08()
else:
print("No graph with that number")
elif isinstance(graph_number_or_file, str):
# if name of a file stored in graphs folder
self.graph = ext.get_graph(graph_number_or_file)
else:
self.graph = graph_number_or_file
def test_belief_vector_prob():
"""Test b_0 for several vertices, user defined probability"""
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0_target = [1, 5, 7]
init_prob = [0.2, 0.5, 0.3]
b_0, M = cp.my_target_motion(g, v0_target, init_prob)
assert b_0 == [0, 0.2, 0, 0, 0, 0.5, 0, 0.3]
def parameters_sim():
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
target_motion = 'random'
belief_distribution = 'uniform'
v0_target = [7]
v0_searchers = [1, 2]
return g, v0_target, v0_searchers, target_motion, belief_distribution
def test_get_vertices_and_steps_start():
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0_searchers = [3, 1]
deadline = 3
# searchers
searchers = cp.create_dict_searchers(g, v0_searchers)
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, deadline, searchers)
assert start[0] == v0_searchers[0]
assert start[1] == v0_searchers[1]
def test_belief_vector():
"""Test b_0 for vertices with equal probability"""
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v_list = [5]
type_distribution = 'uniform'
b_0 = cp.set_initial_belief(g, v_list, type_distribution)
assert b_0 == [0, 0, 0, 0, 0, 1, 0, 0]
v_list = [1, 7]
b_0 = cp.set_initial_belief(g, v_list, type_distribution)
assert b_0 == [0, 1 / 2, 0, 0, 0, 0, 0, 1 / 2]
def test_get_vertices_and_steps_vertices2():
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0 = [3, 1]
deadline = 3
# searchers
searchers = cp.create_dict_searchers(g, v0)
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, deadline, searchers)
assert vertices_t.get((1, 0)) == [3]
assert vertices_t.get((1, 1)) == [1, 3, 5]
assert vertices_t.get((1, 2)) == [1, 2, 3, 5, 6]
assert vertices_t.get((1, 3)) == [1, 2, 3, 4, 5, 6, 7]
def test_assemble_big_matrix2():
"""test assemble of [1, 0; 0, M]"""
# input parameters for graph
n_vertex = 7
graph_name = 'G7V_test.p'
g = ext.get_graph(graph_name)
# input for target initial vertices (belief)
v_target = [7]
# type of motion
target_motion = 'static'
belief_distribution = 'uniform'
b_0, M = cp.my_target_motion(g, v_target, belief_distribution,
target_motion)
big_M = cm.assemble_big_matrix(n_vertex, M)
bigM = ext.convert_list_array(big_M, 'list')
assert isinstance(bigM, list)
assert bigM[0][0] == 1
assert bigM[0][1] == 0
assert bigM[0][2] == 0
assert bigM[0][3] == 0
assert bigM[0][4] == 0
assert bigM[0][5] == 0
assert bigM[0][6] == 0
assert bigM[0][7] == 0
assert bigM[1][0] == 0
assert bigM[1][1] == 1
assert bigM[2][2] == 1
assert bigM[3][3] == 1
assert bigM[4][4] == 1
assert bigM[5][5] == 1
assert bigM[6][6] == 1
assert bigM[7][7] == 1
assert bigM[2][0] == 0
assert bigM[3][0] == 0
assert bigM[4][0] == 0
assert bigM[5][0] == 0
assert bigM[6][0] == 0
assert bigM[7][0] == 0
def parameters_7v_random_motion2():
"""Parameters pre-defined for unit tests"""
# 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]
deadline = 3
# type of motion
target_motion = 'random'
belief_distribution = 'uniform'
# initialize parameters
b_0, M = cp.my_target_motion(g, v_target, belief_distribution)
searchers = cp.create_dict_searchers(g, v0_searchers)
n = 7
return n, b_0, M, searchers, g
def test_get_vertices_and_steps_times():
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0 = [3, 1]
deadline = 3
# searchers
searchers = cp.create_dict_searchers(g, v0)
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, deadline, searchers)
assert times_v.get((1, 1)) == [1, 2, 3]
assert times_v.get((1, 2)) == [2, 3]
assert times_v.get((1, 3)) == [0, 1, 2, 3]
assert times_v.get((1, 4)) == [3]
assert times_v.get((1, 5)) == [1, 2, 3]
assert times_v.get((1, 6)) == [2, 3]
assert times_v.get((1, 7)) == [3]
def test_add_target_variables_alpha():
"""Test for expected B in simple graph"""
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
deadline = 3
md = Model("my_model")
var_for_test = mf.add_target_variables(md, g, deadline)[1]
assert var_for_test.get('alpha')[0] == '[1,1]'
assert var_for_test.get('alpha')[1] == '[2,1]'
assert var_for_test.get('alpha')[2] == '[3,1]'
assert var_for_test.get('alpha')[-3] == '[5,3]'
assert var_for_test.get('alpha')[-2] == '[6,3]'
assert var_for_test.get('alpha')[-1] == '[7,3]'
def test_get_vertices_and_steps_distributed():
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0 = [1, 2]
deadline = 3
# searchers
searchers = cp.create_dict_searchers(g, v0)
temp_s_path = pln.init_temp_path(searchers, deadline)
temp_s_path['current_searcher'] = 1
start, vertices_t, times_v = cm.get_vertices_and_steps_distributed(
g, deadline, searchers, temp_s_path)
assert times_v.get((1, 1)) == [0, 1, 2, 3]
assert times_v.get((1, 2)) == [1, 2, 3]
assert times_v.get((1, 3)) == [1, 2, 3]
assert times_v.get((1, 4)) == [2, 3]
assert times_v.get((1, 5)) == [2, 3]
assert times_v.get((1, 6)) == [3]
assert times_v.get((1, 7)) == []
assert times_v.get((1, 8)) == [4]
assert times_v.get((2, 1)) == []
assert times_v.get((2, 2)) == [0, 1, 2, 3]
assert times_v.get((2, 3)) == []
assert times_v.get((2, 4)) == []
assert times_v.get((2, 5)) == []
assert times_v.get((2, 6)) == []
assert times_v.get((2, 7)) == []
assert times_v.get((2, 8)) == [4]
assert vertices_t.get((1, 0)) == [1]
assert vertices_t.get((1, 1)) == [1, 2, 3]
assert vertices_t.get((1, 2)) == [1, 2, 3, 4, 5]
assert vertices_t.get((1, 3)) == [1, 2, 3, 4, 5, 6]
assert vertices_t.get((1, 4)) == [8]
assert vertices_t.get((2, 0)) == [2]
assert vertices_t.get((2, 1)) == [2]
assert vertices_t.get((2, 2)) == [2]
assert vertices_t.get((2, 3)) == [2]
assert vertices_t.get((2, 4)) == [8]
def test_markovian_matrix():
"""Test Markovian matrix M for random motion"""
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0_target = [1, 5, 7]
init_prob = [0.2, 0.5, 0.3]
b_0, M = cp.my_target_motion(g, v0_target, init_prob)
a = 1 / 3
b = 1 / 4
c = 1 / 2
M_exp = [[a, a, a, 0, 0, 0, 0], [b, b, 0, b, b, 0,
0], [a, 0, a, 0, a, 0, 0],
[0, c, 0, c, 0, 0, 0], [0, b, b, 0, b, b, 0],
[0, 0, 0, 0, a, a, a], [0, 0, 0, 0, 0, c, c]]
assert M == M_exp
def test_add_target_variables_b():
"""Test for expected B in simple graph"""
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
deadline = 3
md = Model("my_model")
var_for_test = mf.add_target_variables(md, g, deadline)[1]
assert var_for_test.get('beta')[0] == '[0,0]'
assert var_for_test.get('beta')[1] == '[1,0]'
assert var_for_test.get('beta')[2] == '[2,0]'
assert var_for_test.get('beta')[3] == '[3,0]'
assert var_for_test.get('beta')[4] == '[4,0]'
assert var_for_test.get('beta')[5] == '[5,0]'
assert var_for_test.get('beta')[6] == '[6,0]'
assert var_for_test.get('beta')[7] == '[7,0]'
def test_neighbors():
# load graph
graph_file = 'G7V_test.p'
g = ext.get_graph(graph_file)
v0 = [3, 1]
deadline = 3
# searchers
searchers = cp.create_dict_searchers(g, v0)
start, vertices_t, times_v = cm.get_vertices_and_steps(
g, deadline, searchers)
s = 1
v = 3
t = 2
tau_ext = ext.get_set_time_u_0(deadline)
v_possible = cm.get_next_vertices(g, s, v, t, vertices_t, tau_ext)
assert v_possible == [1, 5, 3]
def test_get_graph():
g0 = ext.get_graph_00()
g1 = ext.get_graph_01()
g2 = ext.get_graph_02()
g3 = ext.get_graph_03()
g4 = ext.get_graph_04()
g5 = ext.get_graph_05()
g6 = ext.get_graph_06()
g7 = ext.get_graph_07()
assert g0['name'] == 'G7V_test'
assert g1['name'] == 'G60V'
assert g2['name'] == 'G100V_grid'
assert g3['name'] == 'G256V_grid'
assert g4['name'] == 'G9V_grid'
assert g5['name'] == 'G20_home'
assert g6['name'] == 'G25_home'
assert g7['name'] == 'G70V'
V0, n0 = ext.get_set_vertices(g0)
V1, n1 = ext.get_set_vertices(g1)
V2, n2 = ext.get_set_vertices(g2)
V3, n3 = ext.get_set_vertices(g3)
V4, n4 = ext.get_set_vertices(g4)
V5, n5 = ext.get_set_vertices(g5)
V6, n6 = ext.get_set_vertices(g6)
V7, n7 = ext.get_set_vertices(g7)
assert n0 == 7
assert n1 == 60
assert n2 == 100
assert n3 == 256
assert n4 == 9
assert n5 == 20
assert n6 == 25
assert n7 == 70
g0 = ext.get_graph('G7V_test')
g1 = ext.get_graph('G60V')
g2 = ext.get_graph('G100V_grid')
g3 = ext.get_graph('G256V_grid')
g4 = ext.get_graph('G9V_grid')
g5 = ext.get_graph('G20_home')
g6 = ext.get_graph('G25_home')
g7 = ext.get_graph('G70V')
assert g0['name'] == 'G7V_test'
assert g1['name'] == 'G60V'
assert g2['name'] == 'G100V_grid'
assert g3['name'] == 'G256V_grid'
assert g4['name'] == 'G9V_grid'
assert g5['name'] == 'G20_home'
assert g6['name'] == 'G25_home'
assert g7['name'] == 'G70V'
V0, n0 = ext.get_set_vertices(g0)
V1, n1 = ext.get_set_vertices(g1)
V2, n2 = ext.get_set_vertices(g2)
V3, n3 = ext.get_set_vertices(g3)
V4, n4 = ext.get_set_vertices(g4)
V5, n5 = ext.get_set_vertices(g5)
V6, n6 = ext.get_set_vertices(g6)
V7, n7 = ext.get_set_vertices(g7)
assert n0 == 7
assert n1 == 60
assert n2 == 100
assert n3 == 256
assert n4 == 9
assert n5 == 20
assert n6 == 25
assert n7 == 70
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