def exercise_external_clusters(n_trials=10):
# copy of phenix_regression/tardy_action/gly_gly_box.pdb:
"""
CRYST1 12.661 12.601 14.403 90.00 90.00 90.00 P 1
ATOM 0 C GLY A 138 5.965 6.290 5.906 1.00 35.93 C
ATOM 1 O GLY A 138 5.429 5.188 5.784 1.00 40.71 O
ATOM 2 N GLY A 138 7.860 7.800 5.206 1.00 34.54 N
ATOM 3 CA GLY A 138 6.857 6.828 4.801 1.00 33.64 C
ATOM 4 N GLY A 139 5.798 7.062 6.977 1.00 33.49 N
ATOM 5 CA GLY A 139 4.960 6.636 8.087 1.00 33.25 C
ATOM 6 C GLY A 139 5.536 5.495 8.904 1.00 32.97 C
ATOM 7 O GLY A 139 4.801 4.801 9.602 1.00 35.18 O
ATOM 8 OXT GLY A 139 6.772 5.318 8.862 1.00 34.96 O
END
"""
edge_list = [(0,1), (0,3), (0,4), (2,3), (4,5), (5,6), (6,7), (6,8)]
expected = [
(None,
[[0], [1], [2], [3], [4], [5], [6], [7], [8]],
0),
([[3,0,4,5], [0,1,3,4], [5,6,7,8]], # actual
[[0,4], [1], [2], [3], [5], [6], [7], [8]],
1),
([[3,0,4,5], [0,1,2,3], [5,6,7,8]], # artificial
[[0,3,4], [1], [2], [5], [6], [7], [8]],
2),
([[3,0,4,5], [0,1,2,3], [0,4,5,6]], # artificial
[[0,3,4,5], [1], [2], [6], [7], [8]],
3),
([[3,0,4,5], [0,1,2,3], [0,4,5,6], [4,5,6,8]], # artificial
[[0,3,4,5,6], [1], [2], [7], [8]],
4),
([[3,0,4,5], [0,1,2,3], [4,5,6,8]], # artificial
[[0,3,4], [5,6], [1], [2], [7], [8]],
3),
([[0,1,2,3], [4,5,6,8]], # artificial
[[0,3], [5,6], [1], [2], [4], [7], [8]],
2)]
for external_clusters,expected_clusters,expected_count in expected:
tt = construct(
n_vertices=9, edge_list=edge_list, external_clusters=external_clusters)
assert tt.cluster_manager.clusters == expected_clusters
assert tt.external_clusters_connect_count == expected_count
for external_clusters,expected_clusters,expected_count in expected:
if (external_clusters is None): external_clusters = []
for i_trial in xrange(n_trials):
tt = construct(
n_vertices=9,
edge_list=random_permutation(edge_list),
external_clusters=[random_permutation(c) for c in external_clusters])
assert tt.cluster_manager.clusters == expected_clusters
assert tt.external_clusters_connect_count == expected_count
def exercise_fixed_hinges():
# disulfide bond: CA - CB - SG - SG - CB - CA
edge_list = [(0, 1), (1, 2), (2, 5), (3, 4), (4, 5)]
sites = matrix.col_list([(2.031, 74.980, 4.910), (0.672, 75.625, 4.635),
(-0.061, 75.171, 3.047), (-2.009, 74.382, 0.323),
(-0.709, 75.082, 0.718), (-0.355, 75.059, 2.491)])
tt = construct(sites=sites,
edge_list=edge_list,
near_singular_hinges_angular_tolerance_deg=0)
assert tt.cluster_manager.cluster_indices == [0, 0, 0, 3, 2, 1]
tt = construct(sites=sites,
edge_list=edge_list,
near_singular_hinges_angular_tolerance_deg=5)
assert tt.cluster_manager.cluster_indices == [0, 0, 0, 2, 1, 0]
def exercise_test_cases(out):
for i_tc, tc in enumerate(test_cases):
print("test_case index:", i_tc, file=out)
print(tc.art, file=out)
tc_c1, tc_he1, tc_r1, tc_tid1, tc_le1, tc_leb1, \
tc_c2, tc_he2, tc_le2, tc_leb2 = \
tc.clusters1, tc.hinge_edges1, \
tc.roots1, tc.tree_ids1, tc.loop_edges1, tc.loop_edge_bendings1, \
tc.clusters1, tc.hinge_edges1, tc.loop_edges1, tc.loop_edge_bendings1
def assert_same(label, have, expected):
print(label, have, file=out)
if (expected is not None):
if (have != expected):
print("expected:", expected, file=out)
assert have == expected, "Note: --verbose for details"
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
assert_same("c1:", cm.clusters, tc_c1)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print("c1t:", cm.clusters, file=out)
assert_same("he1:", cm.hinge_edges, tc_he1)
assert_same("le1:", cm.loop_edges, tc_le1)
r = cm.roots()
assert_same("r1:", r, tc_r1)
tid = cm.tree_ids()
assert_same("tid1:", tid, tc_tid1)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb1:", cm.loop_edge_bendings, tc_leb1)
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
cm.merge_clusters_with_multiple_connections(edge_sets=tt.edge_sets)
assert_same("c2:", cm.clusters, tc_c2)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print("c2t:", cm.clusters, file=out)
assert_same("he2:", cm.hinge_edges, tc_he2)
assert_same("le2:", cm.loop_edges, tc_le2)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb2:", cm.loop_edge_bendings, tc_leb2)
#
fp = find_paths(edge_sets=tt.edge_sets)
for iv in range(len(tt.edge_sets)):
fp.search_from(iv=iv)
#
print(file=out)
def exercise_three_archs(arch_size_max=8):
for arch_size_1 in xrange(1, arch_size_max + 1):
edge_list_1 = archs_grow_edge_list([], 2, arch_size_1)
for arch_size_2 in xrange(1, arch_size_max + 1):
edge_list_12 = archs_grow_edge_list(edge_list_1, 2 + arch_size_1,
arch_size_2)
for arch_size_3 in xrange(1, arch_size_max + 1):
n_vertices = 2 + arch_size_1 + arch_size_2 + arch_size_3
edge_list_123 = archs_grow_edge_list(
edge_list_12, 2 + arch_size_1 + arch_size_2, arch_size_3)
es, dof = arch_dof(n_vertices=n_vertices,
edge_list=edge_list_123)
expected = max(6,
max(arch_size_1, arch_size_2, arch_size_3) + 1,
arch_size_1 + arch_size_2 + arch_size_3 - 3)
assert expected == dof
is_rigid = (dof == 6)
inferred_is_rigid = (
arch_size_1 < 6 and arch_size_2 < 6 and arch_size_3 < 6
and arch_size_1 + arch_size_2 + arch_size_3 < 10)
assert inferred_is_rigid == is_rigid
#
tt = construct(n_vertices=n_vertices,
edge_list=edge_list_123).build_tree()
inferred_is_rigid = (len(tt.cluster_manager.clusters) == 1)
def exercise_three_archs(arch_size_max=8):
for arch_size_1 in xrange(1, arch_size_max+1):
edge_list_1 = archs_grow_edge_list(
[], 2, arch_size_1)
for arch_size_2 in xrange(1, arch_size_max+1):
edge_list_12 = archs_grow_edge_list(
edge_list_1, 2+arch_size_1, arch_size_2)
for arch_size_3 in xrange(1, arch_size_max+1):
n_vertices = 2 + arch_size_1 + arch_size_2 + arch_size_3
edge_list_123 = archs_grow_edge_list(
edge_list_12, 2+arch_size_1+arch_size_2, arch_size_3)
es, dof = arch_dof(n_vertices=n_vertices, edge_list=edge_list_123)
expected = max(
6,
max(arch_size_1, arch_size_2, arch_size_3) + 1,
arch_size_1 + arch_size_2 + arch_size_3 - 3)
assert expected == dof
is_rigid = (dof == 6)
inferred_is_rigid = (
arch_size_1 < 6
and arch_size_2 < 6
and arch_size_3 < 6
and arch_size_1 + arch_size_2 + arch_size_3 < 10)
assert inferred_is_rigid == is_rigid
#
tt = construct(
n_vertices=n_vertices, edge_list=edge_list_123).build_tree()
inferred_is_rigid = (len(tt.cluster_manager.clusters) == 1)
def tardy_tree_construct(O, fixed_vertex_lists=[]):
from scitbx.graph import tardy_tree
tt = tardy_tree.construct(
sites=O.sites,
edge_list=O.bonds,
fixed_vertex_lists=fixed_vertex_lists)
if (len(fixed_vertex_lists) != 0):
return tt
cm = tt.cluster_manager
if (O.clusters is None):
print "tag:", O.tag
if (O.clusters is None):
print "clusters:", cm.clusters
else:
assert cm.clusters == O.clusters
if (O.hinge_edges is None):
print "hinge_edges:", cm.hinge_edges
else:
assert cm.hinge_edges == O.hinge_edges
if (O.loop_edges is None):
print "loop_edges:", cm.loop_edges
else:
assert cm.loop_edges == O.loop_edges
if (O.loop_edge_bendings is None):
print "loop_edge_bendings:", cm.loop_edge_bendings
else:
assert cm.loop_edge_bendings == O.loop_edge_bendings
assert tt.find_cluster_loop_repeats == O.find_cluster_loop_repeats
assert cm.merge_clusters_with_multiple_connections_passes \
== O.merge_clusters_with_multiple_connections_passes
if (O.clusters is None):
print
return tt
def tardy_tree_construct(O, fixed_vertex_lists=[]):
from scitbx.graph import tardy_tree
tt = tardy_tree.construct(sites=O.sites,
edge_list=O.bonds,
fixed_vertex_lists=fixed_vertex_lists)
if (len(fixed_vertex_lists) != 0):
return tt
cm = tt.cluster_manager
if (O.clusters is None):
print("tag:", O.tag)
if (O.clusters is None):
print("clusters:", cm.clusters)
else:
assert cm.clusters == O.clusters
if (O.hinge_edges is None):
print("hinge_edges:", cm.hinge_edges)
else:
assert cm.hinge_edges == O.hinge_edges
if (O.loop_edges is None):
print("loop_edges:", cm.loop_edges)
else:
assert cm.loop_edges == O.loop_edges
if (O.loop_edge_bendings is None):
print("loop_edge_bendings:", cm.loop_edge_bendings)
else:
assert cm.loop_edge_bendings == O.loop_edge_bendings
assert tt.find_cluster_loop_repeats == O.find_cluster_loop_repeats
assert cm.merge_clusters_with_multiple_connections_passes \
== O.merge_clusters_with_multiple_connections_passes
if (O.clusters is None):
print()
return tt
def exercise_test_cases(out):
for i_tc,tc in enumerate(test_cases):
print >> out, "test_case index:", i_tc
print >> out, tc.art
tc_c1, tc_he1, tc_r1, tc_tid1, tc_le1, tc_leb1, \
tc_c2, tc_he2, tc_le2, tc_leb2 = \
tc.clusters1, tc.hinge_edges1, \
tc.roots1, tc.tree_ids1, tc.loop_edges1, tc.loop_edge_bendings1, \
tc.clusters1, tc.hinge_edges1, tc.loop_edges1, tc.loop_edge_bendings1
def assert_same(label, have, expected):
print >> out, label, have
if (expected is not None):
if (have != expected):
print >> out, "expected:", expected
assert have == expected, "Note: --verbose for details"
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
assert_same("c1:", cm.clusters, tc_c1)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print >> out, "c1t:", cm.clusters
assert_same("he1:", cm.hinge_edges, tc_he1)
assert_same("le1:", cm.loop_edges, tc_le1)
r = cm.roots()
assert_same("r1:", r, tc_r1)
tid = cm.tree_ids()
assert_same("tid1:", tid, tc_tid1)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb1:", cm.loop_edge_bendings, tc_leb1)
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
cm.merge_clusters_with_multiple_connections(edge_sets=tt.edge_sets)
assert_same("c2:", cm.clusters, tc_c2)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print >> out, "c2t:", cm.clusters
assert_same("he2:", cm.hinge_edges, tc_he2)
assert_same("le2:", cm.loop_edges, tc_le2)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb2:", cm.loop_edge_bendings, tc_leb2)
#
fp = find_paths(edge_sets=tt.edge_sets)
for iv in xrange(len(tt.edge_sets)):
fp.search_from(iv=iv)
#
print >> out
def exercise_fixed_hinges():
# disulfide bond: CA - CB - SG - SG - CB - CA
edge_list = [(0,1), (1,2), (2,5), (3,4), (4,5)]
sites = matrix.col_list([
( 2.031, 74.980, 4.910),
( 0.672, 75.625, 4.635),
(-0.061, 75.171, 3.047),
(-2.009, 74.382, 0.323),
(-0.709, 75.082, 0.718),
(-0.355, 75.059, 2.491)])
tt = construct(
sites=sites,
edge_list=edge_list,
near_singular_hinges_angular_tolerance_deg=0)
assert tt.cluster_manager.cluster_indices == [0,0,0,3,2,1]
tt = construct(
sites=sites,
edge_list=edge_list,
near_singular_hinges_angular_tolerance_deg=5)
assert tt.cluster_manager.cluster_indices == [0,0,0,2,1,0]
def check(n_vertices, edge_list, clusters, nosiet, somiet):
sites = matrix.col_list([(i,i%2,0) for i in xrange(n_vertices)])
labels = [str(i) for i in xrange(n_vertices)]
masses = [13, 7, 23, 19, 29, 11, 17][:n_vertices]
assert len(masses) == n_vertices
tt = tardy_tree.construct(sites=sites, edge_list=edge_list)
assert len(tt.cluster_manager.fixed_hinges) == 0
assert tt.cluster_manager.clusters == clusters
tm = construct_tardy_model(
labels=labels, sites=sites, masses=masses, tardy_tree=tt)
assert tm.root_indices() == list(reversed([i for i,n in nosiet]))
assert tm.number_of_sites_in_each_tree() == nosiet
assert tm.sum_of_masses_in_each_tree() == somiet
def exercise_rmsd_calculation():
from scitbx.array_family import flex
from libtbx.test_utils import approx_equal
sites_1 = flex.vec3_double([(0, 0, 0), (0, -1, 1), (0, 1, 1)])
sites_2 = sites_1.select(flex.size_t([0, 2, 1]))
tt = construct(sites=sites_1, edge_list=[(0, 1), (0, 2)])
rmsd_calculator = tt.rmsd_calculator()
assert approx_equal(
rmsd_calculator(sites_cart_1=sites_1, sites_cart_2=sites_1), 0)
assert approx_equal(
rmsd_calculator(sites_cart_1=sites_1, sites_cart_2=sites_2), 0)
#
sites_1 = flex.vec3_double([(0, 0, 0), (0, -1, 1), (0, 1, 1), (0, -1, 2),
(0, -2, 1), (0, 2, 1), (0, 1, 2)])
sites_2 = sites_1.select(flex.size_t([0, 1, 2, 4, 3, 6, 5]))
tt = construct(sites=sites_1,
edge_list=[(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6)])
assert list(tt.rmsd_permutation(
sites_cart_1=sites_1, sites_cart_2=sites_1)) == [0, 1, 2, 3, 4, 5, 6]
assert list(tt.rmsd_permutation(
sites_cart_1=sites_1, sites_cart_2=sites_2)) == [0, 1, 2, 4, 3, 6, 5]
assert list(tt.rmsd_permutation(
sites_cart_1=sites_2, sites_cart_2=sites_1)) == [0, 1, 2, 4, 3, 6, 5]
#
sites_1.append((0, 2, 3))
sites_2.append((0, 3, 2))
tt = construct(sites=sites_1,
edge_list=[(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6),
(6, 7)])
assert list(
tt.rmsd_permutation(sites_cart_1=sites_1,
sites_cart_2=sites_1)) == [0, 1, 2, 3, 4, 5, 6, 7]
assert list(
tt.rmsd_permutation(sites_cart_1=sites_1,
sites_cart_2=sites_2)) == [0, 1, 2, 4, 3, 5, 6, 7]
assert list(
tt.rmsd_permutation(sites_cart_1=sites_2,
sites_cart_2=sites_1)) == [0, 1, 2, 4, 3, 5, 6, 7]
def check(n_vertices, edge_list, clusters, nosiet, somiet):
sites = matrix.col_list([(i, i % 2, 0) for i in range(n_vertices)])
labels = [str(i) for i in range(n_vertices)]
masses = [13, 7, 23, 19, 29, 11, 17][:n_vertices]
assert len(masses) == n_vertices
tt = tardy_tree.construct(sites=sites, edge_list=edge_list)
assert len(tt.cluster_manager.fixed_hinges) == 0
assert tt.cluster_manager.clusters == clusters
tm = construct_tardy_model(labels=labels,
sites=sites,
masses=masses,
tardy_tree=tt)
assert tm.root_indices() == list(reversed([i for i, n in nosiet]))
assert tm.number_of_sites_in_each_tree() == nosiet
assert tm.sum_of_masses_in_each_tree() == somiet
def exercise_rmsd_calculation():
from scitbx.array_family import flex
from libtbx.test_utils import approx_equal
sites_1 = flex.vec3_double([(0,0,0),(0,-1,1),(0,1,1)])
sites_2 = sites_1.select(flex.size_t([0,2,1]))
tt = construct(sites=sites_1, edge_list=[(0,1),(0,2)])
rmsd_calculator = tt.rmsd_calculator()
assert approx_equal(rmsd_calculator(
sites_cart_1=sites_1, sites_cart_2=sites_1), 0)
assert approx_equal(rmsd_calculator(
sites_cart_1=sites_1, sites_cart_2=sites_2), 0)
#
sites_1 = flex.vec3_double([
(0,0,0),(0,-1,1),(0,1,1),(0,-1,2),(0,-2,1),(0,2,1),(0,1,2)])
sites_2 = sites_1.select(flex.size_t([0,1,2,4,3,6,5]))
tt = construct(
sites=sites_1,
edge_list=[(0,1),(0,2),(1,3),(1,4),(2,5),(2,6)])
assert list(tt.rmsd_permutation(
sites_cart_1=sites_1, sites_cart_2=sites_1)) == [0,1,2,3,4,5,6]
assert list(tt.rmsd_permutation(
sites_cart_1=sites_1, sites_cart_2=sites_2)) == [0,1,2,4,3,6,5]
assert list(tt.rmsd_permutation(
sites_cart_1=sites_2, sites_cart_2=sites_1)) == [0,1,2,4,3,6,5]
#
sites_1.append((0,2,3))
sites_2.append((0,3,2))
tt = construct(
sites=sites_1,
edge_list=[(0,1),(0,2),(1,3),(1,4),(2,5),(2,6),(6,7)])
assert list(tt.rmsd_permutation(
sites_cart_1=sites_1, sites_cart_2=sites_1)) == [0,1,2,3,4,5,6,7]
assert list(tt.rmsd_permutation(
sites_cart_1=sites_1, sites_cart_2=sites_2)) == [0,1,2,4,3,5,6,7]
assert list(tt.rmsd_permutation(
sites_cart_1=sites_2, sites_cart_2=sites_1)) == [0,1,2,4,3,5,6,7]
def exercise_fused_loops(arch_size_max=8):
for arch_size_1 in xrange(1, arch_size_max + 1):
edge_list_1 = archs_grow_edge_list([(0, 1)], 2, arch_size_1)
for arch_size_2 in xrange(1, arch_size_max + 1):
n_vertices = 2 + arch_size_1 + arch_size_2
edge_list_12 = archs_grow_edge_list(edge_list_1, 2 + arch_size_1,
arch_size_2)
es, dof = arch_dof(n_vertices=n_vertices, edge_list=edge_list_12)
is_rigid = (dof == 6)
inferred_is_rigid = (arch_size_1 < 6 and arch_size_2 < 6
and arch_size_1 + arch_size_2 < 10)
assert inferred_is_rigid == is_rigid
#
tt = construct(n_vertices=n_vertices,
edge_list=edge_list_12).build_tree()
inferred_is_rigid = (len(tt.cluster_manager.clusters) == 1)
assert inferred_is_rigid == is_rigid
def exercise_all_in_one_rigid_body():
tt = construct(
sites=matrix.col_list([(0,0,0), (0,0,1), (0,0,2)]),
edge_list="all_in_one_rigid_body")
sio = StringIO()
tt.show_summary(vertex_labels=None, out=sio)
assert not show_diff(sio.getvalue(), """\
number of vertices: 3
number of edges: None
find cluster loops: 0 repeats
number of fixed vertex lists: 0
number of fixed vertices: 0
number of clusters: 1
merge clusters with multiple connections: 0 passes
number of hinge edges: 1
number of loop edges: 0
number of loop edge bendings: 0
number of fixed hinges: 0
""")
def exercise_fused_loops(arch_size_max=8):
for arch_size_1 in xrange(1, arch_size_max+1):
edge_list_1 = archs_grow_edge_list(
[(0,1)], 2, arch_size_1)
for arch_size_2 in xrange(1, arch_size_max+1):
n_vertices = 2 + arch_size_1 + arch_size_2
edge_list_12 = archs_grow_edge_list(
edge_list_1, 2+arch_size_1, arch_size_2)
es, dof = arch_dof(n_vertices=n_vertices, edge_list=edge_list_12)
is_rigid = (dof == 6)
inferred_is_rigid = (
arch_size_1 < 6
and arch_size_2 < 6
and arch_size_1 + arch_size_2 < 10)
assert inferred_is_rigid == is_rigid
#
tt = construct(
n_vertices=n_vertices, edge_list=edge_list_12).build_tree()
inferred_is_rigid = (len(tt.cluster_manager.clusters) == 1)
assert inferred_is_rigid == is_rigid
def exercise_near_singular_hinges():
# similar to scitbx/graph/test_cases_tardy_pdb.py, "collinear" test case
r"""
0 6
| \ /
| 2---3---4---5
| /
1
"""
x = -0.5 * 3**0.5
y = 0.5
def build_sites(eps):
return matrix.col_list([(x, -y, 0), (x, y, 0), (0, 0, 0), (1, 0, 0),
(2, 0, eps)])
edge_list = [(0, 1), (0, 2), (1, 2), (2, 3), (3, 4)]
sites = build_sites(eps=0)
for i, j in edge_list:
assert approx_equal(abs(sites[i] - sites[j]), 1)
sites = build_sites(eps=1e-5)
labels = [str(i) for i in range(len(sites))]
masses = [1] * len(sites)
tt = tardy_tree.construct(n_vertices=len(sites), edge_list=edge_list)
tt.build_tree()
assert tt.cluster_manager.clusters == [[0, 1, 2, 3], [4]]
def e_kin_1():
tm = construct_tardy_model(labels=labels,
sites=sites,
masses=masses,
tardy_tree=tt)
rnd = random.Random(0)
tm.assign_random_velocities(e_kin_target=1, random_gauss=rnd.gauss)
assert approx_equal(tm.e_kin(), 1, eps=1e-10)
tm.dynamics_step(delta_t=0.01)
return tm.e_kin()
assert approx_equal(e_kin_1(), 60.9875715394)
tt.fix_near_singular_hinges(sites=sites)
assert tt.cluster_manager.fixed_hinges == [(2, 3)]
assert tt.cluster_manager.clusters == [[0, 1, 2, 3, 4]]
assert approx_equal(e_kin_1(), 1.00004830172, eps=1e-10)
#
sites.append(matrix.col((3, 0, 0)))
labels.append("5")
masses.append(1)
edge_list.append((4, 5))
tt = tardy_tree.construct(n_vertices=len(sites), edge_list=edge_list)
tt.build_tree()
assert tt.cluster_manager.clusters == [[0, 1, 2, 3], [4], [5]]
assert approx_equal(e_kin_1(), 9.55508653428)
tt.fix_near_singular_hinges(sites=sites)
assert tt.cluster_manager.fixed_hinges == [(2, 3), (3, 4)]
assert tt.cluster_manager.clusters == [[0, 1, 2, 3, 4, 5]]
assert approx_equal(e_kin_1(), 1.00005333167, eps=1e-10)
#
sites.append(matrix.col((3 - x, -y, 0)))
assert approx_equal(abs(sites[5] - sites[6]), 1)
labels.append("6")
masses.append(1)
edge_list.append((5, 6))
tt = tardy_tree.construct(n_vertices=len(sites), edge_list=edge_list)
tt.build_tree()
assert tt.cluster_manager.clusters == [[0, 1, 2, 3], [4], [5], [6]]
assert approx_equal(e_kin_1(), 0.99994375467)
tt.fix_near_singular_hinges(sites=sites)
assert tt.cluster_manager.fixed_hinges == [(2, 3), (3, 4)]
assert tt.cluster_manager.clusters == [[0, 1, 2, 3, 4, 5], [6]]
assert approx_equal(e_kin_1(), 1.0000438095, eps=1e-10)
def exercise_near_singular_hinges():
# similar to scitbx/graph/test_cases_tardy_pdb.py, "collinear" test case
"""
0 6
| \ /
| 2---3---4---5
| /
1
"""
x = -0.5*3**0.5
y = 0.5
def build_sites(eps):
return matrix.col_list([
(x,-y,0),
(x,y,0),
(0,0,0),
(1,0,0),
(2,0,eps)])
edge_list = [(0,1),(0,2),(1,2),(2,3),(3,4)]
sites = build_sites(eps=0)
for i,j in edge_list:
assert approx_equal(abs(sites[i]-sites[j]), 1)
sites = build_sites(eps=1e-5)
labels = [str(i) for i in xrange(len(sites))]
masses = [1] * len(sites)
tt = tardy_tree.construct(n_vertices=len(sites), edge_list=edge_list)
tt.build_tree()
assert tt.cluster_manager.clusters == [[0,1,2,3], [4]]
def e_kin_1():
tm = construct_tardy_model(
labels=labels,
sites=sites,
masses=masses,
tardy_tree=tt)
rnd = random.Random(0)
tm.assign_random_velocities(e_kin_target=1, random_gauss=rnd.gauss)
assert approx_equal(tm.e_kin(), 1, eps=1e-10)
tm.dynamics_step(delta_t=0.01)
return tm.e_kin()
assert approx_equal(e_kin_1(), 60.9875715394)
tt.fix_near_singular_hinges(sites=sites)
assert tt.cluster_manager.fixed_hinges == [(2,3)]
assert tt.cluster_manager.clusters == [[0,1,2,3,4]]
assert approx_equal(e_kin_1(), 1.00004830172, eps=1e-10)
#
sites.append(matrix.col((3,0,0)))
labels.append("5")
masses.append(1)
edge_list.append((4,5))
tt = tardy_tree.construct(n_vertices=len(sites), edge_list=edge_list)
tt.build_tree()
assert tt.cluster_manager.clusters == [[0,1,2,3], [4], [5]]
assert approx_equal(e_kin_1(), 9.55508653428)
tt.fix_near_singular_hinges(sites=sites)
assert tt.cluster_manager.fixed_hinges == [(2,3), (3,4)]
assert tt.cluster_manager.clusters == [[0,1,2,3,4,5]]
assert approx_equal(e_kin_1(), 1.00005333167, eps=1e-10)
#
sites.append(matrix.col((3-x,-y,0)))
assert approx_equal(abs(sites[5] - sites[6]), 1)
labels.append("6")
masses.append(1)
edge_list.append((5,6))
tt = tardy_tree.construct(n_vertices=len(sites), edge_list=edge_list)
tt.build_tree()
assert tt.cluster_manager.clusters == [[0,1,2,3], [4], [5], [6]]
assert approx_equal(e_kin_1(), 0.99994375467)
tt.fix_near_singular_hinges(sites=sites)
assert tt.cluster_manager.fixed_hinges == [(2,3), (3,4)]
assert tt.cluster_manager.clusters == [[0,1,2,3,4,5], [6]]
assert approx_equal(e_kin_1(), 1.0000438095, eps=1e-10)
def exercise_special_case_ZINC03847121():
# Only case out of 69587 cases with a RIGID_MINUS_TARDY_6 cluster of
# size different from 3:
# RIGID_MINUS_TARDY_6: 3 NILE=0 LE=2 NV=13 ZINC03847121
# [(0, 10, 11), (3, 10, 12), (9, 10, 11, 12)]
# ZINC03847121 c1ccc2ccc(=O)ccc(c1)C2
# simplified (oxygen removed): c1ccc2cccccc(c1)C2
n_vertices = 12
edge_list = [
(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9),
(9, 10), (9, 11), (0, 10), (3, 11)]
tt = construct(n_vertices=n_vertices, edge_list=edge_list)
cm = tt.cluster_manager
assert sorted(cm.overlapping_rigid_clusters(edge_sets=tt.edge_sets)) == [
(0, 1, 2), (0, 1, 10), (0, 9, 10), (1, 2, 3), (2, 3, 4, 11),
(3, 4, 5), (3, 9, 11), (4, 5, 6), (5, 6, 7), (6, 7, 8), (7, 8, 9),
(8, 9, 10, 11)]
cii_orcs, fixed_vertex_info = \
cm.determine_weighted_order_for_construct_spanning_tree(
edge_sets=tt.edge_sets)
assert cii_orcs == [
(3, 4), (9, 4), (0, 3), (1, 3), (2, 3), (4, 3),
(5, 3), (6, 3), (7, 3), (8, 3), (10, 3), (11, 3)]
assert fixed_vertex_info == [0] * len(cii_orcs)
#
tt = construct(n_vertices=n_vertices, edge_list=edge_list)
sio = StringIO()
assert tt.show_summary(vertex_labels=None, out=sio, prefix="$") is tt
assert not show_diff(sio.getvalue(), """\
$number of vertices: 12
$number of edges: 13
$find cluster loops: None
$number of fixed vertex lists: 0
$number of fixed vertices: 0
$number of clusters: 12
$merge clusters with multiple connections: 0 passes
$number of hinge edges: None
$number of loop edges: None
$number of loop edge bendings: None
$number of fixed hinges: None
""")
tt.build_tree()
sio = StringIO()
assert tt.show_summary(vertex_labels=None, out=sio, prefix=">") is tt
assert not show_diff(sio.getvalue(), """\
>number of vertices: 12
>number of edges: 13
>find cluster loops: 0 repeats
>number of fixed vertex lists: 0
>number of fixed vertices: 0
>number of clusters: 9
>merge clusters with multiple connections: 1 pass
>number of hinge edges: 9
>number of loop edges: 2
>number of loop edge bendings: 5
>number of fixed hinges: None
""")
#
sio = StringIO()
assert tt.cluster_manager.show_tree(out=sio) is tt.cluster_manager
assert not show_diff(sio.getvalue(), """\
# clusters are in square brackets []
# hinge edges are in parentheses ()
# (0, 1) -> [2, 3] means that the cluster with vertices [2, 3]
# rotates around the axis through vertices (0, 1)
# integers are vertex indices (counting from 0)
[2, 3, 4, 11]
(3, 2) -> [1]
(2, 1) -> [0]
(1, 0) -> [10]
(3, 4) -> [5]
(4, 5) -> [6]
(5, 6) -> [7]
(6, 7) -> [8]
(7, 8) -> [9]
""")
sio = StringIO()
assert tt.show_tree(out=sio, prefix="=-", header=False) is tt
assert not show_diff(sio.getvalue(), """\
=-[2, 3, 4, 11]
=- (3, 2) -> [1]
=- (2, 1) -> [0]
=- (1, 0) -> [10]
=- (3, 4) -> [5]
=- (4, 5) -> [6]
=- (5, 6) -> [7]
=- (6, 7) -> [8]
=- (7, 8) -> [9]
""")
def exercise_fixed_vertices_special_cases():
tardy_models = []
"""
2
/
0---1
"""
x = 0.5*3**0.5
y = 0.5
sites = matrix.col_list([
(0,0,0),
(1,0,0),
(1+x,y,0)])
edge_list = [(0,1),(1,2)]
for i,j in edge_list:
assert approx_equal(abs(sites[i]-sites[j]), 1)
labels = [str(i) for i in xrange(len(sites))]
masses = [1] * len(sites)
#
tt = tardy_tree.construct(
sites=sites,
edge_list=edge_list,
fixed_vertex_lists=[])
assert tt.cluster_manager.clusters == [[0,1,2]]
tm = construct_tardy_model(
labels=labels, sites=sites, masses=masses, tardy_tree=tt)
tardy_models.append(tm)
assert len(tm.bodies) == 1
assert tm.bodies[0].joint.degrees_of_freedom == 6
exercise_linear_velocity_manipulations(tardy_model=tm)
#
expected_e_kin_1 = [
1.00009768395,
1.00002522865,
1.00000107257,
1.0,
1.0,
1.0,
0.0]
rnd = random.Random(0)
for i_fv,fixed_vertices in enumerate([[0], [1], [2],
[0,1], [0,2], [1,2],
[0,1,2]]):
tt = tardy_tree.construct(
sites=sites,
edge_list=edge_list,
fixed_vertex_lists=[fixed_vertices])
assert tt.cluster_manager.clusters == [[0,1,2]]
tm = construct_tardy_model(
labels=labels, sites=sites, masses=masses, tardy_tree=tt)
tardy_models.append(tm)
assert len(tm.bodies) == 1
assert tm.bodies[0].joint.degrees_of_freedom \
== [3,1,0][len(fixed_vertices)-1]
tm.assign_random_velocities(e_kin_target=1, random_gauss=rnd.gauss)
if (len(fixed_vertices) != 3):
assert approx_equal(tm.e_kin(), 1, eps=1e-10)
else:
assert approx_equal(tm.e_kin(), 0, eps=1e-10)
tm.dynamics_step(delta_t=0.01)
assert approx_equal(tm.e_kin(), expected_e_kin_1[i_fv], eps=1e-10)
exercise_linear_velocity_manipulations(tardy_model=tm)
#
sites[2] = matrix.col([2,0,0])
assert approx_equal((sites[0]-sites[1]).cos_angle(sites[2]-sites[1]), -1)
for fixed_vertices in [[0,1], [0,2], [1,2]]:
tt = tardy_tree.construct(
sites=sites,
edge_list=edge_list,
fixed_vertex_lists=[fixed_vertices])
assert tt.cluster_manager.clusters == [[0,1,2]]
tm = construct_tardy_model(
labels=labels, sites=sites, masses=masses, tardy_tree=tt)
tardy_models.append(tm)
assert len(tm.bodies) == 1
assert tm.bodies[0].joint.degrees_of_freedom == 0
exercise_linear_velocity_manipulations(tardy_model=tm)
return tardy_models
except RuntimeError, 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, 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 xrange(1,len(cl[0])+1):
for lfvl1 in xrange(1,len(cl[-1])+1):
for i_trial in xrange(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
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]]
def exercise_fixed_vertices_special_cases():
tardy_models = []
"""
2
/
0---1
"""
x = 0.5 * 3**0.5
y = 0.5
sites = matrix.col_list([(0, 0, 0), (1, 0, 0), (1 + x, y, 0)])
edge_list = [(0, 1), (1, 2)]
for i, j in edge_list:
assert approx_equal(abs(sites[i] - sites[j]), 1)
labels = [str(i) for i in range(len(sites))]
masses = [1] * len(sites)
#
tt = tardy_tree.construct(sites=sites,
edge_list=edge_list,
fixed_vertex_lists=[])
assert tt.cluster_manager.clusters == [[0, 1, 2]]
tm = construct_tardy_model(labels=labels,
sites=sites,
masses=masses,
tardy_tree=tt)
tardy_models.append(tm)
assert len(tm.bodies) == 1
assert tm.bodies[0].joint.degrees_of_freedom == 6
exercise_linear_velocity_manipulations(tardy_model=tm)
#
expected_e_kin_1 = [
1.00009768395, 1.00002522865, 1.00000107257, 1.0, 1.0, 1.0, 0.0
]
rnd = random.Random(0)
for i_fv, fixed_vertices in enumerate([[0], [1], [2], [0, 1], [0, 2],
[1, 2], [0, 1, 2]]):
tt = tardy_tree.construct(sites=sites,
edge_list=edge_list,
fixed_vertex_lists=[fixed_vertices])
assert tt.cluster_manager.clusters == [[0, 1, 2]]
tm = construct_tardy_model(labels=labels,
sites=sites,
masses=masses,
tardy_tree=tt)
tardy_models.append(tm)
assert len(tm.bodies) == 1
assert tm.bodies[0].joint.degrees_of_freedom \
== [3,1,0][len(fixed_vertices)-1]
tm.assign_random_velocities(e_kin_target=1, random_gauss=rnd.gauss)
if (len(fixed_vertices) != 3):
assert approx_equal(tm.e_kin(), 1, eps=1e-10)
else:
assert approx_equal(tm.e_kin(), 0, eps=1e-10)
tm.dynamics_step(delta_t=0.01)
assert approx_equal(tm.e_kin(), expected_e_kin_1[i_fv], eps=1e-10)
exercise_linear_velocity_manipulations(tardy_model=tm)
#
sites[2] = matrix.col([2, 0, 0])
assert approx_equal((sites[0] - sites[1]).cos_angle(sites[2] - sites[1]),
-1)
for fixed_vertices in [[0, 1], [0, 2], [1, 2]]:
tt = tardy_tree.construct(sites=sites,
edge_list=edge_list,
fixed_vertex_lists=[fixed_vertices])
assert tt.cluster_manager.clusters == [[0, 1, 2]]
tm = construct_tardy_model(labels=labels,
sites=sites,
masses=masses,
tardy_tree=tt)
tardy_models.append(tm)
assert len(tm.bodies) == 1
assert tm.bodies[0].joint.degrees_of_freedom == 0
exercise_linear_velocity_manipulations(tardy_model=tm)
return tardy_models
