def exercise_simple_loops(loop_size_max=10):
for n_vertices in xrange(3, loop_size_max + 1):
edge_list = [
tuple(sorted((i, (i + 1) % n_vertices)))
for i in xrange(n_vertices)
]
edge_sets = utils.construct_edge_sets(n_vertices=n_vertices,
edge_list=edge_list)
loops, dendrites = find_paths(edge_sets=edge_sets).search_from(iv=0)
if (n_vertices <= 7):
assert len(loops) == 2
assert sorted(dendrites.keys()) == range(1, n_vertices)
else:
assert len(loops) == 0
assert sorted(dendrites.keys()) == range(2, n_vertices - 1)
if (n_vertices == 3):
assert loops == {1: [[2]], 2: [[1]]}
assert dendrites == {1: [set([2])], 2: [set([1])]}
elif (n_vertices == 4):
assert loops == {1: [[2, 3]], 3: [[2, 1]]}
assert dendrites == {
1: [set([2, 3])],
2: [set([1]), set([3])],
3: [set([1, 2])]
}
def angles(O):
return graph_utils.extract_edge_list(
graph_utils.bond_bending_edge_sets(
edge_sets=graph_utils.construct_edge_sets(
n_vertices=len(O.sites),
edge_list=O.bonds),
omit_bonds=True))
def exercise_knot():
edge_sets = utils.construct_edge_sets(n_vertices=4,
edge_list=[(0, 1), (1, 2), (2, 3),
(1, 3)])
expected_loops_dendrites = [({}, {
2: [set([1]), set([1, 3])],
3: [set([1, 2]), set([1])]
}), ({
2: [[3]],
3: [[2]]
}, {
2: [set([3])],
3: [set([2])]
}), ({
1: [[3]],
3: [[1]]
}, {
0: [set([1])],
1: [set([3])],
3: [set([1])]
}), ({
1: [[2]],
2: [[1]]
}, {
0: [set([1])],
1: [set([2])],
2: [set([1])]
})]
for iv in xrange(4):
loop_dendrites = find_paths(edge_sets=edge_sets).search_from(iv=iv)
assert loop_dendrites == expected_loops_dendrites[iv]
def angles(O):
return graph_utils.extract_edge_list(
graph_utils.bond_bending_edge_sets(
edge_sets=graph_utils.construct_edge_sets(n_vertices=len(
O.sites),
edge_list=O.bonds),
omit_bonds=True))
def arch_dof(n_vertices, edge_list):
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=edge_list)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
dofs = [rigidity.determine_degrees_of_freedom(
n_dim=3, n_vertices=n_vertices, edge_list=bbel, method=method)
for method in ["float", "integer"]]
assert dofs[0] == dofs[1]
return es, dofs[0]
def arch_dof(n_vertices, edge_list):
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=edge_list)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
dofs = [rigidity.determine_degrees_of_freedom(
n_dim=3, n_vertices=n_vertices, edge_list=bbel, method=method)
for method in ["float", "integer"]]
assert dofs[0] == dofs[1]
return es, dofs[0]
def exercise_knot():
edge_sets = utils.construct_edge_sets(
n_vertices=4,
edge_list=[(0,1), (1,2), (2,3), (1,3)])
expected_loops_dendrites = [
({}, {2: [set([1]), set([1, 3])], 3: [set([1, 2]), set([1])]}),
({2: [[3]], 3: [[2]]}, {2: [set([3])], 3: [set([2])]}),
({1: [[3]], 3: [[1]]}, {0: [set([1])], 1: [set([3])], 3: [set([1])]}),
({1: [[2]], 2: [[1]]}, {0: [set([1])], 1: [set([2])], 2: [set([1])]})]
for iv in xrange(4):
loop_dendrites = find_paths(edge_sets=edge_sets).search_from(iv=iv)
assert loop_dendrites == expected_loops_dendrites[iv]
def exercise_fixed_vertices(n_trials=10):
cm = cluster_manager(n_vertices=2, fixed_vertex_lists=[[0]])
assert cm.clusters == [[0], [1]]
cm = cluster_manager(n_vertices=2, fixed_vertex_lists=[[1]])
assert cm.clusters == [[1], [0]]
edge_list = [(0,1),(1,2),(2,3),(1,3)]
edge_sets = construct_edge_sets(n_vertices=4, edge_list=edge_list)
for fixed_vertex in [0,1]:
for optimize in [False, True]:
for connects in [[(1,2),(2,3)], [(2,3),(1,2)], [(2,1),(3,2)]]:
cm = cluster_manager(n_vertices=4, fixed_vertex_lists=[[fixed_vertex]])
for i,j in connects:
cm.connect_vertices(i=i, j=j, optimize=optimize)
if (fixed_vertex == 0):
if (connects[0] == (2,1)):
if (not optimize):
assert cm.clusters == [[0], [], [], [3, 2, 1]]
else:
assert cm.clusters == [[0], [], [2, 1, 3], []]
else:
if (not optimize or connects[0][0] == 1):
assert cm.clusters == [[0], [1,2,3], [], []]
else:
assert cm.clusters == [[0], [], [2,3,1], []]
cm.tidy()
assert cm.clusters == [[0], [1,2,3]]
else:
assert cm.clusters == [[1,2,3], [0], [], []]
cm.tidy()
assert cm.clusters == [[1,2,3], [0]]
cm.construct_spanning_trees(edge_sets=edge_sets)
assert cm.clusters == [[0,1,2,3]]
assert cm.hinge_edges == [(-1,1)]
assert cm.loop_edges == []
#
from scitbx.graph import test_cases_tardy_pdb
tc = test_cases_tardy_pdb.test_cases[5]
assert tc.tag == "tyr_with_h"
tt = tc.tardy_tree_construct(fixed_vertex_lists=[[0,16,17]])
assert tt.cluster_manager.clusters == [
[0,1,2,3,4,5,6,7,8,9,10,12,13,14,15,16,17,18,19],
[11], [20]]
try:
tc.tardy_tree_construct(fixed_vertex_lists=[[0],[1]])
except RuntimeError, e:
assert str(e) == \
"connect_clusters(): fixed vertex lists in same connected tree."
def __init__(O,
n_vertices=None,
sites=None,
edge_list=None,
external_clusters=None,
fixed_vertices=None,
fixed_vertex_lists=None,
near_singular_hinges_angular_tolerance_deg=5):
assert [n_vertices, sites].count(None) == 1
assert edge_list is not None
assert [fixed_vertices, fixed_vertex_lists].count(None) != 0
if (sites is not None):
n_vertices = len(sites)
O.n_vertices = n_vertices
all_in_one_rigid_body = (edge_list == "all_in_one_rigid_body")
if (all_in_one_rigid_body):
assert external_clusters is None
O.edge_list = None
O.edge_sets = None
else:
O.edge_list = edge_list
O.edge_sets = construct_edge_sets(n_vertices=n_vertices,
edge_list=edge_list)
if (fixed_vertex_lists is None):
if (fixed_vertices is None or len(fixed_vertices) == 0):
fixed_vertex_lists = ()
else:
assert O.edge_sets is not None # not implemented
fixed_vertex_lists = tree_marking(edge_sets=O.edge_sets) \
.partitions_of(vertex_indices=fixed_vertices)
O.cluster_manager = cluster_manager(
n_vertices=n_vertices,
all_in_one_rigid_body=all_in_one_rigid_body,
fixed_vertex_lists=fixed_vertex_lists)
if (not all_in_one_rigid_body):
O._find_paths()
O._process_external_clusters(clusters=external_clusters)
O.cluster_manager.tidy()
O.find_cluster_loop_repeats = None
if (sites is not None):
O.build_tree()
O.fix_near_singular_hinges(
sites=sites,
angular_tolerance_deg=near_singular_hinges_angular_tolerance_deg
)
def __init__(O,
n_vertices=None,
sites=None,
edge_list=None,
external_clusters=None,
fixed_vertices=None,
fixed_vertex_lists=None,
near_singular_hinges_angular_tolerance_deg=5):
assert [n_vertices, sites].count(None) == 1
assert edge_list is not None
assert [fixed_vertices, fixed_vertex_lists].count(None) != 0
if (sites is not None):
n_vertices = len(sites)
O.n_vertices = n_vertices
all_in_one_rigid_body = (edge_list == "all_in_one_rigid_body")
if (all_in_one_rigid_body):
assert external_clusters is None
O.edge_list = None
O.edge_sets = None
else:
O.edge_list = edge_list
O.edge_sets = construct_edge_sets(
n_vertices=n_vertices, edge_list=edge_list)
if (fixed_vertex_lists is None):
if (fixed_vertices is None or len(fixed_vertices) == 0):
fixed_vertex_lists = ()
else:
assert O.edge_sets is not None # not implemented
fixed_vertex_lists = tree_marking(edge_sets=O.edge_sets) \
.partitions_of(vertex_indices=fixed_vertices)
O.cluster_manager = cluster_manager(
n_vertices=n_vertices,
all_in_one_rigid_body=all_in_one_rigid_body,
fixed_vertex_lists=fixed_vertex_lists)
if (not all_in_one_rigid_body):
O._find_paths()
O._process_external_clusters(clusters=external_clusters)
O.cluster_manager.tidy()
O.find_cluster_loop_repeats = None
if (sites is not None):
O.build_tree()
O.fix_near_singular_hinges(
sites=sites,
angular_tolerance_deg=near_singular_hinges_angular_tolerance_deg)
def build_clash_detector(n_sites, bond_list, threshold):
import scitbx.r3_utils
result = scitbx.r3_utils.clash_detector_simple(
n_sites=n_sites, threshold=threshold)
from scitbx.graph import utils
bond_sets = utils.construct_edge_sets(
n_vertices=n_sites, edge_list=bond_list)
def add_exclusions(edge_sets):
for i,edge_set in enumerate(edge_sets):
for j in edge_set:
if (i < j):
result.add_exclusion(i=i, j=j)
add_exclusions(edge_sets=bond_sets)
angle_sets = utils.bond_bending_edge_sets(edge_sets=bond_sets)
add_exclusions(edge_sets=angle_sets)
for i,j in utils.potential_implied_edge_list(
edge_sets=bond_sets, bond_bending_edge_sets=angle_sets):
result.add_exclusion(i=i, j=j)
return result
def exercise_simple_loops(loop_size_max=10):
for n_vertices in xrange(3, loop_size_max+1):
edge_list = [tuple(sorted((i,(i+1)%n_vertices)))
for i in xrange(n_vertices)]
edge_sets = utils.construct_edge_sets(
n_vertices=n_vertices, edge_list=edge_list)
loops, dendrites = find_paths(edge_sets=edge_sets).search_from(iv=0)
if (n_vertices <= 7):
assert len(loops) == 2
assert sorted(dendrites.keys()) == range(1,n_vertices)
else:
assert len(loops) == 0
assert sorted(dendrites.keys()) == range(2,n_vertices-1)
if (n_vertices == 3):
assert loops == {1: [[2]], 2: [[1]]}
assert dendrites == {1: [set([2])], 2: [set([1])]}
elif (n_vertices == 4):
assert loops == {1: [[2, 3]], 3: [[2, 1]]}
assert dendrites == {
1: [set([2, 3])], 2: [set([1]), set([3])], 3: [set([1, 2])]}
def exercise_tree_marking():
tree_marking = utils.tree_marking
el = []
for n_vertices in xrange(5):
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == range(n_vertices)
el = [(0,1)]
for n_vertices in xrange(2,5):
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0] + range(n_vertices-1)
el = [(2,5)]
es = utils.construct_edge_sets(n_vertices=7, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0,1,2,3,4,2,5]
for n_vertices in xrange(7):
el = [(i,i+1) for i in xrange(n_vertices-1)]
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0] * n_vertices
el = [(0,1),(2,3)]
es = utils.construct_edge_sets(n_vertices=4, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0,0,1,1]
el = [(1,2),(0,3)]
es = utils.construct_edge_sets(n_vertices=4, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0,1,1,0]
el = [
(8,9),(7,9),(3,7),(8,11),(8,12),(12,14),(13,15),(7,13),
(1,6),(4,6),
(0,5)]
es = utils.construct_edge_sets(n_vertices=16, edge_list=el)
tm = tree_marking(edge_sets=es)
assert tm.indices == [0,1,2,3,1,0,1,3,3,3,4,3,3,3,3,3]
assert tm.partitions_of(vertex_indices=()) == []
for i in xrange(16):
assert tm.partitions_of(vertex_indices=[i]) == [[i]]
assert tm.partitions_of(vertex_indices=[14,3]) == [[14,3]]
assert tm.partitions_of(vertex_indices=[5,10]) == [[5],[10]]
assert tm.partitions_of(vertex_indices=range(16)) == [
[0,5], [1,4,6], [2], [3,7,8,9,11,12,13,14,15], [10]]
def exercise_tree_marking():
tree_marking = utils.tree_marking
el = []
for n_vertices in range(5):
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == list(range(n_vertices))
el = [(0, 1)]
for n_vertices in range(2, 5):
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0] + list(range(n_vertices - 1))
el = [(2, 5)]
es = utils.construct_edge_sets(n_vertices=7, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0, 1, 2, 3, 4, 2, 5]
for n_vertices in range(7):
el = [(i, i + 1) for i in range(n_vertices - 1)]
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0] * n_vertices
el = [(0, 1), (2, 3)]
es = utils.construct_edge_sets(n_vertices=4, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0, 0, 1, 1]
el = [(1, 2), (0, 3)]
es = utils.construct_edge_sets(n_vertices=4, edge_list=el)
ti = tree_marking(edge_sets=es).indices
assert ti == [0, 1, 1, 0]
el = [(8, 9), (7, 9), (3, 7), (8, 11), (8, 12), (12, 14), (13, 15),
(7, 13), (1, 6), (4, 6), (0, 5)]
es = utils.construct_edge_sets(n_vertices=16, edge_list=el)
tm = tree_marking(edge_sets=es)
assert tm.indices == [0, 1, 2, 3, 1, 0, 1, 3, 3, 3, 4, 3, 3, 3, 3, 3]
assert tm.partitions_of(vertex_indices=()) == []
for i in range(16):
assert tm.partitions_of(vertex_indices=[i]) == [[i]]
assert tm.partitions_of(vertex_indices=[14, 3]) == [[14, 3]]
assert tm.partitions_of(vertex_indices=[5, 10]) == [[5], [10]]
assert tm.partitions_of(vertex_indices=list(range(16))) == [[
0, 5
], [1, 4, 6], [2], [3, 7, 8, 9, 11, 12, 13, 14, 15], [10]]
def run(args):
assert len(args) == 0
#
el = []
n_vertices = 0
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
assert len(es) == 0
bbes = utils.bond_bending_edge_sets(edge_sets=es)
assert len(bbes) == 0
bbel = utils.extract_edge_list(edge_sets=bbes)
assert len(bbel) == 0
piel = utils.potential_implied_edge_list(edge_sets=es,
bond_bending_edge_sets=bbes)
assert len(piel) == 0
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
assert len(bbesob) == 0
#
el = [(0, 1), (1, 2), (2, 3)]
n_vertices = 4
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
assert len(es) == n_vertices
bbes = utils.bond_bending_edge_sets(edge_sets=es)
assert len(bbes) == n_vertices
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(edge_sets=es,
bond_bending_edge_sets=bbes)
assert piel == [(0, 3)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
assert len(bbesob) == n_vertices
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [(0, 2), (1, 3)]
#
el = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7)]
n_vertices = 8
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [(0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (2, 4), (3, 4),
(3, 5), (4, 5), (4, 6), (5, 6), (5, 7), (6, 7)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(edge_sets=es,
bond_bending_edge_sets=bbes)
assert piel == [(0, 3), (1, 4), (2, 5), (3, 6), (4, 7)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [(0, 2), (1, 3), (2, 4), (3, 5), (4, 6), (5, 7)]
#
el = [(0, 1), (1, 2), (2, 3), (0, 3)]
n_vertices = 4
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(edge_sets=es,
bond_bending_edge_sets=bbes)
assert piel == []
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [(0, 2), (1, 3)]
#
el = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (0, 5)]
n_vertices = 6
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [(0, 1), (0, 2), (0, 4), (0, 5), (1, 2), (1, 3), (1, 5),
(2, 3), (2, 4), (3, 4), (3, 5), (4, 5)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(edge_sets=es,
bond_bending_edge_sets=bbes)
assert piel == [(0, 3), (1, 4), (2, 5)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [(0, 2), (0, 4), (1, 3), (1, 5), (2, 4), (3, 5)]
#
el = [(0, 1), (1, 2), (2, 3), (2, 6), (3, 4), (3, 7), (4, 5), (0, 5)]
n_vertices = 8
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [(0, 1), (0, 2), (0, 4), (0, 5), (1, 2), (1, 3), (1, 5),
(1, 6), (2, 3), (2, 4), (2, 6), (2, 7), (3, 4), (3, 5),
(3, 6), (3, 7), (4, 5), (4, 7)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(edge_sets=es,
bond_bending_edge_sets=bbes)
assert piel == [(0, 3), (0, 6), (1, 4), (1, 7), (2, 5), (4, 6), (5, 7),
(6, 7)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [(0, 2), (0, 4), (1, 3), (1, 5), (1, 6), (2, 4), (2, 7),
(3, 5), (3, 6), (4, 7)]
#
el = [(0, 1), (1, 2), (2, 3), (2, 6), (3, 4), (3, 7), (4, 5), (0, 5)]
n_vertices = 8
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[])
assert len(sub.edge_list) == 0
assert len(sub.edge_sets()) == 0
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[1])
assert len(sub.edge_list) == 0
assert len(sub.edge_sets()) == 1
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[1, 3])
assert len(sub.edge_list) == 0
assert len(sub.edge_sets()) == 2
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[1, 0])
assert sub.edge_list == [(0, 1)]
assert len(sub.edge_sets()) == 2
assert sub.reindexing_dict == {0: 1, 1: 0}
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[6, 7, 3, 2])
assert sub.edge_list == [(1, 2), (2, 3), (0, 3)]
assert len(sub.edge_sets()) == 4
assert sub.reindexing_dict == {2: 3, 3: 2, 6: 0, 7: 1}
#
exercise_tree_marking()
#
print("OK")
def exercise_cluster_manager():
cm = cluster_manager(n_vertices=0)
assert cm.cluster_indices == []
assert cm.clusters == []
cm = cluster_manager(n_vertices=5)
for p in xrange(2):
assert cm.cluster_indices == [0,1,2,3,4]
assert cm.clusters == [[0],[1],[2],[3],[4]]
cm.connect_vertices(i=0, j=0, optimize=True)
for p in xrange(2):
cm.connect_vertices(i=1, j=3, optimize=True)
assert cm.cluster_indices == [0,1,2,1,4]
assert cm.clusters == [[0],[1,3],[2],[],[4]]
for p in xrange(2):
cm.connect_vertices(i=0, j=3, optimize=True)
assert cm.cluster_indices == [1,1,2,1,4]
for q in xrange(2):
assert cm.clusters == [[],[1,3,0],[2],[],[4]]
cm.refresh_indices()
cm.connect_vertices(i=2, j=4, optimize=True)
assert cm.clusters == [[],[1,3,0],[2,4],[],[]]
assert cm.cluster_indices == [1,1,2,1,2]
cm.connect_vertices(i=2, j=3, optimize=True)
assert cm.clusters == [[],[1,3,0,2,4],[],[],[]]
assert cm.cluster_indices == [1,1,1,1,1]
cm.tidy()
assert cm.clusters == [[0,1,2,3,4]]
assert cm.cluster_indices == [0,0,0,0,0]
#
cm = cluster_manager(n_vertices=6)
cm.connect_vertices(i=3, j=0, optimize=True)
cm.connect_vertices(i=2, j=4, optimize=True)
cm.connect_vertices(i=1, j=2, optimize=True)
cm.tidy()
assert cm.clusters == [[1,2,4],[0,3],[5]]
assert cm.cluster_indices == [1,0,0,1,0,2]
edges = [(0,1), (0,2), (3,4), (4,5)]
cm.connect_vertices(i=4, j=5, optimize=True)
cm.tidy()
assert cm.clusters == [[1,2,4,5],[0,3]]
assert cm.cluster_indices == [1,0,0,1,0,0]
es = construct_edge_sets(n_vertices=6, edge_list=edges)
cm.construct_spanning_trees(edge_sets=es)
assert cm.clusters == [[0,1,2,4,5],[3]]
assert cm.cluster_indices == [0,0,0,1,0,0]
assert cm.hinge_edges == [(-1,1), (1,0)]
assert cm.loop_edges == [(2,0), (4,3)]
assert cm.roots() == [0]
assert cm.tree_ids() == [0,0]
cm.find_loop_edge_bendings(edge_sets=es)
assert cm.loop_edge_bendings == [(1,2), (3,5)]
#
cm.cluster_indices = [1,0,0,1,0,0]
cm.clusters = [[1,2,4,5],[0,3]]
cm.hinge_edges = None
cm.loop_edges = None
cm.loop_edge_bendings = None
cm.merge_clusters_with_multiple_connections(edge_sets=es)
assert cm.clusters == [[0,1,2,3,4,5]]
assert cm.cluster_indices == [0,0,0,0,0,0]
#
sio = StringIO()
assert cm.show_summary(out=sio, prefix=">") is cm
assert not show_diff(sio.getvalue(), """\
>number of fixed vertex lists: 0
>number of fixed vertices: 0
>number of clusters: 1
>merge clusters with multiple connections: 2 passes
>number of hinge edges: None
>number of loop edges: None
>number of loop edge bendings: None
>number of fixed hinges: None
""")
#
cm = cluster_manager(n_vertices=3, all_in_one_rigid_body=True)
assert cm.clusters == [[0,1,2]]
assert cm.cluster_indices == [0,0,0]
cm.tidy()
cm.construct_spanning_trees(edge_sets=None)
assert cm.clusters == [[0,1,2]]
assert cm.cluster_indices == [0,0,0]
assert cm.hinge_edges == [(-1,0)]
assert cm.loop_edges == []
assert cm.roots() == [0]
assert cm.tree_ids() == [0]
cm.find_loop_edge_bendings(edge_sets=None)
assert cm.loop_edge_bendings == []
def exercise_minimal():
edge_sets = utils.construct_edge_sets(n_vertices=1, edge_list=[])
assert find_paths(edge_sets=edge_sets).search_from(iv=0) == ({}, {})
edge_sets = utils.construct_edge_sets(n_vertices=2, edge_list=[(0, 1)])
for iv in [0, 1]:
assert find_paths(edge_sets=edge_sets).search_from(iv=iv) == ({}, {})
def exercise_minimal():
edge_sets = utils.construct_edge_sets(n_vertices=1, edge_list=[])
assert find_paths(edge_sets=edge_sets).search_from(iv=0) == ({}, {})
edge_sets = utils.construct_edge_sets(n_vertices=2, edge_list=[(0,1)])
for iv in [0,1]:
assert find_paths(edge_sets=edge_sets).search_from(iv=iv) == ({}, {})
def run(args):
assert len(args) == 0
#
el = []
n_vertices = 0
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
assert len(es) == 0
bbes = utils.bond_bending_edge_sets(edge_sets=es)
assert len(bbes) == 0
bbel = utils.extract_edge_list(edge_sets=bbes)
assert len(bbel) == 0
piel = utils.potential_implied_edge_list(
edge_sets=es, bond_bending_edge_sets=bbes)
assert len(piel) == 0
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
assert len(bbesob) == 0
#
el = [(0,1), (1,2), (2,3)]
n_vertices = 4
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
assert len(es) == n_vertices
bbes = utils.bond_bending_edge_sets(edge_sets=es)
assert len(bbes) == n_vertices
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [(0,1), (0,2), (1,2), (1,3), (2,3)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(
edge_sets=es, bond_bending_edge_sets=bbes)
assert piel == [(0,3)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
assert len(bbesob) == n_vertices
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [(0,2), (1,3)]
#
el = [(0,1), (1,2), (2,3), (3,4), (4,5), (5,6), (6,7)]
n_vertices = 8
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [
(0, 1), (0, 2),
(1, 2), (1, 3),
(2, 3), (2, 4),
(3, 4), (3, 5),
(4, 5), (4, 6),
(5, 6), (5, 7),
(6, 7)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(
edge_sets=es, bond_bending_edge_sets=bbes)
assert piel == [(0,3), (1,4), (2,5), (3,6), (4,7)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [
(0, 2),
(1, 3),
(2, 4),
(3, 5),
(4, 6),
(5, 7)]
#
el = [(0,1), (1,2), (2,3), (0,3)]
n_vertices = 4
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [(0,1), (0,2), (0,3), (1,2), (1,3), (2,3)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(
edge_sets=es, bond_bending_edge_sets=bbes)
assert piel == []
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [(0, 2), (1, 3)]
#
el = [(0,1), (1,2), (2,3), (3,4), (4,5), (0,5)]
n_vertices = 6
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [
(0,1), (0,2), (0,4), (0,5),
(1,2), (1,3), (1,5),
(2,3), (2,4),
(3,4), (3,5),
(4,5)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(
edge_sets=es, bond_bending_edge_sets=bbes)
assert piel == [(0,3), (1,4), (2,5)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [
(0,2), (0,4),
(1,3), (1,5),
(2,4),
(3,5)]
#
el = [(0,1), (1,2), (2,3), (2,6), (3,4), (3,7), (4,5), (0,5)]
n_vertices = 8
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
bbes = utils.bond_bending_edge_sets(edge_sets=es)
bbel = utils.extract_edge_list(edge_sets=bbes)
assert bbel == [
(0,1), (0,2), (0,4), (0,5),
(1,2), (1,3), (1,5), (1,6),
(2,3), (2,4), (2,6), (2,7),
(3,4), (3,5), (3,6), (3,7),
(4,5), (4,7)]
assert set(el).issubset(set(bbel))
piel = utils.potential_implied_edge_list(
edge_sets=es, bond_bending_edge_sets=bbes)
assert piel == [(0,3), (0,6), (1,4), (1,7), (2,5), (4,6), (5,7), (6,7)]
assert set(bbel).isdisjoint(set(piel))
bbesob = utils.bond_bending_edge_sets(edge_sets=es, omit_bonds=True)
bbelob = utils.extract_edge_list(edge_sets=bbesob)
assert bbelob == [
(0,2), (0,4),
(1,3), (1,5), (1,6),
(2,4), (2,7),
(3,5), (3,6),
(4,7)]
#
el = [(0,1), (1,2), (2,3), (2,6), (3,4), (3,7), (4,5), (0,5)]
n_vertices = 8
es = utils.construct_edge_sets(n_vertices=n_vertices, edge_list=el)
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[])
assert len(sub.edge_list) == 0
assert len(sub.edge_sets()) == 0
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[1])
assert len(sub.edge_list) == 0
assert len(sub.edge_sets()) == 1
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[1,3])
assert len(sub.edge_list) == 0
assert len(sub.edge_sets()) == 2
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[1,0])
assert sub.edge_list == [(0,1)]
assert len(sub.edge_sets()) == 2
assert sub.reindexing_dict == {0: 1, 1: 0}
sub = utils.sub_edge_list(edge_sets=es, vertex_indices=[6,7,3,2])
assert sub.edge_list == [(1,2), (2,3), (0,3)]
assert len(sub.edge_sets()) == 4
assert sub.reindexing_dict == {2: 3, 3: 2, 6: 0, 7: 1}
#
exercise_tree_marking()
#
print "OK"
def exercise_fixed_vertices(n_trials=10):
cm = cluster_manager(n_vertices=2, fixed_vertex_lists=[[0]])
assert cm.clusters == [[0], [1]]
cm = cluster_manager(n_vertices=2, fixed_vertex_lists=[[1]])
assert cm.clusters == [[1], [0]]
edge_list = [(0, 1), (1, 2), (2, 3), (1, 3)]
edge_sets = construct_edge_sets(n_vertices=4, edge_list=edge_list)
for fixed_vertex in [0, 1]:
for optimize in [False, True]:
for connects in [[(1, 2), (2, 3)], [(2, 3), (1, 2)],
[(2, 1), (3, 2)]]:
cm = cluster_manager(n_vertices=4,
fixed_vertex_lists=[[fixed_vertex]])
for i, j in connects:
cm.connect_vertices(i=i, j=j, optimize=optimize)
if (fixed_vertex == 0):
if (connects[0] == (2, 1)):
if (not optimize):
assert cm.clusters == [[0], [], [], [3, 2, 1]]
else:
assert cm.clusters == [[0], [], [2, 1, 3], []]
else:
if (not optimize or connects[0][0] == 1):
assert cm.clusters == [[0], [1, 2, 3], [], []]
else:
assert cm.clusters == [[0], [], [2, 3, 1], []]
cm.tidy()
assert cm.clusters == [[0], [1, 2, 3]]
else:
assert cm.clusters == [[1, 2, 3], [0], [], []]
cm.tidy()
assert cm.clusters == [[1, 2, 3], [0]]
cm.construct_spanning_trees(edge_sets=edge_sets)
assert cm.clusters == [[0, 1, 2, 3]]
assert cm.hinge_edges == [(-1, 1)]
assert cm.loop_edges == []
#
from scitbx.graph import test_cases_tardy_pdb
tc = test_cases_tardy_pdb.test_cases[5]
assert tc.tag == "tyr_with_h"
tt = tc.tardy_tree_construct(fixed_vertex_lists=[[0, 16, 17]])
assert tt.cluster_manager.clusters == [[
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17, 18, 19
], [11], [20]]
try:
tc.tardy_tree_construct(fixed_vertex_lists=[[0], [1]])
except RuntimeError as e:
assert str(e) == \
"connect_clusters(): fixed vertex lists in same connected tree."
else:
raise Exception_expected
try:
tc.tardy_tree_construct(fixed_vertex_lists=[[0], [10]])
except RuntimeError as e:
assert str(e) == \
"determine_weighted_order_for_construct_spanning_tree():" \
" fixed vertex lists in same connected tree."
else:
raise Exception_expected
try:
tc.tardy_tree_construct(fixed_vertex_lists=[[0], [11]])
except RuntimeError as e:
assert str(e) == \
"construct_spanning_trees():" \
" fixed vertex lists in same connected tree."
else:
raise Exception_expected
#
for tc in test_cases:
if (max(tc.tree_ids1) == 0): continue
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
tt.build_tree()
cm = tt.cluster_manager
cl = cm.clusters
ti = cm.tree_ids()
assert ti[0] != ti[-1]
for lfvl0 in range(1, len(cl[0]) + 1):
for lfvl1 in range(1, len(cl[-1]) + 1):
for i_trial in range(n_trials):
fvl0 = random_permutation(cl[0])[:lfvl0]
fvl1 = random_permutation(cl[-1])[:lfvl1]
ttf = construct(n_vertices=tc.n_vertices,
edge_list=tc.edge_list,
fixed_vertex_lists=[fvl0,
fvl1]).build_tree()
cmf = ttf.cluster_manager
cif = cmf.cluster_indices
fvgci = cmf.fixed_vertices_given_cluster_index_dict()
assert len(fvgci) == len(cmf.fixed_vertex_lists)
for fixed_vertices in cmf.fixed_vertex_lists:
assert len(set([cif[i] for i in fixed_vertices])) == 1
assert fvgci[cif[fixed_vertices[0]]] is fixed_vertices
#
for fixed_vertex in [0, 1]:
tt = construct(n_vertices=2,
edge_list=[(0, 1)],
fixed_vertex_lists=[[fixed_vertex]]).build_tree()
assert tt.cluster_manager.clusters == [[0, 1]]
#
for fixed_vertex in [0, 1, 2]:
tt = construct(n_vertices=3,
edge_list=[(0, 1), (1, 2)],
fixed_vertex_lists=[[fixed_vertex]]).build_tree()
assert tt.cluster_manager.clusters == [[0, 1, 2]]
#
el = [(8, 9), (7, 9), (3, 7), (8, 11), (8, 12), (12, 14), (13, 15),
(7, 13), (1, 6), (4, 6), (0, 5)]
tt = construct(n_vertices=16, edge_list=el, fixed_vertices=())
assert tt.cluster_manager.fixed_vertex_lists == ()
tt = construct(n_vertices=16,
edge_list=el,
fixed_vertices=(12, 6, 4, 7, 9, 5))
assert tt.cluster_manager.fixed_vertex_lists == [[12, 7, 9], [6, 4], [5]]
