def setup(self):
self.substrate = datamodel.Substrate("paper_example_substrate")
self.substrate.add_node("u", ["universal"], {"universal": 1000},
{"universal": 0.0})
self.substrate.add_node("v", ["universal"], {"universal": 1000},
{"universal": 0.0})
self.substrate.add_node("w", ["universal"], {"universal": 1000},
{"universal": 0.0})
self.substrate.add_edge("u", "v", capacity=1000, bidirected=False)
self.substrate.add_edge("v", "w", capacity=1000, bidirected=False)
self.substrate.add_edge("w", "u", capacity=1000, bidirected=False)
self.request = datamodel.Request("paper_example_request")
self.request.add_node("i", 0.0, "universal", ["w"])
self.request.add_node("j", 0.0, "universal", ["v", "w"])
self.request.add_node("k", 0.0, "universal", ["u"])
self.request.add_node("l", 0.0, "universal", ["u", "w"])
self.request.add_node("m", 0.0, "universal", ["u", "v"])
self.request.add_node("n", 0.0, "universal", ["u", "v"])
self.request.add_node("p", 0.0, "universal", ["v"])
self.request.add_node("q", 0.0, "universal", ["u", "w"])
self.request.add_edge("i", "j", 0.0)
self.request.add_edge("j", "k", 0.0)
self.request.add_edge("k", "l", 0.0)
self.request.add_edge("l", "m", 0.0)
self.request.add_edge("m", "j", 0.0)
self.request.add_edge("m", "p", 0.0)
self.request.add_edge("p", "n", 0.0)
self.request.add_edge("p", "q", 0.0)
self.request.graph["root"] = "j"
self.single_edge_sub = datamodel.Substrate("simple_substrate")
self.single_edge_sub.add_node("u", ["universal"], {"universal": 1000},
{"universal": 0.0})
self.single_edge_sub.add_node("v", ["universal"], {"universal": 1000},
{"universal": 0.0})
self.single_edge_sub.add_edge("u",
"v",
capacity=1000,
bidirected=False)
self.simple_cycle_req = datamodel.Request("simple_cycle_request")
self.simple_cycle_req.add_node("i", 0.0, "universal", ["u"])
self.simple_cycle_req.add_node("j", 0.0, "universal", ["v"])
self.simple_cycle_req.add_node("k", 0.0, "universal", ["w"])
self.simple_cycle_req.add_edge("i", "j", 0.0)
self.simple_cycle_req.add_edge("j", "k", 0.0)
self.simple_cycle_req.add_edge("k", "i", 0.0)
self.simple_cycle_req.graph["root"] = "i"
self.single_edge_req = datamodel.Request("simple_path_request")
self.single_edge_req.add_node("i", 0.0, "universal", ["u", "w"])
self.single_edge_req.add_node("j", 0.0, "universal", ["w", "v"])
self.single_edge_req.add_edge("i", "j", 0.0)
self.single_edge_req.graph["root"] = "i"
def setup(self):
scenariogeneration.random.seed(5)
self.substrate = datamodel.Substrate("paper_example_substrate")
self.substrate.add_node("u", ["universal"], {"universal": 10}, {"universal": 0.8})
self.substrate.add_node("v", ["universal"], {"universal": 10}, {"universal": 1.2})
self.substrate.add_node("w", ["universal"], {"universal": 10}, {"universal": 1.0})
self.substrate.add_edge("u", "v", capacity=100, bidirected=False)
self.substrate.add_edge("v", "w", capacity=100, bidirected=False)
self.substrate.add_edge("w", "u", capacity=100, bidirected=False)
self.request = datamodel.Request("test")
self.request.add_node("i", 0.33, "universal", ["w"])
self.request.add_node("j", 0.33, "universal", ["v", "w"])
self.request.add_node("k", 0.33, "universal", ["u"])
self.request.add_node("l", 0.33, "universal", ["u", "w"])
self.request.add_node("m", 0.33, "universal", ["u", "v"])
self.request.add_node("n", 0.33, "universal", ["u", "v"])
self.request.add_node("p", 0.33, "universal", ["v"])
self.request.add_node("q", 0.33, "universal", ["u", "w"])
self.request.add_edge("i", "j", 0.25)
self.request.add_edge("j", "k", 0.25)
self.request.add_edge("k", "l", 0.25)
self.request.add_edge("l", "m", 0.25)
self.request.add_edge("m", "j", 0.25)
self.request.add_edge("m", "p", 0.25)
self.request.add_edge("p", "n", 0.25)
self.request.add_edge("p", "q", 0.25)
self.request.profit = 1000.0
self.request.graph["root"] = "j"
scenariogeneration.random.seed(0)
self.sg = scenariogeneration.ScenarioGenerator("test")
def test_exclude_edge_mappings_with_insufficient_resources(self):
sub = datamodel.Substrate("paper_example_substrate")
sub.add_node("u", ["universal"], {"universal": 100},
{"universal": 0.0})
sub.add_node("v", ["universal"], {"universal": 100},
{"universal": 0.0})
sub.add_node("w", ["universal"], {"universal": 100},
{"universal": 0.0})
sub.add_edge("u", "v", capacity=1, bidirected=False)
sub.add_edge("v", "w", capacity=1000, bidirected=False)
sub.add_edge("w", "u", capacity=1000, bidirected=False)
req = datamodel.Request("test")
req.add_node("n1", 0.0, "universal", ["u"])
req.add_node("n2", 0.0, "universal", ["v"])
req.add_node("n3", 0.0, "universal", ["w"])
req.add_edge("n1", "n2", 10.0)
req.add_edge("n2", "n3", 0.0)
req.graph["root"] = "n1"
insufficient_ext_edge = (ExtendedCactusGraph._super_node_name(
("n1", "n2"), "u", "layer"),
ExtendedCactusGraph._super_node_name(
("n1", "n2"), "v", "layer"))
ok_ext_edge = (ExtendedCactusGraph._super_node_name(("n2", "n3"), "u",
"layer"),
ExtendedCactusGraph._super_node_name(("n2", "n3"), "v",
"layer"))
eg = ExtendedCactusGraph(req, sub)
assert insufficient_ext_edge not in eg.edges, "Extended graph contained edge corresponding to infeasible edge mapping!"
assert ok_ext_edge in eg.edges, "Extended graph did not contain edge corresponding to feasible edge mapping!"
def create_test_request(request_id,
reverse_edges=None,
set_allowed_nodes=True):
"""
:param request_id:
:param reverse_edges: set of edges that should be reversed if they are contained in the original request.
:return:
"""
if reverse_edges is None:
reverse_edges = set()
request_dict = example_requests[request_id]
request = datamodel.Request("{}_req".format(request_id.replace(" ", "_")))
for node in request_dict["nodes"]:
allowed = ["u", "v", "w"]
if "assumed_allowed_nodes" in request_dict:
allowed = request_dict["assumed_allowed_nodes"][node]
if set_allowed_nodes:
request.add_node(node, 1, "test_type", allowed_nodes=allowed)
else:
request.add_node(node, 1, "test_type")
for edge in request_dict["edges"]:
if edge in reverse_edges:
edge = edge[1], edge[0]
request.add_edge(edge[0], edge[1], 1)
return request
def test_decomposition_can_handle_splitting_flows(self):
req = datamodel.Request("test_req")
req.add_node("root", 1.0, "t1", allowed_nodes=["w"])
req.add_node("n2", 1.0, "t1", allowed_nodes=["v", "w"])
req.add_node("n3", 1.0, "t1", allowed_nodes=["u"])
req.add_edge("root", "n2", 1.0)
req.add_edge("root", "n3", 1.0)
req.add_edge("n2", "n3", 1.0)
req.graph["root"] = "root"
sub = datamodel.Substrate("test_sub")
sub.add_node("u", ["t1"], {"t1": 100}, {"t1": 100})
sub.add_node("v", ["t1"], {"t1": 100}, {"t1": 100})
sub.add_node("w", ["t1"], {"t1": 100}, {"t1": 100})
sub.add_edge("u", "v", 1000.0, bidirected=True)
sub.add_edge("v", "w", 1000.0, bidirected=True)
sub.add_edge("w", "u", 1000.0, bidirected=True)
# this is a simple request with a splitting flow that caused 200+ mappings due to a bug
flow_values = {
'node': {
'root': {
'w': 0.5652934510902061
},
'n3': {
'u': 0.565293451090206
}
},
'embedding': 0.5652934510902061,
'edge': {
('v_[n2n3]_[u]', 'u_[n2n3]_[u]'): 0.5625924430120608,
('w_[n2n3]_[u]', 'v_[n2n3]_[u]'): 0.16087557584604475,
('u_[rootn3]_[u]', 'u_[n3]_-'): 0.5652934510902061,
('v_[rootn2]_[u]', 'v_[n2n3]_[u]'): 0.40171686716601607,
('w_[root]_+', 'w_[rootn2]_[u]'): 0.5652934510902061,
('w_[rootn2]_[u]', 'v_[rootn2]_[u]'): 0.40171686716601607,
('w_[rootn3]_[u]', 'u_[rootn3]_[u]'): 0.5652934510902061,
('w_[root]_+', 'w_[rootn3]_[u]'): 0.5652934510902061,
('w_[n2n3]_[u]', 'u_[n2n3]_[u]'): 0.00270100807814525,
('w_[rootn2]_[u]', 'w_[n2n3]_[u]'): 0.16357658392419,
('u_[n2n3]_[u]', 'u_[n3]_-'): 0.565293451090206
}
}
decomposition = modelcreator_ecg_decomposition.Decomposition(
req, sub, flow_values, 0.0001, 0.0001, 1e-10)
mappings = decomposition.compute_mappings()
assert len(mappings) == 3
expected_flow_values = {
0.40171686716601607, 0.16087557584604475, 0.00270100807814525
}
for m, flow, load in mappings:
best_matching_value = min(
(expected for expected in expected_flow_values),
key=lambda expected: abs(expected - flow))
expected_flow_values.remove(best_matching_value)
assert flow == pytest.approx(best_matching_value, rel=0.001)
def setup(self):
self.substrate = datamodel.Substrate("sub1")
self.request = datamodel.Request("req1")
self.scenario = datamodel.Scenario("Sen1", self.substrate,
[self.request])
self.mapping = solutions.Mapping("map1", self.request, self.substrate,
True)
self.scenariosolution = solutions.IntegralScenarioSolution(
"Solution1", self.scenario)
def triangle_request():
req = datamodel.Request("test_req")
req.add_node(i, 1.0, "t1", [u])
req.add_node(j, 1.0, "t1", [v])
req.add_node(k, 1.0, "t1", [u, v])
req.add_edge(i, j, 1.0, None)
req.add_edge(j, k, 1.0, None)
req.add_edge(i, k, 1.0, None)
req.graph["root"] = i
return req
def test_multiple_compenents_raise_exception(self):
request = datamodel.Request("foo")
request.add_node("i1", 1, "universal", {"u"})
request.add_node("i2", 1, "universal", {"u"})
request.add_node("i3", 1, "universal", {"u"})
request.add_node("i4", 1, "universal", {"u"})
request.add_edge("i1", "i2", 1)
request.add_edge("i3", "i4", 1)
with pytest.raises(ExtendedCactusGraphError) as excinfo:
ExtendedCactusGraph(request, self.substrate)
assert excinfo.match("Request graph may have multiple components:")
def _initialize_bfs_request(self):
self.bfs_request = datamodel.Request("{}_bfs".format(
self.original_request.name))
for node in self.original_request.nodes:
demand = self.original_request.node[node]["demand"]
ntype = self.original_request.node[node]["type"]
allowed = self.original_request.node[node]["allowed_nodes"]
self.bfs_request.add_node(node,
demand=demand,
ntype=ntype,
allowed_nodes=allowed)
self._add_bfs_edges_and_initialize_exploration_queue_with_leaf_nodes()
def test_find_node_labels_errors_directed_cycle():
req = datamodel.Request("test_req")
req.add_node(i, 1.0, "t1", [u, v])
req.add_node(j, 1.0, "t1", [v, w])
req.add_node(k, 1.0, "t1", [u, w])
req.graph["root"] = i
req.add_edge(i, j, 1.0)
req.add_edge(j, k, 1.0)
req.add_edge(k, i, 1.0)
with pytest.raises(commutativity_model.CommutativityModelError) as e:
commutativity_model.CommutativityLabels.create_labels(req)
assert str(e.value) == "Request is no DAG: cycle contains i, k"
def test_initialize_dag_request_error_with_multiple_components():
req = datamodel.Request("test_req")
req.add_node(i, 1.0, "t1", [u, v])
req.add_node(j, 1.0, "t1", [v, w])
req.add_node(k, 1.0, "t1", [u, w])
req.add_node("l", 1.0, "t1", [u, w])
req.graph["root"] = i
req.add_edge(i, j, 1.0)
req.add_edge(k, "l", 1.0)
with pytest.raises(commutativity_model.CommutativityModelError) as e:
commutativity_model.CommutativityModelCreator._initialize_dag_request(req)
assert str(e.value).startswith("Request graph may have multiple components: Nodes set(['k', 'l']) were not visited by bfs.")
def test_exclude_node_mappings_with_insufficient_resources(self):
sub = datamodel.Substrate("paper_example_substrate")
sub.add_node("u", ["t1", "t2"], {
"t1": 100,
"t2": 100
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_node("v", ["t1", "t2"], {
"t1": 100,
"t2": 0.0
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_node("w", ["t1", "t2"], {
"t1": 100,
"t2": 100
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_edge("u", "v", capacity=1000, bidirected=False)
sub.add_edge("v", "w", capacity=1000, bidirected=False)
sub.add_edge("w", "u", capacity=1000, bidirected=False)
req = datamodel.Request("test")
req.add_node("n1", 10.0, "t1", allowed_nodes=["u"])
req.add_node("n2", 10.0, "t2", allowed_nodes=["v", "w"])
req.add_node("n3", 10.0, "t1", allowed_nodes=["w"])
req.add_edge("n1", "n2", 10.0)
req.add_edge("n2", "n3", 0.0)
req.graph["root"] = "n1"
should_not_exist = (ExtendedCactusGraph._super_node_name(
("n1", "n2"), "v",
"layer"), ExtendedCactusGraph._super_node_name("n2", "v", "sink"))
should_exist = (ExtendedCactusGraph._super_node_name(
("n1", "n2"), "w",
"layer"), ExtendedCactusGraph._super_node_name("n2", "w", "sink"))
eg = ExtendedCactusGraph(req, sub)
for u in eg.nodes:
print u
for e in eg.edges:
print e
assert should_not_exist not in eg.edges, "Extended graph contained edge corresponding to infeasible node mapping in path"
assert should_exist in eg.edges, "Extended graph did not contain edge corresponding to feasible node mapping"
def test_find_node_labels_errors_root_with_inneighbors():
req = datamodel.Request("test_req")
req.add_node(i, 1.0, "t1", [u, v])
req.add_node(j, 1.0, "t1", [v, w])
req.add_node(k, 1.0, "t1", [u, w])
req.add_node("l", 1.0, "t1", [u, w])
req.graph["root"] = i
req.add_edge(i, j, 1.0)
req.add_edge("l", i, 1.0)
req.add_edge(i, k, 1.0)
req.add_edge(k, j, 1.0)
with pytest.raises(commutativity_model.CommutativityModelError) as e:
commutativity_model.CommutativityLabels.create_labels(req)
assert str(e.value) == "Root node i has in-neighbors ['l']"
def test_find_node_labels_errors_two_root_nodes():
req = datamodel.Request("test_req")
req.add_node(i, 1.0, "t1", [u, v])
req.add_node(j, 1.0, "t1", [v, w])
req.add_node(k, 1.0, "t1", [u, w])
req.add_node("l", 1.0, "t1", [u, w])
req.graph["root"] = i
req.add_edge(i, j, 1.0)
req.add_edge(i, "l", 1.0)
req.add_edge(k, j, 1.0)
req.add_edge(k, "l", 1.0)
with pytest.raises(commutativity_model.CommutativityModelError) as e:
commutativity_model.CommutativityLabels.create_labels(req)
assert str(e.value) == "Node k has no parents, but is not root (root is i). May have multiple components or not be rooted"
def create_large_request(num_nodes, sub, topology):
if num_nodes > 26:
num_nodes = 26
reverse_edges = set()
request_dict = example_requests[topology]
request = datamodel.Request("{}_req".format(topology.replace(" ", "_")))
for node in request_dict["nodes"]:
allowed = sub.nodes
if "assumed_allowed_nodes" in request_dict:
allowed = request_dict["assumed_allowed_nodes"][node]
request.add_node(node, 1, "test_type", allowed_nodes=allowed)
for edge in request_dict["edges"]:
if edge in reverse_edges:
edge = edge[1], edge[0]
request.add_edge(edge[0], edge[1], 1)
return request
def test_get_valid_substrate_nodes(substrate):
req = datamodel.Request("test_req")
req.add_node(i, 1.0, "t1", [u, v])
req.add_node(j, 1.0, "t1", [v, w])
req.add_node(k, 1.0, "t1", [u, w])
_get_valid_substrate_nodes = commutativity_model.CommutativityModelCreator._get_valid_substrate_nodes.__func__
class MockModelCreator(object):
pass
mmc = MockModelCreator()
mmc.substrate = datamodel.SubstrateX(substrate)
assert (_get_valid_substrate_nodes(mmc, req, {i, j, k}) == {
i: {u, v},
j: {v, w},
k: {u, w},
})
def get_clique_request(number_of_nodes, name="test_request", demand=1.0):
"""
Generate a complete graph as a single request.
:param number_of_nodes:
:param name:
:param demand:
:return:
"""
test_request = datamodel.Request(name)
for i in range(1, number_of_nodes + 1):
test_request.add_node("{}_node_{}".format(name, i), demand,
scenariogeneration.UNIVERSAL_NODE_TYPE)
for i in range(1, number_of_nodes + 1):
for j in range(i + 1, number_of_nodes + 1):
test_request.add_edge("{}_node_{}".format(name, i),
"{}_node_{}".format(name, j), demand)
return test_request
def test_bug_request(self):
req = datamodel.Request("test")
req.add_node("n1", 0.0, "universal", ["u", "w"])
req.add_node("n2", 0.0, "universal", ["u", "w"])
req.add_node("n3", 0.0, "universal", ["u", "w"])
req.add_node("n4", 0.0, "universal", ["u", "w"])
req.add_node("n5", 0.0, "universal", ["u", "w"])
req.add_node("n6", 0.0, "universal", ["u", "w"])
req.add_node("n7", 0.0, "universal", ["u", "w"])
req.add_edge("n1", "n2", 0.0)
req.add_edge("n2", "n3", 0.0)
req.add_edge("n3", "n7", 0.0)
req.add_edge("n3", "n6", 0.0)
req.add_edge("n2", "n4", 0.0)
req.add_edge("n4", "n5", 0.0)
req.add_edge("n5", "n6", 0.0)
req.graph["root"] = "n1"
eg = ExtendedCactusGraph(req, self.substrate)
def _initialize_dag_request(cls, req):
"""
Create a DAG request for the request.
:param req: the request
:return: a rooted DAG request
"""
dag_request = datamodel.Request("{}_dag".format(req.name))
for node in req.nodes:
demand = req.get_node_demand(node)
ntype = req.get_type(node)
allowed = req.get_allowed_nodes(node)
dag_request.add_node(node,
demand=demand,
ntype=ntype,
allowed_nodes=allowed)
cls._add_dag_edges_and_initialize_exploration_queue_with_leaf_nodes(
req, dag_request)
return dag_request
def create_test_request(request_id,
test_substrate,
reversed_edges=None,
allowed_nodes=None,
allowed_edges=None,
node_types=None,
node_demands=None,
edge_demands=None):
if reversed_edges is None:
reversed_edges = set()
if allowed_nodes is None:
allowed_nodes = {}
if allowed_edges is None:
allowed_edges = {}
if node_types is None:
node_types = {}
if node_demands is None:
node_demands = {}
if edge_demands is None:
edge_demands = {}
req_nodes = REQUEST_TOPOLOGIES[request_id]["nodes"]
req_edges = REQUEST_TOPOLOGIES[request_id]["edges"]
request = datamodel.Request("{}_req".format(request_id.replace(" ", "_")))
for i in req_nodes:
i_type = node_types.get(i, "t")
i_demand = node_demands.get(i, 1.0)
i_allowed_nodes = allowed_nodes.get(i, set(test_substrate.nodes))
request.add_node(i,
demand=i_demand,
ntype=i_type,
allowed_nodes=i_allowed_nodes)
for ij in req_edges:
if ij in reversed_edges:
ij = ij[1], ij[0]
ij_demand = edge_demands.get(ij, 1.0)
ij_allowed = allowed_edges.get(ij)
request.add_edge(ij[0], ij[1], ij_demand, allowed_edges=ij_allowed)
return request
def generate_random_request_graph(size,
prob,
req_name="test_req",
substrate_nodes=(u, v, w)):
req = datamodel.Request(req_name)
for i in range(1, size + 1):
node = "{}".format(i)
neighbors = []
for j in req.nodes:
if random.random() <= prob:
neighbors.append(j)
req.add_node(
node, 1.0, "t1",
random.sample(substrate_nodes,
random.randrange(1, len(substrate_nodes))))
for j in neighbors:
req.add_edge(j, node, 1.0)
visited = set()
all_nodes = set(req.nodes)
while visited != all_nodes:
start_node = (all_nodes - visited).pop()
if visited:
req.add_edge(random.choice(list(visited)), start_node, 1.0)
visited.add(start_node)
stack = [start_node]
while stack:
i = stack.pop()
neighbors = req.get_in_neighbors(i) + req.get_out_neighbors(i)
for j in neighbors:
if j in visited:
continue
else:
stack.append(j)
visited.add(j)
req.graph["root"] = random.choice(list(req.nodes))
return req
def test_model_fixing_simple_scenario(self):
sub = datamodel.Substrate("fixing_sub")
sub.add_node("u", {"t1"}, {"t1": 10}, {"t1": 100})
sub.add_node("v", {"t1"}, {"t1": 10}, {"t1": 100})
sub.add_node("w", {"t1"}, {"t1": 10}, {"t1": 100})
sub.add_node("x", {"t1"}, {"t1": 10}, {"t1": 100})
sub.add_edge("u", "v")
sub.add_edge("v", "w")
sub.add_edge("w", "x")
sub.add_edge("x", "u")
req = datamodel.Request("fixing_req")
req.profit = 1000
req.add_node("i", 5, "t1", {"u", "v", "w", "x"})
req.add_node("j", 5, "t1", {"u", "v", "w", "x"})
req.add_edge("i", "j", 0.5)
mapping = solutions.Mapping("fixing_mapping", req, sub, True)
mapping.map_node("i", "u")
mapping.map_node("j", "x")
mapping.map_edge(("i", "j"), [("u", "v"), ("v", "w"), ("w", "x")])
scenario = datamodel.Scenario("fixing_scen", sub, [req],
datamodel.Objective.MAX_PROFIT)
sol = solutions.IntegralScenarioSolution("fixing_sol", scenario)
sol.add_mapping(req, mapping)
mc_ecg = modelcreator_ecg_decomposition.ModelCreatorCactusDecomposition(
scenario)
mc_ecg.init_model_creator()
mc_ecg.fix_mapping_variables_according_to_integral_solution(sol)
ecg_sol = mc_ecg.compute_integral_solution()
new_mapping = ecg_sol.solution.request_mapping[req]
assert new_mapping.mapping_nodes == mapping.mapping_nodes
assert new_mapping.mapping_edges == mapping.mapping_edges
def setup(self):
self.substrate = datamodel.Substrate("sub1")
self.request = datamodel.Request("req1")
self.scenario = datamodel.Scenario("Sen1", self.substrate, [self.request])
def setup(self):
self.request = datamodel.Request("req1")
def test_handmade_example_containing_multiple_mappings(self):
req = datamodel.Request("test_req")
req.add_node("i", 1.0, "t1", allowed_nodes=["w"])
req.add_node("j", 1.0, "t1", allowed_nodes=["v", "w"])
req.add_node("k", 1.0, "t1", allowed_nodes=["u"])
req.add_node("l", 1.0, "t1", allowed_nodes=["u", "v"])
req.add_edge("i", "j", 1.0)
req.add_edge("j", "k", 1.0)
req.add_edge("i", "k", 1.0)
req.add_edge("j", "l", 1.0)
req.graph["root"] = "i"
sub = datamodel.Substrate("test_sub")
sub.add_node("u", ["t1"], {"t1": 100}, {"t1": 100})
sub.add_node("v", ["t1"], {"t1": 100}, {"t1": 100})
sub.add_node("w", ["t1"], {"t1": 100}, {"t1": 100})
sub.add_edge("u", "v", 1000.0, bidirected=True)
sub.add_edge("v", "w", 1000.0, bidirected=True)
sub.add_edge("w", "u", 1000.0, bidirected=True)
ext_graph = extendedcactusgraph.ExtendedCactusGraph(req, sub)
# print util.get_graph_viz_string(ext_graph)
# print "\n".join(str(e) for e in ext_graph.nodes)
# print "\n".join(str(e) for e in ext_graph.edges)
flow_values = {
'embedding': 1.0,
'node': {
'i': {
'w': 1.0
},
'j': {
'v': 0.5,
'w': 0.5
},
'k': {
'u': 1.0
},
'l': {
'v': 0.5,
'u': 0.5
}
},
'edge': {
('w_[i]_+', 'w_[ij]_[u]'): 1.0,
('w_[ij]_[u]', 'w_[jk]_[u]'): 0.5,
('w_[ij]_[u]', 'v_[ij]_[u]'): 0.5,
('v_[ij]_[u]', 'v_[jk]_[u]'): 0.5,
('v_[jk]_[u]', 'u_[jk]_[u]'): 0.5,
('w_[jk]_[u]', 'u_[jk]_[u]'): 0.5,
('u_[jk]_[u]', 'u_[k]_-'): 1.0,
('v_[j]_+', 'v_[jl]'): 0.5,
('w_[j]_+', 'w_[jl]'): 0.5,
('v_[jl]', 'v_[l]_-'): 0.5,
('w_[jl]', 'u_[jl]'): 0.5,
('u_[jl]', 'u_[l]_-'): 0.5,
('w_[i]_+', 'w_[ik]_[u]'): 1.0,
('w_[ik]_[u]', 'u_[ik]_[u]'): 1.0,
('u_[ik]_[u]', 'u_[k]_-'): 1.0,
}
}
decomposition = modelcreator_ecg_decomposition.Decomposition(
req, sub, flow_values, 0.0001, 0.0001, 1e-10)
mappings = decomposition.compute_mappings()
assert len(mappings) == 2
expected_flow_values = [0.5, 0.5]
for m, flow, load in mappings:
best_matching_value = min(
(expected for expected in expected_flow_values),
key=lambda expected: abs(expected - flow))
expected_flow_values.remove(best_matching_value)
assert flow == pytest.approx(best_matching_value)
def test_exclude_node_mappings_with_insufficient_resources_cycle(self):
# check for a cycle
sub = datamodel.Substrate("test_substrate")
sub.add_node("u", ["t1", "t2"], {
"t1": 100,
"t2": 100
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_node("v", ["t1", "t2"], {
"t1": 100,
"t2": 0.0
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_node("w", ["t1", "t2"], {
"t1": 100,
"t2": 100
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_node("x", ["t1"], {"t1": 1.0}, {"t1": 0.0})
sub.add_edge("u", "v", capacity=1000, bidirected=False)
sub.add_edge("v", "w", capacity=1000, bidirected=False)
sub.add_edge("w", "u", capacity=1000, bidirected=False)
sub.add_edge("w", "x", capacity=1000, bidirected=False)
req = datamodel.Request("test_request")
req.graph["root"] = "n1"
req.add_node("n1", 10.0, "t1", allowed_nodes=["u"])
req.add_node("n2", 10.0, "t2", allowed_nodes=["v", "w"])
req.add_node("n3", 10.0, "t1", allowed_nodes=["w"])
req.add_node("target", 10.0, "t1", allowed_nodes=["w", "x"])
req.add_edge("n1", "n2", 10.0)
req.add_edge("n2", "target", 10.0)
req.add_edge("n1", "n3", 10.0)
req.add_edge("n3", "target", 10.0)
eg = ExtendedCactusGraph(req, sub)
should_not_exist = (ExtendedCactusGraph._super_node_name(
("n1", "n2"), "v", "layer_cycle", branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(
("n2", "target"),
"v",
"layer_cycle",
branch_substrate_node="w"))
should_exist = (ExtendedCactusGraph._super_node_name(
("n1", "n2"), "w", "layer_cycle", branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(
("n2", "target"),
"w",
"layer_cycle",
branch_substrate_node="w"))
print should_not_exist
print should_exist
for u in eg.nodes:
print u
for e in eg.edges:
print e
assert should_exist in eg.edges, "Extended graph did not contain edge corresponding to feasible node mapping"
assert should_not_exist not in eg.edges, "Extended graph contained edge corresponding to infeasible node mapping in cycle"
should_not_exist = ExtendedCactusGraph._super_node_name(
("n1", "n2"), "v", "layer_cycle", branch_substrate_node="x")
should_exist = ExtendedCactusGraph._super_node_name(
("n1", "n2"), "v", "layer_cycle", branch_substrate_node="w")
assert should_not_exist not in eg.nodes, "Extended graph contained edge corresponding to infeasible node mapping in cycle"
def test_exclude_edge_mappings_with_insufficient_resources_cycle(self):
sub = datamodel.Substrate("test_substrate")
sub.add_node("u", ["t1", "t2"], {
"t1": 100,
"t2": 100
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_node("v", ["t1", "t2"], {
"t1": 100,
"t2": 100
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_node("w", ["t1", "t2"], {
"t1": 100,
"t2": 100
}, {
"t1": 0.0,
"t2": 0.0
})
sub.add_edge("w", "u", capacity=10.0, bidirected=False)
sub.add_edge("v", "w", capacity=50.0, bidirected=False)
sub.add_edge("u", "v", capacity=100.0, bidirected=False)
req = datamodel.Request("test_request")
req.graph["root"] = "n1"
req.add_node("n1", 10.0, "t1", allowed_nodes=["u", "v", "w"])
req.add_node("n2", 10.0, "t2", allowed_nodes=["u", "v", "w"])
req.add_node("n3", 10.0, "t1", allowed_nodes=["w"])
req.add_edge("n1", "n2", 1.0)
req.add_edge("n2", "n3", 50.0)
req.add_edge("n1", "n3", 100.0)
eg = ExtendedCactusGraph(req, sub)
from alib.util import get_graph_viz_string
print get_graph_viz_string(eg)
should_not_exist = [
(ExtendedCactusGraph._super_node_name(("n2", "n3"),
"w",
"layer_cycle",
branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(("n2", "n3"),
"u",
"layer_cycle",
branch_substrate_node="w")),
(ExtendedCactusGraph._super_node_name(("n1", "n3"),
"w",
"layer_cycle",
branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(("n1", "n3"),
"u",
"layer_cycle",
branch_substrate_node="w")),
(ExtendedCactusGraph._super_node_name(("n1", "n3"),
"v",
"layer_cycle",
branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(("n1", "n3"),
"w",
"layer_cycle",
branch_substrate_node="w")),
]
should_exist = [
(ExtendedCactusGraph._super_node_name(("n2", "n3"),
"u",
"layer_cycle",
branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(("n2", "n3"),
"v",
"layer_cycle",
branch_substrate_node="w")),
(ExtendedCactusGraph._super_node_name(("n2", "n3"),
"v",
"layer_cycle",
branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(("n2", "n3"),
"w",
"layer_cycle",
branch_substrate_node="w")),
(ExtendedCactusGraph._super_node_name(("n1", "n3"),
"u",
"layer_cycle",
branch_substrate_node="w"),
ExtendedCactusGraph._super_node_name(("n1", "n3"),
"v",
"layer_cycle",
branch_substrate_node="w")),
]
for e in should_exist:
assert e in eg.edges
for e in should_not_exist:
assert e not in eg.edges
